semvec/pypi-packages huggingface dataset:
napari-save-transformed 0.0.3
Napari plugin to save layers with their transforms applied.
Requires Python: >=3.9

# napari-save-transformed

[![PyPI - Version](https://img.shields.io/pypi/v/napari-save-transformed.svg)](https://pypi.org/project/napari-save-transformed)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/napari-save-transformed.svg)](https://pypi.org/project/napari-save-transformed)

-----

## Table of Contents

- [Installation](#installation)
- [License](#license)

## Installation

```console
pip install napari-save-transformed
```

## License

`napari-save-transformed` is distributed under the terms of the [BSD-3-Clause](https://spdx.org/licenses/BSD-3-Clause.html) license.
zxing-cpp 3.0.0
Python bindings for the zxing-cpp barcode library
Requires Python: >=3.9
Keywords: barcode

# Python bindings for zxing-cpp

[![PyPI](https://img.shields.io/pypi/v/zxing-cpp.svg)](https://pypi.org/project/zxing-cpp/)


## Installation

```bash
pip install zxing-cpp
```
or

```bash
python setup.py install
```

In case there is no pre-build wheel available for your platform or python version or if you use `setup.py` directly, a suitable [build environment](https://github.com/zxing-cpp/zxing-cpp#build-instructions) including a c++20 compiler is required. To build from source, you can call:

```bash
pip install zxing-cpp --no-binary zxing-cpp
```


## Usage

### Reading barcodes

```python
import cv2, zxingcpp

img = cv2.imread('test.png')
barcodes = zxingcpp.read_barcodes(img)
for barcode in barcodes:
	print('Found barcode:'
		f'\n Text:    "{barcode.text}"'
		f'\n Format:   {barcode.format}'
		f'\n Content:  {barcode.content_type}'
		f'\n Position: {barcode.position}')
if len(barcodes) == 0:
	print("Could not find any barcode.")
```

### Writing barcodes

```python
import zxingcpp
from PIL import Image

barcode = zxingcpp.create_barcode('This is a test', zxingcpp.BarcodeFormat.QRCode, ec_level = "50%")

img = barcode.to_image(scale = 5)
Image.fromarray(img).save("test.png")

svg = barcode.to_svg(add_quiet_zones = False)
with open("test.svg", "w") as svg_file:
	svg_file.write(svg)
```

To get a full list of available parameters for `read_barcodes` and `create_barcode` as well as the properties of the Barcode objects, have a look at the `PYBIND11_MODULE` definition in [this c++ source file](https://github.com/zxing-cpp/zxing-cpp/blob/master/wrappers/python/zxing.cpp).
valohai-llm 0.1.0
Track LLM evaluations to Valohai LLM
Requires Python: >=3.9
Keywords: ai, evaluation, llm, machine-learning, valohai

# valohai-llm

[vh]: https://valohai.com/
[vh-llm]: https://llm.valohai.com/

Python instrumentation library for [Valohai][vh] large language model and generative AI tools.

## Installation

```shell
pip install valohai-llm

# `uv` project with pip-compatibility
uv pip install valohai-llm

# `uv`-managed project
uv add valohai-llm
```

## Usage

1. Get `VALOHAI_LLM_API_KEY` from [Valohai LLM][vh-llm]
2. Make sure `VALOHAI_LLM_API_KEY` is set in your environment
3. Use the library e.g. the simplest case:

```python
import valohai_llm

def main():
    result = valohai_llm.post_result(
        task="my-evaluation",
        labels={"model": "gpt-4", "dataset": "mmlu", "category": "math"},
        metrics={"accuracy": 0.85, "latency_ms": 150},
    )
    print("Result posted:", result)

if __name__ == "__main__":
    main()
```

## Development

```shell
# auto-format and lint code
just format

# run unit tests
uv run pytest

# configure setup to run examples
cp .env.dev-example .env
# edit the .env
uv run --env-file=.env --with-editable=. examples/simple_example.py
```
odp-sdk 0.28.9
ODP Python SDK
Requires Python: <4,>=3.9.5

<a href="https://www.oceandata.earth/">
    <img src="assets/ODP-SDK.png" alt="ODP SDK logo" title="ODP" align="right" height="100" />
</a>


# ODP Python SDK

Connect to the Ocean Data Platform with Python through the Python SDK. Download queried ocean data easily and efficiently into data frames, for easy exploring and further processing in your data science project.

## Documentation

[https://docs.hubocean.earth/sdk/](https://docs.hubocean.earth/sdk/)

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install the Ocean Data Platform Python SDK.

```bash
pip3 install odp_sdk
```
 
## Usage

*Note: Accessing the Ocean Data Platform requires an authorized account. Contact ODP to require one.*

```python
from odp.client import OdpClient

client = OdpClient()

for item in client.catalog.list():
    print(item)
```

Examples can be found in /examples. 


## Testing in Python Notebook
1. Build the Package Locally
```
cd python_sdk
poetry build
```

2. Create a python notebook and test the package
- Building a python vitual environment locally will help you avoid conflicts with other versions of this package.

3. Install the Package Locally from the dist folder
```
pip install dist/<your-package-name>-<version>-py3-none-any.whl
```

To install in editable mode:
```
pip install -e dist/<your-package-name>-<version>-py3-none-any.whl
```

4. Test the new functionalities pointing to PR, Dev or Prod

5. Uninstall the package
```
pip uninstall -y dist/<your-package-name>-<version>-py3-none-any.whl
```
societal-costs-pipeline-2026-02-10-1300 0.1.0
Societal costs pipeline CLI.
Requires Python: >=3.9

# societal_costs

Workspace for the societal costs study.

## Crates

- `crates/costs_core` — core domain types, aggregation, pricing, and validation.
- `crates/costs_models` — two-part, Tweedie, and log-normal models + selection tools.
- `crates/costs_matching` — matching + balance diagnostics.
- `crates/costs_cohort` — cohort assignment + diagnostics.
- `crates/costs_components` — register-derived component builders (LMDB volume so far).
- `crates/costs_population` — population files + public stats QC.
- `crates/costs_pipeline_common` — config, errors, tracing, and shared helpers.
- `crates/costs_pipeline_io` — report/Arrow/CSV/JSON writers.
- `crates/costs_registers` — register ingestion flows (BEF/LPR/LMDB/VNDS/DOD/etc).
- `crates/costs_pipeline_core` — orchestration + analysis/matching/modeling logic.
- `crates/costs_pipeline` — thin facade that re-exports common/core/io APIs.

## LMDB example

See `crates/costs_pipeline/README.md` for the LMDB ingestion example.

## Pipeline config

Start from `pipeline.example.toml` and update the register file paths to match
your local dataset layout. Most SAS7BDAT paths accept either a single file
or a directory (all `.sas7bdat` files are loaded, sorted by name). You can
also set `base_path` in the config to prefix all relative register paths.
File filtering uses `study.data_*` and optional `study.baseline_*` /
`study.followup_*` windows to avoid reading out-of-scope files.
Event registers (VNDS/DOD/DODSAARS/DODSAASG) are **not** year-filtered.
If you use contact-based SCD classification, set
`components.lpr.scd_inpatient_contact_types` (or flip
`components.lpr.scd_allow_outpatient = true` to allow outpatient contacts).

Pipeline outputs include consolidated QC under `qc_summary.csv/json`, plus
step-specific outputs such as `lpr_episode_qc.csv`, `matching_outcome_qc.csv`,
`matching_parent_qc.csv`, and `population_public_stats.csv`.

For terminal progress and timing, set:
- `pipeline.progress = true`
- `pipeline.log_level = "info"` (or `debug`)

## Additional docs

- `docs/README.md` — onboarding index and quick-start path.
- `crates/costs_core/README.md` — core domain and aggregation usage.
- `crates/costs_models/README.md` — model APIs and examples.
- `crates/costs_models/examples/README.md` — runnable model examples.
- `crates/costs_components/README.md` — LMDB note (missing price fields).
- `crates/costs_pipeline/README.md` — pipeline usage and LMDB example.
- `docs/notes/pipeline_contracts.md` — step-level inputs, outputs, invariants.
k7sfunc 1.3.1
VapourSynth video processing functions optimized for media players
Requires Python: >=3.10
Keywords: vapoursynth, video, processing, superresolution, interpolation

# K7sfunc

个人 VapourSynth 常用功能合集

[![Python Version](https://img.shields.io/pypi/pyversions/k7sfunc)](https://pypi.org/project/k7sfunc/)
[![License](https://img.shields.io/badge/license-GPL--3.0-blue.svg)](LICENSE)

## 简介

K7sfunc 是一个为mpv实时播放优化的 VapourSynth 视频处理函数库，提供多种视频增强功能。

## 安装

### 基础安装

```bash
pip install k7sfunc
```

### 安装可选依赖

```bash
# 安装 AI 推理支持
pip install k7sfunc[ai]
```

## 使用示例

编写一个 vpy 脚本以供mpv的 `vf=vapoursynth` 接口调用：

```python
import vapoursynth as vs
from vapoursynth import core
import k7sfunc as k7f

# 链接mpv当前的视频轨
clip = video_in

# 使用DirectML后端加载超分模型并应用
clip = k7f.UAI_DML(input=clip, model_pth="test.onnx")

clip.set_output()
```

## 许可证

GPLv3 License

## 链接

- 与 mpv-lazy 发行同步的版本文档： https://github.com/hooke007/mpv_PlayKit/wiki/3_K7sfunc
- 即时版本的文档： https://github.com/hooke007/K7sfunc/tree/main/doc
- 提问与反馈： https://github.com/hooke007/mpv_PlayKit/discussions
laneswarm 0.1.5
Multi-agent autonomous coding system powered by Flanes version control
Requires Python: >=3.12

# Laneswarm

Multi-agent autonomous coding system powered by [Flanes](https://pypi.org/project/flanes/) version control.

## Install

```bash
pip install laneswarm
```

## Quick Start

```bash
# Plan a project
laneswarm plan "Build a todo app with authentication"

# Execute the tasks
laneswarm run

# Check status
laneswarm status
```

## Dashboard

Laneswarm includes a real-time web dashboard that streams agent activity as tasks execute.

```bash
# Run tasks with the dashboard
laneswarm run --dashboard

# Or launch the dashboard standalone (view current task graph)
laneswarm serve

# Dashboard + execution together
laneswarm serve --run
```

Opens at `http://localhost:8420` by default. Use `--port` to change.

**What you see:**
- **Task grid** — live cards for each task with status, current phase, and iteration count
- **Activity feed** — streaming event log from all agents, color-coded and filterable
- **Orchestrator panel** — worker utilization, dependency graph, overall progress
- **Task detail** — click any task to see agent steps timeline, files written, verification results, and review feedback

The dashboard connects via WebSocket and auto-reconnects if the connection drops.

## Configuration

Copy `.laneswarm.toml.example` to `.laneswarm.toml` and configure your LLM providers.
waykit 0.2.0
generate location metatata like peaks, huts for a given gpx file
Requires Python: >=3.13

waykit
======

waykit is a python tool to generate location metatata like peaks, huts and
other pois for a given gpx file

## Usage

You can run the tool directly from github with [uvx](https://docs.astral.sh/uv/guides/tools/#requesting-different-sources)

```
uvx git+https://github.com/hoffmann/waykit -o output.geojson input.gpx
```

To install and run the package from [pypi](https://pypi.org/project/waykit/):

```
# use your preferred tool to create a virtual environment
pip install waykit
waykit -o output.geojson input.gpx 
``` 

You can also clone the repository and run it locally

```
uv run waykit -o output.geojson input.gpx 
```


## Providers

waykit ships with two data providers that can be selected via the
`--provider` flag.

### openstreetmap (default)

Queries the [Overpass API](https://overpass-api.de/) at runtime to fetch
peaks and alpine huts within a bounding box around the GPX track. This
always returns up-to-date data but requires an internet connection and is
subject to Overpass rate limits.

```
waykit -o output.geojson input.gpx
waykit --provider openstreetmap -o output.geojson input.gpx
```

### cached

Uses a bundled, gzipped JSONL export of OpenStreetMap data. The data is
loaded into a square-grid spatial index on first use, so lookups are fast
and fully offline. This is useful for repeatable results, CI pipelines, or
environments without network access.

```
waykit --provider cached -o output.geojson input.gpx
```

The cached dataset currently covers alpine huts in the Alps. It will be
expanded over time to include peaks and other POI types.


## Spatial indexing

waykit includes a custom square-grid spatial index rather than using an
established system like H3, S2, or Geohash. This is intentional.

The grid index is a simple equirectangular projection divided into
fixed-size meter cells. The entire implementation is pure Python with no
external dependencies, making it straightforward to understand, debug, and
extend.

A key goal is cross-language portability. The same algorithm and cell ID
encoding can be reimplemented in JavaScript (or any other language) without
pulling in a native binding or a large library. This keeps both the Python
package and a future browser/Node.js version lightweight and
dependency-free.


![](docs/waykit.png)

For the scale waykit operates at (regional hiking areas like the Alps), the
equirectangular approximation is more than accurate enough. A full
spherical grid system would add complexity without meaningful benefit.

## Run the tests

If you have just installed you can use the following

```
just test
```

otherwise check the command in the `justfile` to run the pytests