semvec/pypi-packages huggingface dataset:
prt-rl 0.6.2
Python Research Toolkit - Reinforcement Learning
Requires Python: >=3.11

<p align="center">
<picture>
<img src="docs/_static/prt-rl-logo-title.png" width="400" style="max-width: 100%;">
</picture>
</p>

**prt-rl** is part of the broader *Python Research Toolkit* ecosystem and provides a clean, mathematically grounded collection of reinforcement learning algorithms.  
Its primary goal is **clarity, pedagogy, and research exploration**—not raw performance.

This library is designed for researchers, students, and practitioners who want to understand *why* RL algorithms work, how their mathematics map to code, and what practical implementation details matter in real systems.

Unlike high-performance libraries such as **TorchRL**, **RLlib**, and **skrl**, **prt-rl focuses on transparency, composability, and conceptual depth**. Every algorithm is implemented with an emphasis on readability, modularity, and annotated code that highlights both the underlying equations and the implementation tips that make them work in practice.

>⚠️ **Note:** This repository is under active development. APIs, file structure, and module organization may change as the project evolves. Backward compatibility is not guaranteed until version 1.0.


## Documentation

**Installation, Getting Started, and API guides can be found in the full documentation:**

➡️ https://prt-rl.readthedocs.io/en/latest/

---

## Contributing

Contributions are welcome!  
Please open an issue before submitting a pull request so that new features or bug fixes can be discussed beforehand.
frontblok-deploy 0.4.1
Deployment engine for React SPA frontends — Docker + GHCR + Kubernetes
Requires Python: >=3.10
Keywords: deploy, docker, frontend, kubernetes, react, vite

# frontblok-deploy

Deployment engine for React SPA frontends. Extracts all reusable deployment infrastructure into one Python package.

**One package. One pattern. Every frontend.**

## What it owns

- **Dockerfile** — Multi-stage node:20-alpine → nginx:1.25-alpine build
- **nginx.conf** — Security-hardened config with parameterized CSP
- **k8s/deployment.yaml** — Full Kubernetes manifest with placeholder replacement
- **Deploy engine** — The 10-step chain: env → validate → generate files → git sha → docker build → push → namespace → secret → apply → rollout

## What each app provides

Each frontend repo's `deploy.py` is pure config — declaring what makes THIS app different:

```python
#!/usr/bin/env python3
from frontblok_deploy import FrontendDeployer

FrontendDeployer(
    vite_args=[
        "VITE_DATABASE_API_URL",
        "VITE_BUSINESS_LOGIC_API_URL",
        "VITE_GOOGLE_CLIENT_ID",
    ],
    required_vars=[
        "VITE_DATABASE_API_URL",
        "VITE_GOOGLE_CLIENT_ID",
    ],
    csp_sources={
        "script_src": "https://js.stripe.com https://accounts.google.com https://apis.google.com https://cdn.jsdelivr.net",
        "style_src": "https://fonts.googleapis.com https://accounts.google.com https://cdn.jsdelivr.net",
        "font_src": "https://fonts.gstatic.com https://fonts.googleapis.com",
        "frame_src": "https://js.stripe.com https://hooks.stripe.com https://accounts.google.com",
    },
).deploy()
```

That's it. No Dockerfile, no nginx.conf, no K8s manifest needed in the repo. The package generates them at deploy time.

## Install

```bash
pip install frontblok-deploy
# or for development
pip install -e /path/to/frontblok-deploy
```
aiocluster 1.1.0
aiocluster
Requires Python: >=3.13
Keywords: gossip, chitchat, aiocluster, ScuttleButt

# aiocluster

[![GitHub Actions status for master branch](https://github.com/jettify/aiocluster/workflows/CI/badge.svg)](https://github.com/jettify/aiocluster/actions?query=workflow%3ACI)
[![Codecov](https://codecov.io/gh/jettify/aiocluster/branch/master/graph/badge.svg)](https://codecov.io/gh/jettify/aiocluster)
[![Python Versions](https://img.shields.io/pypi/pyversions/aiocluster.svg)](https://pypi.org/project/aiocluster)
[![PyPI Version](https://img.shields.io/pypi/v/aiocluster.svg)](https://pypi.python.org/pypi/aiocluster)

**aiocluster** is a Python 3.11+ module for distributed systems management, enabling cluster membership tracking, failure detection, configuration sharing, and metadata management. It facilitates scalable and fault-tolerant application sharding through robust cluster coordination capabilities.

## References

- ScuttleButt paper: <https://www.cs.cornell.edu/home/rvr/papers/flowgossip.pdf>
- Phi Accrual error detection: <https://www.researchgate.net/publication/29682135_The_ph_accrual_failure_detector>
- chitchat <https://github.com/quickwit-oss/chitchat/blob/main/README.md>

## Requirements

- Python 3.11+.
- protobuf

## Usage

```python
import asyncio
import logging

from aiocluster import Cluster
from aiocluster import Config
from aiocluster import NodeId


async def main():
    node1_id = NodeId(name="simple1", gossip_advertise_addr=("127.0.0.1", 7000))
    node2_id = NodeId(name="simple2", gossip_advertise_addr=("127.0.0.1", 7001))
    node3_id = NodeId(name="simple3", gossip_advertise_addr=("127.0.0.1", 7002))

    config1 = Config(
        node_id=node1_id,
        gossip_interval=1,
        seed_nodes=[("127.0.0.1", 7002)],
        cluster_id="simple-aiocluster",
    )
    config2 = Config(
        node_id=node2_id,
        gossip_interval=1,
        seed_nodes=[("127.0.0.1", 7000)],
        cluster_id="simple-aiocluster",
    )
    config3 = Config(
        node_id=node3_id,
        gossip_interval=1,
        seed_nodes=[("127.0.0.1", 7001)],
        cluster_id="simple-aiocluster",
    )

    cluster1 = Cluster(config1, initial_key_values={"cluster": "1"})
    cluster2 = Cluster(config2, initial_key_values={"cluster": "2"})
    cluster3 = Cluster(config3, initial_key_values={"cluster": "3"})

    async with cluster1, cluster2, cluster3:
        await asyncio.sleep(10)


if __name__ == "__main__":
    logging.basicConfig(level=logging.DEBUG)
    asyncio.run(main())
```
shtns 3.7.5
High performance Spherical Harmonic Transform
Requires Python: >=3.2

This is the python module to use **SHTns, a high performance spherical harmonic transform and rotation** library.
It requires FFTW installed in your system.

## GETTING STARTED

### Basic Installation:
- make sure FFTW is installed in your system; if not, install it using your system package manager.
- run:

    `pip install shtns`

This simple installation should work and be enough for most use cases.
However, **in order to have the highest possible performance, FFTW should be compiled and tuned for your machine**,
which is not the case with pre-compiled system packages.

### Cuda GPU support:
Make sure the environment variable `CUDA_PATH` points to the installed cuda toolkit before running `pip install shtns`.
This will automatically add transparent support for nvidia gpus, in "offload" mode (that means data transfers are
performed by shtns).

### Example code:
See <https://bitbucket.org/nschaeff/shtns/src/master/examples/SHT_example.py>
and <https://bitbucket.org/nschaeff/shtns/src/master/examples/shallow_water.py>.
For using the GPU from python, see <https://bitbucket.org/nschaeff/shtns/src/master/examples/SHT_gpu_example.py>

## MORE INFO
See <https://bitbucket.org/nschaeff/shtns/src/master/README.md>
signalcend 0.1.0
Resolve device states instantly - Deterministic IoT state resolution
Requires Python: >=3.8

# SignalCend

Resolve device states instantly. Deterministic state resolution for IoT fleets.

## Quickstart

```python
pip install signalcend

from signalcend import Client

client = Client(api_key="sk-demo-your-key")
result = client.resolve({
    "device_1": [{"timestamp": 1739273600, "value": "online"}]
})
print(result.resolved_state)  # {"device_1": "online"}
docassemble.LAWVWillsClinic 1.0.6
A docassemble extension for creating a basic will during a LAWV Will Clinic

A guided interview for creating a Last Will and Testatment for a LAWV Will Clinic.  The interview assumes that it is going to be completed by an attorney or paralegal assisting in the clinic after the client has already submitted a Will Clinic questionnaire.  The interview seeks biographical information about the testator and family.  It then seeks specific gifts, general gifts, residual assignees, executors, and guardians. The interview produces a Word document to allow for final edits.