semvec/pypi-packages huggingface dataset:
teltasync 0.1.5
Async, typed API client for Teltonika routers, built for Home Assistant
Requires Python: >=3.13

# teltasync

teltasync is an async python library for interfacing with Teltonika routers via their HTTP API.

> [!NOTE]
> Please report issues and open pull requests only at Codeberg: https://codeberg.org/dmho/teltasync

## Installation

You can install the library using pip:

```bash
pip install teltasync
```

## Usage

This is a simple example of how to use the library:

```python
import asyncio

from teltasync import Teltasync


async def main():
    # Create client
    client = Teltasync(
        base_url="https://192.168.1.1/api",  # Full API URL
        username="admin",  # Admin username
        password="YOUR_PASSWORD",  # Admin password
        verify_ssl=False  # Most Teltonika devices use self-signed certs
    )

    try:
        # Get basic device info (no authentication required)
        device_info = await client.get_device_info()
        print(f"Device: {device_info.device_name} ({device_info.device_model})")

        # Validate credentials
        if await client.validate_credentials():
            print("Credentials are valid!")

            # Get detailed system information
            system_info = await client.get_system_info()
            print(f"Firmware version: {system_info.static.fw_version}")

            # Get modem status
            modems = await client.get_modem_status()
            for modem in modems:
                print(f"Modem {modem.id}: {modem.operator} ({modem.conntype})")
                print(f"  Signal: {modem.rssi} dBm")

        else:
            print("Invalid credentials!")

    finally:
        # Always close the session
        await client.close()


# Using as async context manager (recommended)
async def context_manager_example():
    async with Teltasync(
            base_url="https://192.168.1.1/api",
            username="admin",
            password="YOUR_PASSWORD",
            verify_ssl=False
    ) as client:
        device_info = await client.get_device_info()
        print(f"Device: {device_info.device_name}")
        # Session automatically closed when exiting context


# Run the example
if __name__ == "__main__":
    asyncio.run(main())
```

## Supported Devices

Although it was currently only tested against a RUTX50, this library should work with most Teltonika routers that
support the [HTTP API](https://developers.teltonika-networks.com/), including:

- RUT series (RUT240, RUT241, RUT950, RUT955, etc.)
- RUTX series (RUTX09, RUTX11, RUTX12, etc.)
- TRB series gateways
- Other Teltonika devices with HTTP API support

## Requirements

- Python 3.13+
- aiohttp
- pydantic
absfuyu 6.4.1
A small collection of code
Requires Python: <4,>=3.12
Keywords: utilities

<div align="center">
    <h1 align="center">
        <img src="https://github.com/AbsoluteWinter/AbsoluteWinter.github.io/blob/main/absfuyu/images/repository-image-crop.png?raw=true" alt="absfuyu"/>
    </h1>
    <p align="center">
        <a href="https://pypi.org/project/absfuyu/"><img src="https://img.shields.io/pypi/pyversions/absfuyu?style=flat-square&logo=python" alt="PyPI Supported Versions"/></a>
        <a href="https://pypi.org/project/absfuyu/"><img src="https://img.shields.io/pypi/dm/absfuyu?style=flat-square&color=blue" alt="PyPI Downloads"/></a>
        <a href="https://pypi.org/project/absfuyu/"><img src="https://img.shields.io/pypi/v/absfuyu?style=flat-square&logo=pypi" /></a>
        <a><img src="https://img.shields.io/pypi/l/absfuyu?style=flat-square&logo=github&color=blue"/></a>
        <a><img src="https://img.shields.io/badge/code%20style-black-black?style=flat-square"/></a>
        <a href="https://github.com/astral-sh/ruff"><img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json&style=flat-square" alt="Ruff" style="max-width:100%;"></a>
    </p>
</div>

---

## **SUMMARY:**

This project is a collection of code primarily developed as a personal hobby. It aims to provide practical experience and enhance my coding skills while exploring potential future applications.

## **INSTALLATION:**

To install the package, run the following command:

```bash
pip install -U absfuyu
```

## **USAGE:**

```python
import absfuyu
help(absfuyu)
```

### Notable features

**absfuyu.core**: Provides base components for additional functionalities.

```python
# Decorators that adds info to __doc__
from absfuyu.core.docstring import versionadded, versionchanged, deprecated

# Class mixins for enhanced functionality
from absfuyu.core.baseclass import AutoREPRMixin, GetClassMembersMixin
```

**absfuyu.dxt**: Extension for `list`, `str`, `dict`, `int`.

```python
from absfuyu.dxt import DictExt, IntExt, ListExt, Text
for x in [DictExt, IntExt, ListExt, Text]:
    x.show_all_methods(print_result=1)
```

**absfuyu.tools.Inspector**: An object inspector

```python
from absfuyu.tools import Inspector
print(Inspector(Inspector))
```

There are many additional features available to explore.

## **DOCUMENTATION:**

For more detailed information about the project, please refer to the documentation available at the following link:

> [Project Documentation](https://absolutewinter.github.io/absfuyu-docs/)

## **DEVELOPMENT SETUP**

1. Create a Virtual Environment

```bash
python -m venv env
```

Note: You may need to execute this command in PowerShell on Windows:

```powershell
Set-ExecutionPolicy -ExecutionPolicy Unrestricted -Scope CurrentUser
```

2. Install Required Packages

```bash
python -m pip install -e .[full,dev]
```

3. Acquire Information About the Development Environment Configuration

```bash
hatch env show
```

## **LICENSE:**

This project is licensed under the MIT License.
a3em 1.0.6
A3EM Management Dashboard
Requires Python: >=3.8

A3EM Management Dashboard
=========================

Overview
--------

This package provides a graphical interface called the A3EM Management Dashboard, which
should be used for setup and preparation of all live A3EM deployments. Once installed,
it can be accessed from any location in a command terminal by entering:

``a3em``


Installation
------------

The easiest way to install this tool is through `pip` by entering:

``python3 -m pip install a3em``

If you wish to install the package manually or develop it further, you should first
clone the `A3EM Dashboard repository <https://github.com/vu-a3em/a3em-dashboard>`_ to
your hard drive, `cd` into the root directory of the repository, then issue the
following command in a terminal:

``python3 -m pip install -e .``

Upon configuration and completion of a deployment, all audio and log files should be
properly labeled and accessible on the SD card of the deployed A3EM device.


Available Configuration Options
-------------------------------

TODO: Finish this list and add descriptions

* Deployment Options:
   * Device Label
   * Timezone
   * Start Date and Time
   * End Date and Time (optional)
   * Set RTC to Start Date/Time at Magnet Detect (yes/no)
   * LEDs enabled (yes/no)
   * If LEDs enabled:
      * For how many seconds after deployment starts
   * VHF Radio Start Date and Time
* Audio Recording Options:
   * Mode: Threshold-Triggered, Time-Scheduled, Interval-Scheduled, Continuous
   * If Threshold-Triggered:
      * Max num events per unit time
      * Threshold level (right now in percent of max, but prob should map dB to percent)
   * If Time-Scheduled:
      * List of start/end times (i.e., 6AM-11AM, 6PM-10PM)
   * If Interval-Scheduled:
      * Record every X time units
   * Clip length in seconds (even for continuous, should segment into clips)
   * Extend clip length if continuous audio detected (yes/no)
   * Audio sampling rate
   * Microphone amplification level (low, medium, high)
* IMU Recording Options:
   * Mode: Threshold-Triggered, Audio-Triggered (store IMU data whenever audio clip is recording)
   * If Threshold-Triggered:
      * Threshold level
   * Degrees of Freedom (only 3 available on current chip)
   * IMU sampling rate
retis 1.6.4
Python bindings for Retis events

# retis

Python bindings for [retis](https://retis.readthedocs.io/en/stable/) events.

This python library can be used to read and post-process retis events.

Example:

```python
from retis import EventFile

reader = EventFile("retis.data")

for e in reader.events():
    print(e)
```
oslo.policy 5.0.0
Oslo Policy library
Requires Python: >=3.10

===========
oslo.policy
===========

.. image:: https://governance.openstack.org/tc/badges/oslo.policy.svg

.. Change things from this point on

.. image:: https://img.shields.io/pypi/v/oslo.policy.svg
    :target: https://pypi.org/project/oslo.policy/
    :alt: Latest Version

.. image:: https://img.shields.io/pypi/dm/oslo.policy.svg
    :target: https://pypi.org/project/oslo.policy/
    :alt: Downloads

The Oslo Policy library provides support for RBAC policy enforcement across
all OpenStack services.

* Free software: Apache license
* Documentation: https://docs.openstack.org/oslo.policy/latest/
* Source: https://opendev.org/openstack/oslo.policy
* Bugs: https://bugs.launchpad.net/oslo.policy
* Blueprints: https://blueprints.launchpad.net/oslo.policy
* Release Notes: https://docs.openstack.org/releasenotes/oslo.policy
scriptengine-tasks-ecearth 0.10.1
ScriptEngine tasks for use with the EC-Earth climate model
Requires Python: >=3.11

[![Tests](https://github.com/uwefladrich/scriptengine-tasks-ecearth/actions/workflows/pytest.yml/badge.svg)](https://github.com/uwefladrich/scriptengine-tasks-ecearth/actions)
[![Coverage Status](https://coveralls.io/repos/github/uwefladrich/scriptengine-tasks-ecearth/badge.svg)](https://coveralls.io/github/uwefladrich/scriptengine-tasks-ecearth)

# ScriptEngine Tasks for EC-Earth

Provides [ScriptEngine](https://github.com/uwefladrich/scriptengine) tasks useful for the EC-Earth climate model.

This package is currently being developed. The documentation can be found on [ReadTheDocs](https://scriptengine-tasks-ecearth.rtfd.io).

## Contributing

1. See the documentation for hints on [installation from source (and how to run tests)](https://scriptengine-tasks-ecearth.readthedocs.io/en/latest/source/getting-started/installation.html#installation-from-source).
2. See the documentation for [hints on code formatting, structure, naming schemes, etc.](https://scriptengine-tasks-ecearth.readthedocs.io/en/latest/source/tasks/monitoring/developer-guide.html)
3. Have a look at issues labeled ["good first issue"](https://github.com/uwefladrich/scriptengine-tasks-ecearth/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22) for a place to start! :)
oslo.middleware 8.0.0
Oslo Middleware library
Requires Python: >=3.10

===============
oslo.middleware
===============

.. image:: https://img.shields.io/pypi/v/oslo.middleware.svg
    :target: https://pypi.org/project/oslo.middleware/
    :alt: Latest Version

.. image:: https://img.shields.io/pypi/dm/oslo.middleware.svg
    :target: https://pypi.org/project/oslo.middleware/
    :alt: Downloads

Oslo middleware library includes components that can be injected into
wsgi pipelines to intercept request/response flows. The base class can be
enhanced with functionality like add/delete/modification of http headers
and support for limiting size/connection etc.

* Free software: Apache license
* Documentation: https://docs.openstack.org/oslo.middleware/latest/
* Source: https://opendev.org/openstack/oslo.middleware
* Bugs: https://bugs.launchpad.net/oslo.middleware
* Release notes: https://docs.openstack.org/releasenotes/oslo.middleware/
yuio 2.1.1
Lite and user-friendly CLI library
Requires Python: >=3.10

# Yuio

[![test](https://github.com/taminomara/yuio/actions/workflows/ci.yaml/badge.svg)](https://github.com/taminomara/yuio/actions/workflows/ci.yaml) [![coverage](https://taminomara.github.io/yuio/coverage.svg)](https://taminomara.github.io/yuio/)

Yuio is everything you'll ever need to write a good CLI, deps-free.

Forget searching for *that one progressbar library*,
figuring out how to keep loading configs DRY,
or having headaches because autocompletion was just an afterthought.
Yuio got you.

## Resources

- [Documentation](https://yuio.readthedocs.io/)
- [Issues](https://github.com/taminomara/yuio/issues)
- [Source](https://github.com/taminomara/yuio/)
- [PyPi](https://pypi.org/project/yuio/)
- [Changelog](https://github.com/taminomara/yuio/blob/main/CHANGELOG.md)

## Requirements

The only requirement is `python >= 3.10`.

## Installation

Install `yuio` with pip:

```sh
pip install yuio
```
precice-adapter-schema 0.4.1
Validation utility for preCICE adapter configurations
Requires Python: >=3.10
Keywords: preCICE, adapter, validation, schema

# preCICE Adapter Schema

Here the adapter configuration schema is stored, together with validation utility.

A schema ...

- defines how a configuration file looks like (thus replaces any explicit documentation).
- enables interoperability (through standardization).
- simplifies auto-generation.
- enables tooling support (e.g. IDEs or GUIs).
- enables automatic LLM-based conversion from and to other configuration languages.
- ...

## Installation

Install the package using pip:

```bash
pip install preciceadapterschema
```

For development, install in editable mode:

```bash
pip install -e .
```

## Usage

The `preciceadapterschema` package provides a `validate` function to validate preCICE adapter configurations against the JSON schema.

```python
import preciceadapterschema

# Your configuration data
config_data = {
}

# Validate the configuration
try:
    preciceadapterschema.validate(config_data)
    print("Configuration is valid!")
except Exception as e:
    print(f"Validation failed: {e}")
```

The schema file (`precice_adapter_config.schema.json`) is included in the package and loaded automatically by the `validate` function.

## Configuring preCICE Adapters

We recommend using [MetaConfigurator](https://metaconfigurator.org/?schema=https://github.com/precice/adapter-schema/blob/main/preciceadapterschema/precice_adapter_config.schema.json&settings=https://github.com/precice/adapter-schema/blob/main/metaconfigurator_settings.json) to create and edit preCICE adapter configurations. It provides a user-friendly interface and ensures that your configurations are always valid according to the schema.

## Development

### Running Tests

Run tests using unittest:

```bash
python -m unittest discover -s tests -v
```
bunjee 3.0.0
23 developer tools, zero dependencies
Requires Python: >=3.9
Keywords: cli, terminal, developer-tools, productivity, scaffolding, utilities

# Bunjee

Developer Swiss Army knife — 15+ tools, zero dependencies.

One `pip install`, instant power in your terminal.

## Install

```bash
pip install bunjee
```

## Quick commands

```bash
bunjee                        # Interactive hub with animated startup
bunjee init myapp             # Scaffold a Python project
bunjee serve                  # Instant HTTP file server (port 8000)
bunjee gen password           # Generate a secure password
bunjee gen uuid               # Generate a UUID
bunjee gen token              # URL-safe token
bunjee tree                   # Directory tree viewer
bunjee tree -d 2              # Tree with max depth
bunjee json data.json         # Pretty-print JSON
bunjee json data.json -q users.0.name  # Query into JSON
bunjee hash file.txt          # SHA256 hash a file
bunjee hash "hello" -a md5    # Hash a string
bunjee port 8080              # Check if port is open
bunjee port 8000 --scan --to 9000  # Scan port range
bunjee timer 5m               # Countdown timer
bunjee timer 90s -l "Break"   # Timer with label
bunjee todo add "fix bug"     # Add a todo (persists in ~/.bunjee/)
bunjee todo                   # List todos
bunjee todo done -n 1         # Mark todo #1 done
bunjee b64 "hello world"      # Base64 encode
bunjee b64 -d "aGVsbG8="     # Base64 decode
bunjee count                  # Lines of code by file type
bunjee diff a.py b.py         # Unified diff of two files
bunjee env                    # System & Python info
bunjee env --path             # Inspect PATH entries
bunjee ip                     # Show your IP addresses
bunjee lorem -w 100           # Generate placeholder text
```

## Interactive hub

Run `bunjee` with no arguments to launch the interactive hub:

- **15 code snippets** — retry, cache, dataclass, decorators, async, argparse, pathlib, logging, and more
- **8 tutorials** — CLI building, API clients, testing, git, Docker, PyPI publishing
- **7 project templates** — project layout, FastAPI, Flask, Dockerfile, GitHub Actions, Makefile
- **7 utilities** — slugify, JSON, timestamps, passwords, UUIDs, base64, hashing

## Zero dependencies

Every feature uses only the Python standard library. No pip surprises.

## Build and publish

```bash
python3 -m pip install --upgrade build twine
python3 -m build
export TWINE_USERNAME=__token__
export TWINE_PASSWORD='pypi-YOUR-TOKEN'
python3 -m twine upload dist/*
```
deltachat-rpc-server 2.43.0
Delta Chat JSON-RPC server

# Delta Chat RPC server

This program provides a [JSON-RPC 2.0](https://www.jsonrpc.org/specification) interface to DeltaChat
over standard I/O.

## Install

To download binary pre-builds check the [releases page](https://github.com/chatmail/core/releases).
Rename the downloaded binary to `deltachat-rpc-server` and add it to your `PATH`.

To install from source run:

```sh
cargo install --git https://github.com/chatmail/core/ deltachat-rpc-server
```

The `deltachat-rpc-server` executable will be installed into `$HOME/.cargo/bin` that should be available
in your `PATH`.

## Usage

To use just run `deltachat-rpc-server` command. The accounts folder will be created in the current
working directory unless `DC_ACCOUNTS_PATH` is set:

```sh
export DC_ACCOUNTS_PATH=$HOME/delta/
deltachat-rpc-server
```

The common use case for this program is to create bindings to use Delta Chat core from programming
languages other than Rust, for example:

1. Python: https://pypi.org/project/deltachat-rpc-client/
2. Go: https://github.com/deltachat/deltachat-rpc-client-go/

Run `deltachat-rpc-server --version` to check the version of the server.
Run `deltachat-rpc-server --openrpc` to get [OpenRPC](https://open-rpc.org/) specification of the provided JSON-RPC API.
inet-control 1.0.0
Async Python library for Busch-Jaeger iNet Radio devices
Requires Python: >=3.11
Keywords: home-automation, radio, busch-jaeger, inet, iot


# Busch-Radio iNet Python Library

Asynchronous Python library for controlling and monitoring **Busch-Jaeger iNet Radios** via their UDP protocol. Features real-time push notifications for state changes (volume, station, power) from physical buttons.

## Installation

```bash
pip install inet-control
```

## Quick Start

### 1. Discover radios on your network

```python
import asyncio
from inet_control import RadioManager

async def discover():
    manager = RadioManager()
    await manager.start()
    
    # Broadcast discover and wait for responses
    await manager.discover()
    await asyncio.sleep(2)  # Wait for responses
    
    for ip, radio in manager.radios.items():
        print(f"{radio.name} → {ip}")
    
    await manager.stop()

asyncio.run(discover())
```

**Output:**
```
RADIO-LIVINGROOM → 192.168.1.100
RADIO-KITCHEN → 192.168.1.101
```

### 2. Control a radio

```python
import asyncio
from inet_control import RadioManager

async def control():
    manager = RadioManager()
    await manager.start()
    
    # Connect to a specific radio by IP
    radio = await manager.connect("192.168.1.100", timeout=3.0)
    print(f"Connected: {radio.name} (volume={radio.volume}, power={radio.power})")
    
    # Control the radio
    await manager.turn_on(radio)
    await manager.set_volume(radio, 8)
    await manager.play_station(radio, 1)  # Play station preset 1-8
    
    # State is updated automatically via callbacks
    await asyncio.sleep(1)
    print(f"Now playing: {radio.playing_station_name}")
    
    await manager.stop()

asyncio.run(control())
```

### 3. Monitor state changes (callbacks)

```python
import asyncio
from inet_control import RadioManager

async def monitor():
    manager = RadioManager()
    await manager.start()
    radio = await manager.connect("192.168.1.100")
    
    # Register callback for any state change
    def on_change():
        print(f"[UPDATE] {radio.name}: vol={radio.volume} power={radio.power} "
              f"station={radio.playing_station_name}")
    
    radio.register_callback(on_change)
    print("Listening for changes... (press Ctrl+C to stop)")
    
    try:
        await asyncio.Future()  # Run forever
    except KeyboardInterrupt:
        pass
    finally:
        await manager.stop()

asyncio.run(monitor())
```
## CLI Usage

The library includes a command-line interface:

```bash
# Discover radios
python -m inet_control monitor

# Control a specific radio
python -m inet_control ctl 192.168.1.100 status
python -m inet_control ctl 192.168.1.100 on
python -m inet_control ctl 192.168.1.100 off
python -m inet_control ctl 192.168.1.100 volume 8
python -m inet_control ctl 192.168.1.100 play 3    # Play station 3
python -m inet_control ctl 192.168.1.100 mute
```
base-api-utils 1.1.79
Django Rest Framework micro services common utilities
Requires Python: >=3.10

# base-api-utils
DRF common utilities

## Virtual Env

````bash
$ python3 -m venv env

$ source env/bin/activate
````

## python setup

````bash
sudo add-apt-repository ppa:deadsnakes/ppa -y
sudo apt-get -y -f install python3.7 python3-pip python3.7-dev python3.7-venv libpython3.7-dev python3-setuptools
sudo -H pip3 --default-timeout=50 install --upgrade pip
sudo -H pip3 install virtualenv
````

## Install reqs

````
pip install -r requirements.txt 
````

## Packaging

Create ~/.pypirc:

```bash
[distutils]
index-servers =
    pypi

[pypi]
username = __token__
password = pypi-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

```

````bash
python3 -m pip install --upgrade build
python3 -m build
````
## Uploading 

```bash
python3 -m pip install --upgrade twine
```

### Test Py Pi

```bash
python3 -m twine upload --repository testpypi dist/*
```

## Production PyPi

```bash
python3 -m twine upload dist/*
```

## Install from testPyPi.Org
pip install -i https://test.pypi.org/simple/ base-api-utils --no-deps

## Install from GitHub

pip install git+https://github.com/fntechgit/base-api-utils

# Failed Celery Async Tasks Management

For a deep dive into the technical implementation, CLI usage, and troubleshooting steps, please refer to the dedicated management guide:

**[Management & Recovery Deep Dive: /docs/celery-management.md](./docs/celery-management.md)**
obal 0.14.0
packaging wrapper using ansible
Keywords: ansible foreman packaging koji brew mock

# obal - packaging wrapper using Ansible

[![Documentation Status](https://readthedocs.org/projects/obal/badge/?version=latest)](https://obal.readthedocs.io/en/latest/)

`obal` is an Ansible wrapper with a set of Ansible playbooks to ease maintanance of packaging repositories like [`foreman-packaging`](https://github.com/theforeman/foreman-packaging) and [`pulp-packaging`](https://github.com/pulp/pulp-packaging).

All `obal` actions should also work with plain Ansible when called like `ansible-playbook <action_playbook>.yml -l <package>` instead of `obal <action> <package>`.

## necessary tools

- `python` 3.9+
- `ansible`

## Using Obal via Container

Obal and all it's required packages are available in a container that can be used locally or in build environments. The users Koji credentials and configuration must be mounted into the container alongside of mounting the packaging project into `/opt/packaging` to work. Note the examples below assume SELinux is disabled.

To run (or sub `docker` for `podman`):

    podman run -v `pwd`:/opt/packaging -v ~/.koji:/root/.koji obal:latest scratch katello