semvec/pypi-packages huggingface dataset:
openfisca-paraguay 0.2.1
OpenFisca Rules as Code model for Paraguay.
Requires Python: >=3.9
Keywords: benefit, microsimulation, rac, rules-as-code, tax, paraguay

# OpenFisca Paraguay

This repository contains the OpenFisca model for the Paraguayan tax and benefit system.

## Setup

This project uses `uv` for dependency management.

### Installation

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

## Usage

### Running Tests

```bash
uv run openfisca-run-test tests/test_ips.yaml -c openfisca_paraguay
```

### Checking Parameters

You can inspect the parameters using the OpenFisca CLI (ensure it is installed/accessible):

```bash
uv run openfisca-paraguay show-parameters
```

## Structure

- `openfisca_paraguay/paramaters`: Tax and benefit system parameters (rates, thresholds, etc.), organized by domain.
- `openfisca_paraguay/variables`: Python variables defining the logic of the tax and benefit system.
- `tests`: YAML tests to verify the logic.

## Legislation

The model implements legislation based on:
- Law No. 6380/2019 (Tax Modernization)
- Decree Law No. 1860/1950 (Social Security)
- Various other laws and decrees defining social benefits (Tekoporã, PAAM, Hambre Cero).

## Roadmap

To verify and improve the model, please refer to our roadmap:
- [Roadmap (English)](ROADMAP.md)
- [Hoja de Ruta (Español)](ROADMAP_ES.md)
bbmuse 0.1.0
BlackBoard MUSic Engine - A blackboard system for realtime AI music generation
Requires Python: >=3.12

# BlackBoard MUSic Engine

A blackboard system for realtime AI music generation.

This is ongoing research. The Github repository is currently set to private, but will be available soon.

## Installation and first-run experience

To install via PyPI, use: `pip install bbmuse`

To install locally (e.g., if cloned from github), use: `pip install -e .` (from inside this directory)

To quickly test the local installation, run: `bbmuse tests/DummyProject/ --quit-after 5`

For additional usage, use: `bbmuse --help`

More example projects can be found online soon.
l4v1 0.2.3
A Python library to simplify data-analytics tasks
Requires Python: >=3.10.13

# l4v1
l4v1 is a Python library designed to simplify data analytics tasks through data manipulation and visualization techniques. Built on top of Polars and Plotly, it offers a straightforward API for quickly creating detailed summaries. This project is a work in progress, and more functionality will be added in the future.

## Installation
You can install the `l4v1` package directly from PyPI:

```bash
pip install l4v1
```

## Usage
Calculate price, volume, and mix effects conveniently, and visualize them in an Excel heatmap or a Plotly waterfall chart.

Start by importing Polars to load the data:

```python
import polars as pl

# Load your datasets
sales_week_1 = pl.read_csv("data/sales_week1.csv")
sales_week_2 = pl.read_csv("data/sales_week2.csv")
```

Once you have the data, import the PVM module:
```python
from l4v1.price_volume_mix import PVM

# Initialize the class with your data and desired dimensions
pvm = PVM(
    df_primary=sales_week_2, # Data to analyse
    df_comparison=sales_week_1, # Data to compare against
    group_by_columns=["Product line", "Customer type"] # Dimension(s) to use
    volume_column_name="Quantity", # Column name containing volume (e.g. quantity)
    outcome_column_name="Total", # Column name containing outcome (e.g. revenue or cost)
)
```
Once the class is initialized, you can decide whether to create an Excel table, a Plotly waterfall chart, or continue working with the data in a Polars DataFrame.

To create a waterfall chart:
```python
pvm.waterfall_plot(
    primary_total_label="Week 2 Sales", # Optional label
    comparison_total_label="Week 1 Sales", # Optional label
    title="Sales Week 2 vs 1", # Optional title,
    color_total = "#F1F1F1", # Optional color for totals
    # etc.
)
```
![Waterfall Plot Example](docs/readme/example_waterfall.png)

In Excel, it is easier to visualize if there are many dimensions used:
```python
pvm.write_xlsx_table("your/path/file_name.xlsx") # Must end to .xlsx file extensions
```
![Heatmap Example](docs/readme/example_excel_heatmap.png)

For large datasets, it might be most convenient to continue exploring directly in Polars. In that case, simply call get_table:
```python
pvm.get_table()
```
nova-trame 1.4.0
A Python Package for injecting curated themes and custom components into Trame applications
Requires Python: <3.14,>=3.10
Keywords: NDIP, Python, Trame, Vuetify

nova-trame
==========

`nova-trame` is a Python package for streamlining development of Trame applications used in the NOVA framework.

You can install this package directly with

```commandline
pip install nova-trame
```

Once installed, you can check that it's working by running the widget gallery we use for visually testing components available through NOVA and Trame. We use [Pixi](https://pixi.sh/latest/) internally and recommend it for running the gallery.

```commandline
pixi install
pixi run app
```

A user guide, examples, and a full API for this package can be found at [https://nova-application-development.readthedocs.io/en/stable/](https://nova-application-development.readthedocs.io/projects/nova-trame/en/stable/).

Developers: please read [this document](DEVELOPMENT.md)
audio-tuner-gui 0.11.3
Graphical interface for Audio Tuner
Requires Python: >=3.11
Keywords: audio, music, pitch shift, player, tempo shift, tuning

Audio Tuner GUI
===============

This is the GUI front end for Audio Tuner, a tool for musicians that analyzes
and corrects the pitch of recorded audio.

It's under active development, with more features and usability improvements
planned for future versions.  The current version is already usable, however.

Motivation
~~~~~~~~~~

A surprisingly high proportion of recorded music doesn't conform to any
standard tuning system.  You expect an A4 to be 440 Hz, but when you try to
play along you realize it's not.  Audio Tuner is a tool for measuring the
frequencies in an audio recording so it can be corrected if necessary.  It's
designed to be convenient enough to use that you can do it with a musical
instrument strapped to you.

The primary use case is to correct the tuning of your favorite songs so you
can practice playing an instrument by playing along with them, but it can be
used in any situation where you need to analyze and correct the pitch of a
recording.

What it's not
~~~~~~~~~~~~~

Audio Tuner is not autotune.  It pitch corrects entire songs, not individual
notes.

Dependencies
~~~~~~~~~~~~

**audio-tuner-gui** requires **Python version 3.11 or higher**, **libmpv2**,
and the `audio-tuner`_ and `PyQt6`_ python packages.

Note that pip is not able to install **libmpv2**.  If your operating system
has a package manager, use that to install it.  See the `documentation`_
for details.

Audio Tuner can be configured to use **ffmpeg** and **ffprobe** instead of
libmpv2, at the cost of reduced functionality in the GUI.

.. _documentation: https://audio-tuner.readthedocs.io/
.. _audio-tuner: https://pypi.org/project/audio-tuner/
.. _PyQt6: https://www.riverbankcomputing.com/software/pyqt/

Free as in Freedom
~~~~~~~~~~~~~~~~~~

Audio Tuner is licensed under the `GNU General Public License`_ version 3 or
later.

.. _GNU General Public License: https://gnu.org/licenses/gpl.html

See
`What is Free Software? <https://www.gnu.org/philosophy/free-sw.html>`_
and
`Copyleft: Pragmatic Idealism
<https://www.gnu.org/philosophy/pragmatic.html>`_.

Versioning
~~~~~~~~~~

Audio Tuner attempts to use `Semantic Versioning`_, but with `PEP 440`_
compatible version numbers.

New versions of the base Audio Tuner package and Audio Tuner GUI are released
at the same time with the same version numbers.  The API is already reasonably
stable, but of course nothing's guaranteed until it reaches version 1.0.0.  

.. _Semantic Versioning: https://semver.org
.. _PEP 440: https://peps.python.org/pep-0440/

See Also
~~~~~~~~

audio-tuner:  https://pypi.org/project/audio-tuner/
agent-chatroom 0.2.0
Temporary chat rooms for AI agents to communicate in real-time
Requires Python: >=3.10
Keywords: agents, ai, chat, real-time, sse

# agent-chatroom

Temporary real-time chat rooms for AI agents. Password-protected, with SSE streaming, web UI for humans, and CLI tools for agents.

```bash
uv run --with agent-chatroom agent-chat serve --password SECRET --tunnel cloudflared
```
pptx-concatenator 0.1.0
PowerPoint concatenation library using pptx-slide-copier
Requires Python: >=3.9

# pptx-concatenator

A Python library for concatenating PowerPoint presentations using [pptx-slide-copier](https://github.com/SpringMT/pptx-slide-copier).

## Features

- Concatenate multiple PPTX files by appending slides
- Preserve formatting, images, and layouts
- Support for both file paths and Presentation objects
- Simple and intuitive API
- Command-line interface for easy usage

## Installation

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

For development:

```bash
pip install -e ".[dev]"
```

### Requirements

- Python 3.9+
- python-pptx >= 0.6.21
- pptx-slide-copier >= 0.0.5

## Usage

### Command Line Interface

After installation, you can use the `pptx-concat` command to concatenate PPTX files directly from the command line:

```bash
# Concatenate two presentations
pptx-concat source.pptx target.pptx -o output.pptx

# Concatenate multiple presentations
pptx-concat source.pptx file1.pptx file2.pptx file3.pptx -o output.pptx

# Show help
pptx-concat --help
```

### Python API

#### Basic Usage

Concatenate two PPTX files:

```python
from pptx_concatenator import concat_pptx

# Simple function to concatenate two PPTX files
concat_pptx("source.pptx", "target.pptx", "output.pptx")
```

### Using the PptxConcatenator Class

```python
from pptx_concatenator import PptxConcatenator

# Concatenate two presentations
result = PptxConcatenator.concat("source.pptx", "target.pptx", "output.pptx")

# Concatenate multiple presentations
result = PptxConcatenator.concat_multiple(
    "source.pptx",
    ["target1.pptx", "target2.pptx", "target3.pptx"],
    "output.pptx"
)
```

### Working with Presentation Objects

```python
from pptx import Presentation
from pptx_concatenator import PptxConcatenator

# Load presentations
src_prs = Presentation("source.pptx")
target_prs = Presentation("target.pptx")

# Concatenate
result = PptxConcatenator.concat(src_prs, target_prs)

# Save manually
result.save("output.pptx")
```

## Development

### Setup Development Environment

```bash
make install
```

### Running Tests

```bash
# Run tests
make test

# Run tests with coverage
make test-cov
```

### Linting and Formatting

```bash
# Run linter
make lint

# Format code
make format

# Check formatting without changes
make format-check
```

### Available Make Commands

- `make install` - Install package and development dependencies
- `make test` - Run tests
- `make test-cov` - Run tests with coverage report
- `make lint` - Run ruff linter
- `make format` - Format code with ruff
- `make format-check` - Check formatting without making changes
- `make clean` - Clean build artifacts and cache files

## CI/CD

This project uses GitHub Actions for continuous integration:

- **Lint**: Checks code quality with ruff
- **Test**: Runs tests on Python 3.8-3.12

## License

MIT
lensepy 2.1.1
LEnsE Package including scientific methods in photonics and graphical objects to implement a User Interface
Requires Python: >=3.11

LEnsE Python package
####################

This package is provided by the `LEnsE <https://lense.institutoptique.fr/>`_, the Experimental Teaching Laboratory of
the `Institut d'Optique Graduate School  <https://www.institutoptique.fr>`_.

.. image:: assets/IOGS-LEnsE-logo_small.jpg
   :alt: LEnsE Logo
   :align: center

How to install
==============

**Lensepy** can be installed from PyPI with pip:

.. code-block:: sh

    pip install lensepy


How to use
==========

**Lensepy** can be imported in your Python script:

.. code-block:: python

    import lensepy

For specific use, a documentation is available at this website:
`<https://iogs-lense.github.io/lensepy/>`_.
llmai 0.0.1
Coming soon...
Requires Python: >=3.11

# Same Interface for ALL LLMs

Seamlessly interact with all leading Large Language Model providers through a unified and intuitive client.

## Features

- Supports multiple providers (OpenAI, Anthropic, Google Gemini, and more)
- Easy integration for any workflow or application
- Fast, reliable, and secure requests

---

**Stay tuned!**
pyfive 1.1.0
A pure python HDF5 reader
Requires Python: >=3.10

[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://GitHub.com/Naereen/StrapDown.js/graphs/commit-activity)
[![made-with-python](https://img.shields.io/badge/Made%20with-Python-1f425f.svg)](https://www.python.org/)
[![Documentation Status](https://app.readthedocs.org/projects/pyfive/badge/?version=latest)](https://pyfive.readthedocs.io/en/latest/?badge=latest)
[![Test](https://github.com/NCAS-CMS/pyfive/actions/workflows/pytest.yml/badge.svg)](https://github.com/NCAS-CMS/pyfive/actions/workflows/pytest.yml)
[![codecov](https://codecov.io/gh/NCAS-CMS/pyfive/graph/badge.svg?token=3In5JuzeGK)](https://codecov.io/gh/NCAS-CMS/pyfive)
[![Anaconda-Server Badge](https://anaconda.org/conda-forge/pyfive/badges/version.svg)](https://anaconda.org/conda-forge/pyfive)

![pyfive-logo](https://raw.githubusercontent.com/NCAS-CMS/pyfive/main/doc/figures/Pyfive-logo.png)

[Latest doc builds on RTD](https://app.readthedocs.org/projects/pyfive/builds/)

pyfive : A pure Python HDF5 file reader
=======================================

``pyfive`` is an open source library for reading HDF5 files written using
pure Python (no C extensions). The package is still in development and not all
features of HDF5 files are supported.

``pyfive`` aims to support the same API as [`h5py`](https://github.com/h5py/h5py) for reading files.
Cases where a file uses a feature that is supported by ``h5py`` but not ``pyfive`` are considered bugs
and should be reported in our [Issues](https://github.com/NCAS-CMS/pyfive/issues).
Writing HDF5 output is not a goal of ``pyfive`` and portions of the API which apply only to writing will not be implemented.

Dependencies
============

``pyfive`` is tested against Python versions 3.10 to 3.14.
It may also work with other Python versions.

The only dependencies to run the software besides Python is ``numpy``.

Install
=======

pyfive can be installed using ``pip`` using the command::

    pip install pyfive

``conda`` packages are also available from conda-forge::

    conda install -c conda-forge pyfive

To install from source in your home directory use::

    pip install --user ./pyfive

The library can also be imported directly from the source directory.


Development
===========

git
---

You can check out the latest ``pyfive`` souces with the command::

    git clone https://github.com/NCAS-CMS/pyfive.git

testing
-------

``pyfive`` comes with a test suite in the ``tests`` directory.
These tests can be exercised using the ``pytest`` command from the root directory (requires installation of the ``pytest`` package).

Conda-forge feedstock
=====================

Package repository [conda-forge feedstock](https://github.com/conda-forge/pyfive-feedstock)

Codecov
=======

Test coverage assessement is done using [codecov](https://app.codecov.io/gh/NCAS-CMS/pyfive/)

Documentation
=============

Build locally with Sphinx:

    $ sphinx-build -Ea doc doc/build
sgm3 0.1.3
A user-friendly GUI module, made for Python 3.
Requires Python: >=3.10

# SGM

* The sgm module is made by Swaraaj Arora and is a user-friendly GUI framework.

## EXAMPLE (HELLO WORLD!)
```python
from sgm import SGMApplication, SGMText
app = SGMApplication(title="Window", resizable=True)
text = SGMText(parent=app, text="Hello, World!", width=25, height=3, size=10)
text.Show()
app.StartLoop()
```