semvec/pypi-packages huggingface dataset:
ct-docker-cleaner 1.0.1
An interactive CLI tool to clean up Docker junk safely and beautifully
Requires Python: >=3.7

# 🧼 Docker Cleaner

**Docker Cleaner** is an interactive CLI tool to safely and easily clean up unused Docker resources, built with ❤️ by [CTDevelopers Solutions](https://ctdevelopers.solutions).

## ✨ Features

- **Interactive terminal UI** — no flags to memorize!
- **Standard Cleanup**:
  - Stopped containers
  - Dangling images
  - Unused volumes
  - Unused networks
  - Build cache
- **Advanced Cleanup**:
  - Remove **all** containers or images
  - Select specific containers or images to delete
  - Select containers/images to **keep** (all others will be deleted)
- **Dry-run mode** to preview what would be deleted
- **Age filtering**: remove containers/images older than X hours
- **Disk usage summary** and reclaimable space preview
- **💣 Full Nuke mode** with double confirmation
- **Keyboard shortcuts**: `<space>`, `a`, `i`, for full control

## 📦 Installation

### From PyPI

```bash
pip install ct-docker-cleaner
```

### Usage  

```bash
ct-docker-clean
```

- Then use the arrow keys + spacebar to select what you want to clean.

## 🛡️ Safety First

- Nothing is deleted without confirmation.

- Dry-run mode lets you preview before taking action.

- Build cache cleaning includes a warning.

## 📄 License
This project is licensed under the MIT License. See LICENSE for details.
adef-tools 0.6.3
Script to work with Integrated Alert Deforestacion
Requires Python: >=3.10
Keywords: alert, analysis, deforestation, geospatial, integrated, monitoring

# Configuración y uso de adef-tools

---

## 1. Configurando el entorno de Python

### En Linux/Mac (recomendado: `uv`)

Instala `uv` siguiendo la documentación del sitio:

```bash
curl -LsSf https://astral.sh/uv/install.sh | sh
```
Más opciones de instalación:
https://docs.astral.sh/uv/getting-started/installation/

Crea y activa el entorno virtual:
```bash
uv venv
source .venv/bin/activate
```

Instala las dependencias principales (incluyendo ruedas especiales para GDAL y pyproj):
```bash
uv pip install --find-links https://girder.github.io/large_image_wheels gdal pyproj
```

---

### En Windows (recomendado: Miniconda)

Instala Miniconda con winget:
```bash
winget install anaconda.miniconda3
```
Mas opciones de instalacion:
https://www.anaconda.com/docs/getting-started/miniconda/install

Crea y activa el entorno:
```bash
conda create -n adef-tools python=3.12
conda activate adef-tools
```

Instala las dependencias principales:
```bash
conda install -c conda-forge gdal libgdal-arrow-parquet libgdal pip
```

---

## 2. Instalando el paquete

Con el entorno ya activado, instala la herramienta desde PyPI:

```bash
pip install adef-tools
```

Verifica la instalación:
```bash
adef-tools --help
```

## 3. Usando el paquete

### Ejecución básica

```bash
adef-tools
```

### Opciones predeterminadas

Si no proporcionas opciones, se usarán los siguientes valores:
- `--vector`: Utilizá el límite HN por defecto.
- `--confidence`: 1
- `--out-folder`: `./results`
- `--out-file`: `adef_intg.gpkg`
- `--layer-name`: `alerts`
- `--start-date` y `--end-date`: No se aplicará filtrado por fechas.
- `--use-dask`:

### Ejemplo de uso personalizado

```bash
adef-tools --confidence 2 --out-folder ./custom_results --out-file custom_output.gpkg --layer-name custom_layer --start-date 2023-01-01 --end-date 2023-12-31
```

---

## Créditos
Desarrollado por *@lalgonzales | ICF/CIPF/UMF*

## Licencia
Este proyecto está bajo la Licencia MIT. Consulta el archivo [LICENSE](LICENSE) para más detalles.
file-copy-tool 0.1.0
Non-Redundant Media File Copy Tool: resumable, auditable, cross-platform, CLI-based.
Requires Python: >=3.8

# Non-Redundant Media File Copy Tool

Safely copy media files (photos, videos) from a source HDD pool to a destination HDD pool, ensuring **no redundant (duplicate) files** at the destination. The tool is robust, resumable, and fully auditable, using an SQLite database for all state and supporting both fixed and removable drives.

---

## Features
- Block-wise (4KB) file copying and SHA-256 checksums
- No file is copied if its checksum already exists in the destination
- All state, logs, and planning files are stored in a dedicated job directory
- Fully resumable and idempotent: safely interrupt and resume at any time
- CLI commands for all phases: `init`, `analyze`, `import-checksums`, `checksum`, `copy`, `resume`, `status`, `log`
- Cross-platform: Windows & Linux
- Full test suite for all features and workflows

---

## Quick Start

### 1. Install Requirements
```
pip install -r requirements.txt
```

### 2. Initialize a Job Directory
```
python -m src.main init --job-dir .copy-task
```

### 3. Analyze Source and Destination Volumes
```
python -m src.main analyze --job-dir .copy-task --src <SRC_ROOT> --dst <DST_ROOT>
```

### 4. Compute Checksums
```
python -m src.main checksum --job-dir .copy-task --table source_files
python -m src.main checksum --job-dir .copy-task --table destination_files
```

### 5. Copy Non-Redundant Files
```
python -m src.main copy --job-dir .copy-task --src <SRC_ROOT> --dst <DST_ROOT>
```

### 6. Resume, Status, and Logs
```
python -m src.main resume --job-dir .copy-task --src <SRC_ROOT> --dst <DST_ROOT>
python -m src.main status --job-dir .copy-task
python -m src.main log --job-dir .copy-task
```

### 7. Import Checksums from Old Database (Optional)
```
python -m src.main import-checksums --job-dir .copy-task --old-db <OLD_DB_PATH> --table source_files
```

---

## CLI Commands
- `init` â€” Create and initialize a job directory
- `analyze` â€” Scan source/destination and update the database
- `import-checksums` â€” Import checksums from an old SQLite database
- `checksum` â€” Compute missing/stale checksums
- `copy` â€” Copy only non-duplicate files
- `resume` â€” Resume incomplete/failed operations
- `status` â€” Show job progress and statistics
- `log` â€” Output a log or audit trail

---

## Testing
Run all tests (Windows PowerShell):
```
./scripts/test.ps1
```
Or (Linux/macOS):
```
./scripts/test.sh
```

---

## Project Structure
- `src/` â€” Main source code
- `tests/` â€” Automated tests (pytest)
- `agents/` â€” Agent planning, memory, and reasoning
- `changes/` â€” Execution logs and persistent state
- `scripts/` â€” Automation scripts for testing, linting, formatting, and archival
- `Taskfile.yml` â€” Cross-platform automation tasks

---

## Requirements & Design
See `requirements.md` and `AGENTS.md` for full requirements, design, and agent workflow protocols.

---

## License
MIT License
gardiner2unicode 0.0.3
Mapping Gardiner's codes to Unicode + generating corresponding images.
Requires Python: >=3.6
Keywords: egyptology, ancient egypt, fonts

# gardiner2unicode: Mapping Egyptian Hieroglyphs

A Python3.6+ package that 
* provides a convenient out-of-the-box way to access the mapping 
of [Gardiner's Sign List](https://en.wikipedia.org/wiki/Gardiner%27s_sign_list) codes to unicode IDs;
* generates hieroglyphs as images.

A list of hieroglyphs was copied from 
[this Wikipedia template](https://en.wikipedia.org/w/index.php?title=Template:List_of_hieroglyphs&action=edit).

A 2.06 version of [NewGardiner font](https://mjn.host.cs.st-andrews.ac.uk/egyptian/fonts/newgardiner.html) is used
by default. Please note that since 2.05 its license is [OFL 1.1](https://scripts.sil.org/cms/scripts/page.php?item_id=OFL_web).

One can use any other font with `UnicodeGlyphGenerator`.


![Python 3x](https://img.shields.io/badge/python-3.x-blue.svg)
[![PyPI version][pypi_badge]][pypi_link]
[![Downloads](https://pepy.tech/badge/gardiner2unicode)](https://pepy.tech/project/gardiner2unicode)

[pypi_badge]: https://badge.fury.io/py/gardiner2unicode.svg
[pypi_link]: https://pypi.python.org/pypi/gardiner2unicode

## Installation

    pip install -U gardiner2unicode

## Usage example

```python
from gardiner2unicode import GardinerToUnicodeMap, UnicodeGlyphGenerator

g2u = GardinerToUnicodeMap()
print(g2u.to_unicode_hex("A1"))

ugg = UnicodeGlyphGenerator()
ugg.generate_image("𓉓", save_path_png="O3_image.png")
```
Output:

`00013000`

![O3](O3_image.png?raw=true "Generated O3 image: a combination of a house, an oar, a tall loaf and a beer jug.")

## How to cite

Please cite this repository if you use this work in your research.

```bibtex
@misc{gardiner2unicode2021alekseev,
  title     = {{alexeyev/gardiner2unicode: Mapping Egyptian Hieroglyphs}},
  author    = {Anton Alekseev}, 
  year      = {2021},
  url       = {https://github.com/alexeyev/gardiner2unicode},
  language  = {english},
  publisher = {GitHub}, 
  journal   = {GitHub repository},  
  howpublished = {\url{https://github.com/alexeyev/gardiner2unicode/}}, 
}
```

## Links

* [NewGardiner font](https://mjn.host.cs.st-andrews.ac.uk/egyptian/fonts/newgardiner.html)
* [Gardiner's Sign List](https://en.wikipedia.org/wiki/Gardiner%27s_sign_list)
outjack 21
JACK and PortAudio integration for Python

# outjack
JACK and PortAudio integration for Python.

## Install
These are generic installation instructions.

### To use, disposably
Install the current release from PyPI to a virtual environment:
```
python3 -m venv venvname
venvname/bin/pip install -U pip
venvname/bin/pip install outjack
. venvname/bin/activate
```

### To use, permanently
```
pip3 install --break-system-packages --user outjack
```
See `~/.local/bin` for executables.

### To develop
First install venvpool to get the `motivate` command:
```
pip3 install --break-system-packages --user venvpool
```
Get codebase and install executables:
```
git clone git@github.com:combatopera/outjack.git
motivate outjack
```
Requirements will be satisfied just in time, using sibling projects with matching .egg-info if any.

## Commands

### ojplay
Usage example.

## API

<a id="outjack.jackclient"></a>

### outjack.jackclient

<a id="outjack.portaudioclient"></a>

### outjack.portaudioclient
xerini 0.3.1
A minimal python library for orchestrating runs of large SQL scripts.
Requires Python: >=3.11

# Sciurus
![coverage](https://gitlab.com/tipanverella/sciurus/badges/main/coverage.svg?job=coverage)

Sciurus is a python library for orchestrating runs of large `SQL` scripts.

You can explore the library by checking out [this documentation](https://sciurus-76b570.gitlab.io/).

You can quickly try it out if you have `docker`:

1. Run the following in the project directory after cloning it:

```zsh
docker build -t xerini -f Dockerfile .
docker run -it xerini zsh
```

2. When inside the container run:


```zsh
make
```
This will run `black`, `pylint`, `mypy`, and `pytest`


3. You can also build and use the deployment container:

```zsh
docker build -t xerini-deploy -f deploy.Dockerfile . --no-cache
docker run -it xerini-deploy python -c "from sciurus.utilities import random_id8; print(random_id8())"
```
This should produce a `random_id8()` string
isic-challenge-scoring 5.8.0
Submission scoring for the ISIC Challenge.
Requires Python: >=3.13
Keywords: challenge, isic, isic-challenge, scoring

# ISIC: Skin Lesion Analysis Towards Melanoma Detection Scoring

[![PyPI](https://img.shields.io/pypi/v/isic-challenge-scoring)](https://pypi.org/project/isic-challenge-scoring/)
[![Docker Build Status](https://img.shields.io/docker/build/isic/isic-challenge-scoring)](https://hub.docker.com/r/isic/isic-challenge-scoring)

Automated scoring code for the [ISIC Challenge](http://challenge.isic-archive.com).

## Installation
### Python
Python version >= 3.13 is required.
```bash
pip install isic-challenge-scoring
```

### Docker
```bash
docker pull isic/isic-challenge-scoring:latest
```

## Usage
### Python
#### Segmentation (2016 Tasks 1 & 2B, 2017 Task 1, 2018 Tasks 1 & 2)
```bash
isic-challenge-scoring segmentation /path/to/ISIC_GroundTruth/ /path/to/ISIC_predictions/
```

#### Classification (2016 Tasks 3 & 3B, 2017 Task 3, 2018 Task 3, 2019 Tasks 1 & 2)
```bash
isic-challenge-scoring classification /path/to/ISIC_GroundTruth.csv /path/to/ISIC_prediction.csv
```

### Docker
Since the application requires read access to files, [Docker must mount](https://docs.docker.com/storage/bind-mounts/#use-a-read-only-bind-mount) them within the container; these examples use `--mount` to [prevent nonexistent host paths from being accidentally created](https://github.com/moby/moby/issues/13121).

#### Segmentation (2016 Tasks 1 & 2B, 2017 Task 1, 2018 Tasks 1 & 2)
```bash
docker run \
  --rm \
  --mount type=bind,source="/path/to/ISIC_GroundTruth/",destination=/root/gt/,readonly \
  --mount type=bind,source="/path/to/ISIC_predictions/",destination=/root/pred/,readonly \
  isic/isic-challenge-scoring:latest \
  segmentation \
  /root/gt/ \
  /root/pred/
```

#### Classification (2016 Tasks 3 & 3B, 2017 Task 3, 2018 Task 3, 2019 Tasks 1 & 2)
```bash
docker run \
  --rm \
  --mount type=bind,source="/path/to/ISIC_GroundTruth.csv",destination=/root/gt.csv,readonly \
  --mount type=bind,source="/path/to/ISIC_prediction.csv",destination=/root/pred.csv,readonly \
  isic/isic-challenge-scoring:latest \
  classification \
  /root/gt.csv \
  /root/pred.csv
```
read-only-lists 0.0.0
Read only lists!
Keywords: read, only, lists

# read-only-lists

Minimalist semantic alias for read-only lists:

```python
from readonlylists import ReadOnlyList

x = ReadOnlyList([1, 2, 3])
print(x)         # (1, 2, 3)
x[0] = 42        # ❌ TypeError
piper-build 0.1.1
a toml-based build system
Requires Python: >=3.11


# Piper

A TOML-based build system written in Python.

## Overview

Piper is a modern **TOML-based build system** written in Python with flexibility and readibility in mind.



## Syntax

Piper reads a single **`TOML-based`** file, by default `Piperfile`

### `[config]` (Required)

Controls execution behavior

- `allow_env` (Array of Strings): This key defines every variable that can be modified with the environment
- `default_target` (String) (Required): This key defines the default target that is executed if a target is not provided

### `[variables]`

Optional global key-value pairs.

Both the key and the value must be a string.

### `[[target]]`
Defines a build target, multiple targets can be declared, at least one target must exist for `default_target` to work

- `name` (String) (Required): The name of the target
- `cmd` (Array of Strings): Shell commands to be executed
- `deps` (Array of Strings): Required targets to be executed before the current one
- `src` (Array of Strings): Required source files 

### `cmd` commands
Commands added to `cmd` in a `[[target]]` can interpolate variables defined in `[variables]` and special keys such as
- `target`: The name of the current target
- `src`: A space-separated list of the source files specified in the `src` array, if any

### Example
```toml
[config]
allow_env = ["CC", "CFLAGS"]
default_target = "hello"

[variables]
CC = "gcc"
CFLAGS = "-Os -static"

[[target]]
name = "hello"
src = ["hello.c"]
cmd = [
    "{CC} {CFLAGS} {src} -o {target}"
]
```
## License

**Piper** is licensed with the [**MIT License**](https://spdx.org/licenses/MIT.html)
redlog-py 0.1.1
A modern Python logging library
Requires Python: <4.0,>=3.8

# redlog

a modern python logging library

## features

- beautiful aligned output with automatic color detection
- structured logging with key-value fields
- immutable scoped loggers for hierarchical context
- thread-safe by design
- printf-style formatting support
- customizable themes and formatters

## quick start

```python
import redlog

log = redlog.get_logger("app")

log.info("hello world")
log.info("user login", 
         redlog.field("username", "alice"),
         redlog.field("success", True))

db_log = log.with_name("database")
db_log.error("connection failed", redlog.field("host", "localhost"))
```

## install

```bash
pip install redlog-py
```

## usage

### basic logging

```python
log = redlog.get_logger("myapp")

log.critical("system failure")
log.error("something went wrong")
log.warn("potential issue")
log.info("general information")
log.debug("debugging details")
```

### short forms

```python
log.crt("critical")  # same as critical()
log.err("error")     # same as error()
log.inf("info")      # same as info()
log.dbg("debug")     # same as debug()
```

### structured fields

```python
log.info("user action",
         redlog.field("user_id", 12345),
         redlog.field("action", "login"),
         redlog.field("ip", "192.168.1.100"))
```

### scoped loggers

```python
request_log = log.with_field("request_id", 12345) \
                 .with_field("method", "POST")

handler_log = request_log.with_name("handler")
handler_log.info("processing request")
```

### printf-style formatting

```python
log.info_f("user %s logged in from %s", username, ip_address)
log.error_f("failed to connect to %s:%d", host, port)
```

### configuration

```python
# set minimum log level
redlog.set_level(redlog.Level.DEBUG)

# use plain theme (no colors)
redlog.set_theme(redlog.themes.PLAIN)
```

## development

```bash
poetry install
poetry run python examples/basic.py
poetry run pytest
```
moa-engine 0.1.0
A simple library for searching the web and using internet search engines.
Requires Python: >=3.7

# pyMOA 🌐

**pyMOA** is a free and open source Python library that implements the MOA metasearch engine as a clean and easy-to-use client for Python. It allows you to seamlessly integrate web search into your Python programs.

The project is currently in alpha development, so there is no pre-built package.



## 🔍 Key Features

- **Privacy First**  
  No user data is stored or tracked during searches.

- **Metasearch Support**  
  Utilizes MOA under the hood to fetch and combine results from multiple search engines simultaneously.

- **Ad-free Search Results**  
  Clean, clutter-free search responses.

- **Open-source under GPL‑3.0 License**  
  Use, modify, and distribute freely under GPL‑3.0 terms.


### 🛠️ Build & Install from Source

1. Clone the repository:

```bash
git clone https://github.com/moa-engine/pyMOA.git
cd pyMOA
```

2. (Optional but recommended) Create a virtual environment:

```bash
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
```

3. Install dependencies:

```bash
pip install -r requirements.txt
```

4. Build the package:

```bash
python -m build
```

5. Install the wheel package:

```bash
pip install dist/pyMOA-0.1.0-py3-none-any.whl
```

> Replace the filename if the version changes.

---

### ✅ Usage Example

```python
from pyMOA import search

results = search(
    q="privacy search engine",
    lang="en",
    country="us",
    engine=None,         # Optional: specify engines like ["google", "duckduckgo"]
    page=1,
    safesearch=1,        # 0: off, 1: moderate, 2: strict
    time_range=None,     # One of ["day", "week", "month", "year"]
    size=5               # Max number of results per engine
)

print(results)
```



Let me know if you also want to add error handling or CLI usage examples.


## 🤝 Contributing

- Open an Issue to report bugs or request new features  
- Submit a Pull Request to add functionality, improve tests, or update documentation



## 📄 License

Distributed under the **GPL‑3.0** License. You are free to use, modify, and redistribute this library, provided modified source is also shared.
fp-mqtt-broker 0.1.2
A flexible MQTT broker package for IoT services with optional message handlers
Requires Python: >=3.8

# FP MQTT Broker Package

A flexible MQTT broker package for IoT services that supports optional message handlers, allowing different services to subscribe and handle MQTT messages independently.

## Features

- **Flexible Message Handling**: Support for multiple, optional message handlers
- **Easy Configuration**: Simple configuration through dictionaries or BrokerConfig objects
- **Extensible**: Abstract interfaces for easy customization
- **Production Ready**: Built-in error handling, reconnection logic, and logging

## Installation

```bash
pip install -e .
```

## Usage

```python
from fp_mqtt_broker import BrokerFactory
from fp_mqtt_broker.abstractions import MessageHandler

config = {
    'mqtt': {
        'broker_host': 'localhost',
        'broker_port': 1883,
        'client_id': 'my_service'
    }
}

# Define a custom message handler
class MyMessageHandler(MessageHandler):
    def get_subscribed_topics(self) -> list:
        return ['my/topic']

    def handle_message(self, topic: str, payload: str):
        print(f"Received message on {topic}: {payload}")

# Create and connect the broker with the custom message handler
broker = BrokerFactory.create_broker(config, [MyMessageHandler()])
broker.connect()
```

## Testing

```bash
pytest -v
```