semvec/pypi-packages huggingface dataset:
tskit-arg-visualizer 0.1.2
Interactive visualization method for ancestral recombination graphs
Requires Python: >=3.7
Keywords: population genetics, tree sequence, ancestral recombination graph, visualization, D3.js

<p align="center">
  <img alt="ARG Visualizer Example" src="https://raw.githubusercontent.com/kitchensjn/tskit_arg_visualizer/master/images/tskit_arg_visualizer.png" width="500">
</p>

*Code for above image [here](https://github.com/kitchensjn/tskit_arg_visualizer/blob/main/docs/readme_figure.ipynb).*

A method for drawing ancestral recombination graphs from tskit tree sequences in Python using D3.js. ARGs are plotted using a D3's [force layout](https://github.com/d3/d3-force). All nodes have a fixed position on the y-axis set by fy. Sample nodes have a fixed position on the x-axis set by fx; the ordering of the sample nodes comes from the first tree in the tskit tree sequence (this is not always the optimal ordering but is generally a good starting point for plotting). The x positions of other nodes are set by a force simulation where all nodes repel each other countered by a linkage force between connected nodes in the graph.

Users can click and drag the nodes (including the sample) along the x-axis to further clean up the layout of the graph. The simulation does not take into account line crosses, which can often be improved with some fiddling. Once a node has been moved by a user, its position is fixed with regards to the force simulation.

See [tutorial.md](https://github.com/kitchensjn/tskit_arg_visualizer/blob/main/docs/tutorial.md) for a walkthrough of the package.
mcp-nix 0.4.0
MCP server for Nixpkgs, NixOS and Home Manager
Requires Python: >=3.13
Keywords: ai, claude, home-manager, llm, mcp, model-context-protocol, nix, nixos

# A complete MCP server for Nix*
[![Tests](https://github.com/felixdorn/mcp-nix/actions/workflows/test.yml/badge.svg)](https://github.com/felixdorn/mcp-nix/actions/workflows/test.yml)

## Features
* **Search Nixpkgs and read package derivations**
* **Broad options coverage**
  * NixOS
  * Home Manager
  * Nix Darwin
  * Other: Nixvim Impermanence, MicroVM.nix, nix-nomad, simple-nixos-mailserver, sops-nix, nixos-hardware, disko.
* **Search the nix standard library and read function definitions**
* **Find versions of nixpkgs in which a package exists**

## Installation

Use the following configuration to add the MCP server to your client:

**Using uvx:**

```json
{
  "mcpServers": {
    "nix": {
      "command": "uvx",
      "args": ["mcp-nix"]
    }
  }
}
```

**Using nix run:**

```json
{
  "mcpServers": {
    "nix": {
      "command": "nix",
      "args": ["run", "github:felixdorn/mcp-nix"]
    }
  }
}
```

**Declaratively:**

Add the flake input:

```nix
{
  inputs.mcp-nix.url = "github:felixdorn/mcp-nix";
}
```

Then reference the package:

```nix
{
  command = "${inputs.mcp-nix.packages.${system}.default}/bin/mcp-nix";
}
```

### Tools

| Tool | Description |
|------|-------------|
| `search_nixpkgs` | Search Nixpkgs packages |
| `read_derivation` | Read package source code |
| `search_options` | Search options for many projects |
| `list_versions` | List available versions for a project |
| `show_option_details` | Get option details or list children |
| `read_option_declaration` | Read option source code |
| `find_nixpkgs_commit_with_package_version` | Get nixpkgs commit for a version, shows available versions if not found (NixHub) |
| `search_nix_stdlib` | Search Nix stdlib functions (Noogle) |
| `help_for_stdlib_function` | Get help for a stdlib function (Noogle) |

### Excluding Tools

Use `--exclude` to disable specific tools:

```json
{
  "mcpServers": {
    "nix": {
      "command": "uvx",
      "args": ["mcp-nix", "--exclude=read_derivation,read_option_declaration"]
    }
  }
}
```

### Contributing
Read [CONTRIBUTING.md](CONTRIBUTING.md)

### Acknowledgments
Thanks to the [NixOS Search Team](https://search.nixos.org), [ExtraNix](https://extranix.com), [NüschtOS](https://github.com/NuschtOS/search), [nix-nomad](https://github.com/tristanpemble/nix-nomad), [NixHub](https://nixhub.io), [Noogle](https://noogle.dev) for maintaining the backends and pipeline this server uses and for the Nix community for making any of this possible.

### License
GPLv3: [License](LICENSE)

    <!-- mcp-name: io.github.felixdorn/mcp-nix -->
aave 0.0.0
Ape SDK for interacting with Aave protocols
Requires Python: >=3.10
Keywords: ethereum, ape, aave, defi

# Overview

Ape-based SDK for working with deployments of the Aave family of protocols

## Dependencies

- [python](https://python.org/downloads) v3.10+, python3-dev
- [Ape](https://docs.apeworx.io/ape/stable/userguides/overview#installation) v0.8+

## Installation

### via `pip`

You can install the latest release via [`pip`](https://pypi.org/project/pip):

```sh
pip install aave
```

### via `uv`

You can install the latest release via [`uv`](https://docs.astral.sh/uv):

```sh
uv pip install aave
```

## Quick Usage

### Scripting

The SDK can be used for any scripting task:

```python
>>> from aave import Aave
>>> aave = Aave()
>>> market = Aave.all_markets[0]
>>> pos = market.get_position(<acct>)
>>> pos.ltv
Decimal('0.56')
>>> pos.health_factor
Decimal('1.48')
>>> pos.repay("<TOKEN>", amount="100 TOKEN", sender=me)
```

### CLI

TBD

### Silverback

TBD

## Development

This project is in development and should be considered a beta.
Things might not be in their final state and breaking changes may occur.
Comments, questions, criticisms and pull requests are welcomed.

### Support

Support for different parts of the Aave protocols:

- [ ] V1 (deprecated)
- [ ] V2 (deprecated)
- [x] V3 (actively used)
- [ ] V4 (protocol unreleased)
- [ ] Aave staking

## License

This project is licensed under [Apache 2.0](./LICENSE).
pygluon 1.0.0
Gluon simulator library for python.
Requires Python: >=3.10

# pygluon

Gluon simulator library for Python. Simulates the Gluon protocol's reactor mechanics including fission, fusion, and beta decay reactions.

## Installation

```bash
pip install pygluon
```

## Quick Start

```python
from pygluon.reactors import GluonZReactor
from pygluon.reactors.types import (
    GluonReaction,
    GluonZReactorParameters,
    GluonZReactorState,
    Tokeons,
)

# Configure reactor parameters
params = GluonZReactorParameters(
    critical_neutron_ratio=0.5,
    fission_fee=0.01,
    fusion_fee=0.01,
    beta_decay_fee_slope=0.1,
    beta_decay_fee_intercept=0.005,
    volume_decay_factor=0.99,
)

# Initialize reactor state
state = GluonZReactorState(
    reserves=1000.0,
    neutron_circulating_supply=500.0,
    proton_circulating_supply=500.0,
    prev_volume_delta=0.0,
    prev_reaction_time=0.0,
)

# Create reactor instance
reactor = GluonZReactor(params, state)

# Execute a fission reaction (basecoins -> neutrons + protons)
result = reactor.execute(
    GluonReaction.FISSION,
    balance=100.0,
    neutron_target_price=1.0,
    reaction_time=1.0,
)
print(f"Received: {result.reactor_output}")
print(f"New reserves: {result.reactor_state.reserves}")
```

## Reactions

The Gluon protocol supports four reaction types:

- **FISSION**: Convert basecoins into neutrons and protons
- **FUSION**: Convert neutrons and protons back into basecoins
- **BETA_DECAY_PLUS**: Convert protons into neutrons
- **BETA_DECAY_MINUS**: Convert neutrons into protons

## Types

The library uses type aliases for documentation:

- `Basecoin` - Reserve currency amounts (`float`)
- `Neutron` - Neutron token amounts (`float`)
- `Proton` - Proton token amounts (`float`)
- `BasecoinPerNeutron` - Price ratio (`float`)
- `BasecoinPerProton` - Price ratio (`float`)
- `Tokeons` - A dataclass containing neutrons and protons

## License

MIT
apibean-jupyter 0.1.0a4
Embed and manage Jupyter Server as a reusable Python component for applications and tools.
Requires Python: <4.0,>=3.9

# apibean-jupyter

**apibean-jupyter** is an infrastructure library for embedding and managing
a Jupyter Server as a reusable Python component.

Instead of treating Jupyter as a standalone application, apibean-jupyter
allows you to launch, configure, and control a Jupyter Server programmatically,
making it suitable for tools, GUIs, notebooks automation, and managed processes.

---

## Why apibean-jupyter?

Jupyter is often started as a CLI tool (`jupyter lab`, `jupyter server`),
which makes it difficult to:

- Embed Jupyter inside another application
- Manage its lifecycle from Python code
- Integrate it with process managers or dashboards
- Reuse the same configuration across tools

apibean-jupyter solves this by exposing Jupyter Server as a **first-class
Python object** with a clear lifecycle and extension points.

---

## Features

- Embed Jupyter Server via a simple Python API
- Optional CLI for quick launching
- Clean separation between core logic and UI/tooling
- Plugin hooks for customization (kernels, extensions, reporters)
- Designed for `uv run` workflows and managed environments
- No dependency on GUI frameworks

---

## Installation

```bash
pip install apibean-jupyter
```

Or run it directly with `uv`:

```bash
uv run --with apibean-jupyter apibean-jupyter --root notebooks
```

---

## Quick Start (Python API)

```python
from apibean_jupyter import JupyterServer

server = JupyterServer(
    root_dir="notebooks",
    ip="127.0.0.1",
)

print("Starting Jupyter at:", server.url)
server.start()
```

---

## Command Line Usage

```bash
apibean-jupyter --root notebooks
```

Show server information without starting:

```bash
apibean-jupyter --info
```

---

## Using with `uv run`

`apibean-jupyter` is designed to work well with `uv`:

```bash
uv run --with apibean-jupyter apibean-jupyter --root notebooks
```

It can also be embedded into other tools that depend on it.

---

## Extending via Plugins

apibean-jupyter provides a lightweight plugin system to hook into the server
lifecycle:

* Pre/post initialization
* Pre/post server start
* Shutdown handling

This allows you to implement features such as:

* Kernel mapping
* JupyterLab extension configuration
* Metrics and reporting
* Integration with process managers

---

## Relationship to the apibean ecosystem

apibean-jupyter is part of the **apibean ecosystem**, a collection of libraries
and tools focused on testability, automation, and developer tooling.

It is designed to be used alongside:

* **apibean-notebook** – notebook automation and analysis
* **apibean-client** – API and service interaction

---

## Design Philosophy

* Prefer composition over inheritance
* Keep CLI logic thin and reusable
* Avoid tight coupling with UI frameworks
* Make production behavior explicit and reproducible

---

## License

MIT License