semvec/pypi-packages huggingface dataset:
livekit 1.1.2
Python Real-time SDK for LiveKit
Requires Python: >=3.9.0
Keywords: webrtc, realtime, audio, video, livekit

# LiveKit SDK for Python

Python SDK to integrate LiveKit's real-time video, audio, and data capabilities into your Python applications using WebRTC. Designed for use with [LiveKit Agents](https://github.com/livekit/agents) to build powerful voice AI apps.

See https://docs.livekit.io/ for more information.
inoopa_utils 10.10.0
Collection of utils used at Inoopa.
Requires Python: >=3.10

# Inoopa's helpers

This repo contains helper functions we use in all of our python projects.

## This is pushed publicly to Pypi, so NEVER commit any secret here

## How to use this package in your code

```bash
pip install inoopa_utils
```

```python
from inoopa_utils.mongodb_helpers import DbManagerMongo

db_manager = DbManagerMongo()
```

## Development Setup

This project uses [UV](https://github.com/astral-sh/uv) for dependency management.

```bash
# Install UV (if not already installed)
curl -LsSf https://astral.sh/uv/install.sh | sh

# Install dependencies
uv sync

# Install development dependencies
uv sync --dev

# Add a new dependency
uv add <package-name>

# Add a new development dependency
uv add --dev <package-name>
```

## How to publish package to Pypi

### Automatic Publishing (Recommended)

The package is automatically published to PyPI when you push changes to `pyproject.toml` on the `main` branch, **but only if the version has been bumped**.

1. Make your code changes
2. **Update the package version** in [pyproject.toml](./pyproject.toml) at the key `version`
3. Commit and push to `main`
4. GitHub Actions will automatically:
   - Verify the version was bumped
   - Build the package
   - Publish to PyPI
   - Create a GitHub release

**Required Setup:**

- Add your PyPI API token as a GitHub secret named `PYPI_API_TOKEN`

### Manual Publishing

If you need to publish manually:

```bash
# Export your PyPI token
export UV_PUBLISH_TOKEN="..."

# Build project
uv build

# Publish (requires PyPI token to be configured)
uv publish
```

Note: You'll need to configure your PyPI credentials. You can either:

- Set the `UV_PUBLISH_TOKEN` environment variable with your PyPI token
- Use `uv publish --username __token__ --password <your-token>`
cal-gitlab-releases 0.1.0
Download and upload release assets for GitLab projects and groups
Requires Python: >=3.12
Keywords: assets, download, gitlab, releases, upload

# cal-gitlab-releases

Download and upload release assets for GitLab projects and groups.

## Installation

```bash
pip install cal-gitlab-releases
```

## Usage

```bash
# Download release assets from a group
cal-gitlab-releases download -u https://gitlab.com -p myorg/public -o ./releases

# Upload release assets to a target GitLab
cal-gitlab-releases upload -u https://gitlab.example.com -p target-group -i ./releases -t TOKEN
```

## Commands

### download

Download release assets from GitLab projects or groups. Supports version filtering, manifest-based incremental downloads, and parallel threads.

Use `--flat` to download all files into a single directory (useful for manual inspection). Note that flat output cannot be used with the `upload` command, which requires the `project/tag` directory structure.

### upload

Upload release assets to GitLab. Reads the same directory structure produced by `download`, creates releases if they don't exist, and attaches asset files as release links.

## Configuration

Settings can be provided via CLI args, environment variables, or a config file at `~/.config/cal-gitlab-releases/config.json`:

```json
{
    "gitlab_url": "https://gitlab.example.com",
    "token": "glpat-xxxxxxxxxxxx",
    "base_group": "myorg",
    "output": "./downloads",
    "version_filter": "release",
    "parallel": 32
}
```

## Licence

MIT License — Copyright (c) 2026 Cyber Assessment Labs
qmm-core 0.4.14
A software platform for analysing the structure and function of complex systems
Requires Python: >=3.9

# Qualitative Mathematical Modelling (QMM) in Python

[![Status](https://img.shields.io/badge/Status-Active%20Development-yellow)]()
[![Python Version](https://img.shields.io/badge/Python-3.9%2B-blue)](https://www.python.org/)

![QMM Logo](logo.png)

Qualitative Mathematical Modelling (QMM) is a method for analysing the structure of complex systems where general causal relationships are known but precise quantitative data are lacking. By utilising signed digraphs to visualise system structure, QMM enables users to build models of real-world systems and generate testable predictions of system response to perturbations.

## Features

- Python package (`qmm`) for qualitative mathematical modelling, including core modules for defining model structure, stability analysis, perturbation analysis and making qualitative predictions.
- Integration with an interactive web application for creating signed digraph (network) models representing the mathematical structure of a complex system.

## Quick start

1. Install using pip: ```pip install qmm-core```.
2. Create a model using the prototype [web application](https://www.digraphbuilder.com/).
3. Import functions using ```import qmm``` to analyse your model in Python.

## Documentation

Full documentation is available at **[jaydenhyman.github.io/qmm](https://jaydenhyman.github.io/qmm)**, including:

- [Getting Started](https://jaydenhyman.github.io/qmm/getting-started/) - Installation and basic usage
- [API Reference](https://jaydenhyman.github.io/qmm/reference/) - Complete function reference

## Licensing

This project is licensed under the the BSD 3-Clause Licence and is **free** and **open source**.

## Contact

Jayden Hyman - <j.hyman@uq.edu.au>
deltacycle 0.29.1
Delta Cycle
Requires Python: >=3.12

# Delta Cycle

DeltaCycle is a Python library for discrete event simulation (DES).

A simulation has two components: a collection of *variables*,
and a collection of *tasks*.
Variables represent the instantaneous state of the simulation.
They may be organized into arbitrary data structures.
Tasks define how that state evolves.
They may appear concurrent, but are scheduled sequentially.

Task execution is subdivided into a sequence of slots.
Slots are assigned a monotonically increasing integer value, called *time*.
Multiple tasks may execute in the same slot, and therefore at the same time.
The term "delta cycle" refers to a zero-delay subdivision of a time slot.
It is the clockwork mechanism behind the illusion of concurrency.

[Read the docs!](https://deltacycle.rtfd.org) (WIP)

[![Documentation Status](https://readthedocs.org/projects/deltacycle/badge/?version=latest)](https://deltacycle.readthedocs.io/en/latest/?badge=latest)

## Features

* Kernel: task scheduler
* Task: coroutine wrapper
* Synchronization Primitives:
    * Events
    * Semaphores
    * Credit Pools
    * Queues
    * Containers
* Structured Concurrency:
    * Task Groups (parent/child hierarchy)
    * Interrupts
    * Exceptions
* Model Variables:
    * Singular
    * Aggregate

## Example

The following code simulates two clocks running concurrently.
The *fast* clock prints the current time every time step.
The *slow* clock prints the current time every two time steps.

```python
>>> from deltacycle import now, run, sleep

>>> async def clock(name: str, period: int):
...     while True:
...         print(now(), name)
...         await sleep(period)

>>> async def main():
...     create_task(clock("fast", 1))
...     create_task(clock("slow", 2))

>>> run(main(), until=6)
0 fast
0 slow
1 fast
2 slow
2 fast
3 fast
4 slow
4 fast
5 fast
```

## Installing

DeltaCycle is available on [PyPI](https://pypi.org):

    $ pip install deltacycle

It requires Python 3.12+

## Developing

DeltaCycle's repository is on [GitHub](https://github.com):

    $ git clone https://github.com/cjdrake/deltacycle.git

It is 100% Python, and has no runtime dependencies.
Development dependencies are listed in `requirements-dev.txt`.