semvec/pypi-packages huggingface dataset:
aphex-service-clients 0.2.2
Generated API clients for Aphex platform services
Requires Python: >=3.11

# Aphex Service Clients

Generated API clients for Aphex platform services with built-in retry logic, exponential backoff, and jitter.

## Installation

```bash
pip install aphex-service-clients
```

## Usage

```python
from aphex_clients.embedding import EmbeddingClient

async with EmbeddingClient(base_url="http://embedding-svc:8000") as client:
    response = await client.create_embeddings(input=["Hello world"])
    embeddings = [d.embedding for d in response.data]
```

## Regenerating Clients

When OpenAPI specs change:

```bash
pip install -e ".[dev]"
./scripts/generate-clients.sh
```

## Services

- **Embedding Service** - OpenAI-compatible embedding generation
aovt 1.0.0
A tool for decompress/compressed file AOV/ROV game
Requires Python: >=3.8

ENG:

A Tool Python to Decompress/Compress AOV/ROV file with library Python Zstandard (pyzstd)

VI:

1 công cụ Python dùng để Giải mã hoá/Mã hoá tệp với thư viện Python Zstandard (pyzstd)



\# **Update 0.0.5**

ENG:

* Added new alias package "aovt"
* Fix bug

VI:

* Thêm tên gọi gói mới "aovt"
* Sửa lỗi
orascope 0.0.2
Computational paleography engine for Chinese script evolution
Requires Python: >=3.10
Keywords: paleography, oracle-bone-script, chinese, manifold-learning, computational-linguistics

# 🔭 Orascope (Code: ORASCOPE)
**"A Hubble Telescope for Ancient Chinese Civilization"**

## Overview
Orascope is a computational paleography engine built to reverse-engineer Chinese script evolution. It bridges the "Modality Gap" between Oracle Bone Script (OBS) imagery and modern semantic concepts using manifold learning.

## The Instrument Suite
Orascope integrates three core "lenses":
* **`maniscope`**: RAG-based retrieval and evidence grounding.
* **`semanscope`**: Geometric visualization of semantic manifolds.
* **`orascope`**: The evolution tracker and cross-modal alignment engine.

## Core Principles
* **Non-Euclidean:** Uses Diffusion Geometry and Geodesic distances.
* **Topology-First:** Prioritizes stroke connectivity and branching over raw pixel similarity.

## References

- https://gemini.google.com/app/a9c9d1ade606fa50
    - https://gemini.google.com/share/9bb45103f1ec
dd-logging 0.1.1
Shared logging helpers for Digital Duck projects (spl-llm, spl-flow, …)
Requires Python: >=3.10
Keywords: logging, digital-duck, spl

# dd-logging

Shared logging helpers for [Digital Duck](https://github.com/digital-duck) projects.

Provides a consistent, timestamped-file logging pattern for CLI tools and Streamlit apps.
Used by **spl-llm** and **spl-flow**; designed to be reused by any project in the ecosystem.

## Install

```bash
# from PyPI (once published)
pip install dd-logging

# local editable install (for development)
pip install -e /path/to/dd-logging
```

## Usage

```python
from dd_logging import setup_logging, get_logger, disable_logging

# 1. Call once per process (CLI entry point or app startup)
log_path = setup_logging(
    "run",
    root_name="my_app",       # top-level logger namespace
    adapter="openrouter",     # appended to filename (optional)
    log_level="info",         # debug | info | warning | error
)
# → logs/run-openrouter-20260215-143022.log

# 2. In each module
_log = get_logger("nodes.text2spl", root_name="my_app")
_log.info("translating query  len=%d", len(query))

# 3. Silence all logging (e.g. --no-log CLI flag)
disable_logging("my_app")
```

### Thin wrapper pattern (recommended)

Each project wraps `dd_logging` so call-sites never pass `root_name`:

```python
# myapp/logging_config.py
from pathlib import Path
from dd_logging import setup_logging as _setup, get_logger as _get, disable_logging as _disable

_ROOT   = "my_app"
LOG_DIR = Path(__file__).resolve().parent.parent / "logs"

def get_logger(name: str):
    return _get(name, _ROOT)

def setup_logging(run_name: str, **kw):
    kw.setdefault("log_dir", LOG_DIR)
    return _setup(run_name, root_name=_ROOT, **kw)

def disable_logging():
    return _disable(_ROOT)
```

## Log file naming

```
<log_dir>/<run_name>[-<adapter>]-<YYYYMMDD-HHMMSS>.log

logs/run-openrouter-20260215-143022.log
logs/benchmark-claude_cli-20260215-144500.log
logs/generate-20260215-145001.log
```

## Logger hierarchy

```
my_app                     ← root (FileHandler attached here)
├── my_app.api             ← get_logger("api", "my_app")
├── my_app.nodes.text2spl  ← get_logger("nodes.text2spl", "my_app")
└── my_app.flows           ← get_logger("flows", "my_app")
```

All child loggers inherit the root's handler — no per-module handler setup needed.

## Design notes

- **`propagate=False`** — prevents duplicate output when a root Python logger
  handler is already configured (e.g. Streamlit, pytest, Jupyter).
- **Stale-handler removal** — calling `setup_logging()` multiple times in one
  process (e.g. test suites) is safe; old `FileHandler`s are replaced.
- **No third-party dependencies** — stdlib `logging` only.

## Projects using dd-logging

| Project | Root name | Log dir |
|---------|-----------|---------|
| [spl-llm](https://github.com/digital-duck/SPL) | `spl` | `SPL/logs/` |
| [spl-flow](https://github.com/digital-duck/SPL-Flow) | `spl_flow` | `SPL-Flow/logs/` |

## License

MIT
pybinbot 0.6.29
Utility functions for the binbot project.
Requires Python: >=3.11

# PyBinbot

Utility functions for the binbot project. Most of the code here is not runnable, there's no server or individual scripts, you simply move code to here when it's used in both binbot and binquant.

``pybinbot`` is the public API module for the distribution.

This module re-exports the internal ``shared`` and ``models`` packages and the most commonly used helpers and enums so consumers can simply::

        from pybinbot import round_numbers, ExchangeId

The implementation deliberately avoids importing heavy third-party libraries at module import time.


## Installation

```bash
uv sync --extra dev
```

`--extra dev` also installs development tools like ruff and mypy


## Publishing

1. Save your changes and do the usual Git flow (add, commit, don't push the changes yet).
2. Bump the version, choose one of these:

```bash
make bump-patch
```
or 

```bash
make bump-minor
```

or

```bash
make bump-major
```

3. Git tag the version for Github. This will read the bump version. There's a convenience command:
```
make tag
```

4. `git commit --amend`. This is to put these new changes in the previous commit so we don't dup uncessary commits. Then `git push`


For further commands take a look at the `Makefile` such as testing `make test`