semvec/pypi-packages huggingface dataset:
cv-ws-streamer 0.1.0
High-performance bridge connecting Python OpenCV to React using Binary WebSockets
Requires Python: >=3.8

# cv-ws-streamer

A high-performance Python library for streaming frames (OpenCV/NumPy) to a React client via Binary WebSockets.

## Features
- 🚀 **Binary Protocol**: Low overhead MJPEG streaming.
- **Two-way Communication**: Handle clicks and events from the frontend.
- **FastAPI Integration**: Easy to drop into existing FastAPI apps.

## Installation

```bash
pip install cv-ws-streamer
```

## Usage

```python
from fastapi import FastAPI, WebSocket
from cv_ws_streamer.core import Streamer
import cv2

app = FastAPI()
streamer = Streamer(jpeg_quality=70)

@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    await streamer.connect(websocket)

# In your video loop:
# await streamer.send_frame(frame)
```
sotodlib 0.6.16
Simons Observatory TOD Simulation and Processing
Requires Python: <3.14,>=3.10


# SO TOD Library

![!Build and Test](https://github.com/simonsobs/sotodlib/workflows/Build%20and%20Test/badge.svg)
[![Documentation Status](https://readthedocs.org/projects/sotodlib/badge/?version=latest)](https://sotodlib.readthedocs.io/en/latest/?badge=latest)
[![PyPI - Version](https://img.shields.io/pypi/v/sotodlib.svg)](https://pypi.org/project/sotodlib)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/sotodlib.svg)](https://pypi.org/project/sotodlib)

Tools for working with real and simulated time ordered data.

Full documentation here:

https://sotodlib.readthedocs.io/en/latest/
unrealzap 0.1.1
Unreal Tournament bug zapper
Requires Python: <4.0,>=3.12

# Unreal Zap

Based on an amazing idea to have the Unreal Tournament kill streak sounds play when the bug zapper goes off, this script makes that dream a reality.

It listens to microphone input and waits for a burst of sound over a certain volume threshold, then plays the appropriate Unreal Tournament kill streak sound based on number of kills so far that day.

It also supports multi-kills—if you get multiple zaps within 60 seconds, you'll be treated to "double kill" instead of "killing spree," and so on. If you get more zaps than there are sounds, you're treated to "Headshot!" for the rest of that day.

The script resets at midnight each day, and supports quiet hours to avoid going off overnight.

## Sounds

In addition to "Headshot," the following sounds are included:

### Kill Streak

1. First Blood
2. Killing Spree
3. Rampage
4. Dominating
5. Unstoppable
6. Godlike

### Multi-Kills

1. Double Kill
2. Multi-Kill
3. Ultra Kill
4. Monster Kill

## Setting Up a Raspberry Pi

This is simple to set up with a Raspberry Pi and a USB conference mic that works with Linux like [this one](https://www.amazon.com/dp/B0899S421T).

Make sure the Raspberry Pi is up-to-date:

```bash
sudo apt update
sudo apt upgrade
```

Install using pip:

```bash
pip install unrealzap
```

Create a `systemd` service to run the script on startup:

```bash
sudo nano /etc/systemd/system/unrealzap.service
```

Configure like so:

```bash
[Unit]
Description=Unreal Zap
After=network.target sound.target
Wants=sound.target

[Service]
ExecStart=/path/to/python -m unrealzap.bug_zapper:main
StandardOutput=journal
StandardError=journal
Restart=on-failure
RestartSec=5
User=danny
Group=audio
Environment=PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin  # May need adjustment
Environment=PYTHONUNBUFFERED=1
Environment=XDG_RUNTIME_DIR=/run/user/1000
Environment=ALSA_CARD=S3
TimeoutStopSec=10
Nice=-10

[Install]
WantedBy=multi-user.target
```

Enable and start the service, and check the status to confirm:

```bash
sudo systemctl enable --now unrealzap.service
sudo systemctl start unrealzap.service
sudo systemctl status unrealzap.service
```

M-M-M-M-MONSTER KILL!
aldsim 0.0.5
Simple models for atomic layer deposition
Keywords: atomic layer deposition, transport models, microelectronics, ALD, atomic scale processing, plasma, thin films

# aldsim

Simple models for thin film growth using atomic layer deposition


## Motivation

Atomic layer deposition is a thin film growth technique that
relies on self-limited surface kinetics. It plays a key role
in areas such as microelectronics, and it is applied for energy,
energy storage, catalysis, and decarbonization applications.

`aldsim` implements a series of models to help explore ALD in 
various contexts and reactor configurations.

It has grown from a collection of papers that we have published over
the past 10 years.

## Status

`aldsim` is still in development. Over the next few months it will
be expanded to incorporate a variety of models. Please check aldsim's
documentation in [readthedocs](https://aldsim.readthedocs.io/en/latest/).


## Quick install

Through pypi:

```
pip install aldsim
```

## Usage

## Acknowledgements

Argonne's Laboratory Directed Research and Development program

## Copyright and license

Copyright © 2024, UChicago Argonne, LLC

`aldsim` is distributed under the terms of BSD License. 

Argonne Patent & Intellectual Property File Number: SF-24-041
kcidb-io 140
KCIDB = Linux Kernel CI reporting - I/O data library
Requires Python: >=3.10

kcidb-io
========

`kcidb-io` is a Python 3 library for validating and manipulating Linux Kernel
CI reports in JSON format. This library is used by [`kcidb`][kcidb] - a
package for maintaining a service storing and serving that data.

Installation
------------

`kcidb-io` requires Python v3.10 or later.

To install the latest version from PyPI:

    pip3 install kcidb-io

To install from the git repository:

    pip3 install git+https://github.com/kernelci/kcidb-io.git

To install from a local directory:

    pip3 install .

Using
-----

Here's an example creating an empty report and then validating it:
```python
# Import the kcidb-io package
import kcidb_io
# Create an empty report using the latest schema version
json = kcidb_io.new()
# Validate the report
kcidb_io.schema.validate(json)
```

Exporting the JSON schema
-------------------------

The current schema is available as a JSON Schema dictionary on the version
class. The latest schema is exposed as `kcidb_io.schema.LATEST`.

Export the latest schema to a file:

```bash
python3 - <<'PY'
import json
from kcidb_io import schema

v = schema.LATEST
with open(f"kcidb-io.schema.v{v.major}.{v.minor}.json", "w") as f:
    json.dump(v.json, f, indent=2, sort_keys=True)
PY
```

Compatibility notes
-------------------

The schema is validated in this library using JSON Schema Draft-07. The
exported schema JSON does not include a `$schema` field; if a validator
requires one, add:

```json
{
  "$schema": "http://json-schema.org/draft-07/schema#"
}
```

The schema uses `$defs` and the `uri` string format. If your validator supports
format checking, enable it to validate `uri` values.

Hacking
-------

If you want to hack on the source code, install the package in the editable
mode with the `-e/--editable` option, and with "dev" extra included. E.g.:

    pip3 install --user --editable '.[dev]'

The latter installs the `kcidb-io` package using the modules from the source
directory, and changes to them will be reflected immediately without the need
to reinstall. It also installs extra development tools, such as `flake8` and
`pylint`.

[kcidb]: https://github.com/kernelci/kcidb/
filemind 0.1.0
Declarative local file pipelines in Python
Requires Python: >=3.12

# Filemind — Rule-Driven Local File Automation

**Declarative local file pipelines for organizing your files.**

Filemind lets you describe *what should happen* to your files — not *how*.  
You define rules in YAML (extensions, regex, age, priority), and Filemind applies them safely with dry‑run support, conflict handling, and a clean CLI.

This project was built as a learning + portfolio tool focused on clarity, safety, and developer experience.

---

## ✨ Features

- Declarative YAML configuration
- Rule engine with priority (highest wins)
- Match by:
  - File extensions
  - Regex on filename
  - File age (`older_than_days`)
- Conflict policies:
  - `rename`
  - `skip`
  - `overwrite`
- Dry-run mode (preview changes before touching files)
- Summary report after each run
- Proper logging levels (`INFO` / `DEBUG`)
- Cross-platform (Windows, macOS, Linux)

---

## 📦 Installation

### From PyPI (planned / when published)

```bash
pip install filemind
```

Or:

```bash
python -m pip install filemind
```

### Local development

```bash
pip install -e .
```

With uv:

```bash
uv sync
```

---

## 🚀 Quick Start

Create a `filemind.yaml`:

```yaml
source: ~/Downloads
default_target: ~/Downloads/others
conflict_policy: rename

rules:
  - name: invoices
    priority: 100
    match:
      extensions: ["pdf"]
      regex: "(?i)invoice|nota|nf"
    action:
      move_to: ~/Downloads/finance/invoices

  - name: documents
    priority: 50
    match:
      extensions: ["pdf", "docx", "xlsx"]
    action:
      move_to: ~/Downloads/documents

  - name: images
    priority: 40
    match:
      extensions: ["jpg", "jpeg", "png", "webp"]
    action:
      move_to: ~/Downloads/images

  - name: old_installers
    priority: 80
    match:
      extensions: ["exe", "msi"]
      older_than_days: 14
    action:
      move_to: ~/Downloads/installers/old
```

Preview changes:

```bash
filemind run --dry-run
```

Run for real:

```bash
filemind run
```

Verbose mode (per-file logs):

```bash
filemind run --log-level DEBUG
```

---

## 🧠 How it works

1. Filemind scans the source directory
2. Rules are evaluated by priority (highest first)
3. The first matching rule wins
4. Files are moved according to the selected conflict policy
5. A summary is printed at the end

---

## ⚔ Conflict Policy

- `rename` (default): creates `file (1).ext`, `file (2).ext`, etc
- `skip`: ignores files that already exist
- `overwrite`: replaces existing files

---

## 🧪 Development

Run tests:

```bash
uv run pytest
```

Project layout:

```
filemind/
├── src/filemind/
├── tests/
├── pyproject.toml
└── README.md
```

---

## 🛠 Status

Early alpha / experimental.

APIs may change.

---

## 📄 License

MIT

---

## Roadmap

- [ ] Watch mode (real-time folder monitoring)
- [ ] Per-rule conflict policies
- [ ] Copy instead of move
- [ ] Trash support
- [ ] Config validation