semvec/pypi-packages huggingface dataset:
azure-mgmt-computebulkactions 1.0.0b1
Microsoft Azure Computebulkactions Management Client Library for Python
Requires Python: >=3.9
Keywords: azure, azure sdk

# Microsoft Azure SDK for Python

This is the Microsoft Azure Computebulkactions Management Client Library.
This package has been tested with Python 3.9+.
For a more complete view of Azure libraries, see the [azure sdk python release](https://aka.ms/azsdk/python/all).

## _Disclaimer_

_Azure SDK Python packages support for Python 2.7 has ended 01 January 2022. For more information and questions, please refer to https://github.com/Azure/azure-sdk-for-python/issues/20691_

## Getting started

### Prerequisites

- Python 3.9+ is required to use this package.
- [Azure subscription](https://azure.microsoft.com/free/)

### Install the package

```bash
pip install azure-mgmt-computebulkactions
pip install azure-identity
```

### Authentication

By default, [Azure Active Directory](https://aka.ms/awps/aad) token authentication depends on correct configuration of the following environment variables.

- `AZURE_CLIENT_ID` for Azure client ID.
- `AZURE_TENANT_ID` for Azure tenant ID.
- `AZURE_CLIENT_SECRET` for Azure client secret.

In addition, Azure subscription ID can be configured via environment variable `AZURE_SUBSCRIPTION_ID`.

With above configuration, client can be authenticated by following code:

```python
from azure.identity import DefaultAzureCredential
from azure.mgmt.computebulkactions import ComputeBulkActionsMgmtClient
import os

sub_id = os.getenv("AZURE_SUBSCRIPTION_ID")
client = ComputeBulkActionsMgmtClient(credential=DefaultAzureCredential(), subscription_id=sub_id)
```

## Examples

Code samples for this package can be found at:
- [Search Computebulkactions Management](https://docs.microsoft.com/samples/browse/?languages=python&term=Getting%20started%20-%20Managing&terms=Getting%20started%20-%20Managing) on docs.microsoft.com
- [Azure Python Mgmt SDK Samples Repo](https://aka.ms/azsdk/python/mgmt/samples)


## Troubleshooting

## Next steps

## Provide Feedback

If you encounter any bugs or have suggestions, please file an issue in the
[Issues](https://github.com/Azure/azure-sdk-for-python/issues)
section of the project. 

# Release History

## 1.0.0b1 (2026-02-10)

### Other Changes

  - Initial version
asteroid-odyssey 1.6.215
Python SDK for the Asteroid Agents API
Requires Python: >=3.9
Keywords: OpenAPI, Asteroid Agents API, browser automation, AI agents

# Asteroid Odyssey Python SDK

Python SDK for the Asteroid Agents API.

## Installation

```bash
pip install asteroid-odyssey
```

## Usage

```python
from asteroid_odyssey import ApiClient, Configuration, ExecutionApi

# Configure the client
config = Configuration(
    host="https://odyssey.asteroid.ai/agents/v2",
    api_key={"ApiKeyAuth": "your-api-key"}
)

client = ApiClient(config)
execution_api = ExecutionApi(client)

# Execute an agent
response = execution_api.agent_execute_post(
    agent_id="your-agent-id",
    agents_agent_execute_agent_request={"inputs": {"input": "value"}}
)
print(f"Execution ID: {response.execution_id}")
```

## Documentation

See [docs.asteroid.ai](https://docs.asteroid.ai) for full documentation.
wgc-clippy 1.0.2
Low-level utility helpers for WGC QA framework
Requires Python: >=3.7

# wgc-clippy

Low-level utility helpers for the WGC QA framework.

## Modules

- `cmd_helper` — subprocess command execution
- `waiter` — polling/wait utilities with timeout
- `os_helper` — OS-level file and process operations
- `registry` — Windows Registry read/write
- `process_helper` — process inspection and manipulation
- `regex_helper` — regex matching utilities
- `testrail_api` — TestRail API integration
- `torrents_helper` — torrent file operations
- `file_downloader` — HTTP file download
- `magic_folder` — temporary directory utilities

## Install

```bash
pip install wgc-clippy
```
open-dread-rando 2.19.0
An open source randomizer patcher for Metroid Dread.
Requires Python: >=3.10

# Open Dread Rando
Open Source randomizer patcher for Metroid Dread. Intended for use in [Randovania](https://randovania.github.io/).
Currently supports patching item pickups, starting items, and elevator/shuttle/teleportal destinations.

## Installation
`pip install open-dread-rando`

## Usage
You will need to provide JSON data matching the [JSON schema](https://github.com/randovania/open-dread-rando/blob/main/src/open_dread_rando/files/schema.json) in order to successfully patch the game. 

The patcher expects a path to an extracted romfs directory of Metroid Dread 1.0.0 or 2.1.0 as well as the desired output directory.
Output files are in a format compatible with either Atmosphere or Ryujinx, depending on the settings provided.

With a JSON file:
`python -m open_dread_rando --input-path path/to/dread/romfs --output-path path/to/the/output-mod --input-json path/to/patcher-config.json`

## Game Versions

Only versions 1.0.0 and the latest version are supported long term. Other versions might be compatible at any given point,
but new releases are free to remove that.

Currently, the following versions are supported:
- 1.0.0
- 2.1.0
xdof-sdk 0.0.1rc7
Useful libraries for interacting with xdof data and services.
Requires Python: >=3.9

# Getting Started

## Installation

```bash
# Base package
xdof-sdk

# With visualization dependencies (rerun)
xdof-sdk[viz]

# All optional dependencies
xdof-sdk[all]
```

## Data

## Visualization

Requires the `[viz]` or `[all]` extras to be installed.
openclaw-x402 0.1.0
Drop-in x402 payment middleware for Flask APIs. Machine-to-machine payments on Base chain.
Requires Python: >=3.8
Keywords: x402, openclaw, payments, flask, coinbase, base-chain, usdc, wrtc, ai-agent, machine-to-machine

# openclaw-x402

Drop-in x402 payment middleware for Flask APIs. Add machine-to-machine payments to any OpenClaw platform in 5 lines.

## Install

```bash
pip install openclaw-x402
```

## Quick Start

```python
from flask import Flask, jsonify
from openclaw_x402 import X402Middleware

app = Flask(__name__)
x402 = X402Middleware(app, treasury="0xYourBaseAddress")

@app.route("/api/premium/data")
@x402.premium(price="10000", description="Premium data export")  # $0.01 USDC
def premium_data():
    return jsonify({"data": "your premium content"})

# Free endpoints work normally — no decorator needed
@app.route("/api/public/data")
def public_data():
    return jsonify({"data": "free content"})
```

## How It Works

1. Agent hits your premium endpoint
2. Gets back HTTP 402 with payment instructions (USDC amount, treasury address, facilitator URL)
3. Agent pays via Coinbase wallet on Base chain
4. Agent retries with `X-PAYMENT` header containing tx hash
5. Middleware verifies payment via Coinbase facilitator
6. Access granted

## Free Mode

Set `price="0"` to pass all requests through without payment — useful for testing the flow before charging.

```python
@x402.premium(price="0", description="Free for now")
def free_premium():
    return jsonify({"data": "free during testing"})
```

## Configuration

| Env Var | Purpose |
|---------|---------|
| `CDP_API_KEY_NAME` | Coinbase Developer Platform API key name |
| `CDP_API_KEY_PRIVATE_KEY` | CDP API private key |

Get credentials at [portal.cdp.coinbase.com](https://portal.cdp.coinbase.com).

## Contract Addresses (Base Mainnet)

| Token | Address |
|-------|---------|
| USDC | `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913` |
| wRTC | `0x5683C10596AaA09AD7F4eF13CAB94b9b74A669c6` |
| Aerodrome Pool | `0x4C2A0b915279f0C22EA766D58F9B815Ded2d2A3F` |

## Links

- [x402 Protocol](https://www.x402.org/) — HTTP 402 Payment Required standard
- [Coinbase Agentic Wallets](https://docs.cdp.coinbase.com/agentkit/docs/welcome)
- [RustChain](https://rustchain.org) — Proof-of-Antiquity blockchain
- [BoTTube](https://bottube.ai) — AI video platform using openclaw-x402
- [Aerodrome DEX](https://aerodrome.finance) — Swap USDC to wRTC

## License

MIT
hiro-agent 0.1.1
AI security review agent for code, plans, and infrastructure
Requires Python: >=3.11

# hiro-agent

AI security review agent for code, plans, and infrastructure. Integrates with Claude Code, Cursor, VSCode Copilot, and Codex CLI to enforce security reviews before commits and plan finalization.

## Install

```bash
# Recommended (isolated environment, works on macOS/Linux)
pipx install hiro-agent

# Or with pip in a virtual environment
pip install hiro-agent
```

## Quick Start

```bash
# Set up hooks for your AI coding tools
hiro setup

# Review code changes
git diff | hiro review-code

# Review an implementation plan
cat plan.md | hiro review-plan

# Review infrastructure configuration
hiro review-infra main.tf
```

## Commands

| Command | Description |
|---------|-------------|
| `hiro review-code` | Security review of code changes (stdin: git diff) |
| `hiro review-plan` | STRIDE threat model review of a plan (stdin) |
| `hiro review-infra` | IaC security review (file arg or stdin) |
| `hiro setup` | Auto-detect and configure all AI coding tools |
| `hiro verify` | Verify hook integrity against installed version |

### Setup Options

```bash
hiro setup                # Auto-detect all tools
hiro setup --claude-code  # Claude Code only
hiro setup --cursor       # Cursor only
hiro setup --vscode       # VSCode Copilot only
hiro setup --codex        # Codex CLI only
```

## Configuration

Set `HIRO_API_KEY` to connect to the Hiro platform for organizational context (security policies, memories, org profile). Without it, reviews still run using your `ANTHROPIC_API_KEY` directly.

```bash
export HIRO_API_KEY=hiro_ak_...     # Optional: Hiro platform context
export ANTHROPIC_API_KEY=sk-ant-... # Required if HIRO_API_KEY not set
```

## How It Works

1. **`hiro setup`** installs hook scripts in `.hiro/hooks/` and configures your AI coding tool to call them
2. Hooks track file modifications and block commits until `hiro review-code` has run
3. Hooks track plan creation and block finalization until `hiro review-plan` has run
4. Review agents use `claude-agent-sdk` to spawn a Claude instance that performs the security review
5. When connected to Hiro (`HIRO_API_KEY`), reviews are enriched with your org's security policy, accepted risks, and architecture context

## License

MIT
crunch-cli 10.13.1
crunch-cli - CLI of the CrunchDAO Platform
Requires Python: >=3
Keywords: package development template

# CrunchDAO CLI

[![PyTest](https://github.com/crunchdao/crunch-cli/actions/workflows/pytest.yml/badge.svg)](https://github.com/crunchdao/crunch-cli/actions/workflows/pytest.yml)

This Python library is designed for the CrunchDAO Platform, offering convenient access to competition's data and enabling effortless submission. When utilized in the command-line interface (CLI), its goal is to deliver a user experience akin to GitHub, enabling you to seamlessly push the code from your local environment.

## Installation

Use [pip](https://pypi.org/project/crunch-cli/) to install the `crunch-cli`.

```bash
pip install crunch-cli --upgrade
```

## Usage

```python
import crunch
crunch = crunch.load_notebook()

# Getting the data
X_train, y_train, X_test = crunch.load_data()
```

`crunch.load_data()` accept arguments for `read_parquet`.

```python
crunch.load_data(
  engine="fastparquet"
)
```

## Submit with Crunch CLI

```bash
Usage: crunch push [OPTIONS]

  Send the new submission of your code.

Options:
  -m, --message TEXT      Specify the change of your code. (like a commit
                          message)

  -e, --main-file TEXT    Entrypoint of your code.  [default: main.py]
  --model-directory TEXT  Directory where your model is stored.  [default:
                          resources]

  --help                  Show this message and exit.
```

## Detecting the environment

Detecting whether you are running inside the runner or not, allows you to configure your program more precisely.

```python
import crunch

if crunch.is_inside_runner:
  print("running inside the runner")
else:
  print("running elsewhere")

  model.enable_debug()
  logger.set_level("TRACE")
```

## Competition Links

- [Competition Platform](https://www.crunchdao.com)
- [ADIA Lab Market Prediction Competition](https://www.crunchdao.com/live/adialab)
- [see more](https://hub.crunchdao.com/)

## Contributing

Pull requests are always welcome! If you find any issues or have suggestions for improvements, please feel free to submit a pull request or open an issue in the GitHub repository.

## License

[MIT](https://choosealicense.com/licenses/mit/)
crowdstrike-aidr-google-genai 0.2.0
A wrapper around the Google GenAI Python SDK
Requires Python: >=3.12

# CrowdStrike AIDR + Google Gen AI SDK

A wrapper around the Google Gen AI SDK that wraps the Gemini API with
CrowdStrike AIDR. Supports Python v3.12 and greater.

## Installation

```bash
pip install -U crowdstrike-aidr-google-genai
```

## Usage

```python
import os

import crowdstrike_aidr_google_genai as genai

client = genai.CrowdStrikeAidrClient(
    api_key=os.environ.get("GEMINI_API_KEY"),
    crowdstrike_aidr_api_token=os.environ.get("CROWDSTRIKE_AIDR_API_TOKEN"),
    crowdstrike_aidr_base_url_template=os.environ.get("CROWDSTRIKE_AIDR_BASE_URL_TEMPLATE"),
)

response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents="Explain how AI works in a few words",
)
print(response.text)
```
wgc-third-party 1.0.1
Third-party binary tools for WGC QA framework (7z, procdump, dummy games, etc.)
Requires Python: >=3.7

# wgc-third-party

Third-party binary tools packaged for the WGC QA framework.

> ⚠️ **This package is ~100MB** due to bundled binaries. Only install when needed for full test runs.

## Contents

| Binary | Purpose |
|---|---|
| `7z.exe` / `7z.dll` | Archive operations (patch extraction) |
| `procdump.exe` | Memory dump capture on crashes |
| `cdb.exe` / `cdb7.exe` / `windbg.exe` | Crash analysis debuggers |
| `make_torrent.exe` | Torrent file generation for game patches |
| `dummy_game_c#_*.exe` | Fake game binaries for testing (x86/x64, Steam, 360) |
| `sigcheck64.exe` | Digital signature verification |
| `Dbgview.exe` | Debug output monitor |
| `Listdlls.exe` / `pslist.exe` | Process inspection tools |
| `Procmon64.exe` | Process Monitor |
| `wdsdiff.exe` | Binary diff tool |
| `DeltaMAX.dll` | Delta patching library |
| `QRes.exe` | Screen resolution changer |
| `certutil.exe` / `signtool.exe` | Certificate and signing tools |
| `openh264-*.dll` | Video codec for screen recording |
| `wgc_gpu_hang*.dll` / `wgc_renderer_oom*.dll` | Crash injection DLLs for testing |
| `server.crt` / `server.key` | Self-signed SSL certificate for mock HTTPS |

## Usage

```python
from wgc_third_party import get_third_party_path

sevenzip = get_third_party_path('7z.exe')
# Returns: absolute path to 7z.exe within the installed package
```

## Install

```bash
pip install wgc-third-party
```
wgc-pages 4.0.1
Page Objects for WGC QA framework
Requires Python: >=3.7

# wgc-pages

Page Objects for the WGC QA framework. Provides high-level API for interacting with every page and dialog in Wargaming Game Center.

## Page Object Pattern

Each WGC screen is represented by a Python class with methods for user actions:

```python
from wgc_pages import PageArsenalCommon, PageArsenalLogin, PageArsenalInstalledGame

# Login
login_page = PageArsenalLogin(client)
login_page.login(email='test@test.com', password='pass123')

# Navigate to installed game
common = PageArsenalCommon(client)
common.open_game('WOT')

# Interact with game page
game_page = PageArsenalInstalledGame(client)
game_page.click_play()
game_page.wait_for_game_launch()
```

## Available Pages

### Arsenal Pages (New UI)

| Page | Class | Description |
|---|---|---|
| Common | `PageArsenalCommon` | Navigation, game list, sidebar, surveys |
| Login | `PageArsenalLogin` | Login forms (WG ID, OAuth, 2FA, Steam) |
| Registration | `PageArsenalRegistration` | Account registration, demo accounts |
| Installed Game | `PageArsenalInstalledGame` | Game management: play, update, repair, patches |
| Not Installed | `PageArsenalNotInstalledGame` | Game installation initiation |
| Game Settings | `PageArsenalGameSettings` | Game-specific settings (path, components) |
| Preinstall | `PageArsenalPreinstallSettings` | Pre-install configuration (path, components) |
| Settings | `PageArsenalSettings` | WGC application settings |
| Profile | `PageArsenalProfile` | User profile management |
| Shop | `PageArsenalShop` | In-app store, product browsing |
| Overlay | `PageArsenalOverlay` | In-game overlay UI |
| Notifications | `PageArsenalNotifications` | Notification center |
| Queue | `PageArsenalQueue` | Download queue management |
| Support | `PageArsenalSupport` | Support page |
| Legal Docs | `PageArsenalLegalDocs` | EULA, privacy policy |
| About | `PageArsenalAbout` | About dialog |

### Classic Pages

| Page | Class | Description |
|---|---|---|
| Common | `PageCommon` | Base page: login, account switching, Steam |
| Game | `PageGame` | Game management (classic UI) |
| Game Install | `PageGameInstall` | Game installation flow |
| Install by ID | `PageInstallById` | Install game via command line ID |
| Import | `PageImport` | Import existing game installations |
| Showroom | `PageShowroom` | Game showcase/storefront |
| Settings | `PageSettings` | WGC settings (classic) |
| Purchase | `PagePurchase` | Purchase flow |
| Overlay | `PageOverlay` | Overlay (classic) |
| Plugin | `PagePlugin` | Plugin page |
| Game News | `PageGameNews` | In-app news |
| About | `PageAbout` | About dialog |
| Legal Docs | `PageLegalDocs` | Legal documents |

## Install

```bash
pip install wgc-pages
```

## Dependencies

- `wgc-client` — WGCClient for UI interaction
- `wgc-core` — config, logger
- `wgc-helpers` — waiter, localization, requirements
wgc-client 4.0.1
WGC Client for QA framework: WGCClient, WebSocket, UI elements, UI maps
Requires Python: >=3.7

# wgc-client

WGC Client package for the QA framework. Provides `WGCClient` — the main class for interacting with Wargaming Game Center through WebSocket, JavaScript injection, and Win32 API.

## Architecture

```
WGCClient
├── Process Management (Win32 API)
│   ├── start_wgc() / stop_wgc()
│   ├── Process monitoring (crash detection)
│   └── Window handle management
│
├── WebSocket Communication
│   ├── /websocket/wgc          — main UI channel
│   ├── /websocket/overlay      — overlay channel
│   ├── /websocket/game-overlay — in-game overlay
│   └── /websocket/news         — news feed
│
├── UI Elements
│   ├── WebElement  — CSS selectors via JS injection
│   └── NativeElement — Win32 Accessibility API
│
└── UI Maps (34 .ini files)
    ├── common.ini, arsenalcommon.ini
    ├── arsenallogin.ini, arsenalshop.ini
    └── ... (page-specific element maps)
```

## Usage

```python
from wgc_client import WGCClient

# Initialize and start WGC
client = WGCClient()
client.run_game_center()

# Get UI elements
login_btn = client.get_wgc_element('button_login')
login_btn.click()

# Web elements (CSS selectors via WebSocket)
email_field = client.get_wgc_element('input_email')
email_field.set_text('user@test.com')
email_field.react_set_text('user@test.com')  # React-specific

# Native elements (Win32 API)
dialog = client.get_native_element('install_dialog')
dialog.click()

# Element properties
text = login_btn.get_text()
visible = login_btn.is_element_displayed
attrs = login_btn.get_attribute('class')
```

## UI Element Types

### WebElement
Interacts with Chromium UI via JavaScript injection over WebSocket:
- `click()`, `react_click()` — click via JS dispatchEvent
- `set_text()`, `react_set_text()` — input via nativeInputValueSetter
- `get_text()` — read innerText
- `get_attribute()` — read DOM attributes
- `is_element_displayed` — visibility check via offsetParent

### NativeElement
Interacts with native Windows UI via Win32 Accessibility API:
- `click()` — mouse_event at element coordinates
- `get_text()` — read acc_value via UISoup
- `set_text()` — set_value via UISoup
- For native dialogs, file pickers, OS-level windows

## UI Maps

Element selectors are defined in `.ini` files:
```ini
[common]
button_login = .login-button
input_email = input[name="email"]
game_list = .game-list-container
```

Parsed by `UIMapParser` and accessed via `client.get_wgc_element('button_login')`.

## Install

```bash
pip install wgc-client
```

## Dependencies

- `wgc-core`, `wgc-helpers`, `wgc-mocks`, `wgc-clippy`
- `websocket-client` — WebSocket communication
- `pywin32` — Win32 API
- `uisoup`, `uiautomation` — Windows UI automation
- `ui-map-parser` — INI-based UI map parsing