semvec/pypi-packages huggingface dataset:
soft-comp 0.0.1.dev25
Soft-Computing algorithms and helpers for lecture and exercises - Intelligent Embedded Systems (IES), University of Kassel
Keywords: Soft Computing, Evolutionary Algorithms, Fuzzy, Neural Networks

# Soft-Computing - Python Package

This python package contains python code used in the lectures and exercises of the IES Soft-Computing course.

## virtual environment

~~~bash
python -m venv softcomp-py
source ./softcomp-py/bin/activate
~~~

## install package

~~~bash
pip install -r requirements.txt
python setup.py install --user
~~~
hazardous 0.1.0
Predictive Competing Risks and Survival Analysis.
Requires Python: >=3.9

# HΛZΛRDOUS

Predictive Competing Risks and Survival Analysis.

[![Tests](https://github.com/soda-inria/hazardous/actions/workflows/test.yml/badge.svg)](https://github.com/soda-inria/hazardous/actions/workflows/test.yml)

## Installation and usage

XXX: the following will work only once the 0.1.0 release is out!

```
pip install hazardous
```

or

```
conda install -c conda-forge hazardous
```

Then browse the [online documentation](https://soda-inria.github.io/hazardous/)
and run the `examples/` to get started.

## Development and testing

Install in "editable" mode in your current Python env (after a standard installation to install the dependencies):

```
pip install flit
pip install . -v
pip install -e ".[dev]" --no-build-isolation -v
pre-commit install
```

Run the tests with nox to test in an environment that matches exactly on
specific CI build, for instance:

```
nox -p 3.11 -s test_latest_from_pypi -r
```

The `-r` flag makes it possible to reuse an existing env.

You can also install the test dependencies in the current env and use `pytest`
directly with arbitrary command line arguments:

```
pip install -e ".[test]" --no-build-isolation -v
pytest -vl -x -k test_name_pattern
```

## Building the doc

Using `nox`:

```
nox -s doc -r
```

or manually:

```
pip install -e ".[doc]" --no-build-isolation -v
cd doc
make html
```

The resulting html files are generated under the `doc/_build` folder.

## Building a release

```
pip install build
python -m build
ls dist/
```

TODO: make it possible to automate a release using GitHub Actions for a given tag.
pyeilcd 7.0.14
A Python package that converts ILCD XML formats to their Python equivalents and export the same data back to XML.
Requires Python: >=3.8

# pyeilcd User Guide

[![PyPI](https://img.shields.io/pypi/v/pyeilcd.svg)][pypi status]
[![Python Version](https://img.shields.io/pypi/pyversions/pyeilcd)][pypi status]

[pypi status]: https://pypi.org/project/pyeilcd/

[English](https://github.com/linancn/pyilcd/blob/main/README.md) | [中文](https://github.com/linancn/pyilcd/blob/main/README_CN.md)

**Note:** This package supports Python versions 3.8 to 3.12 only.

## 1. Introduction

pyeilcd is a Python package that provides a simple interface to validate extended-ILCD (eILCD) XML files against the ILCD schemas. It is built on top of the [pyilcd](https://github.com/brightway-lca/pyilcd) library.

---

## 2. pyeilcd Usage

### (1) Installation Instructions

You can install _pyeilcd_ via [pip] from [PyPI]:

```console
$ pip install pyeilcd
```
### (2) Functionalities

pyeilcd offers the following key functionalities:

- Performs schema validation on eILCD XML files.

- Supports multiple ILCD standard-compliant dataset types (e.g., ContactDataset, ProcessDataset, etc.).

- ​Leverages core validation capabilities from [pyilcd](https://github.com/brightway-lca/pyilcd).    

### (3) Usage Examples

```python
from pyeilcd import validate_file_contact_dataset, Defaults

# Override defaults if needed, else skip. Defaults are already set.
Defaults.config_defaults("config.ini")  # Replace with your own config file

# Validate the ContactDataset class against the ContactDataset schema.
validate_file_contact_dataset("data/invalid/sample_contact_invalid.xml")  # Replace with your own XML file
>> data/contact/sample_contact_invalid.xml:17:0:ERROR:SCHEMASV:SCHEMAV_CVC_DATATYPE_VALID_1_2_1: Element '{http://lca.jrc.it/ILCD/Common}class', attribute 'level': 'a' is not a valid value of the atomic type '{http://lca.jrc.it/ILCD/Common}LevelType'. data/contact/sample_contact_invalid.xml:17:0:ERROR:SCHEMASV:SCHEMAV_CVC_IDC: Element '{http://lca.jrc.it/ILCD/Common}class', attribute 'level': Warning: No precomputed value available, the value was either invalid or something strange happened.
```

## 3. Automatic Building and Publishing (CI/CD)

This project supports automatic building and publishing. When you push a git tag named with the v<version> format to the repository, it will trigger the workflow automatically. For example:

```bash
#list existing tags
git tag
#creat a new tag
git tag v7.0.12
#push this tag to origin
git push origin v7.0.12

```

## 4. License

Distributed under the terms of the GPL 3.0 license,
_pyeilcd_ is free and open source software.


[pip]: https://pip.pypa.io/en/stable/
[PyPI]: https://pypi.org/project/pyeilcd/
eamcvd 1.4.1
A library to fetch EAMCVD(elefant ai mod comp. and vulnerabilities database) incompatibility reports

# EAMCVD

A library to fetch EAMCVD(elefant ai mod comp. and vulnerabilities database) incompatibility reports.

## Installation

 `pip install eamcvd`

## Usage

```python
from eamcvd import requlib

# Search by ID
posts = requlib.getByID('id(witout 'eai-')')

# Search by name
posts = requlib.getByName('mod-name')
RxInfer 0.0.1
The official Python library for RxInfer
Requires Python: >=3.9

# RxInfer

RxInfer, a probabilistic programming framework.

> **Note:** This project is currently a work in progress. The implementation is under active development and may undergo significant changes.

## Overview

RxInfer allows you to define models, run inference, and process results with a clean API.

## Installation

```bash
pip install rxinfer
```

## Requirements

- Python 3.9+

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## License

This project is licensed under the Apache License, Version 2.0 - see the LICENSE file for details.
importo 0.2.1
Python import time profiler.
Requires Python: >=3.9

importo
=======

Python import time profiler.


## Installing

`importo` requires Python 3.9 or higher to work.

To install run

```
$ pip install importo
```

## Usage

`importo` can profile any Python module currently installed in your enviroment (virtual or otherwise).

```
$ importo datetime
cum     self    import
24219   957     runpy
13814   2181    contextlib
11998   2051    site
9016    2735    collections
7796    1934    os
4770    1689    encodings
3438    1328    pkgutil
3349    3349    _collections_abc
2878    661     importlib
```

By default, `importo` will only stay at the root module level, and order by cumulative time.

You can sort by `cumulative` time (time the import and all its child imports took),
`self` (time spent on just this particular import, child imports excluded) and module `name`.
You can also choose the depth of import to go into, much like `du` and other tools do as well as
pipe into other unix commands.

For example
```
$ importo datetime -d 1 -m encodings | head
cum     self    import
2312    1068    encodings
649     649     encodings.aliases
400     400     encodings.latin_1
273     273     encodings.utf_8
```
> instead of `--match`/`-m` you could also just pipe to grep and it would probably work just fine.

If you're looking for more statistical relevance in import times other than just a couple of runs,
you can specify the number of iterations the profiler goes through.

```
$ importo datetime -i 400 -d 1 -m encodings
cum     self    import
2071    899     encodings
530     530     encodings.aliases
349     349     encodings.latin_1
332     332     encodings.cp437
246     246     encodings.utf_8
```

For multiple iterations, the p99 values are used as it's probably the most useful.

## Testing

Tests are ran via `tox` to cover supported Python version.
As such simply run

```
$ tox
```

from the root of the repository, whilst you have the required python versions accessible to `tox`.

### Other

For more information on the available options run

```
$ importo -h
```

## About
This tool was motivated by the fact that Python3.7 introduced a new feature to show cumulative module import times.

An explanation and use case for this new feature can be found in this [blog entry](https://dev.to/methane/how-to-speed-up-python-application-startup-time-nkf) from a CPython core dev.

This is a wrapper on top of `python -X importtime`.
For small import trees I suggest using that tool first, it will probably suffice for your use case.

For actual production applications for my job, I've found that this tools helps me in narrowing down culprits and statistically tracking improvements.


**Notes**
> I've noticed that the sum of `self` times doesn't fully add to the `cumulative` value of the root module. I don't yet know why this is the case.


## Wishlist

1. Move project direction to also support detection of import cycles.
h3ppy 0.6.1
Model and fit H3+ spectra
Keywords: infrared spectroscopy H3+ modelling


# h3ppy
A python package for modelling and fitting H<sub>3</sub><sup>+</sup> spectra

## Install via pip
```
pip3 install h3ppy
```

Full [documentation on Github](https://github.com/henrikmelin/h3ppy) and at [https://h3ppy.readthedocs.io/](https://h3ppy.readthedocs.io/).
vsdpir 4.3.0
DPIR function for VapourSynth
Requires Python: >=3.10
Keywords: DPIR, PyTorch, TensorRT, VapourSynth

# DPIR
Plug-and-Play Image Restoration with Deep Denoiser Prior, based on https://github.com/cszn/DPIR.


## Dependencies
- [PyTorch](https://pytorch.org/get-started/) 2.6.0 or later
- [VapourSynth](http://www.vapoursynth.com/) R66 or later

`trt` requires additional packages:
- [TensorRT](https://developer.nvidia.com/tensorrt) 10.7.0.post1 or later
- [Torch-TensorRT](https://pytorch.org/TensorRT/) 2.6.0 or later

To install the latest stable version of PyTorch and Torch-TensorRT, run:
```
pip install -U packaging setuptools wheel
pip install -U torch torchvision torch_tensorrt --index-url https://download.pytorch.org/whl/cu126 --extra-index-url https://pypi.nvidia.com
```


## Installation
```
pip install -U vsdpir
```

If you want to download all models at once, run `python -m vsdpir`. If you prefer to only download the model you
specified at first run, set `auto_download=True` in `dpir()`.


## Usage
```python
from vsdpir import dpir

ret = dpir(clip)
```

See `__init__.py` for the description of the parameters.
metaidigitstt 0.1.3
Speech Recognition Library
Requires Python: >=3.10

# MetaidigitSTT

MetaidigitSTT is a lightweight Speech-to-Text (STT) recognition module utilizing Groq's Whisper model for high-accuracy transcription. It enables real-time audio recording and transcription using Python.

## Features
- Records audio via microphone and saves it as an MP3 file.
- Uses Groq's Whisper-Large-V3 model for transcription.
- Simple and easy-to-use API.

## Installation

Ensure you have Python 3.10 or higher installed.

### Using Pip
```sh
pip install -r requirements.txt
```

### Required Dependencies
- `ffmpeg`
- `SpeechRecognition`
- `pyaudio`
- `pydub`
- `groq`
- `python-dotenv`

You may need to install `ffmpeg` manually:
```sh
# Ubuntu/Linux
sudo apt install ffmpeg

# macOS
brew install ffmpeg

# Windows
choco install ffmpeg
```

## Usage

### 1. Recording Audio

The `record_audio` function records audio from the microphone and saves it as an MP3 file.

```python
from metaidigitstt import record_audio

record_audio("audio/test.mp3", timeout=20, phrase_time_limit=10)
```

### 2. Transcribing Audio

The `transcribe_with_groq` function transcribes recorded audio using Groq's Whisper model.

```python
from metaidigitstt import transcribe_with_groq

GROQ_API_KEY = "your_api_key_here"
stt_model = "whisper-large-v3"
audio_filepath = "audio/test.mp3"

transcription = transcribe_with_groq(stt_model, audio_filepath, GROQ_API_KEY)
print(transcription)
```

## Environment Variables
Set up your API key in a `.env` file:
```sh
GROQ_API_KEY=your_api_key_here
```

## Packaging & Deployment

To install the package locally:
```sh
pip install metaidigitstt
```

## License
This project is licensed under the MIT License.

## Author
[Suhal Samad](mailto:samadsuhal@gmail.com)
RxInferClient 0.0.1
The official Python library for the RxInfer API
Requires Python: >=3.9

# RxInferClient

A Python client for interacting with RxInfer, a probabilistic programming framework.

> **Note:** This project is currently a work in progress. The implementation is under active development and may undergo significant changes.

## Overview

RxInferClient provides a simple and intuitive interface to work with RxInfer from Python. It allows you to define models, run inference, and process results with a clean API.

## Installation

```bash
pip install rxinferclient
```

## Requirements

- Python 3.9+
- Dependencies are listed in `requirements.txt`

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## License

This project is licensed under the Apache License, Version 2.0 - see the LICENSE file for details.
JsonCreatoor 0.0.1
Json library creator
Requires Python: >=3.10.0

# jsoncreatoor

A library for working with JSON files.

## Installation

```bash
pip install jsoncreatoor
```

# How does the library work?
It's quite simple.

First, we need an empty space with one Python file. After that, we write the code:
```python
import jsoncreatoor
# or for specific parts
from jsoncreatoor import example_json, create_json, json_config
```

Once we import the library, we have access to three functions: `example_json`, `create_json`, and `json_config`.

# Main functionality of the library

`example_json` - creates a file named `data.json` with the following content:
```json
{
    "Example_code": true,
    "Example": false,
    "data": 1,
    "Local": 0
}
```

`create_json` - creates a file with data provided by the user. For example:
```python
from jsoncreatoor import create_json

# Example JSON data
data = {
    "Example_code": true,
    "Example": false,
    "data": 1,
    "Local": 0
}

create_json(data, "file_name", '')  # data uses the variable containing your code
# file_name - you don't need to write file_name.json, just the name; otherwise, it will be file_name.json.json
# directory - if you leave it empty, the file will be created in the same folder as your script
```

`json_config` - creates or overwrites an already existing file. If the file does not exist, it will be created. Example:
```python
from jsoncreatoor import json_config

# Example JSON data
data = {
    "Example_code": true,
    "Example": false,
    "data": 1,
    "Local": 0
}

json_config(data, "file_name", '')  # similar to create_json
```

Good luck!
cuda-selector 0.1.5
A simple tool to select the optimal CUDA device based on memory, power, or utilization.
Requires Python: >=3.6

![PyPI - Version](https://img.shields.io/pypi/v/cuda_selector)
![PyPI - License](https://img.shields.io/pypi/l/cuda_selector)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/cuda_selector)
![PyPI - Downloads](https://img.shields.io/pypi/dm/cuda_selector)

# Auto Cuda Selector

A simple tool to select the optimal CUDA device based on memory, power, temperature, or utilization. It supports fallback to CPU and custom sorting functions. Supports CUDA devices on Linux and MPS devices on macOS. Full documentation be found [here](https://samermakni.github.io/cuda-selector/)

### Install
```bash
pip install cuda-selector
```
### Usage
```python
from cuda_selector import auto_cuda

# Select the CUDA device with the most memory available
device = auto_cuda()

# Select the CUDA device with the lowest power usage
device = auto_cuda('power')

# Select the CUDA device with the lowest GPU utilization
device = auto_cuda('utilization')

# Select the CUDA device with the lowest temperature
device = auto_cuda('temperature')

# Select multiple devices with the most free memory
devices = auto_cuda(n=3)

# Exclude specific devices by their index
devices = auto_cuda(exclude=[0, 1])

# Apply thresholds for power usage and utilization
devices = auto_cuda(thresholds={'power': 150, 'utilization': 70})

# Use a custom ranking function for selecting devices
devices = auto_cuda(sort_fn=lambda d: d['memory_free'] * 0.7 + d['utilization'] * 0.3)
```
artii 1.0.1
A CLI tool to convert images, GIFs, and videos to ASCII
Requires Python: >=3.6

# 🎨 ASCII Art CLI
Convert images, videos, and GIFs to **ASCII art** directly in your terminal!
Supports **color**, **background effects**, and **video/GIF playback**.

## 🚀 Features
✔️ **Image to ASCII conversion** (JPG, PNG, etc.)
✔️ **Video to ASCII playback** (MP4, AVI, etc.)
✔️ **GIF to ASCII animation** (Animated GIF support)
✔️ **Color & background options** (`--color`, `--bg`)
✔️ **Interactive mode** (`-i`) for easy use
✔️ **Docker support** (No dependencies needed)

---

## 📦 Installation

### 🔹 1. Install Locally with Python
Requires **Python 3.7+**
```bash
pip install -r requirements.txt
python ascii_art.py -i
```

### 🔹 2. Run with Docker (No Dependencies Needed)
```bash
docker build -t ascii-art-cli .
docker run --rm -it -v "$(pwd):/app" ascii-art-cli -i
```

---

## 🎥 Usage Examples

### 1️⃣ **Convert an Image to ASCII**
```bash
python ascii_art.py my_image.jpg --color
```

### 2️⃣ **Play a Video as ASCII**
```bash
python ascii_art.py my_video.mp4 --color --fps 15
```

### 3️⃣ **Play an Animated GIF as ASCII**
```bash
python ascii_art.py my_animation.gif --color
```

### 4️⃣ **Interactive Mode (Step-by-Step Selection)**
```bash
python ascii_art.py -i
```

---

## 🛠️ Advanced Options
| Option       | Description                        | Default |
|-------------|------------------------------------|---------|
| `--width`   | Output ASCII width                | `100`   |
| `--color`   | Enable color output               | `False` |
| `--bg`      | Enable background color effects   | `False` |
| `--fps`     | Frame rate for videos             | `30`    |
| `--output`  | Save ASCII output to a file       | `None`  |

Example: Save ASCII output to a file
```bash
python ascii_art.py my_image.jpg --output=ascii_output.txt
```

---

## 🐫 Running Inside Docker
**No Python installation needed!** Just use Docker:

1️⃣ **Build the Docker image**
```bash
docker build -t ascii-art-cli .
```

2️⃣ **Run an image through Docker**
```bash
docker run --rm -it -v "$(pwd):/app" ascii-art-cli samples/vegeta.jpeg --color
```

```bash
docker run --rm -it -v "$(pwd):/app" ascii-art-cli samples/sangoku.png --color
```

3️⃣ **Play a video in ASCII through Docker**
```bash
docker run --rm -it -v "$(pwd):/app" ascii-art-cli samples/countdown.mp4 --fps 60 --color
```

4️⃣ **Play an animated GIF in ASCII through Docker**
```bash
docker run --rm -it -v "$(pwd):/app" ascii-art-cli samples/fusion.gif --color
```

---

## 🤖 Contributing
Feel free to **fork**, create a PR, or submit an issue!

---

## 📝 License
MIT License
hyperiax 2.0.2
Tree traversals using JAX
Requires Python: >=3.8

# Hyperiax: Tree traversals using JAX
<p align="center">
 <img width="300", height="250" src="./docs/figures/hyperiax_logo.png">
</p>

## Introduction

_Hyperiax_ is a framework for tree traversal and computations on large-scale tree. Its primary purpose is to facilitate **efficient message passing** and **operation execution** on large trees. Hyperiax uses [JAX](https://jax.readthedocs.io/en/latest/index.html) for fast execution and automatic differentiation. _Hyperiax_ is currently developed and maintained by [CCEM, UCPH](https://www.ccem.dk/) actively.

Initially, _Hyperiax_ was designed specifically for phylogenetic analysis of biological shape data, particularly enabling statistical inference with continuous time stochastic processes along the edges of the trees. For this purpose, is integrated with [JAXGeometry](https://bitbucket.org/stefansommer/jaxgeometry/src/main/), a computational differential geometry toolbox implemented in [JAX](https://jax.readthedocs.io/en/latest/index.html). However, _Hyperiax_'s messaging system and operations are general, which means that they can be easily adapted for use in other contexts. With minor modifications, _Hyperiax_ can be used for any application where fast tree-level computations are necessary. Included examples cover such cases with inference in Gaussian graphical models, phylogenetic mean computation, and recursive shape matching in binary trees.

## Installation
```bash
# Install Hyperiax directly using pip
pip install hyperiax

# Install Hyperiax from the repository, for the newest version
pip install git+https://github.com/ComputationalEvolutionaryMorphometry/hyperiax.git

# Install Hyperiax for development
git clone git@github.com:ComputationalEvolutionaryMorphometry/hyperiax.git
# or (if you haven't set up ssh)
git clone https://github.com/ComputationalEvolutionaryMorphometry/hyperiax.git
# and go into the directory
cd hyperiax
# and then install by
pip install -e hyperiax[dev]
# and optionally
pip install -e hyperiax[examples]
# to install the dependencies for all the example notebooks
```

## Documentation
- **Usage**: See [Usage](https://computationalevolutionarymorphometry.github.io/hyperiax/usage.html) for different examples of _Hyperiax_.
- __Full API Documentation__: See [Hyperiax API](https://computationalevolutionarymorphometry.github.io/hyperiax/hyperiax.html)

## Todo

## Contribution
Contributions, issues and feature requests are all welcome! Please refer to the [contributing guidelines](./CONTRIBUTION.md) before you want to contribute to the project.

## Contact
If you experience problems or have technical questions, please open an issue. For questions related to the Hyperiax project or CCEM, please contact [Stefan Sommer](mailto:sommer@di.ku.dk).