semvec/pypi-packages huggingface dataset:
blackspace 0.0.55
BlackSpace is a programming language that compiles to WhiteSpace.
Requires Python: >=3.12

# BlackSpace

BlackSpace is a programming language that compiles to WhiteSpace, an esoteric programming language
that uses only spaces, tabs, and linefeeds as syntax. BlackSpace is designed to make it easier
to write and read WhiteSpace programs by providing a higher-level syntax.

Currently the parser is not implemented, and only the compiler from an AST to WhiteSpace
is available.
xenon-fuse 1.6.3
XENON Framework for Unified Simulations of Events
Requires Python: <4.0,>=3.9

# XENON fuse

[![PyPI version shields.io](https://img.shields.io/pypi/v/xenon-fuse.svg)](https://pypi.python.org/pypi/xenon-fuse/)
[![Coverage Status](https://coveralls.io/repos/github/XENONnT/fuse/badge.svg)](https://coveralls.io/github/XENONnT/fuse)
[![Test package](https://github.com/XENONnT/fuse/actions/workflows/pytest.yml/badge.svg?branch=main)](https://github.com/XENONnT/fuse/actions/workflows/pytest.yml)
[![Readthedocs Badge](https://readthedocs.org/projects/fuse/badge/?version=latest)](https://xenon-fuse.readthedocs.io/en/latest/?badge=latest)
[![pre-commit.ci status](https://results.pre-commit.ci/badge/github/XENONnT/fuse/main.svg)](https://results.pre-commit.ci/latest/github/XENONnT/fuse/main)
[![DOI](https://zenodo.org/badge/622956443.svg)](https://zenodo.org/doi/10.5281/zenodo.11059395)

**F**ramework for **U**nified **S**imulation of **E**vents

fuse is the refactored version of the XENONnT simulation chain. The goal of this project is to unify [epix](https://github.com/XENONnT/epix) and [WFSim](https://github.com/XENONnT/WFSim) into a single program. fuse is based on the [strax framework](https://github.com/AxFoundation/strax), so that the simulation steps are encoded in plugins with defined inputs and outputs. This allows for a flexible and modular simulation chain.

## Installation

With all requirements fulfilled (e.g., on top of the [XENONnT montecarlo_environment](https://github.com/XENONnT/montecarlo_environment)):
```
python -m pip install xenon-fuse
```
or install from source:
```
git clone git@github.com:XENONnT/fuse
cd fuse
python -m pip install . --user
```

## Plugin Structure

The full simulation chain in split into multiple plugins. An overview of the simulation structure can be found below.

![fuse plugin structure](docs/source/figures/fuse_simulation_chain.png)
todopro-cli 0.1.0
A professional command-line interface for TodoPro task management system
Requires Python: >=3.12

# TodoPro CLI

> A professional command-line interface for TodoPro task management system, inspired by kubectl.

## Features

- **Kubectl-inspired**: Resource-oriented commands with consistent patterns
- **Context-aware**: Maintains authentication state and user preferences
- **Multi-environment**: Switch between dev, staging, and prod contexts seamlessly
- **Output flexibility**: JSON, YAML, table, and custom formats
- **Interactive & scriptable**: Menu-driven UI for exploration, flags for automation
- **Professional UX**: Rich terminal UI with colors, progress indicators, and helpful messages

## Installation

```bash
# Install from source
uv tool install --from . todopro-cli
```

## Quick Start

```bash
# Login to TodoPro
todopro login

# Quick add a task (natural language, just like Todoist)
todopro add "Buy milk tomorrow at 2pm #groceries @shopping"

# List tasks
todopro tasks list

# Create a task (traditional way)
todopro tasks create "Buy groceries"

# Reschedule all overdue tasks to today
todopro tasks reschedule overdue

# Skip confirmation prompt
todopro tasks reschedule overdue --yes

# Get current timezone
todopro auth timezone

# Set timezone (IANA format)
todopro auth timezone Asia/Ho_Chi_Minh
todopro auth timezone America/New_York
todopro auth timezone Europe/London

# 1. Set your timezone
todopro auth timezone Asia/Ho_Chi_Minh

# 2. Check today's tasks (includes overdue)
todopro today

# 3. Reschedule all overdue tasks to today
todopro tasks reschedule overdue

# See what's due today
todopro today

# Get the next task to work on
todopro next

# Complete a task
todopro complete <task_id>

# Reschedule a task to today (quick rescheduling)
todopro reschedule <task_id>

# Reschedule to a specific date
todopro reschedule <task_id> --date tomorrow
todopro reschedule <task_id> --date 2026-02-15

# Task ID Shortcuts
# You can use task ID suffixes instead of full IDs for convenience
# If the full ID is "task-abc123def", you can use:
todopro complete abc123def    # Uses suffix
todopro complete 123def       # Even shorter suffix
todopro reschedule e562bb     # Reschedule to today by suffix
todopro get e562bb            # Get task details by suffix
todopro update 123def --content "Updated task"
todopro delete abc123         # Delete by suffix

# View project details
todopro describe project <project_id>

# Get help
todopro --help
```

## Development

```bash
# Install with development dependencies
uv pip install -e ".[dev]"

# Run all tests with coverage
uv run pytest --cov=src/todopro_cli --cov-report=term-missing

# Run tests for specific module
uv run pytest tests/test_api_client.py -v

# Generate HTML coverage report
uv run pytest --cov=src/todopro_cli --cov-report=html
# Open htmlcov/index.html in browser

# Format code
black src/ tests/

# Lint code
ruff check src/ tests/
```
mito-utils 0.1.4
Utilities for MT-based single cell Lineage Tracing (scLT).
Requires Python: >=3.11

<div align="center">

<img src="image/nf_mito.png" alt="nf-MiTo Logo" width="500" style="margin-bottom: 30px;">

<div style="background: linear-gradient(135deg, #1e3c72 0%, #2a5298 50%, #6a85b6 100%); padding: 60px 40px; border-radius: 25px; margin: 30px auto; max-width: 1000px; box-shadow: 0 20px 50px rgba(0,0,0,0.3); border: 4px solid rgba(255,255,255,0.15);">
  
  <h1 style="border: none; font-family: 'SF Mono', 'Monaco', 'Inconsolata', 'Roboto Mono', 'Source Code Pro', 'Menlo', 'Consolas', monospace; font-size: 6em; font-weight: 900; margin: 20px 0; letter-spacing: 0.05em; text-transform: none; line-height: 1;">
    <span style="color: #dc2626; filter: drop-shadow(3px 3px 6px rgba(0,0,0,0.4));">MiTo</span>
  </h1>
  
  <div style="width: 200px; height: 6px; background: linear-gradient(90deg, #ff6b6b, #ff8e53, #4ecdc4, #44a08d); margin: 35px auto; border-radius: 3px; box-shadow: 0 3px 12px rgba(0,0,0,0.4);"></div>
  
  <p style="font-size: 1.5em; font-weight: 400; color: #f8f9fa; margin: 30px 0 10px 0; line-height: 1.6; font-style: italic; text-shadow: 2px 2px 4px rgba(0,0,0,0.4); max-width: 800px; margin-left: auto; margin-right: auto;">
    Mitochondrial lineage tracing and single-cell multi-omics in Python
  </p>
  
</div>

[![Python](https://img.shields.io/badge/python-3.11%2B-blue.svg)](https://www.python.org/)
[![Conda](https://img.shields.io/badge/conda-enabled-green.svg)](https://conda.io/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![DOI](https://img.shields.io/badge/DOI-10.1101%2F2025.06.17.660165-blue)](https://doi.org/10.1101/2025.06.17.660165)

</div>

## Documentation
An extensive documentation of MiTo's key functionalitites is available at [MiTo Docs](https://andrecossa5.readthedocs.io/en/latest/index.html).

## Installation
1. Install [mamba](https://mamba.readthedocs.io/en/latest/installation/mamba-installation.html) (or conda)
2. Clone this repo:

```bash
git clone https://github.com/andrecossa5/MiTo.git
```

3. Reproduce MiTo conda environment:

```bash
cd MiTo
mamba env create -f envs/environment.yml -n MiTo
```

3. Activate the environment, and install MiTo via pypi:

```bash
mamba activate MiTo
pip install mito-utils
```

4. Verify successfull installation:

```python
import mito as mt
print(mt.__version__)
```

## Releases
See [CHANGELOG.md](CHANGELOG.md) for a history of notable changes.
mozanalysis 2026.1.2
A library for Mozilla experiments analysis
Requires Python: >=3.11

# Mozilla Experiments Analysis [![CircleCI](https://circleci.com/gh/mozilla/mozanalysis.svg?style=svg)](https://circleci.com/gh/mozilla/mozanalysis) [![codecov](https://codecov.io/gh/mozilla/mozanalysis/branch/master/graph/badge.svg)](https://codecov.io/gh/mozilla/mozanalysis) [![CalVer - Timely Software Versioning](https://img.shields.io/badge/calver-YYYY.M.MINOR-22bfda.svg)](https://calver.org/)

The `mozanalysis` Python library is a library to standardize experiment analysis
at Mozilla for the purpose of producing decision reports templates that are
edited by data scientists.

## Documentation

Online documentation is available at https://mozilla.github.io/mozanalysis/

##  Installation from pypi
- To install this package from pypi run:
```
pip install mozanalysis
```

## Local Installation
### Dependencies
Dependencies are specified in the `requirements.txt` and `requirements-dev.txt` files, which are used for testing and development respecitvely.
To create a virtualenv and set up the package execute the following, replacing `requirements.txt` with `requirements-dev.txt` if you plan on contributing to the package.
```bash
# Create and activate a python virtual environment.
python3 -m venv venv/
source venv/bin/activate
pip install -r requirements.txt
pip install -e . --no-dependencies
```

## Development
Linting and Formatting are done with Ruff.

When adding new dependencies, add them to the `pyproject.toml` `dependencies` list.  Then generate updated requirements files using the script `script/update_deps`.  [`pip-compile` is called](https://pypi.org/project/pip-tools/) in this script, which uses the specified dependencies to create the `requirements.txt` and `requirements-dev.txt` files.  Finally, you'll want to update the requirements in your virtual env by running `pip install -r requirements-dev.txt`

## Testing locally

### With pytest
Run `pytest` on the commandline from the root of the package file structure.

### With tox

Tox is included in the dev dependencies.  If you want to run with tox, install the dev dependencies in the `requirements-dev.txt` as detailed above.

You can pass flags to tox to limit the different environments you test in
or the tests you run. Options after `--` or positional arguments are forwarded to pytest.

For example, you can run:

* `tox -e lint` to lint

* `tox -e py311 -- -k utils` to only run tests with "utils" somewhere in the name, on Python 3.11

* `tox tests/test_utils.py` to run tests in a specific file

## Deploying a new release

Releasing mozanalysis happens by tagging a CalVer based Git tag with the
following pattern:

    YYYY.M.MINOR

where YYYY is the four-digit year number, M is a single-digit month number and
MINOR is a single-digit zero-based counter which does NOT relate to the day of
the release. Valid versions numbers are:

    2017.10.0
    2018.1.0
    2018.12.12

Once the (signed) Git tag has been pushed to the main GitHub repository using
git push origin --tags, Circle CI will automatically build and push a release to
PyPI after the tests have passed.
claude-traces-client 0.1.2
Extract and upload Claude Code traces
Requires Python: >=3.10

# claude_traces_client

Extract and upload Claude Code traces to a configurable endpoint.

## Installation

```bash
pip install claude-traces-client
```

Or install from source:

```bash
cd claude_traces_client
pip install -e .
```

## Usage

```python
from claude_traces_client import traced
from claude_code_sdk import query, ClaudeCodeOptions

# Endpoint read from CLAUDE_TRACES_ENDPOINT env var (default: https://claudetraces.dev/api/trace)
async for msg in traced(query(prompt="Hello", options=opts)):
    print(msg)  # Messages flow through unchanged
# Trace is POSTed automatically after iteration completes
```

## Configuration

| Environment Variable | Default | Description |
|---------------------|---------|-------------|
| `CLAUDE_TRACES_ENDPOINT` | `https://claudetraces.dev/api/trace` | URL to POST traces to |

## API

### `traced(messages, *, project_path=None, headers=None, timeout=30.0, raise_on_upload_error=False)`

Wrap a Claude SDK message iterator to upload traces after completion.

**Parameters:**
- `messages`: AsyncIterator from `query()` or `ClaudeSDKClient`
- `project_path`: Project path for trace lookup (default: cwd)
- `headers`: Optional headers for the POST request (e.g., `{"Authorization": "Bearer ..."}`)
- `timeout`: Upload timeout in seconds
- `raise_on_upload_error`: If True, raise on upload failure; if False, silently continue

**Yields:** Messages unchanged from the underlying iterator

## How It Works

1. Wraps the Claude SDK's async message iterator
2. Captures the `session_id` from the first `SystemMessage` with `subtype='init'`
3. After iteration completes, reads the trace file from `~/.claude/projects/<encoded-path>/<session_id>.jsonl`
4. POSTs the trace contents to the configured endpoint with `Content-Type: application/x-ndjson`

## Trace File Location

Claude Code writes traces to:
```
~/.claude/projects/<encoded-path>/<session_id>.jsonl
```

Where `<encoded-path>` is the project path with `/` replaced by `-` (e.g., `/Users/foo/bar` becomes `-Users-foo-bar`).
zhinst 26.1.0
Zurich Instruments Python API
Requires Python: >=3.10

# Zurich Instruments LabOne Packages

![](https://github.com/zhinst/zhinst-meta/blob/main/thumbnail.jpg)

The `zhinst` package is purely a metapackage that installs the whole Python API
stack for LabOne&reg;, the Zurich Instruments control software.

It includes the following packages:

* [zhinst-core](https://pypi.org/project/zhinst-core/) (native Python API for LabOne)
* [zhinst-utils](https://pypi.org/project/zhinst-utils/) (utility functions for zhinst-core)
* [zhinst-toolkit](https://pypi.org/project/zhinst-toolkit/) (high-level Python API for LabOne)

This package includes everything required to interface with LabOne form within Python.
For more information see the dedicated package documentation or the
[online documentation](https://docs.zhinst.com).

WARNING: Upgrading from version <= 22.02 to 22.08 requires to uninstall this package first and the reinstalling it, `--upgrade` will corrupt the package.
cipfsuf 1.0.0
The IPFS Unfuccker - Global CID Propagation Tool
Requires Python: >=3.6

# 🛠 CIPFSUF - THE IPFS UNFUCCKER v1.0 🚀

![IPFS](https://img.shields.io/badge/Network-IPFS-blue)
![Language](https://img.shields.io/badge/Language-Python%20%26%20C%2B%2B-green)
![License](https://img.shields.io/badge/License-MIT-red)
![Status](https://img.shields.io/badge/Status-Unfucking%20Complete-brightgreen)

> **"If it works without limitations, locks and optimizations are useless."** - MurilooPrDev

---

## 💀 WHAT IS THIS SHIT?
**CIPFSUF** is a brutal propagation tool for the IPFS network. It was built because standard tools are slow, polite, and full of useless limitations. This tool is designed to make your content (like the **GNU Android Optimizer**) immortal by forcing global gateways to cache your data.

**CODE IS SACRED. PYTHON IS SACRED. C++ IS SACRED. ELF IS SACRED.**

---

## 🔥 FEATURES
* **Shard Core (C++):** Shreds your files into binary pieces so small that no firewall can catch them.
* **Global Blast (Python):** Uses a massive 50-worker thread pool to scream your CID at every public gateway on the planet simultaneously.
* **Dynamic Scraping:** Don't rely on hardcoded lists. It fetches the latest global gateways from the abyss of the internet.
* **Zero-Daemon Persistence:** Upload your shit, blast it, and turn off your Termux. The network is now your slave.

---

## ⚠️ WARNING (READ THIS OR GTFO)
1.  **I don't care** what you upload. You are responsible for your own digital ghosts.
2.  **No Limits:** This tool ignores "best practices." We don't want best practices; we want the file online forever.
3.  **Parasitic Hosting:** We are using third-party caches. If they don't like it, they shouldn't be running public gateways.

---

## 🛠 INSTALLATION & USAGE
Stop being a script kiddie and just run it:

```bash
# Shred and Push
./cipfsuf --push <YOUR_CID_HERE>
```

---

## 📜 LICENSE (MIT)
Copyright (c) 2026 MurilooPrDev / Chopper Team

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files, 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... **AS LONG AS YOU RECOGNIZE THAT CODE IS SACRED.**

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND. IF IT BREAKS YOUR COMPUTER OR STARTS A NUCLEAR WAR, IT'S NOT MY PROBLEM.

---

*Built in my pc. Dedicated to the immortality of code.*
map2poster 0.2.4
Generate beautiful, minimalist map posters for any city in the world.
Requires Python: >=3.11
Keywords: map, poster, osm, openstreetmap, art, visualization

# 🗺️ map2poster

**Create beautiful, minimalist map posters for any city in the world.**

`map2poster` is a high-performance Python tool that transforms OpenStreetMap data into stunning, gallery-ready minimalist art. Whether you're capturing the grid of New York, the canals of Venice, or the organic sprawl of Tokyo, `map2poster` delivers premium-quality visualizations with customizable themes and professional typography.

## ✨ Features

- **Global Coverage**: Fetch street networks, water bodies, and green spaces for any location on Earth.
- **Premium Themes**: Choose from 17+ curated color palettes (Noir, Terracotta, Neon Cyberpunk, etc.).
- **Vector Output**: Export as PNG, SVG, or PDF for high-resolution printing.
- **Precision Control**: Custom radius, dimensions, and coordinate overrides.
- **Multilingual Support**: Supports native scripts (CJK, Arabic, etc.) with automatic Google Fonts integration.
- **Fast & Efficient**: Local caching and optimized rendering pipeline.

## 🚀 Installation

### With `uv` (Recommended)

```bash
uv pip install map2poster
```

### With `pip`

```bash
pip install map2poster
```

## 🛠️ Usage

### Command Line Interface

Generate a poster instantly from your terminal:

```bash
map2poster --city "Paris" --country "France" --theme noir
```

| Option | Short | Description | Default |
| :--- | :--- | :--- | :--- |
| `--city` | `-c` | City name for geocoding | Required |
| `--country` | `-C` | Country name for geocoding | Required |
| `--theme` | `-t` | Theme name (noir, terracotta, etc.) | `terracotta` |
| `--distance` | `-d` | Map radius in meters | `18000` |
| `--format` | `-f` | Output format (png, svg, pdf) | `png` |
| `--list-themes` | | Show all available styles | |

### Python API

Integrate map generation into your own workflows:

```python
from map2poster import CreatePoster, load_theme, get_coordinates

# 1. Resolve location
coords = get_coordinates("Tokyo", "Japan")

# 2. Pick a style
theme = load_theme("japanese_ink")

# 3. Create the art
CreatePoster(
    city="Tokyo",
    country="Japan",
    point=coords,
    dist=12000,
    output_file="tokyo_poster.png",
    output_format="png",
    theme=theme
)
```

## 🎨 Themes

Capturing the mood of your city:

- **Noir**: Classic high-contrast black and white.
- **Terracotta**: Warm Mediterranean clay tones.
- **Neon Cyberpunk**: Electric pinks and cyans on deep indigo.
- **Midnight Blue**: Elegant navy and gold.
- **Blueprint**: Technical architectural aesthetic.
- *...and many more! Use `map2poster --list-themes` to see them all.*

## 📜 License

Distributed under the MIT License. See `LICENSE` for more information.

---
Created with ❤️ by **Anton Vice** ([a1996nton@gmail.com](mailto:a1996nton@gmail.com))
ai-commander 0.1.0
CLI framework orchestration and AI-powered command execution
Requires Python: >=3.10
Keywords: ai, cli, command, orchestration

# Commander

CLI framework orchestration and AI-powered command execution.

> **Note**: This project was extracted from [claude-mpm](https://github.com/masa/claude-mpm) to serve as a standalone CLI framework.

## Installation

```bash
# Basic installation
pip install ai-commander

# With OAuth support
pip install ai-commander[oauth]

# Development installation
pip install -e ".[dev]"
```

## Usage

```bash
# Run commander
commander --help
```

## Development

### Setup

```bash
# Clone the repository
git clone https://github.com/masa/commander.git
cd commander

# Create virtual environment
python -m venv .venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate

# Install with dev dependencies
pip install -e ".[dev]"

# Install pre-commit hooks
pre-commit install
```

### Running Tests

```bash
# Run tests with coverage
pytest

# Run specific test file
pytest tests/test_example.py -v
```

### Code Quality

```bash
# Run linter
ruff check src/ tests/

# Run formatter
ruff format src/ tests/

# Run type checker
mypy src/
```

## License

MIT License - see [LICENSE](LICENSE) for details.
formularity-dag 0.1.0
A declarative Python library for building computation DAGs
Requires Python: >=3.10
Keywords: computation, dag, dataflow, formula, graph, reactive

# formularity-dag

A declarative Python framework for building computation/formula DAGs (Directed Acyclic Graphs).

## Installation

```bash
pip install formularity-dag

# With JSON serialization support
pip install formularity-dag[json]
```

## Quick Start

```python
from formularity_dag import InputPlaceholder, ContextPlaceholder, compute, formula_dataclass

# Define a dataclass for structured data
@formula_dataclass
class TaxConfig:
    rate: float = 0.1
    name: str = "Sales Tax"

# Declare inputs
price = InputPlaceholder("price", float, "Item price", default_val=10.0)
quantity = InputPlaceholder("quantity", int, "Number of items", default_val=1)

# Declare context (environment parameters)
tax_config = ContextPlaceholder("tax_config", TaxConfig, "Tax configuration", default_val=TaxConfig())

# Define computations - dependencies are automatically wired by parameter names
@compute
def subtotal(price, quantity):
    return price * quantity

@compute
def tax_amount(subtotal, tax_config):
    return subtotal * tax_config.rate

@compute(is_output=True)
def total(subtotal, tax_amount):
    return subtotal + tax_amount
```

## Evaluating the Graph

```python
# The graph is automatically created in the module
graph = __compute_graph__

# Evaluate with inputs
result = graph.evaluate({
    "price": 25.0,
    "quantity": 3,
    "tax_config": {"rate": 0.08, "name": "State Tax"}
})

print(result['outputs'])  # {'total': 81.0}
print(result['state'])    # {'subtotal': 75.0, 'tax_amount': 6.0, 'total': 81.0}
```

## Features

- **Declarative syntax**: Define inputs and computations, let the framework handle wiring
- **Automatic dependency resolution**: Parameter names match node names automatically
- **Type hints support**: Full support for Python type annotations
- **Dataclass integration**: First-class support for dataclasses with optional JSON serialization
- **Input/Context separation**: Distinguish between user inputs and environment configuration
- **Output marking**: Tag specific nodes as final outputs

## API Reference

### Placeholders

- `InputPlaceholder(name, dtype, description, default_val, is_required)` - Declare an input node
- `ContextPlaceholder(name, dtype, description, default_val, is_required)` - Declare a context node

### Decorators

- `@compute` - Register a computation node
- `@compute(is_output=True)` - Register as an output node
- `@compute(mapping={'param': 'node_name'})` - Custom parameter-to-node mapping
- `@formula_dataclass` - Combined `@dataclass` + `@dataclass_json` decorator

### Utilities

- `is_dataclass_type(dtype)` - Check if a type is a dataclass
- `dataclass_to_dict(obj)` - Convert dataclass instance to dict
- `dict_to_dataclass(data, dtype)` - Convert dict to dataclass instance

## License

MIT