semvec/pypi-packages huggingface dataset:
prune-cli 0.1.1
A CLI tool named prune for cleaning Python code
Requires Python: >=3.11
Keywords: cli, code, formatting, refactor, ast, prune

# prune

A CLI tool named prune for cleaning Python code.

## Installation

```bash
pip install prune-cli
```

## Usage

```bash
prune <command> [options]
```

### Commands

- `prune comments` - Remove comments from Python files
- `prune prints` - Remove print statements from Python files  
- `prune docstrings` - Remove docstrings from Python files
- `prune asserts` - Remove assert statements from Python files
- `prune logs` - Remove logging statements from Python files

### Examples

```bash
# Remove all print statements
prune prints

# Remove inline comments only (preserve noqa, type:, pragma)
prune comments --default

# Remove all types of comments
prune comments --all

# Remove specific log levels
prune logs --debug --info --error

# Remove all log levels
prune logs --all

# Show per-file details (verbose is default)
prune prints

# Suppress per-file output
prune prints --quiet
```

## Development

This project uses a src-layout packaging structure.

### Requirements

- Python >= 3.11
- LibCST

## License

MIT License
khinsider-dl 1.3.4
Download soundtracks from downloads.khinsider.com with a useful and quick CLI

# KHIDL

***NOTE: THIS PROJECT IS NOT AFFILIATED WITH KHINSIDER.***

Download soundtracks from [KHInsider](https://downloads.khinsider.com)
with a simple CLI.

## Installing

Download the latest version from PyPi using pip with the following command.

```sh
pip install khinsider-dl
```

You can also download the .whl file from the github releases [here](https://github.com/qwerinope/khidl/releases)
and install it with `pip install`.

There's an AUR package available too: [`python-khidl`](https://aur.archlinux.org/packages/python-khidl)

## Usage

### Download

```sh
khidl download [soundtrack id/url]
```

This command will download the specified soundtrack to a named directory
in the current working directory.

```sh
khidl download minecraft output --format flac --no-images
```

This command will download the minecraft soundtrack to a directory called output.
If the second positional command is left empty it will download the soundtrack
to a new directory named after the requested soundtrack.

The `--format` flag can be used to specify the requested music format.
All soundtracks are available in mp3 format.
Most soundtracks have other optional formats, like flac or m4a.
If a soundtrack is unavailable in the requested format,
the program will stop and notify the user about available formats.
If the user specifies the format as `nomusic`, the program will not download music, only images.

The `--no-images` argument makes sure `khidl` doesn't download images
belonging to the soundtrack.


For more detail please read the help page:

```sh
khidl download -h
```

### Search

```sh
khidl search [query]
```

This command will query the KHInsider database for soundtracks containing the query.
Afterwards it will print the result to the terminal in a pretty table.

```sh
khidl search lonely rolling star --song
```

This command will search the database for songs with the query 'lonely rolling star'.
Afterwards it will return all soundtracks with a song that features the query.

`khidl search` returns the name and ID of the soundtrack,
as well as the year of release.
You need to pass the ID into the [download function](#download)
to download the ost.

Note that searcing for a specific song is considerably slower,
it can take about 10 seconds to show data.

### Batch

To create the default configuration, run

```sh
khidl batch --init
```

This creats a `soundtrack.json`. In this file,
you can specify multiple soundtracks to be downloaded.
For each soundtrack you can set the requested download format.

The example showcases all options and ways to configure it.
There is a JSON schema included, please use it,
as it will warn you before running the script if you have made an error.

The script will validate the json before parsing it.
This behavior can be stopped by using `-f`/`--force`.
This is intended for testing and development only.
If the formatting is wrong the program will crash.

#### Special thanks

Special thanks to KHInsider for the incredible database.  
Special thanks to [obskyr's khinsider.py](https://github.com/obskyr/khinsider) project.
fastapi-oauth-rbac 0.2.0
A comprehensive FastAPI library for Authentication and NIST-style Role-Based Access Control (RBAC) with SQLAlchemy support.
Requires Python: >=3.10

# FastAPIOAuthRBAC

[![PyPI version](https://badge.fury.io/py/fastapi-oauth-rbac.svg)](https://badge.fury.io/py/fastapi-oauth-rbac) [![Downloads](https://static.pepy.tech/badge/fastapi-oauth-rbac)](https://pepy.tech/project/fastapi-oauth-rbac) [![Downloads Month](https://static.pepy.tech/badge/fastapi-oauth-rbac/month)](https://pepy.tech/project/fastapi-oauth-rbac)

A comprehensive FastAPI library for Authentication and NIST-style Role-Based Access Control (RBAC).

---

## 📖 Complete Documentation

The documentation has been significantly improved and split into easy-to-digest resources:

- **[Documentation Index](docs/README.md)** - Start here for the full overview.
- **[🚀 Getting Started](docs/getting-started.md)** - Installation and basic usage.
- **[⚙️ Configuration](docs/configuration.md)** - Environment variables and setup.
- **[🛡️ NIST RBAC Model](docs/rbac.md)** - Learn about roles, hierarchies, and permissions.
- **[🖥️ Admin Dashboard](docs/dashboard.md)** - Guide to the visual administration panel.
- **[💻 Frontend Integration](docs/frontend-integration.md)** - Vanilla JS & React guides.

---

## 🛠️ Examples

Check out the `examples/` directory for practical implementations:
- `basic_app.py`: Standard implementation.
- `multi_tenancy.py`: [NEW] Scoping users and roles to tenants.
- `advanced_extension.py`: [NEW] Custom User models, Hooks, and Email services.
- `testing_example.py`: [NEW] How to test your protected routes.

---

## Quick Start (Minimal)

```python
from fastapi import FastAPI
from fastapi_oauth_rbac import FastAPIOAuthRBAC

app = FastAPI()

# Initialize with default settings or your own Settings object
auth = FastAPIOAuthRBAC(app)

# Explicitly include the routes you want
auth.include_auth_router()
auth.include_dashboard()
```

### 📦 Installation Extras

```bash
# For PostgreSQL support
pip install "fastapi-oauth-rbac[postgres]"

# For SQLite support (async)
pip install "fastapi-oauth-rbac[sqlite]"
```

## Features
- **Asynchronous**: Full support for `aiosqlite`, `asyncpg`, etc.
- **NIST RBAC**: Advanced Role-Based Access Control with hierarchy.
- **Full Auth Flow**: Login, Signup, OAuth (Google), and Global Logout.
- **Premium Dashboard**: Manage users and roles through a beautiful glassmorphism UI.

## License
MIT
dbt-semantic-interfaces 0.10.5
The shared semantic layer definitions that dbt-core and MetricFlow use
Requires Python: >=3.8

<p align="center">
    <a target="_blank" href="https://twitter.com/dbt_labs">
    <img src="https://img.shields.io/twitter/follow/dbt_labs?labelColor=image.png&color=163B36&logo=twitter&style=flat">
  </a>
    <a target="_blank" href="https://www.getdbt.com/community/">
    <img src="https://img.shields.io/badge/Slack-join-163B36">
  </a>
    <a href="https://github.com/psf/black"><img src="https://img.shields.io/badge/code%20style-black-000000.svg" /></a>
</p>

# dbt-semantic-interfaces

This repo contains the shared semantic classes, default validation, and tests designed to be used by both the dbt-core and MetricFlow projects. By centralizing these shared resources, we aim to maintain consistency and reduce code duplication across both projects.

## Features
- Protocols for shared semantic classes: Define the interfaces and common attributes that must be implemented by the objects in both projects.
- Validation: Ensure that the objects comply with the expected structure and constraints.
- Tests: Ensure that the objects' behavior is consistent and correct across both projects.

## Contributing
We welcome contributions to improve this codebase! If you're interested in contributing, please read our [contributing guidelines](CONTRIBUTING.md) and [code of conduct](CODE_OF_CONDUCT.md) first.

## License
This package is released under the Apache2 License.

## Support
If you encounter any issues or have questions regarding the repo, please open an issue!
iflow-mcp_genorca-unrealmcp 1.0.2
MCP Server for Unreal Engine integration
Requires Python: >=3.8

# unreal-mcp-server

unreal-mcp-server is a Python-based server that implements the Model Context Protocol (MCP) for Unreal Engine. 
It enables smooth communication between MCP clients (e.g., Claude, Cursor, Windsurf) and the Unreal Editor, and is intended to be used together with the Unreal-MCPython Plugin.

- Demo : [Build 3D Scenes in Unreal Engine with Claude AI | Unreal-MCPython Demo](https://youtu.be/V7KyjzFlBLk?si=sOY1dEVGV2hqi4JC)
- Fab Link : [Unreal-MCPython: AI Assistant Plugin for Unreal Editor using Python & MCP](https://fab.com/s/aed5f75d50b2)
- Github Link : [GenOrca/unreal-mcpython](https://github.com/GenOrca/unreal-mcpython)


## 🎯 Why Choose Unreal-MCPython?

<p align="center">
<img src="https://raw.githubusercontent.com/GenOrca/Screenshot/refs/heads/main/unreal-mcp/Screenshot%202025-06-02%20025106.png" width="400">
<img src="https://raw.githubusercontent.com/GenOrca/Screenshot/refs/heads/main/unreal-mcp/Screenshot%202025-06-02%20025111.png" width="400">
<img src="https://raw.githubusercontent.com/GenOrca/Screenshot/refs/heads/main/unreal-mcp/Screenshot%202025-06-02%20025115.png" width="400">
<img src="https://raw.githubusercontent.com/GenOrca/Screenshot/refs/heads/main/unreal-mcp/Screenshot%202025-06-02%20025120.png" width="400">
</p>

- 🧠 **Unreal AI integration** - Direct Claude AI assistance in Unreal Engine
- 🔗 **Native MCP protocol support** - Seamless communication between AI and UE
- 🎮 **Intelligent game development** - AI-powered asset management and scene manipulation  
- ⚡ **Smart automation** - Context-aware blueprint scripting with AI guidance
- 🎨 **Technical artist focused** - AI assistance for complex production pipelines

## Key Features

- MCP server for communication with Unreal Engine
- Built-in routers for various operations (e.g., Actor, Asset, Editor, etc)
- Supports Python 3.11 and later

# Installation

Clone the repository:

```bash
git clone https://github.com/your-org/unreal-mcp-server.git
cd unreal-mcp-server
```

# Running the Server

You can start the MCP server with the following command:
```bash
uv --directory absolute/path/to/unreal-mcp-server run src/unreal_mcp/main.py
```

# Example Configuration (Using Claude, VSCode, Cursor)

The following is an example configuration for launching the MCP server from Claude, VSCode, or Cursor:

```json
{
    "mcpServers": {
        "unreal-mcpython": {
            "command": "uv",
            "args": [
                "--directory",
                "/absolute/path/to/unreal-mcp-server",  // e.g., D:/GitHub/unreal-mcp-server
                "run",
                "src/unreal_mcp/main.py"
            ]
        }
    }
}
```

This configuration approach works similarly across editors like VSCode and Cursor.

# License

This project is licensed under the Apache-2.0 License. See the LICENSE file for details.
societal-costs-pipeline-2026-02-10-2300 0.1.0
Societal costs pipeline CLI.
Requires Python: >=3.9

# societal_costs

Workspace for the societal costs study.

## Crates

- `crates/costs_core` — core domain types, aggregation, pricing, and validation.
- `crates/costs_models` — two-part, Tweedie, and log-normal models + selection tools.
- `crates/costs_matching` — matching + balance diagnostics.
- `crates/costs_cohort` — cohort assignment + diagnostics.
- `crates/costs_components` — register-derived component builders (LMDB volume so far).
- `crates/costs_population` — population files + public stats QC.
- `crates/costs_pipeline_common` — config, errors, tracing, and shared helpers.
- `crates/costs_pipeline_io` — report/Arrow/CSV/JSON writers.
- `crates/costs_registers` — register ingestion flows (BEF/LPR/LMDB/VNDS/DOD/etc).
- `crates/costs_pipeline_core` — orchestration + analysis/matching/modeling logic.
- `crates/costs_pipeline` — thin facade that re-exports common/core/io APIs.

## LMDB example

See `crates/costs_pipeline/README.md` for the LMDB ingestion example.

## Pipeline config

Start from `pipeline.example.toml` and update the register file paths to match
your local dataset layout. Most SAS7BDAT paths accept either a single file
or a directory (all `.sas7bdat` files are loaded, sorted by name). You can
also set `base_path` in the config to prefix all relative register paths.
File filtering uses `study.data_*` and optional `study.baseline_*` /
`study.followup_*` windows to avoid reading out-of-scope files.
Event registers (VNDS/DOD/DODSAARS/DODSAASG) are **not** year-filtered.
If you use contact-based SCD classification, set
`components.lpr.scd_inpatient_contact_types` (or flip
`components.lpr.scd_allow_outpatient = true` to allow outpatient contacts).

Pipeline outputs include consolidated QC under `qc_summary.csv/json`, plus
step-specific outputs such as `lpr_episode_qc.csv`, `matching_outcome_qc.csv`,
`matching_parent_qc.csv`, and `population_public_stats.csv`.

For terminal progress and timing, set:
- `pipeline.progress = true`
- `pipeline.log_level = "info"` (or `debug`)

## Additional docs

- `docs/README.md` — onboarding index and quick-start path.
- `crates/costs_core/README.md` — core domain and aggregation usage.
- `crates/costs_models/README.md` — model APIs and examples.
- `crates/costs_models/examples/README.md` — runnable model examples.
- `crates/costs_components/README.md` — LMDB note (missing price fields).
- `crates/costs_pipeline/README.md` — pipeline usage and LMDB example.
- `docs/notes/pipeline_contracts.md` — step-level inputs, outputs, invariants.
lorem-pysum 1.4.12
Library to generate instances of Pydantic models.
Requires Python: >=3.9

<!--suppress HtmlDeprecatedAttribute -->
<div align=center>
  <h1>Lorem Pysum</h1>
  <h3>Generate instances of Pydantic models.</h3>
  <img src="https://img.shields.io/badge/License-MIT-blue.svg"
   height="20"
   alt="License: MIT">
  <img src="https://img.shields.io/badge/code%20style-black-000000.svg"
   height="20"
   alt="Code style: black">
  <img src="https://img.shields.io/pypi/v/lorem-pysum.svg"
   height="20"
   alt="PyPI version">
  <img src="https://img.shields.io/badge/coverage-100%25-success"
   height="20"
   alt="Code Coverage">
</div>

## Install

Lorem Pysum is on PyPI and can be installed with:

```shell
uv add lorem-pysum
```

or

```shell
pip install lorem-pysum
```

## Usage

Given a Pydantic model type Lorem Pysum can generate instances of that model with
randomly generated values.

## Example

```python
from enum import auto, Enum
from uuid import UUID

import lorem_pysum
from pydantic import BaseModel


class Flavor(Enum):
    MOCHA = auto()
    VANILLA = auto()


class Brand(BaseModel):
    brand_name: str


class Coffee(BaseModel):
    id: UUID
    description: str
    cream: bool
    sweetener: int
    flavor: Flavor
    brand: Brand


lorem_pysum.generate(Coffee)
# Result -> id=UUID('550342d5-13ce-4ee1-b73d-d3c5e81607ce') description='string' cream=True sweetener=0 flavor=<Flavor.MOCHA: 1> brand=Brand(brand_name='string')
```
j2gpp-verilog 1.0.0
J2GPP extension for Verilog and SystemVerilog
Requires Python: >=3.8
Keywords: j2gpp, jinja2, extension, verilog, systemverilog, rtl, hdl, asic, fpga

# J2GPP-Verilog

A J2GPP extension for Verilog and SystemVerilog hardware description languages used in ASIC and FPGA development.

## Installation

The extension is a Python library that can be installed with pip and just requires J2GPP>=4.0 being installed.

```shell
pip install j2gpp-verilog
```

Once installed, the extension is automatically loaded by J2GPP and its filters, tests, and globals are usable in any template file.
noaio 1.0.0
Run (some) coroutine functions synchronously.
Requires Python: >=3.10
Keywords: asyncio, sync, performance

# noaio

![Licensed under BSD-3-Clause-Clear](https://img.shields.io/badge/license-BSD--3--Clause--Clear-yellow?style=for-the-badge)

Run (some) coroutine functions synchronously.

## Usage

Coroutine functions can be checked for syncifiability with `can_syncify`. Functions that contain any `await`, `async with`, or `async for` expression are not syncifiable. If they are, wrap them in `syncify` to run them as regular synchronous functions.

```python
from noaio import syncify, can_syncify


async def func_without_await():
    return 1


can_syncify(func_without_await) == True
syncify(func_without_await)() == 1
```

```python
async def func_with_await():
    await asyncio.sleep(0)
    return 1


can_syncify(func_with_await) == False
syncify(func_with_await)  ## ValueError
```

## How can I break it?

`can_syncify` checks the AST of the function you provide it. If it contains any `await`, `async with` or `async for` opcodes at the root level (immediately executed), it will return `False`.

`syncify` wraps the provided async function in a synchronous one that drives the coroutine to completion using `.send`, catching the iteration error and returning the result.

The library is typed, and expects you to use it in compliance with its type signatures.
boltzgen 0.3.0
Protein design
Requires Python: >=3.11

<div align="center">
  <div>&nbsp;</div>
  <img src="https://raw.githubusercontent.com/HannesStark/boltzgen/main/assets/boltzgen.png" alt="BoltzGen logo" width="60%">

[Paper](https://hannes-stark.com/assets/boltzgen.pdf) | 
[Slack](https://boltz.bio/join-slack) <br> <br>
 ![alt text](https://raw.githubusercontent.com/HannesStark/boltzgen/main/assets/cover.png)
</div>

# Installation
In an environment with python >=3.11:
```bash
pip install boltzgen
```

For more details see the [GitHub](https://github.com/HannesStark/boltzgen/tree/main).
trailblazer-ml 0.1.11
Uma biblioteca de AutoML Exploratório e 'Glass-Box'.
Requires Python: <4,>=3.8
Keywords: automl, data-science, preprocessing, cleaning

# ScoutML: Enterprise AutoML & Audit Framework

**Versão:** 2.1.0  
**Foco:** Governança, Auditabilidade e Robustez

O **ScoutML** não é apenas mais um framework de AutoML. Ele foi desenhado para ambientes regulados e críticos (Crédito, Fraude, Seguros, Saúde), onde explicar **por que** um modelo tomou uma decisão é tão importante quanto a sua performance.

Diferente de outras ferramentas do tipo *caixa-preta*, o ScoutML gera um **Relatório de Auditoria Completo** (Markdown + Gráficos) detalhando cada decisão estatística tomada, desde a limpeza de dados até a validação de estabilidade (PSI/KS).

---

## Principais Diferenciais (v2.1)

### 1. Scout v2 (O Analista Estatístico)

Antes de treinar, o Scout realiza uma varredura profunda nos dados:

- **Detecção de Leakage:**  
  Usa um modelo "Sentinela" para identificar variáveis que contêm a resposta (vazamento de dados) e remove-as automaticamente.
- **Perfilamento Estatístico:**  
  Calcula *Skewness* (assimetria), *Kurtosis* e *Outliers* (via IQR) para guiar o pré-processamento.
- **Higiene de Dados:**  
  Remove identificadores (IDs), colunas constantes e multicolinearidade excessiva.

---

### 2. Forge v2 (O Engenheiro Inteligente)

Constrói pipelines de **scikit-learn** dinamicamente, baseados no diagnóstico do Scout:

- **Tratamento de Outliers:**  
  Aplica `RobustScaler` automaticamente se detectar mais de 5% de outliers.
- **Normalização:**  
  Aplica `PowerTransformer` (Yeo-Johnson) em distribuições enviesadas.
- **Encoding Inteligente:**  
  Alterna entre `OneHotEncoder` (baixa cardinalidade) e `TargetEncoder` (alta cardinalidade) para evitar explosão dimensional.

---

### 3. Auditoria de Risco & Estabilidade

Para problemas de classificação, o ScoutML gera métricas padrão de mercado financeiro:

- **KS (Kolmogorov-Smirnov):**  
  Mede a separação entre classes.
- **PSI (Population Stability Index):**  
  Garante que o modelo não está degradado entre Treino e Teste.
- **Matriz de Confusão:**  
  Visualização clara de Falsos Positivos e Falsos Negativos.

---

## Instalação

O ScoutML depende de bibliotecas robustas de Data Science.

1. Crie um arquivo `requirements.txt` (veja a seção abaixo).
2. Instale as dependências:

```bash
pip install -r requirements.txt
iflow-mcp_andy-aranda-pr-reviewer 0.1.3
Add your description here
Requires Python: >=3.11

# 🤖 PR Reviewer with Claude + Notion + GitHub

This project automates the analysis of Pull Requests (PRs) using a LLM (Claude) connected via the [MCP (Model Context Protocol)](https://modelcontextprotocol.io/introduction). 

The system receives a PR link, generates a technical summary, and stores it in a Notion page as documentation.
![image](images/pr-reviewer-lk.gif)


---

## 🧩 Architecture
![image](images/pr-reviewer.svg)

1.	The user sends a PR URL to Claude Desktop.
2.	Claude interprets the request and uses its internal MCP Client.
3.	The MCP Client sends a structured request to the local MCP Server.
4.	The MCP Server acts as an adapter to fetch PR data from GitHub and save a summary to Notion, using both platforms’ APIs.
5.	The retrieved and processed information is returned to Claude, who presents it to the user as a technical summary.
6.	Finally, the information is automatically saved to a Notion page.
---

## ✨ Features

- Automatically fetches PR changes via GitHub API.
- Uses Claude Desktop to generate a semantic analysis of the code.
- Creates a Notion entry with the generated summary.
- Modular and extensible: you can add more tools to the MCP server.

---

## 🚀 How It Works

1. **Claude Desktop** detects the MCP server when it runs locally.
2. The user sends a PR link to Claude.
3. Claude calls the MCP server and uses:
   - `fetch_pr` → fetches PR metadata and diffs from GitHub.
   - `create_notion_page` → saves the analysis in a new Notion page.
4. The whole process is triggered from Claude's interface with no manual steps.

---

## 🔧 Requirements

- Python 3.10+
- [Claude Desktop](https://claude.ai/)
- Account / API key from:
  - [GitHub](https://github.com/settings/tokens)
  - [Notion](https://www.notion.so/my-integrations)

---

## ⚙️ Setup

1. Install `uv` (lightweight Python environment manager):
   ```bash
   curl -LsSf https://astral.sh/uv/install.sh | sh
   ```

2. Initialize project:
   ```bash
   uv init pr_reviewer
   cd pr_reviewer
   uv venv
   source .venv/bin/activate
   ```

3. Install dependencies:
   ```bash
   uv add "mcp[cli]" requests python-dotenv notion-client
   ```

4. Create `.env` file:
   ```env
   GITHUB_TOKEN=ghp_***************
   NOTION_API_KEY=secret_**************
   NOTION_PAGE_ID=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
   ```

5. Configure Claude Desktop with the `claude_desktop_config.json` file, e.g.:
   ```json
   {
     "mcpServers": {
       "pr-reviewer": {
         "command": "/path/to/python",
         "args": ["/path/to/pr_anayzer.py"],
         "cwd": "/path/to/project"
       }
     }
   }
   ```

---

## 🧪 Usage

1. Run the MCP server:
   ```bash
   python pr_anayzer.py
   ```

2. Open Claude Desktop and pass a PR link:
   ```
   https://github.com/your_username/your_repo/pull/1
   ```

3. Claude will analyze the PR and ask whether to save the result in Notion.

---

## 📌 Possible Improvements

- Full automation using `n8n` or GitHub Actions.
- PR validation with custom rules.
- Integration with other tools like Slack or ClickUp.