semvec/pypi-packages huggingface dataset:
ppyrogam 1.0.0
Custom build of Pyrogram for private use
Requires Python: >=3.8

<p align="center">
    <a href="https://github.com/pyrogram/pyrogram">
        <img src="https://docs.pyrogram.org/_static/pyrogram.png" alt="Pyrogram" width="128">
    </a>
    <br>
    <b>Telegram MTProto API Framework for Python</b>
    <br>
    <a href="https://pyrogram.org">
        Homepage
    </a>
    •
    <a href="https://docs.pyrogram.org">
        Documentation
    </a>
    •
    <a href="https://docs.pyrogram.org/releases">
        Releases
    </a>
    •
    <a href="https://t.me/pyrogram">
        News
    </a>
</p>

## Pyrogram

> Elegant, modern and asynchronous Telegram MTProto API framework in Python for users and bots

``` python
from pyrogram import Client, filters

app = Client("my_account")


@app.on_message(filters.private)
async def hello(client, message):
    await message.reply("Hello from Pyrogram!")


app.run()
```

**Pyrogram** is a modern, elegant and asynchronous [MTProto API](https://docs.pyrogram.org/topics/mtproto-vs-botapi)
framework. It enables you to easily interact with the main Telegram API through a user account (custom client) or a bot
identity (bot API alternative) using Python.

### Support

If you'd like to support Pyrogram, you can consider:

- [Become a GitHub sponsor](https://github.com/sponsors/delivrance).
- [Become a LiberaPay patron](https://liberapay.com/delivrance).
- [Become an OpenCollective backer](https://opencollective.com/pyrogram).

### Key Features

- **Ready**: Install Pyrogram with pip and start building your applications right away.
- **Easy**: Makes the Telegram API simple and intuitive, while still allowing advanced usages.
- **Elegant**: Low-level details are abstracted and re-presented in a more convenient way.
- **Fast**: Boosted up by [TgCrypto](https://github.com/pyrogram/tgcrypto), a high-performance cryptography library written in C.  
- **Type-hinted**: Types and methods are all type-hinted, enabling excellent editor support.
- **Async**: Fully asynchronous (also usable synchronously if wanted, for convenience).
- **Powerful**: Full access to Telegram's API to execute any official client action and more.

### Installing

``` bash
pip3 install pyrogram
```

### Resources

- Check out the docs at https://docs.pyrogram.org to learn more about Pyrogram, get started right
away and discover more in-depth material for building your client applications.
- Join the official channel at https://t.me/pyrogram and stay tuned for news, updates and announcements.
rt-hat-inr 0.6.9
RealtimeHAT control
Requires Python: >=3.6

# Realtime-HAT python package

* contain python bindings to control your Realtime-HAT https://github.com/InnoRoute/RealtimeHAT
* update with `sudo pip3 install --upgrade rt_hat_inr --break-system-packages`

## Dokumentation
* clone https://github.com/InnoRoute/RT_HAT_python and have a look into the examples folder
* follow the tutorials on https://github.com/InnoRoute/RealtimeHAT/wiki
* see https://github.com/InnoRoute/RT_HAT_python/wiki/Realtime-HAT-python-package
lakepipe 0.1.0
Modern data transfer for cloud data lakes - High-performance pipelines via object storage
Requires Python: >=3.10
Keywords: data-engineering, etl, data-pipeline, data-lake, sqoop, teradata, hive

# LakePipe

**Modern data transfer for cloud data lakes**

LakePipe is a high-performance data pipeline framework for moving data between data lakes and warehouses via object storage. Think of it as **Sqoop for the cloud era** - optimized for modern cloud architectures with vendor-specific bulk loaders.

[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE)
[![Python](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)

## Why LakePipe?

- **Cloud-native**: Uses object storage (S3/GCS/Azure/OBS) as intermediate layer
- **Fast**: Leverages vendor-optimized bulk loaders (TPT, Snowpipe, BigQuery Storage API)
- **Observable**: Real-time progress, validation, and actionable error messages
- **Flexible**: YAML configs, Python SDK, or CLI - your choice
- **Extensible**: Plugin architecture for sources, targets, and transformations

## Quick Start

### Installation

```bash
pip install lakepipe
```

### Simple Transfer

```yaml
# lakepipe.yml
version: 1.0
name: my_pipeline

source:
  type: hive
  database: my_db
  table: my_table
  partition_by: date

storage:
  type: s3
  bucket: my-bucket
  path: /staging

target:
  type: teradata
  host: td-host
  database: target_db
  table: target_table
  loader: tpt

validation:
  row_count:
    enabled: true
    max_variance: 0.01
```

```bash
lakepipe run lakepipe.yml --params date=2025-01-15
```

## Documentation

- [Getting Started](docs/getting-started.md)
- [Examples](examples/)

## Supported Connectors

### Sources
- Hive (beeline)
- PostgreSQL (planned)
- MySQL (planned)
- MongoDB (planned)

### Storage
- S3 (AWS)
- GCS (Google Cloud)
- Azure Blob Storage
- OBS (Huawei Cloud)

### Targets
- Teradata (TPT)
- Snowflake (planned)
- BigQuery (planned)
- Redshift (planned)

## Contributing

Contributions are welcome! Please read [CONTRIBUTING.md](CONTRIBUTING.md) for details.

## License

Apache License 2.0 - See [LICENSE](LICENSE) for details.

## Acknowledgments

Inspired by Apache Sqoop, built for the cloud era.

---

**Author**: Md. Rakibul Hasan
**Status**: Alpha - Active Development
httpx-aws-auth 4.1.1
Provides AWS authentication classes to be used with httpx authentication parameter
Requires Python: >=3.10

# httpx-aws-auth

## Overview

This module provides AWS Signature Version 4 (SigV4) authentication for HTTPX, supporting both synchronous and asynchronous authentication flows. It includes two main classes:

- `AwsSigV4Auth`: For direct AWS credential authentication
- `AwsSigV4AssumeRoleAuth`: For authentication using AWS IAM Role assumption

## Features

- Simple integration with HTTPX
- Support for both synchronous and asynchronous authentication
- AWS SigV4 signing for API requests
- IAM Role assumption with configurable duration
- Credential expiration and automatic refresh
- Flexible configuration options

## Installation

Install the package using pip:

```bash
pip install httpx-aws-auth
```

## Usage

### Basic AWS Credentials Authentication

```python
import httpx
from httpx_aws_auth import AwsSigV4Auth, AwsCredentials

# Create AWS credentials
credentials = AwsCredentials(
    access_key='YOUR_ACCESS_KEY',
    secret_key='YOUR_SECRET_KEY'
)

# Create an authenticated client
client = httpx.Client(
    auth=AwsSigV4Auth(
        credentials=credentials,
        region='us-west-2',
        service='execute-api'
    )
)

# Make a request
response = client.get('https://your-api-endpoint.com')
```

### IAM Role Assumption (Synchronous)

```python
import boto3
from httpx_aws_auth import AwsSigV4AssumeRoleAuth

# Create AWS session
session = boto3.Session()

# Create an authenticated client with role assumption
client = httpx.Client(
    auth=AwsSigV4AssumeRoleAuth(
        region='us-west-2',
        role_arn='arn:aws:iam::123456789012:role/YourRole',
        session=session,
        duration=timedelta(hours=1)
    )
)

# Make a request
response = client.get('https://your-api-endpoint.com')
```

### IAM Role Assumption (Asynchronous)

```python
import aioboto3
from httpx_aws_auth import AwsSigV4AssumeRoleAuth

# Create async AWS session
async_session = aioboto3.Session()

# Create an authenticated async client with role assumption
async_client = httpx.AsyncClient(
    auth=AwsSigV4AssumeRoleAuth(
        region='us-west-2',
        role_arn='arn:aws:iam::123456789012:role/YourRole',
        async_session=async_session,
        duration=timedelta(hours=1)
    )
)

# Make an async request
async with async_client as client:
    response = await client.get('https://your-api-endpoint.com')
```

## Configuration Options

### AwsSigV4Auth

- `credentials`: AWS credentials object
- `region`: AWS region
- `service`: AWS service name (default: 'execute-api')

### AwsSigV4AssumeRoleAuth

- `region`: AWS region
- `role_arn`: IAM Role ARN to assume
- `service`: AWS service name (default: 'execute-api')
- `session`: Synchronous boto3 session
- `async_session`: Asynchronous aioboto3 session
- `duration`: Credential validity duration (default: 1 hour)
- `refresh_buffer`: Time before expiration to refresh credentials (default: 0 seconds)

## Dependencies

- HTTPX
- boto3 (for synchronous authentication)
- aioboto3 (for asynchronous authentication)
aiohttp-aws-auth 0.0.3
Provides AWS authentication middlewares to be used with aiohttp
Requires Python: >=3.10

# aiohttp-aws-auth

## Overview

This module provides AWS Signature Version 4 (SigV4) authentication for aiohttp through two primary middleware classes:

- `AwsSigV4Auth`: For direct AWS credential authentication
- `AwsSigV4AssumeRoleAuth`: For authentication using AWS IAM Role assumption

## Features

- Simple integration with aiohttp
- Support for both synchronous and asynchronous authentication
- AWS SigV4 signing for API requests
- IAM Role assumption with configurable duration
- Credential expiration and automatic refresh
- Flexible configuration options

## Installation

Install the package using pip:

```bash
pip install aiohttp-aws-auth
```

## Usage

### Basic AWS Credentials Authentication

```python
import aiohttp
from aiohttp_aws_auth import AwsSigV4Auth, AwsCredentials

# Create AWS credentials
credentials = AwsCredentials(
    access_key='YOUR_ACCESS_KEY',
    secret_key='YOUR_SECRET_KEY'
)

# Create an authentication middleware
aws_auth_middleware = AwsSigV4Auth(
    credentials=credentials,
    region='us-west-2',
    service='execute-api',
)


# Make a request
async with ClientSession(middlewares=(aws_auth_middleware,)) as session:
    resp = await session.get("https://your-api-endpoint.com")
```

### IAM Role Assumption

```python
import aioboto3
from aiohttp_aws_auth import AwsSigV4AssumeRoleAuth

# Create async AWS session
session = aioboto3.Session()

# Create an authentication middleware
aws_auth_middleware = AwsSigV4AssumeRoleAuth(
    region='us-west-2',
    role_arn='arn:aws:iam::123456789012:role/YourRole',
    session=session,
    duration=timedelta(hours=1),
)

# Make an async request
async with ClientSession(middlewares=(aws_auth_middleware,)) as session:
    resp = await session.get("https://your-api-endpoint.com")
```

## Configuration Options

### AwsSigV4Auth

- `credentials`: AWS credentials object
- `region`: AWS region
- `service`: AWS service name (default: 'execute-api')

### AwsSigV4AssumeRoleAuth

- `region`: AWS region
- `role_arn`: IAM Role ARN to assume
- `service`: AWS service name (default: 'execute-api')
- `session`: Synchronous boto3 session
- `async_session`: Asynchronous aioboto3 session
- `duration`: Credential validity duration (default: 1 hour)
- `refresh_buffer`: Time before expiration to refresh credentials (default: 0 seconds)

## Dependencies

- aiohttp
- aioboto3 (only needed when using AwsSigV4AssumeRoleAuth)
pytest-freezeblaster 2.1.0
Wrap tests with fixtures in freeze_time
Requires Python: >=3.10

# pytest-freezeblaster

Wrap tests with fixtures in freeze_time

## Features

- Freeze time in both the test and fixtures
- Access the freezer when you need it

## Installation

You can install "pytest-freezeblaster" via `pip` from `PyPI`:

    $ pip install pytest-freezeblaster

## Usage

Freeze time by using the `freezer` fixture:

```python
def test_frozen_date(freezer):
    now = datetime.now()
    time.sleep(1)
    later = datetime.now()
    assert now == later
```

This can then be used to move time:

```python
def test_moving_date(freezer):
    now = datetime.now()
    freezer.move_to('2017-05-20')
    later = datetime.now()
    assert now != later
```

You can also pass arguments to freezegun by using the `freeze_time` mark:

```python
@pytest.mark.freeze_time('2017-05-21')
def test_current_date():
    assert date.today() == date(2017, 5, 21)
```

The `freezer` fixture and `freeze_time` mark can be used together,
and they work with other fixtures:

```python
@pytest.fixture
def current_date():
    return date.today()

@pytest.mark.freeze_time
def test_changing_date(current_date, freezer):
    freezer.move_to('2017-05-20')
    assert current_date == date(2017, 5, 20)
    freezer.move_to('2017-05-21')
    assert current_date == date(2017, 5, 21)
```

They can also be used in class-based tests:

```python
class TestDate:
    @pytest.mark.freeze_time
    def test_changing_date(self, current_date, freezer):
        freezer.move_to('2017-05-20')
        assert current_date == date(2017, 5, 20)
        freezer.move_to('2017-05-21')
        assert current_date == date(2017, 5, 21)
```

## Credits

All credits go to [ktosiek](https://github.com/ktosiek).
urdf-to-casadi 0.1.1
Module for tuning a chain in a URDF to a casadi function. Fork of urdf2casadi by Mathias Hauan Arbo (maharbo).
Requires Python: >=3.11

# urdf_to_casadi

This is a fork with more recent library versions of [urdf2casadi](https://github.com/mahaarbo/urdf2casadi).
pylibsrtp 1.0.0
Python wrapper around the libsrtp library
Requires Python: >=3.10

pylibsrtp
=========

.. image:: https://img.shields.io/pypi/l/pylibsrtp.svg
   :target: https://pypi.python.org/pypi/pylibsrtp
   :alt: License

.. image:: https://img.shields.io/pypi/v/pylibsrtp.svg
   :target: https://pypi.python.org/pypi/pylibsrtp
   :alt: Version

.. image:: https://img.shields.io/pypi/pyversions/pylibsrtp.svg
   :target: https://pypi.python.org/pypi/pylibsrtp
   :alt: Python versions

.. image:: https://github.com/aiortc/pylibsrtp/workflows/tests/badge.svg
   :target: https://github.com/aiortc/pylibsrtp/actions
   :alt: Tests

.. image:: https://img.shields.io/codecov/c/github/aiortc/pylibsrtp.svg
   :target: https://codecov.io/gh/aiortc/pylibsrtp
   :alt: Coverage

.. image:: https://readthedocs.org/projects/pylibsrtp/badge/?version=latest
   :target: https://pylibsrtp.readthedocs.io/
   :alt: Documentation

What is ``pylibsrtp``?
----------------------

``pylibsrtp`` is a Python wrapper around `libsrtp`_, making it possible to
encrypt and decrypt Secure Real-time Transport Protocol (SRTP) packets from
Python code.

SRTP is a profile of the Real-time Transport Protocol (RTP) which provides
confidentiality, message authentication, and replay protection. It is defined
by `RFC 3711`_.

You can install ``pylibsrtp`` with ``pip``:

.. code-block:: console

    $ pip install pylibsrtp

To learn more about ``pylibsrtp`` please `read the documentation`_.

.. _libsrtp: https://github.com/cisco/libsrtp

.. _RFC 3711: https://tools.ietf.org/html/rfc3711

.. _read the documentation: https://pylibsrtp.readthedocs.io/en/stable/

Example
-------

.. code:: python

    #!/usr/bin/env python

    from pylibsrtp import Policy, Session

    key = (b'\x00' * 30)
    rtp = b'\x80\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + (b'\xd4' * 160)

    # protect RTP
    tx_policy = Policy(key=key, ssrc_type=Policy.SSRC_ANY_OUTBOUND)
    tx_session = Session(policy=tx_policy)
    srtp = tx_session.protect(rtp)

    # unprotect RTP
    rx_policy = Policy(key=key, ssrc_type=Policy.SSRC_ANY_INBOUND)
    rx_session = Session(policy=rx_policy)
    rtp2 = rx_session.unprotect(srtp)

    # check roundtrip worked!
    assert rtp2 == rtp

Building pylibsrtp
------------------

If you wish to build pylibsrtp yourself, you will need libsrtp version 2.0 or better.

Linux
.....

On Debian/Ubuntu run:

.. code-block:: console

    $ apt install libsrtp2-dev

On Fedora/CentOS run:

.. code-block:: console

    $ dnf install libsrtp-devel

macOS
.....

On macOS run:

.. code-block:: console

    $ brew install srtp

You will need to set some environment variables to link against libsrtp:

.. code-block:: console

   export CFLAGS=-I$(brew --prefix openssl)/include -I$(brew --prefix srtp)/include
   export LDFLAGS=-L$(brew --prefix openssl)/lib -L$(brew --prefix srtp)/lib

License
-------

``pylibsrtp`` is released under the `BSD license`_.

.. _BSD license: https://pylibsrtp.readthedocs.io/en/stable/license.html
nginx-config-lint 0.1.1
CLI tool for linting nginx jinja2 templates
Requires Python: >=3.13

## Nginx Config Lint

CLI tool for linting nginx jinja2 templates from `nginx/dev.conf` and `nginx/pr.conf`

## How to upload to pip

Install `twine`

`python3 -m pip install --upgrade twine`

- Bump version in `pyproject.toml`
- Build Package (`python3 -m build`)
- Upload Package (`python3 -m twine upload dist/*`)