semvec/pypi-packages huggingface dataset:
scan-your-trash 1.0.1
A tool that extracts samples created using the Scan Your Trash app.

# Scan Your Trash

This library helps extract data from samples created with the [Scan Your Trash](https://scanyourtrash.de) app.

## Using as command line tool

After installing this package you will get access to the `scan-your-trash` command line tool.

### Syncing files from s3 to disk

The sync command downloads any samples on the s3 bucket that aren't already on your disk. It ignores files that already have been downloaded.

It's recommended to install the [awscli](https://pypi.org/project/awscli/) utility when using this functionality.

1. Make sure you log in to the s3 bucket: `aws configure --endpoint https://landfill.scantrash.de`
2. Start a sync job: `scan-your-trash sync <bucket-name> ./`

### Unpacking a sample into frames

1. Make sure you have a folder to store the unpacked results: `mkdir unpacked`
2. Unpack the sample: `scan-your-trash unpack 4/54E2CF4C-3E61-483B-91C9-D668D2E76537.mov unpacked`

## Using as a library

Example:

```python
from scan_your_trash import Reader

with Reader("4/54E2CF4C-3E61-483B-91C9-D668D2E76537.mov") as r:
  print(r.get_metadata())
```

Reader exposes the following methods:
 - `get_recycling_logo()` - Returns None or the recycling logo photo as PIL.Image
 - `get_metadata()` - Returns the global metadata for the sample
 - `get_samples(compute_mask = True)` - Yields frame samples: `(timestamp, main_frame, depth_frame, saliency_frame, object_mask, frame_meta)`
openfacekit 0.2.0
OpenFaceKit is a Python library for face detection and recognition in images, videos and streams using deep learning models.
Requires Python: >=3.10
Keywords: data-science, machine-learning, computer-vision

# OpenFaceKit

<h1 align="center">
    <img src="./docs/images/face-recognition.jpg">
</h1>


| | |
| --- | --- |
| Package | ![Python](https://img.shields.io/badge/python-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12%20%7C%203.13-blue) [![PyPI](https://img.shields.io/pypi/v/openfacekit)](https://pypi.org/project/openfacekit/) [![Downloads](https://static.pepy.tech/badge/openfacekit)](https://pepy.tech/project/openfacekit) [![Downloads](https://img.shields.io/pypi/dm/openfacekit?style=flat-square&color=blue&label=downloads%2Fmonth)](https://pypistats.org/packages/openfacekit) [![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://github.com/openfacekit/openfacekit/graphs/commit-activity) [![Project Status: Active](https://www.repostatus.org/badges/latest/active.svg)](https://www.repostatus.org/#active) |
| Meta | [![License](https://img.shields.io/github/license/skforecast/skforecast)](https://github.com/skforecast/skforecast/blob/master/LICENSE)
|Donation | [![paypal](https://img.shields.io/static/v1?style=social&amp;label=Donate&amp;message=%E2%9D%A4&amp;logo=Paypal&amp;color&amp;link=%3curl%3e)](https://www.paypal.com/donate/?hosted_button_id=D2JZSWRLTZDL6) ![GitHub Sponsors](https://img.shields.io/github/sponsors/joaquinamatrodrigo?logo=github&label=Github%20sponsors&link=https%3A%2F%2Fgithub.com%2Fsponsors%2FJoaquinAmatRodrigo) |


OpenFaceKit is a Python library for face detection and recognition in images, videos and streams using deep learning models.

# Installation & Dependencies

To install the basic version of `openfacekit` with core dependencies, run the following:

```bash
pip install git+https://github.com/JoaquinAmatRodrigo/openfacekit.git
```

**Dependencies:**

- numpy>=1.24.0
- scipy>=1.3.2
- matplotlib>=3.3, <3.11
- torch>=2.4, <2.8; python_version < '3.13'
- tqdm>=4.57
- joblib>=1.1
- opencv-python >= 4.10
- facenet-pytorch>=2.5.3
- pillow>=11.0

# Documentation and user guide

Usage examples can be found in [Face detection and recognition with deep learning and python](https://cienciadedatos.net/documentos/py34-face-detection-and-recognition-python).
ecg-k-fold 0.1.3
ECG k-Fold utilities
Requires Python: >=3.9
Keywords: ecg, machine-learning, kfold, huggingface, datasets

# ECG-k-Fold

Utilities for creating reproducible k-fold splits for open-access ECG datasets (FAIR compliant), packaged as a Python library with a CLI and CI/CD. Includes an option to push datasets to the Hugging Face Hub.

## Install

```bash
pip install ecg-k-fold
```

For development:

```bash
git clone <this-repo>
cd ECG-k-Fold
make init
```

Or manually:

```bash
git clone <this-repo>
cd ECG-k-Fold
# Install uv if not already installed: curl -LsSf https://astral.sh/uv/install.sh | sh
uv pip install -e .[dev]
uv run pre-commit install
```

## CLI

Push a local dataset directory to the Hugging Face Hub. Requires an access token with write permissions.

```bash
export HF_TOKEN=hf_************************
ecg-k-fold push-dataset ./path/to/dataset \
  --repo-id org_or_user/dataset-name \
  --private \
  --commit-message "Add v1"
```

Flags:
- `--repo-id`: target dataset repo, e.g. `your-org/ecg-dataset`
- `--private/--public`: repository visibility (default private)
- `--commit-message`: commit title for the upload
- `--token`: override `HF_TOKEN` env var

Dataset contents are uploaded as-is; common temp files are ignored.

## Python API

```python
from pathlib import Path
from ecg_k_fold.datasets.push_hf import push_local_dataset_to_hub

push_local_dataset_to_hub(
    local_dir=Path("./path/to/dataset"),
    repo_id="your-org/ecg-dataset",
    private=True,
    commit_message="Initial upload",
    hf_token="hf_...",
)
```

## CI/CD

- Lint, type-check, and tests run on PRs and pushes to `develop` and `main` (`.github/workflows/ci.yml`).
- Publishing to PyPI happens on pushing a tag like `vX.Y.Z` (`.github/workflows/publish.yml`). Uses PyPI Trusted Publishers, no PyPI token needed. See https://docs.pypi.org/trusted-publishers/
- A manual workflow can push datasets to Hugging Face (`.github/workflows/hf-dataset-push.yml`). Set `HF_TOKEN` in repo secrets.

## Gitflow

- Default branches: `main` (stable), `develop` (integration).
- Create feature branches off `develop` (`feature/<name>`), open PRs into `develop`.
- Release by creating a tag `vX.Y.Z` on `main` to trigger PyPI publish.

See `CONTRIBUTING.md` for details.

## License

Apache-2.0. See `LICENSE`.
google-re2 1.1.20251105
RE2 Python bindings
Requires Python: ~=3.9

A drop-in replacement for the re module.

It uses RE2 under the hood, of course, so various PCRE features
(e.g. backreferences, look-around assertions) are not supported.
See https://github.com/google/re2/wiki/Syntax for the canonical
reference, but known syntactic "gotchas" relative to Python are:

  * PCRE supports \Z and \z; RE2 supports \z; Python supports \z,
    but calls it \Z. You must rewrite \Z to \z in pattern strings.

Known differences between this module's API and the re module's API:

  * The error class does not provide any error information as attributes.
  * The Options class replaces the re module's flags with RE2's options as
    gettable/settable properties. Please see re2.h for their documentation.
  * The pattern string and the input string do not have to be the same type.
    Any str will be encoded to UTF-8.
  * The pattern string cannot be str if the options specify Latin-1 encoding.

Known issues with regard to building the C++ extension:

  * Building requires RE2 to be installed on your system.
    On Debian, for example, install the libre2-dev package.
  * Building requires pybind11 to be installed on your system OR venv.
    On Debian, for example, install the pybind11-dev package.
    For a venv, install the pybind11 package from PyPI.
  * Building on macOS is known to work, but has been known to fail.
    For example, the system Python may not know which compiler flags
    to set when building bindings for software installed by Homebrew;
    see https://docs.brew.sh/Homebrew-and-Python#brewed-python-modules.
  * Building on Windows has not been tested yet and will probably fail.
mofresh 0.2.6
A Python package for fresh data processing
Requires Python: >=3.8

<img src="imgs/fresh-green.png" width=125 height=125 align="right" style="z-index: 9999;">


### Mofresh

Widgets, designed for marimo, that can automatically refresh

## Installation

You can install the package using pip:

```bash
uv pip install mofresh
```

## Usage

The goal of this project is to offer a few tools that make it easy for you to refresh charts in marimo. This can be useful during a PyTorch training loop where you might want to update a chart on every iteration, but there are many other use-cases for this too.

### Widgets

The library provides three widgets:

1. **`ImageRefreshWidget`** - Displays images that can be updated dynamically. Perfect for refreshing matplotlib plots or any image content.
2. **`HTMLRefreshWidget`** - Renders HTML content that can be updated on the fly. Great for Altair charts, plotly visualizations, or custom HTML.
3. **`ProgressBar`** - A modern progress bar with dark mode support. Ideal for tracking training loops or long-running operations.

## How it works

The trick to get updating charts to work is to leverage [anywidget](https://anywidget.dev/). These widgets have a loop that is independant of the marimo cells which means that you can update a chart even if the cell hasn't completed running. The goal of this library is to make it easy to use this pattern by giving you a few utilities.

Effectively that means you can expect to see stuff like this in marimo: 

![CleanShot 2025-05-07 at 13 55 42](https://github.com/user-attachments/assets/4ccee74f-b89c-4af5-8188-9124da6d1fa1)

## Live demo 

If you want to dive deep and experience the API, the best way is to explore the live notebook on [Github pages](https://koaning.github.io/mofresh/). 

[Go to live docs.](https://koaning.github.io/mofresh/)
dwm-notebooks 0.4.0
A small package that bundles six ML notebooks and provides a CLI to extract them to a user folder.
Requires Python: >=3.8

# dwm-notebooks

This package bundles six machine-learning/notebook examples and provides a small CLI to extract them to an easy-to-access folder on your system.

Install:

  pip install dwm-notebooks

Usage (after installing):

  dwm-install             # copies notebooks to ~/dwm_notebooks
  dwm-install --dest DIR  # copy to an explicit directory

Gemini terminal chat (updated in 0.3.0):

- Run `dwm-gemini` to open an interactive terminal session that helps craft code snippets.
  - The assistant is locked to the `gemini-2.5-flash` model.
  - Use `--system-instruction` to customize the code assistant persona.
  - The CLI is pre-configured with a Gemini API key, so no extra setup is required.

The package includes the following notebooks:

- apriori.ipynb
- clustering.ipynb
- Kmean.ipynb
- naive_bayes.ipynb
- text_mining.ipynb
- pagerank.ipynb
udapi 0.5.1
Python framework for processing Universal Dependencies data
Requires Python: >=3.9

# udapi-python
Python framework for processing Universal Dependencies data

[![Build Status](https://circleci.com/gh/udapi/udapi-python.svg?style=shield)](https://circleci.com/gh/udapi/udapi-python)
[![Website](https://img.shields.io/website-up-down-green-red/http/udapi.github.io.svg)](http://udapi.github.io)
[![Documentation Status](https://readthedocs.org/projects/udapi/badge/)](http://udapi.readthedocs.io)

## Requirements
- You need Python 3.6 or higher.
- If the [ufal.udpipe](https://pypi.python.org/pypi/ufal.udpipe/) parser is needed,
  make sure you have a C++11 compiler (e.g. [g++ 4.7 or newer](.travis.yml#L9))
  and install UDPipe with `pip3 install --user --upgrade ufal.udpipe`.

## Install Udapi for developers
Let's clone the git repo to `~/udapi-python/`, install dependencies
and setup `$PATH` and `$PYTHONPATH` accordingly.
```bash
cd
git clone https://github.com/udapi/udapi-python.git
pip3 install --user -r udapi-python/requirements.txt
echo '## Use Udapi from ~/udapi-python/ ##'                >> ~/.bashrc
echo 'export PATH="$HOME/udapi-python/bin:$PATH"'          >> ~/.bashrc
echo 'export PYTHONPATH="$HOME/udapi-python/:$PYTHONPATH"' >> ~/.bashrc
source ~/.bashrc # or open new bash
```

## Install Udapi for users
This is similar to the above, but installs Udapi from PyPI to the standard (user) Python paths.
```
pip3 install --user --upgrade udapi
```
Try `udapy -h` to check it is installed correctly.
If it fails, make sure your `PATH` includes the directory where `pip3` installed the `udapy` script.
Usually, this results in
```bash
export PATH="$HOME/.local/bin/:$PATH"
```
stiggy 0.1.3
Stiggy: Python framework for software engineering
Requires Python: <3.14,>=3.12

# Stiggy

A Python framework for scalable, structured software engineering.

## Setup on development machine

```bash


mkdir -p ~/projects/public/exida-oss/stiggy
cd ~/projects/public/exida-oss/stiggy
git clone git@gitlab.com:exida-oss/stiggy/stiggy.git
cd stiggy/scripts


./setup.sh
./build.sh
```


## Set up pycharm

1. In pycharm, open ~/projects/public/exida-oss/stiggy/stiggy/
2. When asked about poetry executable, select the proposed one (in .local folder). Note: we do not select python executable nor .venv.
3. In Pycharm console, cd scripts and ./build.sh
4. Create a new branch, push your changes, create merge request.


## 7. A shorthand to run all during development

```bash
poetry lock && poetry install && poetry run pytest && poetry run stiggy export config/PTH_safety_analyses/DCDCSW_cluster_safety_analysis.yaml

```



## 🚀 Connecting existing project to new GitLab project - instructions for new project creation from template

```bash

# Step 1: Rename 'master' to 'main' (if not already done)
git branch -m master main

# Step 2: Add GitLab remote (adjust if not yet added)
git remote add origin git@gitlab.com:exida/STIG/stiggy.git

# Step 3: Pull remote main branch with rebase
git fetch origin
git pull --rebase origin main

# Step 4: Push your rebased local 'main' to GitLab and set tracking
git push -u origin main

```
consdata 0.0.1
Utility to fetch constituents data from various sources
Requires Python: >=3.9
Keywords: utility

# Utility to fetch constituents data from various sources

This module is a small library to fetch various lists of symbols/constituents stored as parquet dataframes somewhere in the file system or in the cloud.


## Configuration
- CONSDATA_ROOTPATH environment variable
- Default location ~/Document/ConsData


## Usage

To list available datasets

```python
import consdata

consdata.list_items()
```

To get a constituents

```python
consdata.get_cons(name)
```

To get list of symbols

```python
consdata.get_symbols(name)
```

## Related projects and Resources
- [FinanceDataBase](https://github.com/JerBouma/FinanceDatabase)
Database of 300.000+ symbols containing Equities, ETFs, Funds, Indices, Currencies, Cryptocurrencies and Money Markets