semvec/pypi-packages huggingface dataset:
ygo 1.2.18
一个轻量级 Python 工具包，支持 并发执行（带进度条）、延迟调用、链式绑定参数、函数信息获取、模块/函数动态加载。
Requires Python: >=3.12

# ygo
一个轻量级 Python 工具包，底层基于 joblib 和 tqdm 、loguru 实现，支持
- 并发执行（带进度条）
- 延迟调用
- 链式绑定参数
- 函数信息获取
- 模块/函数动态加载...
- 并结合 ylog 提供日志记录能力

### 安装
```shell
pip install -U ygo
```

### 🧰 功能概览

| 模块   | 功能                                                         |
| :----- | :----------------------------------------------------------- |
| `ygo`  | 支持并发执行（带进度条）、延迟调用、函数信息获取以及模块/函数动态加载等功能 |
| `ylog` | 日志模块，提供统一的日志输出接口                             |

### 示例

```
├── a
│   ├── __init__.py
│   └── b
│       ├── __init__.py
│       └── c.py
└── test.py

c.py 中定义了目标函数
def test_fn(a, b=2):
    return a+b
```

#### 场景1: 并发执行

```python
import ygo
import ylog
from a.b.c import test_fn

with ygo.pool(n_jobs=5, show_progress=True) as go:
    for i in range(10):
        go.submit(test_fn)(a=i, b=2*i)
    for res in go.do():
        ylog.info(res)
```

#### ✅ `ygo.pool` 支持的参数

| 参数名        | 类型 | 描述                                                         |
| ------------- | ---- | ------------------------------------------------------------ |
| n_jobs        | int  | 并行任务数(<=1 表示串行)                                     |
| show_progress | bool | 是否显示进度条                                               |
| backend       | str  | 执行后端（默认 'threading'，可选 'multiprocessing' 或 'loky'） |

#### 场景2: 延迟调用

```
>>> fn = delay(test_fn)(a=1, b=2)
>>> fn()
3
>>> # 逐步传递参数
>>> fn1 = delay(lambda a, b, c: a+b+c)(a=1)
>>> fn2 = delay(fn1)(b=2)
>>> fn2(c=3)
6
>>> # 参数更改
>>> fn1 = delay(lambda a, b, c: a+b+c)(a=1, b=2)
>>> fn2 = delay(fn1)(c=3, b=5)
>>> fn2()
9
```

#### 场景3: 获取目标函数信息

```
>>> ygo.fn_info(test_fn)
=============================================================
    a.b.c.test_fn(a, b=2)
=============================================================
    def test_fn(a, b=2):
    return a+b
```

#### 🔍 其他函数信息工具

| 方法名                    | 描述                                     |
| ------------------------- | ---------------------------------------- |
| `fn_params(fn)`           | 获取函数实参                             |
| `fn_signature_params(fn)` | 获取函数定义的所有参数名                 |
| `fn_code(fn)`             | 获取函数源码字符串                       |
| `fn_path(fn)`             | 获取函数所属模块路径                     |
| `fn_from_str(s)`          | 根据字符串导入函数（如 "a.b.c.test_fn"） |
| `module_from_str(s)`      | 根据字符串导入模块                       |

#### 场景4: 通过字符串解析函数并执行

```
>>> ygo.fn_from_str("a.b.c.test_fn")(a=1, b=5)
6
```
iperf3-lib 0.1.0
Modern Python wrapper for iperf3 using cffi (libiperf), with async support.
Requires Python: >=3.12
Keywords: MPTCP, SCTP, async, benchmark, cffi, iperf3, network, throughput

# iperf3-lib

Modern Python wrapper for **iperf3** using **cffi** against **libiperf**.  
- Typed configs/results (Pydantic)
- Sync + Async APIs
- Feature detection for SCTP / bidirectional / MPTCP (when lib supports it)
- Ready for `uv` workflows, ruff/ty/pytest

## Quickstart

```bash
# create env & install
uv venv
source .venv/bin/activate
uv pip install -e ".[dev]"
```

You need a system libiperf (install iperf3 via your package manager).
To point to a non-standard library path:

```bash
export IPERF3_LIB=/usr/local/lib/libiperf.so
```

```python
from iperf3_lib.config import ClientConfig, Protocol
from iperf3_lib.iperf_client import Client

cfg = ClientConfig(server="127.0.0.1", duration=2, protocol=Protocol.TCP, parallel=2)
res = Client(cfg).run()
print("OK:", res.ok, "Mbps:", f"{res.summary_mbps:.2f}", "err:", res.error)
```
Notes
* Full features require a recent libiperf (iperf3 ≥ 3.19.x recommended).
* Some symbols may not exist on older builds; we detect and degrade gracefully.
* Integration tests are marked with @pytest.mark.integration.

---

## Running tests

- Run tests locally with Docker (recommended for Windows):

```bash
# build the test image (pick python base and iperf version if needed)
docker build --build-arg PYTHON_BASE=python:3.12-slim --build-arg IPERF3_VERSION=3.20 -t py-iperf3-test .

# run the full test suite inside the container (mounted volume allows editing without rebuilding)
docker run --rm -v "$(pwd):/app" py-iperf3-test bash -c "pytest -vv --cov=src --cov-report=term-missing"
```

- Quick single-test run (example):

```bash
docker run --rm -v "$(pwd):/app" py-iperf3-test bash -c "pytest -q tests/test_client_integration_configs.py::test_client_various_configs\[udp_rate\] -vv"
```

Notes about optional features
- MPTCP and some other features are optional and require the libiperf to be built with kernel/header support. Tests that exercise optional features will be skipped or xfailed depending on whether the built shared object exports the required symbol.

CI
- This repository includes a GitHub Actions workflow that builds and runs the tests inside the Docker image for a matrix of Python base images and iperf versions (see `.github/workflows/ci.yml`).

---

```markdown
# Changelog

## 0.1.0
- Initial release: cffi (ABI) wrapper of libiperf (client & server),
  Pydantic models, async support, ruff/ty/pytest, CI with uv.

```
olang-resolver-test 0.1.5
O-lang resolver conformance and certification toolkit
Requires Python: >=3.9

﻿# O-Lang Resolver Test Suite

Language-agnostic conformance and certification tests for **O-Lang resolvers**.

O-Lang resolvers are executable contracts: small, deterministic units that perform actions described in O-Lang.  
This test suite ensures that resolvers behave **consistently, predictably, and safely** across **all programming languages that understand JSON**.

---

## TL;DR

- One contract
- One test suite
- Any programming language
- Deterministic, auditable resolvers

If your resolver passes these tests, it is **O-Lang compliant**.

---

## What This Test Suite Does

The O-Lang Resolver Test Suite validates that a resolver:

- Declares required metadata (`resolverName`, `version`)
- Exposes a valid `resolve(input)` entry point
- Accepts structured JSON input
- Returns a strictly shaped response:
  - `{ "output": ... }` **or**
  - `{ "error": ... }`
- Fails explicitly and predictably
- Behaves deterministically (same input → same output)

The **same tests** apply whether your resolver is written in:

- Python
- JavaScript (Node.js)
- Go
- Rust
- Java
- Or **any language capable of JSON I/O**

---

## Why This Exists

Most systems don’t fail because of syntax errors.  
They fail because **contracts are unclear**.

Without resolver conformance testing:

- Every resolver invents its own response format
- Error handling becomes inconsistent
- Cross-language execution breaks silently
- Tooling cannot reason about behavior

O-Lang solves this by enforcing resolver contracts with a shared, language-agnostic test suite.

---

## Documentation & Guide

For a full walkthrough covering:

- Resolver contracts
- Test philosophy
- Python and JavaScript examples
- Cross-language guarantees

Read the official Medium article:

👉 **How to Test O-Lang Resolvers in Python and JavaScript**  
https://medium.com/@o-lang/how-to-test-o-lang-resolvers-in-python-and-javascript-07e6fab4385f

---

## Typical Resolver Structure

```text
resolver-your-action/
├── resolver.py        # or index.js, main.go, etc.
├── resolver.json
└── tests/
    ├── R-005-resolver-metadata-contract.json
    ├── R-006-resolver-runtime-shape.json
    ├── R-007-resolver-failure-contract.json
    └── ...
p1-taskqueue 0.1.32
A Task Queue Wrapper for Dekoruma Backend
Requires Python: >=3.11

# TaskQueue

A Task Queue Wrapper for Dekoruma Backend

## Description

TaskQueue is a Python package that provides a  wrapper around Celery for task queue management. It includes automatic queue setup, Dead Letter Queue (DLQ) routing, and dynamic task execution capabilities.


## Deploy
- Push changes to main
- Create new TAG with version name (i.e 0.1.3)
- Check status on the Actions page on Github
asanAI 426
Tools to help with the scripts created by asanAI

# asanAI Python Module

[![Release Workflow](https://github.com/NormanTUD/asanAI_python/actions/workflows/release.yml/badge.svg?event=push)](https://github.com/NormanTUD/asanAI_python/actions/workflows/release.yml)

**asanAI** is a Python module that allows you to execute scripts generated from machine learning models created in [asanAI](https://asanai.scads.ai/). It handles all necessary conversions from TensorFlow.js to Python and provides seamless integration for running, visualizing, and interacting with models locally.

> ⚠️ **Note:** Users typically do not need to install this module manually. It is automatically handled by the scripts generated by asanAI.

---

## Features

- Execute scripts generated from asanAI directly in Python.
- Automatic conversion of TensorFlow.js models to Python TensorFlow (Keras) format.
- Support for **TensorFlow Sequential models**.
- Visualization support for:
  - Webcam input
  - Static image input
  - Simple and complex image outputs
  - Classification outputs with labeled probabilities
- Beginner-friendly while still supporting advanced usage.

---

## Getting Started

1. **Create model**
   On [asanAI](https://asanai.scads.ai/), create and train a model

2. **Download your model**
   On [asanAI](https://asanai.scads.ai/), click **Code** and there, **"Download model data"** (or *"Modelldaten downloaden"*). Place the downloaded file in the same folder as your generated Python script.

3. **Run the script**

```bash
python3 your_script.py          # Predict using webcam or default behavior
python3 your_script.py 1.jpg 2.jpg 3.jpg  # Predict on specific images
bayesml 0.4.1
Your First Library for Bayesian Machine Learning
Requires Python: ~=3.7

## Purpose

BayesML contributes to wide society thourgh promoting education, 
research, and application of machine learning based on Bayesian 
statistics and Bayesian decision theory.

## Characteristics

* **Easy-to-use:**
  * You can use pre-defined Bayesian statistical models by simply importing it. 
    You don't need to define models yourself like PyMC or Stan.
* **Bayesian Decision Theoretic API:**
  * BayesML's API corresponds to the structure of decision-making based on 
    Bayesian decision theory. Bayesian decision theory is a unified framework for 
    handling various decision-making processes, such as parameter estimation and 
    prediction of new data. Therefore, BayesML enables intuitive operations for 
    a wider range of decision-making compared to the fit-predict type API adopted in 
    libraries like scikit-learn. Moreover, many of our models also implement 
    fit-predict functions.
* **Model Visuialization Functions:**
  * All packages have methods to visualize the probabilistic data generative model, 
    generated data from that model, and the posterior distribution learned from 
    the data in 2~3 dimensional space. Thus, you can effectively understand 
    the characteristics of probabilistic data generative models and algorithms through 
    the generation of synthetic data and learning from them.
* **Fast Algorithms Using Conjugate Prior Distributions:**
  * Many of our learning algorithms adopt exact calculation methods or variational 
    Bayesian methods that effectively use the conjugacy between probabilistic data 
    generative models and prior distributions. Therefore, they are much faster than 
    general-purpose MCMC methods and are also suitable for online learning. 
    Although some algorithms adopt MCMC methods, but they use MCMC methods specialized 
    for each model, taking advantage of conjugacy.
escape-sdk 2.2.1
OSRS Bot Development SDK with game-native structure
Requires Python: >=3.12
Keywords: osrs, runescape, bot, automation, sdk

# Escape SDK

Python SDK for OSRS bot development via RuneLite bridge.

## Requirements

- Python 3.12+
- Linux with inotify support
- RuneLite with Escape plugin

## Installation

```bash
pip install escape-sdk
```

## Development

```bash
git clone https://github.com/OSEscape/escape_sdk.git
cd escape_sdk
uv sync --all-extras
pre-commit install
```

```bash
make test      # Run all checks (ruff, basedpyright, skylos, pytest)
make format    # Auto-format and fix linting issues
```

## Contributing

We use [Conventional Commits](https://www.conventionalcommits.org/) for automated versioning and changelog.

| Type | Bump | Example |
|------|------|---------|
| `feat` | Minor | `feat(bank): add deposit-all` |
| `fix` | Patch | `fix: resolve crash on empty inventory` |
| `feat!` | Major | `feat!: redesign API` |
| `docs`, `refactor`, `test`, `chore` | — | `chore: update deps` |

Push to `main` triggers automatic release to PyPI.

## License

MIT