semvec/pypi-packages huggingface dataset:
suprconfig 0.9
This library created for comfortable using config


## Example: ##

### ENG:

```python
import suprconfig.config as config # import module

cfg = config.Config("config.json") # Creating an instance of a class

cfg.add(name = "app-name", value = "suprconfig") # Creating the "app-name" variable with the value "suprconfig" in the config.

cfg.add(name = "version", value = "v1.0") # Creating the "version" variable with the value "v1.0" in the config.

app_name = cfg.get('app-name') # Recording the value of the "app-name" variable from the config. (if no argument is specified, the function will return all variables and config values).
version = cfg.get('version') # Recording the value of the "version" variable from the config. (if no argument is specified, the function will return all variables and config values).

print(f"App Name: {app_name}
Version: {version}") # Information output to the terminal
```

### RUS:
```python
import suprconfig.config as config # Импорт модуля.

cfg = config.Config("config.json") # Создание экземпляра класса.

cfg.add(name = "app-name", value = "suprconfig") # Создание переменной "app-name" со значением "suprconfig" в конфиг.

cfg.add(name = "version", value = "v1.0") # Создание переменной "version" со значением "v1.0" в конфиг.

app_name = cfg.get('app-name') # Запись значение переменной "app-name" из конфига. (если аргумент не указан, функция вернет все переменные и значения конфига).
version = cfg.get('version') # Запись значение переменной "version" из конфига. (если аргумент не указан, функция вернет все переменные и значения конфига).

print(f"App Name: {app_name}
Version: {version}") # Вывод информации в терминал.
```
hrfparser 1.1.0
A convenience library for working with Human-Readable Formats ( HRFs ) such as YAML and JSON.
Requires Python: >=3.7

HRFParser
=========

Copyright (c) 2024 Sean Yeatts. All rights reserved.

A convenience pipeline for working with Human-Readable Formats ( HRFs ) such
as YAML and JSON. It's designed to easily read / write data between HRFs and
Python dictionaries, both in raw and flattened ( single key-value pairs )
formats.

Features:
    - Auto-conversion between different HRF formats based on file extensions.
    - 'Unpacking' of nested data to flattened, single key-value pairs.

Current supported HRFs:
    - YAML
    - JSON
    
Methods:
    - read() : read raw HRF from file
    - write() : write raw HRF to destination
    - unpack() : read and flatten HRF data from file
    - pack() : fold HRF data and write to destination
    - flatten() : deconstruct nested data as single key-value pairs
    - fold() : rebuild data as nested key-value pairs
array-api-jax-compat 0.13
Array-API JAX compatibility
Requires Python: >=3.10

# array-api-jax-compat

[![Actions Status][actions-badge]][actions-link]
[![Documentation Status][rtd-badge]][rtd-link]

[![PyPI version][pypi-version]][pypi-link]
[![Conda-Forge][conda-badge]][conda-link]
[![PyPI platforms][pypi-platforms]][pypi-link]

[![GitHub Discussion][github-discussions-badge]][github-discussions-link]

<!-- SPHINX-START -->

<!-- prettier-ignore-start -->
[actions-badge]:            https://github.com/GalacticDynamics/array-api-jax-compat/workflows/CI/badge.svg
[actions-link]:             https://github.com/GalacticDynamics/array-api-jax-compat/actions
[conda-badge]:              https://img.shields.io/conda/vn/conda-forge/array-api-jax-compat
[conda-link]:               https://github.com/conda-forge/array-api-jax-compat-feedstock
[github-discussions-badge]: https://img.shields.io/static/v1?label=Discussions&message=Ask&color=blue&logo=github
[github-discussions-link]:  https://github.com/GalacticDynamics/array-api-jax-compat/discussions
[pypi-link]:                https://pypi.org/project/array-api-jax-compat/
[pypi-platforms]:           https://img.shields.io/pypi/pyversions/array-api-jax-compat
[pypi-version]:             https://img.shields.io/pypi/v/array-api-jax-compat
[rtd-badge]:                https://readthedocs.org/projects/array-api-jax-compat/badge/?version=latest
[rtd-link]:                 https://array-api-jax-compat.readthedocs.io/en/latest/?badge=latest

<!-- prettier-ignore-end -->

This package is going to be renamed to `quaxed`. Please use `quaxed.array_api`
instead of `array-api-jax-compat`.
tradingview-websocket 0.6
This Python package provides a simple WebSocket client for connecting to the TradingView WebSocket API. It allows users to subscribe to real-time financial data streams and retrieve historical data.

# TradingView WebSocket Client

## Introduction
This Python package provides a simple WebSocket client for connecting to the TradingView WebSocket API. It allows users to subscribe to real-time financial data streams and retrieve historical data.

## Installation
You can install the package via pip:

```bash
pip install tradingview_websocket
```

## Usage

```python
from tradingview_websocket import TradingViewWebSocket
```

### Define symbol, timeframe, and number of candles
```python
symbol = "USDEUR"
timeframe = "1D"
candles = 100
```

### Initialize TradingViewWebSocket object
```python
ws = TradingViewWebSocket(symbol, timeframe, candles)
ws.connect()
```

### Run the WebSocket client
```python
ws.run()
```

### Access the result data
```python
result_data = ws.result_data
print(result_data)
```

## License
This project is licensed under the MIT License - see the [LICENSE](LICENSE.md) file for details.

## Issues
If you encounter any issues or have questions regarding the package, please feel free to open an issue on GitHub.
passwd-crypto 0.1
Password manager with Fernet encryption

# passwd-crypto

This Python module provides a simple password manager for securely storing and retrieving encrypted password entries. The passwords are encrypted using the Fernet symmetric encryption scheme. The module includes functionality to derive a Fernet key from a password, initialize a password manager instance, retrieve encrypted passwords, decrypt and read stored passwords, encrypt text, and write new password entries to a file.

## Usage

### Initialization

```python
from passwd-crypto import Passwd, generate_key_from_password

# Example usage
password = b'MyStrongPassword'
key = generate_key_from_password(password)
filename = 'passwords.txt'

# Initialize a Passwd instance
password_manager = Passwd(filename, key)
```

### Reading Passwords

```python
# Retrieve encrypted passwords from the file
encrypted_passwords = password_manager.getEncryptedPasswds()

# Decrypt and read stored passwords
password_entries = password_manager.read()
```

### Writing Passwords

```python
# Write a new password entry to the file
app_name = 'MyApp'
email_address = 'user@example.com'
user_password = 'SecurePassword123'

password_manager.write(app_name, email_address, user_password)
```

## API Reference

### `generate_key_from_password(password: bytes) -> Fernet`

Generates a Fernet key derived from the provided password.

### `class Passwd(filename: str, key: bytes) -> None`

Initialize a Passwd instance.

- `filename (str)`: The name of the file to store encrypted passwords.
- `key (bytes)`: The Fernet key used for encryption and decryption.

### `getEncryptedPasswds() -> list[bytes]`

Retrieve encrypted passwords from the file.

### `read() -> list[list[str]]`

Decrypt and read stored passwords from the file. Returns a list of decrypted password entries, where each entry is a list with the format `[App, Email, Password]`.

### `encrypt(text: str) -> bytes`

Encrypt the given text using the Fernet key.

- `text (str)`: The text to be encrypted.

### `write(app: str, email: str, password: str) -> None`

Encrypt and write a new password entry to the file.

- `app (str)`: The application or service name.
- `email (str)`: The associated email address.
- `password (str)`: The password for the application or service.

## Security Note

Adjust the number of iterations in the key derivation process (`iterations` parameter in `generate_key_from_password`) based on your security requirements. Higher iterations increase security but also result in longer key derivation times.