semvec/pypi-packages huggingface dataset:
mfpandas 0.1.6
Parsing various z/OS structures into Panda dataframes.
Requires Python: >=3.6

mfpandas
########

The framework for working with various Mainframe (z/OS) datastructures via Pandas Dataframes.
Read the docs at https://mfpandas.readthedocs.io 

Installation::

    pip install mfpandas 


This used to be `pyracf` but that name is now being used by an awesome framework to work with RACF directly from python.
Read more about it via: https://github.com/ambitus/pyracf
remap-badblocks 0.10.1
CLI tool for remapping bad sectors on Linux disks using device-mapper
Requires Python: >=3.10

# remap-badblocks

`remap-badblocks` is a Linux CLI tool written in Python that scans a block device for bad sectors and creates a device-mapper target that skips over them. It can also reserve extra space to dynamically remap future badblocks.

It's a simple way to extend the usefulness of slightly damaged drives, ideal for anyone who wants to avoid discarding a disk due to a few bad sectors.

## Features

* Scans disks using `badblocks` to identify damaged sectors
* Creates a `device-mapper` target that avoids bad sectors
* Reserves spare sectors for dynamic remapping
* Supports using only part of a device (e.g., for hard partitioning or isolation)

## Installation

### From PyPI

```bash
pip install remap-badblocks
```

### From source

```bash
git clone https://gitlab.com/Luigi-98/remap-badblocks.git
cd remap-badblocks
pip install -e .[dev]
```

## Usage

### Database

`remap-badblocks` relies on a single source of stateful storage: a SQLite database. By default, it is stored at `/etc/remap_badblocks/devices_config.db`, but you can specify an alternative location using the `-P` option.

### Device Identification

Devices can be referenced by either:

* **Name**: set at creation, used as the name of the output device-mapper
* **ID**: an internal remap-badblocks identifier

### CLI Reference

```bash
remap-badblocks --help
```

### Example Workflow

```bash
# Add a new device
remap-badblocks add my_remapped_device --path /dev/sda

# Run a read-mode scan and initialize the mapping
#   by reserving spare space
remap-badblocks update --name my_remapped_device --mode read --spare-space 100MB

# Apply changes to generate the device-mapper
remap-badblocks apply

# Resulting device appears under /dev/mapper
ls /dev/mapper/
# /dev/mapper/my_remapped_device
```

## Contributing

We welcome feedback, bug reports, feature ideas, code contributions, and help shaping the roadmap — or even rethinking the project from the ground up.

Start with CONTRIBUTING.md, then open an issue or submit a merge request to get involved.

## License

GPL v3 License — see LICENSE for details.

## Community

* GitLab: [remap-badblocks project page](https://gitlab.com/Luigi-98/remap_badblocks)
* PyPI: [remap-badblocks](https://pypi.org/project/remap-badblocks/)
* Issues: [remap-badblocks Gitlab issues](https://gitlab.com/Luigi-98/remap_badblocks/-/issues)

## Acknowledgements & Related Tools

* [`badblocks`](https://linux.die.net/man/8/badblocks)
* [`device-mapper`](https://linux.die.net/man/8/dmsetup)
elizaos-plugin-vision 2.0.0a4
Vision plugin for ElizaOS - provides camera integration and visual awareness
Requires Python: >=3.10
Keywords: ai-vision, camera, computer-vision, elizaos, plugin, vision

# elizaos-plugin-vision

Vision plugin for ElizaOS - provides camera integration and visual awareness.

## Installation

```bash
pip install elizaos-plugin-vision
```

## Usage

See the main plugin documentation for usage instructions.
elizaos-plugin-tee 2.0.0a4
elizaOS TEE Plugin - Trusted Execution Environment integration for secure key management and remote attestation
Requires Python: >=3.11
Keywords: agents, ai, attestation, elizaos, phala, security, tee

# elizaos-plugin-tee (Python)

Python implementation of the elizaOS TEE Plugin for Trusted Execution Environment integration.

## Features

- 🔐 **Remote Attestation** - Prove agent execution in TEE
- 🔑 **Key Derivation** - Secure Ed25519 and ECDSA key derivation
- 🛡️ **Vendor Support** - Extensible vendor system (Phala Network)
- ⚡ **Async** - Full async/await support
- 🔒 **Type Safe** - Pydantic models with strict validation

## Installation

```bash
pip install elizaos-plugin-tee
```

## Quick Start

```python
from elizaos_plugin_tee import TEEService, TeeMode

# Start the service
service = await TEEService.start(tee_mode="LOCAL")

# Derive Ed25519 keypair (for Solana)
solana_result = await service.derive_ed25519_keypair(
    path="my-secret-salt",
    subject="solana",
    agent_id="agent-123"
)
print(f"Solana Public Key: {solana_result.public_key}")

# Derive ECDSA keypair (for EVM)
evm_result = await service.derive_ecdsa_keypair(
    path="my-secret-salt",
    subject="evm",
    agent_id="agent-123"
)
print(f"EVM Address: {evm_result.address}")

# Stop the service
await service.stop()
```

## Configuration

| Variable             | Description                                     | Required |
| -------------------- | ----------------------------------------------- | -------- |
| `TEE_MODE`           | Operation mode: `LOCAL`, `DOCKER`, `PRODUCTION` | Yes      |
| `WALLET_SECRET_SALT` | Secret for key derivation                       | Yes      |
| `TEE_VENDOR`         | Vendor name (default: `phala`)                  | No       |

## API Reference

### TEEService

Main service for TEE operations.

```python
# Initialize
service = await TEEService.start(tee_mode="LOCAL")

# Derive keys
await service.derive_ed25519_keypair(path, subject, agent_id)
await service.derive_ecdsa_keypair(path, subject, agent_id)
await service.raw_derive_key(path, subject)

# Cleanup
await service.stop()
```

### Remote Attestation

```python
from elizaos_plugin_tee import (
    PhalaRemoteAttestationProvider,
    handle_remote_attestation,
)

# Using provider directly
provider = PhalaRemoteAttestationProvider("LOCAL")
quote = await provider.generate_attestation(report_data)
await provider.close()

# Using action handler
result = await handle_remote_attestation(
    tee_mode="LOCAL",
    agent_id="agent-123",
    entity_id="entity-456",
    room_id="room-789",
    content="Message content"
)
```

### Types

```python
from elizaos_plugin_tee import (
    TeeMode,
    TeeVendor,
    RemoteAttestationQuote,
    Ed25519KeypairResult,
    EcdsaKeypairResult,
)
```

## Development

```bash
# Install dev dependencies
pip install -e ".[dev]"

# Run tests
pytest

# Type checking
mypy elizaos_plugin_tee

# Linting
ruff check .
ruff format .
```

## License

MIT
crypto-connector 0.6.1
A lightweight library that works as a connector to several crypto exchanges APIs.
Requires Python: >=3.10

# Crypto-connector

![tests](https://github.com/Izem0/crypto-connector/actions/workflows/tests.yml/badge.svg)
[![PyPI version](https://img.shields.io/pypi/v/crypto-connector)](https://pypi.python.org/pypi/crypto-connector)
[![Python version](https://img.shields.io/pypi/pyversions/crypto-connector)](https://www.python.org/downloads/)
[![Code Style](https://img.shields.io/badge/code_style-black-black)](https://black.readthedocs.io/en/stable/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)


This is a lightweight library that works as a connector to Binance SPOT and HTX SPOT APIs.

- Supported APIs:
    - [Binance SPOT API](https://developers.binance.com/docs/binance-spot-api-docs/rest-api)
    - [HTX SPOT API](https://www.htx.com/en-in/opend/newApiPages/)

## Installation

```bash
pip install crypto-connector
```

## Usage examples

### Public endpoints
```python
import crypto_connector as cc

exc = cc.Binance()
# exc = cc.HTX()

# get server time
print(exc.get_server_time())

# get last 200 klines of ETHUSDT with 1d timeframe
print(exc.klines("ETHUSDT", "1d"))
```

### Private endpoints
API key/secret are required for private endpoints.
```python
import crypto_connector as cc

# some binance API endpoints require both sub and master accounts API key/secret.
# Therefore user needs to create a subaccount and provide subaccount api key, 
# subaccount api secret, subaccount email, master account api key and 
# master account api secret to the Binance constructor
exc = cc.Binance(
    sub_api_key="",
    sub_api_secret="",
    sub_email="",
    master_api_key="",
    master_api_secret="",
)
# exc = cc.HTX(
#     api_key="",
#     api_secret="",
# )

# get api key info
print(exc.get_api_key_info())

# get balance
print(exc.get_balance())

# post a new order
order = exc.place_order("ETHUSDT", type="limit", side="buy", qty=0.015, price=1000)
print(order)

# get open orders
print(exc.get_open_orders())
```

## Limitation

- This library is not intended to be comprehensive, I use it mainly for my personal projects
- Not all endpoints of the different APIs are supported
- Websocket and Futures are not supported
elizaos-plugin-solana 2.0.0a4
elizaOS Solana Plugin - Solana blockchain operations for elizaOS agents
Requires Python: >=3.11
Keywords: agents, ai, blockchain, elizaos, solana, spl-token, swap, wallet

# elizaOS Plugin Solana (Python)

Python implementation of the Solana blockchain plugin for elizaOS agents.

## Installation

```bash
pip install elizaos-plugin-solana
```

## Quick Start

```python
import asyncio
from elizaos_plugin_solana import SolanaClient, WalletConfig

async def main():
    # Read-only mode (just need a public key)
    config = WalletConfig.read_only(
        "https://api.mainnet-beta.solana.com",
        "YourPublicKeyHere"
    )

    async with SolanaClient(config) as client:
        # Get SOL balance
        balance = await client.get_sol_balance()
        print(f"Balance: {balance} SOL")

        # Get token accounts
        tokens = await client.get_token_accounts()
        for token in tokens:
            print(f"{token.mint}: {token.ui_amount}")

asyncio.run(main())
```

## With Signing Capability

```python
from elizaos_plugin_solana import SolanaClient, WalletConfig
from decimal import Decimal

# Full access mode (with private key)
config = WalletConfig.with_keypair(
    "https://api.mainnet-beta.solana.com",
    "YourPrivateKeyHere"
)

async with SolanaClient(config) as client:
    # Transfer SOL
    recipient = "RecipientPublicKey"
    result = await client.transfer_sol(recipient, Decimal("0.1"))
    print(f"Transfer signature: {result.signature}")
```

## Environment Variables

Load configuration from environment:

```python
config = WalletConfig.from_env()
```

Required environment variables:

- `SOLANA_RPC_URL` - Solana RPC endpoint (defaults to mainnet)
- `SOLANA_PRIVATE_KEY` or `WALLET_PRIVATE_KEY` - Private key for signing
- `SOLANA_PUBLIC_KEY` or `WALLET_PUBLIC_KEY` - Public key (if no private key)

Optional:

- `SLIPPAGE` - Slippage tolerance in basis points (default: 50)
- `HELIUS_API_KEY` - For enhanced RPC
- `BIRDEYE_API_KEY` - For token price data

## Token Swaps via Jupiter

```python
from elizaos_plugin_solana import SwapQuoteParams

params = SwapQuoteParams(
    input_mint="So11111111111111111111111111111111111111112",  # SOL
    output_mint="EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",  # USDC
    amount="1000000000",  # 1 SOL in lamports
    slippage_bps=50,
)

quote = await client.get_swap_quote(params)
print(f"Expected output: {quote.out_amount}")

# Execute the swap
result = await client.execute_swap(quote)
print(f"Swap signature: {result.signature}")
```

## Development

```bash
# Install dev dependencies
pip install -e ".[dev]"

# Run tests
pytest tests/ -v

# Run linting
ruff check .
ruff format .

# Run type checking
mypy elizaos_plugin_solana
```

## License

MIT
elizaos-plugin-zalouser 2.0.0a4
Zalo Personal Account plugin for elizaOS - Python implementation via zca-cli
Requires Python: >=3.11
Keywords: agents, ai, chat, elizaos, messaging, vietnam, zalo

# elizaOS Plugin: Zalo User (Python)

Zalo Personal Account integration for elizaOS agents via zca-cli.

## Overview

This plugin enables elizaOS agents to interact with Zalo personal accounts using the zca-cli tool. It supports:

- QR code login flow
- Direct messages (DMs) and group messages
- Multi-profile support
- Friend and group listing
- Media sending (images, links)

## Prerequisites

You must have [zca-cli](https://github.com/nickvt99/zca-cli) installed:

```bash
npm install -g zca-cli
```

Then authenticate with your Zalo account:

```bash
zca auth login
```

## Installation

```bash
pip install elizaos-plugin-zalouser
```

## Configuration

Set the following environment variables:

| Variable | Description | Required |
|----------|-------------|----------|
| `ZALOUSER_ENABLED` | Enable/disable the plugin | No (default: `true`) |
| `ZALOUSER_DEFAULT_PROFILE` | Default zca profile to use | No (default: `default`) |
| `ZALOUSER_COOKIE_PATH` | Path to cookie file for auth persistence | No |
| `ZALOUSER_IMEI` | IMEI for authentication | No |
| `ZALOUSER_USER_AGENT` | User agent for API requests | No |
| `ZALOUSER_PROFILES` | JSON config for multiple profiles | No |
| `ZALOUSER_ALLOWED_THREADS` | JSON array or comma-separated list of allowed thread IDs | No |
| `ZALOUSER_DM_POLICY` | DM policy: `open`, `allowlist`, `pairing`, `disabled` | No (default: `pairing`) |
| `ZALOUSER_GROUP_POLICY` | Group policy: `open`, `allowlist`, `disabled` | No (default: `disabled`) |
| `ZALOUSER_LISTEN_TIMEOUT` | Listen timeout in ms | No (default: `30000`) |

## Usage

```python
from elizaos_plugin_zalouser import ZaloUserService, ZaloUserConfig, SendMessageParams

# Create config
config = ZaloUserConfig.from_env()

# Create and start service
service = ZaloUserService(config)
await service.start()

# Send a message
result = await service.send_message(
    SendMessageParams(
        threadId="123456789",
        text="Hello from elizaOS!",
    )
)

# List friends
friends = await service.list_friends()

# List groups
groups = await service.list_groups()

# Stop service
await service.stop()
```

## License

MIT
elizaos-plugin-zalo 2.0.0a4
Zalo Official Account Bot API plugin for elizaOS - Python implementation
Requires Python: >=3.11
Keywords: agents, ai, bot, chat, elizaos, vietnam, zalo

# elizaos-plugin-zalo (Python)

Python implementation of the Zalo Official Account Bot API plugin for elizaOS.

## Installation

```bash
pip install elizaos-plugin-zalo
```

## Usage

```python
import asyncio
from elizaos_plugin_zalo import ZaloService, ZaloConfig

async def main():
    # Load config from environment
    config = ZaloConfig.from_env()
    
    # Create and start service
    service = ZaloService(config)
    await service.start()
    
    # Send a message
    message_id = await service.send_message("user_id", "Hello from elizaOS!")
    print(f"Sent message: {message_id}")
    
    # Stop service
    await service.stop()

asyncio.run(main())
```

## Configuration

Set the following environment variables:

- `ZALO_APP_ID` - Zalo App ID (required)
- `ZALO_SECRET_KEY` - Zalo Secret Key (required)
- `ZALO_ACCESS_TOKEN` - OAuth access token (required)
- `ZALO_REFRESH_TOKEN` - OAuth refresh token (optional)
- `ZALO_WEBHOOK_URL` - Webhook URL (required for webhook mode)
- `ZALO_USE_POLLING` - Set to `true` for polling mode (optional)
- `ZALO_ENABLED` - Set to `false` to disable (optional)
- `ZALO_PROXY_URL` - HTTP proxy URL (optional)

## Development

```bash
# Install dev dependencies
pip install -e ".[dev]"

# Run tests
pytest

# Type checking
mypy elizaos_plugin_zalo

# Linting
ruff check elizaos_plugin_zalo
ruff format elizaos_plugin_zalo
```
elizaos-plugin-xai 2.0.0a4
elizaOS xAI Plugin - Grok models and X (formerly Twitter) API integration
Requires Python: >=3.11
Keywords: ai, elizaos, grok, llm, x, xai

# elizaos-plugin-xai (Python)

Python package for elizaOS xAI integration.

## Installation

```bash
pip install elizaos-plugin-xai
```

## Usage

```python
from elizaos_plugin_xai import GrokClient, GrokConfig, TwitterClient, TwitterConfig

# Grok text generation
grok = GrokClient(GrokConfig.from_env())
result = await grok.generate_text(TextGenerationParams(prompt="Hello world"))
print(result.text)

# X (formerly Twitter) integration
x = TwitterClient(TwitterConfig.from_env())
me = await x.me()
print(f"@{me.username}")
```

## Development

```bash
# Install dev dependencies
pip install -e ".[dev]"

# Run tests
pytest

# Type checking
mypy elizaos_plugin_xai

# Linting
ruff check .
ruff format .
```
elizaos-plugin-whatsapp 2.0.0a4
WhatsApp Cloud API plugin for ElizaOS agents
Requires Python: >=3.10
Keywords: elizaos, messaging, meta, plugin, whatsapp

# elizaos-plugin-whatsapp

WhatsApp Cloud API plugin for ElizaOS agents.

## Installation

```bash
pip install elizaos-plugin-whatsapp
```

## Features

- Send and receive WhatsApp messages via Cloud API
- Support for text, media, interactive, and reaction messages
- Webhook handling for incoming messages
- Full type support with Pydantic models

## License

MIT
elizaos-plugin-webhooks 2.0.0a4
HTTP webhook ingress plugin for ElizaOS
Requires Python: >=3.11

# elizaos-plugin-webhooks

HTTP webhook ingress plugin for ElizaOS

## Installation

```bash
pip install elizaos-plugin-webhooks
```

## Part of elizaOS

This is a Python plugin for the [elizaOS](https://github.com/elizaos/eliza) AI agent framework.

## License

MIT
elizaos-plugin-vercel-ai-gateway 2.0.0a4
elizaOS Vercel AI Gateway Plugin - AI Gateway integration for text, embeddings, and images
Requires Python: >=3.11
Keywords: agents, ai, anthropic, elizaos, embeddings, gateway, llm, openai, vercel

# elizaOS Vercel AI Gateway Plugin (Python)

Python implementation of the Vercel AI Gateway plugin for elizaOS.

## Features

- **Text Generation**: `TEXT_SMALL`, `TEXT_LARGE` chat completions
- **Embeddings**: Vector embeddings generation
- **Images**: Image generation and description
- **Structured Output**: JSON object generation
- **Streaming**: Real-time streaming support

## Installation

```bash
pip install elizaos-plugin-gateway
```

## Quick Start

```python
import asyncio
from elizaos_plugin_gateway import GatewayPlugin

async def main():
    async with GatewayPlugin() as plugin:
        # Text generation
        response = await plugin.generate_text_large("What is quantum computing?")
        print(response)

        # Embeddings
        embedding = await plugin.create_embedding("Hello, world!")
        print(f"Embedding dimensions: {len(embedding)}")

asyncio.run(main())
```

## Configuration

Set environment variables:

```bash
# Required - one of:
export AI_GATEWAY_API_KEY="your-api-key"
export AIGATEWAY_API_KEY="your-api-key"
export VERCEL_OIDC_TOKEN="your-oidc-token"

# Optional
export AI_GATEWAY_BASE_URL="https://ai-gateway.vercel.sh/v1"
export AI_GATEWAY_SMALL_MODEL="gpt-5-mini"
export AI_GATEWAY_LARGE_MODEL="gpt-5"
export AI_GATEWAY_EMBEDDING_MODEL="text-embedding-3-small"
```

## elizaOS Integration

```python
from elizaos_plugin_gateway import get_gateway_plugin

# Get the singleton plugin instance
plugin = get_gateway_plugin()

# Use with AgentRuntime
runtime = AgentRuntime(plugins=[plugin])
```

## API Reference

### GatewayPlugin

#### Text Generation

```python
await plugin.generate_text_small(prompt, system=None, max_tokens=None)
await plugin.generate_text_large(prompt, system=None, max_tokens=None)
await plugin.stream_text(prompt, model=None, system=None)
```

#### Embeddings

```python
await plugin.create_embedding(text)
```

#### Images

```python
await plugin.generate_image(prompt, n=1, size="1024x1024", quality="standard", style="vivid")
await plugin.describe_image(image_url, prompt=None, max_tokens=8192)
```

#### Structured Output

```python
await plugin.generate_object(prompt, model=None, temperature=None)
```

## Development

```bash
# Install dev dependencies
pip install -e ".[dev]"

# Run tests
pytest

# Type checking
mypy elizaos_plugin_gateway

# Linting
ruff check .
ruff format .
```

## License

MIT
elizaos-plugin-twitch 2.0.0a4
Twitch chat integration plugin for ElizaOS agents
Requires Python: >=3.10
Keywords: chat, elizaos, plugin, streaming, twitch

# elizaos-plugin-twitch

Twitch chat integration plugin for ElizaOS agents

## Installation

```bash
pip install elizaos-plugin-twitch
```

## Part of elizaOS

This is a Python plugin for the [elizaOS](https://github.com/elizaos/eliza) AI agent framework.

## License

MIT
elizaos-plugin-twilio 2.0.0a4
Twilio plugin for elizaOS - Python implementation for SMS, MMS, and voice calls
Requires Python: >=3.11
Keywords: agents, ai, elizaos, mms, sms, twilio, voice

# elizaos-plugin-twilio

Twilio plugin for elizaOS - Python implementation for SMS, MMS, and voice calls

## Installation

```bash
pip install elizaos-plugin-twilio
```

## Part of elizaOS

This is a Python plugin for the [elizaOS](https://github.com/elizaos/eliza) AI agent framework.

## License

MIT
elizaos-plugin-tts 2.0.0a4
elizaOS TTS Plugin - text-to-speech coordinator with multi-provider support
Requires Python: >=3.11
Keywords: agents, ai, elizaos, text-to-speech, tts

# elizaos-plugin-tts

elizaOS TTS Plugin - text-to-speech coordinator with multi-provider support

## Installation

```bash
pip install elizaos-plugin-tts
```

## Part of elizaOS

This is a Python plugin for the [elizaOS](https://github.com/elizaos/eliza) AI agent framework.

## License

MIT
elizaos-plugin-trust 2.0.0a4
Trust scoring, security threat detection, and permission management plugin for elizaOS
Requires Python: >=3.11
Keywords: agent, ai, elizaos, permissions, security, trust

# elizaos-plugin-trust

Trust scoring, security threat detection, and permission management plugin for elizaOS

## Installation

```bash
pip install elizaos-plugin-trust
```

## Part of elizaOS

This is a Python plugin for the [elizaOS](https://github.com/elizaos/eliza) AI agent framework.

## License

MIT
elizaos-plugin-trajectory-logger 2.0.0a4
elizaOS Trajectory Logger Plugin - capture agent interaction trajectories for RL training
Requires Python: >=3.11
Keywords: agents, ai, elizaos, rl, training, trajectory

# elizaOS Trajectory Logger Plugin (Python)

Python implementation of the elizaOS Trajectory Logger plugin.

This package provides:

- In-memory trajectory logging (`TrajectoryLoggerService`)
- ART / GRPO formatting helpers (OpenPipe ART message format)
- Simple heuristic reward scoring