semvec/pypi-packages huggingface dataset:
ag2-agentos 0.0.0a29
CLI tool for AG2 agent development with A2A protocol support
Requires Python: >=3.11
Keywords: a2a, ag2, agent, ai, cli

# AG2 CLI

A CLI tool for building, running, and deploying A2A-compatible agents.

## Installation

```bash
pip install ag2-cli
```

Or install from source:

```bash
git clone https://github.com/AG2Platform/ag2-cli.git
cd ag2-cli
pip install -e .
```

## Quick Start

### Create a new agent

```bash
ag2 init my-agent
cd my-agent
```

### Build and run with Docker

```bash
ag2 build
ag2 run
```

### Run natively (without Docker)

```bash
ag2 run --native
```

### Register with AgentOS

```bash
ag2 auth login
ag2 register https://my-agent.example.com
```

## Commands

### Authentication

```bash
ag2 auth login      # Login to AgentOS
ag2 auth logout     # Logout
ag2 auth whoami     # Show current user
```

### Agent Development

```bash
ag2 init [name]       # Create new agent project
ag2 create file.yaml  # Create agent from AgentFile
```

### Docker Lifecycle

```bash
ag2 build [path]    # Build agent Docker image
ag2 run [name]      # Run agent in Docker container
ag2 stop <name>     # Stop a running container
ag2 restart <name>  # Restart a container
ag2 logs <name>     # View container logs
ag2 ps              # List running containers
ag2 rm <name>       # Remove a container
ag2 rmi <name>      # Remove an image
ag2 images          # List built images
ag2 tag <src> <dst> # Tag an image
```

### Registry

```bash
ag2 register <url>  # Register running agent with AgentOS
ag2 agents          # List your registered agents
ag2 list            # List local agent images
```

### A2A Protocol

```bash
ag2 call <url> "message"  # Call any A2A agent
ag2 card show [path]      # Display agent card (from path or Docker image)
ag2 card validate [path]  # Validate A2A compliance
```

### Configuration

```bash
ag2 configure         # Interactive configuration wizard
ag2 config show       # Show current configuration
ag2 config set <k> <v> # Set configuration value
```

## AgentFile Format

The `agent.yaml` file defines your agent:

```yaml
name: "my-agent"
version: "1.0.0"
description: "My AI agent"

card:
  provider: "my-org"
  skills:
    - name: "default"
      description: "Default capability"
  auth:
    scheme: "bearer"

agent:
  model: "gpt-4o"
  system_prompt: |
    You are a helpful assistant.

build:
  python: "3.11"
  dependencies:
    - requests

deploy:
  replicas: 2
  memory: "1GB"
```

## A2A Protocol

This CLI generates A2A-compatible agents that implement:

- Agent Card at `/.well-known/a2a/agent-card.json`
- JSON-RPC 2.0 task endpoints
- SSE streaming support
- Standard authentication schemes

## Development

### Running tests

```bash
make test          # Run unit tests
make test-docker   # Run Docker lifecycle tests
make test-all      # Run all tests
```

### Documentation

```bash
make docs-install  # Install documentation dependencies
make docs          # Start local docs server
make docs-build    # Build documentation
```

## License

MIT
image-upscaling-api 2026.0.1
image-upscaling.net api client
Requires Python: >=3
Keywords: upscale, image upscale, ai, image-processing, image-upscaling, super-resolution, machine-learning, deep-learning, api, free


# image-upscaling-api

A simple Python wrapper for the [image-upscaling.net](https://image-upscaling.net) upscaling API.

## Installation
```bash
pip install image-upscaling-api
```

## Documentation

-   **Full API Documentation:** [image-upscaling.net/api.html](https://image-upscaling.net/api.html)
    
-   **Help on Model & Scale Config:** [get_upscalers_config](https://image-upscaling.net/get_upscalers_config)
- **Client ID:** 32 digits, 0-9, a-z, A-Z  
You can find your client id here: [image-upscaling.net/account](https://image-upscaling.net/account/en.html)  
If you have an account with positive balance, you need to use your linked client id from the account page to use your balance in this api.
    

## Examples
### 1. Basic File Upscaling
- Uploads an image from disk and saves it back to disk. 
- upscaled by 4x using the "plus" model
- The upscaler encodes your image as png but you can save it as any opencv supported extension.

```Python
from image_upscaling_api import UpscalerAPI

api = UpscalerAPI(client_id="a9898cb899c1542468b8555e59dfa331")

# Upload (scale: 4, model: plus)
img_id = api.upload("baboon.png", model="plus", scale=4, face_enhance=False)

# Download and save as jpg
api.wait_and_download(img_id, save_path="./baboon_upscaled.jpg")

```

### 2. OpenCV & Diffuser
- uses opencv images for upload and download
- uses diffuser model with fixed output resolution (-1 = 4MPx)
- no save_path  -> image is returned as opencv image

```Python
from image_upscaling_api import UpscalerAPI
import cv2

api = UpscalerAPI(client_id="a9898cb899c1542468b8555e59dfa331")

image = cv2.imread("photo1.jpg")

# Upload with diffuser-lite and custom prompt
img_id = api.upload(image, model="diffuser-lite", scale=-1, prompt="", creativity=0.1)

# Download back into numpy array
upscaled = api.wait_and_download(img_id)
cv2.imwrite("upscaled_photo1.png", upscaled)

```

## Github

Find the source code here: [[dercodeKoenig/image-upscaling.net_API](https://github.com/dercodeKoenig/image-upscaling.net_API)]

## License

MIT
filesnap 0.1.2
A simple CLI to handle your files
Requires Python: >=3.12
Keywords: cli, files

# filesnap

`filesnap` is a command-line tool for managing files and directories.

## Commands

### `filesnap scan`

Scans all the files in the path.

| Argument | Description | Default |
|---|---|---|
| `path` | Path to scan | Current directory |

| Option | Alias | Description |
|---|---|---|
| `--recursive` | `-r` | Recursive search. |
| `--pretty` | `-p` | Pretty print the output in a table. |
| `--exclude` | | Exclude files/directories from scanning. |
| `--ext` | `-e` | Scan only files with these extensions. |

### `filesnap count`

Counts all the files by extension in the path selected.

| Argument | Description | Default |
|---|---|---|
| `path` | Path to count | Current directory |

| Option | Alias | Description |
|---|---|---|
| `--recursive` | `-r` | Recursive search. |
| `--exclude` | | Exclude files/directories from counting. |

### `filesnap clean`

Cleans the content of a path.

| Argument | Description |
|---|---|
| `path` | Path to clean |

| Option | Alias | Description |
|---|---|---|
| `--recursive` | `-r` | Recursive cleaning. |
| `--contain` | `-c` | Clean only files containing this string. |
| `--ext` | `-e` | Clean only files with these extensions. |
| `--exclude` | | Exclude files/directories from cleaning. |
| `--force` | `-f` | Force deletion without confirmation. |
| `--dry-run` | `--dry` | Simulate cleaning without deleting files. |

### `filesnap export`

Exports the filenames to a file.

| Argument | Description |
|---|---|
| `path` | Path to scan for filenames |

| Option | Alias | Description |
|---|---|---|
| `--type` | `-t` | The type of file to export to (e.g., `txt`, `csv`, `json`). |
| `--recursive` | `-r` | Recursive scanning. |
| `--output` | `-o` | The output file name. |
| `--format` | `-f` | The format of the output. |
| `--column` | `-c` | The column to export (defaults to `file_name`). |
mansil 0.1.2
Multi-language ANSI codes library
Requires Python: >=3.11
Keywords: ansi, colors, escape-codes, terminal

# mansil
Mansil is a ***M***ulti-language ***ANSI*** escape code ***L***ibrary

It provides the commonly used ANSI escape codes and helper functions for:

- Dart
- Go
- JS/TS
- Python
- Rust


## Install

```bash
# Dart
dart pub add mansil

# Go
go get github.com/vieolo/mansil

# JS/TS
npm install @vieolo/mansil

# Python
pip install mansil # using pip
uv add mansil # using uv

# Rust
cargo add mansil
```
pytklib 0.3.1
Easy Tkinter helper library
Requires Python: >=1.5.2

# pytklib

**pytklib** is an easy-to-use Tkinter helper library for Python.  
It lets you add buttons, labels, images, and sounds easily in Tkinter projects.

## Features

- Add unlimited buttons and labels
- Add images to buttons and labels

- Change window title and size
- Easy to start and hide windows

## Update releases
- 0.1.0 is the og release
- 0.2.0 adds moving and names system
- 0.2.1 adds a required python amount
- 0.3.0 adds labels
- 0.3.1 fixes a couple of things

## Example

```python
import pytklib

pytklib.add_label("Hello World!", 10, 10)
pytklib.add_button("Click Me", lambda: print("Hi!"), 50, 50)
pytklib.startwin()
wordly 0.4.0
A simple python client that requests dictionary definitions from a server that implements Dictionary Server Protocol
Requires Python: >=3.11
Keywords: wordly, definition, dictionary, DICT

# Wordly

A python client to communicate with servers implementing the
[Dictionary Server Protocol](https://datatracker.ietf.org/doc/html/rfc2229)

If you are using `uv`, you may use `wordly` like so:

```
❯ uvx wordly recalcitrant
"Recalcitrant" gcide "The Collaborative International Dictionary of English v.0.48"
Recalcitrant \Re*cal"ci*trant\ (r[-e]*k[a^]l"s[i^]*trant), a.
   [L. recalcitrans, p. pr. of recalcitrare to kick back; pref.
   re- re- + calcitrare to kick, fr. calx heel. Cf.
   {Inculcate}.]
   Kicking back; recalcitrating; hence, showing repugnance or
   opposition; refractory.
   [1913 Webster]
.
```

## Getting Started

```
pip install wordly
```

## Usage

Once installed you may use wordly from the command line:

```
$ wordly programming
"programming" wn "WordNet (r) 3.0 (2006)"
programming
    n 1: setting an order and time for planned events [syn:
         {scheduling}, {programming}, {programing}]
    2: creating a sequence of instructions to enable the computer to
       do something [syn: {programming}, {programing}, {computer
       programming}, {computer programing}]
.
```

Or you may import `Word` from `wordly` in your scripts.

```py
from wordly import Word

w = Word("curious")

print(w.definition)
```
sibyl-dev 0.3.0
CLI for Sibyl - Collective Intelligence Runtime for AI agents
Requires Python: >=3.13
Keywords: ai-agents, cli, knowledge-graph, mcp

# sibyl-cli

Command-line interface for Sibyl. REST API client with Rich terminal output, designed for humans and AI agents.

## Quick Reference

```bash
# Install
uv tool install sibyl-cli     # or: moon run install-cli

# Configure
sibyl config set server.url http://localhost:3334/api
sibyl auth login

# Link to project (scopes all commands)
sibyl project link <project_id>
```

## Core Commands

```bash
sibyl search "query"                    # Semantic search
sibyl add "title" "content"             # Add knowledge
sibyl task list --status todo,doing     # List tasks
sibyl task start <id>                   # Start task
sibyl task complete <id> --learnings "..." # Complete with learnings
```

## All Commands

| Command | Purpose |
|---------|---------|
| `search` | Semantic search |
| `add` | Add knowledge |
| `task` | Task lifecycle (list, start, complete, block, review) |
| `project` | Project management (list, link, create) |
| `epic` | Epic management (list, start, complete, roadmap) |
| `entity` | Entity CRUD |
| `explore` | Graph navigation (related, dependencies, communities) |
| `source` | Documentation sources (list, create, crawl) |
| `document` | View crawled documents |
| `auth` | Login, logout, API keys |
| `org` | Organization switching, member management |
| `config` | Configuration |
| `context` | Multi-server context management |
| `local` | Supabase-style local dev (start, stop, logs, reset) |

## Output Formats

```bash
sibyl task list              # JSON (default, for scripts)
sibyl task list --table      # Human-friendly
sibyl task list --csv        # Spreadsheets
```

## Context System

```bash
# Override for single command
sibyl --context myproject task list
SIBYL_CONTEXT=myproject sibyl task list

# Priority: --context flag > SIBYL_CONTEXT env > active context > path link
```

## Development

```bash
moon run cli:lint         # Ruff check
moon run cli:typecheck    # Pyright
moon run cli:test         # Tests
```

## SilkCircuit Colors

Terminal output uses the SilkCircuit palette:
- `#e135ff` Electric Purple — Headers
- `#80ffea` Neon Cyan — Interactions
- `#ff6ac1` Coral — Data/IDs
- `#50fa7b` Success Green
- `#ff6363` Error Red

## Dependencies

Depends on `sibyl-core` for shared models.
qubit-os-proto 0.1.0
Protocol Buffers for QubitOS quantum control kernel
Requires Python: >=3.11
Keywords: quantum, grpc, protobuf

# QubitOS Protocol Buffers

[![CI](https://github.com/qubit-os/qubit-os-proto/actions/workflows/ci.yaml/badge.svg)](https://github.com/qubit-os/qubit-os-proto/actions/workflows/ci.yaml)
[![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)

Protocol Buffer definitions for QubitOS - the open-source quantum control kernel.

## Overview

This repository contains the protocol buffer definitions that form the contract between QubitOS components:

- **quantum.common.v1** - Shared types (TraceContext, Timestamp, Error)
- **quantum.pulse.v1** - Pulse specifications (Hamiltonian, PulseShape, GRAPE)
- **quantum.backend.v1** - Backend service interface (ExecutePulse, Health, HardwareInfo)

## Installation

### Python

```bash
pip install qubit-os-proto
```

```python
from quantum.pulse.v1 import pulse_pb2, grape_pb2
from quantum.backend.v1 import service_pb2_grpc
```

### Rust

```toml
# Cargo.toml
[dependencies]
qubit-os-proto = "0.1"
```

```rust
use qubit_os_proto::quantum::pulse::v1::PulseShape;
use qubit_os_proto::quantum::backend::v1::quantum_backend_client::QuantumBackendClient;
```

## Structure

```
quantum/
├── common/v1/
│   └── common.proto      # Shared types
├── pulse/v1/
│   ├── hamiltonian.proto # System Hamiltonian specification
│   ├── pulse.proto       # Pulse waveform definition
│   └── grape.proto       # GRAPE optimization protocol
└── backend/v1/
    ├── service.proto     # QuantumBackend gRPC service
    ├── execution.proto   # Pulse execution messages
    └── hardware.proto    # Hardware info and health
```

## Build-Time Generation

Code is generated automatically at build time - no manual generation step needed.

**Rust:** `cargo build` runs `tonic-build` via `build.rs`

**Python:** `pip install .` runs `grpcio-tools` via `setup.py`

### For Contributors

If you need to lint or check protos directly:

```bash
# Install buf
brew install bufbuild/buf/buf  # macOS

# Lint protos
buf lint

# Format check
buf format -d

# Check for breaking changes (on PRs)
buf breaking --against 'https://github.com/qubit-os/qubit-os-proto.git#branch=main'
```

## Versioning

- Proto packages use path-based versioning: `quantum.pulse.v1`, `quantum.pulse.v2`
- The `proto_version` field in messages is informational only
- Breaking changes require a new package version (v2, v3, etc.)
- Deprecated versions are supported for at least 2 minor releases

## Documentation

- [Design Document](../docs/QubitOS-Design-v0.5.0.md)
- [Pauli String Grammar](docs/pauli-string-grammar.md)
- [Matrix Formats](docs/matrix-formats.md)

## License

Apache 2.0 - See [LICENSE](LICENSE) for details.