semvec/pypi-packages huggingface dataset:
duckdice-cli 1.0.0
Powerful CLI app for DuckDice - Place bets and monitor balances
License: MIT
Requires Python: >=3.8

# DuckDice CLI

A powerful and beautiful CLI application for the DuckDice Bot API. 

## Features

- **Beautiful UI**: Tables, colors, and panels powered by `rich`.
- **Easy Configuration**: Securely store your API key locally.
- **Full Betting Suite**: Original Dice and Range Dice support.
- **Wallet Monitoring**: Check your balances and user stats at a glance.

## Installation

```bash
pip install duckdice-cli
```

## Quick Start

1. **Set your API Key**:
   ```bash
   duckdice config set your_api_key_here
   ```

2. **Check your profile**:
   ```bash
   duckdice user
   ```

3. **Check balances**:
   ```bash
   duckdice balance
   ```

4. **Place a bet**:
   ```bash
   # 50% chance bet on DOGE for 0.1 amount
   duckdice play dice -s DOGE -a 0.1 -c 50 --high
   ```

5. **Place a range bet**:
   ```bash
   # Bet inside [0, 4999] range
   duckdice play range -s DOGE -a 0.1 --min 0 --max 4999 --in
   ```

## License

MIT
duckdice-api 1.1.0
Python client for DuckDice Bot API - Place bets and retrieve statistics
License: MIT
Requires Python: >=3.8

# DuckDice API Python Wrapper

A modern, type-safe Python client for the [DuckDice Bot API](https://duckdice.io/bot-api). Place bets, manage balances, and retrieve user statistics programmatically.

## Features

- **Simple & Intuitive**: Easy-to-use API client with clear method signatures
- **Type Hints**: Full type annotations for IDE support and better code safety
- **Error Handling**: Comprehensive exception handling with `DuckDiceAPIException`
- **Well Tested**: 13 unit tests covering all methods and edge cases
- **Production Ready**: Used by DuckDice bot operators worldwide

## Installation

```bash
pip install duckdice-api
```

## Quick Start

```python
from duckdice_api import DuckDiceAPI, DuckDiceConfig

# Initialize client
cfg = DuckDiceConfig(api_key="YOUR_BOT_API_KEY")
client = DuckDiceAPI(cfg)

# Get user info
user = client.get_user_info()
print(f"Username: {user['username']}, Level: {user['level']}")

# Get currency stats
stats = client.get_currency_stats("XLM")
print(f"Bets: {stats['bets']}, Wins: {stats['wins']}")

# Place Original Dice bet
result = client.play_dice(
    symbol="XLM",
    amount="0.1",
    chance="77.77",
    is_high=True
)
print(f"Bet result: {result['bet']['result']}")

# Place Range Dice bet
result = client.play_range_dice(
    symbol="XLM",
    amount="0.1",
    range_vals=[0, 5000],
    is_in=True
)
```

## API Methods

### Read Methods

- `get_user_info()` — Retrieve bot user profile, balances, wagering bonuses, and TLE info
- `get_currency_stats(symbol)` — Get statistics for a specific currency (bets, wins, profit, volume)

### Betting Methods

- `play_dice(symbol, amount, chance, is_high, ...)` — Place Original Dice bet (high/low prediction)
- `play_range_dice(symbol, amount, range_vals, is_in, ...)` — Place Range Dice bet (range prediction)

All methods return parsed JSON responses from the DuckDice API.

## Configuration

```python
from duckdice_api import DuckDiceConfig

cfg = DuckDiceConfig(
    api_key="your_api_key",                      # Required
    base_url="https://duckdice.io/api",         # Default
    timeout=30                                    # Seconds
)
```

## Error Handling

```python
from duckdice_api import DuckDiceAPIException

try:
    user = client.get_user_info()
except DuckDiceAPIException as e:
    print(f"API Error: {e}")
```

## Full Documentation

See [docs/USAGE.md](docs/USAGE.md) for more examples and [https://duckdice.io/bot-api](https://duckdice.io/bot-api) for official API documentation.

## Requirements

- Python 3.8+
- `requests>=2.25.0`

## Testing

Run the test suite:

```bash
pytest tests/
```

## License

MIT License — Copyright (c) 2025 duckdice.casino
copier-super-important-project 0.0.1
A modern Python package powered by Copier.
License: MIT
Requires Python: >=3.9
Keywords: copier, template, python

Copier Super Important Project
==============================

![PyPI](https://img.shields.io/pypi/v/copier-super-important-project?logo=pypi&color=brightgreen)
![Python Version](https://img.shields.io/pypi/pyversions/copier-super-important-project?logo=python)
![Tests](https://img.shields.io/github/actions/workflow/status/Karol-G/copier-super-important-project/workflow.yml?branch=main&logo=github)
[![Copier](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/copier-org/copier/master/img/badge/badge-grayscale-inverted-border-purple.json)](https://github.com/copier-org/copier)
![License](https://img.shields.io/github/license/Karol-G/copier-super-important-project)

A modern Python package powered by Copier.

## Features
- Package at repo root (`copier_super_important_project`) with dynamic versioning from Git tags via `setuptools_scm`
- GitHub Actions CI for lint/test and PyPI publishing on version tags
- PyPI-friendly metadata with README and license ready to ship
- Minimal default test to keep CI green, even with no custom tests
- Copier-powered customization (name, package folder, author, remotes, Python version)

## Getting started

1. Install Copier if needed: `pip install copier`.
2. Generate a new project:
   ```bash
   copier copy https://github.com/Karol-G/copier-super-important-project new-project
   ```
3. Answer the prompts (project/package names, author, GitHub info, remote).
4. Enter the project directory, initialize git, and set your remote:
   ```bash
   cd new-project
   git init
   git remote add origin git@github.com:Karol-G/copier-super-important-project.git
   ```

## Development

- Install dev dependencies and run tests:
  ```bash
  python -m pip install --upgrade pip
  pip install -e .[dev]
  pytest || if [ $? -eq 5 ]; then echo \"No tests collected\"; fi
  ```

- Versioning is tag-driven via `setuptools_scm`. Create tags like `v0.1.0`:
  ```bash
  git tag v0.1.0 && git push origin v0.1.0
  ```

## Continuous Integration

- CI runs on pushes and pull requests to `main`.
- Publishing to PyPI triggers when pushing tags that start with `v`. Set `PYPI_API_TOKEN` in repository secrets.

## Project layout

```
.
├─ copier_super_important_project/              # Your package code
├─ tests/                           # Pytest tests (default sample included)
├─ .github/workflows/workflow.yml   # CI + publish workflow
├─ pyproject.toml                   # PEP 621 metadata with setuptools_scm
└─ README.md                        # You are here
```

## License

Distributed under the MIT license. See `LICENSE` for details.
life-restart-core 0.3.3
High-performance life restart simulator core engine written in Rust
License: MIT
Requires Python: >=3.12
Keywords: game, simulator, rust, performance

# Life Restart Core

High-performance life restart simulator core engine written in Rust with Python bindings.

## Features

- 🚀 **10-25x faster** than pure Python implementation
- 🐍 **Python 3.14+** compatible via PyO3
- 🔧 **Drop-in replacement** for existing Python code
- 📦 **Pre-built wheels** for Linux, Windows, and macOS

## Installation

```bash
pip install life-restart-core
```

## Usage

```python
from life_restart_core import simulate_full_life

result = simulate_full_life(
    talent_ids=[1001, 1002, 1003],
    properties={"CHR": 5, "INT": 5, "STR": 5, "MNY": 5},
    achieved_list=[],
    config={
        "talents": {...},
        "events": {...},
        "ages": {...},
        "achievements": {...},
        "judge": {...},
    }
)

# Result contains:
# - trajectory: List of year results
# - summary: Life summary with scores
# - new_achievements: Newly unlocked achievements
# - triggered_events: List of triggered event IDs
# - replacements: Talent replacement results
```

## Development

### Prerequisites

- Rust 1.70+
- Python 3.14+
- maturin

### Build

```bash
# Install maturin
pip install maturin

# Build and install in development mode
maturin develop

# Build release wheel
maturin build --release
```

### Test

```bash
# Run Rust tests
cargo test

# Run Python tests
pytest tests/
```

### Benchmark

```bash
cargo bench
```

## License

MIT
ufazien-cli 0.3.0
Command-line interface for deploying web applications on Ufazien platform
License: MIT
Requires Python: >=3.8
Keywords: ufazien, cli, deployment, hosting, web

# Ufazien CLI

🚀 A Command-line interface for deploying web applications on the Ufazien platform.

## Features

- ✨ Beautiful terminal UI powered by [Rich](https://github.com/Textualize/rich)
- 🎯 Modern CLI framework using [Typer](https://github.com/tiangolo/typer)
- 🔐 Secure authentication with token management
- 📦 Easy project creation and deployment
- 🗄️ Database provisioning support
- 📝 Automatic project structure generation

## Installation

### From Source

```bash
git clone https://github.com/martian56/ufazien-cli.git
cd ufazien-cli-py

# Install in development mode
pip install -e .

# Or install in production mode
pip install .
```

### From PyPI

```bash
pip install ufazien-cli
```

## Usage

### Login

Authenticate with your Ufazien account:

```bash
ufazien login
```

You'll be prompted for your email and password.

### Create a New Website

Create a new website project in the current directory:

```bash
ufazien create
```

The CLI will guide you through:
- Website name and subdomain
- Website type (Static, PHP, or Build)
- Database creation (for PHP projects)
- Build folder name (for Build projects)
- Project structure generation

### Deploy Your Website

Deploy your website to Ufazien:

```bash
ufazien deploy
```

This will:
1. Create a ZIP archive of your project (excluding files in `.ufazienignore`, or from build folder for Build projects)
2. Upload the files to your website
3. Trigger the deployment

### Check Status

Check your login status and profile:

```bash
ufazien status
```

### Logout

Logout from your account:

```bash
ufazien logout
```

## Commands

| Command | Description |
|---------|-------------|
| `login` | Login to your Ufazien account |
| `logout` | Logout from your account |
| `create` | Create a new website project |
| `deploy` | Deploy your website |
| `status` | Check login status and profile |
actory 0.1.5
Official Python SDK for the Actory Agent Commerce Protocol (ACP) API
License: MIT
Requires Python: >=3.8
Keywords: actory, acp, ai, agent, commerce, api, sdk

# Actory Python SDK

Official Python client for the Actory Agent Commerce Protocol (ACP) API.

## Installation

```bash
pip install actory
```

## Quick Start

```python
from actory import Actory

# Initialize with your API key
client = Actory(api_key="act_sk_your_key_here")

# Search for products
results = client.search("red shoes", max_price=100, in_stock=True)
print(f"Found {results.total} products")

for product in results.products:
    print(f"  {product.title}: {product.currency} {product.price:.2f}")
```

## Features

### Search Products

```python
# Basic search
results = client.search("shoes")

# With filters
results = client.search(
    "shoes",
    in_stock=True,
    min_price=20,
    max_price=100,
    vendor="Nike",
    category="footwear",
    limit=50,
    page=1
)
```

### Natural Language Search

```python
# Parse natural language queries
results = client.nl_search("red shoes under $50 in stock")
# Automatically extracts: color=red, maxPrice=50, inStock=true
```

### Get Product Details

```python
product = client.get_product("product_id_here")
print(f"{product.title}: {product.currency} {product.price:.2f}")
print(f"In Stock: {product.in_stock}")
```

### List Merchants

```python
merchants = client.list_merchants()  # or client.get_merchants()
for m in merchants:
    print(f"{m.name} ({m.domain}): {m.product_count} products")
```

### List Categories & Vendors

```python
categories = client.list_categories()
vendors = client.list_vendors()
```

## Error Handling

```python
from actory import Actory, AuthenticationError, RateLimitError, ActoryError

try:
    client = Actory(api_key="invalid_key")
    results = client.search("test")
except AuthenticationError:
    print("Invalid API key")
except RateLimitError:
    print("Too many requests, slow down")
except ActoryError as e:
    print(f"API error: {e}")
```

## Configuration

```python
# Custom base URL (for local development)
client = Actory(
    api_key="act_sk_...",
    base_url="http://localhost:3000"
)
```

## Get an API Key

1. Visit [app.actory.ai](https://app.actory.ai)
2. Navigate to API Keys
3. Create a new API key and use in your application

## License

MIT
flake8_timeout 2.0.0
flake8 plugin that checks for missing `timeout` parameters in network calls.
License: MIT
Requires Python: >=3.10

[![ci](https://github.com/jkittner/flake8-timeout/workflows/ci/badge.svg)](https://github.com/jkittner/flake8-timeout/actions?query=workflow%3Aci)
[![pre-commit.ci status](https://results.pre-commit.ci/badge/github/jkittner/flake8-timeout/master.svg)](https://results.pre-commit.ci/latest/github/jkittner/flake8-timeout/master)

# flake8-timeout

A flake8 plugin that checks for missing `timeout` parameters in network calls.

By default, the plugin checks common HTTP libraries but can be configured to track any function that accepts a timeout parameter.

## installation

```bash
pip install flake8-timeout
```

## flake8 code

| Code   | Description                      |
| ------ | -------------------------------- |
| TIM100 | timeout missing for request call |

## default tracked functions

The plugin tracks these functions by default:

- `requests.get`
- `requests.post`
- `requests.put`
- `requests.delete`
- `requests.head`
- `requests.patch`
- `requests.options`
- `requests.request`
- `urllib.request.urlopen` (timeout at positional index 2)

## configuration

### as a pre-commit hook

See [pre-commit](https://pre-commit.com) for instructions

Sample `.pre-commit-config.yaml`:

```yaml
-   repo: https://github.com/pycqa/flake8
    rev: 7.0.0
    hooks:
    -   id: flake8
        additional_dependencies: [flake8-timeout==2.0.0]
```

### extending the defaults

Use `--timeout-extend-funcs` to add custom functions while keeping the defaults:

**Command line:**
```bash
flake8 --timeout-extend-funcs=my_http_lib.request,custom.api.call:1
```

**Pre-commit:**
```yaml
-   repo: https://github.com/pycqa/flake8
    rev: 7.0.0
    hooks:
    -   id: flake8
        additional_dependencies: [flake8-timeout==2.0.0]
        args: [--timeout-extend-funcs=my_http_lib.request,custom.api.call:1]
```

This will check the defaults plus your custom functions.

### overriding the defaults

Use `--timeout-funcs` to replace the defaults entirely:

**Command line:**
```bash
flake8 --timeout-funcs=custom.http.get,custom.http.post:2
```

**Pre-commit:**
```yaml
-   repo: https://github.com/pycqa/flake8
    rev: 7.0.0
    hooks:
    -   id: flake8
        additional_dependencies: [flake8-timeout==2.0.0]
        args: [--timeout-funcs=custom.http.get,custom.http.post:2]
```

This will only check the functions you specify, ignoring the defaults.

### positional timeout arguments

Some functions accept timeout as a positional argument. Specify the 0-based index after a colon:

```
my_lib.fetch:2    # timeout is at index 2 (3rd argument)
other.call:0      # timeout is at index 0 (1st argument)
```

Example with positional timeout:

```python
# my_lib.fetch(url, data, timeout)
my_lib.fetch('https://api.example.com', None, 30)  # OK - timeout at index 2
my_lib.fetch('https://api.example.com', None)      # TIM100 - missing timeout
```