semvec/pypi-packages huggingface dataset:
tactigon-ironboy 1.0.1
IronBoy Library
License: MIT
Requires Python: >=3.8.0
Keywords: tactigon, arduino, robot, cobot, ironboy

# Tactigon IronBoy

![The tactigon team](https://avatars.githubusercontent.com/u/63020285?s=200&v=4)

This package enables to comunicate with IronBoy using a Bluetooth to UART device such as Adafruit Bluefruit LE Uart.

This package can be used alongside with [Tactigon Gear](https://pypi.org/project/tactigon-gear/) and [Tactigon Speech](https://pypi.org/project/tactigon-speech/) libraries to drive IronBoy robot using gesture and "edge" voice command detection.


## Prerequisites
In order to use the Tactigon Arduino Braccio library you need:

* Python version: following versions has been used and tested. It is STRONGLY recommended to use these ones depending on platform.
  * Win10: 3.8.7

## Installing

Install and update using pip:

`pip install tactigon-ironboy`

## A Simple Example

```python
import time
from tactigon_ironboy import IronBoy, IronBoyCommand, IronBoyConfig

if __name__ == "__main__":
    cfg = IronBoyConfig("TactigonIronBoy", "FE:E2:2B:47:5D:80")

    with IronBoy(cfg) as ironboy:
        while True:
            if not ironboy.connected:
                print("connecting...")
                time.sleep(1)
                continue

            print("Connected")

            # Do 5 steps forward
            ironboy.send_command(IronBoyCommand.WALK_FWD, 5)

            while ironboy.executing:
                time.sleep(0.1)

            # Do celebration!
            ironboy.send_command(IronBoyCommand.CELEBRATE)

            while ironboy.executing:
                time.sleep(0.1)
            
            break
```

## Links
- [Arduino code](https://github.com/TactigonTeam/Tactigon-SDK/blob/main/examples/arduino_braccio/arduino_code/braccio.ino)
- [Solver](https://github.com/NNaert/Python-controlled-Braccio-robot-arm)
- [Tactigon integration](https://github.com/TactigonTeam/Tactigon-SDK)
qfex 0.1.0
A Python SDK for the QFEX Taker API
License: MIT
Requires Python: >=3.7

# qfex-py

A modern, high-performance Python SDK for the [QFEX](https://qfex.com) Taker API.

![Python Version](https://img.shields.io/badge/python-3.10%2B-blue)
![License](https://img.shields.io/badge/license-MIT-green)

## Features

*   **AsyncIO**: Fully asynchronous design using `asyncio` and `websockets` for low-latency trading.
*   **Type Safe**: Comprehensive type hints and Enums (`Side`, `OrderType`, etc.) for robust code.
*   **Easy Configuration**: Simple configuration object for switching between Prod/UAT and managing keys.
*   **Strategy Pattern**: Clean `TakerStrategy` base class to separate your trading logic from connection management.
*   **Resilience**: Automatic reconnection, exponential backoff, and heartbeat management.
*   **Modern Python**: Built for Python 3.10+ with Context Manager support.

## Installation

Install via pip (once published) or directly from source:

```bash
pip install qfex
```

Or from source:

```bash
git clone https://github.com/qfex/qfex-py.git
cd qfex-py
pip install .
```

## Quick Start

Here is a minimal example of a strategy that logs the Best Bid/Offer (BBO) and Order Fills.

```python
import asyncio
import logging
from qfex import QFEXTakerClient, QFEXConfig, TakerStrategy, BBO, Side

class MyStrategy(TakerStrategy):
    async def on_bbo(self, bbo: BBO) -> None:
        print(f"BBO Update: {bbo.symbol} {bbo.bid_qty} @ {bbo.bid_px}")

    async def on_fill(self, fill: dict) -> None:
        print(f"Fill: {fill}")

async def main():
    # 1. Configure
    cfg = QFEXConfig(
        is_prod=False,  # Set to True for Production
        symbol_list=["AAPL-USD"],
        public_key="YOUR_PUBLIC_KEY",
        secret_key="YOUR_SECRET_KEY",
    )

    # 2. Initialize Strategy & Client
    # Note: Strategy is initialized with a placeholder client initially
    client = QFEXTakerClient(cfg, strategy=None) # type: ignore
    strategy = MyStrategy(client)
    client.strategy = strategy

    # 3. Run
    print("Starting client...")
    await client.run()

if __name__ == "__main__":
    asyncio.run(main())
```

## Advanced Usage

### Sending Orders

You can send orders easily from within your strategy callbacks or any other async function:

```python
await client.send_ioc_limit(
    symbol="AAPL-USD",
    side=Side.BUY,
    quantity=Decimal("0.1"),
    price=Decimal("50000.00")
)
```

### Async Context Manager

For integration with other async applications (like FastAPI, or multi-exchange bots), use the client as a context manager. This runs the websocket loops in the background without blocking your main thread.

```python
async def main():
    cfg = ... 
    client = QFEXTakerClient(cfg, strategy=...)
    
    async with client:
        # Client is now connected and processing events
        print("Client is running in background")
        
        # Do other work...
        await asyncio.sleep(60)
        
    # Client automatically disconnects here
```

## Development

### Requirements

*   Python 3.10+
*   `websockets`

### Running Tests (Type Checking)

```bash
mypy src/qfex
```

## License

MIT