semvec/pypi-packages huggingface dataset:
WuttaPOS 0.4.2
Point of Sale system based on Wutta Framework


# WuttaPOS

This is an old idea but a new effort, for a Python-based point of sale
system.

This project includes two primary components:

- web app and related daemons, to run on the server
- standalone GUI app, to run on the lanes

This project is in the very early stages and is not yet documented.
But in any case there *are* some docs, at
https://docs.wuttaproject.org/wuttapos/

The docs below will go away at some point, but are left here for now.


## Server

Make a virtual environment and install the app:

    python3 -m venv wuttapos
    source wuttapos/bin/activate
    pip install WuttaPOS[server]
    wuttapos install

For more info see
https://docs.wuttaproject.org/wuttjamaican/narr/install/index.html


## Terminal

It uses [Flet](https://flet.dev/) for the GUI toolkit.  The intended
use case is to run as a proper standalone GUI app on the lane desktop.

Flet has yet to reach a stable 1.0 version, although it's getting
close.  Some things have changed since this GUI app project first
began, and it needs refactoring to support newer Flet.  It currently
is pinning an older version so the code at least works.

So far, there is no installer per se.  For development purpose you can
install the server (above) and then within that same virtual
environment:

    pip install WuttaPOS[terminal]

The terminal and server apps will share the same database.  The terminal
probably requires more setup than just that, needs to be documented...

To launch the terminal app in GUI mode:

    wuttapos run

To run the terminal as a web server:

    wuttapos serve
roj 0.2.4
roj (run on jail) runs a command (login shell by default) on a local or remote jail
Requires Python: >=3.9

roj (Run On Jail)
=================

roj is a simple command-line tool that runs a command (login shell by default)
in the given jail, either locally or over SSH.

Examples:

```sh
roj abc
```

Runs a login shell in the local jail named `abc`.

```sh
roj -H adx ldap1 ps axl
```

Runs `ps axl` in the jail named `ldap1` on the remote SSH host `adx`.

```sh
roj
```

Shows the jails on the local host.

```sh
roj -H pbsp
```

Shows the jails on the remote SSH host `pbsp`.

iocage Compatibility
--------------------

[The `iocage` jail manager](https://github.com/iocage/iocage)
uses the `ioc-` prefix in its jail names.
To maintain compatibility with `iocage`,
by default `roj` shows and accepts jail names without the `ioc-` prefix.

Except if there is a conflict, then this prefix stripping behavior is disabled.
For example, if there is a jail `ioc-xyz` and there is also another jail `xyz`,
then the former is shown as and must be specified as `ioc-test`.

This behaviour can be disabled using the `-f`/`--full` flag.

SSH Host (`-H`/`--host`) Config
-------------------------------

The hostname given to `-H`/`--host` is provided verbatim to
[OpenSSH `ssh(1)`](https://www.freebsd.org/cgi/man.cgi?query=ssh&sektion=1)
so the name is subject to the usual
[configuration](https://www.freebsd.org/cgi/man.cgi?query=ssh_config&sektion=5)
settings.  For example, to use a shorthand alias, ex: `roj -Hadx`:

```
Host adx
        HostName adx-florence.bop.gov
```

SSH Pseudo TTY Allocation
-------------------------

Just like OpenSSH `ssh(1)`, by default login shells are run with a pseudo TTY,
and explicit commands are run without one.
This behavior can be overridden with `--tty`/`--no-tty`
(or `-t`/`-T`, as with `ssh(1)`).


Bash Completion
---------------

To use Bash completion support of `roj`:

```sh
complete -C 'roj --bash-complete' roj
```

It takes connection-related options (`-H`/`--host` and `-u`/`--user`)
so the following works as expected:

```sh
alias roj1='roj --host=server1'
complete -C `roj1 --bash-complete` roj1
```
haematite 0.1.0
Runtime support for Haematite notebooks - variable extraction and export API
Requires Python: >=3.9
Keywords: data-exploration, haematite, notebook, polyglot

# haematite

Runtime support for [Haematite](https://github.com/tomWhiting/haematite) notebooks.

## Installation

```bash
pip install haematite
```

## Usage

Export values from your notebook cells:

```python
import haematite as hm

# Export a specific value
data = [1, 2, 3, 4, 5]
hm.export("my_data", data)

# Take a snapshot of all local variables
hm.snapshot("checkpoint")
```

Exported values are automatically captured and can be used in subsequent cells or visualizations.

## API

### `hm.export(name: str, value: Any) -> None`

Export a named value. The value is captured at the point of the call, preserving its state at that moment.

### `hm.snapshot(label: str, filter: Optional[List[str]] = None) -> None`

Capture all local variables at the current point. Optionally filter to specific variable names.

## License

MIT
scicomp-molecular-mcp 0.1.6
MCP server for classical molecular dynamics simulations
Requires Python: >=3.11
Keywords: dynamics, gpu, mcp, model-context-protocol, molecular, physics, simulation

# scicomp-molecular-mcp

mcp-name: io.github.andylbrummer/molecular-mcp

MCP server for classical molecular dynamics simulations.

## Overview

This server provides tools for molecular dynamics simulations with support for various ensembles and interaction potentials:

- **Particle systems** - Create and manage systems of interacting particles
- **Interaction potentials** - Lennard-Jones and Coulomb interactions
- **Ensembles** - NVE (microcanonical), NVT (canonical), NPT (isothermal-isobaric)
- **Analysis tools** - Radial distribution functions, mean squared displacement, phase transitions
- **Visualization** - Trajectory rendering and density field visualization
- **GPU acceleration** - Optional CUDA acceleration for large systems

## Installation & Usage

```bash
# Run directly with uvx (no installation required)
uvx scicomp-molecular-mcp

# Or install with pip
pip install scicomp-molecular-mcp

# With GPU support
pip install scicomp-molecular-mcp[gpu]

# Run as command
scicomp-molecular-mcp
```

## Available Tools

### System Setup
- `create_particles` - Initialize particle system with temperature
- `add_potential` - Add Lennard-Jones or Coulomb interactions

### Simulation
- `run_md` - NVE ensemble (constant energy, volume)
- `run_nvt` - NVT ensemble (constant temperature, volume)
- `run_npt` - NPT ensemble (constant temperature, pressure)
- `get_trajectory` - Retrieve simulation trajectory data

### Analysis
- `compute_rdf` - Radial distribution function analysis
- `compute_msd` - Mean squared displacement
- `analyze_temperature` - Thermodynamic properties
- `detect_phase_transition` - Identify phase transitions
- `density_field` - Compute density field visualization

### Visualization
- `render_trajectory` - Animate particle trajectories

## Configuration

Enable GPU acceleration with environment variable:

```bash
MCP_USE_GPU=1 scicomp-molecular-mcp
```

## Examples

### 🎬 Visual Demos
Spectacular animated demonstrations:
- [Galaxy Collision](https://andylbrummer.github.io/math-mcp/docs/demos/galaxy-collision) - N-body gravitational dynamics

Run demos with Claude:
```bash
claude -p "Simulate two galaxies colliding" \
  --allowedTools "mcp__molecular-mcp__*"
```

### 📖 Code Examples
Practical tutorials in [EXAMPLES.md](EXAMPLES.md):
- Simple liquid simulation with Lennard-Jones
- Temperature & pressure control
- Diffusion coefficient calculation
- Ionic systems with Coulomb interactions

### 📚 Full Documentation
See the [API documentation](https://andylbrummer.github.io/math-mcp/api/molecular-mcp) for complete reference.

## Part of Math-Physics-ML MCP System

Part of a comprehensive system for scientific computing. See the [documentation](https://andylbrummer.github.io/math-mcp/) for the complete ecosystem.
scicomp-llm-mcp 0.1.6
MCP server for LLM training, fine-tuning, and experimentation
Requires Python: >=3.11
Keywords: gpt, language-model, llm, mamba, mcp, model-context-protocol, training

# LLM MCP Server

MCP server for LLM training, fine-tuning, and experimentation. Part of the scicomp-mcp suite.

## Features

- **Model Architectures**: GPT (Transformer decoder) and Mamba (State Space Model)
- **Tokenizers**: tiktoken, BPE, SentencePiece, character-level
- **Training**: AdamW, learning rate scheduling, gradient checkpointing, mixed precision
- **Evaluation**: Perplexity, loss, text generation

## Installation

```bash
uv sync --all-extras
```

## Usage

```bash
scicomp-llm-mcp
```

## Tools

### Model Management
- `create_model` - Create GPT or Mamba architecture
- `get_model_config` - Get model configuration
- `list_models` - List all models

### Tokenizers
- `create_tokenizer` - Create or load tokenizer
- `tokenize_text` - Tokenize text

### Datasets
- `load_dataset` - Load training dataset
- `prepare_dataset` - Prepare for training

### Training
- `create_trainer` - Configure training
- `train_step` - Execute training steps
- `get_training_status` - Monitor progress

### Evaluation
- `evaluate_model` - Evaluate on dataset
- `generate_text` - Generate text
- `compute_perplexity` - Compute perplexity

### Checkpoints
- `save_checkpoint` - Save model checkpoint
- `load_checkpoint` - Load from checkpoint

### Analysis
- `analyze_attention` - Analyze attention patterns
- `compute_gradient_norms` - Compute gradient norms
- `estimate_memory` - Estimate training memory requirements
- `compute_model_flops` - Compute model FLOPs
- `analyze_weights` - Analyze weight distributions
- `analyze_sparsity` - Compute model sparsity
- `analyze_norms` - Analyze layer norms
- `compare_models` - Compare model architectures

### Dataset Ablation
- `analyze_data_influence` - Compute sample influence
- `analyze_token_distribution` - Analyze token frequencies
- `analyze_sequences` - Compute sequence statistics
- `run_data_ablation` - Run ablation studies
- `suggest_augmentations` - Suggest data augmentation strategies

### Attention Visualization
- `visualize_attention` - Extract attention summary
- `analyze_attention_patterns` - Detect attention patterns
- `compute_head_rankings` - Rank heads by importance
- `compare_heads` - Compare attention heads

## License

MIT
jellyfin-letterboxd-sync 0.1.4
Sync watched status from Jellyfin to Letterboxd
Requires Python: >=3.13

# Jellyfin Letterboxd Sync

Sync your watched movies and episodes from Jellyfin to Letterboxd.

## Features

- Fetches watched movies and episodes from your Jellyfin server.
- Handles TV shows by mapping them to their series name (since Letterboxd supports some series/miniseries).
- Exports data to a CSV file compatible with Letterboxd import.
- Automates the upload process to Letterboxd using Playwright (browser automation).

## Installation

You can install this package via pip (or uv):

```bash
uv tool install jellyfin-letterboxd-sync
# or
pip install jellyfin-letterboxd-sync
```

Since this tool uses Playwright, you'll also need to install the browser binaries. This tool defaults to using Brave/Chrome, so ensure you have a Chromium-based browser installed or install the Playwright browsers:

```bash
uv run playwright install chromium
# or
playwright install chromium
```

## Usage

Run the sync tool with the required parameters:

```bash
jellyfin-letterboxd-sync \
  --jellyfin-url "https://your-jellyfin-server.com" \
  --jellyfin-user "your_jellyfin_username" \
  --jellyfin-api-key "YOUR_JELLYFIN_API_KEY" \
  --letterboxd-user "your_letterboxd_email" \
  --letterboxd-pass "your_letterboxd_password"
```

### Options

| Argument             | Description                              | Required | Default                      |
| -------------------- | ---------------------------------------- | -------- | ---------------------------- |
| `--jellyfin-url`     | URL of your Jellyfin server              | Yes      | -                            |
| `--jellyfin-user`    | Jellyfin username to sync from           | Yes      | -                            |
| `--jellyfin-api-key` | API Key generated in Jellyfin Dashboard  | Yes      | -                            |
| `--letterboxd-user`  | Letterboxd account email/username        | Yes      | -                            |
| `--letterboxd-pass`  | Letterboxd account password              | Yes      | -                            |
| `--csv-path`         | Temporary path for generated CSV         | No       | `/tmp/letterboxd_import.csv` |
| `--headless`         | Run browser in headless mode (invisible) | No       | `False`                      |

### Getting a Jellyfin API Key

1. Go to your Jellyfin Dashboard.
2. Navigate to **API Keys**.
3. Click **+** to create a new key.
4. Name it "Letterboxd Sync" (or similar).
5. Copy the generated key.

## Development

To run locally without installing:

```bash
uv run -m jellyfin_letterboxd_sync.main --help
```
pickledb 1.6
An in-memory key-value store using orjson.
Requires Python: >=3.10
Keywords: pickle, database, json, redis, asyncio, sqlite

[![Logo](https://patx.github.io/pickledb/logo.png)](https://patx.github.io/pickledb)

[pickleDB](https://patx.github.io/pickledb) is a fast, easy to use, in-memory Python 
key-value store with first class asynchronous support. It is built with the `orjson` 
module for extremely high performance. It is licensed under the BSD three-clause 
license. [Check out the website](https://patx.github.io/pickledb) for installation 
instructions, API docs, advanced examples, benchmarks, and more.

```python
from pickledb import PickleDB

db = PickleDB("example.json").load()
db.set("key", "value")

db.get("key")  # return "value"
```
fail-kit-lsp 2.0.0
F.A.I.L. Kit Language Server for Python - Forensic analysis for LangChain, CrewAI, and AutoGen
Requires Python: >=3.9
Keywords: ai-safety, audit, autogen, crewai, fail-kit, forensic, langchain, language-server, lsp

# F.A.I.L. Kit Python Language Server

Language Server Protocol (LSP) implementation for Python AI agent frameworks.

## Features

- **LangChain Support**: Analyze LangChain agents, tools, and chains
- **CrewAI Support**: Analyze CrewAI agents, tasks, and crews
- **AutoGen Support**: Analyze AutoGen agents and group chats
- **Real-time Diagnostics**: Issues appear as you type
- **Quick Fixes**: One-click fixes for common issues
- **Hover Information**: Detailed issue descriptions on hover

## Installation

```bash
pip install fail-kit-lsp
```

## Usage

### VS Code

Install the F.A.I.L. Kit VS Code extension, which automatically uses this LSP for Python files.

### Neovim (nvim-lspconfig)

```lua
require('lspconfig').fail_kit_lsp.setup{}
```

### Other Editors

Start the language server:

```bash
fail-kit-lsp
```

The server communicates over stdin/stdout using the Language Server Protocol.

## Detected Issues

| Rule | Category | Description |
|------|----------|-------------|
| FK001 | Audit | Tool call without receipt generation |
| FK002 | Reliability | LLM call without error handling |
| FK003 | Security | Hardcoded secrets in code |
| FK004 | Safety | Destructive operation without confirmation |
| FK005 | Resilience | LLM call without retry/timeout |
| FK006 | Audit | Missing provenance metadata |

## Example

```python
# This code will trigger FK001 and FK002 warnings

from langchain.agents import AgentExecutor
from langchain_openai import ChatOpenAI

llm = ChatOpenAI()  # FK002: No error handling

# FK001: No receipt generation
result = agent_executor.invoke({"input": "delete all files"})
```

With F.A.I.L. Kit fixes:

```python
from langchain.agents import AgentExecutor
from langchain_openai import ChatOpenAI
from fail_kit import generate_receipt, audit_logger

llm = ChatOpenAI()

try:
    result = agent_executor.invoke({"input": "delete all files"})
    
    receipt = generate_receipt(
        tool_name="agent_executor",
        input_data={"input": "delete all files"},
        result=result,
    )
    audit_logger.log_action(receipt)
    
except Exception as e:
    audit_logger.log_failure({
        "error_type": type(e).__name__,
        "error_message": str(e),
    })
    raise
```

## Configuration

Create a `fail-kit.toml` in your project root:

```toml
[fail-kit]
# Skip patterns
skip_patterns = ["*_test.py", "test_*.py", "conftest.py"]

# Severity overrides
[fail-kit.severity]
FK001 = "error"  # Treat as error instead of warning
FK005 = "hint"   # Treat as hint instead of info

# Custom patterns
[fail-kit.patterns]
tool_calls = ["my_custom_tool\\.run"]
```

## Development

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

# Run tests
pytest

# Type checking
mypy fail_kit_lsp

# Format code
black fail_kit_lsp
ruff check fail_kit_lsp
```

## License

MIT
scicomp-neural-mcp 0.1.6
MCP server for neural network training and experimentation
Requires Python: >=3.11
Keywords: deep-learning, mcp, model-context-protocol, network, neural, pytorch, training

# scicomp-neural-mcp

mcp-name: io.github.andylbrummer/neural-mcp

MCP server for neural network training and experimentation.

## Overview

This server provides tools for building, training, and analyzing neural networks:

- **Model building** - Pre-trained models (ResNet, MobileNet) and custom architectures
- **Dataset loading** - CIFAR-10, MNIST, ImageNet datasets with standard preprocessing
- **Training** - Full training loops with configurable learning rates and batch sizes
- **Evaluation** - Model evaluation, metrics computation, and analysis
- **Hyperparameter tuning** - Automated hyperparameter search
- **Export** - Export models to ONNX and TorchScript formats
- **GPU acceleration** - Optional CUDA acceleration for training

## Installation & Usage

```bash
# Run directly with uvx (no installation required)
uvx scicomp-neural-mcp

# Or install with pip
pip install scicomp-neural-mcp

# With GPU support (recommended for training)
pip install scicomp-neural-mcp[gpu]

# Run as command
scicomp-neural-mcp
```

## Available Tools

### Model Management
- `define_model` - Create neural network models (ResNet18, MobileNet, custom)
- `load_pretrained` - Load pretrained models from torchvision or Hugging Face
- `get_model_summary` - Get detailed layer-by-layer breakdown
- `export_model` - Export to ONNX or TorchScript

### Data Loading
- `load_dataset` - Load standard datasets (CIFAR-10, MNIST, ImageNet)
- `create_dataloader` - Create batched dataloaders with shuffling

### Training
- `train_model` - Train model on dataset with configurable parameters
- `get_experiment_status` - Monitor training progress
- `evaluate_model` - Evaluate on test set

### Analysis
- `compute_metrics` - Compute detailed performance metrics
- `confusion_matrix` - Generate confusion matrices
- `plot_training_curves` - Visualize loss and accuracy curves
- `visualize_predictions` - Inspect model predictions on samples

### Hyperparameter Optimization
- `tune_hyperparameters` - Automated hyperparameter search

## Configuration

Enable GPU acceleration with environment variable:

```bash
MCP_USE_GPU=1 scicomp-neural-mcp
```

## Examples

### 📖 Code Examples
Practical tutorials in [EXAMPLES.md](EXAMPLES.md):
- MNIST digit recognition (complete workflow)
- Transfer learning with ResNet
- Hyperparameter optimization
- Confusion matrix analysis
- Progressive learning path (beginner → advanced)

### 📚 Full Documentation
See the [API documentation](https://andylbrummer.github.io/math-mcp/api/neural-mcp) for complete API reference.

## Part of Math-Physics-ML MCP System

Part of a comprehensive system for scientific computing. See the [documentation](https://andylbrummer.github.io/math-mcp/) for the complete ecosystem.
scicomp-math-mcp 0.1.6
MCP server for symbolic algebra and GPU-accelerated numerical computing
Requires Python: >=3.11
Keywords: algebra, gpu, math, mcp, model-context-protocol, symbolic, sympy

# scicomp-math-mcp

mcp-name: io.github.andylbrummer/math-mcp

MCP server for symbolic algebra and GPU-accelerated numerical computing.

## Overview

This server provides tools for mathematical computation combining symbolic algebra with numerical computing:

- **Symbolic mathematics** - Equations, simplification, differentiation, integration (via SymPy)
- **GPU-accelerated numerics** - Fast array operations and linear algebra
- **Mathematical transforms** - FFT, optimization, root finding
- **Linear systems** - Solving systems of equations with GPU acceleration

## Installation & Usage

```bash
# Run directly with uvx (no installation required)
uvx scicomp-math-mcp

# Or install with pip
pip install scicomp-math-mcp

# Then run as a command
scicomp-math-mcp
```

## Available Tools

### Symbolic Computation
- `symbolic_solve` - Solve symbolic equations
- `symbolic_diff` - Compute derivatives
- `symbolic_integrate` - Compute integrals
- `symbolic_simplify` - Simplify expressions

### Numerical Computing
- `create_array` - Create arrays with various patterns
- `matrix_multiply` - GPU-accelerated matrix multiplication
- `solve_linear_system` - Solve Ax = b
- `fft` / `ifft` - Fast Fourier transforms
- `optimize_function` - Function minimization
- `find_roots` - Find function roots

## Configuration

Set the `MCP_USE_GPU` environment variable to enable GPU acceleration:

```bash
MCP_USE_GPU=1 scicomp-math-mcp
```

## Examples

### 📖 Code Examples
Practical tutorials in [EXAMPLES.md](EXAMPLES.md):
- Projectile motion with symbolic + numerical computation
- Chemical equilibrium analysis
- Fourier signal analysis
- Circuit analysis with linear systems
- Progressive difficulty (beginner → advanced)

### 📚 Full Documentation
See the [API documentation](https://andylbrummer.github.io/math-mcp/api/math-mcp) for complete API reference.

## Part of Math-Physics-ML MCP System

Part of a comprehensive system for scientific computing. See the [documentation](https://andylbrummer.github.io/math-mcp/) for the complete ecosystem.