semvec/pypi-packages huggingface dataset:
er_episim 0.0.1
A stub for the EntityRisk PROVEN Platform
Requires Python: <4.0,>=3.9

This is a public stub of a proprietary EntityRisk package uploaded to protect
users of the EntityRisk PROVEN Platform from
[dependency confusion](https://medium.com/@alex.birsan/dependency-confusion-4a5d60fec610).

This package is non-functional and users accidentally installing it will
receive an error message when trying to import it.
fable-library 4.29.0
Fable library for Python
Requires Python: <4.0,>=3.10

# Fable Library for Python

This module is used as the [Fable](https://fable.io/) library for Python.

This document outlines the distribution strategy for the Fable Python
target, which includes both Python code and Rust-based extensions for
features like unsigned integers that aren't natively supported in
Python.

The code should be annotated using [type
hints](https://docs.python.org/3/library/typing.html) and statically
type checked using
[pylance](https://marketplace.visualstudio.com/items?itemName=ms-python.vscode-pylance)
at `strict` setting.

The code should be formatted using the
[ruff](https://docs.astral.sh/ruff/) formatter with default settings.

## Fable Python Target Distribution Design

### Design Goals

- Provide proper type support for F# (including uint8, etc.) and
  performance using Rust extensions
- Support cross-platform usage of libraries compiled with Fable
- Offer flexibility for library authors (bundled vs PyPI dependency)
- Minimize duplication while ensuring stability

### Architecture

The system uses a two-tier architecture:

1. **Python components** - The main Fable library functionality
2. **Rust extensions** - Native code for performance and proper type support

### Distribution Approach

The `fable-library` package will be available through two methods:

1. **Bundled** - Generated and included directly with compiled F# code
2. **PyPI** - Installable as a dependency with wheels for all major platforms

Library authors can choose which approach to use based on their distribution needs. Note
that libraries made for distribution must use the PyPI approach since the bundled
version will only work locally (single architecture).

### Version Management

#### Major Versions

- Versions are aligned with main Fable releases and a new release will
  be generated for every tagged release
- Older versions for compatibility remain available through version pinning

### Implementation Notes

1. All Rust extensions are compiled for multiple platforms during the PyPI package build
enpipe 0.0.2b1
Chaining functions execution made easy
Requires Python: >=3.9

# enpipe: Chaining functions execution made easy

```
from enpipe import make_pipeline
from math import sqrt

def operation(n1: float, n2: float) -> float:
    return n1 + n2

pipeline = make_pipeline(
    operation,
    lambda n: n**0.5
)

assert pipeline(1, 2) == sqrt(3)
```
ndscope 0.20.7
Next-generation NDS time series plotting
Requires Python: >=3.9

# Next-generation NDS oscilloscope

`ndscope` is a tool for viewing time series data from the LIGO Network
Data Services (NDS).  Based on
[dttlib](https://https://git.ligo.org/cds/software/cr_tools/dttlib) and the
high-performance [pyqtgraph](http://pyqtgraph.org/) plotting library,
`ndscope` is a able to plot both online and offline data for many
channels simultaneously with intuitive mouse pan/zoom support.

![ndscope](ndscope.png)

### Features:

* online mode for raw and trend data
* mouse pan and zoom, with background auto-fetch of new data
* automatic transition to second/minute trend data at appropriate zoom levels
* triggering, for true oscilloscope behavior
* cursors and crosshair in both time and Y axes
* save layout templates in easy-to-use YAML format
* load templates from various legacy formats, including StripTool .stp, dataviewer .xml, and .txt
* enhanced "StripTool mode" with auto-backfill of past data
* Arrakis and NDS protocol support
* channel selection GUI

Left mouse click+drag for pan, and right mouse click+drag for zoom
(left/right for in/out in time, and up/down for in/out in Y).
Click+drag on axis to retrict pan/zoom to only that dimension.

## Issues

Please report issues to the [gitlab issue tracker](https://git.ligo.org/cds/ndscope/issues).

## Requirements

Package requirements for `ndscope` (Debian package names):

* [python3-pyqtgraph](http://pyqtgraph.org/)
* [dttlib](https://https://git.ligo.org/cds/software/cr_tools/dttlib)
* nds2-client (but see [NDS2 dependency](#nds2-dependency))
* python3-qtpy
* [python3-gpstime](https://git.ligo.org/cds/gpstime)
* python3-dateutil
* python3-yaml
* python3-cairosvg
* python3-h5py

The following packages are used for development purposes:

* pyqt5-dev-tools
* qt5-designer
* python3-setuptools_scm
* pytest3-pytest

Pre-built binary packages are available via
[pip](https://pypi.org/project/ndscope) and
[conda](https://anaconda.org/conda-forge/ndscope) and for the various
[IGWN supported operating
systems](https://computing.docs.ligo.org/guide/software/installation/).

### NDS2 dependency
ndscope does not directly depend on NDS2 client, but all published version of dttlib do
depend on NDS2 client.

It is possible to make a custom build of dttlib that does not depend
on NDS2 client.  ndscope would then be arrakis-only, and could not connect to NDS servers.
iii-motia 1.0.0rc5
Motia framework for III Engine
Requires Python: >=3.10

# Motia Framework for Python

High-level framework for building workflows with the III Engine.

## Installation

```bash
uv pip install iii-motia
```

## Usage

### Defining a Step

```python
from motia import FlowContext, event

config = {
    "name": "process-data",
    "triggers": [event("data.created")],
    "emits": ["data.processed"],
}

async def handler(data: dict, ctx: FlowContext) -> None:
    ctx.logger.info("Processing data", data)
    await ctx.emit({"topic": "data.processed", "data": data})
```

### API Steps

```python
from motia import ApiRequest, ApiResponse, FlowContext, api

config = {
    "name": "create-item",
    "triggers": [api("POST", "/items")],
    "emits": ["item.created"],
}

async def handler(req: ApiRequest, ctx: FlowContext) -> ApiResponse:
    ctx.logger.info("Creating item", req.body)
    await ctx.emit({"topic": "item.created", "data": req.body})
    return ApiResponse(status=201, body={"id": "123"})
```

### Streams

```python
from motia import Stream

# Define a stream
todo_stream = Stream[dict]("todos")

# Use the stream
item = await todo_stream.get("group-1", "item-1")
await todo_stream.set("group-1", "item-1", {"title": "Buy milk"})
await todo_stream.delete("group-1", "item-1")
items = await todo_stream.get_group("group-1")
```


### Build & Publish
```bash
python -m build
uv publish --index cloudsmith dist/*
```


## Features

- Event-driven step definitions
- API route handlers
- Cron job support
- Stream-based state management
- Type-safe context with logging

## Testing

### Running Integration Tests

Integration tests require a running III Engine instance. Make sure to have it built or installed before running tests.

1. Install dev dependencies:
   ```bash
   cd motia && uv sync --all-extras

   ```

   ```
3. Run tests:
   ```bash
   uv run pytest
   ```

### Test Configuration

Tests use non-default ports to avoid conflicts:
- Engine WebSocket: `ws://localhost:49199`
- HTTP API: `http://localhost:3199`

Set `III_ENGINE_PATH` environment variable to point to the III engine binary.

### Test Coverage

The integration test suite covers:
- Bridge connection and function registration
- API triggers (HTTP endpoints)
- KV Server operations
- PubSub messaging
- Logging module
- Motia framework integration
- Stream operations (when available)
- State management (when available)
argus-cv 1.5.5
CLI tool for working with vision AI datasets
Requires Python: >=3.10

# argus-cv

Vision AI dataset toolkit for working with YOLO, COCO, and semantic mask datasets.

**[Documentation](https://pirnerjonas.github.io/argus/)**

Library users can start with the Python API reference:

- https://pirnerjonas.github.io/argus/reference/python-api/

## Installation

```bash
uvx argus-cv
```

## Highlights

- Detects YOLO, COCO, and folder-based semantic mask datasets.
- Reports per-class stats (pixel coverage for mask datasets).
- Interactive viewer with bounding boxes, polygons, or mask overlays.
- Split unsplit YOLO/COCO datasets into train/val/test.

## Usage

```bash
# List datasets in current directory
uvx argus-cv list

# List datasets in specific path
uvx argus-cv list --path /path/to/datasets

# Limit search depth
uvx argus-cv list --path . --max-depth 2

# Show instance statistics for a dataset
uvx argus-cv stats --dataset-path /path/to/dataset

# Short form
uvx argus-cv stats -d /path/to/dataset

# View annotations interactively
uvx argus-cv view -d /path/to/dataset --split val

# Split an unsplit dataset into train/val/test
uvx argus-cv split -d /path/to/dataset -o /path/to/output -r 0.8,0.1,0.1
```
jsonschema-to-marshmallow 0.1.1
Get Marshmallow class from JSON Schema
Requires Python: >=3.10
Keywords: jsonschema, marshmallow

# JsonSchema to Marshmallow
jsonschema-to-marshmallow translates JSON Schema to Marshmallow class.

### Simple Example
```python
from jsonschema_marshmallow import MarshmallowJsonSchema

json_schema = {
  "type": "object",
  "properties": {
    "price": {
      "type": "number"
    },
    "name": {
      "type": "string"
    }
  }
}
Schema = MarshmallowJsonSchema(json_schema).load()

Schema().dump({'name': 'john'})
```
pypentair 0.4.1
Python package for interacting with Pentair Home devices over the cloud
Requires Python: >=3.10
Keywords: Pentair, Pentair Home, python, salt level sensor

# pypentair

[![PyPI - Version](https://img.shields.io/pypi/v/pypentair?style=for-the-badge)](https://pypi.org/project/pypentair/)
[![Buy Me A Coffee/Beer](https://img.shields.io/badge/Buy_Me_A_☕/🍺-F16061?style=for-the-badge&logo=ko-fi&logoColor=white&labelColor=grey)](https://ko-fi.com/natekspencer)
[![Sponsor on GitHub](https://img.shields.io/badge/Sponsor_💜-6f42c1?style=for-the-badge&logo=github&logoColor=white&labelColor=grey)](https://github.com/sponsors/natekspencer)

[![GitHub License](https://img.shields.io/github/license/natekspencer/pypentair?style=flat-square)](LICENSE)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pypentair?style=flat-square)](https://pypi.org/project/pypentair/)
![Pepy Total Downloads](https://img.shields.io/pepy/dt/pypentair?style=flat-square)
![PyPI - Downloads](https://img.shields.io/pypi/dm/pypentair?style=flat-square)

A Python package for interacting with Pentair Home devices over the cloud. Used in the [Pentair Home for Home Assistant](https://github.com/natekspencer/hacs-pentair) integration.

## ❤️ Support Me

I maintain this python project in my spare time. If you find it useful, consider supporting development:

- 💜 [Sponsor me on GitHub](https://github.com/sponsors/natekspencer)
- ☕ [Buy me a coffee / beer](https://ko-fi.com/natekspencer)
- 💸 [PayPal (direct support)](https://www.paypal.com/paypalme/natekspencer)
- ⭐ [Star this project](https://github.com/natekspencer/pypentair)
- 📦 If you’d like to support in other ways, such as donating hardware for testing, feel free to [reach out to me](https://github.com/natekspencer)

## 📈 Star History

[![Star History Chart](https://api.star-history.com/svg?repos=natekspencer/pypentair)](https://www.star-history.com/#natekspencer/pypentair)