semvec/pypi-packages huggingface dataset:
dimos-lcm 0.1.2
LCM-Foxglove bridge and message utilities for Dimensional Robotics
Requires Python: >=3.8

# LCM Message Definitions

This repository contains LCM message definitions for the Dimos project and tools to generate those language bindings.

It depends on our [LCM fork](https://github.com/dimensionalOS/lcm) for generation since we introduced some convinience changes to python message definitions.

lcmgen from our lcm fork is conviniently pulled and built by our `flake.nix`

## Generating Bindings

Run `generate.sh` to regenerate all bindings:

```sh
./generate.sh
```

This will:
1. Convert ROS messages to LCM definitions (from `sources/ros_msgs/` to `lcm_types/`)
2. Generate Python bindings (`generated/python_lcm_msgs/`)
3. Generate C++ bindings (`generated/cpp_lcm_msgs/`)
4. Generate C# bindings (`generated/cs_lcm_msgs/`)
5. Generate Java bindings (`generated/java_lcm_msgs/`)
6. Generate Typescript bindings (`generated/ts_lcm_msgs/`)

## Directory Structure

- `sources/` - Source ROS message definitions and conversion tools
- `lcm_types/` - Generated LCM message definitions
- `generated/` - Generated language bindings

## Python Package

This repo is also a Python package and you can install it via `pip install dimos-lcm`
It is not very useful standalone and is meant to be used in conjuction with actual [dimOS](https://github.com/dimensionalOS/dimos)
vsl-ial 0.0.10
Color spaces made reasonable
Requires Python: >=3.10

# VSL Image Appearance Library

Python module for working with color spaces and stuff

## Usage

### Color space conversion:

* Convert from `sRGB` to `libRGB`

```python
from vsl_ial.cs import convert, sRGB, linRGB

convert(sRGB(), linRGB(), color=[0.12412, 0.07493, 0.3093])
```

### Available color spaces

| Function name | Color space description |
| :---          | :--- |
| `XYZ()`       | CIE XYZ |
| `CIExyY()`    | CIE xyY |
| `CIELUV()`    | CIELUV |
| `CIELAB()`    | CIELAB |
| `ProLab()`    | proLab |
| `Oklab()`     | Oklab |
| `ICaCb()`     | ICaCb |
| `ICtCp()`     | ICtCp |
| `JzAzBz()`    | Jzazbz |
| `CAM02LCD()`  | CAM02-LCD |
| `CAM02SCD()`  | CAM02-SCD |
| `CAM02UCS()`  | CAM02-UCS |
| `CAM16LCD()`  | CAM16-LCD |
| `CAM16SCD()`  | CAM16-SCD |
| `CAM16UCS()`  | CAM16-UCS |
| `sRGB()`      | sRGB |
| `linRGB()`    | linear sRGB |
| `LMS()`       | LMS |
| `Opponent()`  | Opponent color space by Zhang and Wandell |
| `PCS23-UCS()` | Uniform Color Space with Advanced Hue Linearity |

### Available measures of the consistency between perceived and computed color differences
* CV
* PF/3
* STRESS
* Mean STRESS
* Group STRESS
* Weighted group STRESS

## Model evaluation

Run
```bash
python -m vsl_ial.eval
```

To get uniformity table

 **<center>group_stress</center>**
|           | COMBVD | BFD-P D65 | BFD-P M | BFD-P C | RIT-DuPont | Witt  | Leeds | Munsell-3.3 |
|-----------|--------|-----------|---------|---------|------------|-------|-------|-------------|
| CAM16-SCD | 0.295  | 0.254     | 0.346   | 0.283   | 0.237      | 0.306 | 0.219 | 0.218       |
| CAM16-UCS | 0.305  | 0.271     | 0.35    | 0.297   | 0.206      | 0.31  | 0.245 | 0.205       |
| CAM16-LCD | 0.339  | 0.311     | 0.372   | 0.366   | 0.214      | 0.372 | 0.292 | 0.217       |
| CAM02-SCD | 0.296  | 0.266     | 0.338   | 0.303   | 0.244      | 0.303 | 0.221 | 0.266       |
| CAM02-UCS | 0.306  | 0.28      | 0.343   | 0.321   | 0.213      | 0.305 | 0.246 | 0.267       |
| CAM02-LCD | 0.339  | 0.318     | 0.366   | 0.404   | 0.223      | 0.366 | 0.296 | 0.333       |
| PCS23-UCS | 0.311  | 0.289     | 0.325   | 0.379   | 0.3        | 0.381 | 0.332 | 0.253       |
| CIELAB    | 0.426  | 0.41      | 0.433   | 0.543   | 0.334      | 0.517 | 0.401 | 0.308       |
| ProLab    | 0.441  | 0.451     | 0.429   | 0.485   | 0.302      | 0.519 | 0.394 | 0.289       |
| Oklab     | 0.471  | 0.515     | 0.424   | 0.416   | 0.318      | 0.452 | 0.45  | 0.132       |
| J<sub>z</sub>A<sub>z</sub>B<sub>z</sub>    | 0.418  | 0.404     | 0.424   | 0.494   | 0.385      | 0.474 | 0.451 | 0.244       |
| IC<sub>a</sub>C<sub>b</sub>     | 0.391  | 0.396     | 0.38    | 0.424   | 0.248      | 0.474 | 0.373 | 0.192       |
| IC<sub>t</sub>C<sub>p</sub>     | 0.463  | 0.481     | 0.441   | 0.636   | 0.423      | 0.559 | 0.397 | 0.34        |

## For module developers

* How to make whl file:

```bash
python -m pip install --upgrade build
python -m build
```


* How to run unit tests:

```bash
python -m unittest
```

* How to run coverage:

```bash
python -m coverage run -m unittest
python -m coverage html
```
wagtail-form-plugins 0.6.0
A set of plugins used to customize and improve the Wagtail form builder in a modular way.
Requires Python: >=3.10
Keywords: wagtail, form, plugins

# Wagtail Form Plugins

A set of plugins used to customize and improve the Wagtail form builder in a modular way.

This project uses Wagtail StreamFields to improve the user experience when creating a form.
This feature was included in a plugin at first, but moving it to a built-in feature allows a better
integration between plugins and Wagtail StreamFields.

Available plugins:

- **conditional fields**: make a field appear or not depending on the value of a previous field;
- **editable**: allow form admins to modify form submissions;
- **emails**: send multiple emails when a form is submitted;
- **file_input**: allow users to send a file via the form;
- **indexed_results**: add an index value in the results (can be used in the templating plugin);
- **label**: add a new _Label_ field type to put subtitles in forms, in order to split it into sections;
- **named_form**: add user value in form sumission, allowing to fill the form only once per user;
- **nav_buttons**: add some buttons for an easier novigation for form admins;
- **templating**: allow to inject variables in field initial values and emails such as the user name, etc;
- **token_validation**: add token-validation process via email, useful for public forms.

Each plugin is supposed to work independently.

## Usage

You add form plugins with class inheritance.
Since there are several classes to extend, a WagtailFormPlugin object can be used for convenience:

```py
from wagtail_form_plugins import plugins

wfp = WagtailFormPlugin(
    plugins.ConditionalFields,
    plugins.Editable,
    plugins.EmailActions,
    plugins.FileInput,
    plugins.IndexedResults,
    plugins.Label,
    plugins.AuthForm,
    plugins.NavButtons,
    plugins.Templating,
    plugins.Validation,
)

class CustomFormSubmission(*wfp.form_submission_classes):
    pass

class CustomFormBuilder(*wfp.form_builder_classes):
    pass

class CustomFormField(*wfp.form_field_classes):
    pass

class CustomSubmissionListView(*wfp.submission_list_view_classes):
    pass

class CustomFormPage(*wfp.form_page_classes):
    pass

class CustomFormFieldsBlock(*wfp.form_block_classes):
    pass

```

See the `demo` project for further understanding and up-to-date usage.

## Installation

This package is [published on pypi](https://pypi.org/project/wagtail_form_plugins/), so typically:

    uv add wagtail_form_plugins

## Contribution

You are welcome to make pull requests to add you own plugins if you think they can be useful for others.
riskit 0.3.0
A library providing implementations of various risk metrics for risk-aware trajectory planning.
Requires Python: >=3.13
Keywords: autonomous systems, risk metrics, robotics, safety, trajectory planning, uncertainty quantification

## RisKit

### Documentation

To build the documentation, you need to install some custom Typst packages locally. You can do that by running:

```bash
typi --project-directory=documents
```

`typi` is available after you've set up the project environment with `uv sync`. Don't forget to activate the virtual environment first.
ebi-pm 0.3.9
Ebi: a stochastic process mining utility
Keywords: process mining, stochastic process mining, business process analysis

Ebi is a tool and library that focuses on stochastic process mining algorithms.
Ebi is available as a command-line utility, as a ProM plug-in and as a Python package.

More information on its use can be found in its [manual.pdf](https://git.rwth-aachen.de/rwth-bpm/rustlibrary/-/raw/main/build/nightly/manual.pdf?ref_type=heads&inline=true).

# How to use from the command line

Ebi can be used as a standalone tool from the command line.
Compiled versions are available on [Ebi's  website](https://ebitools.org).

# How to use from ProM

Ebi can be used as a plug-in of the [ProM framework](\url{https://promtools.org}) on Windows and Linux. 
ProM has limited support for Mac OS X.
		
To install, open the ProM Package Manager and install the \verb=Ebi= package.
Then, a selection of Ebi commands can be run, just as any other ProM plug-in.

The [manual.pdf](https://git.rwth-aachen.de/rwth-bpm/rustlibrary/-/raw/main/build/nightly/manual.pdf?ref_type=heads&inline=true) indicates which commands are available in ProM.

# How to use from Python

1. Install the Ebi-pm package using pip: 

        pip install ebi-pm

1. Then, one can use it as follows:
        
        import pm4py
        import ebi
        # Load a log using PM4Py
        log = pm4py.read_xes("myLog.xes", return_legacy_log_object=True)
        # Load a model as a string
        with open('mymodel.slpn', 'r') as file:
            model = file.read()
        # Call the Ebi function
        result = ebi.conformance_earth_movers_sample(
            log,
            model,
            1000
        )
        print(result)

    The names of the Ebi functions can be found in the [manual.pdf](https://git.rwth-aachen.de/rwth-bpm/rustlibrary/-/raw/main/build/nightly/manual.pdf?ref_type=heads&inline=true).
    
    Please note that for fractional numbers, Ebi returns an array consisting of 1) a 4-decimal approximation, 2) the full numerator, and 3) the full denominator.

# Getting started with development

1. Install Rustup
    https://www.rust-lang.org/tools/install

1. Log out and in again

1. Install Visual Studio Code

1. Install extension 'rust-analyzer' in Visual Studio Code
    - https://code.visualstudio.com/docs/languages/rust

1. Go to the project at https://github.com/BPM-Research-Group/Ebi choose "Clone" and "Visual Studio Code (SSH)", and clone it in Visual Studio Code.

1. To run Ebi, use the terminal of Visual Studio Code to give the command "cargo run --" instead of "Ebi". Everything else is equivalent to the commands mentioned in the manual.
harvestor 0.0.1
Harvest intelligence from any document - AI-powered data extraction and validation
Requires Python: <3.14,>=3.13
Keywords: ai, llm, data-extraction, pdf, document-processing, ocr, anthropic, openai

# 🌾 Harvestor

**AI-powered document data extraction toolkit**

Extract structured data from documents (invoices, receipts, forms) using Claude's vision API. Easily integrate into your Python applications with flexible input options and built-in cost tracking.

> ⚠️ **Early Development**: This project is in active development. Core functionality is working, but many features are still being built.

## What Works Now

- ✅ **Vision API Integration**: Extract data from images (.jpg, .png, .gif, .webp)
- ✅ **Flexible Input**: Accepts file paths, bytes, or file-like objects (like PIL, requests)
- ✅ **Cost Tracking**: Built-in monitoring and limits for API usage
- ✅ **Structured Output**: Returns Pydantic-validated data models that you can define
- 🚧 **Multi-strategy Extraction**: Cost-optimized cascade to reduce api calls (planned)

## Quick Start

```bash
# Install dependencies
uv sync

# Setup environment
cp .env.template .env
# Add your Anthropic API key to .env

# Run a test
uv run python example.py
```

## Basic Usage

```python
from harvestor import harvest

# From file path
result = harvest("invoice.jpg")
print(f"Invoice #: {result.data.get('invoice_number')}")
print(f"Total: ${result.data.get('total_amount')}")
print(f"Cost: ${result.total_cost:.4f}")

# From bytes (e.g., API upload)
with open("invoice.jpg", "rb") as f:
    data = f.read()
result = harvest(data, filename="invoice.jpg")

# From file-like object
from io import BytesIO
buffer = BytesIO(image_data)
result = harvest(buffer, filename="invoice.jpg")

# Display summary output
print(result.to_summary())
```

## Testing

```bash
# Install test dependencies
uv sync --extra dev

# Run tests
make test

# Run with coverage
make test-cov
```

## Requirements

- Python 3.13
- Anthropic API key (for Claude vision API)

## Citation

For testing and evaluation, we are using the following dataset:

> Limam, M., et al. FATURA Dataset. Zenodo, 13 Dec. 2023, https://doi.org/10.5281/zenodo.10371464.

## License

MIT
acoustools 1.0.5
A Full-Stack Python based library for working with acoustic fields for holgraphy
Requires Python: >=3.7

# AcousTools

<!-- [![PyPI - Version](https://img.shields.io/pypi/v/acoustools.svg)](https://pypi.org/project/acoustools)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/acoustools.svg)](https://pypi.org/project/acoustools) -->

A Full-Stack Python based library for working with acoustic fields for holgraphy. Developed using PyTorch, AcousTools uses PyTorch Tensors to represent points, acoustic fields and holograms to enable development of new algorithms, applications and acoustic systems. As a full-stack solution, Acoustools is able to implement each stage of development making it a single point of call.

See [Here](https://github.com/JoshuaMukherjee/AcousticExperiments/tree/main/AcousTools_Examples) for examples of code using AcousTools.
The [Preprint of AcousTools can be found on arXiv](https://arxiv.org/abs/2511.07336)

-----

**Table of Contents**

- [Installation](#installation)
- [License](#license)
- [Docs](#documentation)

## Installation


Optionally create a virtual environment to install AcousTools into <br>
Optionally install the correct version of [PyTorch](https://pytorch.org/get-started/locally/) <br>

Run 
```console
pip install acoustools
```
Or visit [AcousTools' on PyPi](https://pypi.org/project/acoustools/)

### Local Installation

Clone the repo and then run

```console
pip install -r <path-to-clone>/requirements.txt
pip install -e <path-to-clone>/acoustools/ --config-settings editable_mode=strict
```

Use `python<version> -m` before the above commands to use a specific version of python.

where `<path-to-clone>` is the local location of the repository 

## Documentation

#### Documentation can be seen [Here](https://joshuamukherjee.github.io/AcousTools/src/acoustools.html)

Or to view the documentation for AcousTools locally, firstly install pdoc:
```console
pip install pdoc
```
Then run pdoc on AcousTools to create a locally hosted server containing the documentation
```console
python -m pdoc <path-to-clone>/acoustools/ --math
```

See [Here](https://github.com/JoshuaMukherjee/AcousticExperiments/tree/main/AcousTools_Examples) for examples of code using AcousTools.


## AcousTools Basics

AcousTools represents data as `torch.Tensors`. A point is represented as a tensor where each column represents a (x,y,z) point. Groups of points can also be grouped into batches of points for parallel computation and so have a shape (B,3,N) for B batches and N points.

Ultrasound waves can be focused by controlling many sources such that at a given point in space all waves arrive in phase and therefore constructivly interfere. This can be done in a number of ways (`acoustools.Solvers`). This allows for applications from high speed persistance-of-vision displays to haptic feedback and non-contact fabrication. 

## License

`acoustools` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
gdata-vaas 6.0.4
G DATA Verdict-as-a-Service Python client
Requires Python: >=3.10

# gdata-vaas

An SDK to easily utilize G DATA VaaS.

_Verdict-as-a-Service_ (VaaS) is a service that provides a platform for scanning files for malware and other threats. It allows easy integration in your application. With a few lines of code, you can start scanning files for malware.

## What does the SDK do?

It gives you as a developer a functions to talk to G DATA VaaS. It wraps away the complexity of the API into 3 basic functions.

### for_sha256

If you calculate the sha256 for a file, you can request that sha256 against G DATA VaaS. It's the fastest way to get a verdict from our service.

### for_url

If you want to request if a file behind a URL is safe, you can specify the URL as well. Depending on the file size, the duration for the analysis can vary.

### for_file

You can also ask for a file itself. You will still get the benefit of a fast verdict via Sha256 because the SDK will do that for you first. But additionally, if we don't know the file, the file will get uploaded and (automatically) analyzed by us.

## What do the Verdicts look like

The verdicts are simple. They are either
- `Clean`: The scanners didn't find anything malicious.
- `Malicious`: The scanners found something malicious.
- `Unknown`: We don't know the file hash yet. A scan is then performed for each except `for_sha256` function.
- `Pup`: Potentially Unwanted Program (Adware, Spyware, etc.)

The scan functions will return the following dict:
```python
{
    "Sha256": "<Sha256>",
    "Guid": "<Guid>",
    "Verdict": <"Clean"|"Malicious"|"Unknown"|"Pup">,
    "Detection": "<Name of the detected malware>",
    "FileType": "<FileType>",
    "MimeType": "<MimeType>"
}
```

## How to use

### Installation

```bash
pip3 install gdata-vaas
```

gdata-vaas requires Python 3.12+.

### Import

```python
from vaas import Vaas, ClientCredentialsGrantAuthenticator
```

### Request a verdict

Authentication & Initializing:
```python
authenticator = ClientCredentialsGrantAuthenticator(
    CLIENT_ID,
    CLIENT_SECRET,
    TOKEN_URL,
    SSL_VERIFICATION
)
vaas = Vaas(authenticator=authenticator)
```

The Vaas instance can and should be used for multiple requests.

Verdict Request for SHA256:
```python
sha256 = "275a021bbfb6489e54d471899f7db9d1663fc695ec2fe2a2c4538aabf651fd0f"
verdict = await vaas.for_sha256(sha256)
```

Verdict Request for a file:
```python
path = "/path/to/file"
verdict = await vaas.for_file(path)
```

Verdict Request for a URL:
```python
url = "https://www.gdatasoftware.com/oem/verdict-as-a-service"
verdict = await vaas.for_url(url)
```

## <a name="interested"></a>I'm interested in VaaS

You need credentials to use the service in your application. If you are interested in using VaaS, please [contact us](mailto:oem@gdata.de).

## Developing with Visual Studio Code

Every single SDKs also includes [Devcontainer](./devcontainer/). If you use the [Visual Studio Code Dev Containers extension](https://code.visualstudio.com/docs/devcontainers/containers), you can run the code in a full-featured development environment.
xivgear-wrapper-Cedohran 0.0.3
Small python wrapper for xivgear API (and a bit of xivapi)
Requires Python: >=3.9

# xivgear-python-wrapper
A python wrapper for the xivgear API, with additional info provided by xivapi.

Relevant docs:

https://xivgear.app/docs/

https://v2.xivapi.com/docs/welcome/

## How to use
Install using pip:
```
pip install xivgear-wrapper-Cedohran
```

Examples in [example.py](https://github.com/Cedohran/xivgear-python-wrapper/blob/main/src/xivgear_wrapper_Cedohran/example.py).