semvec/pypi-packages huggingface dataset:
llm-poker 0.1.14
Texas Hold'em environment with LLM players
Requires Python: >=3.8

# README.md
# llm_poker

A minimal Texas Hold’em environment that seats multiple **LLM-based players** (via the `llm` library) and manages everything from dealing hole cards to forced blinds, betting rounds, and a straightforward showdown.  

**Core features**:  
- **Blinds**: Each hand forces a small blind and a big blind, ensuring there’s money in the pot.  
- **Betting**: We query each LLM once per betting round, requesting an action in strict JSON form (`fold`, `call`, or `raise`).  
- **Local showdown logic**: The environment determines the best 5-card hand from each player’s 7 cards and awards the pot.  
- **Pydantic-based JSON validation**: The LLM responses are parsed and validated. If invalid, we retry.  
- **Optional CLI**: The `llm_poker` command can run multiple rounds using the specified LLMs.

-----

## Installation

1. **Install** the package:
   ```bash
   pip install llm_poker
   ```

You must also configure your llm library with the API keys for whichever LLM models you plan to use (e.g., gpt-4o, Anthropic, etc.). For example:

```bash
llm keys set openai
```

-----

## Quickstart Examples
1. Just run run.py
```bash
python run.py
```
Deals up to 5 rounds between multiple players: gpt-5, claude-4-sonnet, gemini-2.5-pro, deepseek-reasoner.
Uses elimination_count=0 so the game does not stop early (unless someone busts).
The minimum raise is 500 chips.
Logs each hand’s actions, culminating in a final standings table.

2. Using the CLI
If you installed with the included console script, you can do:

```bash
llm_poker --models "gpt-5 claude-4-sonnet gemini-2.5-pro deepseek-reasoner" --elimination-count 0 --stack 10000

```
This deals 5 rounds of heads-up between gpt-5 and claude-4-sonnet.


Once installed, you have access to:

```bash
llm_poker [OPTIONS]
```
--models/-m: Multiple model names or aliases recognized by llm (defaults to "gpt-5").
--rounds/-r: How many hands to deal (default 3).
--elimination-count/-e: Stop once only this many players remain (default 1).
--stack/-s: Starting chip stack (default 10000).

-----

## Known Limitations
- No side pots: Currently, if a player goes all-in, the environment doesn’t handle side pots.
- Manual environment checks: If the LLM returns “check” while facing a bet, the code interprets it as invalid and re-prompts.
- Fictitious ‘expert-level poker AI’: The LLM’s strategic brilliance is not guaranteed. This is more a demonstration environment than a truly advanced solver.
plane-adk 0.1.1
Plane Agent Development Kit
Requires Python: >=3.9

# plane-adk

A Python SDK for building intelligent agents that integrate with Plane.so workspace management platform. This package provides tools to create automated workflows, handle webhooks, and respond to workspace events.

## Installation

```bash
pip install plane-adk
```

## Usage

### Basic Setup

First, set up your environment variables for Plane OAuth:

```bash
export PLANE_CLIENT_ID="your_client_id"
export PLANE_CLIENT_SECRET="your_client_secret"
export PLANE_REDIRECT_URI="your_redirect_uri"
export PLANE_BASE_URL="https://api.plane.so"  # Optional, defaults to this
```

### Creating a PlaneAgent

```python
from plane_adk.agent import PlaneAgent, Credentials

# Create credentials
credentials = Credentials(
    client_id="your_client_id",
    client_secret="your_client_secret",
    app_installation_id="your_app_installation_id",
    base_url="https://api.plane.so",  # Optional
    redirect_uri="your_redirect_uri"
)

# Initialize the agent
agent = PlaneAgent(credentials)
```

### Handling Events

The PlaneAgent supports various events that you can listen to:

```python
def assigned_callback(handler, context):
    """Called when an issue is assigned to the bot"""
    handler.progress("I've been assigned to this issue!")

    # Access issue details
    issue_id = context.issue_id
    issue_payload = context.issue_payload

    # Add a comment to the issue
    handler.progress("Starting work on this issue...")

def mentioned_callback(handler, context):
    """Called when the bot is mentioned in an issue comment"""
    handler.progress("Thanks for mentioning me!")

    # You can access the comment data
    comment_data = context.event.data

    # Respond to the mention
    handler.progress("I'm here to help with this issue!")

# Register event handlers
agent.issue.on("assigned", assigned_callback)
agent.issue.on("mentioned", mentioned_callback)

# Process incoming webhooks
agent.process_webhook(webhook_data)
```

### Examples

For more detailed examples, check out the `example/` folder which includes:

- **FastAPI Integration**: Complete webhook server setup with OAuth handling
- **AI Task Breakdown**: Advanced example using AI to automatically break down issues into actionable tasks

## Supported Events

- `assigned`: Triggered when an issue is assigned to the bot
- `mentioned`: Triggered when the bot is mentioned in an issue comment
- `unassigned`: Triggered when the bot is unassigned from an issue

## Context Object

The context object passed to event handlers contains:

- `issue_id`: The ID of the issue
- `workspace_id`: The workspace ID
- `workspace_slug`: The workspace slug
- `project_id`: The project ID (if applicable)
- `issue_payload`: Full issue data from Plane API
- `event`: The original webhook event data
- `entity_name`: Type of entity ("issue" or "comment")
- `entity_id`: ID of the entity

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.
aviyal-desktop 0.0.3
an unofficial tool for running anvil app locally in desktop environment
Requires Python: >=3.6
Keywords: desktop, anvi, run, local, generate

### aviyal_desktop_library

An unofficial tool for running Anvil apps locally in a desktop environment.  
This library allows you to programmatically run the Anvil runtime, internally using a Java command to run a JAR file bundled with your Anvil app. It is especially useful for embedding Anvil-based web apps into a desktop setting or automating local Anvil app launches.

#### Features

- Programmatic interface (`aviyal` class) to run Anvil apps without using the command line.
- Mimics Python executable behavior for running scripts and modules, useful for PyInstaller-based desktop apps.
- Automatically manages Java runtime environment and port configuration.
- Supports passing configuration files and managing app dependencies.
- Handles SSL certificate setup for server JAR downloads (critical for Windows environments).

#### Installation

Clone the repository and include it in your Python environment:

```sh
git clone https://github.com/its-me-abi/aviyal_desktop_library.git
cd aviyal_desktop_library
# install dependencies as needed
```

#### Usage

Here is an example of starting an Anvil server locally with an app created using the online Anvil editor:

```python
from aviyal_desktop.aviyal_desktop import aviyal
from pathlib import Path

app_path = Path("ANVIL_APPS/MyTodoList")
stub_path = Path("ANVIL_DESKTOP_DEPENDENCYS")
anvilobj = aviyal(app_path, ANVIL_DESKTOP_DEPENDECYS=stub_path)
anvilobj.run()
```

- `app_path`: Path to your exported Anvil app.
- `ANVIL_DESKTOP_DEPENDECYS`: Path to the directory containing dependencies (e.g., Java Runtime).

#### How it works

- The `aviyal` class assembles command-line arguments, manages dependencies, and launches the Anvil server.
- If a `config.yaml` file is present in the app directory, it will be used for additional server configuration.
- The library sets up the environment so that embedded Java and Python executables work seamlessly for both direct launching and proxy execution.

#### License
This software is distributed under the GNU Affero General Public License v3 (AGPLv3), with a special exception for Anvil applications. See the [LICENSE](LICENSE) file for details.

#### credits
all credits goes to creators of anvil system.because this tool is created on top of it
m-tecConnectOPC-UA-TEST 0.0.2
OPC-UA client classes for m-tec machines (Mixingpump, Printhead, Dosingpump)
Requires Python: >=3.7
Keywords: opcua m-tec automation mixingpump printhead dosingpump

# m-tecConnectOPC-UA

OPC-UA client classes for m-tec machines (Mixingpump, Printhead, Dosingpump).

## Installation

```bash
pip install m-tecConnectOPC-UA
```

## Usage

```python
from m-tecConnectOPC-UA import Mixingpump, Printhead, Dosingpump

# Example usage
mp = Mixingpump()
mp.connect("opc.tcp://10.129.4.73:4840")
mp.running = True
print(mp.real_speed)
```

## Requirements
- Python >= 3.7
- asyncua >= 1.0.0

## License
MIT