semvec/pypi-packages huggingface dataset:
dojo-sdk-client 0.1.37
Client sdk to intearct with Dojo
Requires Python: >=3.10

# Dojo SDK Client

Python client SDK for interacting with the Dojo API

## Installation

```bash
uv add dojo-sdk-client
```

if you want to use our example agents:

```bash
uv add "dojo-sdk-client[agents]"
```

if you want to use our multi-turn environment with [verifiers](https://github.com/willccbb/verifiers)

```bash
uv add "dojo-sdk-client[multi_turn_env]"
```

if you want to use our browserbase engine:

```bash
uv add "dojo-sdk-client[browserbase]"
```

## Quick Start

### Basic Task Execution

```python
from dojo_sdk_client import BaseDojoClient
from dojo_sdk_client.types import TaskStatus

client = BaseDojoClient(api_key="your-api-key")

# Create and start task
exec_id = await client.create_task(
    task_id="tic-tac-toe/win-game",
    state={"board": [[0]*3 for _ in range(3)]}
)
await client.start_task(exec_id)

status = await client.get_task_status(exec_id)
while status.status == TaskStatus.QUEUED:
    await asyncio.sleep(1)
    status = await client.get_task_status(exec_id)

# Submit action
action = {"type": "click", "x": 100, "y": 100}
await client.submit_action(exec_id, action, "Making move")

```

### Agent Evaluation

```python
from dojo_sdk_client import DojoEvalClient
from dojo_sdk_client.select_engine import select_engine

engine = select_engine(API_KEY)

eval_client = DojoEvalClient(agent=agent, engine=engine)

results = await eval_client.evaluate(tasks=["tic-tac-toe/win-game", "2048/get-256-tile"], num_runners=1)
```

### Changing Engines

```python
from dojo_sdk_client.engines.browserbase_engine import BrowserBaseEngine

engine = BrowserBaseEngine(
    api_key="your-browserbase-api-key",
    project_id="your-browserbase-project-id",
    dojo_api_key="your-dojo-api-key"
)

eval_client = DojoEvalClient(agent=your_agent,engine=engine)
```

BrowserBase engine has a concurrency limit that can be controlled with the `BROWSERBASE_CONCURRENT_LIMIT` environment variable.

## Clients

**BaseDojoClient** - Low-level HTTP client for direct API interactions

**DojoEvalClient** - High-level client for running automated evaluations

**MultiTurnEnv** - Multi-turn environment for running evaluations with Verifiers

## Engines

**DojoEngine** - Default engine for running tasks using Dojo

**BrowserBaseEngine** - Engine for running tasks using BrowserBase

## Documentation

Visit [docs.trydojo.ai](https://docs.trydojo.ai) for complete documentation.
retinahash 0.1.1
A lightweight Python library for perceptual image hashing, currently providing pHash with an extensible design.
Requires Python: >=3.12

# RetinaHash  
**Lightweight, pure-NumPy perceptual hashing for images**

RetinaHash computes compact, rotation-invariant fingerprints of images using only NumPy...no OpenCV, no PIL, no Scipy.  
Perfect for duplicate detection, near-duplicate search, and lightweight image clustering.

## Features
- **Pure NumPy** – runs anywhere Python runs  
- **Rotation invariant** – same hash for 0°, 90°, 180°, 270° rotations  
- **Auto-crop** – strips solid scanner borders automatically  
- **Extensible** – plug-in architecture for new hash algorithms  
- **Fast** – ~1 ms per 512×512 image on a laptop CPU (**TRUST ME BRO** Benchmark, lol.)

## Install
```bash
pip install retinahash
```
Or better, because you are sane and use uv to manage your projects:
```bash
uv add retinahash
```
(or drop the `retinahash/` folder into your project—zero dependencies beyond NumPy).

## Quick Start
```python
import imageio.v3 as iio          # any loader will do but numpy array is expected
from retinahash import RetinaHash

img = iio.imread("photo.jpg")
h   = RetinaHash.phash(img, rotation_invariant=True)
print(h)        # 16-char hex string, e.g. 'a5f3c1e8d2b4906e'
```

Compare two images (via Hamming distance):
```python
h1 = RetinaHash.phash(img1)
h2 = RetinaHash.phash(img2)
distance = RetinaHash.distance(h1, h2)
```

## API
`RetinaHash.hash(image, method='phash', hash_size=8, rotation_invariant=False, auto_crop=False)`  
`RetinaHash.phash(image, **kwargs)` – convenience wrapper  
`RetinaHash.distance(hex1, hex2)` – Hamming distance between two hex hashes  

## Algorithms
| Key  | Description |
|------|-------------|
| `phash` | DCT-based perceptual hash (default) |

More algorithms (`ahash`, `dhash`, `whash`, …) can be added by dropping a new module into `retinahash/strategies/` and registering it in `STRATEGIES`.

## Customisation
```python
# 16-bit hash, auto-crop on, rotation invariant
h = RetinaHash.hash(img, method='phash', hash_size=16,
                    auto_crop=True, rotation_invariant=True)
```

## License
MIT – do what you want, just keep the copyright notice.
See LICENSE file.

---

That’s it—clone, hash, dedupe.