semvec/pypi-packages huggingface dataset:
rero-invenio-files 1.2.0
Files support for the RERO invenio instances.
Requires Python: <3.13,>=3.9.2

<!-- RERO-Invenio-Files
Copyright (C) 2024 RERO.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, version 3 of the License.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.

You should have received a copy of the GNU Affero General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>. -->

<!-- PROJECT SHIELDS -->
[![Github actions
status](https://github.com/rero/rero-invenio-files/actions/workflows/continuous-integration-test.yml/badge.svg)](https://github.com/rero/rero-invenio-files/actions/workflows/continuous-integration-test.yml)
[![Release
Number](https://img.shields.io/github/tag/rero/rero-invenio-files.svg)](https://github.com/rero/rero-invenio-files/releases/latest)
[![Downloads](https://img.shields.io/pypi/dm/rero-invenio-files.svg)](https://pypi.python.org/pypi/rero-invenio-files)
[![License](https://img.shields.io/badge/License-AGPL%20v3-blue.svg)](http://www.gnu.org/licenses/agpl-3.0.html)
[![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)

Files support for the RERO invenio instances.
librds 2.1
RDS Group Generator
Keywords: radiodatasystem, rds, broadcast_fm

# LibRDS

LibRDS is a simple library that you can use to generate and decode the RDS groups, just the groups, so something like `3000 2000 7575 7575` the origins of development of this started on 12 May, later creating the [rdPy](https://github.com/KubaPro010/rdPy) repository

RBDS compatibility is not guranteed.

Example code:

```python
import librds

basic = librds.GroupGenerator.basic(0x3000)
print(basic)

ps = librds.GroupGenerator.ps(basic,"hi",0)
print(ps)

print(librds.GroupDecoder.decode(ps))
```

Output:

```python
    Group(a=12288, b=0, c=0, d=0, is_version_b=False)
    Group(a=12288, b=0, c=57549, d=26729, is_version_b=False)
    DecodedGroup(raw_group=Group(a=12288, b=0, c=57549, d=26729, is_version_b=False), pi=12288, tp=False, pty=0, group=GroupIdentifier(group_number=0, group_version=False), details=PSDetails(segment=0, di_dpty=False, ta=False, text='hi', af=AlternativeFrequencyEntryDecoded(is_af=False, af_freq=0, af_freq1=0, lfmf_follows=False, all_af_lenght=0)))
```

**Note** that LibRDS required Python 3.10+ to run due to its use of `match`

## Decoder

LibRDS also includes a RDS Group decoder, so you can encode with librds and then also decode it, currently librds's decoder decodes all of the groups it can encode

## How to install it?

either clone this and do `pip install .` or be simple and do `pip install librds`
eksma-optics-motorized-devices 0.1.3
EKSMA Optics Motorized Devices
Requires Python: >=3.8

# EKSMA Optics Motorized Devices

[![PyPI - Version](https://img.shields.io/pypi/v/eksma-optics-motorized-devices.svg)](https://pypi.org/project/eksma-optics-motorized-devices)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/eksma-optics-motorized-devices.svg)](https://pypi.org/project/eksma-optics-motorized-devices)

A library for controlling EKSMA Optics motorized devices.

## Getting Started

### Installation

```shell
pip install eksma-optics-motorized-devices[standard]
```

### Usage

```python
from eksma_optics_motorized_devices.control import Control
from eksma_optics_motorized_devices.transport import SerialTransport

# Initialize the serial transport with the appropriate serial port
transport = SerialTransport(port="/dev/ttyUSB0")  # Replace with your actual port

# Create a Control instance using the transport
device = Control(transport)

# Query the device identification
try:
    identification = device.get_identification()
    print("Device Identification:", identification)
except Exception as e:
    print("Failed to get identification:", e)
```

## License

MIT
avian-lwma 0.1.0
LWMA target calculator for dual-algo Avian forks (pybind11)
Requires Python: >=3.12

# avian_lwma

High-performance LWMA (Zawy v3) target calculator for dual-algo Avian forks (X16RT + MinotaurX).

- No Boost/OpenSSL: ships a tiny 256-bit integer core (GCC/Clang required for __uint128_t).
- pybind11: import from Python and call at header-sync/checkpoint time.
- Per-algo windows: pass the last N headers of a given algo.
- Optional WASM FFI: compile the same core to .wasm if you want a web/Node verifier (not included in this zip).

## Quick start (build wheel)

```bash
pip install -U pip build
pip install pybind11 scikit-build-core
pip install .
```

> Windows: build with MSYS2/MinGW or Clang, or use WSL. (MSVC lacks __uint128_t; a MSVC-safe Big256 can be added.)

## CMake build

```bash
cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build -j
```

## Python usage

```python
from avian_lwma import HeaderLite, next_bits_window, filter_last_n_for_algo

N = 45           # LWMA window
T = 30           # target spacing (seconds)
POW_LIMITS = {
    0: "00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",  # X16RT
    1: "000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",  # MinotaurX
}

def algo_from_version(ver: int) -> int:
    return 1 if (ver & (1<<28)) else 0  # example mapping

# chain: list[HeaderLite] oldest->newest (fill from your header DB)
window = filter_last_n_for_algo(chain, N, algo_from_version, algo_id=1)
expected_bits = next_bits_window(window, T, len(window), POW_LIMITS[1])
```

### API
- HeaderLite(time: uint32, version: uint32, bits: uint32)
- next_bits_window(window, target_spacing_s, N, pow_limit_hex) -> int (compact bits)
- filter_last_n_for_algo(chain, N, algo_from_version, algo_id) -> list[HeaderLite]

### Notes
- Targets are full 256-bit integers decoded from compact bits. The result is clamped to pow_limit before re-encoding.
- The Big256 here uses __uint128_t for intermediate math. For MSVC, swap in a different Big256 (PRs welcome).