semvec/pypi-packages huggingface dataset:
flask-cctv-stream 0.0.1
Minimal Flask app for CCTV streaming.
Requires Python: >=3.9
Keywords: flask, cctv, streaming

# flask-cctv-stream

A minimal Flask-based MJPEG video streaming server with fullscreen responsive client UI, camera auto-open/close logic, frame limiting, and resolution scaling.

## Quick start

```bash
pip install flask-cctv-stream
# then open http://localhost:8080/
```

## Configuration

You can configure via **CLI args** (highest priority) or **environment variables** (fallback). Defaults are shown below.

### CLI flags

```bash
--camera-index   int    Camera index (default 0)
--width          int    Frame width (default 1280)
--height         int    Frame height (default 720)
--fps            int    FPS limit (default 15)
--timeout        int    Inactivity timeout seconds (default 2)
--host           str    Bind host (default 0.0.0.0)
--port           int    Bind port (default 8080)
--log-level      str    Logging level (default INFO)
```

**Environment variables** (used when the corresponding flag is not provided)

```text
CAMERA_INDEX      FRAME_WIDTH           FRAME_HEIGHT
FPS_LIMIT         INACTIVITY_TIMEOUT
HOST              PORT                  LOG_LEVEL
```

## Running with overrides

```bash
flask-cctv-stream \
  --camera-index 0 --width 1280 --height 720 \
  --fps 15 --timeout 2 --host 0.0.0.0 --port 8080 --log-level DEBUG

# or via env vars
CAMERA_INDEX=0 FRAME_WIDTH=1280 FRAME_HEIGHT=720 \
FPS_LIMIT=15 INACTIVITY_TIMEOUT=2 PORT=8080 LOG_LEVEL=DEBUG \
flask-cctv-stream
```
triton_submodular 0.1.0a1
A Triton implementation of greedy submodular algorithms using fused GPU kernels
Requires Python: >=3.9

# Triton Implementation of Greedy Optimization of Submodular Functions

This is a python-only implementation of [submodlib](https://github.com/decile-team/submodlib/) and [apricot](https://github.com/jmschrei/apricot/).

This library provides fused kernels for every (function, optimizer) pair available by dynamically generating them.

## Installation

```bash
pip install triton_submodular
```

or with uv,

As a package dependency:
```bash
uv add triton_submodular
```
For a venv:
```bash
uv pip install triton_submodular
```
For older GPUs (like pascal), you need to specify the cu126 wheel for pytorch:
```bash
uv pip install triton_submodular --torch-backend=cu126
```

## Features
- Functions:
  - Facility Location
  - Graph Cut
  - Feature Based
  - Max Coverage
- Optimizers:
  - Naive Greedy
  - Stochastic Greedy
  - Lazy Greedy

## Example Usage
```python
import torch
from triton_submodular.functions import FacilityLocation

X = torch.randn(100, 10, device="cuda", dtype=torch.float32)

fn = FacilityLocation(X) # generates euclidean similarity matrix by default

indices, gains = fn.maximize(10, "LazyGreedyTriton")

X_subset = X[indices]
```
This will take the data (100 points, 10 dimensional) and greedy select 10 points using the lazy greedy optimizer
which tries to maximize the facility location function.

## Testing

Clone and run `uv run -p 3.9 pytest -n auto`. Requires a GPU with CUDA support.

Deterministic optimizers are tested to be 1:1 against both apricot and submodlib's implementations.
Random algorithms (currently only stochastic greedy) are only tested against apricot, as submodlib uses
C's `rand()` function, making reproduction difficult.


NOTE: The stochastic greedy optimizer with the graphcut function currently does not match 1:1 to apricot's implementation.

## Roadmap
- [ ] Benchmarks and optimizations
- [ ] Add more submodular functions
- [ ] Add more optimizers
- [ ] Add more similarity metrics to graph functions that require a similarity matrix
- [ ] Add knapsack constraints
- [ ] Add sparse matrix support (maybe)
- [ ] Add streaming optimization (maybe)
lynx-nb 0.1.5
Block diagram editor for control systems
Requires Python: >=3.11

<!--
SPDX-FileCopyrightText: 2026 Jared Callaham <jared.callaham@gmail.com>

SPDX-License-Identifier: GPL-3.0-or-later
-->

# Lynx - Block Diagram Widget for Control Systems

<!-- <img src="js/src/assets/lynx-logo.png" alt="Lynx logo" width="380" height="380"> -->

**Lightweight block diagram editor GUI for control systems in Jupyter notebooks**

Lynx is a Jupyter widget that enables interactive creation and editing of block diagrams for linear SISO control systems. Designed for controls engineers working in Jupyter environments.

## Features

- **Interactive Canvas**: Drag-and-drop block diagram editing
- **Control Theory Blocks**: Transfer Function, State Space, Gain, Sum Junction, I/O markers
- **Real-Time Validation**: Algebraic loop detection, connection constraints
- **Git-Friendly Persistence**: Human-readable JSON format
- **Python Integration**: Use numpy expressions for parameters, export to python-control
- **SISO Systems**: Focus on linear single-input, single-output control systems

For more details, see the [documentation site](https://pinetreelabs.github.io/lynx/)

## Quick Start

The easiest way to install from pip:

```bash
pip install lynx-nb
```

### Source build

#### Backend installation

```bash
# Using UV (recommended)
uv pip install -e ".[dev]"

# Or using pip
pip install -e ".[dev]"
```

#### Frontend Setup

```bash
cd js
npm install
npm run build
```

### Jupyter Kernel Setup

```bash
# Install Jupyter kernel for this project
uv run ipython kernel install --user --env VIRTUAL_ENV $(pwd)/.venv --name=lynx
```

### Basic Usage

```python
import lynx
import numpy as np

# Create a diagram
diagram = lynx.Diagram()

# Launch interactive editor (displays in Jupyter)
lynx.edit(diagram)
```
dsinternals 1.2.5
Directory Services Internals Library
Requires Python: >=3.4

![](./.github/banner.png)
</br></br>

# pydsinternals - Directory Services Internals Library

<p align="center">
  <img alt="MIT License" src="https://img.shields.io/badge/License-MIT-green.svg">
  <img alt="Build Status" src="https://travis-ci.com/p0dalirius/pydsinternals.svg?branch=main">
  <img alt="PyPI" src="https://img.shields.io/pypi/v/dsinternals">
  <a href="https://twitter.com/intent/follow?screen_name=podalirius_" title="Follow"><img src="https://img.shields.io/twitter/follow/podalirius_?label=Podalirius&style=social"></a>
  <a href="https://www.youtube.com/c/Podalirius_?sub_confirmation=1" title="Subscribe"><img alt="YouTube Channel Subscribers" src="https://img.shields.io/youtube/channel/subscribers/UCF_x5O7CSfr82AfNVTKOv_A?style=social"></a>
  <br>
</p>

A Python native library containing necessary classes, functions and structures to interact with Windows Active Directory.

## Installation

```
python3 -m pip install dsinternals
```

## Contributing

Pull requests are welcome. Feel free to open an issue if you want to add other features.

## Credits

This code base was heavily inspired by [MichaelGrafnetter](https://twitter.com/MGrafnetter)'s [DS Internals](https://github.com/MichaelGrafnetter/DSInternals) library.

## References
 - https://github.com/MichaelGrafnetter/DSInternals