semvec/pypi-packages huggingface dataset:
simt-fly-machines 0.2.6
A python API to start, stop and list Fly.io machines
Requires Python: <4.0,>=3.13

# simt-py-fly-machines

[![Python checks](https://github.com/cepro/simt-py-fly-machines/actions/workflows/python-checks.yml/badge.svg)](https://github.com/cepro/simt-py-fly-machines/actions/workflows/python-checks.yml)

A python API to start, stop and list Fly.io machines using the [Machines REST API](https://docs.machines.dev/#description/introduction).

## Local Development

```
> python3 -m venv .venv
> source .venv/bin/activate

(.venv)> pip install -U pip setuptools
(.venv)> pip install poetry

(.venv)> poetry install
```

## Local Testing CLI (Fire)

Locally fire is available to invoke the API from CLI.

Example invocation:
```sh
# List machines
python -m simt_fly_machines.cli list mediators-hmce

# Create new machine
python -m simt_fly_machines.cli \
    create \
        mediators-hmce \
        simt-emlite:0.9.4 \
        '["simt_emlite.orchestrate.mediators"]' \
            --name "mediator-100.79.244.203" \
            --env_vars '{"EMLITE_HOST": "100.79.244.203"}' \
            --metadata '{"meter_id": "a4d636c3-9b13-4261-89ab-c018e86120e8"}'

# Destroy machine
python -m simt_fly_machines.cli destroy mediators-hmce d8dd67ea074138
```
accml 0.1.0
python accelerator middle layer
Requires Python: >=3.7

# accml: Accelerator middle layer

`accml` is a software stack designed to facilitate implementing tools 
 characterising (high) energy charged accelerator.

These tools typically address:
* characterising an accelerator
* commissioning of an accelerator
* forecasting the performance of an accelerator, which is currently under design.

For details of its concept see [design.md](https://github.com/python-accelerator-middle-layer/accml/design.md).

## 🚀 Installation and Running Instructions

### 1. Clone the Repository

```bash
git clone https://github.com/python-accelerator-middle-layer/accml.git
cd accml

### 2. Install Dependencies
```bash  
git checkout dev/main

git submodule update --init --recursive
```
### 3. Install the Package
```bash
python3 -m pip install -e .
```
### 4. Run the Virtual Accelerator (Test bench) --EPICS VERSION
```bash 
apptainer run oras://registry.hzdr.de/digital-twins-for-accelerators/containers/pyat-softioc-digital-twin:v0-1-2-bessy.2475331
```
Keep this terminal running — it simulates a virtual accelerator backend.
### 5. Run the pyAML Client (example)
```bash
cd examples/tune
python3 tune_response_measurement.py
```

### 4.1 Run the Virtual Accelerator (Test bench) --TANGO VERSION
## 4.1.1 Assuming mysql is runnig. or run below my sql container
```bash
where is mysql container
```

```bash
apptainer run oras://registry.hzdr.de/digital-twins-for-accelerators/containers/pyat-tango-digital-twin:v0-1-0.2554955
```
Keep this terminal running — it simulates a virtual accelerator backend.
### 5.1 Run the pyAML Client (example)
```bash
cd examples/tune
```
Comment line 14 and uncomment line 15 in tune_response_measurement.py. Then  it should look like this:

```python3

# from accml.custom.accml_lib.bessyii.setup import setup
from accml.custom.accml_lib.bessyii_on_tango.setup import setup

```
Now you can execute on the command line:

execute:
```bash
python3 tune_response_measurement.py
```
digital-valerii 0.1.0
AI Clone/Avatar of Valerii Sysoiev
Requires Python: <3.14,>=3.11

# Digital Valerii

[![CI](https://github.com/ValeriiSysoiev/digital-valerii/actions/workflows/ci.yml/badge.svg)](https://github.com/ValeriiSysoiev/digital-valerii/actions/workflows/ci.yml)

> AI Clone / AI Avatar - A persistent AI that thinks, speaks, and acts as Valerii

## Overview

Digital Valerii is an AI-powered digital clone with:

- **Persistent Memory** - Remembers all interactions, projects, people
- **Multiple Interfaces** - CLI, Web, Slack, Voice, Meeting Avatar
- **Task Execution** - Calendar, email, documents, browser automation
- **Continuous Learning** - Extracts lessons from experience

## Quick Start

```bash
# Clone and setup
cd digital-valerii

# Start local development environment
docker-compose up -d

# Install CLI
cd apps/cli && pip install -e .

# Run CLI
dv chat
```

## Documentation

- [Architecture](docs/ARCHITECTURE.md) - Full system design
- [Setup Guide](docs/SETUP.md) - Installation instructions
- [API Reference](docs/API.md) - API documentation

## Project Structure

```
digital-valerii/
├── docs/              # Documentation
├── apps/
│   ├── api/          # FastAPI Backend
│   ├── web/          # Next.js Dashboard
│   └── cli/          # CLI Interface
├── packages/
│   └── shared/       # Shared code
├── infrastructure/   # Docker, Railway, Azure configs
└── scripts/          # Utility scripts
```

## Tech Stack

| Component | Technology |
|-----------|------------|
| Agent | Claude Agent SDK + Claude Sonnet 4 |
| Backend | Python + FastAPI |
| Frontend | Next.js 15 |
| Database | PostgreSQL + Qdrant + Redis |
| Avatar | HeyGen Interactive |
| Meetings | Recall.ai |
| Voice | ElevenLabs |

## Development Phases

- [x] Phase 1: Architecture Design
- [ ] Phase 2: Foundation (Agent + Memory + CLI)
- [ ] Phase 3: Web Dashboard
- [ ] Phase 4: Slack Integration
- [ ] Phase 5: Voice & Avatar
- [ ] Phase 6: Production Polish

## License

Private - All rights reserved
hanzo-tools-computer 0.5.2
Computer control tools for Hanzo AI - automation, screen recording, activity detection, session compression for Claude (100 images/32MB/2000px limits)
Requires Python: >=3.12
Keywords: ai, automation, computer, hanzo, mcp, pyautogui, tools

# hanzo-tools-computer

Computer control tools for Hanzo AI - pyautogui-based Mac automation.

## Installation

```bash
pip install hanzo-tools-computer
```

## Usage

```python
from hanzo_tools.computer import ComputerTool, register_tools

# Register with MCP server
register_tools(mcp_server, permission_manager)
```

## Actions

### Mouse
- `click` - Click at (x, y)
- `double_click` - Double click at (x, y)
- `right_click` - Right click at (x, y)
- `move` - Move mouse to (x, y)
- `drag` - Drag to (x, y)
- `scroll` - Scroll by amount

### Keyboard
- `type` - Type text string
- `press` - Press single key
- `hotkey` - Press key combination

### Screen
- `screenshot` - Capture screen
- `locate` - Find image on screen
- `info` - Get screen/mouse info

## Examples

```python
# Click at coordinates
computer(action="click", x=100, y=200)

# Type text
computer(action="type", text="Hello world")

# Keyboard shortcut (Cmd+C on Mac)
computer(action="hotkey", keys=["command", "c"])

# Take screenshot
computer(action="screenshot")

# Get screen info
computer(action="info")
```

## Safety

- FAILSAFE enabled: Move mouse to corner to abort
- macOS only (checks platform)
- All actions run in executor threads (non-blocking)

## License

MIT
wetwire-azure 1.0.0
Azure ARM/Bicep template synthesis for wetwire
Requires Python: >=3.11
Keywords: arm, azure, bicep, dataclasses, iac, infrastructure

# wetwire-azure-python

[![Python Version](https://img.shields.io/badge/python-3.11%2B-blue)](https://www.python.org/downloads/)
[![License](https://img.shields.io/badge/license-MIT-green)](LICENSE)
[![CI Status](https://github.com/lex00/wetwire-azure-python/workflows/CI/badge.svg)](https://github.com/lex00/wetwire-azure-python/actions)
[![PyPI](https://img.shields.io/pypi/v/wetwire-azure)](https://pypi.org/project/wetwire-azure/)
[![codecov](https://codecov.io/gh/lex00/wetwire-azure-python/branch/main/graph/badge.svg)](https://codecov.io/gh/lex00/wetwire-azure-python)

Python implementation of wetwire for Azure ARM/Bicep templates.

## Overview

wetwire-azure enables defining Azure resources using Python dataclasses, with full type safety and IDE support. Write infrastructure as code using Python, get ARM templates as output.

## Installation

```bash
pip install wetwire-azure
```

## Quick Start

```python
from wetwire_azure.resources.compute import VirtualMachine
from wetwire_azure.resources.network import VirtualNetwork, Subnet

my_vnet = VirtualNetwork(
    name="my-vnet",
    location="eastus",
    properties={
        "addressSpace": {
            "addressPrefixes": ["10.0.0.0/16"]
        }
    }
)

my_vm = VirtualMachine(
    name="my-vm",
    location="eastus",
    properties={
        "hardwareProfile": {"vmSize": "Standard_DS1_v2"},
        # ...
    }
)
```

## Commands

- `wetwire-azure build` - Generate ARM templates from Python code
- `wetwire-azure lint` - Lint Azure resource definitions
- `wetwire-azure import` - Import existing ARM templates
- `wetwire-azure validate` - Validate against Azure schemas
- `wetwire-azure test` - Run synthesis tests with AI personas

See [docs/CLI.md](docs/CLI.md) for detailed command reference.

## Documentation

- [Quick Start](docs/QUICK_START.md) - Get started in 5 minutes
- [CLI Reference](docs/CLI.md) - Complete command documentation
- [Lint Rules](docs/LINT_RULES.md) - Available lint rules and best practices
- [Import Workflow](docs/IMPORT_WORKFLOW.md) - Convert ARM templates to Python
- [MCP Server](docs/MCP_SERVER.md) - Claude Code integration
- [FAQ](docs/FAQ.md) - Frequently asked questions
- [CLAUDE.md](CLAUDE.md) - AI assistant context

## Development

```bash
# Install dependencies
uv sync --all-extras

# Run tests
uv run pytest

# Lint code
uv run ruff check src/

# Type check
uv run ty check src/wetwire_azure/
```

## Contributing

Contributions are welcome! Please open an issue or pull request on GitHub.

## License

MIT
pie-server 0.2.5
Programmable Inference Engine
Requires Python: <3.13,>=3.10

# Pie

## Installation

### From PyPI (Recommended)

```bash
# For NVIDIA GPUs (includes CUDA dependencies)
pip install "pie-server[cuda]"

# For Apple Silicon (includes Metal dependencies)  
pip install "pie-server[metal]"

# Base installation (no GPU-specific packages)
pip install pie-server
```

### From Source

```bash
uv sync --extra cu128 # cu126, cu128, cu130 supported
```

### Verify Installation

```bash
pie doctor
```