semvec/pypi-packages huggingface dataset:
pnl-core 0.7.1
Infrastructure Economics Advisor: Measure Kyle's Lambda fairness gaps using Rust-accelerated calculations. Optimize trading strategy within broker latency constraints.
Requires Python: >=3.7
Keywords: trading, execution, fairness, kyle-lambda, market-microstructure, infrastructure-economics, rust, quantitative-finance

# PnL Watchdog for Crypto Market Makers

PnL Watchdog is a read-only execution intelligence layer for market makers on crypto venues like Bybit.

It helps you answer one question fast: `is my edge being eaten by microstructure friction?`

## Why it is useful

- Measures execution friction (impact, slippage, toxicity proxies, order-flow quality)
- Flags anomaly windows where fills degrade (latency/slippage outliers)
- Gives user-scoped import + analytics from your own account history
- Works with read-only exchange credentials (no trade/withdraw permissions required)

## 5-minute setup

1. Start API:

```bash
uvicorn pnl_watchdog_lib.api.main:app --host 0.0.0.0 --port 8000
```

2. Register your PnL Watchdog API key:

```bash
curl -X POST http://localhost:8000/v1/auth/register \
  -H "Content-Type: application/json" \
  -d '{"email":"you@example.com"}'
```

3. Import Bybit read-only trade history:

```bash
curl -X POST http://localhost:8000/import/bybit \
  -H "Content-Type: application/json" \
  -H "X-API-Key: pnlw_your_key" \
  -d '{"api_key":"BYBIT_READ_KEY","api_secret":"BYBIT_READ_SECRET","market_type":"swap","lookback_days":7}'
```

4. Get your execution stats:

```bash
curl -X GET http://localhost:8000/stats/pnl \
  -H "X-API-Key: pnlw_your_key"
```

## Security model

- Use exchange keys with `read-only` scope only.
- PnL Watchdog API keys are stored hashed at rest.
- Data is scoped per authenticated user.
edufms 0.3.0
Пакет для взаимодействия с ФМС
Requires Python: >=3.9

Пакет для взаимодействия с ФМС.
==================================================

**Пример использования**

1. Указываем параметры конфигурации
::

    config_params = {
        'wsdl_url': settings.WSDL_URL,
        'certificate_path': cert_path,
        'private_key_path': key_path,
        'private_key_pass': settings.SMEV_PRIVKEY_PASS,
        'smev_sender_code': settings.SMEV_SENDER_CODE,
        'smev_sender_name': settings.SMEV_SENDER_NAME,
        'recipient_code': settings.RECIPIENT_CODE,
        'recipient_name': settings.RECIPIENT_NAME,
        'system_okato': settings.OKATO,
        'region_code': settings.REGION_CODE
    }
    config = FmsRequestConfig(**config_params)


2. Создаем экземпляр клиента
::

    fms_client = FmsClient(config)

3. Выполняем запрос с параметрами
::

    request_params = {
        'RequestIdRef': fms_request.request_id_ref,
        'OriginRequestIdRef': fms_request.origin_request_id_ref,
        'taskId': fms_request.query_id,
    }
    result = fms_client.request('getResult', request_params)

4. Пример обработки результата
::

    err_code = result.MessageData.AppData.errorCode
    error_description = result.MessageData.AppData.errorDescription

    if err_code == FmsClient.RC_REQUEST_ACCEPTED:
        last_sent = fms_client.last_sent
        last_received = fms_client.last_received
        # save results
    else:
        # process error
pogo-torch 1.0.1
A Proximal One-step Geometric Orthoptimizer in Pytorch
Requires Python: >=3.11
Keywords: torch, pytorch, optimizer, orthoptimizer, constrained-optimization, deep learning

# A Proximal One-step Geometric Orthoptimizer

This a [PyTorch](https://pytorch.org>) implementation of the POGO algorithm proposed in  [An Embarrassingly Simple Way to Optimize Orthogonal Matrices at Scale](TODO).
This is a lightweight and easy-to-use library containing the optimizer as a normal Pytorch Optimizer, and two base optimizers to choose for from now: SGD and [Vector Adam](https://arxiv.org/abs/2205.13599).

**Beware:** You should pass only orthogonal parameters to POGO and initialize them as such. See below!

## Installation

You can install `pogo` from pip by simply running

```bash
pip install pogo-torch
```

Or, if you are using `uv`, you can add it to your project with
```bash
uv add pogo-torch
```

Alternatively, you can install it directly from the repository:

```bash
pip install git+https://github.com/adrianjav/pogo
```

## Getting started

POGO is implemented as a Pytorch optimizer, so it should be quite intuitive to use. Moreover, the default parameters should work for most use cases. If that were not the case, feel free to check the docstrings and ultimately open an issue.

To initialize your parameters as orthogonal, you can either use [`torch.init.orthogonal_`](https://docs.pytorch.org/docs/stable/nn.init.html#torch.nn.init.orthogonal_) (but make sure it does what you intend given the shape of your parameters) or use any other initialization method and then project them to be orthogonal. For example:

```python
X = ... # My parameter
U, S, VT = torch.linalg.svd(X, full_matrices=False)
X.data = U @ VT
```

Then, you can use POGO as any other optimizer:

```python
from pogo import base, POGO

model = ...  # Ensure that your parameters are initialized as orthogonal!
optimizer = POGO(model.parameters(), base.VectorAdam(), learning_rate)

for epoch in range(num_epochs):
    optimizer.zero_grad()
    ...
    loss.backward()
    optimizer.step()
```

By default, POGO expects matrices of the form `[num_matrices, p, n]` with $p < n$ and such that `torch.bmm(X, X)` yields `num_matrices` identity matries of size $p \times p$. If that does not fit your needs (e.g. you have more than one leading axis, or you need colum-orthogonal matrices), then please do check POGO's `flatten_fn` and `rows` parameters.

## Citation

```bibtex
@article{javaloy2026pogo,
    title   = {An Embarrassingly Simple Way to Optimize Orthogonal Matrices at Scale},
    author  = {Javaloy, Adri{\'a}n and Vergari, Antonio},
    year    = 2025,
	journal = {ArXiv preprint},
	volume  = {2602.14656},
	url     = {https://arxiv.org/abs/2602.14656}
}
```
rtc-tools-simulation 0.3.0b1
Extension for building models used for simulation in rtc-tools.
Requires Python: >=3.9

# rtc-tools-simulation

This is rtc-tools-simulation, a toolbox for simulation model building for [rtc-tools](https://gitlab.com/deltares/rtc-tools).

## Install

```bash
pip install rtc-tools-simulation
```

## Documentation

Documentation and examples can be found on [readthedocs](https://rtc-tools-simulation.readthedocs.io).

## Developer guidelines

Developer guidelines can be found [here](https://gitlab.com/rtc-tools-project/rtc-tools-simulation/-/blob/main/CONTRIBUTING.md)
pybelugaxl 0.1.4
A Python library to track the Airbus BelugaXL flights in real time using FlightRadar24
Requires Python: >=3.11
Keywords: belugaxl, airbus, beluga, flightradar24, realtimetracking

# <img src="https://raw.githubusercontent.com/Tarikul-Islam-Anik/Animated-Fluent-Emojis/master/Emojis/Animals/Whale.png" alt="Whale" width="25" height="25" /> pybelugaxl

A Python library to track the Airbus BelugaXL flights in real time using FlightRadar24.

## <img src="https://raw.githubusercontent.com/Tarikul-Islam-Anik/Animated-Fluent-Emojis/master/Emojis/Activities/Bullseye.png" alt="Bullseye" width="25" height="25" /> Features
- Fetch current BelugaXL flights
- Filter by registration number, flight status, or departure/arrival airport
- Return detailed flight information: position, speed, altitude, departure/arrival times
- Return a boolean if a specific aircraft is found in a given zone
- Get stats about the entire BelugaXL fleet

## <img src="https://raw.githubusercontent.com/Tarikul-Islam-Anik/Animated-Fluent-Emojis/master/Emojis/Travel%20and%20places/Airplane%20Departure.png" alt="Airplane Departure" width="25" height="25" /> Usage
```python
from pybelugaxl import get_beluga, is_beluga_in_zone

flights = get_beluga(status="enroute")
for f in flights:
    print(f"{f.registration}: {f.from_airport} -> {f.to_airport}, Altitude: {f.altitude} ft")

in_zone = is_beluga_in_zone(zone="france", registration="F-GXLI")
print(in_zone)
```

## <img src="https://raw.githubusercontent.com/Tarikul-Islam-Anik/Animated-Fluent-Emojis/master/Emojis/Objects/Light%20Bulb.png" alt="Light Bulb" width="25" height="25" /> Installation 
```bash
pip install pybelugaxl
```

## <img src="https://raw.githubusercontent.com/Tarikul-Islam-Anik/Animated-Fluent-Emojis/master/Emojis/Objects/Link.png" alt="Link" width="25" height="25" /> Attribution 
Data is provided by the unofficial [FlightRadarAPI](https://github.com/JeanExtreme002/FlightRadarAPI)
 library (MIT License).

## <img src="https://raw.githubusercontent.com/Tarikul-Islam-Anik/Animated-Fluent-Emojis/master/Emojis/Objects/Page%20with%20Curl.png" alt="Page with Curl" width="25" height="25" /> License
This project uses an MIT license, see [LICENSE](LICENSE) file for more information.
vardict 1.0.5.post0
vardict - dict with variables
Requires Python: >=3.9

 <img src="https://www.salabim.org/vardict/vardict_logo.png">

### Changelog

For the changelog, see www.salabim.org/vardict/changelog .

### Introduction

With vardict, it is possible to build up a dictionary based on variable names and their value.
For instance,

```
first_name = "John"
last_name = "Smith"
name = vardict(first_name, last_name)
```
Now, `name` will be `dict(first_name='John', last_name='Smith')`.

In the same call, additional keywords can be added:

```
name = vardict(first_name, last_name, age=21, nationality="FR")
```
Now, `name` will be `dict(first_name='John', last_name='Smith', age=21, nationality='FR')`.

This functionality is handy for calling functions with (many) keyword arguments, e.g. with salabim:
```
for x in range(1001,100):
    for y in range(701, 100):
        text = f'{x}-{y}'
        sim.Animatext(**vardict(x, y, text, angle=45)) # instead of sim.Animatext(**vardict(x=x, y=y, text=text, angle=45))
```
Note that only variables are allowed, so no literals or expressions.


### Usage
Importing can be done with
```
import vardict
```
or
```
from vardict import vardict
```

### Installation
Just install with `pip install vardict`.
gradium 0.5.8
Python client for Gradium API
Requires Python: >=3.12
Keywords: ai, api, gradium, streaming, stt, tts, voice

# Gradium Python Client

Python client library for the [Gradium Voice AI API](https://gradium.ai).

## Examples

See the [examples/](examples/) directory for usage examples:

- Text-to-Speech Streaming: `examples/tts_streaming.py`
- Speech-to-Text Streaming: `examples/stt_streaming.py`

You can also try it out in Google Colab.

- EU Server <a target="_blank" href="https://colab.research.google.com/github/gradium-ai/gradium-py/blob/main/notebooks/gradium_example_eu.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a>
- US server <a target="_blank" href="https://colab.research.google.com/github/gradium-ai/gradium-py/blob/main/notebooks/gradium_example_us.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a>


## Command Line Interface

The package includes a CLI that can be run via `uvx gradium`:

```bash
# Text-to-speech
uvx gradium tts "Hello world" -o output.wav
uvx gradium tts "Hello world" --voice-id abc123 -o output.ogg

# Speech-to-text
uvx gradium stt audio.wav
uvx gradium stt audio.wav --json  # outputs JSON with timestamps

# To handle non-wav file, additional dependencies are required
uvx --from 'gradium[cli]' gradium stt audio.mp3
```

Run `uvx gradium --help` for all available options.

## Text-to-Speech Streaming Example

You can find some examples in the `examples/` directory. Try them out with
[uv](https://docs.astral.sh/uv/getting-started/installation/). For
the text-to-speech streaming example, run:

```bash
uv run --with sphn examples/tts_streaming.py \
    --text "Hello, this is a test of the Gradium TTS streaming API." \
    --api-key gsk_...
```

## Speech-to-Text Streaming Example

You can also try the speech-to-text streaming example:

```bash
uv run --with sphn examples/stt_streaming.py \
    --audio test_file.mp3 \
    --api-key gsk_...
```
dc-adb-tools 0.1.0
A lightweight Khmer greeting utility for Python

# DC AdbTools

**Credit:** Original development by **Dai Chao Online**

adbTools is a lightweight Python package for Android device automation using ADB.  
It helps developers control devices, manage apps, and automate actions with simple and clear methods.

## Features

- Get a list of connected devices
- Get the index of a specific device
- Uninstall the uiautomator2 app
- Set the device's timezone
- Set the timezone based on a region
- Grant permissions to the uiautomator2 app

## Usage
```python
from dc_adb_tools import AdbCommand, AdbConnection

# Create an AdbCommand instance
adb_command = AdbCommand(deviceID="your_device_id")

# Uninstall the uiautomator2 app
adb_command.uninstall_uiautomator2()

# Set the device's timezone
adb_command.set_device_timezone(timezone="Asia/Shanghai")
```

## Installation

Install using pip:

```bash
pip install dc-adb-tools
qedma-api 0.21.0
Qedma QESEM SDK
Requires Python: <3.14,>=3.10

# QEDMA API Client

Qedma’s mission is to significantly accelerate the timeline towards quantum advantage by providing QESEM (Quantum Error Suppression and Error Mitigation): a robust, cutting-edge, cross-platform Quantum error reduction software solution.

## Overview

The QEDMA API client provides a Python interface to interact with QEDMA's quantum computing services. This client allows you to create and manage jobs, monitor their status, and retrieve results.

## Features

- **Error Mitigation**: Built-in error mitigation
- **Real-time Monitoring**: Track job status and execution progress

## Installation

```bash
pip install qedma-api
```

## Documentation
A full documentation of the API can be found [here](https://docs.qedma.io/).
bsit-bob 0.1.3
BACnet Semantic Interoperability Toolkit - Bob - Building Model Builder
Requires Python: >=3.13

# SI-Builder

[![Python package](https://github.com/ChristianTremblay/bsit-bob/actions/workflows/python-package.yml/badge.svg)](https://github.com/ChristianTremblay/bsit-bob/actions/workflows/python-package.yml)

Build ASHRAE 223P–compliant models using YAML and Python. si-builder emits RDF (Turtle) and aligns key concepts with RealEstateCore.

Install

```bash
% mkdir my-building
% cd my-building
% uv init --python 3.13
Initialized project `my-building`
% uv add bsit-bob
# or uv pip install ".[tests,validation,templates,doc]", choose what you need
Using CPython 3.13.1
Creating virtual environment at: .venv
```

Verify import
```python
# ipython
import bob  # si-builder package
```

Environment
- Install python-dotenv (recommended). si-builder automatically loads a .env at the project root if present.
- See doc/environment.md for available variables and effects.

Run tests
- Windows (PowerShell)
```powershell
cd d:\0Programmes\Ashrae\si-builder
pytest .\tests\
```
- Linux (bash)
```bash
cd /path/to/si-builder
pytest tests/
```

Build documentation (HTML)
This runs helpers, executes examples to generate TTL, renders SVG graphs, and builds Sphinx.

Prerequisites (one-time)
- Windows (PowerShell)
```powershell
python -m pip install -U sphinx myst-parser rdflib graphviz python-dotenv sphinxawesome-theme
choco install graphviz
```
- Linux (bash)
```bash
python3 -m pip install -U sphinx myst-parser rdflib graphviz python-dotenv sphinxawesome-theme
sudo apt-get update && sudo apt-get install -y graphviz  # Debian/Ubuntu
# Fedora:
sudo dnf install -y graphviz
# Arch:
sudo pacman -S graphviz
```

Build and open
- Windows (PowerShell)
```powershell
python .\tools\build_docs.py
Start-Process .\doc\_build\html\index.html
```
- Linux (bash)
```bash
python3 ./tools/build_docs.py
xdg-open ./doc/_build/html/index.html
```

Docs contents (from doc/index.md)
- Getting Started
- Environment
- Core
- Enumerations
- Basics
- Syntax Operators
- Syntax
- Connections
- Junctions and Boundaries
- Sensors and Observation
- Controllers and BACnet
- References
- Systems vs Equipment
- Equipment
- Spaces
- Properties
- External References
- Templates and Catalog
- Validation and Export
- Examples from Tests
- Operators Implementation