semvec/pypi-packages huggingface dataset:
mtxt 0.9.0
MTXT Music Text Format - Python bindings
License: MIT
Requires Python: >=3.8
Keywords: mtxt, music, midi, text, format

# MTXT - Music Text Format - Python Bindings

This is a Python binding to the [MTXT](https://github.com/danibiro/mtxt) library. See their readme for more information on the project and format details. 



## What is MTXT?

MTXT is a human-editable, text-based format for representing musical performance data. It stores events with precise timing, pitch, and expression values in a simple line-based structure that's easy to edit without requiring specialized tools.

The format is designed for cases where exact performance details matter - arbitrary timings, micro-tuning, dynamic changes, and other expressive parameters. MTXT avoids binary encoding, making it suitable for manual and AI-assisted editing.



### Usage

```python
import mtxt

# Parse MTXT
file = mtxt.parse("""mtxt 1.0
0 tempo 120
0 note C4 dur=1 vel=0.8
""")
# Or using file I/O
file = mtxt.load("song.mtxt")
file.save("output.mtxt")


# Access properties
print(file.version)           # "1.0"
print(file.duration)          # 0.0 (beats)
print(file.get_meta("title")) # metadata


# MIDI conversion
file.to_midi("output.mid")
file_from_midi = mtxt.MtxtFile.from_midi("output.mid")

# Print as mtxt string
print(file_from_midi)
# Prints: MtxtFile(version=Some("1.0"), records=3, duration=Some(0.0))
print(repr(file_from_midi))
```


### How to build the library

```bash
pip install maturin
maturin develop --features python,midi

# run tests
pytest tests/python/
```

For more details on the MTXT format specification and CLI options, see the [main MTXT repository](https://github.com/Daninet/mtxt).


## License

Original MTXT library: Copyright © 2025 Dani Biró
Python bindings: Copyright © 2026 Sven Hollowell

MTXT specification and reference implementation are dual-licensed under the Apache-2.0 license or the MIT license, at your option.
datamask 3.0.0a1
Data PII cleaning/masking for PostgreSQL
License: MIT
Requires Python: <4,>=3.10

# pgdatacleaner
## Purpose
Mask sensetive data in a database (i.e. PII/PHI) so it can be used for development/testing purposes.
It is meant to keep IDs, so databases that for some reason has PII data in PK/FKs won't work very well.
## Usage
First, create a data dictionary from an existing database:
```bash
datadict 'postgresql://<user>:<password>@<host>/<database>' <schema> my_pii_dd.csv
```
You will need to edit this file and set `pii` to `yes` for any columns that need to be masked,
and the `pii_type` to one of the available types to generate fake data. `dataclean -h` will
list all available fakers.

Then, run `dataclean` to modify a database masking data as specified in the CSV. This is not a very fast operation
on databases of any significant size.
```bash
dataclean -f 'postgresql://<user>:<password>@<host>/<database>' -f my_edited_pii_dd.csv
```

If you change your schema, adding/modifying/deleting columns and tables, you can regenerate the data dictionary
using your last copy as a seed so you don't have to re-specify columns that have not changed:

```bash
datadict 'postgresql://<user>:<password>@<host>/<database>' <schema> -i my_existing_dd.csv my_new_pii_dd.csv
```

## Status
Stable, supports postgresql.
Consists of 45% todo's and hacks - still works.


## Release history

    * 1.1.4
      * Added static_str
      * Handle lists and dicsts as JSONB [] when writing back rows

## Caveats
I'm not responsible for your data. Never run this against a production database, unless you feel like testing your backup restore procedures.

## License

Copyright (c) 2021, Fredrik Håård

Do whatever you want, don't blame me. You may also use this software as licensed under the MIT or BSD licenses, or the more permissive license below:

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
ogpu 0.2.0.14
OpenGPU SDK for distributed AI task deployment
License: MIT
Requires Python: >=3.8

# 🧠 OpenGPU SDK

Welcome to the edge of distributed AI.

The `ogpu.service` SDK lets you write **task handlers** that will run **on remote provider machines** — not your laptop.  
You define what your task expects and does, and we handle the wiring, serving, and background magic.

> ✨ Write your task. 🛰️ Deploy it. ⚡️ Let the network run it.

---

## 🚀 What is this?

This SDK is used by **client developers** to write Python **tasks** (as functions) that will be deployed and executed **on OpenGPU network providers**.

Your code will:
- Accept inputs (Pydantic model)
- Process them inside a registered **task handler**
- Expose a `/run/{task}/{task_address}` endpoint via FastAPI
- Be served by remote compute

---

## 🧪 Example: Your First Task

```python
import ogpu.service
from pydantic import BaseModel

class MultiplyInput(BaseModel):
    a: int
    b: int

class MultiplyOutput(BaseModel):
    result: int

@ogpu.service.expose()
def multiply(data: MultiplyInput) -> MultiplyOutput:
    ogpu.service.logger.info(f"🧮 Starting multiplication: {data.a} * {data.b}")
    result = data.a * data.b
    ogpu.service.logger.info(f"✅ Result computed: {result}")
    return MultiplyOutput(result=result)

ogpu.service.start()
```

That's it.
This exposes an endpoint at:

```
POST /run/multiply/{task_address}
```

With body:
```json
{
  "a": 5,
  "b": 7
}
```

---

## 📡 How It Works

- `@expose()`: Marks your function as a **task handler**.
- `start()`: Starts a FastAPI server that awaits tasks.
- Your task runs in a background thread.
- The result is logged, not returned over HTTP.

---

## 📚 Documentation

Complete documentation is available at: **https://opengpu-network.github.io/sdk-ogpu-py/**

- **[Quick Start Guide](https://opengpu-network.github.io/sdk-ogpu-py/getting-started/quickstart/)**
- **[API Reference](https://opengpu-network.github.io/sdk-ogpu-py/api/service/)**
- **[Examples & Templates](https://opengpu-network.github.io/sdk-ogpu-py/sources/templates/)**

---

## 🧙 Guidelines

- Your task handler must accept **one** `pydantic.BaseModel` input
- It must return another `pydantic.BaseModel`
- Task (function) names must be **unique**
- Output will be logged to the console — keep it clean 💅

---

## 🤝 Made for the OpenGPU Network  
Unleash your code. Let the grid handle the rest.