semvec/pypi-packages huggingface dataset:
navcom-py 1.0.0
Navigate through git repository commits chronologically
Requires Python: >=3.7

# navcom - Navigate Git Commits

A simple bash script to navigate through git repository commits chronologically, perfect for studying a codebase's evolution.

![Demo](demo.gif)

## What It Does

- Lets you step through commits in chronological order (oldest to newest)
- Jump to first commit with `first`, navigate forward with `next`, or backward with `prev`
- Automatically tracks your progress
- Shows commit details at each step

## Installation

### MacOS/Linux

```bash
make install
```

This installs the script as `navcom` in `/usr/local/bin`.

### Manual Installation

```bash
sudo cp bin /usr/local/bin/navcom
sudo chmod +x /usr/local/bin/navcom
```

## Usage

Navigate to any git repository and run:

```bash
# Jump to first commit
navcom first

# Move to next commit (chronologically)
navcom next

# Move to previous commit
navcom prev
```

On first run, it will initialize by scanning the repository's commit history.

## How It Works

1. **First Run**: Creates a chronological list of all commits in the default branch
2. **Navigation**: Checks out commits in order and tracks your position
3. **Progress**: Stores tracking data in `.git/nc-progress` and `.git/nc-commits`

## Reset Progress

To start over from the beginning:

```bash

rm .git/nc-progress .git/nc-commits
```

## Uninstall

```bash
make uninstall
```
pyffmpeg 2.5.2.3.1
FFmpeg wrapper for python
Keywords: ffmpeg, FFmpeg, ffprobe, FFprobe, album art, cover art, metadata, conversion, converting, audio, video

# pyffmpeg |      [![Downloads](https://static.pepy.tech/personalized-badge/pyffmpeg?period=week&units=international_system&left_color=black&right_color=brightgreen&left_text=Downloads/week)](https://pepy.tech/project/pyffmpeg)


FFmpeg wrapper for python. It uses the most up-to-date FFmpeg binary to provide both FFmpeg and FFprobe functionality. So you can kill two birds with one stone.

The beautiful thing about this is that it comes with it's own FFmpeg executable. It is compressed, making it the smallest one you can find. Becuase it's cross-platform and python 3, it is the only option available for building cross-platform apps with ffmpeg in python.

## FFmpeg Version
Uses current FFmpeg version

## Installation
    pip install pyffmpeg

## Usage
### FFmpeg
```python
from pyffmpeg import FFmpeg

inp = 'path/to/music_folder/f.mp4'
out = 'path/to/music_folder/f.mp3'

ff = FFmpeg()

output_file = ff.convert(inp, out)

print(output_file)

```
OR

```python
from pyffmpeg import FFmpeg
ff = FFmpeg()
ff.input('path/to/music_folder/f.mp4').output('path/to/music_folder/f.mp3').run()
```
Or for multiple input files
```
ff.input(
         'path/to/music_folder/f.mp4',
         'path/to/music_folder/g.mp3',
          map=['0:1', '0:0']
).output('path/to/music_folder/f.mp4').run()
```
This method allows more complex file handling

### FFprobe
Provides FFprobe functions and values


```python
from pyffmpeg import FFprobe

input_file = 'path/to/music.mp3'
fp = FFprobe(input_file)

print(fp.duration)
```
will print
```shell
> 00:04:32:32
```
NB: The above digits are just for illustration purposes.


## Wiki
The wiki can be located [here](https://github.com/deuteronomy-works/pyffmpeg/wiki)


## Contributing
Contributions are welcome. Please read [Contributing](https://github.com/deuteronomy-works/pyffmpeg/wiki/How-to-Contribute)

## Legal
This library uses prebuilt binaries of <a href=http://ffmpeg.org>FFmpeg</a> licensed under the <a href=http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html>LGPLv2.1</a> and can be downloaded via the following links:
  * Mac - <a href="https://evermeet.cx/ffmpeg/">here</a>
  * Linux - <a href="https://johnvansickle.com/ffmpeg/">here</a>
  * Windows - <a href="https://www.gyan.dev/ffmpeg/builds/">here</a>
recx 0.0.8
Lightweight reconciliation tests for DataFrames
Requires Python: >=3.10

<br>

<div align="center">
    <a href="https://github.com/robolyst/recx">
        <img src="https://github.com/robolyst/recx/raw/main/docs/assets/logo.svg" width="400">
     </a>
</div>

<br>

<h1 align="center">
  Lightweight reconciliation tests for DataFrames
</h1>

[![CI Build](https://img.shields.io/github/actions/workflow/status/robolyst/recx/ci.yml?branch=main&label=tests&style=for-the-badge)](https://github.com/robolyst/recx/actions/workflows/ci.yml?query=branch%3Amain)
[![PyPI version](https://img.shields.io/pypi/v/recx.svg?style=for-the-badge)](https://pypi.org/project/recx/)
[![PyPI license](https://img.shields.io/pypi/l/recx.svg?style=for-the-badge)](https://pypi.python.org/pypi/)
[![Project Status: Active](https://img.shields.io/badge/repo%20status-Active-Green?style=for-the-badge)](https://www.repostatus.org/#active)

Use Rec to compare two DataFrames (baseline vs candidate) with per-column checks (equality, absolute / relative tolerance, regex-driven selection) and clear summaries of failures.

## Features

- Declarative column mapping
- Built-in checks: equality, absolute tolerance, relative tolerance
- Index integrity checks (missing / extra index values)
- Regex column selection (`regex=True` on checks)
- Compact textual summary
- Extensible: implement custom checks by subclassing `ColumnCheck`

## Install

With `pip`:

```bash
pip install recx
```

with `uv`:
```bash
uv add recx
```

## Quick Example

```python
import pandas as pd
from recx import Rec, EqualCheck, AbsTolCheck

baseline = pd.DataFrame({
    "price": [100.00, 200.00, 300.00],
    "status": ["active", "inactive", "active"]
})

candidate = pd.DataFrame({
    "price": [100.00, 200.00, 301.00],
    "status": ["active", "inactive", "active"]
})

rec = Rec(columns={
    "price": AbsTolCheck(tol=0.01),
    "status": EqualCheck(),
})

result = rec.run(baseline, candidate)
result.summary()
```

---

Feel free to open issues or PRs with suggestions or improvements.
pi3d 2.55
pi3d OpenGL 3D graphics library
Requires Python: >=3.7
Keywords: OpenGL, 3D, raspberry, raspi, graphics, game engine

Introduction to pi3d
====================

pi3d is a Python module that aims to greatly simplify writing 3D in Python
whilst giving access to the power of the Raspberry Pi GPU. It enables both
3D and 2D rendering and aims to provide a host of exciting commands to load
in textured/animated models, create fractal landscapes, shaders and much more.

The pi3d module runs on platforms other than the Raspberry Pi (On Windows
using pygame, on linux using the X server directly and on Android using
python-for-android) and runs with python 3 as well as 2.
The OpenGLES2.0 functionality of the Raspberry Pi or Android is used directly
or via mesa or ANGLE on 'big' machines. This makes it generally *faster*
and opens up the world of *shaders* that allow effects such as normal and 
reflection maps, blurring and many others. It has various demos of built-in
shapes, landscapes, model loading, walk-about camera and much more! See the demos
on github.com/pi3d/pi3d_demos and experiment with them ..

Documentation (instalation instructions): https://pi3d.github.io/html/ReadMe.html

FAQ: https://pi3d.github.io/html/FAQ.html

Demo programs: https://github.com/pi3d/pi3d_demos

Source code: https://github.com/tipam/pi3d

Book: http://paddywwoof.github.io/pi3d_book/

Changelog: https://github.com/tipam/pi3d/blob/master/ChangeLog.txt
tavo-sdk 0.4.0
Python SDK for Tavo AI API
Requires Python: >=3.8

# tavo-python-sdk

Python SDK for Tavo AI API

## Installation

```bash
pip install tavo-python-sdk
# or
poetry add tavo-python-sdk
```

## Usage

### Basic Usage

```python
from tavo import TavoClient

# Initialize client
client = TavoClient(api_key='your-api-key-here')

# Health check
health = client.health_check()
print(f'API Status: {health.status}')
```

### Advanced Usage

```python
from tavo import TavoClient

client = TavoClient(
    api_key='your-api-key',
    base_url='https://api.tavoai.net'  # optional
)

# Scan a repository
scan = client.scans.create(
    repository_url='https://github.com/user/repo',
    scan_type='security'
)

print(f'Scan created: {scan.id}')

# Get scan results
results = client.scans.get_results(scan.id)
print(f'Vulnerabilities found: {len(results.vulnerabilities)}')
```

### Async Support

```python
import asyncio
from tavo import AsyncTavoClient

async def main():
    client = AsyncTavoClient(api_key='your-api-key')

    # Health check
    health = await client.health_check()
    print(f'API Status: {health.status}')

    # Scan repository
    scan = await client.scans.create(
        repository_url='https://github.com/user/repo'
    )
    print(f'Scan created: {scan.id}')

asyncio.run(main())
```

## API Reference

### TavoClient

Main client class for interacting with Tavo AI API.

#### Constructor Options

- `api_key` (str): Your Tavo AI API key
- `base_url` (str, optional): API base URL (defaults to production)
- `timeout` (float, optional): Request timeout in seconds

#### Methods

- `health_check()`: Check API availability
- `scans.create(options)`: Create a new scan
- `scans.get_results(scan_id)`: Get scan results
- `scans.list()`: List all scans

### AsyncTavoClient

Async version of TavoClient with the same interface.

## Authentication

Get your API key from [Tavo AI Dashboard](https://app.tavoai.net).

```bash
export TAVO_API_KEY="your-api-key"
```

## Requirements

- Python 3.8+
- pip or poetry

## License

Apache-2.0

## Support

- [Documentation](https://docs.tavoai.net/python/)
- [GitHub Issues](https://github.com/TavoAI/tavo-sdk/issues)
- [Community Forum](https://community.tavoai.net)
mavspy 1.0.6
The MSU Autonomous Vehicle Simulator
Requires Python: >=3.8

# MavsPy

Python interface to the [MSU Autonomous Vehicle Simulator](https://www.cavs.msstate.edu/capabilities/mavs.php). 

MAVS is a software library for simulating autonomous ground vehicles in off-road terrain. MAVS simulates the sensors, vehicle, and environment. It uses physics-based models to simulate camera, lidar, and radar interacting with environmental features such as rain, dust, and fog.

Once installed, examples of scripts running different autonomous simulations can be found on the [MAVS-Examples github](https://github.com/CGoodin/MAVS-Examples).

## Citing MAVS
If you use MAVS for your research, please cite the following:
* Hudson, C., Goodin, C., Miller, Z., Wheeler, W., & Carruth, D. (2020, August). Mississippi state university autonomous vehicle simulation library. In Proceedings of the Ground Vehicle Systems Engineering and Technology Symposium (pp. 11-13).
* Goodin, C., Carruth, D. W., Dabbiru, L., Hudson, C. H., Cagle, L. D., Scherrer, N., ... & Jayakumar, P. (2022, June). Simulation-based testing of autonomous ground vehicles. In Autonomous Systems: Sensors, Processing and Security for Ground, Air, Sea and Space Vehicles and Infrastructure 2022 (Vol. 12115, pp. 167-174). SPIE.

## Other Documentation

Software documentation for the MAVS library is here:

https://mavs-documentation.readthedocs.io/en/latest/

The MAVS-API is documented here:

https://cgoodin.gitlab.io/msu-autonomous-vehicle-simulator/
merge3 0.0.16
Python implementation of 3-way merge
Requires Python: >=3.9

A Python implementation of 3-way merge of texts.

Given BASE, OTHER, THIS, tries to produce a combined text
incorporating the changes from both BASE->OTHER and BASE->THIS.
All three will typically be sequences of lines.

Usage
=====

From the command-line::

    $ echo foo > mine
    $ echo bar > base
    $ echo blah > other
    $ python -m merge3 mine base other > merged
    $ cat merged

Or from Python::

    >>> import merge3
    >>> m3 = merge3.Merge3(
    ...                    ['common\n', 'base\n'],
    ...                    ['common\n', 'a\n'],
    ...                    ['common\n', 'b\n'])
    >>> list(m3.merge_annotated())
    ['u | common\n', '<<<<\n', 'A | a\n', '----\n', 'B | b\n', '>>>>\n']
polarityjam 0.4.2
Feature extraction pipeline for vascular cell data
Requires Python: ~=3.10
Keywords: vascular cell, imaging, data analysis, polarity

# Feature extraction pipeline

The feature extraction pipeline to study endothelial cell polarity, junctions and morphology.

Check out our journal [paper](https://doi.org/10.1038/s41467-025-56643-x).
Check out our arxiv [preprint](https://doi.org/10.1101/2024.01.24.577027).

For installation, usage, and more read our [wiki](https://polarityjam.readthedocs.io/en/latest/).

Administrators and Maintainers please look here: [admin-wiki](https://github.com/polarityjam/polarityjam/wiki)
cloud-storage-clients 0.3.0
Storage clients for different cloud providers
Requires Python: >=3.10

## cloud-storage-clients

`cloud-storage-clients` is a Python library for having an unique interface over different cloud storage providers.
It can be used to connect a python client to providers.
This package is maintained by [Picsellia](https://fr.picsellia.com/).

This has been conceived for you to override classes.
For example, override VaultRepository if you retrieve credentials in another way.
You can create or override factories of client to add some additional parameters.

## Installation

Add it to your [poetry](https://python-poetry.org/)  environment
```bash
poetry add cloud-storage-clients
```

Or use the package manager [pip](https://pip.pypa.io/en/stable/) to install it.
```bash
pip install cloud-storage-clients
```

## Usage

### Basic client usage to retrieve a specific object name from an S3 bucket
```python
from cloud_storage_clients.connector import Connector
from cloud_storage_clients.s3.client import S3Client

connector = Connector(client_type="s3", bucket="my-bucket")

client = S3Client(connector, {"access_key_id": "access-key", "secret_access_key": "secret-access-key" })

with open("/path/object-name.jpg", "wb") as file:
    response = client.get("object-name.jpg")
    file.write(response.content)

```

### Pool Instanciation
```python
from cloud_storage_clients.connector import Connector
from cloud_storage_clients.s3.factory import S3ClientFactory
from cloud_storage_clients.repositories.vault_adapter import DefaultVaultAdapter, TokenCredentials
from cloud_storage_clients.repositories.vault import VaultCredentialRepository
from cloud_storage_clients.pool import ClientPool

# Login to your Vault by creating a VaultAdapter and its repository
vault_adapter = DefaultVaultAdapter(
    url="http://localhost:7200",
    credentials=TokenCredentials(token="vault_token", unseal_key="unseal_key")
)
repository = VaultCredentialRepository(adapter=vault_adapter)

# Instantiate a ClientPool and add an S3ClientFactory for minio client_type
pool = ClientPool(default_repository=repository)
pool.register_factory("minio", factory=S3ClientFactory())

# Create a connector object
connector = Connector(client_type="minio", bucket="my-bucket")

# Use pool to instantiate a client that have its credentials in Vault
client = pool.get_client(connector)

# Generate a presigned url that an user without access to your bucket can download
presigned_url = client.get_download_url("object-name", 3600).url



```
risiko-engine 1.0.0
A Stateless Russian Roulette Python Engine
Requires Python: >=3.12
Keywords: game, engine, roulette, stateless


<div align="center">

# risiko-engine 

**A Stateless Russian Roulette Python Engine**

</div>

<div align="center">

[![PyPI version](https://badge.fury.io/py/risiko-engine.svg)](https://badge.fury.io/py/risiko-engine)
[![Python Version](https://img.shields.io/pypi/pyversions/risiko-engine.svg)](https://pypi.org/project/risiko-engine)
[![License](https://img.shields.io/pypi/l/risiko-engine.svg)](https://opensource.org/licenses/MIT)
[![CI](https://github.com/Kodutzu/risiko-engine/actions/workflows/python-ci.yml/badge.svg)](https://github.com/Kodutzu/risiko-engine/actions/workflows/python-ci.yml)

</div>

---

## 📖 Table of Contents

- [🚀 Installation](#-installation)
- [🎯 Quickstart](#-quickstart)
- [📜 License](#-license)

---

## 🚀 Installation

```bash
pip install risiko-engine
```

---

## 🎯 Quickstart

Here's a quick example of how to use `risiko-engine` to simulate a game of Russian Roulette:

```python
from risiko import RisikoState, processors
from risiko.core import PlayerBase, ShellBase

# Initialize the game state
state = RisikoState()

# Add a player to the game
state = processors.add_player_to_game(
    game_state=state, player=PlayerBase(id="player1", name="Player 1", charges=3)
)

# Load the magazine with shells
state = processors.load_magazine(
    game_state=state,
    round=[
        ShellBase(shell_type="live", damage=1),
        ShellBase(shell_type="blank", damage=0),
        ShellBase(shell_type="live", damage=1),
        ShellBase(shell_type="blank", damage=0),
    ],
)

# Shuffle the magazine
state = processors.shuffle_magazine(game_state=state)

# Load a shell into the shotgun
state = processors.shotgun_load_shell(game_state=state)

# Get the current player
current_player_id = state.turns.current_player_id
print(f"Current player: {current_player_id}")

# Fire the shell
fired_shell, state = processors.fire_shell(game_state=state, shooter_id=current_player_id)
print(f"Fired a {fired_shell.shell_type} shell!")

# Check the player's health
player = state.player.get_player(current_player_id)
print(f"{player.name} has {player.charges} charges remaining.")
```

`Note: Will be publishing it's documentation`

---


## 📜 License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
gemseo-umdo 4.3.0
Robust MDO and advanced UQ with GEMSEO.
Requires Python: <3.14,>=3.10

<!--
Copyright 2021 IRT Saint Exupéry, https://www.irt-saintexupery.com

This work is licensed under the Creative Commons Attribution-ShareAlike 4.0
International License. To view a copy of this license, visit
http://creativecommons.org/licenses/by-sa/4.0/ or send a letter to Creative
Commons, PO Box 1866, Mountain View, CA 94042, USA.
-->
# gemseo-umdo

[![PyPI - License](https://img.shields.io/pypi/l/gemseo-umdo)](https://www.gnu.org/licenses/lgpl-3.0.en.html)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/gemseo-umdo)](https://pypi.org/project/gemseo-umdo/)
[![PyPI](https://img.shields.io/pypi/v/gemseo-umdo)](https://pypi.org/project/gemseo-umdo/)
[![Codecov branch](https://img.shields.io/codecov/c/gitlab/gemseo:dev/gemseo-umdo/develop)](https://app.codecov.io/gl/gemseo:dev/gemseo-umdo)

## Overview

`gemseo-umdo` is a plugin of the library [GEMSEO](https://www.gemseo.org),
dedicated to multidisciplinary optimization (MDO) under uncertainty.

### MDO under uncertainty

The main goal of `gemseo-umdo` is to extend GEMSEO
to MDO under uncertainty.

Given a collection of disciplines,
we are interested in solving a problem like

$$
\begin{align}
&\underset{x\in\mathcal{X}}{\operatorname{minimize}}&
& \mathbb{E}[f(x,U)]+\kappa\times\mathbb{S}[f(x,U)] \\
&\operatorname{subject\;to}
& &\mathbb{P}[g(x,U)\geq 0] \leq \varepsilon
\end{align}
$$

by selecting an MDO formulation to handle the multidisciplinary coupling
and an estimation technique to approximate the statistics.

### Statistics

`gemseo-umdo` also proposes advanced techniques
for uncertainty quantification and management (UQ&M).
In presence of multilevel simulators,
multilevel Monte Carlo (MLMC) sampling can reduce
the variance of the statistics estimators.
Another variance reduction technique
consists of using the outputs of surrogate models
as control variates,
even moderately correlated with the original models.

### Visualization

A third facet of `gemseo-umdo` is the visualization toolbox
to display the propagation of the uncertainties
through a multidisciplinary system
as well as the interaction between the uncertain input variables.

## Installation

Install the latest version with `pip install gemseo-umdo`.

See [pip](https://pip.pypa.io/en/stable/getting-started/) for more information.

## Bugs and questions

Please use the [gitlab issue tracker](https://gitlab.com/gemseo/dev/gemseo-umdo/-/issues)
to submit bugs or questions.

## Contributing

See the [contributing section of GEMSEO](https://gemseo.readthedocs.io/en/stable/software/developing.html#dev).

## Contributors

- Antoine Dechaume
- Matthias De Lozzo
gemseo-pymoo 5.0.0
A GEMSEO wrapper for pymoo optimization algorithms.
Requires Python: <3.14,>=3.10

<!--
Copyright 2021 IRT Saint Exupéry, https://www.irt-saintexupery.com

This work is licensed under the Creative Commons Attribution-ShareAlike 4.0
International License. To view a copy of this license, visit
http://creativecommons.org/licenses/by-sa/4.0/ or send a letter to Creative
Commons, PO Box 1866, Mountain View, CA 94042, USA.
-->

# gemseo-pymoo

[![PyPI - License](https://img.shields.io/pypi/l/gemseo-pymoo)](https://www.gnu.org/licenses/lgpl-3.0.en.html)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/gemseo-pymoo)](https://pypi.org/project/gemseo-pymoo/)
[![PyPI](https://img.shields.io/pypi/v/gemseo-pymoo)](https://pypi.org/project/gemseo-pymoo/)
[![Codecov branch](https://img.shields.io/codecov/c/gitlab/gemseo:dev/gemseo-pymoo/develop)](https://app.codecov.io/gl/gemseo:dev/gemseo-pymoo)

## Overview

A GEMSEO wrapper for pymoo optimization algorithms.

## Installation

Install the latest version with `pip install gemseo-pymoo`.

See [pip](https://pip.pypa.io/en/stable/getting-started/) for more information.

## Bugs and questions

Please use the [gitlab issue tracker](https://gitlab.com/gemseo/dev/gemseo-pymoo/-/issues)
to submit bugs or questions.

## Contributing

See the [contributing section of GEMSEO](https://gemseo.readthedocs.io/en/stable/software/developing.html#dev).

## Contributors

- Gabriel Max DE MENDONCA ABRANTES
- Francois GALLARD
- Antoine Dechaume
- Lluis ARMENGOL GARCIA
- Luca SARTORI
- Gilberto RUIZ JIMENEZ