semvec/pypi-packages huggingface dataset:
synsc-context-proxy 1.2.1
Lightweight MCP proxy for SyntheticSciences Context — gives AI agents deep code, research paper, and HuggingFace dataset context.
Requires Python: >=3.10
Keywords: ai, claude, code-search, cursor, datasets, huggingface, mcp, research-papers, semantic-search

Lightweight MCP proxy for [Synsc Context](https://context.syntheticsciences.ai). Gives AI agents (Claude, Cursor, etc.) deep code, research paper, and HuggingFace dataset context via 25 tools. Only needs an API key — no heavy dependencies.
ebsl 0.1.0
The ensemble binomial subjective logic framework
Requires Python: >=3.12

## Introduction

The `ebsl` is a Python module implementing the Ensemble Binomial Subjective Logic framework, a binary ensemble classifier (based on subjective logic) that provides dynamic weighting.

The C++ extension is documented [here](https://a-h-ismail.gitlab.io/ebsl-ids-docs/).

## Installation

The EBSL framework is installable using `pip`. Simply run `pip install ebsl`. The instructions below are for building from source.

### Dependencies

- Python (>= 3.12)
- Numpy (>= 2.0)
- Pandas

You will also need a C++20 compliant compiler to compile the C++ extension and `cmake`.

### Building using pip

Clone the repository and move into its directory:
```
git clone --recurse-submodules https://github.com/a-h-ismail/ebsl-ids.git
cd ebsl-ids
```

Then install using `pip`:
```
pip install .
```
The extension will be automatically built and installed globally. Adapt the command as needed for virtual environments.
stown 1.2.1
Manage file system object mapping via symlinks. Lightweight alternative to GNU Stow.
Requires Python: >=3.9
Keywords: symlinks-manager, symlinks, lightweight, dotfiles

stown
=====

"stown" manages file system object mapping via symlinks. It was inspired by GNU
Stow, which I found very useful but too unwieldly for my personal use. GNU Stow
relies on a number of Perl modules and can be a hassle to install on
minimalistic systems. In contrast, stown requires only Python 3.9 or newer,
without any additional dependencies.

If you are looking for a lightweight tool instead of a full-fledged symlink
farm manager, stown might be for you.

Comprehensive [documentation](https://www.seichter.de/stown/) is provided in
HTML and [PDF](https://www.seichter.de/stown/stown.pdf) format.

Installing
----------

To install the [PyPI package](https://pypi.org/project/stown/), you can use
this shell command:

```bash
pip install stown
```

Example use case
----------------

If you store your dotfiles in a special repository, like many of us do, the
following simple statement can help you quickly set up a new user account with your
favourite settings:

```bash
stown $HOME /path/to/dotfiles
```

This brief teaser is obviously not much to go by. Please see the [full
documentation](https://www.seichter.de/stown/) for detailed information about
how stown is used and how it operates.
sage-sanctum-sdk 0.4.0
SDK for building agents that run within Sage Sanctum infrastructure
Requires Python: >=3.11
Keywords: sage-sanctum, agent-sdk, spiffe, security

# Sage Sanctum Agent SDK

SDK for building agents that run within the [Sage Sanctum](https://sagesecurity.ai) secure multi-agent execution platform.

## Features

- **SPIFFE Authentication** - Automatic JWT SVID management for agent identity
- **Transaction Tokens (TraT)** - IETF-standard authorization for scoped transactions
- **LLM Gateway Integration** - Route LLM calls through authenticated, policy-enforced gateways
- **Multi-Provider Support** - OpenAI, Anthropic, and Google via unified interface
- **SARIF Output** - Standard static analysis output format for GitHub Code Scanning
- **Testing Utilities** - Mock gateway, LLM, and TraT clients for unit testing

## Quick Start

```python
from sage_sanctum import AgentContext, AgentRunner, SageSanctumAgent, AgentResult
from sage_sanctum.io.inputs import AgentInput, RepositoryInput
from sage_sanctum.io.outputs import SarifOutput, Finding, Location
from sage_sanctum.llm.model_category import ModelCategory


class MySecurityAgent(SageSanctumAgent):
    @property
    def name(self) -> str:
        return "my-security-agent"

    @property
    def version(self) -> str:
        return "0.1.0"

    async def run(self, agent_input: AgentInput) -> AgentResult:
        # Get an LLM client for analysis
        llm = self.context.create_llm_client(ModelCategory.ANALYSIS)

        # Your agent logic here...
        response = llm.invoke([...])

        return AgentResult(
            output=SarifOutput(
                tool_name=self.name,
                tool_version=self.version,
                findings=[...],
            ),
            exit_code=0,
        )


# Entry point
if __name__ == "__main__":
    import sys
    sys.exit(AgentRunner(MySecurityAgent).run())
```

## Installation

```bash
pip install sage-sanctum-sdk
```

## Architecture

Agents run in isolated containers with no direct network access. All external communication (LLM calls, MCP tools, packages) flows through authenticated gateways:

```
Agent Pod (seccomp: no AF_INET)
  └── Agent SDK
       ├── SPIFFE JWT (identity)
       ├── Transaction Token (authorization)
       └── Gateway Client (Unix socket)
            └── LLM Gateway → OpenAI / Anthropic / Google
```

## License

MIT
wj-spaceinvaders 1.0.0
Classic Space Invaders game for the terminal using ANSI colour and Unicode half-block graphics
Requires Python: >=3.14
Keywords: ansi, console, game, terminal, wj-spaceinvaders

# wj-spaceinvaders

Classic Space Invaders game for the terminal, rendered using ANSI 24-bit colour and Unicode half-block characters for full-colour pixel graphics.

**Python 3.14+ | stdlib only | No dependencies**

## Installation

```bash
pip install wj-spaceinvaders
```

## Usage

```bash
# Run the game
wj-spaceinvaders

# Or via module
python -m wj_spaceinvaders

# Show version
wj-spaceinvaders --version
```

## Controls

| Key          | Action     |
|--------------|------------|
| Left / Right | Move ship  |
| Space        | Fire       |
| P            | Pause      |
| Q / Escape   | Quit       |

## Scoring

| Alien      | Points |
|------------|--------|
| Squid      | 30     |
| Crab       | 20     |
| Octopus    | 10     |
| Mystery    | ?????  |

## Requirements

- Python 3.14+
- A terminal supporting ANSI 24-bit colour and Unicode
- Minimum terminal size: 80×30

## Development

```bash
make dev          # Set up development environment
make check        # Format check + lint
make format       # Auto-format code
make lint         # Run pyright type checker
make build        # Build wheel
make publish      # Publish to PyPI
```

## Licence

MIT License — Copyright (c) 2026 WaterJuice
provenanced 0.8.1
ProveIt: Cryptographically Provable AI Compliance for Banks
Requires Python: >=3.9
Keywords: provenance, ml, machine-learning, data-lineage, audit, compliance, fairness, fair-lending, disparate-impact, documentation, model-risk-management, sr-11-7, ecoa, eu-ai-act, banking

# ProveIt

Cryptographically provable AI compliance for banks: tamper-proof provenance tracking, fair lending analysis, and automated compliance documentation.

## Install

```bash
pip install -e .
pip install -e ".[all]"  # with sklearn, flask, postgres, shap, opentelemetry
```

## Quick Start

### Provenance Tracking

```python
import proveit

proveit.configure(dag=True)
apps = proveit.wrap(apps_df, "applications.csv")
credit = proveit.wrap(credit_df, "credit_bureau.csv")

df = apps.merge(credit, on="applicant_id")
risk_score = df["balance"] / df["limit"]

dag = proveit.get_dag_simple(risk_score)
print(dag.source_nodes)
```

### Fairness Analysis

```python
from proveit.fairness import FairLensEngine, FairLensConfig

config = FairLensConfig(
    protected_columns=["race", "gender", "age"],
    industry="lending",
)
engine = FairLensEngine(config=config)
results = engine.analyze(
    model=model, X_train=X_train, y_train=y_train,
    X_test=X_test, y_test=y_test, protected_data=prot_test,
)
print(results.disparate_impact_results)
```

### Compliance Documentation

```python
from proveit.docs import AutoDocEngine, TemplateType, ModelMetadata

engine = AutoDocEngine()
report = engine.generate(
    template=TemplateType.SR_11_7,
    model_metadata=ModelMetadata(
        name="Risk Model v2",
        version="2.1.0",
        model_type="XGBoost",
    ),
)
report.save("sr117_report.md")
```

## CLI

```bash
proveit fairness analyze --model m.pkl --data d.csv --protected race,sex --industry lending
proveit docs generate --template sr11-7 --model metadata.json
proveit docs templates
proveit dashboard
```

## Modules

| Module | Description |
|--------|-------------|
| `proveit` | Core provenance DAG engine with Merkle tree anchoring |
| `proveit.fairness` | Disparate impact, proxy detection, LDA search, adverse action codes |
| `proveit.docs` | SR 11-7, EU AI Act, Model Cards, ECOA, GDPR, NIST AI RMF, dbt |
| `proveit.compliance` | EU AI Act and ECOA compliance engines |
| `proveit.persistence` | SQLite, PostgreSQL, DuckDB, S3 storage backends |
| `proveit.integrations` | Airflow, Kubeflow, Prefect, Dagster, dbt, Vertex AI, SageMaker, Azure ML |
| `proveit.dashboard` | Flask-based provenance dashboard |

## Test

```bash
pytest tests/ -v
```

## Requirements

- Python >= 3.9
- numpy >= 1.24
- pandas >= 2.0
- scikit-learn >= 1.3

## License

Proprietary. Copyright (c) 2024-2026 Provenance, Inc. All rights reserved.