semvec/pypi-packages huggingface dataset:
label-studio-brush-rle-rs 0.1.1
Rust implementation of run-length encoding for brush masks in Label Studio for speed.
Requires Python: >=3.8

# label-studio-brush-rle-rs

[![CI](https://github.com/teepoy/label-studio-brush-rle-rs/actions/workflows/CI.yml/badge.svg)](https://github.com/teepoy/label-studio-brush-rle-rs/actions/workflows/CI.yml)

Speedup decode_rle (~100x) and encode_rle (~3x) by put it in rust extension.

A community-maintained Rust acceleration layer for Label Studio's brush RLE encoder/decoder. It mirrors the reference implementation that ships with Label Studio while delivering faster encode/decode routines via PyO3 bindings.

## Installation

```bash
pip install label-studio-brush-rle-rs
```

The wheel bundles a native extension compiled from Rust. No additional system packages are required on supported platforms.

## Usage

The package exposes the same helpers as the original converter module:

```python
import numpy as np
from label_studio_brush_rle_rs import decode_rle, encode_rle

# Encode a flattened RGBA mask (each pixel repeated 4 times)
mask = (np.random.random((32, 32)) > 0.5).astype(np.uint8) * 255
flattened = np.repeat(mask.ravel(), 4)
encoded = encode_rle(flattened)

# Decode back to verify round-trip
decoded = decode_rle(encoded)
assert np.array_equal(decoded, flattened)
```

The functions fall back to the original Python implementation when the extension is unavailable, so you can safely import them in environments without a local build.
django-pgallery 0.12
Photo gallery app for PostgreSQL and Django.
Requires Python: >=3.10

===============
django-pgallery
===============

.. image:: https://requires.io/github/zsiciarz/django-pgallery/requirements.svg?branch=master
    :target: https://requires.io/github/zsiciarz/django-pgallery/requirements/?branch=master
    :alt: Requirements Status

.. image:: https://img.shields.io/pypi/v/django-pgallery.svg
    :target: https://pypi.python.org/pypi/django-pgallery/
    :alt: Latest PyPI version

.. image:: https://img.shields.io/pypi/dm/django-pgallery.svg
    :target: https://pypi.python.org/pypi/django-pgallery/
    :alt: Number of PyPI downloads

.. image:: https://img.shields.io/pypi/pyversions/django-pgallery.svg
    :target: https://pypi.python.org/pypi/django-pgallery/
    :alt: Supported Python versions

.. image:: https://img.shields.io/pypi/wheel/django-pgallery.svg
    :target: https://pypi.python.org/pypi/django-pgallery/
    :alt: Wheel Status

.. image:: https://travis-ci.org/zsiciarz/django-pgallery.svg?branch=master
    :target: https://travis-ci.org/zsiciarz/django-pgallery

.. image:: https://coveralls.io/repos/zsiciarz/django-pgallery/badge.png?branch=master
    :target: https://coveralls.io/r/zsiciarz/django-pgallery?branch=master


Photo gallery app for Django using PostgreSQL-specific goodies.

Overview
========

This is yet another Django app for creating and managing photos and photo
galleries, but with a PostgreSQL twist. It was made to show off some of the
advanced PostgreSQL features, therefore it is deliberately not portable
to other RDBMS-es.

Features
========

 * image tagging with array data type
 * storing EXIF data in HStore fields

Resources
---------

 * `Issue tracker <https://github.com/zsiciarz/django-pgallery/issues>`_

Author
======

 * Zbigniew Siciarz (zbigniew at siciarz dot net)

License
=======

This work is released under the MIT license. A copy of the license is provided
in the LICENSE file.
infinyon-coagent-client 0.6.0
Add your description here
Requires Python: >=3.10

# coagent-client

A Python client library for interacting with Coagent services.

## Installation

```bash
pip install infinyon-coagent-client
```

## Usage

```python
client = CoagentClient()

# Session-based logging with structured data
client.log_session_start("session123", "Hello world", prompt_number=1)
client.log_llm_response("session123", "Hi there", 1, 1,
    input_tokens=10, output_tokens=5)
client.log_error("session123", 1, 1, "Connection failed",
    error_type="network")
```

## Development

This package is part of the coagent-python-client workspace.
civic-digital-twins 0.5.0
Civic-Digital-Twins Modeling Framework
Requires Python: >=3.11.0

# Civic-Digital-Twins Modeling Framework

[![Build Status](https://github.com/fbk-most/civic-digital-twins/actions/workflows/test.yml/badge.svg)](https://github.com/fbk-most/civic-digital-twins/actions) [![codecov](https://codecov.io/gh/fbk-most/civic-digital-twins/branch/main/graph/badge.svg)](https://codecov.io/gh/fbk-most/civic-digital-twins) [![PyPI version](https://img.shields.io/pypi/v/civic-digital-twins.svg)](https://pypi.org/project/civic-digital-twins/) [![Python Versions](https://img.shields.io/pypi/pyversions/civic-digital-twins.svg)](https://pypi.org/project/civic-digital-twins/) [![License](https://img.shields.io/pypi/l/civic-digital-twins.svg)](https://pypi.org/project/civic-digital-twins/)

This repository contains a Python package implementing a Civic-Digital-Twins
modeling framework. The framework is designed to support defining digital
twins models and evaluating them in simulated environment with varying
contextual conditions. We develop this package at [@fbk-most](
https://github.com/fbk-most), a research unit at [Fondazione Bruno Kessler](
https://www.fbk.eu/en/).

*Note: this package is currently in an early development stage.*

## Installation

The package name is `civic-digital-twins` on [PyPi](
https://pypi.org/project/civic-digital-twins/). Install
using `pip`:

```bash
pip install civic-digital-twins
```

or, using `uv`:

```bash
uv add civic-digital-twins
```

The main package name is `civic_digital_twins`:

```Python
import civic_digital_twins
```

or

```Python
from civic_digital_twins import dt_model
```

## Minimum Python Version

Python 3.11.

## API Stability Guarantees

The package is currently in an early development stage. We do not
anticipate breaking APIs without a good reason to do so, yet, breaking
changes may occur from time to time. We generally expect subpackages
within the top-level package to change more frequently.

## Development Setup

We use [uv](https://astral.sh/uv) for managing the development environment.

To get started, run:

```bash
git clone https://github.com/fbk-most/civic-digital-twins
cd civic-digital-twins
uv venv
source .venv/bin/activate
uv sync --dev
```

We use [pytest](https://docs.pytest.org/en/stable/) for testing. To run
tests use this command (from inside the virtual environment):

```bash
pytest
```

Each pull request is automatically tested using GitHub Actions. The workflow
is defined in [`.github/workflows/test.yml`](.github/workflows/test.yml).

## Updating Dependencies

```bash
uv self update
uv sync --upgrade
```

## Releasing

1. Make sure the version number in `pyproject.toml` is correct.

2. Make sure you are outside the virtual environment.

3. Make sure `python3-hatchling` is installed (`sudo apt install python3-hatchling`).

4. Make sure `twine` is installed (`sudo apt install twine`).

5. Build the package using `python3 -m hatchling build`.

6. Check whether the package is okay using `twine check dist/*`.

7. Upload the package to PyPI using `twine upload dist/*`.

## License

```
SPDX-License-Identifier: Apache-2.0
```
eiquadprog 1.3.0
C++ implementations of the algorithm of Goldfarb and Idnani for the solution of a (convex) QP
Requires Python: >=3.8

# eiquadprog

[![Pipeline status](https://gitlab.laas.fr/stack-of-tasks/eiquadprog/badges/master/pipeline.svg)](https://gitlab.laas.fr/stack-of-tasks/eiquadprog/commits/master)
[![Coverage report](https://gitlab.laas.fr/stack-of-tasks/eiquadprog/badges/master/coverage.svg?job=doc-coverage)](https://gepettoweb.laas.fr/doc/stack-of-tasks/eiquadprog/master/coverage/)
[![pre-commit.ci status](https://results.pre-commit.ci/badge/github/stack-of-tasks/eiquadprog/master.svg)](https://results.pre-commit.ci/latest/github/stack-of-tasks/eiquadprog)

This repo contains different C++ implementations of the algorithm of Goldfarb and Idnani for the solution of a (convex) Quadratic Programming problem by means of a dual method.

The problem is in the form:
 min 0.5 * x G x + g0 x
 s.t.
 CE^T x + ce0 = 0
 CI^T x + ci0 >= 0

There are 3 implementations:
- `eiquadprog.hpp`: the original C++ implementation
- `eiquadprog-fast.hpp`: an improved version employing a wrapper, avoiding dynamic memory allocation
- `eiquadprog-rt.hpp`: similar to the above, it employs fixed-size Eigen vectors. This requires the problem dimensions to be known at compile time and is recommended only for small problems.

Please refer to the unit tests for examples of usage.

## Authors

[Eiquadprog](https://github.com/stack-of-tasks/eiquadprog) was created at LAAS-CNRS by Gabriele Buondonno, based on
parts from [TSID](https://github.com/stack-of-tasks/tsid) by Andrea Del Prete.

This work was based on previous libraries:
- [QuadProg++](https://github.com/liuq/QuadProgpp), Copyright (C) 2007-2016 Luca Di Gaspero, MIT License.
- [uQuadProg](https://github.com/fx74/uQuadProg), Copyright (C) 2006 - 2017 Angelo Furfaro, LGPL v3.
- [eiquadprog.hpp](http://www.cs.cmu.edu/~bstephe1/eiquadprog.hpp), Copyright (2011) Benjamin Stephens, GPL v2.
- [quadprog++](https://gitlab.inria.fr/alta/alta/blob/3c11d5a4ed6cd15ed39f938a1da1aecad1a4b31e/external/quadprog++/QuadProg++.cc)
  Copyright (C) 2014-2015 Gael Guennebaud, LGPL v3.
soldet 1.0.0
A package for solitonic feature detection in absorption images of Bose-Einstein condensates, with wider use for cold atom image analysis.
Requires Python: >=3.7

# SolDet
SolDet is an object-oriented package for solitonic fearture detection in absorption images of Bose-Einstein condensates, with wider use for cold atom image analysis. 
It is featured with classifier, object detector, and Mexican hat metric methods. 
Technical details are explained in https://arxiv.org/abs/2111.04881.

The dataset used to prepare SolDet is currently being prepared for public release. Until then, it can be requested from [Justyna Zwolak](jpzwolak@nist.gov).
Note that SolDet assumes the following folder structure for the data files:

```
SolDet
|- ...
|- data
    |- data_files
        |- class-0
        |- class-1
        |- ...
        |- class-9
    |- data_info
        |- data_roster.csv
        |- data_roster.npy
|- ...
```

## Installation
(1) (Recommended) Create an Anaconda environment with python 3.7, then activate it
```
conda create -n SDenv python=3.7
conda activate SDenv
```

(2) Clone this repository and change directory to it
```
cd your_directory/SolDet
```
Replace <em>your_directory</em> with your root directory.

(3) You can install SolDet by running:
```
python setup.py build  
python setup.py install
```

## Getting started

All features of SolDet are integrated in the `SolitonDetector` object. To start using SolDet:
```
from soldet import SolitonDetector
sd = SolitonDetector()
```

## Import data

To import labeled dataset, use `load_data` method:
```
sd.load_data(directory='directory_str', data_key={'train':0.9, 'test':0.1}, data_type='labeled') 
```

To import unlabeled dataset, use
```
sd.load_data(directory='directory_str', data_key='new', data_type='unlabeled') 
```

## Train models

To train an ML model, use use `train_ML` method:
```
sd.train_ML(model_key='object_detector', data_key='train', save=save_str)
```
where `model_key` can be `'object_detector'` or `'classifier'`.

To train the physics-based model, use `define_PIE_classifier` method:
```
sd.define_PIE_classifier(data_key='train', save=save_str)
```
to define a phycics-informed exictiation (PIE) classifier. 
Use `train_quality_estimator` method:
```
sd.train_quality_estimator(data_key='train', save=save_str) 
```
to train a quality estimator.

## Predict and label with pre-trained models

To predict new or test data, use `predict` method:
```
pred = sd.predict(data_key='test', model_key=model_key)
```
where `model_key` can be `'classifier'`, `'object_detector'`, `'PIE_classifier'`, or `'quality_estimator'`. 

To filter predicted data with certain criteria, use `pipeline` method:
```
checks ={'classifier_labels':[1,2], 
         'object_detector_positions_length':[1,2,3],
         'PIE_types':[0], 
         'quality_estimates_bounds':[0.3,1]}
refined_data = sd.pipeline(data_key='new', new_data_key='refined', checks=checks)
```
zyte-common-items 0.29.0
Item definitions for Zyte API schema
Requires Python: >=3.9

=================
zyte-common-items
=================

.. image:: https://img.shields.io/pypi/v/zyte-common-items.svg
   :target: https://pypi.python.org/pypi/zyte-common-items
   :alt: PyPI Version

.. image:: https://img.shields.io/pypi/pyversions/zyte-common-items.svg
   :target: https://pypi.python.org/pypi/zyte-common-items
   :alt: Supported Python Versions

.. image:: https://github.com/zytedata/zyte-common-items/workflows/tox/badge.svg
   :target: https://github.com/zytedata/zyte-common-items/actions
   :alt: Build Status

.. image:: https://codecov.io/github/zytedata/zyte-common-items/coverage.svg?branch=master
   :target: https://codecov.io/gh/zytedata/zyte-common-items
   :alt: Coverage report

.. description starts

``zyte-common-items`` is a Python 3.9+ library of item_ and `page object`_
classes for web data extraction that we use at Zyte_ to maximize opportunities
for code reuse.

.. _item: https://docs.scrapy.org/en/latest/topics/items.html
.. _page object: https://web-poet.readthedocs.io/en/stable/
.. _Zyte: https://www.zyte.com/

.. description ends

* Documentation: https://zyte-common-items.readthedocs.io/en/latest/
* License: BSD 3-clause
llmdata 0.1.0
rubrics
Requires Python: >=3.13
Keywords: rubrics, grading, eval

# Rubrics

A Python library for managing rubrics with criterion rules.

## Installation

```bash
pip install rubrics
```

## Usage

```python
from rubrics import CriterionRule, RubricService

# Create a criterion rule
rule = CriterionRule(
    weight=1.0,
    requirement="Must meet the specified criteria"
)

# Use the rubric service
service = RubricService()
```

## Features

- Define criterion rules with weights and requirements
- Manage rubrics for evaluation and assessment
- Built with Pydantic for robust data validation

## Requirements

- Python 3.13 or higher
- pydantic >= 2.0.0

## Development

This package is built using the [uv](https://github.com/astral-sh/uv) build backend.

## License

MIT License - see LICENSE file for details.
pelmesha 0.4.0
A package for proccesing and aligning peaklist Mass-spectrometry imaging data from .imzml files
Requires Python: >=3.8

# Package pelmesha

`pelmesha` (Peak Extraction Library for Mass spectrometry Enhanced by Statistical High-throughput Analysis) is a Python package that allows users to process Mass Spectrometry Imaging (MSI) data from imzml files. It provides several features, including:
1) Conversion of raw imzml data to the hdf5 format (function `imzml2hdf5` from module `pspectra`)
2) Processing of mass spectra (function `Raw2proc` from module `pspectra`)
3) Creation of peaklists from the data (functions `proc2peaklist` and `Raw2peaklist` from module `pspectra`)
4) Generation of a feature matrix from a single image's peaklist by grouping peaks (function `Pgrouping_KD` from module `pfeats`)
5) Generation of a feature matrix for multiple images from the peaklists of each image (function `Roi_Pgrouping_KD` from module `pfeats`)

The processing of mass spectra includes several steps:
- **Data resampling** — This process allows you to bring data to a uniform scale between points on the `mz` and to a single scale on the `mz`.
- **Alignment of spectra relative to reference peaks** using the [`msalign`](https://github.com/lukasz-migas/msalign) tool. It should be noted that `msalign` does a worse job with non-continuous and non-uniform data, so it is strongly recommended to perform a resampling process before using it. Also `msalign` is modified in this package for correct work with other steps.
- **Baseline correction** using the [pybaselines](https://pybaselines.readthedocs.io) package.
- **Smoothing** — based on code snippets from the [mMass](https://github.com/xxao/mMass) library, which provide smoothing using the moving average, Gaussian, and Savitsky-Goley algorithms.
- **Peak-picking** — peaks in the spectrum are searched and filtered.

In the mass spectra in the image, there is a slight difference in the peak values, even after alignment during processing. To further analyze these spectra, it will be necessary to group the peaks based on their relative positions and create a feature matrix as a result.

The `Pgrouping_KD` and `Roi_Pgrouping_KD` functions combine the wandering peak values from signals in mass spectra into a single `mz` value based on their kernel density estimation. This is achieved by determining the centers around which the peak values are located.

To ensure accurate results, high-quality bandwidth selection is required. This can be done manually or automatically. The probability density is estimated using the FFTKDE function from the [kdepy package](https://github.com/tommyod/KDEpy), which is extremely fast and uses Fourier transforms for calculation.
colabfit-mcp 0.0.3
A suite of MCP tools for interacting with the ColabFit database
Requires Python: >=3.10
Keywords: machine learning, interatomic potentials, MCP, model context protocol

# colabfit-mcp

An MCP server for interacting with the [ColabFit](https://materials.colabfit.org) database.

## Installation
Download source code:
```
git clone https://github.com/colabfit/colabfit-mcp.git
```
Make sure the mcp package is installed.
```
pip install mcp[cli]
```
Modify your Claude configuration file.
Navigate to Settings &rarr; Developer &rarr; Edit Config.
Your config file should look something like:
```
    {
    "mcpServers": {
        "colabfit-mcp": {
        "command": "<path to environment's mcp command>",
        "args": [
            "run",
            "<download-location>/colabfit-mcp/colabfit_mcp.py>"
        ]
        }
    }
        }
```

## Functionality
Currently, this MCP server will allow clients to query the online ColabFit database and download its dataset files.

## License
The ColabFit Tools package is copyrighted by the Regents of the University of
Minnesota. It can be freely used for educational and research purposes by
non-profit institutions and US government agencies only. Other organizations are
allowed to use the ColabFit Tools package only for evaluation purposes, and any
further uses will require prior approval. The software may not be sold or
redistributed without prior approval. One may make copies of the software for
their use provided that the copies, are not sold or distributed, are used under
the same terms and conditions. As unestablished research software, this code is
provided on an "as is'' basis without warranty of any kind, either expressed or
implied. The downloading, or executing any part of this software constitutes an
implicit agreement to these terms. These terms and conditions are subject to
change at any time without prior notice.

[mcp-name: io.github.colabfit/colabfit-mcp]: #
smarttext 0.1.0
An intelligent text analysis library for Python
Requires Python: >=3.8

﻿# SmartText ??

SmartText - Python üçün agilli m?tn analiz kitabxanasidir.

## ?? Qurasdirma
pip install smarttext

## ?? Istifad?
from smarttext import analyze

text = "Python is a powerful programming language. It is easy to learn!"
analyze(text)
core-datetime 2.0.0
This project/library contains common elements related to date & time...
Requires Python: >=3.9

core-datetime
===============================================================================

This project/library contains common elements related to date & time...

===============================================================================

.. image:: https://img.shields.io/pypi/pyversions/core-datetime.svg
    :target: https://pypi.org/project/core-datetime/
    :alt: Python Versions

.. image:: https://img.shields.io/badge/license-MIT-blue.svg
    :target: https://gitlab.com/bytecode-solutions/core/core-datetime/-/blob/main/LICENSE
    :alt: License

.. image:: https://gitlab.com/bytecode-solutions/core/core-datetime/badges/release/pipeline.svg
    :target: https://gitlab.com/bytecode-solutions/core/core-datetime/-/pipelines
    :alt: Pipeline Status

.. image:: https://readthedocs.org/projects/core-datetime/badge/?version=latest
    :target: https://readthedocs.org/projects/core-datetime/
    :alt: Docs Status

.. image:: https://img.shields.io/badge/security-bandit-yellow.svg
    :target: https://github.com/PyCQA/bandit
    :alt: Security

|

Execution Environment
---------------------------------------

Install libraries
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

.. code-block:: shell

    pip install --upgrade pip
    pip install virtualenv
..

Create the Python Virtual Environment.
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

.. code-block:: shell

    virtualenv --python={{python-version}} .venv
    virtualenv --python=python3.11 .venv
..

Activate the Virtual Environment.
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

.. code-block:: shell

    source .venv/bin/activate
..

Install required libraries
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

.. code-block:: shell

    pip install .
..

Optional libraries
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

.. code-block:: shell

    pip install '.[dev]'
..

Check tests and coverage
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

.. code-block:: shell

    python manager.py run-tests
    python manager.py run-coverage
..