semvec/pypi-packages huggingface dataset:
monty 2026.2.18
Monty is the missing complement to Python.
Requires Python: >=3.11

[![GitHub license](https://img.shields.io/github/license/materialsvirtuallab/monty)](https://github.com/materialsvirtuallab/monty/blob/main/LICENSE)
[![Linting](https://github.com/materialsvirtuallab/monty/workflows/Linting/badge.svg)](https://github.com/materialsvirtuallab/monty/workflows/Linting/badge.svg)
[![Testing](https://github.com/materialsvirtuallab/monty/workflows/Testing/badge.svg)](https://github.com/materialsvirtuallab/monty/workflows/Testing/badge.svg)
[![Downloads](https://static.pepy.tech/badge/monty)](https://pepy.tech/project/monty)
[![codecov](https://codecov.io/gh/materialsvirtuallab/monty/branch/master/graph/badge.svg?token=QdfT2itxgu)](https://codecov.io/gh/materialsvirtuallab/monty)

# Monty: Python Made Even Easier

Monty is the missing complement to Python. Monty implements supplementary
useful functions for Python that are not part of the standard library.
Examples include useful utilities like transparent support for zipped files,
useful design patterns such as singleton and cached_class, and many more.

Python is a great programming language and comes with "batteries
included". However, even Python has missing functionality and/or quirks that
make it more difficult to do many simple tasks. In the process of
creating several large scientific frameworks based on Python,
my co-developers and I have found that it is often useful to create
reusable utility  functions to supplement the Python standard library. Our
forays in various developer sites and forums also found that many developers
are looking for solutions to the same problems.

Monty is created to serve as a complement to the Python standard library. It
provides suite of tools to solve many common problems, and hopefully,
be a resource to collect the best solutions.

Monty supports Python 3.9+.

Please visit the [official docs](https://materialsvirtuallab.github.io/monty) for more information.
mkmake 0.2.0
Generate project and meta Makefiles with a Python API
Requires Python: >=3.8

# mkmake

[![PyPI version](https://img.shields.io/pypi/v/mkmake.svg)](https://pypi.org/project/mkmake/)

`mkmake` is a Python package for generating Makefiles for multiple related C projects from code.

## Installation

```bash
pip install mkmake
```

## Features

- Generate project and meta Makefiles from Python project definitions.
- Model mixed project types with a shared API (`CProject`, `YYProject`, `TestProject`).
- Discover and wire header dependencies for C projects.
- Inject dependency include paths and library linkage across project boundaries.
- Let `TestProject` opt into dependency private headers for unit-test-only coupling.
- Configure build variants through `debug` and `test` generation flags.

## Quick Start

```python
from mkmake import make_projects
from mkmake.projects import CProject, TestProject, YYProject
```

Define projects in a dictionary, then call `make_projects(...)` with build flags:

```python
projects = {
    "core": CProject("core", output_name="libcore.a"),
    "parser": YYProject("parser", output_name="libparser.a", depends=["core"]),
    "tests": TestProject("tests", test_command="python3 {0} {1}", depends=["core", "parser"]),
}
make_projects(projects, debug=True, test=True)
```

If test code needs a dependency's private headers from `src/include`, opt in explicitly:

```python
"tests": TestProject(
    "tests",
    test_command="python3 {0} {1}",
    depends=["core", "parser"],
    private_depends=["core"],
)
```

Notes:
- `private_depends` is test-only and should be used sparingly.
- Every `private_depends` entry must also be present in `depends`.
- On header basename collisions, local project headers remain authoritative.

Full usage example: `examples/generic_make.py`

## Limitations

- package-only API surface
- no CLI in package code
bear-config 1.0.9
A useful Pydantic based config system with various options
Requires Python: >=3.12


# Bear Config

[![pypi version](https://img.shields.io/pypi/v/bear-config.svg)](https://pypi.org/project/bear-config/)

A useful Pydantic based config system with various options

## Installation

With [`uv`](https://docs.astral.sh/uv/): `uv tool install bear-config`

## Configuration precedence

Values are merged in order; later sources override earlier ones:

1. `default.toml`
2. `{env}.toml` (for the active environment, e.g., `dev.toml`, `prod.toml`)
3. `local.toml`
4. Environment variables prefixed with your program name (e.g., `MY_APP_...`)

Search paths (by default): `~/.config/{program}/` and `./config/{program}/`.

## Quickstart

Define a Pydantic model for your settings, then load it with the `ConfigManager`.

```python
from pydantic import BaseModel
from bear_config.config_manager import ConfigManager


class Database(BaseModel):
    host: str = "localhost"
    port: int = 5432


class Settings(BaseModel):
    database: Database = Database()
    debug: bool = False


config = ConfigManager[Settings](
    config_model=Settings,
    program_name="my_app",
    env="dev",
).config

print(config.database.host)
print(config.debug)
```

Environment variables can override nested keys using the program prefix. For example, `MY_APP_DATABASE_HOST=prod.db` and `MY_APP_DEBUG=true` will replace the corresponding fields after files are loaded.

## Generating a default config

You can scaffold a TOML file with the model’s default values:

```python
from bear_config.config_manager import ConfigManager

config_mgr = ConfigManager[Settings](Settings, program_name="my_app")
config_mgr.create_default_config()  # writes default.toml into the local config dir
```
pax25 0.8.1
A complete AX.25 stack and application library.
Requires Python: >=3.14

# PAX25

pax25 is intended to be a full AX.25 stack.

It implements V2 of the AX.25 stack (not 2.2-- so no MOD128, no SREJ, no XID)
Multiple interfaces (KISS/Serial, AX over IP, file) support.

Target Python is 3.13. Earlier versions of the 3.X branch will not work, but later versions will likely work.

## Documentation

[Documentation for Pax25](https://foxyfoxie.gitlab.io/pax25/) is built and published based on the contents of the `documentation` directory. It is based on [mkdocs](https://www.mkdocs.org/), the configuration for which is found in the repository root.
morphlabs 0.1.1
Python SDK for Morphlabs biosignal processing API
Requires Python: >=3.8

# morphlabs

Python SDK for Morphlabs biosignal processing API.

## Installation

```bash
pip install morphlabs
```

## Quick Start

```python
from morphlabs.models import Scientia

# Set SCIENTIA_API_KEY environment variable or pass directly
scientia = Scientia(api_key="your-api-key")

# Clean EEG data
cleaned_data = scientia.clean_data("path/to/eeg_file.csv")
```

## Documentation

For full documentation, see [docs.morphlabs.tech](https://docs.morphlabs.tech)

## License

MIT
verifile 0.1.1
File Identification and Verification Tool
Requires Python: >=3.9

# VeriFile

VeriFile is a command-line file identification and integrity analysis tool built in Python.

It detects the true file type using magic number analysis and verifies file integrity using cryptographic hashing.

## Features

- File type detection using libmagic
- SHA256 hash generation
- Extension mismatch detection
- Clean CLI interface

## Installation

pip install verifile

## Usage

verifile path/to/file
openai-agents-trust 0.1.0
Trust & governance layer for OpenAI Agents SDK — policy enforcement, trust-gated handoffs, and Merkle audit trails
Requires Python: >=3.9
Keywords: agents, audit, governance, guardrails, openai, security, trust

# openai-agents-trust

Trust & governance layer for the [OpenAI Agents SDK](https://github.com/openai/openai-agents-python). Adds policy enforcement, trust-gated handoffs, and tamper-evident audit trails using native SDK guardrails and hooks.

> Built by [AgentMesh](https://github.com/imran-siddique/agent-mesh) — the open-source trust layer for multi-agent systems. Similar integrations merged into [Dify](https://github.com/langgenius/dify-plugins/pull/2060) (65K ⭐), [LlamaIndex](https://github.com/run-llama/llama_index/pull/20644) (47K ⭐), and [Microsoft Agent-Lightning](https://github.com/microsoft/agent-lightning/pull/478) (15K ⭐).

## Install

```bash
pip install openai-agents-trust
```

## Quick Start

```python
from agents import Agent, Runner
from openai_agents_trust import (
    trust_input_guardrail,
    policy_input_guardrail,
    GovernanceHooks,
    TrustGuardrailConfig,
    PolicyGuardrailConfig,
    TrustScorer,
    GovernancePolicy,
    AuditLog,
)

# Shared governance state
scorer = TrustScorer()
audit = AuditLog()
policy = GovernancePolicy(
    name="production",
    max_tool_calls=20,
    blocked_patterns=[r"DROP TABLE", r"rm -rf", r"eval\("],
    min_trust_score=0.7,
)

# Create guardrails
trust_config = TrustGuardrailConfig(scorer=scorer, min_score=0.7, audit_log=audit)
policy_config = PolicyGuardrailConfig(policy=policy, audit_log=audit)

# Attach to agents
agent = Agent(
    name="researcher",
    instructions="You are a research assistant.",
    input_guardrails=[
        trust_input_guardrail(trust_config),
        policy_input_guardrail(policy_config),
    ],
)

# Run with governance hooks
result = await Runner.run(
    agent,
    input="Analyze this data",
    run_config=RunConfig(hooks=GovernanceHooks(policy=policy, scorer=scorer, audit_log=audit)),
)

# Verify audit integrity
print(f"Audit entries: {len(audit)}")
print(f"Chain valid: {audit.verify_chain()}")
```

## Trust-Gated Handoffs

```python
from openai_agents_trust import trust_gated_handoff

billing_agent = Agent(name="billing", instructions="Handle billing.")
support_agent = Agent(name="support", instructions="Handle support.")

triage = Agent(
    name="triage",
    handoffs=[
        trust_gated_handoff(billing_agent, scorer=scorer, min_score=0.8),
        trust_gated_handoff(support_agent, scorer=scorer, min_score=0.6),
    ],
)
```

## Features

| Feature | SDK Hook | Description |
|---------|----------|-------------|
| **Trust Guardrail** | `InputGuardrail` | Blocks agents below trust threshold |
| **Policy Guardrail** | `InputGuardrail` | Enforces blocked patterns, tool limits |
| **Content Guardrail** | `OutputGuardrail` | Validates output against policies |
| **Governance Hooks** | `RunHooksBase` | Tracks tools, audits handoffs, scores trust |
| **Trust-Gated Handoff** | `is_enabled` | Disables handoffs to untrusted agents |
| **Merkle Audit** | — | Tamper-evident chain of all decisions |

## License

MIT
reachy-mini-dances-library-bwc 0.2.1.post1
Brain Wave Collective maintained fork of reachy-mini-dances-library (originally developed by Pollen Robotics).
Requires Python: >=3.12

# ⚠️ Maintained Fork Notice

This repository is a **Brain Wave Collective–maintained fork** of the original upstream project.

It exists to maintain compatibility with Brain Wave Collective systems and may include dependency or version adjustments that differ from upstream.

If you are not using Brain Wave Collective software, you likely want the official upstream project instead.

All original licensing and attribution are preserved.

---

# Reachy Mini Dances Library

A library of dance moves and choreographies for the Reachy Mini robot.

## Installation

```bash
pip install -e .
```

## Usage

```bash
# Interactive mode (cycles through all moves)
python examples/dance_demo.py

# Play a specific choreography
python examples/dance_demo.py --choreography ./examples/choreographies/another_one_bites_the_dust.json --no-keyboard
```