semvec/pypi-packages huggingface dataset:
rtcpconnect 1.6.3
fix http error for python 3.11+ 

# webflux

**rtcptconnect** is a simple and powerful Python module for building real-time communication applications. Inspired by the WebRTC standard, it allows you to handle audio, video, and P2P data with low latency and minimal syntax.

---

## Features

* **P2P Communication**: Direct data exchange between clients without a central server.
* **Audio & Video**: Real-time transmission with low latency.
* **Data Channels**: Send and receive text or JSON messages instantly.
* **Event Handling**: Simple callbacks for `on_connect`, `on_message`, `on_disconnect`.
* **Secure**: Built-in DTLS/SRTP encryption.
* **Interoperable**: Compatible with browsers and other webflux clients.

---

## Installation

```bash
pip install rtcpconnect
```



---

## Basic Usage

### Create a client and connect

```python
from rtcpconnect import rtcpClient

# Initialize the client
client = rtcpClient(username="Alice")

# Event triggered when a message is received
@client.on("message")
def handle_message(sender, content):
    print(f"{sender} says: {content}")

# Connect to a peer
client.connect("bob_peer_id")

# Send a message
client.send("bob_peer_id", "Hi Bob!")

# Listen for events
client.listen()
```

### Audio/Video example

```python
client.connect_audio()
client.connect_video()
```

---

## Use Cases

* Real-time audio and video chats
* P2P multiplayer games
* Streaming and data sharing
* Collaborative tools (drawing, shared documents)

---
mddj 0.4.2
A CLI for extracting python metadata from packages
Requires Python: >=3.10

# mddj

Your DJ of MetaData.

[![PyPI - Version](https://img.shields.io/pypi/v/mddj.svg)](https://pypi.org/project/mddj)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mddj.svg)](https://pypi.org/project/mddj)

-----

## Overview

A CLI for interacting with your python package metadata.

Supports multiple packaging backends via a uniform interface.

For full documentation, see the [docs site](https://mddj.readthedocs.io/en/latest/).

## Installation

```console
pipx install mddj
```

## Quickstart

`mddj` supports usage as a CLI and as library!

Here's how you can instantiate read the project version in Python:

```python
from mddj.api import DJ

dj = DJ()
print(dj.read.version())
```

and, equivalently, via the CLI:

```bash
mddj read version
```

## License

`mddj` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
django-htmx 1.27.0
Extensions for using Django with htmx.
Requires Python: >=3.10
Keywords: Django

===========
django-htmx
===========

.. image:: https://img.shields.io/readthedocs/django-htmx?style=for-the-badge
   :target: https://django-htmx.readthedocs.io/en/latest/

.. image:: https://img.shields.io/github/actions/workflow/status/adamchainz/django-htmx/main.yml.svg?branch=main&style=for-the-badge
   :target: https://github.com/adamchainz/django-htmx/actions?workflow=CI

.. image:: https://img.shields.io/badge/Coverage-100%25-success?style=for-the-badge
   :target: https://github.com/adamchainz/django-htmx/actions?workflow=CI

.. image:: https://img.shields.io/pypi/v/django-htmx.svg?style=for-the-badge
   :target: https://pypi.org/project/django-htmx/

.. image:: https://img.shields.io/badge/code%20style-black-000000.svg?style=for-the-badge
   :target: https://github.com/psf/black

.. image:: https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white&style=for-the-badge
   :target: https://github.com/pre-commit/pre-commit
   :alt: pre-commit

----

.. figure:: https://raw.githubusercontent.com/adamchainz/django-htmx/main/docs/_static/logo.svg
  :alt: django-htmx logo
  :align: center

Extensions for using Django with `htmx <https://htmx.org/>`__.

Documentation
-------------

Please see https://django-htmx.readthedocs.io/.
fromjcl 0.1.1
Convert JCL to modern formats: mvscmd, Ansible, and more
Requires Python: >=3.10

# fromjcl

Convert JCL to modern formats.
```
fromjcl job.jcl --to ansible    # Ansible playbook
fromjcl job.jcl --to mvscmd     # Shell script for z/OS USS
fromjcl job.jcl --to json       # Structured JSON
fromjcl job.jcl --to yaml       # Structured YAML
```

## Example

Input (`job.jcl`):
```jcl
//COPYJOB  JOB (ACCT),'COPY DATA',CLASS=A,MSGCLASS=X
//STEP01   EXEC PGM=IEBGENER
//SYSPRINT DD SYSOUT=*
//SYSIN    DD DUMMY
//SYSUT1   DD DSN=MY.INPUT.FILE,DISP=SHR
//SYSUT2   DD DSN=MY.OUTPUT.FILE,DISP=SHR
```

Output (`fromjcl job.jcl --to ansible`):
```yaml
- name: Execute JCL job COPYJOB
  hosts: zos_host
  gather_facts: false
  tasks:
  - name: Step STEP01 - IEBGENER
    ibm.ibm_zos_core.zos_mvs_raw:
      program_name: IEBGENER
      dds:
      - dd_output:
          dd_name: SYSPRINT
          return_content:
            type: text
      - dd_dummy:
          dd_name: SYSIN
      - dd_data_set:
          dd_name: SYSUT1
          data_set_name: MY.INPUT.FILE
          disposition: shr
      - dd_data_set:
          dd_name: SYSUT2
          data_set_name: MY.OUTPUT.FILE
          disposition: shr
```

Output (`fromjcl job.jcl --to mvscmd`):
```bash
#!/bin/sh
# Generated by fromjcl
# Job: COPYJOB

# Step: STEP01
mvscmd \
    --pgm=IEBGENER \
    --sysprint=* \
    --sysin=dummy \
    --sysut1=MY.INPUT.FILE \
    --sysut2=MY.OUTPUT.FILE
```

## Installation
```bash
pip install fromjcl
```

## Python API
```python
from fromjcl import parse, Job
from fromjcl.converters import mvscmd, ansible

job = Job.from_parsed(parse("job.jcl"))

# Inspect
for step in job.steps:
    print(f"{step.name}: {step.program}")

# Convert
print(ansible.convert(job))
print(mvscmd.convert(job))
```

## Status

Early development. Contributions welcome.

## Acknowledgments

JCL parsing uses [Mike Fulton's JCLParser](https://github.com/MikeFultonDev/JCLParser), licensed under the Apache License 2.0.

## License

MIT (this project)

The bundled JCLParser is licensed under the Apache License 2.0:
```
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
```
olist-loafer 7.1.0b1
Asynchronous message dispatcher for concurrent tasks processing
Requires Python: >=3.11
Keywords: asyncio, dispatcher, message, microservices, tasks

[![PyPI latest](https://img.shields.io/pypi/v/olist-loafer.svg?maxAge=2592000)](https://pypi.python.org/pypi/loafer)
[![Python versions](https://img.shields.io/pypi/pyversions/olist-loafer.svg?maxAge=2592000)](https://pypi.python.org/pypi/loafer)
[![License](https://img.shields.io/pypi/l/loafer.svg?maxAge=2592000)](https://pypi.python.org/pypi/olist-loafer)
[![CircleCI](https://circleci.com/gh/olist/olist-loafer/tree/main.svg?style=svg)](https://circleci.com/gh/olist/olist-loafer/tree/main)
[![Olist Sponsor](https://img.shields.io/badge/sponsor-olist-53b5f6.svg?style=flat-square)](http://opensource.olist.com/)


**olist-loafer** is an asynchronous message dispatcher for concurrent tasks processing, with the following features:

* Encourages decoupling from message providers and consumers
* Easy to extend and customize
* Easy error handling, including integration with sentry
* Easy to create one or multiple services
* Generic Handlers
* Amazon SQS integration

---
:information_source: Currently, only AWS SQS is supported

---

## How to use

A simple message forwader, from ``source-queue`` to ``destination-queue``:

```python
from loafer.ext.aws.handlers import SQSHandler
from loafer.ext.aws.routes import SQSRoute
from loafer.managers import LoaferManager

routes = [
    SQSRoute('source-queue', handler=SQSHandler('destination-queue')),
]

if __name__ == '__main__':
    manager = LoaferManager(routes)
    manager.run()
```

## How to contribute

Fork this repository, make changes and send us a pull request. We will review your changes and apply them. Before sending us your pull request please check if you wrote and ran tests:

```bash
make test
```
robust-python 0.0.1
robust-python
Requires Python: <4.0,>=3.10
Keywords: robust-python

# robust-python

robust_python

---

**[📚 View Documentation](https://robust-python.readthedocs.io/)** | **[🐛 Report a Bug](https://github.com/56kyle/robust-python/issues)** | **[✨ Request a Feature](https://github.com/56kyle/robust-python/issues)**

---

## Installation

You can install `robust_python` via [pip](pip-documentation) from PyPI:

```bash
pip install robust_python
```

### Installation for Development

To set up `robust_python` for local development:

1.  Clone the repository:
    ```bash
    git clone https://github.com/56kyle/robust-python.git
    cd robust-python
    ```
2.  Install dependencies using [:term:`uv`](uv-documentation):
    ```bash
    uv sync
    ```
3.  Install pre-commit hooks:
    ```bash
    uvx nox -s pre-commit -- install
    ```

This sets up a virtual environment and installs core, development, and quality check dependencies.

## Usage

(This section should explain how to use the generated application. Replace the content below with instructions specific to your project's functionality. If your project is a library, show import examples. If it's a CLI application, show command examples. Link to the full documentation for details.)

### As a Library

```python
# Example usage of your package as a library
# from robust_python import some_function
# result = some_function()
# print(result)
```

### As a Command-Line Application

If your project defines command-line entry points in `pyproject.toml`:

```bash
# Example usage of your CLI application
# robust-python --help
# robust-python do-something --input file.txt
```

For detailed API documentation and CLI command references, see the **[Documentation][documentation]**.

## Development Workflow

This project uses a robust set of tools for development, testing, and quality assurance. All significant automated tasks are run via [:term:`Nox`](nox-documentation), orchestrated by the central `noxfile.py`.

- **Run all checks (lint, typecheck, security):** `uvx nox -s check`
- **Run test suite with coverage:** `uvx nox -s test`
- **Build documentation:** `uvx nox -s docs`
- **Build package:** `uvx nox -s build`
- **See all available tasks:** `uvx nox -l`

Explore the `noxfile.py` and the project documentation for detailed information on the automated workflow.

## Contributing

(This section should guide contributions _to this specific generated project_, not the template. It should refer to the project's `CODE_OF_CONDUCT.md` and link to a `CONTRIBUTING.md` specific to the project, if you choose to generate one.)

Report bugs or suggest features via the [issue tracker](https://github.com/56kyle/robust-python/issues).

See [CONTRIBUTING.md](#) for contribution guidelines.

## License

Distributed under the terms of the **MIT** license. See [LICENSE](LICENSE) for details.

---

**This project was generated from the [cookiecutter-robust-python template][cookiecutter-robust-python].**

<!-- Reference Links -->

[cookiecutter-robust-python]: https://github.com/robust-python/cookiecutter-robust-python
[documentation]: https://robust-python.readthedocs.io/
softiqtech-sofi-agent 0.1
A FastAPI + Next.js website agent shipped as a pip package
Requires Python: >=3.8

# SoftiqTech Sofi Agent

**SoftiqTech Sofi Agent** is a Python package that provides a ready-to-use web assistant interface built with FastAPI for the backend and a static frontend, including interactive 3D assets. This package is designed to help developers quickly integrate a web-based assistant or demo application into their projects.

---

## Features

- ✅ FastAPI backend for serving APIs and static frontend.
- ✅ Pre-built frontend served from `frontend_build` folder.
- ✅ 3D interactive assets (like `kawaii_cute_flying_robot`) integrated with the frontend.
- ✅ Easy mounting of frontend and static assets using a single function.
- ✅ Works out-of-the-box after installation via PyPI.
- ✅ Lightweight and modular, ready to be extended for AI agents or assistant applications.

---

## Installation

You can install the package directly from PyPI:

```bash
pip install softiqTech-sofi-agent

When you install the package using pip, automatically the following packages are installed:
1) FastApi
2) uvicorn
3) openai-agents
vehicle-market-x23311428 1.0.0
Motor marketplace utilities library for automotive applications
Requires Python: >=3.7
Keywords: vehicle, automotive, marketplace, price-estimation, validation, car, bike

# Vehicle Marketplace Utils

A comprehensive Python library for vehicle marketplace applications, providing utilities for validation, price estimation, and data formatting.

**Student ID:** x23311428  
**Author:** Dhruv Jani

## Installation
```bash
pip install vehicle-market-x23311428
```

## Features

- **VehicleValidator**: Validate year, price, mileage, and phone numbers
- **PriceEstimator**: Calculate vehicle depreciation and estimate resale prices
- **VehicleFormatter**: Format prices, mileage, age, and phone numbers for display

## Quick Start

### Validation
```python
from vehicle_utils import VehicleValidator

# Validate year
is_valid, message = VehicleValidator.validate_year(2020)
print(f"Valid: {is_valid}, Message: {message}")

# Validate price
is_valid, message = VehicleValidator.validate_price(25000)

# Validate mileage
is_valid, message = VehicleValidator.validate_mileage(50000)

# Validate phone
is_valid, message = VehicleValidator.validate_phone("1234567890")
```

### Price Estimation
```python
from vehicle_utils import PriceEstimator

# Estimate vehicle price
result = PriceEstimator.estimate_price(
    original_price=30000,
    year_of_purchase=2018,
    category='sedan',
    fuel_type='petrol',
    transmission='automatic',
    mileage=50000,
    condition='good'
)

print(f"Estimated Price: €{result['estimated_price']}")
print(f"Depreciation: {result['total_depreciation_percentage']}%")
print(f"Vehicle Age: {result['age']} years")
```

### Data Formatting
```python
from vehicle_utils import VehicleFormatter

# Format price
formatted_price = VehicleFormatter.format_price(25000)
print(formatted_price)  # €25,000

# Format mileage
formatted_mileage = VehicleFormatter.format_mileage(50000)
print(formatted_mileage)  # 50,000 km

# Format age
age = VehicleFormatter.format_age(2020)
print(age)  # 5 years old

# Format phone
phone = VehicleFormatter.format_phone("1234567890")
print(phone)  # 123-456-7890
```

## Depreciation Model

The price estimator uses a sophisticated depreciation model:

- **Year 1**: 20% depreciation
- **Years 2-5**: 15% depreciation per year
- **Year 6+**: 10% depreciation per year

### Additional Factors

- **Category**: SUVs (+15%), Trucks (+10%), Coupes (-10%)
- **Fuel Type**: Electric (+20%), Hybrid (+10%), Diesel (+5%)
- **Transmission**: Automatic (+5%), Manual (-5%)
- **Mileage**: 2% depreciation per 10,000 km
- **Condition**: Excellent (+10%), Good (baseline), Fair (-15%), Poor (-30%)

## Requirements

- Python 3.7+
- No external dependencies

## License

MIT License
motor-market-x23311428 1.0.0
Motor marketplace utilities library for automotive applications
Requires Python: >=3.7
Keywords: vehicle, automotive, marketplace, price-estimation, validation, car, bike

# Vehicle Marketplace Utils

A comprehensive Python library for vehicle marketplace applications, providing utilities for validation, price estimation, and data formatting.

**Student ID:** x23311428  
**Author:** Dhruv Jani

## Installation
```bash
pip install motor-market-x23311428
```

## Features

- **VehicleValidator**: Validate year, price, mileage, and phone numbers
- **PriceEstimator**: Calculate vehicle depreciation and estimate resale prices
- **VehicleFormatter**: Format prices, mileage, age, and phone numbers for display

## Quick Start

### Validation
```python
from vehicle_utils import VehicleValidator

# Validate year
is_valid, message = VehicleValidator.validate_year(2020)
print(f"Valid: {is_valid}, Message: {message}")

# Validate price
is_valid, message = VehicleValidator.validate_price(25000)

# Validate mileage
is_valid, message = VehicleValidator.validate_mileage(50000)

# Validate phone
is_valid, message = VehicleValidator.validate_phone("1234567890")
```

### Price Estimation
```python
from vehicle_utils import PriceEstimator

# Estimate vehicle price
result = PriceEstimator.estimate_price(
    original_price=30000,
    year_of_purchase=2018,
    category='sedan',
    fuel_type='petrol',
    transmission='automatic',
    mileage=50000,
    condition='good'
)

print(f"Estimated Price: €{result['estimated_price']}")
print(f"Depreciation: {result['total_depreciation_percentage']}%")
print(f"Vehicle Age: {result['age']} years")
```

### Data Formatting
```python
from vehicle_utils import VehicleFormatter

# Format price
formatted_price = VehicleFormatter.format_price(25000)
print(formatted_price)  # €25,000

# Format mileage
formatted_mileage = VehicleFormatter.format_mileage(50000)
print(formatted_mileage)  # 50,000 km

# Format age
age = VehicleFormatter.format_age(2020)
print(age)  # 5 years old

# Format phone
phone = VehicleFormatter.format_phone("1234567890")
print(phone)  # 123-456-7890
```

## Depreciation Model

The price estimator uses a sophisticated depreciation model:

- **Year 1**: 20% depreciation
- **Years 2-5**: 15% depreciation per year
- **Year 6+**: 10% depreciation per year

### Additional Factors

- **Category**: SUVs (+15%), Trucks (+10%), Coupes (-10%)
- **Fuel Type**: Electric (+20%), Hybrid (+10%), Diesel (+5%)
- **Transmission**: Automatic (+5%), Manual (-5%)
- **Mileage**: 2% depreciation per 10,000 km
- **Condition**: Excellent (+10%), Good (baseline), Fair (-15%), Poor (-30%)

## Requirements

- Python 3.7+
- No external dependencies

## License

MIT License
Flake8-pyproject 1.2.4
Flake8 plug-in loading the configuration from pyproject.toml
Requires Python: >=3.6
Keywords: Flake8, pyproject.toml

﻿# Flake8-pyproject
*Flake8 plug-in loading the configuration from `pyproject.toml`*

[Flake8] cannot be configured via `pyproject.toml`, even though
virtually all other Python dev tools have adopted it as the central
location for project configuration. The discussion of the original
proposal ([#234]) was closed as "too heated", subsequent feature
and pull requests were marked as "spam" ([#1332], [#1421], [#1431],
[#1447], [#1501]).

Flake8-pyproject also has bad manners and force-feeds Flake8 the
spam it so despises. It registers itself as a Flake8 plug-in to
seamlessly load the configuration from `pyproject.toml` when you
run the `flake8` command.

[Flake8]: https://github.com/PyCQA/flake8
[#234]:   https://github.com/PyCQA/flake8/issues/234
[#1332]:  https://github.com/PyCQA/flake8/pull/1332
[#1421]:  https://github.com/PyCQA/flake8/issues/1421
[#1431]:  https://github.com/PyCQA/flake8/issues/1431
[#1447]:  https://github.com/PyCQA/flake8/issues/1447
[#1501]:  https://github.com/PyCQA/flake8/issues/1501


## Usage

Say your Flake8 configuration in `.flake8` (or in `tox.ini`, or
`setup.cfg`) is this:
```ini
[flake8]
ignore = E231, E241
per-file-ignores =
    __init__.py:F401
max-line-length = 88
count = true
```

Copy that `[flake8]` section to `pyproject.toml`, rename it as
`[tool.flake8]`, and convert the key–value pairs to the [TOML format]:
```toml
[tool.flake8]
ignore = ['E231', 'E241']
per-file-ignores = [
    '__init__.py:F401',
]
max-line-length = 88
count = true
```

Then run `flake8` in the project root folder, where `pyproject.toml`
is located.

In case your TOML-based configuration is contained in a different
folder, or the file has a different name, specify the location with
the `--toml-config` command-line option.

For compatibility with earlier versions of this package, and perhaps
extra reliability in terms of possible future breakage of the plug-in
hook, the package also provides a `flake8p` command that could be
called alternatively to lint the code.

[TOML format]: https://toml.io
vehicle-marketplace-utils-x23311428 1.0.0
Vehicle marketplace utilities library for automotive applications
Requires Python: >=3.7
Keywords: vehicle, automotive, marketplace, price-estimation, validation

# Vehicle Marketplace Utils

A comprehensive Python library for vehicle marketplace applications, providing utilities for validation, price estimation, and data formatting.

**Student ID:** x23311428  
**Author:** Dhruv Jani

## Installation
```bash
pip install vehicle-marketplace-utils-x23311428
```

## Features

- **VehicleValidator**: Validate year, price, mileage, and phone numbers
- **PriceEstimator**: Calculate vehicle depreciation and estimate resale prices
- **VehicleFormatter**: Format prices, mileage, age, and phone numbers for display

## Quick Start

### Validation
```python
from vehicle_utils import VehicleValidator

# Validate year
is_valid, message = VehicleValidator.validate_year(2020)
print(f"Valid: {is_valid}, Message: {message}")

# Validate price
is_valid, message = VehicleValidator.validate_price(25000)

# Validate mileage
is_valid, message = VehicleValidator.validate_mileage(50000)

# Validate phone
is_valid, message = VehicleValidator.validate_phone("1234567890")
```

### Price Estimation
```python
from vehicle_utils import PriceEstimator

# Estimate vehicle price
result = PriceEstimator.estimate_price(
    original_price=30000,
    year_of_purchase=2018,
    category='sedan',
    fuel_type='petrol',
    transmission='automatic',
    mileage=50000,
    condition='good'
)

print(f"Estimated Price: €{result['estimated_price']}")
print(f"Depreciation: {result['total_depreciation_percentage']}%")
print(f"Vehicle Age: {result['age']} years")
```

### Data Formatting
```python
from vehicle_utils import VehicleFormatter

# Format price
formatted_price = VehicleFormatter.format_price(25000)
print(formatted_price)  # €25,000

# Format mileage
formatted_mileage = VehicleFormatter.format_mileage(50000)
print(formatted_mileage)  # 50,000 km

# Format age
age = VehicleFormatter.format_age(2020)
print(age)  # 5 years old

# Format phone
phone = VehicleFormatter.format_phone("1234567890")
print(phone)  # 123-456-7890
```

## Depreciation Model

The price estimator uses a sophisticated depreciation model:

- **Year 1**: 20% depreciation
- **Years 2-5**: 15% depreciation per year
- **Year 6+**: 10% depreciation per year

### Additional Factors

- **Category**: SUVs (+15%), Trucks (+10%), Coupes (-10%)
- **Fuel Type**: Electric (+20%), Hybrid (+10%), Diesel (+5%)
- **Transmission**: Automatic (+5%), Manual (-5%)
- **Mileage**: 2% depreciation per 10,000 km
- **Condition**: Excellent (+10%), Good (baseline), Fair (-15%), Poor (-30%)

## Requirements

- Python 3.7+
- No external dependencies

## License

MIT License