semvec/pypi-packages huggingface dataset:
whatsapp-web-py 0.1.0
A pure Python library for WhatsApp Web communication with full Signal Protocol encryption support
Requires Python: >=3.7

# WhatsApp Web Python Library

O bibliotecă Python pură pentru comunicarea cu WhatsApp Web, cu suport complet pentru criptarea Signal Protocol.

## Caracteristici

- Autentificare prin cod QR
- Autentificare prin cod de asociere (pairing code)
- Conexiune WebSocket la serverele WhatsApp Web
- Criptare completă Signal Protocol (Double Ratchet, X3DH)
- Suport pentru parsarea/serializarea Protobuf binară
- Trimiterea/primirea de mesaje text
- Arhitectură bazată pe evenimente pentru evenimente în timp real

## Instalare

```bash
pip install whatsapp-web-py
```

## Exemplu rapid

```python
import asyncio
from whatsapp import WAClient, WAEventType

async def on_message_received(message_data):
    print(f"Mesaj nou primit: {message_data}")

async def on_qr_code_received(qr_data):
    print(f"Scanează acest cod QR cu WhatsApp: {qr_data}")

async def main():
    # Creează clientul
    client = WAClient(session_path="./whatsapp_session")
    
    # Configurează handlerii de evenimente
    client.set_qr_callback(on_qr_code_received)
    client.on(WAEventType.MESSAGE, on_message_received)
    
    # Conectează
    await client.connect()
    
    # Așteaptă autentificarea
    while not client.authenticated:
        await asyncio.sleep(1)
    
    # Trimite un mesaj
    await client.send_message("+1234567890", "Salut de la WhatsApp Web Python!")
    
    # Menține rularea
    await asyncio.sleep(3600)

if __name__ == "__main__":
    asyncio.run(main())
```

## Licență

MIT License

## Autor

gyovannyvpn123
adfinmcp 0.1.1
An MCP server that interacts with all Adfin public APIs.
Requires Python: >=3.12

## Requirements:
1. Python 3.10 or higher

## Step 1. Install uv:
   - MacOS/Linux: curl -LsSf https://astral.sh/uv/install.sh | sh
   - Windows: powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

## Step 2. Configure Claude Desktop
1. Download [Claude Desktop](https://claude.ai/download).
2. Launch Claude and go to Settings > Developer > Edit Config.
3. Modify `claude_desktop_config.json` with:
```json
{
  "mcpServers": {
    "Adfin": {
      "command": "<home_path>/.local/bin/uv",
      "args": [
        "--directory",
        "<absolute_path_to_adfin_mcp_folder>",
        "run",
        "main_adfin_mcp.py"
      ],
      "env": {
        "ADFIN_EMAIL": "<email>",
        "ADFIN_PASSWORD": "<password>"
      }
    },
    "filesystem": {
      "command": "<home_path>/.local/bin/uv",
      "args": [
        "--directory",
        "<absolute_path_to_adfin_mcp_folder>",
        "run",
        "filesystem.py"
      ]
    }
  }
}
```
4. Relaunch Claude Desktop.

The first time you open Claude Desktop with these setting it may take
10-20 seconds before the Adfin tools appear in the interface due to
the installation of the required packages and the download of the most 
recent Adfin API documentation.

Everytime you launch Claude Desktop, the most recent Adfin API tools are made available 
to your AI assistant.

## Step 3. Launch Claude Desktop and let your assistant help you
### Examples
**Request a credit control status**
```text
Give me a credit control status check.
```
**Create a new invoice**
```text
Create a new invoice for 60 GBP for Abc Def that is due in a week. His email is abc.def@example.com.
```
**Ask the assistant to upload multiple invoices from your folder**
```text
Upload all pdf invoices from the invoices folder from my Desktop.
```
amfiprot-amfitrack 0.0.1a15
AmfiTrack extension for Amfiprot
Requires Python: >=3.6

AmfiTrack extensions for the [Amfiprot](https://pypi.org/project/amfiprot/) package.

# Installation
Install (or update) with `pip`:

```shell
pip install -U amfiprot-amfitrack
```

# Usage example
Instead of creating a generic `amfiprot.Device`, create an `amfitrack.Device` to get access to AmfiTrack specific functionality and payload interpretation:

```python
import amfiprot
import amfiprot_amfitrack as amfitrack

VENDOR_ID = 0xC17
PRODUCT_ID_SENSOR = 0xD12
PRODUCT_ID_SOURCE = 0xD01

if __name__ == "__main__":
    conn = None
    try:
        conn = amfiprot.USBConnection(VENDOR_ID, PRODUCT_ID_SENSOR)
    except:
        try:
            conn = amfiprot.USBConnection(VENDOR_ID, PRODUCT_ID_SOURCE)
        except:
            print("No Amfitrack device found")
            exit()
            
    nodes = conn.find_nodes()
    Devs = []

    print(f"Found {len(nodes)} node(s).")
    for node in nodes:
        print(f"[{node.tx_id}] {node.name}")
        Devs.append(amfitrack.Device(node))

    conn.start()

    while True:
        for idx, Dev in enumerate(Devs):
            if Dev.packet_available():
                packet = Dev.get_packet()
                if type(packet.payload) == amfitrack.payload.EmfImuFrameIdPayload:
                    # Sensor measurement package 
                    payload: amfitrack.payload.EmfImuFrameIdPayload = packet.payload
                    print(payload.emf) # emf contains position and orientation
                elif type(packet.payload) == amfitrack.payload.SourceMeasurementPayload:
                    # Source measurement package
                    payload: amfitrack.payload.SourceMeasurementPayload = packet.payload
                    print("Source current:" + str(payload.current))
                elif type(packet.payload) == amfitrack.payload.SourceCalibrationPayload:
                    # Source calibration package (sent at 5Hz)
                    payload: amfitrack.payload.SourceCalibrationPayload = packet.payload
                    print("Source frequency:" + str(payload.frequency))
                else:
                    print(packet)
```
python-introspection 0.1.0.post1
Python library and CLI tool to introspect Python installations

# python-introspection [![PyPI version](https://badge.fury.io/py/python-introspection.svg)](https://pypi.org/project/python-introspection/)

[![pre-commit.ci status](https://results.pre-commit.ci/badge/github/FFY00/python-introspection/main.svg)](https://results.pre-commit.ci/latest/github/FFY00/python-introspection/main)
[![Discord](https://img.shields.io/discord/803025117553754132?label=PyPA%20Discord)](https://discord.gg/pypa)

<!-- [![CI test](https://github.com/FFY00/python-introspection/actions/workflows/test.yml/badge.svg)](https://github.com/FFY00/python-introspection/actions/workflows/test.yml) -->
<!-- [![codecov](https://codecov.io/gh/FFY00/python-introspection/branch/main/graph/badge.svg)](https://codecov.io/gh/FFY00/python-introspection) -->
<!-- [![Documentation Status](https://readthedocs.org/projects/python-introspection/badge/?version=latest)](https://python-introspection.readthedocs.io/en/latest/?badge=latest) -->

Python library and CLI tool to introspect Python installations.

## Installation

```sh
$ pip install python-instrospection

```

## Usage (CLI)

```sh
$ python -m python_introspection (options) <command> ...
```

Option                 | Description
---------------------- | -------------------------------------------------------
`--interpreter <path>` | Selects the Python interpreter to instrospect.
`--write-to <path>`    | Write introspection data to the specified file.


### `generate-build-details`

Generated a`build-details.json` file (from [PEP 739](https://peps.python.org/pep-0739/)).

```sh
$ python -m python_introspection generate-build-details (options)
```

Option                 | Description
-------------------------- | ---------------------------------------------------
`--schema-version <value>` | Schema version of the build-details.json file to generate.
`--relative-paths`         | Whether to specify paths as absolute, or as relative paths to `base_prefix`.
Njalla 0.9.0
A python library built to integrate the njal.la API

# Njal.la Python

![Njal.la Logo](njalla.svg)

## Description

This Python library provides a convenient interface for interacting with the Njal.la API, allowing users to seamlessly integrate Njal.la services into their Python applications.

## Installation

To install the library, use the following command:

```
pip install Njalla
```

## Usage

```python
import Njalla
# Initialize the Njal.la client
client = Njalla.Client(api_key="your_api_key")
```

## API Key

To use the library, you need to obtain an API key from Njal.la.
You can sign up for an account on [Njal.la website](https://njal.la/) and generate an API key in your account settings.

## Pronunciation

The library is named after "/ˈɲalla/" (Sami),
which refers to a small hut in the Sápmi forest, built to protect against predators.
This concept aligns with Njal.la's commitment to providing a secure and protective environment for online activities.

## License

This library is licensed under the `CC BY-NC-SA 4.0` License - see the [LICENSE](LICENSE) file for details.

## Contributing

We welcome contributions!
If you find any issues or have suggestions for improvement,
please open an [issue](https://github.com/DevCa-IO/Njalla/issues)
or submit a [pull request](https://github.com/DevCa-IO/Njalla/pulls).


## Classes

Njalla provides five different API classes.
You can use these simply by adding the class name on top of your Instance.\
Those are:
- API
- Domain
- Server
- VPN
- Wallet


```python
import Njalla

# Initialize the Njal.la client
client = Njalla.Client("your_api_key")

# API

print(client.API.add_token("comment", "from", "allowed_domains", "allowed_servers", "allowed_methods", "allowed_types", "acme"))

# Domain

print(client.Domain.register_domain("domain", "years"))

# Server

print(client.Server.add_traffic("id", "amount", "months", "starts_today"))

# VPN

print(client.VPN.add_vpn("name", "autorenew"))

# Wallet

print(client.Wallet.get_balance())
```

All the methods are also available in our (not yet existing) ReadTheDocs Documentation.\
You can find the documentation [here](https://njalla.readthedocs.io/en/latest/) soon.
config-lang-serder 0.1.1
A Rust library and Python extension for reading and converting configuration files (TOML, YAML, JSON, XML) into Python dictionaries or vice versa. Powered by PyO3.
Requires Python: >=3.10

# config_lang_serder

A Rust library and Python extension for reading and converting configuration files (TOML, YAML, JSON, XML) into Python
dictionaries and vice versa. Powered by [PyO3](https://github.com/PyO3/pyo3), this project enables seamless integration
of Rust's
performance with Python's usability for configuration management.

## Features

- **Read and parse TOML, YAML, JSON, and XML (not fully supported yet) files**
- **Unified API:** Returns configuration as a Python `dict` regardless of format
- **High performance:** Leverages Rust for fast parsing
- **Python bindings:** Easily callable from Python via PyO3
- **Write Python dict to TOML, YAML, or JSON file**

## Installation

### by PyPI

```sh
uv pip install config-lang-serder
# or
pip install config-lang-serder
```

### from source (via maturin or setuptools-rust)

Build and install with [maturin](https://github.com/PyO3/maturin):

```sh
maturin develop
```

Or build a wheel:

```sh
maturin build
pip install target/wheels/config_lang_serder-*.whl
```

## Usage

### Python

```python
import config_lang_serder

# Read: Automatically detects file type by extension
config = config_lang_serder.read('config.yaml')
print(config)

# Write: Automatically detects file type by extension
config_lang_serder.write({'foo': 123, 'bar': True}, 'config.yaml')
```

Current supported extensions: `.toml`, `.yaml`, `.json`, `.xml` (read), `.toml`, `.yaml`, `.json` (write)

## API

- `read(path: str) -> dict`: Reads a config file and returns its contents as a Python dict. Supported extensions: toml,
  yaml, json, xml.
- `write(dict: dict, path: str) -> None`: Writes a Python dict to a file. The format is determined by the file
  extension (supports: toml, yaml, json).

## Development

- Rust code in `src/`
- Python bindings via PyO3
- Tests in `test.py` and `tests/`

## License

MIT