semvec/pypi-packages huggingface dataset:
c3p 0.5.0
CHEBI Classification Programs
Requires Python: <4.0,>=3.9

# C3PO: CHEBI Classification Programs Ontology

Learning classification programs to categorize SMILES strings into [CHEBI](https://www.ebi.ac.uk/chebi/) classes.

![logo](docs/assets/c3p-small.png)

- Documentation: [c3p docs](https://chemkg.github.io/c3p/)
- [Slides](https://docs.google.com/presentation/d/1VJvRptWu6FhTTmZGM4X3ymbxn9JwYPWDUp9djfMfDao/edit#slide=id.p)

## Usage

```bash
pip install c3p
c3p -x "CC1=CC=C(C=C1)C1=C(C#N)C2=NC3=CC=CC=C3N2C(N)=C1C#N"
```

## Learning Programs

All code in Notebook

Example [generated programs](c3p/programs/)

## Guide to paper
moviecolor 2.0.0
Generate a 'Moviebarcode' of a video using ffmpeg with real-time progress interface.
Requires Python: >=3.8
Keywords: moviebarcode, movie, barcode

# MovieColor

Create a "MovieBarcode" using average color of each frame as bars:

***Example: John Wick Movie***

![John Wick normal](https://raw.githubusercontent.com/AsaadMe/MovieColor/master/doc/johnwicknormal.jpg)

or using shrinked frames as bars (with `--alt` argument):

![John Wick alt](https://raw.githubusercontent.com/AsaadMe/MovieColor/master/doc/johnwickalt.jpg)

## Installation:

Install with [uv](https://docs.astral.sh/uv/):
```
uv tool install moviecolor
```
Or clone the project and use `uv run moviecolor`.

*\* Make sure you have [ffmpeg](https://www.ffmpeg.org/) installed.*

## Usage:

Run it with:
```
moviecolor input.mp4 [--alt] [--help]
```

or without installing:
```
uvx moviecolor input.mp4 [--alt] [--help]
```

>-a , --alt: instead of using average color, use shrinked frames


![Usage](https://raw.githubusercontent.com/AsaadMe/MovieColor/master/doc/usage.gif)
sklearn-freezer 0.1.0
Utility package for compiling scikit-learn classifiers for faster single-sample inference
Requires Python: >=3.10

# Sklearn-Freezer

High-performance scikit-learn classifier compilation for ultra-fast single-sample inference.

## Overview

Sklearn-Freezer compiles scikit-learn classifiers' `predict` or `predict_proba` methods into optimized implementations, dramatically improving single-sample prediction performance for real-time applications.

**Disclaimer:** This is a simple optimization created to address performance bottlenecks from iterative scikit-learn model calls. The implementation is naive with limited model support. Currently only `predict_proba` for binary classification of `RandomForestClassifier` and `DecisionTreeClassifier` are supported.

## Compilation Backends

- **Python**: Pure Python implementation (baseline)
- **Cython**: Cython-compiled implementation (significant speedup)
- **C**: Native C extension (maximum speed)

## Installation

```bash
# Basic installation
pip install sklearn-freezer

# With optional backends
pip install sklearn-freezer[cython]  # Cython backend
pip install sklearn-freezer[c]       # C backend
pip install sklearn-freezer[all]     # All backends
```

## Quick Start

```python
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification
from sklearn_freezer import compile_predict_proba

# Train and compile model
X, y = make_classification(n_samples=1000, n_features=4, random_state=42)
clf = RandomForestClassifier(random_state=42).fit(X, y)
compiled_func = compile_predict_proba(clf, backend="c")

# Fast single-sample prediction
probability = compiled_func(*X[0])
```

## Performance

The benchmark compares five prediction approaches:

1. **Iterative clf.predict_proba**: Individual `clf.predict_proba([sample])` calls
2. **Compiled Python/Cython/C**: Using compiled backends
3. **Batch clf.predict_proba**: Single `clf.predict_proba(all_samples)` call

Performance ordering: iterative single-sample calls < compiled functions < batch processing.

Run benchmark: `python example/benchmark.py`

## Requirements

- Python 3.10+
- scikit-learn

**Optional:** `cython`, `setuptools`
homeseer-client 0.1.2
A thin wrapper around the Homeseer HTTP JSON API
Requires Python: >=3.8

# homeseer-python-client

A thin wrapper around the Homeseer HTTP JSON API

## Usage

```bash
pip install homeseer-client
```

```python
from homeseer_client import Homeseer

# Create a client instance
client = Homeseer(host="192.168.1.100", username="admin", password="password")

# Use the client to interact with your HomeSeer system
client.get_locations()

client.get_events()

client.get_control(ref=None)

client.get_status(
      ref=None,
      location1=None,
      location2=None,
      compress=False,
      everything=False
    )

client.control_device_by_value(ref, value)

client.control_device_by_label(ref, label)
```

## Development

```
 Choose a make command to run

  init      initialize a new python project
  install:  add a new package (make install <package>), or install all project dependencies from piplock.txt (make install)
  start     run local project
```

Generated by https://github.com/jritsema/cookiecutter-python
wagtail-font-awesome-svg 2.0
Font Awesome 7 icons as SVG for Wagtail
Requires Python: >=3.8

# Wagtail Font Awesome SVG

Add [Font Awesome v7](https://fontawesome.com/icons?d=gallery&m=free) SVG icons to your Wagtail project.

## Install

```sh
pip install wagtail-font-awesome-svg
```

Add `wagtailfontawesomesvg` to your installed apps.

```python
INSTALLED_APPS = [
    'wagtailfontawesomesvg',
]
```

## Usage

This is an [overview of available icons](https://fontawesome.com/v6/icons?m=free&d=gallery). 
Choose an icon and add it via your `wagtail_hooks.py`:

```python
from wagtail import hooks

@hooks.register("register_icons")
def register_icons(icons):
    return icons + [
        'wagtailfontawesomesvg/brands/facebook.svg',
        'wagtailfontawesomesvg/regular/face-laugh.svg',
        'wagtailfontawesomesvg/solid/yin-yang.svg',
        ...
    ]
```
django-simple-ordering 1.0.2
Simple Integer-based Ordering for Django Models
Requires Python: >=3.9

## Django Simple Ordering

A package for adding simple integer-based ordering to your Django models.

### Installation

Run the following command to install `django-simple-ordering` package.

`pip install django-simple-ordering`

### Usage

Follow the below steps to add ordering to your models:

1. Make sure `django_simple_ordering` and `django_object_actions` exist
   in your Django project `INSTALLED_APPS` setting. This is because this
   package relies on the [django-object-actions](https://github.com/crccheck/django-object-actions/)
   package for implementing changelist actions.

```python
INSTALLED_APPS = [
    # Django Applications ...

    "django_object_actions",
    "django_simple_ordering",

    # Your Applications ...
]
```

2. Add the `SimpleOrderingModelMixin` to your model:

```python
from django.db import models

from django_simple_ordering.models import SimpleOrderingModelMixin


class Book(SimpleOrderingModelMixin, models.Model):
    title = models.CharField(max_length=100, unique=True)

    class Meta(SimpleOrderingModelMixin.Meta):
        verbose_name = "book"
        verbose_name_plural = "books"
```

3. Add the `SimpleOrderingModelAdminMixin` to your model admin:

```python
from django.contrib import admin

from django_simple_ordering import SimpleOrderingModelAdminMixin


@admin.register(Book)
class BookAdmin(SimpleOrderingModelAdminMixin, admin.ModelAdmin):
    list_display = ("title",)
```
shared-utils-ems 4.2.0
A shared utility library for event management system based on microservices architecture.

# Shared Library Approach in Microservices  

## Why Use a Shared Library?  

In a microservices architecture, multiple services often need **common functionalities** such as logging, error handling, authentication, and utility functions. Instead of duplicating code across services, we use a **shared library** to:  

**Reduce Code Duplication** : Avoid repeating the same logic in every service.  
**Ensure Consistency** : Standardized utilities across all services.  
**Simplify Maintenance** : Fix issues or update features in one place.  
**Improve Scalability** : Microservices remain lightweight and focused.  
**Enhance Deployment** : Easier to manage updates and dependencies.  


## Installation  

To install the shared library in your microservices, run:  

```sh
pip install shared-utils
```

Or specify it in your `requirements.txt`:  

```
shared-utils>=1.0.0
```

## Usage  

Inside any microservice, import and use the shared utilities:  

```python
from shared_utils.logging import setup_logger

logger = setup_logger(__name__)
logger.info("Shared utilities are working!")
```

## Updating `shared_utils`
If a new feature or bug fix is added to `shared_utils`, follow these steps:

1. **Modify the code**: Implement your changes in `shared_utils`.
2. **Update version**: Change the version in `setup.py` (e.g., `1.0.1` to `1.0.2`).
3. **Build the package**:

   ```sh
   python setup.py sdist bdist_wheel
   ```
4. **Publish to PyPI**:

   ```sh
   twine upload dist/*
   ```
5. **Upgrade in services**:

   ```sh
   pip install --upgrade shared-utils
   ```

## Versioning  

We follow **Semantic Versioning (SemVer)**:  

- **MAJOR** â€“ Breaking changes.  
- **MINOR** â€“ New features (backward compatible).  
- **PATCH** â€“ Bug fixes and improvements.  

## release history
**[pypi](https://pypi.org/project/shared-utils-ems/)**
polars-splitters 0.4.5
Polars-based splitter functionalities for polars LazyFrames and DataFrames, similar to `sklearn.model_selection.train_test_split` and `sklearn.model_selection.StratifiedKFold`.
Requires Python: <3.14,>=3.10

# polars-splitters

<p align="center">
 <em>stratified splitting of polars dataframes</em>
</p>
<p align="center">
<a href="https://github.com/machml/polars-splitters/actions" target="_blank">
<img src="https://github.com/machml/polars_splitters/actions/workflows/test.yml/badge.svg" alt="Tests">
</a>
<img src="https://img.shields.io/pypi/v/polars-splitters?color=%2334D058&label=pypi%20package" alt="Package version">
<a href="https://pypi.org/project/polars-splitters" target="_blank">
<img src="https://img.shields.io/pypi/pyversions/polars-splitters.svg?color=%2334D058" alt="Supported Python versions">
</a>
</p>

Polars-based splitter functionalities for polars DataFrames similar to sklearn.model_selection.train_test_split and sklearn.model_selection.StratifiedKFold.

## features

- split_into_train_eval
- split_into_k_folds
- sample: stratified sampling

## installation

```shell
pip install polars-splitters
```

## usage

```python
import polars as pl
from polars_splitters import split_into_train_eval, split_into_k_folds, sample

df = pl.DataFrame(
    {
        "feature_1": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
        "treatment": [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1],
        "outcome": [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1],
    }
)

# Split into train and eval
df_train, df_test = split_into_train_eval(
    df,
    eval_rel_size=0.4,
    stratify_by=["treatment", "outcome"],
    shuffle=False,
)
print(df_train, df_test)

# Split into k folds
folds = split_into_k_folds(
    df,
    k=3,
    stratify_by=["treatment", "outcome"],
    shuffle=False,
)

# e.g. get the pair df_train, df_eval for the first fold
df_train, df_val = folds[0]["train"], folds[0]["eval"]
print(df_train, df_val)

# Stratified sample
df_sample = sample(
    df,
    fraction=0.5,
    stratify_by=["treatment", "outcome"],
)

print(df_sample)
```

## current limitations

- only supports polars eager API (pl.DataFrame): no pl.LazyFrame

## future work

- improve resilience against ties in quantized float columns in stratify_by