semvec/pypi-packages huggingface dataset:
snakemake-interface-report-plugins 1.3.0
The interface for Snakemake report plugins.
Requires Python: <4.0,>=3.11

# Snakemake interface for report plugins

This package defines the interface between Snakemake and its report plugins.

Plugins should implement the following skeleton to comply with this interface.
It is recommended to use [Snakedeploy to set up the skeleton](https://snakedeploy.readthedocs.io/en/stable/snakemake_developers/scaffold_snakemake_plugins.html) (and automated testing) within a python package.

```python

from dataclasses import dataclass, field

from snakemake_interface_common.exceptions import WorkflowError
from snakemake_interface_report_plugins.reporter import ReporterBase
from snakemake_interface_report_plugins.settings import ReportSettingsBase


# Optional:
# Define additional settings for your reporter.
# They will occur in the Snakemake CLI as --report-<reporter-name>-<param-name>
# Omit this class if you don't need any.
# Make sure that all defined fields are Optional (or bool) and specify a default value
# of None (or False) or anything else that makes sense in your case.
@dataclass
class ReportSettings(ReportSettingsBase):
    myparam: Optional[int] = field(
        default=None,
        metadata={
            "help": "Some help text",
            # Optionally request that setting is also available for specification
            # via an environment variable. The variable will be named automatically as
            # SNAKEMAKE_REPORT_<reporter-name>_<param-name>, all upper case.
            # This mechanism should ONLY be used for passwords and usernames.
            # For other items, we rather recommend to let people use a profile
            # for setting defaults
            # (https://snakemake.readthedocs.io/en/stable/executing/cli.html#profiles).
            "env_var": False,
            # Optionally specify a function that parses the value given by the user.
            # This is useful to create complex types from the user input.
            "parse_func": ...,
            # If a parse_func is specified, you also have to specify an unparse_func
            # that converts the parsed value back to a string.
            "unparse_func": ...,
            # Optionally specify that setting is required when the reporter is in use.
            "required": True,
            # Optionally specify multiple args with "nargs": True
        },
    )


# Required:
# Implementation of your reporter
class Reporter(ReporterBase):
    def __post_init__(self):
        # initialize additional attributes
        # Do not overwrite the __init__ method as this is kept in control of the base
        # class in order to simplify the update process.
        # See https://github.com/snakemake/snakemake-interface-report-plugins/snakemake_interface_report_plugins/reporter.py
        # for attributes of the base class.
        # In particular, the settings of above ReportSettings class are accessible via
        # self.settings.

    def render(self):
        # Render the report, using attributes of the base class.
        ...
```
pyeqx-core 0.7.20
Python library for interacting with Spark, Azure, Minio, and other data sources.
Requires Python: >=3.12

# esbm-dis-dfts-pyeqx-core

Spark: `3.5.3`

## pre-requisites

to setup virtual environment to execute unit tests, it has to setup virtual env and install dependencies

```bash
# setup virtual env
python3.12 -m venv .venv

# activate virtual env
source .venv/bin/activate

# install dependencies
pip install delta-spark pyspark pandas retrying minio requests

# install dependencies (If you want to publish)
pip install twine
```

## tests

to execute unit test run this command at root of the project

```bash
python3 -m unittest discover test -p "**.py"

# or

pytest
```

## build

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

## publish to testpypi

```bash
python3 -m twine upload --repository testpypi dist/*
```

## publish to pypi

```bash
python3 -m twine upload dist/*

# specific config for pypi
python3 -m twine upload --config-file .pypirc dist/*
```

## publish to gitlab

```bash
python3 -m twine upload --repository-url https://gitlab.com/api/v4/projects/<project_id>/packages/pypi/ --username gitlab-ci-token --password <access_token> dist/*

# Replace <project_id> with the ID of your GitLab project
```

## install from gitlab

```bash
#install from pypi
pip install pyeqx-core

#install from testpypi
pip install -i https://test.pypi.org/simple/ pyeqx-core

# install from gitlab
pip install datadriven-core --index-url https://__token__:<access_token>@gitlab.com/api/v4/projects/<project_id>/packages/pypi/simple
pip install pyeqx-core --index-url https://__token__:<access_token>@gitlab.com/api/v4/projects/<project_id>/packages/pypi/simple
# Replace <project_id> with the ID of your GitLab project
```
whisper-tools 0.1.12
Real-time speech recognition with Whisper
Requires Python: >=3.8

# Whisper-tools
High-level python library for stream and static transcription based on faster-whisper

# Getting started

Installation 
```bash
pip install whisper-tools
```

# Transcribing an audio file

Transcribing an audio file locally:
```python
from whisper_tools import WhisperLocal

text = WhisperLocal().transcribe_file("/voice example/example.wav")

print(text)
```

Transcribing an audio file via API:
```python
from whisper_tools import WhisperAPI

whisper_api = WhisperAPI(api_key="your_key", base_url="your_url")
text = whisper_api.transcribe_file_api("/voice example/example.wav")

print(text)
```

# Real-time transcription

> [!IMPORTANT]  
> True streaming transcription requires modifications to the Whisper architecture, as the original model expects a complete audio file, so we send information in chunks.

Streaming transcription locally:
```python
from whisper_tools import WhisperLocal, StreamRecorder

recorder = StreamRecorder(WhisperLocal())

try:
    # start recording
    recorder.start_recording()
    print("Recording... Press Ctrl+C to stop")
    while True:
        # get a chunk (block of transcribed speech)
        text = recorder.process_chunk()
        if text:
            print(text)
except KeyboardInterrupt:
    print("\nStopping...")
finally:
    # stop recording
    recorder.stop_recording()
```

Or we can write to the file:
```python
try:
    f = open('transcribed.txt', 'w')
    # start recording
    recorder.start_recording()
    print("Recording... Press Ctrl+C to stop")
    while True:
        # get a chunk (block of transcribed speech)
        text = recorder.process_chunk()
        if text:
            f.write(text + '\n')
            f.flush() 
except KeyboardInterrupt:
    print("\nStopping...")
finally:
    f.close()
    # stop recording
    recorder.stop_recording()
```

Streaming transcription via API:
```python
from whisper_tools import WhisperAPI, StreamRecorderAPI

recorder = StreamRecorderAPI(WhisperAPI(api_key="your_key", base_url="your_url"))

try:
    recorder.start_recording()
    print("Recording... Press Ctrl+C to stop")
    while True:
        text = recorder.process_chunk()
        if text:
            print(text)
except KeyboardInterrupt:
    print("\nStopping...")
finally:
    recorder.stop_recording()
```
mcrnmf 0.1.2
Multivariate Curve Resolution using Nonnegative Matrix Factorization
Requires Python: <3.14,>=3.11.9
Keywords: MCR, chemometrics, NMF, Multivariate Curve Resolution, Nonnegative Matrix Factorization

# McrNmf

**McrNmf** is a Python package for Multivariate Curve Resolution (MCR) using a range of
Nonnegative Matrix Factorization (NMF) algorithms. MCR is widely used in chemometrics,
for instance, to decompose mixture spectra into their pure component spectra and
associated concentration profiles.

## Key Features

- **Multiple solvers** – unified interface for three NMF variants: classic Alternating
  Least Squares (FroALS), Fast Projected Gradient (FroFPGM), and Minimum-Volume
  formulation (MinVol).
- **Built-in constraints** – supports closure, normalization, equality, and per-component
  unimodality constraints.
- **Robust initialisation** – includes Successive Nonnegative Projection (SNPA) algorithm
  for generating reliable starting estimates of spectra and concentrations
- **Lightweight implementation** – written almost entirely in NumPy, with Numba used
  only to speed up unimodal regression.

For more details, see the [documentation](https://siddarthvasudevan.github.io/mcrnmf/).

---

## Installation

With pip:

```bash
pip install mcrnmf
```
> **Note for macOS Apple Silicon (M4) users:** When running the **McrNmf** package
installed via pip, you may encounter runtime numerical warnings (e.g., divide/overflow).
To avoid these, please install via **conda-forge**.


With conda:

```
conda install -c conda-forge mcrnmf
```

`mcrnmf` requires:
- Python ≥ 3.11.9, < 3.14
- NumPy ≥ 1.24, < 2.3
- Numba ≥ 0.61.2

---
## Quick Start

```python
from mcrnmf.datasets import load_rxn_spectra
from mcrnmf import SNPA, MinVol

# load a Raman spectroscopy data (wv × time)
X, wv, t = load_rxn_spectra()

# specify the number of components
rank = 4

# generate initial guess for W and H using SNPA
snpa = SNPA(rank=rank, iter_max=1000)
snpa.fit(X)
Wi = snpa.W  # intial guess for W (pure spectra)
Hi = snpa.H  # intial guess for H (conc. profiles)


mvol = MinVol(rank=rank,
              constraint_kind=1,
              unimodality={"H": True},
              iter_max=2000,
              tol=1e-4)
# fit the Minimum Volume NMF model
mvol.fit(X=X, Wi=Wi, Hi=Hi)
# access the decomposed factors
W = mvol.W
H = mvol.H
# access relative reconstruction error at each iter.
rel_recon_err = mvol.rel_reconstruction_error_ls

```

More worked examples can be found in the [Usage](https://siddarthvasudevan.github.io/mcrnmf/usage/index.html) section of the documentation.

---
## Citation

If you use **McrNmf** in your work, please consider citing the following preprint:

> Vasudevan SA, Kohlbrenner R, Ritschel N, Vent-Schmidt T.
> *Beyond Classical MCR-ALS—Minimum Volume NMF and Strategic Sampling for Robust Reaction Monitoring*.
> ChemRxiv. 2025; [doi:10.26434/chemrxiv-2025-qs5g4](https://doi.org/10.26434/chemrxiv-2025-qs5g4)

---
## License

MIT – see [LICENSE](LICENSE).
blog-uploader 0.1.8
A command-line tool to manage Hugo blog posts.
Requires Python: >=3.6

# Blog Uploader

`blog-uploader` is a command-line tool to help you manage your Hugo blog posts. It allows you to create new posts from local markdown files, remove existing posts, and list all current posts.

## Features

- **Create New Posts**: Quickly create a new Hugo post from a markdown file.
- **Remove Posts**: Safely delete a post by its folder name.
- **List Posts**: View a list of all your current blog posts.
- **Git Integration**: Automatically clones your blog's repository, and commits and pushes changes.
- **Cross-Platform**: Works on Windows, macOS, and Linux.

## Requirements

- **Hugo**: This tool depends on Hugo. Before using `blog-uploader`, please ensure that Hugo is installed and accessible in your system's PATH. The tool will automatically check for Hugo's presence and guide you if it's missing.

## Installation

You can install `blog-uploader` via pip:

```bash
pip install .
```
(After navigating into the `blog-uploader` directory)

Or, once it's published on PyPI:
```bash
pip install blog-uploader
```

## Usage

The tool provides three main commands: `new`, `remove`, and `list`.

### 1. Create a New Post

To create a new post, use the `new` command and provide the path to your markdown file.

```bash
blog-uploader new /path/to/your/post.md
```

The tool will:
1. Clone or pull the latest version of your blog repository.
2. Create a new post in Hugo.
3. Append the content of your file to the new post's `index.md`.
4. **Automatically open the new file in Typora** for editing (if Typora is found).
5. Prompt you to confirm after you have set the title and other metadata.
6. After you confirm, it will rename the post's folder based on the title.
7. Build the site with Hugo, and commit and push the changes to your repository.

### 2. Remove a Post

To remove a post, use the `remove` command with the post's folder name.

```bash
blog-uploader remove "name-of-the-post-folder"
```

You will be asked for confirmation before the post is deleted.

### 3. List All Posts

To see a list of all your posts, use the `list` command.

```bash
blog-uploader list
```

This will display the folder names of all posts in your `content/post` directory.

## Configuration

Currently, the tool is configured with a hardcoded Git repository URL. In future versions, this will be customizable through a configuration file.