semvec/pypi-packages huggingface dataset:
viorina 2025.7.8
Light-weight minimal API Fuzzer in Python
Requires Python: >=3.12

```plaintext
  _     _ _             _             
(_)   (_|_)           (_)            
 _     _ _  ___   ____ _ ____  _____ 
| |   | | |/ _ \ / ___) |  _ \(____ |
 \ \ / /| | |_| | |   | | | | / ___ |
  \___/ |_|\___/|_|   |_|_| |_\_____|
                                     
Light-weight minimal API Fuzzer in Python
```

**Viorina** is a minimalist, lightweight API-fuzzing tool.  
Describe your payload once—Viorina generates compliant, random test data for you.

#### It stays tiny

* **Declarative schemas** – Register any model with `@Viorina.payload` (FastAPI-style, zero boiler-plate).  
* **Descriptor magic** – Python’s descriptor protocol auto-wires parent/child fields, so you don’t have to.  
* **Accurate text fuzzing** – Uses the Rust crate **`regex-generate`** to create strings that match your exact pattern.

# Examples
#### Use `@app.payload` to register
- Describe your payload structure and call `Viorina.build_dict()` at the end
```python
import viorina            # For `app = viorina.Viorina()`
from viorina import Auto  # For describing schema


app = viorina.Viorina()


# Use `app.payload` to register
@app.payload
class Root:           # ... its child node `BranchA` not defined yet ...
    BranchA = Auto()  # => {"Root": { "BranchA": { ... } } }
    Name = "Anji"     # => {"Root": { "Name": "Anji", "BranchA": { ... } } }
    

@app.payload
class BranchA:        # ... the node `BranchA` defined later ...
    Age = 233         # => { "BranchA": { "Age": 233 } }
    

p = app.build_dict()  # ... build payload

# 
# {'Root': 
#     {'Name': 'Anji', 
#      'BranchA': {'Age': 233}
#     }
# }
```
#### Use descriptors to generate random data for fuzz testing
- Use `Text`, `Integer`, `Auto` descriptors to generate **random** mock values
```python
from viorina import Text, Integer, Auto, Viorina


app = Viorina()


@app.payload
class Root:
    SomeNode = Auto()
    RandomValue = Integer(min_value=233, max_value=235)


@app.payload
class SomeNode:
    RandomName = Text(regex=r'[AEIOU][aeiou][rnmlv][aeiou]{2}')
    ChildNode = Auto()
    RandomValue = Integer(min_value=0, max_value=9)


@app.payload
class ChildNode:
    ConstValue: int = 233


if __name__ == "__main__":
    import pprint
    
    for _ in range(3):
        pprint.pp(app.build_dict())
        
# Output:
        
# {'Root': {'RandomValue': 235,
#           'SomeNode': {'RandomName': 'Eolee',
#                        'RandomValue': 5,
#                        'ChildNode': {'ConstValue': 233}}}}
# {'Root': {'RandomValue': 235,
#           'SomeNode': {'RandomName': 'Aarei',
#                        'RandomValue': 7,
#                        'ChildNode': {'ConstValue': 233}}}}
# {'Root': {'RandomValue': 234,
#           'SomeNode': {'RandomName': 'Uovai',
#                        'RandomValue': 1,
#                        'ChildNode': {'ConstValue': 233}}}}
```
osilicense 0.1.0
Add your description here
Requires Python: >=3.10

# osilicense: OSI License CLI & Python Package

osilicense is a Python package and command-line tool for listing, searching, and viewing details of OSI Approved Licenses® using the official OSI API.

## Features
- List all OSI Approved Licenses®
- View details for a specific license by SPDX ID
- Search licenses by name
- Automatic suggestions for similar licenses if a license is not found
- Usable as a standalone CLI or as a Python package

## Installation

### Using pip (editable mode for development)
```bash
pip install -e .
```
Or with [uv](https://github.com/astral-sh/uv):
```bash
uv pip install -e .
```

### Requirements
- Python 3.8+
- `requests` and `tabulate` Python packages

## Usage

### CLI
After installation, use the `osilic` command:

- List all licenses:
  ```bash
  osilic
  ```
- Show details for a license by SPDX ID:
  ```bash
  osilic gpl-3-0
  ```
- Search licenses by name:
  ```bash
  osilic -s gpl
  ```
- If a license is not found, the CLI will suggest similar licenses automatically.

### As a Python Package
You can also use OLC in your own Python code:
```python
from olc.model import license_from_dict, print_licenses_table, print_license_details_table
import requests

resp = requests.get("https://opensource.org/api/license")
licenses = license_from_dict(resp.json())
print_licenses_table(licenses)
```

## API Reference
- List all licenses: `https://opensource.org/api/license`
- License details: `https://opensource.org/api/license/{spdx-id}`
- Search licenses: `https://opensource.org/api/license?name={search_key}`

## Reference & Further Reading
- Official OSI API Blog Post: [Introducing the New API for OSI Approved Licenses](https://opensource.org/blog/introducing-the-new-api-for-osi-approved-licenses)
- For more information on OSI licenses, visit [opensource.org](https://opensource.org/licenses).

## Development
- Source code: [GitHub](https://github.com/dineshr93/olc)
- Issues and contributions welcome!

## License
This project is licensed under the Creative Commons Attribution-ShareAlike 3.0 Unported (CC BY-SA 3.0) License.

Copyright © 2025 Dinesh R

See [LICENSE](LICENSE) for details.

## Author
- Dinesh R

## Changelog
See [CHANGELOG.md](CHANGELOG.md) for a list of all commits and changes.

---
For more information on OSI licenses, visit [opensource.org](https://opensource.org/licenses).
ros2-installer 0.1.3
Unofficial CLI tool for installing ROS 2 and setting up a workspace
Requires Python: >=3.8

# ros2-installer


A CLI tool to install ROS 2 distributions easily from the official repositories.

## Disclaimer

This tool installs ROS 2 from the official repositories but is **not an official ROS release**. Use at your own risk.

> The owner of this project, platform, or service shall not be held liable for any loss, damage, or corruption of data, whether caused by system failures, user errors, or any other unforeseen circumstances. By using this service, you acknowledge and agree that you are solely responsible for backing up and protecting your data.

---

## Features

- Interactive ROS 2 distro selection (e.g., humble, iron)
- Automatic locale setup
- Workspace creation
- Optionally appends sourcing commands to `.bashrc`
- Headless mode (non-interactive) with all options specified via CLI arguments
- Works on Ubuntu 22.04+

---

## Installation

```bash
pip install ros2-installer
```

---

## Usage

### Interactive Mode

Just run:

```bash
ros2-installer
```

You will be prompted step by step to:

- Choose the ROS 2 distro (humble or iron)
- Confirm installation
- Specify workspace name and location
- Choose whether to auto-source in `.bashrc`

---

### Headless Mode

If you want to run everything non-interactively (e.g., in CI pipelines or Docker), you can pass all required arguments:

```bash
ros2-installer \
  --distro humble \
  --workspace ~/ros2_ws \
  --yes \
  --auto-source
```

**Arguments:**

| Argument            | Description                                                  |
|---------------------|--------------------------------------------------------------|
| `--distro`          | ROS 2 distro to install (`humble`, `iron`)                   |
| `--workspace`       | Path to create the workspace                                 |
| `--yes`             | Automatically confirm all prompts                            |
| `--auto-source`     | Automatically append sourcing commands to `.bashrc`          |

Example:

```bash
ros2-installer --distro humble --workspace ~/ros2_ws --yes --auto-source
```

---
## Bug-Report
- Raise an issue in the [github repository](https://github.com/mohammedrashithkp/ros2-installer)
## License

[MIT](./LICENSE)
cli-string 0.1.2
This CLI tool analyzes a string or a file containing strings and outputs **only the characters that appear exactly once** in each line (case-insensitive). Additionally, it measures the execution time of the function call.
Requires Python: >=3.12

# Unique Characters in a String

This CLI tool analyzes a string or a file containing strings and outputs **only the characters that appear exactly once** in each line (case-insensitive). Additionally, it measures the execution time of the function call.

---

## 🔍 Features

- ✅ Detects **unique characters only** (characters that appear exactly once).
- 🔠 **Case-insensitive** comparison (e.g., `'A'` and `'a'` are treated as the same).
- ♻️ **Result caching** with `functools.lru_cache` for optimized repeated calls.
- ⏱ **Execution time logging** using the custom `perf_counter_deco` decorator.

---

## 📦 Installation

1. Make sure you're using **Python 3.12** or later.
2. Install the package locally or from a distribution (if published):

```bash
pip install cli_string
```
or
```bash
poetry add cli_string
```
⸻

🚀 Usage


Analyze a single string:

```cli_string --string "Example"```

Analyze lines from a file:

```cli_string --file path/to/file.txt```

⚠️ If both --string and --file are provided, the file input takes precedence.

Provide both string and file:

```cli_string --file path/to/file.txt --string "Example"```

If no arguments are provided:

Please provide a string or a file with lines to process.


⸻

📤 Example Output

String: 'Hello, World' => Unique characters: he, wrd


⸻

🧠 Function Breakdown

count_chars_in_string(s: str) -> str
	•	Validates input type and non-emptiness.
	•	Uses collections.Counter to identify characters that appear only once.
	•	Returns the resulting characters in lowercase.
	•	Output is cached using @lru_cache.
	•	Execution time is measured with the @perf_counter_deco.

main()
	•	Parses command-line arguments:
	•	--string: input string to analyze.
	•	--file: path to a file containing strings.
	•	Prioritizes file input if both are passed.
	•	Prints formatted results for each line.
	•	Handles missing arguments gracefully.

⸻

📁 Project Structure

cli_string/
├── __init__.py
├── main.py
├── utils.py
pyproject.toml
README.md


⸻

👨‍💻 Author

Daniel Kravchenko
📧 daniel.kravchenko@protonmail.com

⸻

📄 License

Distributed under the MIT License.

---
sb-on-demand-randomness 1.0.1
Switchboard On Demand Randomness Python SDK
Requires Python: >=3.8

# Switchboard On Demand Randomness Python SDK

Python SDK for interacting with Sb On Demand Randomness.

## Install 

```bash
pip install sb-on-demand-randomness
```

## Usage

see main.py

## Deps
- solders
- spl-token
- solana
solar-circuit 0.1.3
CLI-based AI development framework
Requires Python: >=3.10

# solar-circuit-v2

[![CI](https://github.com/seishinshigo/solar_circuit_v2/actions/workflows/ci.yml/badge.svg)](https://github.com/seishinshigo/solar_circuit_v2/actions/workflows/ci.yml)
[![Codecov](https://codecov.io/gh/seishinshigo/solar_circuit_v2/branch/main/graph/badge.svg)](https://codecov.io/gh/seishinshigo/solar_circuit_v2)
[![Coverage](https://codecov.io/gh/あなたのユーザー名/solar_circuit_v2/branch/main/graph/badge.svg)](https://codecov.io/gh/あなたのユーザー名/solar_circuit_v2)
[![PyPI version](https://badge.fury.io/py/solar-circuit.svg)](https://pypi.org/project/solar-circuit/)
[![License](https://img.shields.io/github/license/seishinshigo/solar_circuit_v2)](LICENSE)

> “Markdown 1 枚 × 最小コマンド” で AI 主導開発を完遂する CLI ワークフロー
> Python 3.12｜Typer｜GitHub Actions｜pytest＋coverage｜OS Keyring

---

## 🎯 目的・ゴール

* **ソロ開発者向け** に、Markdown＋CLI だけで日々の開発ワークフローを完結
* **MVP**：`init` → `new` → `save` → `finish` の 4 コマンドで基本サイクルを実現
* **拡張ロードマップ** に基づき、今後もコマンドを追加予定

---

## 🚀 特徴

* **シンプルなプロジェクト初期化**：`sc init` でテンプレート一式を展開
* **Work Order 自動管理**：`sc new` で作業票を自動採番＆Markdown生成
* **開発メモ追記**：`sc save` で日付ヘッダー付きに統一ファイルへ記録
* **ステータス可視化**：`sc status` でメモ／未完了 WO／添付・出力ファイルを一覧
* **作業指示書一覧**：`sc list` で既存 WO をテーブル表示
* **ファイル添付**：`sc attach` で資料や成果物を attachments/outbound に整理
* **CLI 完結**：Gemini API 鍵は OS Keyring に安全保存
* **テストカバレッジ**：pytest＋coverage ≥80%
* **CI**：GitHub Actions で lint／pytest／coverage／（将来的に markdownlint）自動チェック

---

## 📦 インストール

```bash
# Python 3.12 を用意
git clone https://github.com/seishinshigo/solar_circuit_v2.git
cd solar_circuit_v2
python -m venv .venv
source .venv/bin/activate

# 本体インストール
pip install -e .

# 開発用（テスト・lint）を整える場合
pip install -e .[dev]
```

---

## 📸 コマンドリファレンス（実行例）

Solar Circuit CLI の各コマンド操作を VSCode ターミナル上で実行した様子
（`new` → `save` → 不正 → 対象ファイル無し → `list` など、一連の典型的操作のデモ）

![スクリーンショット](docs/images/ss800_01.png)

---

### `sc init`

```bash
sc init
```

プロジェクトの雛形をカレントディレクトリにコピーします。
`.sc/`, `work_orders/`, `attachments/`, `outbound/` などを生成。

---

### `sc new [--id <ID>]`

```bash
sc new
sc new --id WO-20250713-005
```

新しい Work Order を作成します。
ID は自動または手動で指定可能。

---

### `sc save`

```bash
sc save
```

`dev_memory.md` に今日のメモを追記します。エディタが立ち上がり、編集内容が保存されます。

---

### `sc attach [--name <NAME>] <ファイルパス>`

```bash
sc attach report.pdf
sc attach --name summary.docx path/to/file.docx
```

ファイルを `attachments/` にコピーします。

---

### `sc outbound [--name <NAME>] <ファイルパス>`

```bash
sc outbound data.csv
```

ファイルを `outbound/` ディレクトリにコピーします。

---

### `sc status`

```bash
sc status
```

以下の情報を一覧表示します：

* Today’s Memory（最新メモ）
* Open Work Orders
* Attachments / Outbound のファイル数と容量

---

### `sc list [--open] [--closed]`

```bash
sc list
sc list --open
sc list --closed
```

作業指示書（WO）をテーブル形式で一覧表示します。オプションで絞り込み可能。

---

### `sc version`

```bash
sc version
# → solar-circuit-v2 version 0.1.x
```

CLI のバージョンを表示します。

---

### `sc help`

```bash
sc help
sc <command> --help
```

各コマンドのヘルプを表示します。

---

## ✅ Quickstart

```bash
pip install solar-circuit-v2
mkdir my-solar-project
cd my-solar-project
sc init
sc new
sc save
sc status
sc list
```

---

This project is licensed under the MIT License.
compost-rpc 0.6.0
Compost RPC protocol generator
Requires Python: >=3.10
Keywords: protocol, RPC, MCU, embedded

# Compost

Compost is a Remote Procedure Call ([RPC](https://en.wikipedia.org/wiki/Remote_procedure_call))
protocol generator with a simple wire format.

It abstracts communication between a PC and an MCU. Basically it allows you to
call functions on your MCU from a PC.

Compost is meant to be used over any medium, but it's simplicity is best suited
for UART/RS232 or UDP/IP.

## Install

    pip install compost_rpc

## Documentation

Documentation is available in the [Wiki](https://github.com/STMicroelectronics/compost-rpc/wiki)

## Introduction

With Compost you can write a function for your MCU in C, but call
it from Python or C# on a PC.

The call on the PC looks like a normal function
call, but Compost takes the arguments, creates a message and sends it
over a transport like serial port. Then, Compost on the MCU parses the message
and calls your function with the arguments you provided on the PC.
Your function returns a value. Compost on the MCU creates a response message
with the return value. The response is sent to PC. Compost on the PC parses the
message and the function you called on the PC returns the value you provided in
the MCU.

Simplified functionality diagram:

![Functional overview](docs/_static/image/getting_started/compost-simple.svg)

## Features

### Languge support

- C
  - C11 standard
  - Implemented roles
    - RPC server (callee)
    - Notification sender
    - Notification receiver
- Python
  - Needs version >= 3.10
  - Implemented roles
    - RPC client (caller)
    - Notification receiver
- C#
  - Implemented roles
    - RPC client (caller)
    - Notification receiver

### Transports

- UDP transport
- Serial transport
- Raw ethernet transport (Linux only)
- TCP transport
- Stdio transport
- Custom

### Data types

- 8, 16, 32 and 64-bit signed and unsigned integers
- 32 and 64-bit floating-point numbers (IEEE 754)
- Bit-precise integers
- C like Struct
- C like Enum with selectable underlying type
- Dynamically sized array (list) for each supported primitive type

## Try it!

You just need Python and a C compiler like GCC to run our single PC example.

Clone the repository and enter the directory with the example:

    git clone https://github.com/STMicroelectronics/compost-rpc.git
    cd compost-rpc/examples/pc_to_pc

Generate C code from the protocol definition:

    python protocol_def.py

Compile the server:

On Linux or macOS:

    gcc -o server main.c compost.c

On Windows:

    gcc -o server main.c compost.c -lws2_32

In one terminal run the C server:

    ./server

In another terminal run the Python client:

    python main.py

Client sends two integers and the server adds them together and sends the result back to the client.
It's probably the simplest Compost example you can have.

If you want to try Compost-RPC properly with an MCU, check out
the [Tutorial](https://github.com/STMicroelectronics/compost-rpc/wiki/Tutorial).
astmio 1.0.0a3
Python implementation of ASTM E1381/1394 protocol.
Requires Python: >=3.8

ASTMIO

`astmio` is a Python library designed to handle ASTM communication protocols used in medical and laboratory equipment. It provides tools to parse, build, and transmit ASTM E1381/E1394 messages over serial connections, making it easy to integrate lab machines like blood analyzers with custom Laboratory Information Systems (LIS).

## Features

*   Full support for ASTM message parsing and encoding
*   Serial port abstraction for easy device communication
*   Customizable message mapping and field-level access
*   Built with extensibility in mind for LIS and middleware integration

Read the docs for more info: https://PrasoonPratham.github.io/astmio/

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

## Acknowledgements

This project is a fork of the original `python-astm` library created by Alexander Shorin. The original project, licensed under the 3-Clause BSD License, can be found at [the original PyPI project](https://pypi.org/project/astm/). Many thanks to the original author for their work.
damsmoviesdk 0.0.2
SDK Python pour accéder à l’API MovieLens (Data Analysts/Data Scientists friendly)
Requires Python: >=3.13

# MovieLens SDK - `damsmoviesdk`

Un SDK Python simple pour interagir avec l’API REST MovieLens. Il est conçu pour les **Data Analysts** et **Data Scientists**, avec une prise en charge native de **Pydantic**, **dictionnaires** et **DataFrames Pandas**.

[![PyPI version](https://badge.fury.io/py/moviesdk.svg)](https://badge.fury.io/py/moviesdk)
[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)

---

## Installation

```bash
pip install damsmoviesdk
```

---

## Configuration

```python
from damsmoviesdk import MovieClient, MovieConfig

# Configuration avec l’URL de votre API (Render ou locale)
config = MovieConfig(movie_base_url="https://movie-backend-3m0o.onrender.com")
client = MovieClient(config=config)
```

---

## Tester le SDK

### 1. Health check

```python
client.health_check()
# Retourne : {"status": "ok"}
```

### 2. Récupérer un film

```python
movie = client.get_movie(1)
print(movie.title)
```

### 3. Liste de films au format DataFrame

```python
df = client.list_movies(limit=5, output_format="pandas")
print(df.head())
```

---

## Modes de sortie disponibles

Toutes les méthodes de liste (`list_movies`, `list_ratings`, etc.) peuvent retourner :

- des objets **Pydantic** (défaut)
- des **dictionnaires**
- des **DataFrames Pandas**

Exemple :

```python
client.list_movies(limit=10, output_format="dict")
client.list_ratings(limit=10, output_format="pandas")
```

---

## Tester en local

Vous pouvez aussi utiliser une API locale :

```python
config = MovieConfig(movie_base_url="http://localhost:8000")
client = MovieClient(config=config)
```

---

## Public cible

- Data Analysts
- Data Scientists
- Étudiants et curieux en Data
- Développeurs Python

---

## Licence

MIT License

---

## Liens utiles

- API Render : [https://movie-backend-3m0o.onrender.com](https://movie-backend-3m0o.onrender.com)
- PyPI : [https://pypi.org/project/damsmoviesdk](https://pypi.org/project/damsmoviesdk)
pnvm 0.0a1
Python-based Node Version Manager
Requires Python: >=3.13

# README

![pipeline](https://gitlab.com/axelkarlsson/pnvm/badges/develop/pipeline.svg?job=pipeline-status)
[![coverage report](https://gitlab.com/axelkarlsson/pnvm/badges/develop/coverage.svg)](https://gitlab.com/axelkarlsson/pnvm/-/commits/master) 


**pnvm** (sometimes **PNVM**), is a small, FOSS utility for managing Node.js versions.  
It is written in Python, and more specifically Python >= 3.13, and focuses on **security**.

## Important Note

This project is still in alpha and under active development, and as such not ready to be used.

## Installing

You may install this utility via `pip`, kinda like this:
```bash
# NOTE: Don't install inside a `venv` unless you know what you are doing.
$ python3 -m pip install --upgrade pnvm

# If pnvm hasn't been added to $PATH, do the following:
# NOTE: replace `.bashrc` with whatever equivalent if you're using a shell which isn't bash.
$ echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc
# Source the RC file again.
$ . ~/.bashrc
```

## License

pnvm is **free software** licensed under the **GNU GPLv3**, or, if available, any later version.

## Examples

Installing Node.js version 18.20.8 via `pnvm`:
```bash
# NOTE: You may also write "--install".
$ pnvm -i v18.20.8
...
# Show list of versions:
$ pnvm -l
v18.20.8
# Switch to the newly installed version:
$ pnvm -c v18.20.8

$ node
Welcome to Node.js v18.20.8.
...
```

## Security

If there are any issues regarding security, please contact me via the email  
connected to `git`, or, preferrably, open an issue on GitLab.  

It is rather important to do so since this project is decently focused on security.

## Contact

Please open an issue on GitLab before contacting me.  
If you want to email me, you may do so via the email connected to `git`.

## Extra Notes

I've never ever published a project to PyPI and I'm gonna be honest and admit that I'm a  
beginner to it. Feel free to help me out if you're more experienced.

## Development

After cloning, run `uv sync` in the project folder.

### Project maintenance with UV

Type checking:

```shell
uv run mypy
```

Test/Coverage: 

```shell
uv run pytest --cov-report term-missing --cov ./src
```

If you need detailed reports: 

```shell
uv run pytest --cov-report html:.coverage-html --cov ./src
```

Linting

```shell
uv run ruff check  ./src
```

Checking formatting:

```shell
uv run ruff format --check ./src
```

Applying formatting:

```shell
uv run ruff format ./src
```

Upgrade packages:

```shell
uv sync --upgrade
```