semvec/pypi-packages huggingface dataset:
hik-isapi-audio 0.1.0
A asynchronous Python client for Hikvision ISAPI with enhanced support for two-way audio and stream data.
Requires Python: >=3.11


# hik_isapi_audio

`hik_isapi_audio` 是一个轻量级、高性能的 Python 异步客户端，专门用于与海康威视（Hikvision）摄像头进行 **ISAPI** 协议交互。

与市面上现有的库不同，本项目除了支持基础的云台操作外，**核心亮点在于对音频数据（Audio Data）的封装**，支持实时语音对讲、广播以及音频流的获取。

## ✨ 核心特性

* **语音对讲 (Audio Two-way):** 支持基于 `System/TwoWayAudio` 的音频流处理。
* **云台控制 (Access Control):** 轻松实现摄像头的旋转\倾斜操作。
* **简单易用:** 基于 `aiohttp` 的封装，自动处理 Digest 摘要认证。
* **流式传输:** 支持处理海康私有的音频打包格式，方便接入 AI 语音识别或播放器。

## 安装

### use pip
```shell
pip install hik_isapi_audio
pip install 'hik_isapi_audio[mic]'  # 可选依赖: 支持麦克风
```

### use uv
```shell
uv add hik_isapi_audio
uv add hik_isapi_audio --extra mic  # 可选依赖: 支持麦克风
```

## 🚀 快速开始

```python
import asyncio
from hik_isapi_audio import HikCameraControl

cam = HikCameraControl("192.168.1.64", "admin", "password")

# 1. 播放g711a格式音频文件
asyncio.run(cam.play_audio("tests/data/test.g711a"))

# 2. 云台移动
asyncio.run(cam.ptz_move(pan=50, duration=2))
asyncio.run(cam.ptz_move(pan=0, tilt=-10, duration=2))


# 3. 麦克风实时录制播放
async def test_mic_capture_task(cam):

    from hik_isapi_audio.mic import mic_capture_task, mic_data_generator

    queue = asyncio.Queue(maxsize=15)
    token = await cam.get_token_for_audio_data()
    await cam.voice_open()
    try:
        async with asyncio.TaskGroup() as tg:
            tg.create_task(mic_capture_task(queue))
            tg.create_task(cam.socket_send_task(mic_data_generator(queue), token))
    finally:
        await cam.voice_close()

asyncio.run(test_mic_capture_task(cam))
```
road24-sdk 0.1.4
Shared logging and metrics library for Road24 FastAPI microservices
Requires Python: >=3.12

# road24-sdk

Shared logging and metrics SDK for Road24 microservices. Provides structured JSON logging, Prometheus metrics, and framework-specific integrations following a Sentry SDK-like pattern.

## Installation

```bash
# Core library
pip install road24-sdk

# With all integrations
pip install road24-sdk[all]

# Development (includes test tools)
pip install road24-sdk[dev]
```

## Quick Start

```python
import road24_sdk
from fastapi import FastAPI
from httpx import AsyncClient, Timeout
from road24_sdk.integrations.fastapi import FastApiLoggingIntegration
from road24_sdk.integrations.httpx import HttpxLoggingIntegration
from road24_sdk.integrations.redis import RedisLoggingIntegration
from road24_sdk.integrations.sqlalchemy import SqlalchemyLoggingIntegration

def setup_road24_sdk():
    road24_sdk.init(
        service_name="my-service",
        log_level="INFO",
        integrations=[
            HttpxLoggingIntegration(),
            SqlalchemyLoggingIntegration(),
            RedisLoggingIntegration(),
        ],
    )

# FastAPI requires .setup(app) since it needs the app instance
app = FastAPI()
setup_road24_sdk()
FastApiLoggingIntegration().setup(app)
```

## Available Integrations

| Integration | Extra | Description |
|---|---|---|
| `FastApiLoggingIntegration` | `fastapi` | Inbound HTTP request/response logging and metrics |
| `HttpxLoggingIntegration` | `httpx` | Outbound HTTP request/response logging and metrics |
| `SqlalchemyLoggingIntegration` | `sqlalchemy` | Database query logging and metrics |
| `RedisLoggingIntegration` | `redis` | Redis command logging and metrics |

## Manual Testing

Standalone scripts to inspect structured JSON logs and metrics (no server needed):

```bash
make test-logs-http-input    # Inbound HTTP request log
make test-logs-http-output   # Outbound HTTPX request log
make test-metrics-http       # Prometheus metrics after HTTP calls
make test-logs-redis         # Redis command logs (SET, GET, HSET, etc.)
make test-logs-db            # DB query logs (SELECT, INSERT, UPDATE, DELETE)
```

## Development

```bash
make install    # Install all dependencies (requires uv)
make test       # Run tests with coverage
make lint       # Lint with ruff
make format     # Format with ruff
make check      # Lint + test
```
eaopack 3.0.13
A Framework for Optimizing Decentralized Portfolios
Requires Python: >=3.10

![Test Success](https://github.com/RIVACON/EAO/blob/gh-pages/badges/tests-badge.svg)
![Notebooks](https://github.com/RIVACON/EAO/blob/gh-pages/badges/notebook-badge.svg)
![Test Coverage](https://github.com/RIVACON/EAO/blob/gh-pages/badges/coverage-badge.svg)
[![documentation](https://img.shields.io/badge/-documentation-blue.svg)](https://rivacon.github.io/EAO/)
[![RIVACON](https://img.shields.io/badge/powered%20by-RIVACON-lightgrey.svg)](https://www.rivacon.com/en/)

# The Energy Asset Optimization (EAO) package

The EAO package is a modular Python framework, designed to enable practitioners to use, build and optimize energy and commodity trading portfolios using linear or mixed integer programming as well as stochastic linear programming. It provides an implementation of
- standard assets such as contracts, transport and storages
- addition of new asset types
- their combination to complex portfolios using network structures
- (de-) serialization to JSON
- basic input & output functionality

We found that the approach is useful for modeling very different problem settings, such as decentral and renewable power generation, green power supply and PPAs and sector coupling in ad-hoc analysis, market modeling or daily operation.

Further information:
 - documentation along with several sample notebooks: [`EAO documentation`](https://RIVACON.github.io/EAO) 
 - extensive technical report: [`Report`](doc/source/EnergyAssetOptimization_White_Paper.pdf)

Please feel free to contact us if you have questions or if you are interested in using EAO: [`Contact`](https://rivacon.com/kontakt/)

To install: pip install eaopack

----------------------------------------------------------------------
[`Impressum`](https://rivacon.com/impressum/)
tina4-python 0.2.170
Tina4Python - This is not another framework for Python
Requires Python: <4.0,>=3.12

# Tina4 Python — This is not a framework

Laravel joy. Python speed. 10× less code.

## Quickstart
```bash
pip install tina4_python
tina4 init my_project
cd my_project
python app.py
```

You've just built your first Tina4 app — zero configuration, zero classes, zero boilerplate!

## Features

- Full ASGI compliance, use any ASGI compliant webserver
- Full async support out of the box
- Built-in JWT and Session handling
- Automatic Swagger docs at `/swagger`
- Instant CRUD interfaces with one line: `result.to_crud(request)`
- Built-in Twig templating, migrations, WebSockets, authentication and middleware
- Works with SQLite, PostgreSQL, MySQL, MariaDB, MSSQL, Firebird
- Hot reload in development (`uv run python -m jurigged app.py`)

## Install

```bash
pip install tina4-python
```

## Routing

Here are some basic GET routes

```python
# .src/__init__.py
from tina4_python import get

# simple get route
@get("/hello")
async def get_hello(request, response):
    return response("Hello, Tina4 Python!")

# simple get route with inline params
@get("/hello/{world}")
async def get_hello_world(world, request, response):
    return response(f"Hello, {world} ")

# simple route responding with json
@get("/hello/json")
async def get_hello_json(world, request, response):
    cars = [{"brand": "BMW"}, {"brand": "Toyota"}]

    return response(cars)

# respond with a file
@get("/hello/{filename}")
async def get_hello_file(filename, request, response):
   
    return response.file(filename, './src/public')

# respond with a redirection to another location
@get("/hello/redirect")
async def get_hello_redirect(request, response):
    
    return response.redirect("/hello/world")

@get("/hello/template")
async def get_hello_template(request, response):
    
    # renders any template in .src/templates
    return response.render("index.twig", {"data": request.params})

```

## Further Documentation

https://tina4.com/

## Community

- GitHub: https://github.com/tina4stack/tina4-python

## License

MIT © 2007 – 2025 Tina4 Stack  
https://opensource.org/licenses/MIT

## Testing 

uv run pytest --verbose

---

**Tina4** – The framework that keeps out of the way of your coding.
gwpy 4.0.1
A python package for gravitational-wave astrophysics
Requires Python: >=3.11
Keywords: gravitational waves, igwn, ligo, virgo

GWpy is a collaboration-driven Python package providing tools for
studying data from ground-based gravitational-wave detectors.

GWpy provides a user-friendly, intuitive interface to the common
time-domain and frequency-domain data produced by the LIGO and Virgo
observatories and their analyses, with easy-to-follow tutorials at each
step.

<https://gwpy.github.io>

# Release status

[![PyPI version](https://badge.fury.io/py/gwpy.svg)](http://badge.fury.io/py/gwpy)
[![Conda version](https://img.shields.io/conda/vn/conda-forge/gwpy.svg)](https://anaconda.org/conda-forge/gwpy/)

[![License](https://img.shields.io/pypi/l/gwpy.svg)](https://choosealicense.com/licenses/gpl-3.0/)
![Supported Python versions](https://img.shields.io/pypi/pyversions/gwpy.svg)
[![SPEC 0 — Minimum Supported Dependencies](https://img.shields.io/badge/SPEC-0-green?labelColor=%23004811&color=%235CA038)](https://scientific-python.org/specs/spec-0000/)

# Development status

[![Build status](https://gitlab.com/gwpy/gwpy/badges/main/pipeline.svg)](https://gitlab.com/gwpy/gwpy/-/pipelines/?ref=main)
[![Coverage status](https://gitlab.com/gwpy/gwpy/badges/main/coverage.svg)](https://gitlab.com/gwpy/gwpy/-/pipelines/?ref=main)

# Installation

To install, you can do:

```
conda install -c conda-forge gwpy
```

or

```
python -m pip install gwpy
```

You can test your installation, and its version by

```
python -c "import gwpy; print(gwpy.__version__)"
```

# License

GWpy is released under the GNU General Public License v3.0 or later, see
[here](https://choosealicense.com/licenses/gpl-3.0/) for a description of
this license, or see the
[LICENSE](https://gitlab.com/gwpy/gwpy/-/blob/main/LICENSE) file for the
full text.