semvec/pypi-packages huggingface dataset:
azure_jobs 0.1.12
Add your description here
Requires Python: >=3.10

# Azure Jobs

A simple interface to manage Azure Jobs. Features include:

1. Create jobs from templates with flexible command line overrides.
2. Support global and local configurations by using `.azurejobs` files. (Credentials may be stored here.)
3. Pretty print job details, export status, link to custom dashboards.
4. Set up alerts for job events using simple hooks.

# Get started

1. Install the Azure Jobs CLI tool.

```bash
pipx install azure_jobs
```

2. Setup your credentials by running:

```bash
aj init
```

3. Pull templates from private repositories:

```bash
aj pull <repository-url>
```

4. Run jobs using the CLI:

```bash
aj run -t <template> <command> [args...]
```

# Template

A template consists of a YAML file defines:
1. The job's environment (e.g., AML, Singularity)
2. GPU, CPU resources required
3. Storages used.
4. Pre-execution commands (Environment preparation commands)
5. Account information (e.g., Azure subscription ID)

By default, `azure_jobs` will store environments in the `~/.azurejobs/environments` directory. Storage credentials will be stored in the `~/.azurejobs/storage` directory. Account information will be stored in the `~/.azurejobs/account` directory.

Templates will be stored in the `~/.azurejobs/templates` directory. A reserved template name is `default`, it will be updated automatically with the latest configuration.

# Configuration Structure

```yaml
base: base_configuration or a list of configurations to merge
config:
    example_a: value_a
    example_b: value_b
```

# Configuration Merging

Configuration can be merged by the following rules:
1. Dict configuration will be merged recursively.
2. List configuration will be merged by appending elements from the source list to the target list.
3. Scalar values will be replaced by the target value.

Here is the code for merging configurations:

```python
def merge_confs(*data):
    # merge multiple dictionaries or lists recursively
    if all(isinstance(d, dict) for d in data):
        merged = {}
        for d in data:
            for key, value in d.items():
                if key in merged:
                    merged[key] = merge_confs(merged[key], value)
                else:
                    merged[key] = value
        return merged
    elif all(isinstance(d, list) for d in data):
        merged = []
        for d in zip(*data):
            merged.append(merge_confs(*d))
        return merged
    return data[-1]
```
mcp-replay-dota2 1.2.0
Model Context Protocol server for Dota 2 match analysis using replay files
Requires Python: <3.13,>=3.12
Keywords: analysis, dota2, esports, mcp, model-context-protocol, replay

# MCP Dota 2 Match Analysis Server

[![Build Status](https://github.com/DeepBlueCoding/mcp-replay-dota2/actions/workflows/test.yml/badge.svg)](https://github.com/DeepBlueCoding/mcp-replay-dota2/actions/workflows/test.yml)
[![Documentation](https://img.shields.io/badge/docs-gh--pages-blue.svg)](https://deepbluecoding.github.io/mcp-replay-dota2/)
[![Python 3.12](https://img.shields.io/badge/python-3.12-blue.svg)](https://www.python.org/downloads/)

[FastMCP](https://github.com/jlowin/fastmcp) server for Dota 2 match analysis using replay files and OpenDota API.

**Built-in coaching instructions** guide LLMs to provide meaningful analysis - pattern recognition, objective rotations, networth swings linked to teamfights, and actionable coaching advice.

## Quick Start

### Local

```bash
git clone https://github.com/DeepBlueCoding/mcp-replay-dota2.git
cd mcp-replay-dota2
uv sync
uv run python dota_match_mcp_server.py
```

### Docker

```bash
docker build -t dota2-mcp-server .
docker run -p 8081:8081 dota2-mcp-server --transport sse
# Connect to http://localhost:8081/sse
```

## What It Does

- **Resources**: Static reference data (heroes, map, pro players/teams)
- **Tools**: Match analysis (deaths, combat log, objectives, timelines, drafts)
- **Instructions**: Built-in coaching guidance for meaningful LLM responses

See [full documentation](https://deepbluecoding.github.io/mcp-replay-dota2/) for API reference and integration guides.

## Development

```bash
uv run pytest                       # Run tests
uv run pytest -m "not integration"  # Skip slow tests
```

## License

MIT
mcp-reticle 0.1.0rc7
Real-time debugging proxy for MCP (Model Context Protocol) servers
Requires Python: >=3.8
Keywords: ai, debugging, llm, mcp, model-context-protocol, proxy

# mcp-reticle

**The Wireshark for the Model Context Protocol**

*See what your Agent sees.*

Reticle intercepts, visualizes, and profiles JSON-RPC traffic between your LLM and MCP servers in real-time — with zero latency overhead.

## Installation

```bash
pip install mcp-reticle
```

## Usage

Wrap your MCP server command with `mcp-reticle run`:

```bash
mcp-reticle run --name my-server -- python -m my_mcp_server
```

### Claude Desktop Configuration

Edit `~/Library/Application Support/Claude/claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "my-server": {
      "command": "mcp-reticle",
      "args": ["run", "--name", "my-server", "--", "python", "-m", "my_mcp_server"]
    }
  }
}
```

## Features

- **Deep Packet Inspection** — See raw JSON-RPC messages in real-time
- **Request/Response Correlation** — Automatically links responses to requests
- **Latency Profiling** — Color-coded latency indicators
- **Token Profiling** — Real-time token estimation per message
- **Multi-Session Support** — Debug multiple MCP servers simultaneously
- **Zero-Latency Proxy** — Microsecond overhead

## Documentation

Full documentation at [github.com/labterminal/mcp-reticle](https://github.com/labterminal/mcp-reticle)

## License

MIT
siili-coding-agents 0.2.1
Pre-built coding agents for AI-assisted software development
Requires Python: >=3.10
Keywords: agents, ai, claude, coding, cursor, developer-tools

# Siili Coding Agents

Pre-built coding agents powered by [siili-ai-sdk](https://pypi.org/project/siili-ai-sdk/) for AI-assisted software development.

## Features

- **Claude Code Agent**: Wrapper for Claude Code SDK with streaming support
- **Cursor Agent**: Integration with Cursor AI editor
- **SDK Integration**: Built on siili-ai-sdk for consistent streaming and message handling

## Installation

```bash
pip install siili-coding-agents
```

## Quick Start

### Claude Code Agent

```python
import anyio
from siili_coding_agents import ClaudeAgent, ClaudeCodeOptions

async def main():
    agent = ClaudeAgent(
        options=ClaudeCodeOptions(cwd="."),
        yolo=True  # Bypass permission prompts
    )
    
    async for block in agent.stream_blocks("Create a hello world script"):
        print(block)

anyio.run(main)
```

### Synchronous Usage

```python
from siili_coding_agents import ClaudeAgent

agent = ClaudeAgent()
agent.run("Fix the bug in main.py")
```

## Requirements

- Python 3.10+
- [siili-ai-sdk](https://pypi.org/project/siili-ai-sdk/) >= 0.2.0
- Claude Code SDK

## License

MIT License - Copyright (c) 2025 Siili Solutions Oyj
shimeri 0.2.0
A Python package for calculating psychrometric properties of moist air and plotting psychrometric charts.
Requires Python: >=3.9



# shimeri
![PyPI Downloads](https://static.pepy.tech/badge/shimeri)

A Python package for calculating psychrometric properties of moist air and plotting psychrometric charts based on plotly.

*shimeri* means "moisture" or "humidity" in Japanese.

## Installation

``` sh
pip install shimeri
```

## Example

Usage example: [example.py](https://github.com/yutaka-shoji/shimeri/blob/main/example/example.py?raw=true)

Example Result:  
![Example Result](https://github.com/yutaka-shoji/shimeri/blob/main/example/example.png?raw=true)


## Web App

*shimeri on web* is available at [shimeri-web.vercel.app](https://shimeri-web.vercel.app/).
palindrome-helper 0.1.0
A helper file is simple up your palindrome check

#  palindrome_helper

A simple and lightweight Python utility library for string-related operations.
This package currently provides a clean and reliable **palindrome checker**
that works with both **strings and integers**.

---

## ðŸš€ Features

- âœ… Check palindrome for strings
- âœ… Check palindrome for integers
- âœ… Case-insensitive
- âœ… Ignores spaces
- âœ… Beginner-friendly and lightweight
- âœ… No external dependencies

---

## ðŸ“¦ Installation

Install from PyPI using pip:

```bash
pip install palindrome_helper
run-weeklychallenge 1.0.6
Facilitates running a solution to https://theweeklychallenge.org using one or more sets of inputs provided as JSON command line arguments.
Requires Python: >=3.9

Facilitates running a solution to [the Weekly Challenge](https://theweeklychallenge.org) using one or more sets of inputs provided as JSON command line arguments.

Example usage running a "solution" to sum integers:

    def sum_of_ints(ints: list[int]) -> int:
        sum: int = 0
        i: int
        for i in ints:
            sum += i
        return sum
    
    if __name__ == '__main__':
        import run_weeklychallenge as run
        run.run_weekly_challenge(
            run_solution = lambda inputs: str(sum_of_ints(run.as_int_list(inputs, 'ints'))),
            inputs_example = '{"ints":[1,2,3]}',
            inputs_schema_json = '''{
                "type": "object",
                "properties": {
                    "ints": {
                        "type": "array",
                        "items": { "type": "integer" }
                    }
                },
                "required": ["ints"],
                "additionalProperties": false
            }'''
        )

Example output:

    $ python example.py '{"ints":[1,2,3]}' '{"ints":[]}'
    Inputs: {"ints":[1,2,3]}
    Output: 6
    Inputs: {"ints":[]}
    Output: 0

You must provide an example JSON inputs string (used in error messages), a JSON schema for inputs, and a shim function to run the solution given the decoded JSON inputs and reformat the output if desired.  To support type checking, helper functions are provided to extract properties of the JSON input as various types to pass to the solution in the shim function.
django-migrate-or-rollback 0.1.0
Management command to attempt Django migrations and rollback on failure
Requires Python: >=3.6
Keywords: django, migrations

# django-migrate-or-rollback

While single migrations in Django are atomic (as long as they have the default `atomic=True`),
a group of migrations are not.  Thus, when running migrations, you can have a partial
failure where some but not all of your migrations succeed.  This library fixes that.

This library provides a new management command `migrate_or_rollback`.  It's a drop-in
replacement for the Django builtin management command `migrate`.  Here's how it works:

1. Checks your database and current migration files for the latest migrations run per Django app.
2. Runs migrations as normal.
3. If migrations fail, it rolls back to the migrations identified in step 1.

## Instalation

`pip install django-migrate-or-rollback`

Alternatively, add `django-migrate-or-rollback` to your requirements.txt file.

Then, add `"django_migrate_or_rollback"` to your `INSTALLED_APPS` in settings.py, like so:

```
# settings.py
INSTALLED_APPS = [
    # ...
    "django_migrate_or_rollback",
]
```

## Usage

Run `python manage.py migrate_or_rollback` instead of the standard `migrate` command.

In particular, you should use `migrate_or_rollback` in place of `migrate` in your deployment scripts or CI/CD system.

`migrate_or_rollback` has all of the same options as `migrate`, such as the `--noinput` flag.


## Warning

This library assumes that your migrations are reversable.  Not all migrations are reversible.  Additionally, rolling back migrations only reverses schema doesn't rewind the database contents.

In particular:
* Deleted data (such as dropping columns or tables) won't be restored by rolling
back the migration that deletes it.  To avoid this, you should make fields
nullable in one deploy and delete them in the next.
* `RunPython` statements that are missing a `reverse` function will error on
rollback.  At a minimum, add `migrations.RunPython.noop` as a reverse function.
Additionally, RunPython reverse functions can be used to rewind changes to
database contents on migration rollback.
* A migration that deletes a non-nullable field will error on rollback.
To avoid this, make the field nullable in one deploy and delete it in the next.
bugpilot-cli 1.3.5
AI-Powered Autonomous Penetration Testing CLI
Requires Python: >=3.8

# BugPilot CLI

AI-Powered Autonomous Penetration Testing Tool

**Version**: 1.4.0  
**Author**: LAKSHMIKANTHAN K (letchupkt)  
**Status**: Production Ready  

---

## Overview

BugPilot CLI is an AI-powered command-line tool for penetration testing and security research. It combines the power of multiple AI models with built-in security knowledge tools.

## Features

- Multiple LLM support (Gemini, Groq, Claude, OpenAI, Ollama)
- Two operating modes: Forge (interactive) and Hacker (autonomous)
- Built-in CVE database lookup
- OWASP Top 10 2021 reference
- Auto-update system
- Rich terminal UI with 7 themes
- Session management and export
- Persistent operating modes

## Quick Start

### Installation

```bash
# Install dependencies
pip install -r requirements.txt

# Run BugPilot
python -m bugpilot
```

### First Time Setup

1. Add API key to `settings.yaml` or environment variable
2. Run `/settings` to configure
3. Type `/help` to see all commands

## Commands

```
/help          - Show all commands
/settings      - Configure settings
/update        - Check for updates
/cve <ID>      - Look up CVE information
/owasp [ID]    - Get OWASP Top 10 info
/mode          - Switch operating modes
/clear         - Clear screen
/exit          - Exit BugPilot
```

## Examples

### Look up a CVE
```bash
/cve CVE-2021-44228
```

### Search for product vulnerabilities
```bash
/cve search apache 2.4.49
```

### Get OWASP Top 10 info
```bash
/owasp A03
```

###Update BugPilot
```bash
/update check
/update install
```

## Architecture

BugPilot uses a hybrid execution model:
- Regex-based command parsing for CLI commands
- Direct Python function calls for tools (CVE, OWASP, etc.)
- LLM integration for AI-powered analysis
- Optional MCP support available

## Documentation

- `QUICKSTART.md` - Detailed quick start guide
- `SECURITY_TOOLS.md` - CVE and OWASP tools documentation
- `FINAL_PROJECT_STATUS.md` - Complete project status

## Requirements

- Python 3.8+
- See `requirements.txt` for full list
- API key for at least one LLM provider

## License

See LICENSE file

## Contributing

Contributions welcome! Please ensure all tests pass before submitting.

## Support

For issues and questions, refer to the documentation in the `docs_archive` folder or create an issue.

---

**Happy Hunting!**