semvec/pypi-packages huggingface dataset:
itoutils 26.2.12.0
GIP Plateforme de l'inclusion's utilities library
Requires Python: >=3.12

# itoutils

Bibliothèque d'utilitaire utilisée au sein des différents projets Python du GIP Plateforme de l'inclusion.


## Développement

Vous aurez besoin du petit utilitaire [`uv`](https://docs.astral.sh/uv/getting-started/installation/) sur votre système.

Pour la création du virtualenv :
```shell
uv venv
```

Pour les dépendances :
```shell
uv sync
```
vezilka-schemas 0.1.5
Pydantic models for the scraped data storage for the Vezilka Project
Requires Python: >=3.8

# Vezilka Schemas

Pydantic models for managing structured scraped data in the Vezilka project.

## Features

- Type-safe models using Pydantic v2
- Built-in validation for data integrity
- Easy serialization to JSON and dictionary
- Designed for MongoDB, APIs, and RAG pipelines

## Package Structure

```
vezilka-schemas/
├── __init__.py              # Package exports
├── models.py                # Core Pydantic models
```

## Installation

```bash
pip install vezilka-schemas
```

For development installation and running tests, see [QUICKSTART.md](QUICKSTART.md)

## Models

### Record

Represents a single scraped item.

**Fields:**
- `id`: Unique identifier
- `text`: Full content text
- `type`: Content type (`RecordType`)
- `last_modified_at`: Last modification timestamp
- `meta`: Metadata object (`RecordMeta`)

### RecordMeta

Metadata associated with a record.

**Fields:**
- `source`: Source identifier (domain, filename, etc.)
- `url`: Original URL (optional)
- `tags`: List of tags (optional)
- `labels`: Additional labels (optional)
- `scraped_at`: Scraping timestamp

### RecordType

Enum defining record types:
- `NARRATIVE`: Articles, stories, documentation
- `HUMAN`: Speeches, transcripts, interviews

## Usage

### Creating a Record

```python
from vezilka_schemas import Record, RecordMeta, RecordType
from datetime import datetime

# Create metadata
meta = RecordMeta(
    source="mk.wikipedia.org",
    url="https://mk.wikipedia.org/wiki/Ѓаваткол",
    tags=["Историско-географски области", "Битола"],
    labels=[],
    scraped_at=datetime.now(),
)

# Create record
record = Record(
    id="wiki_1068030",
    text="Ѓаваткол е историско-географска област...",
    type=RecordType.NARRATIVE,
    last_modified_at=datetime.now(),
    meta=meta
)

# Serialize to JSON
json_str = record.to_json()

# Convert to dictionary
data_dict = record.to_dict()
```

### Creating from Dictionary

```python
from vezilka_schemas import Record

data = {
    "id": "speech_9f8e7d6c5b4a",
    "text": "Говорник Африм Гаши: Почитувани пратеници...",
    "type": "human",
    "last_modified_at": "2026-02-11",
    "meta": {
        "source": "stenogram_session_12.pdf",
        "url": "",
        "tags": [],
        "labels": [],
        "scraped_at": "2026-01-17T01:40:11"
    }
}

record = Record.from_dict(data)
```

### Validation

The models include built-in validation. For example, empty `id` or `text` will raise `ValidationError`.

## License

MIT License

## Contributing

Contributions are welcome! Please feel free to submit a pull request.
iflow-mcp_eversinc33-triagemcp 0.1.0
Add your description here
Requires Python: >=3.11

# TriageMCP

MCP server to enable an LLM to do basic static triage of a PE. 

A minimal prompt idea could be:

```
You are a malware analyst tasked to analyse the sample at <PATH> with your MCP tools. Create a markdown report that summarizes your findings. 
```

Of course supplying more info will usually yield a better result.

## Installation
Install dependencies:

```shell
pip install pefile yara-python die-python mcp[cli]
```

Then adjust `triage.py` and change `<TOOL>_EXE_PATH` and `YARA_RULE_PATH` accordingly.

### Claude Desktop Integration
You can install this server in Claude Desktop and interact with it right away by running:

```shell
mcp install .\triage.py
```

## Different transport protocol
By default, without using arguments, the server will use `stdio` transport:

```shell
.\triage.py
```

To use `SSE` transport:

```shell
.\triage.py --transport http://127.0.0.1:8744
```

## TODO

* VT/AnyRun/Sandbox integration
* Hash lookup
* Streamable HTTP transport
pytnl 0.0.10
Python bindings for the Template Numerical Library
Requires Python: >=3.12

# PyTNL

**PyTNL** provides Python bindings for the [Template Numerical Library (TNL)](
https://tnl-project.org/) — a modern C++ library for building efficient
numerical solvers and HPC algorithms.

TNL targets **multicore CPUs**, **GPUs** (CUDA and ROCm/HIP) and
**distributed-memory systems** (MPI) behind a unified programming model.
PyTNL exposes selected TNL building blocks to Python, enabling Python-driven
workflows while keeping performance-critical kernels in compiled backends.

## Scope

PyTNL is intended for:

- interoperability with TNL components where Python bindings are available,
- prototyping and orchestration of numerical solvers or HPC workflows,
- combining Python ergonomics with native code performance characteristics.

The exact set of exported classes and functions may evolve over time.

## Highlights

TNL (and therefore PyTNL where bindings exist) provides building blocks such as:

- CPU/GPU-aware data structures and memory utilities
- parallel primitives (iteration patterns, reductions, scans)
- linear algebra foundations (templated vectors, dense and sparse matrices,
  sparse data formats (segments))
- iterative linear solvers and preconditioners (CG, BiCGStab, GMRES, Jacobi, etc.)
- ODE solvers (Euler, Fehlberg, Kutta, Heun, Runge-Kutta-Merson, Matlab, etc.)
- structured grid and unstructured mesh data structures (including distributed)
  and utilities, including import from FPMA, Netgen, VTK, VTU and PVTU formats

## Documentation

PyTNL documentation (including installation instructions) is hosted on GitLab
Pages: <https://tnl-project.gitlab.io/pytnl/>

## License

PyTNL is provided under the terms of the [MIT License](./LICENSE).
dkdc-md-cli 0.1.4
CLI for the MotherDuck REST API
Requires Python: >=3.11

# MotherDuck CLI

CLI for the [MotherDuck REST API](https://motherduck.com/docs/sql-reference/rest-api/motherduck-rest-api/).

**Important**: This is a personal project. I am not affiliated with MotherDuck.

## Install

Pre-built binaries are available for Linux and macOS via Python (`uv`). Windows users should install via `cargo` or use macOS/Linux.

uv:

```bash
uv tool install dkdc-md-cli
```

cargo:

```bash
cargo install dkdc-md-cli
```

Either option will install the `md` command globally. You can use `uvx` to run it without installing:

```bash
uvx --from dkdc-md-cli md
```

## Authentication

Set a MotherDuck API token via environment variable:

```bash
export MOTHERDUCK_TOKEN="your-token-here"
```

Token resolution order (first non-empty wins):

1. `--token` flag (pass `-` to read from stdin)
2. `motherduck_token`
3. `MOTHERDUCK_TOKEN`
4. `motherduck_api_key`
5. `MOTHERDUCK_API_KEY`

## Usage

```
md [--output text|json] [--token TOKEN] [--yes] <command>
```

### Global flags

| Flag | Short | Description |
|------|-------|-------------|
| `--output` | `-o` | Output format: `text` (default) or `json` |
| `--token` | | API token (overrides env vars; `-` reads from stdin) |
| `--yes` | `-y` | Skip confirmation prompts |

### `service-account`

```bash
# Create a service account
md service-account create <username>

# Delete a service account (prompts for confirmation)
md service-account delete <username>
```

### `token`

```bash
# List tokens for a user
md token list <username>

# Create a new token
md token create <username> --name <name> [--ttl <seconds>] [--token-type <type>]

# Delete a token (prompts for confirmation)
md token delete <username> <token_id>
```

`--ttl`: time-to-live in seconds (300–31536000). Omit for no expiration.

`--token-type`: `read-write` (default) or `read-scaling`.

### `duckling`

```bash
# Get current duckling config
md duckling get <username>

# Set duckling config (at least one override required)
md duckling set <username> [--rw-size <size>] [--rs-size <size>] [--flock-size <n>]
```

Instance sizes: `pulse`, `standard`, `jumbo`, `mega`, `giga`.

Flock size: 0–64. `duckling set` fetches the current config and merges your overrides, so you only need to specify what you're changing.

### `account`

```bash
# List active accounts and their ducklings
md account list-active
```
PostgresLite 0.2.1
Python SQLite combined with syntax compared to asyncpg progject.
Requires Python: >=3.11.0
Keywords: asyncpg, sqlite, postgres, lite, database, sql

# PostgresLite
Python SQLite combined with syntax compared to asyncpg progject.

No longer do you need to use the default SQLite and rather have a more powerful and easy way to work with SQLite and have good, default additions for things like timestamps, dates.
It also supports async and sync connections, in case you need to use it in an async environment.

## Install
You can install it by running `pip install postgreslite`

## How to use
```py
from postgreslite import PostgresLite

db = PostgresLite("./hello_world.db")
pool = db.connect()

# Same syntax as asyncpg with pool connection
```
The value you put in PostgresLite will become the filename of the database.
If you leave it empty, it will use the default filename of `storage.db`.
django-er-mermaid 0.1.0
Generate Mermaid ER diagrams and data dictionaries from Django models
Requires Python: >=3.13
Keywords: database, django, documentation, er-diagram, erd, mermaid, schema, visualization

# django-er-mermaid

Generate Mermaid ER diagrams and data dictionaries from Django models.

## Features

- **Mermaid ER Diagram**: Generate ER diagrams in Mermaid syntax with `help_text` annotations
- **Data Dictionary**: Auto-generate comprehensive data dictionary tables
- **Deprecation Warnings**: Detect deprecated patterns like `ForeignKey(unique=True)` and `unique_together`
- **Flexible Output**: Write to file or stdout

## Installation

```bash
pip install django-er-mermaid
```

Add `django_er_mermaid` to your `INSTALLED_APPS`:

```python
INSTALLED_APPS = [
    'django_er_mermaid',
    # ... your other apps
]
```

## Usage

### Basic Usage

```bash
# Generate ER diagram to docs/er-diagram.md (default)
python manage.py generate_er

# Specify output file
python manage.py generate_er -o output.md

# Print to stdout
python manage.py generate_er --to-stdout
```

### Target Specific Apps

```bash
# Single app
python manage.py generate_er -a myapp

# Multiple apps
python manage.py generate_er -a app1,app2,app3
```

### Deprecation Warnings

```bash
# Include warnings in markdown output
python manage.py generate_er -w

# Include warnings in Japanese
python manage.py generate_er -w -j
```

Detects the following deprecated patterns:
- `ForeignKey(unique=True)` � Use `OneToOneField` instead
- `unique_together` � Use `UniqueConstraint` instead

## Output Example

### ER Diagram (Mermaid)

```mermaid
erDiagram
    User {
        bigint id PK
        varchar username "Username for login"
        varchar email "Email address"
    }
    Profile {
        bigint id PK
        bigint user_id FK
        text bio "User biography"
    }
    User ||--|| Profile : "user"
```

### Data Dictionary

| Field | Type | PK | FK | Null | Unique | Description |
|-------|------|----|----|------|--------|-------------|
| id | bigint |  |  |  |  |  |
| username | varchar |  |  |  |  | Username for login |
| email | varchar |  |  |  |  | Email address |

## Options

| Option | Short | Description |
|--------|-------|-------------|
| `--apps` | `-a` | Target apps (comma-separated). Default: all project apps |
| `--output` | `-o` | Output file path. Default: `docs/er-diagram.md` |
| `--to-stdout` |  | Print to stdout instead of file |
| `--include-warnings` | `-w` | Include deprecation warnings in markdown |
| `--japanese` | `-j` | Output warnings in Japanese (requires `-w`) |

## Requirements

- Python >= 3.13
- Django >= 5.0

## License

MIT License - see [LICENSE](LICENSE) for details.

## Credits

This project was inspired by [django-erd-generator](https://pypi.org/project/django-erd-generator/) by Andryo Marzuki.
epeira 0.2.2
Convenience model tooling for Io Kleiser Consulting.
Requires Python: >=3.11

# epeira
Convenience model tooling for [Io Kleiser Consulting](https://www.iokleiser.com/).

In general, these tools are created for use in multiple siloed private repos,
so not all of them will have full demonstrations in this package or repo.

## Revision history

### 0.2.2
- Added model_computed_field decorator which wraps pydantic computed_field and adds features

### 0.2.1
- Added get_variant_catalog_suffix function to parsing

### 0.2.0
- Added ability to create or add to input csv files any new models or parameters from catalogs

### 0.1.1
- Downgraded required version of Python to >= 3.11 for compatibility with other tooling

### 0.1.0
- Initial set of functions, primarily for marking classes and fields
- String parsing tools for convenience
fastapi-zitadel-auth 0.3.2
Zitadel authentication for FastAPI
Requires Python: >=3.10
Keywords: async, asyncio, authentication, fastapi, oauth, oidc, zitadel

# FastAPI Zitadel Auth

<p>
    <em>Simplify OAuth2 authentication and authorization in FastAPI apps using <b><a href="https://zitadel.com">Zitadel</a></b>.</em>
</p>

<a href="https://github.com/cleanenergyexchange/fastapi-zitadel-auth/actions/workflows/test.yml" target="_blank">
    <img src="https://github.com/cleanenergyexchange/fastapi-zitadel-auth/actions/workflows/test.yml/badge.svg" alt="Test status">
</a>
<a href="https://codecov.io/gh/cleanenergyexchange/fastapi-zitadel-auth">
    <img src="https://codecov.io/gh/cleanenergyexchange/fastapi-zitadel-auth/graph/badge.svg?token=A3TSXDVLQT" alt="Code coverage"/> 
</a>
<a href="https://pypi.org/pypi/fastapi-zitadel-auth">
    <img src="https://img.shields.io/pypi/v/fastapi-zitadel-auth.svg?logo=pypi&logoColor=white&label=pypi" alt="Package version">
</a>
<a href="https://pepy.tech/projects/fastapi-zitadel-auth">
    <img src="https://static.pepy.tech/badge/fastapi-zitadel-auth/month" alt="PyPI downloads">
</a>
<a href="https://python.org">
    <img src="https://img.shields.io/badge/python-v3.10+-blue.svg?logo=python&logoColor=white&label=python" alt="Python versions">
</a>
<a href="https://mypy-lang.org">
    <img src="https://www.mypy-lang.org/static/mypy_badge.svg" alt="mypy">
</a>

---

**Documentation**: <a href="https://cleanenergyexchange.github.io/fastapi-zitadel-auth" target="_blank">https://cleanenergyexchange.github.io/fastapi-zitadel-auth</a>

**Source Code**: <a href="https://github.com/cleanenergyexchange/fastapi-zitadel-auth" target="_blank">https://github.com/cleanenergyexchange/fastapi-zitadel-auth</a>

---

## Features

* Authorization Code flow with PKCE
* JWT validation using JWKS
* Role-based access control using Zitadel roles
* Service user authentication (JWT Profile)
* Swagger UI integration
* Type-safe token validation
* Extensible claims and user models
* Async loading of OpenID configuration



> **Note:** This library implements JWT, locally validated using JWKS, as it prioritizes performance, 
see [Zitadel docs on Opaque tokens vs JWT](https://zitadel.com/docs/concepts/knowledge/opaque-tokens#use-cases-and-trade-offs). 
If you need to validate opaque tokens using Introspection, 
please [open an issue](https://github.com/cleanenergyexchange/fastapi-zitadel-auth/issues?q=is%3Aissue%20state%3Aopen%20introspection) – PRs are welcome!


## License

This project is licensed under the terms of the [MIT license](https://github.com/cleanenergyexchange/fastapi-zitadel-auth/blob/main/LICENCE).

## Acknowledgements

This package was heavily inspired by [intility/fastapi-azure-auth](https://github.com/intility/fastapi-azure-auth/). 
Give them a star ⭐️!
databricks-switch-plugin 0.1.7
LLM-powered tool to convert SQL, code, and workflow files into Databricks notebooks.
Requires Python: >=3.10
Keywords: Conversion, Databricks, LLM, Migration, SQL

# Switch
LLM-Powered Code Conversion Plugin for Lakebridge

[![codecov](https://codecov.io/gh/databrickslabs/switch/branch/main/graph/badge.svg?token=YOUR_TOKEN)](https://codecov.io/gh/databrickslabs/switch)

## Project Description
Switch is a Lakebridge transpiler plugin that transforms SQL and other source formats into Databricks-compatible notebooks using Large Language Models (LLMs). As a core component of the Lakebridge migration platform, Switch provides automated code conversion capabilities through a multi-stage processing pipeline designed for large-scale platform migrations.

## Project Support
Please note that all projects in the /databrickslabs github account are provided for your exploration only, and are not formally supported by Databricks with Service Level Agreements (SLAs).  They are provided AS-IS and we do not make any guarantees of any kind.  Please do not submit a support ticket relating to any issues arising from the use of these projects.

Any issues discovered through the use of this project should be filed as GitHub Issues on the Repo.  They will be reviewed as time permits, but there are no formal SLAs for support.

## Using the Project
Switch is primarily designed as a Lakebridge transpiler plugin. To use Switch for code conversion:

1. **Install Lakebridge**: Follow the [Lakebridge documentation](https://databrickslabs.github.io/lakebridge)
2. **Install Switch transpiler**: Use Lakebridge to install the Switch transpiler plugin
3. **Run conversion**: Use Lakebridge's transpile command with Switch

For complete usage instructions and configuration options, refer to the [Lakebridge documentation](https://databrickslabs.github.io/lakebridge).