semvec/pypi-packages huggingface dataset:
zenith-trade-client 0.1.3
Python client for accessing Zenith-Trade backend
License: MIT
Requires Python: >=3.8

# Zenith Trade Client

A simple Python client to interact with the **Zenith-Trade FastAPI backend**.

## Installation
``` bash
pip install zenith-trade-client
```

## 🚀 Usage

### Import the client

``` python
from zenith_trade_client import ZenithTradeClient
# default: mode="localhost", port=8000 (works on in-house server)
client = ZenithTradeClient()

# OR: Remote via Tailscale hostname
client = ZenithTradeClient(mode="tailscale", tailscale_host="", port=8000)
```

### List All Exchanges

``` python
exchanges = client.list_exchanges()
print(exchanges)
```

### Get Exchange Info

``` python
info = client.get_exchange_info("lmax_futures")
print(info)
```

### Check Data Availability

``` python
availability = client.check_data_availability(
    exchange="binance",
    symbols=["BTCUSDT", "ETHUSDT"],
    data_types=["trades", "book_snapshot_5"],
    from_date="2025-09-01",
    to_date="2025-09-08"
)
print(availability)
```
fastofreader 0.2.0
Fast numerical operations implemented in Cython
License: MIT
Requires Python: >=3.10
Keywords: cython, numerics, performance

# fastofreader

Fast readers for OpenFOAM mesh files implemented in Cython. Currently supports:

- faces: reads integer index groups from OpenFOAM `faces` files
- points: reads triplets of floats from OpenFOAM `points` files
- boundary: reads boundary metadata (nFaces, startFace) from OpenFOAM `boundary` files

Designed to be simple, dependency-free, and fast.

Author: Tomas Vicar <tomasvicar@gmail.com>

## Installation

For development (editable):

```bash
pip install -e .
```

This builds the Cython extension once and links it in editable mode.

## Usage

```python
from fastofreader import (
	read_faces,
	read_points,
	read_faces_from_text,
	read_points_from_text,
	read_boundary,
)

# Faces from file
faces = read_faces("faces_test_file")
print(len(faces), faces[0][:4])

# Points from file
pts = read_points("points_test_file")
print(len(pts), pts[0])

# Boundary file
bounds = read_boundary("boundary_test_file")
print(list(bounds.items())[:1])

# In-memory variants
faces2 = read_faces_from_text("(1 2 3) (4, 5, 6)")
pts2 = read_points_from_text("(0 0 0) (1e-5 0 0)")
```

## API

- `read_faces(path: str) -> list[list[int]]`
	- Reads all integer groups enclosed in parentheses from a file. Returns a list of groups.
- `read_faces_from_text(text: str) -> list[list[int]]`
	- Same as above but takes a string input.
- `read_points(path: str) -> list[list[float]]`
	- Reads point coordinates as triplets `(x y z)` from a file. Returns a list of `[x, y, z]`.
- `read_points_from_text(text: str) -> list[list[float]]`
	- Same as above but takes a string input.
- `read_boundary(path: str) -> dict[str, dict[str, int]]`
	- Parses OpenFOAM boundary file into `{name: {"nFaces": int, "startFace": int}}`.

Notes:
- Parsers ignore the OpenFOAM header and the outer count/parenthesis wrapper.
- Faces parser accepts separators as whitespace, commas, or semicolons.

## Performance tips

- Prefer file-based functions (`read_faces`, `read_points`) to avoid extra encoding/decoding.
- Use CPython 3.10+ for best performance.

## Development

Requirements are declared in `pyproject.toml` and built via setuptools. Common tasks:

```bash
# Editable install
python -m pip install -e .

# Run tests
pytest -q
```

## License

MIT

## Instalace (vývoj)
```bash
pip install -e .