semvec/pypi-packages huggingface dataset:
tushell 0.2.22
The Data Diver's best Intelligent and Narrative Command-Line Tooling you will have ever had

# tushell

The Data Diver's best Intelligent and Narrative Command-Line Tooling you will have ever had.

## Description

`tushell` is a CLI-native, recursive DevOps & narrative command tooling package designed to provide intelligent and narrative libraries and command-line tooling for data divers.

## Installation

To install `tushell`, use pip:

```bash
pip install tushell
```

## Usage

### Implemented Commands

* `get-memory`: Retrieve memory by key, with advanced Markdown/JSON output options.

```bash
tushell get-memory --key <keyname> [--md|--md-file|--mkey|--jkey]
```

- `--md` : Output as Markdown to stdout
- `--md-file <filename>` : Output as Markdown to a file
- `--mkey <keyname>` : Output as Markdown using the key as fallback if `--key` is omitted
- `--jkey <keyname>` : Output as JSON using the key as fallback if `--key` is omitted

See the [Markdown Output Ritual](../../docs/OUTPUTS.md) for full details and best practices.

* `draw-memory-graph`: Print an ASCII-rendered graph of the memory keys and Arc structure.

```bash
tushell draw-memory-graph
```

### FUTURE COMMANDS

The following commands are planned but not yet fully implemented:

* `scan-nodes`: Simulate scanning and listing nodes in the system.
* `flex`: Demonstrate flexible orchestration of tasks.
* `trace-orbit`: Trace and visualize the orbit of data or processes.
* `echo-sync`: Synchronize data or processes across nodes.

---

#### Markdown Output Ritual

`tushell get-memory` supports a recursive Markdown output ritual:
- The key is always the first section.
- Nested `"value"` fields unfold as sub-sections.
- All Markdown output modes (`--md`, `--md-file`, `--mkey`) use this structure.

See [OUTPUTS.md](../../docs/OUTPUTS.md) for detailed examples and best practices.
yllm-chat 0.1.0
A simple CLI tool for chatting with OpenAI-compatible APIs
Requires Python: >=3.10
Keywords: ai, chatgpt, cli, llm, openai

# yllm-chat

A simple CLI tool for chatting with OpenAI-compatible APIs.

## Installation

```bash
pip install yllm-chat
```

## Usage

### Command Line

```bash
# Direct message
yllm "Explain Python decorators"

# With custom system prompt
yllm -s "You are a Python expert" "What are generators?"

# Pipe input
echo "Summarize this" | yllm

# Disable streaming
yllm --no-stream "Hello"
```

### As a Library

```python
from yllm import chat_with_openai

# Streaming (prints to stdout)
chat_with_openai("Hello, world!")

# Non-streaming (returns string)
response = chat_with_openai("Hello", stream=False)
print(response)
```

## Configuration

Set these environment variables (or use a `.env` file):

| Variable          | Required | Description                                      |
| ----------------- | -------- | ------------------------------------------------ |
| `OPENAI_API_KEY`  | Yes      | Your API key                                     |
| `OPENAI_BASE_URL` | No       | Custom API endpoint (for OpenAI-compatible APIs) |
| `OPENAI_MODEL`    | No       | Model to use (default: `gpt-4o-mini`)            |

## Development

```bash
# Install in development mode
pip install -e ".[dev]"

# Run tests
pytest

# Lint
ruff check .
```

## License

MIT
buddy-ai-cli 0.1.1
Your AI Coding Assistant CLI
Requires Python: >=3.6

# Buddy - AI Coding Assistant

Buddy is a powerful CLI tool that leverages Groq's LLMs to help you write, explain, and refactor code directly from your terminal.

## Installation

```bash
pip install buddy-ai-cli
```

Or install from source:

```bash
git clone https://github.com/yeabwang/buddy.git
cd buddy
pip install .
```

## Configuration

### 1. Set up API Key
Buddy uses Groq. You need to set your API key first.

```bash
buddy config --key <YOUR_GROQ_API_KEY>
```

### 2. Health Check & Dependencies
Run `buddy config` without arguments to check your API key status and install dependencies from a `requirements.txt` if present in your current directory.

```bash
buddy config
```

## Usage

### Generate Code
Ask a question in a text file and get the code output.

```bash
# Create a question file
echo "Write a Python script to scrape a website" > question.txt

# Generate code
buddy code question.txt -a scraper.py
```

### Explain Code
Get a clear explanation of what a code file does.

```bash
buddy explain complex_script.py
```

### Refactor Code
Refactor code to be cleaner and more efficient.

```bash
# Print refactored code to stdout
buddy refactor legacy_code.py

# Save refactored code to a file
buddy refactor legacy_code.py -o clean_code.py
```

### Options
- `-m, --model`: Specify the LLM model to use (default: `openai/gpt-oss-20b`).
  ```bash
  buddy code question.txt -a answer.py -m llama3-70b-8192
  ```

## License

MIT
yapyrg 0.1.0
A blazingly fast recursive file searcher powered by Ripgrep engines.
Requires Python: >=3.8

# yapyrg

Python bindings for [ripgrep](https://github.com/BurntSushi/ripgrep)'s underlying crates (\`grep-searcher\` and \`ignore\`).

It provides a simple interface to search files recursively while respecting \`.gitignore\` rules.

![CI](https://github.com/brunoportis/yapyrg/actions/workflows/CI.yml/badge.svg)

## Installation

```bash
uv add yapyrg
```

## Usage

```python
import yapyrg

# Search recursively for "pattern" in the current directory
matches = yapyrg.search(".", r"pattern")

# Returns a list of dicts
for m in matches:
    print(f"{m['path']}:{m['line']} - {m['content']}")
```

## Development

```bash
uv run maturin develop
```
CMGDB 1.3.2
CMGDB (Conley Morse Graph Database) Python Extension

# CMGDB
Conley Morse Graph Database

## Overview

This project uses combinatorial and topological methods to compute dynamics of discrete dynamical systems.

## Installation

Install the latest tagged version:

	pip install CMGDB

To uninstall:

	pip uninstall CMGDB

## Documentation and examples

To get started on how to run the code see the examples in the Jupyter notebooks in the [examples](examples) folder.

In particular the notebooks [Examples.ipynb](examples/Examples.ipynb), [Gaussian\_Process\_Example.ipynb](examples/Gaussian_Process_Example.ipynb), and [Conley\_Index\_Examples.ipynb](examples/Conley_Index_Examples.ipynb) present basic examples on how to run the code and are a good starting point.

Here is an old [survey](http://chomp.rutgers.edu/Projects/survey/cmdbSurvey.pdf) and a
[talk](http://chomp.rutgers.edu/Projects/Databases_for_the_Global_Dynamics/software/LorentzCenterAugust2014.pdf) that might be useful.

## Installing from source and dependencies

To install from source you need a C++ compiler and the following dependencies installed: [Boost](https://www.boost.org/), [GMP](https://gmplib.org/), and the [Succinct Data Structure Library (SDSL)](https://github.com/simongog/sdsl-lite). Assuming you have these dependencies installed in your system, you can install from source with the command:

	pip install --force-reinstall --no-deps --no-cache-dir git+https://github.com/marciogameiro/CMGDB.git

Alternatively, you can clone the GitHub repository and install with:

	git clone https://github.com/marciogameiro/CMGDB.git
	cd CMGDB
	./install.sh
myliu-ragflow-mcp-server-continue 0.3.2
RAGFlow MCP Server Continue
Requires Python: >=3.10

# myliu-ragflow-mcp-server-continue MCP server

RAGFlow MCP Server Continue

## Components

### Resources

The server implements a simple note storage system with:
- Custom note:// URI scheme for accessing individual notes
- Each note resource has a name, description and text/plain mimetype

### Prompts

The server provides a single prompt:
- summarize-notes: Creates summaries of all stored notes
  - Optional "style" argument to control detail level (brief/detailed)
  - Generates prompt combining all current notes with style preference

### Tools

The server implements one tool:
- add-note: Adds a new note to the server
  - Takes "name" and "content" as required string arguments
  - Updates server state and notifies clients of resource changes

## Configuration

[TODO: Add configuration details specific to your implementation]

## Quickstart

### Install

#### Claude Desktop

On MacOS: `~/Library/Application\ Support/Claude/claude_desktop_config.json`
On Windows: `%APPDATA%/Claude/claude_desktop_config.json`

<details>
  <summary>Development/Unpublished Servers Configuration</summary>
  ```
  "mcpServers": {
    "myliu-ragflow-mcp-server-continue": {
      "command": "uv",
      "args": [
        "--directory",
        "/home/lmy01/project/myliu-ragflow-mcp-server-continue",
        "run",
        "myliu-ragflow-mcp-server-continue"
      ]
    }
  }
  ```
</details>

<details>
  <summary>Published Servers Configuration</summary>
  ```
  "mcpServers": {
    "myliu-ragflow-mcp-server-continue": {
      "command": "uvx",
      "args": [
        "myliu-ragflow-mcp-server-continue"
      ]
    }
  }
  ```
</details>

## Development

### Building and Publishing

To prepare the package for distribution:

1. Sync dependencies and update lockfile:
```bash
uv sync
```

2. Build package distributions:
```bash
uv build
```

This will create source and wheel distributions in the `dist/` directory.

3. Publish to PyPI:
```bash
uv publish
```

Note: You'll need to set PyPI credentials via environment variables or command flags:
- Token: `--token` or `UV_PUBLISH_TOKEN`
- Or username/password: `--username`/`UV_PUBLISH_USERNAME` and `--password`/`UV_PUBLISH_PASSWORD`

### Debugging

Since MCP servers run over stdio, debugging can be challenging. For the best debugging
experience, we strongly recommend using the [MCP Inspector](https://github.com/modelcontextprotocol/inspector).


You can launch the MCP Inspector via [`npm`](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm) with this command:

```bash
npx @modelcontextprotocol/inspector uv --directory /home/lmy01/project/myliu-ragflow-mcp-server-continue run myliu-ragflow-mcp-server-continue
```


Upon launching, the Inspector will display a URL that you can access in your browser to begin debugging.
aetheric 1.0.0
Cryptographic governance primitive — 4-of-5 quorum, Ed25519 seats, immutable ledger
Requires Python: >=3.9

# aetheric v1.0.0 — Cryptographic Governance Primitive

- 5-seat Ed25519 signing
- 4-of-5 quorum enforcement
- BLAKE3-chained immutable ledger
- Python, TypeScript, Go SDKs

```bash
pip install aetheric
npm install @aetheric/core
go get github.com/aetheric/core
multic4ll 0.0.1
aggregate results from multiple ethereum contract calls
Requires Python: <3.11,>=3.8

# okaswap/multic4ll

### ⚠️ Warn
This repository is a fork of the original project: https://github.com/banteg/multicall.py.git.
This repository is strictly intended for development testing purposes only.
 - Do not use the code from this repository in production environments or for general use.
 - The code here may be unstable, contain bugs, or cause errors.
Use at your own risk. It is recommended to refer to the original repository for a stable release.
rentclc 1.0.0
A generic rent calculation library for Python projects.
Requires Python: >=3.7

# rentcalc
A generic rent calculation library for Python.

## Install:
pip install rentcalc

## Example:
from rentcalc import RentCalculator
from datetime import date

RentCalculator.auto_calculate(1200, "monthly", date(2025,1,1), date(2025,6,1))
axmp-openapi-mcp-server 0.2.3
This is a template mcp server for the axmp-ai-agent-studio
Requires Python: <4.0,>=3.12

# MCP Inspector CLI for lowlevel server
```bash
$ npx @modelcontextprotocol/inspector uv --directory /Users/kks/IdeaProjects/aiops/axmp-openapi-mcp-server run axmp-openapi-mcp-server --transport stdio --endpoint https://api.ags.cloudzcp.net --access-key xxx --spec-path /Users/kks/IdeaProjects/aiops/axmp-openapi-mcp-server/openapi/zmp_mixed_api_spec.json
```

# fastmcp cli command
```bash
$ mcp dev src/axmp_openapi_mcp_server/fastmcp/zcp_alert_manager.py
$ mcp run src/axmp_openapi_mcp_server/fastmcp/zcp_alert_manager.py -t sse
$ mcp install src/axmp_openapi_mcp_server/fastmcp/zcp_alert_manager.py --name alert-manager --with zmp-openapi-toolkit,pyyaml
```

# How to run the lowlevel.server
## streamable-http
```bash
axmp-openapi-mcp-server --port 21000 --transport streamable-http \
--server-name axmp-mixed-openapi-mcp-server \
--profile-base-path /Users/kks/IdeaProjects/ai_agent_studio/axmp-openapi-mcp-server/mcp_profiles \
--profile-id=683734a65b3c20f3b1a4f721
```

## stdio
first install the axmp-openapi-mcp-server
```bash
pip install axmp-openapi-mcp-server
```

local test
```bash
axmp-openapi-mcp-server \
--transport stdio \
--profile-base-path /Users/kks/IdeaProjects/ai_agent_studio/axmp-openapi-mcp-server/mcp_profiles \
--profile-id 683734a65b3c20f3b1a4f721 \
--backend-server-auth-configs zcp-alert-backend:X-Access-Key=zmp-09bae73d-9f59-491a-ae06-7747e8f79883,zcp-mcm-backend:X-Access-Key=zmp-09bae73d-9f59-491a-ae06-7747e8f79883
```

then configure the mcp server into the mcp host like claude desktop or cursor
```json
{
  "mcpServers": {
    "axmp-openapi-mcp-server": {
      "command": "python3",
      "args": [
        "-m",
        "axmp_openapi_mcp_server",
        "--transport",
        "stdio",
        "--profile-base-path",
        "/Users/kks/IdeaProjects/ai_agent_studio/axmp-openapi-mcp-server/mcp_profiles",
        "--profile-id",
        "683734a65b3c20f3b1a4f721",
        "--backend-server-auth-configs",
        "zcp-alert-backend:X-Access-Key=zmp-09bae73d-9f59-491a-ae06-7747e8f79883,zcp-mcm-backend:X-Access-Key=zmp-09bae73d-9f59-491a-ae06-7747e8f79883"
      ]
    }
  }
}
```


# backup the claude desktop mcp conf
```json
{
  "mcpServers": {
    "axmp-openapi-mcp-server": {
      "command": "python3",
      "args": [
        "-m",
        "axmp_openapi_mcp_server",
        "--transport",
        "stdio",
        "--endpoint",
        "https://api.ags.cloudzcp.net",
        "--access-key",
        "xxxx",
        "--spec-path",
        "/Users/kks/IdeaProjects/aiops/axmp-openapi-mcp-server/openapi/zmp_mixed_api_spec.json"
      ]
    },
    "tavily-mcp": {
      "command": "npx",
      "args": ["-y", "tavily-mcp@0.1.4"],
      "env": {
        "TAVILY_API_KEY": "xxxxx"
      }
    },
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/kks/Desktop"
      ]
    }
  }
}
 ```
axe-playwright-python 0.1.7
Automated web accessibility testing using axe-core engine and Playwright.
Requires Python: >=3.8
Keywords: accessibility, axe, axe-core, playwright

# axe-playwright-python

Automated web accessibility testing using [axe-core](https://github.com/dequelabs/axe-core) engine
and [Playwright](https://playwright.dev/python/docs/intro).

## Documentation

- [Full documentation](https://pamelafox.github.io/axe-playwright-python/).

### Further Reading & More
- ["Automated accessibility audits" - Pamela Fox (North Bay Python 2023)](https://www.youtube.com/watch?v=J-4Qa6PSomM&pp=ygUUcGFtZWxhIGZveCBub3J0aCBiYXk%3D)
- [Using Python to Fix my Accessibility Night of a Website](https://kjaymiller.com/blog/using-python-to-fix-my-accessibility-nightmare-of-a-website.html) & [Website Accessibility Audit Reports via GH Actions](https://kjaymiller.com/blog/website-accessibility-audit-reports-via-gh-actions.html) by [Jay Miller](https://github.com/kjaymiller)


## Dependencies

- Python >= 3.10
- [playwright](https://github.com/microsoft/playwright-python) >= 1.25.0

## Installation

```console
python3 -m pip install -U axe-playwright-python
python3 -m playwright install --with-deps
```

## Usage

```python
from playwright.sync_api import sync_playwright
from axe_playwright_python.sync_playwright import Axe

axe = Axe()

with sync_playwright() as playwright:
    browser = playwright.chromium.launch()
    page = browser.new_page()
    page.goto("https://www.google.com")
    results = axe.run(page)
    browser.close()

print(f"Found {results.violations_count} violations.")
print(f"Full axe-core response: {results.response}")
```

For more examples see [documentation](https://pamelafox.github.io/axe-playwright-python/).

## Contributing

See [guide on contributing](CONTRIBUTING.md).

## Acknowledgments

This project is based on [axe-core-python](https://github.com/ruslan-rv-ua/axe-core-python) by @ruslan-rv-ua and also takes inspiration from [axe-selenium-python](https://pypi.org/project/axe-selenium-python/) for output formats.
anindit-aoc-cli 1.0.4
Advent of Code CLI with leaderboard integration and code quality grading
Requires Python: >=3.9
Keywords: advent-of-code, aoc, cli, competitive-programming, leaderboard

# AOC CLI

Advent of Code CLI with leaderboard integration.

## Installation

```bash
cd packages/cli-py
pip install -e .
```

## Usage

### Initialize configuration

```bash
aoc init
```

You'll be prompted for:
- Email, display name, AoC session token
- Language (press Enter for Python, the only built-in template)

This creates:
- `~/.aocconfig` - Your configuration
- `aoc/templates/python.py` - Customizable solution template
- `aoc/<year>/` - Directory for your solutions

**Note:** Only Python is supported out of the box. For other languages, create your own template at `aoc/templates/<language>.<ext>`.

### Get puzzle input

```bash
aoc get 2024/1
```

This will:
- Download your puzzle input to `in.txt`
- Copy your template to `solution.*`
- Extract a test case to `test.txt` (auto-parsed—verify manually)
- Register start time with the server
- Open the puzzle in your browser

**Note:** Only one test case is extracted. The expected answer is auto-parsed and may be incorrect.

### Run solution with real input

```bash
aoc run
# or
aoc run -p 2024/1
```

### Run solution against test cases

```bash
aoc test
# or
aoc test -p 2024/1
```

The expected output shown is auto-parsed from the problem page—always verify it's correct.

### Submit answer

```bash
aoc submit
# or
aoc submit -a 12345
# or
aoc submit -p 2024/1 -a 12345
```

The answer is parsed from the last line of your solution's stdout. The CLI will show you what it parsed—verify it's correct before submission.

## Solution Requirements

Your solution must:
1. Read input from `in.txt`
2. Print the final answer as the **last line** to stdout