semvec/pypi-packages huggingface dataset:
pybreathe 0.2.2
A python package for respiratory air flow rates analysis
Requires Python: >=3.10

# pybreathe: a python package for respiratory air flow rates analysis

## Get started

First of all, we highly recommend that you install [miniconda](https://www.anaconda.com/docs/getting-started/miniconda/install) on your machine.

To set up the virtual environment required for respiratory flow analysis, open **Anaconda prompt** and please run (only the first time):

```bash
$ conda create --name pybreathe
$ conda activate pybreathe
$ pip install pybreathe
$ conda install conda-forge::jupyterlab
```

If you encounter an error stating that `pip` cannot be found, then run: `$ conda install anaconda::pip`

Then, every time you want to analyze data, open **Anaconda prompt** and activate the virtual environment with:

```bash
$ conda activate pybreathe
```

(do not reinstall `pybreathe` each time)

To get started with `pybreathe` API, we strongly recommend that you use and refer to the example scripts. The package comes with [example scripts](https://github.com/tcoustillet/pybreathe/tree/main/examples) based on simulated breathing signals that are representative of the data that can be collected experimentally. They explain the milestones involved in carrying out an analysis (feature extraction) and they supply useful documentation.

Run the example script (or any other) with:

```bash
$ jupyter lab example.ipynb
```

> /!\ You must either be in the same directory as your .ipynb file, or specify the absolute path. You can either move to your directory with the `$ cd` command (*e.g.*, `$ cd algo/test`) or you can type the command : `$ jupyter lab ` and then drag and drop your file into the terminal. This will automatically copy the absolute path of your file: `$ jupyter lab '/home/tcoustillet/algo/test/example.ipynb'`

Once the example notebook is open, you can run the cells one by one and understand how `pybreathe` works. To analyse your own data, create a new notebook and refer to the examples for how the API works.

Finally, to quit the analysis, please follow these steps:

- Right clic on your .ipynb file in the tree, then "Shut Down Kernel"
- Clic on "File", the "Shut Down"
- When you regain control in your terminal, run:

```bash
$ conda deactivate
```
safaa 0.0.3
Created as a part of the 2023 Google Summer of Code project:      Reducing Fossology's False Positive Copyrights, the purpose is to be able      to predict whether a given copyright output from the Fossology software      is a false positive or not. It is also able to remove extra      text from a copyright notice.
Requires Python: >=3.6

<!--
        SPDX-FileCopyrightText: © 2023 abdelrahmanjamal5565@gmail.com
        
        SPDX-License-Identifier: LGPL-2.1-only
        -->
        # Safaa
        
        Safaa is a Python package designed for handling false positive detection in copyright notices.
        Additionally, it can declutter copyright notices, removing unnecessary extra text.
        
        ## Features
        
        - Load pre-trained models or train your own.
        - Integration with scikit-learn for training and prediction.
        - Integrated with spaCy for named entity recognition and decluttering tasks.
        - Preprocessing tools to ensure data consistency and quality.
        - Ability to handle local or default model directories.
        
        ## Installation
        
        To install Safaa, simply use pip:
        
        ```bash
        pip install safaa
        ```
        
        ## Usage
        
        ### Initialization
        
        ```
        from safaa.Safaa import *
        agent = SafaaAgent()
        ```
        
        ### Preprocessing Data
        ```
        data = ["Your raw data here"]
        preprocessed_data = agent.preprocess_data(data)
        ```
        
        ### Predicting False Positives
        ```
        predictions = agent.predict(data)
        ```
        
        ### Decluttering Copyright Notices
        ```
        decluttered_data = agent.declutter(data, predictions)
        ```
        
        ### Training Models
        **To train the false positive detector:**
        
        ```
        training_data = ["Your training data here"]
        labels = ["Your labels here"]
        agent.train_false_positive_detector_model(training_data, labels)
        ```
        
        **To train the named entity recognition model:**
        
        ```
        train_path = "path/to/train.spacy"
        dev_path = "path/to/dev.spacy"
        agent.train_ner_model(train_path, dev_path)
        ```
        
        ### Saving Trained Models
        ```
        save_path = "path/to/save"
        agent.save(save_path)
        ```
        
        ## Dependencies
        * scikit-learn
        * spaCy
        * joblib
        * regex
        * os
        * shutil
        
        ## License
        
        This project is licensed under the [GNU LESSER GENERAL PUBLIC LICENSE, Version 2.1, February 1999](LICENSE).
        
        ## Contact Information
        
        - **Name**: Abdelrahman Jamal
        - **Email**: [abdelrahmanjamal5565@gmail.com](mailto:abdelrahmanjamal5565@gmail.com)
        - **LinkedIn**: [linkedin.com/in/abdelrahmanjamal](https://linkedin.com/in/abdelrahmanjamal)
iflow-mcp_python-local 0.1.1
An MCP Server to run python locally
Requires Python: >=3.12

# python_local MCP Server

An MCP Server that provides an interactive Python REPL (Read-Eval-Print Loop) environment.

## Components

### Resources

The server provides access to REPL session history:
- Custom `repl://` URI scheme for accessing session history
- Each session's history can be viewed as a text/plain resource
- History shows input code and corresponding output for each execution

### Tools

The server implements one tool:
- `python_repl`: Executes Python code in a persistent session
  - Takes `code` (Python code to execute) and `session_id` as required arguments
  - Maintains separate state for each session
  - Supports both expressions and statements
  - Captures and returns stdout/stderr output

## Configuration

### Install

#### Claude Desktop

On MacOS: `~/Library/Application\ Support/Claude/claude_desktop_config.json`
On Windows: `%APPDATA%/Claude/claude_desktop_config.json`

<details>
  <summary>Development/Unpublished Servers Configuration</summary>
  ```json
  "mcpServers": {
    "python_local": {
      "command": "uv",
      "args": [
        "--directory",
        "/path/to/python_local",
        "run",
        "python_local"
      ]
    }
  }
  ```
</details>

<details>
  <summary>Published Servers Configuration</summary>
  ```json
  "mcpServers": {
    "python_local": {
      "command": "uvx",
      "args": [
        "python_local"
      ]
    }
  }
  ```
</details>

## Development

### Building and Publishing

To prepare the package for distribution:

1. Sync dependencies and update lockfile:
```bash
uv sync
```

2. Build package distributions:
```bash
uv build
```

This will create source and wheel distributions in the `dist/` directory.

3. Publish to PyPI:
```bash
uv publish
```

Note: You'll need to set PyPI credentials via environment variables or command flags:
- Token: `--token` or `UV_PUBLISH_TOKEN`
- Or username/password: `--username`/`UV_PUBLISH_USERNAME` and `--password`/`UV_PUBLISH_PASSWORD`

### Debugging

Since MCP servers run over stdio, debugging can be challenging. For the best debugging
experience, we strongly recommend using the [MCP Inspector](https://github.com/modelcontextprotocol/inspector).

You can launch the MCP Inspector via [`npm`](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm) with this command:

```bash
npx @modelcontextprotocol/inspector uv --directory /path/to/python_local run python-local
```

Upon launching, the Inspector will display a URL that you can access in your browser to begin debugging.
visualizr 0.1.0
Video Generator part of the Chatacter Backend
Requires Python: ==3.10.*
Keywords: anitalker, video

# Visualizr

<div align="center">
<pre aria-label="VISUALIZR ASCII banner">
 █████   █████ █████  █████████  █████  █████   █████████   █████       █████ ███████████ ███████████  
░░███   ░░███ ░░███  ███░░░░░███░░███  ░░███   ███░░░░░███ ░░███       ░░███ ░█░░░░░░███ ░░███░░░░░███ 
 ░███    ░███  ░███ ░███    ░░░  ░███   ░███  ░███    ░███  ░███        ░███ ░     ███░   ░███    ░███ 
 ░███    ░███  ░███ ░░█████████  ░███   ░███  ░███████████  ░███        ░███      ███     ░██████████  
 ░░███   ███   ░███  ░░░░░░░░███ ░███   ░███  ░███░░░░░███  ░███        ░███     ███      ░███░░░░░███ 
  ░░░█████░    ░███  ███    ░███ ░███   ░███  ░███    ░███  ░███      █ ░███   ████     █ ░███    ░███ 
    ░░███      █████░░█████████  ░░████████   █████   █████ ███████████ █████ ███████████ █████   █████
     ░░░      ░░░░░  ░░░░░░░░░    ░░░░░░░░   ░░░░░   ░░░░░ ░░░░░░░░░░░ ░░░░░ ░░░░░░░░░░░ ░░░░░   ░░░░░ 
</pre>
</div>

<div align="center">
 
[![PyPI - Version](https://img.shields.io/pypi/v/visualizr)](https://pypi.org/project/visualizr)
[![Build](https://github.com/AlphaSphereDotAI/visualizr/actions/workflows/build.yaml/badge.svg)](https://github.com/AlphaSphereDotAI/visualizr/actions/workflows/build.yaml)
[![CI Tools](https://github.com/AlphaSphereDotAI/visualizr/actions/workflows/ci_tools.yaml/badge.svg)](https://github.com/AlphaSphereDotAI/visualizr/actions/workflows/ci_tools.yaml)
[![CodeQL](https://github.com/AlphaSphereDotAI/visualizr/actions/workflows/github-code-scanning/codeql/badge.svg)](https://github.com/AlphaSphereDotAI/visualizr/actions/workflows/github-code-scanning/codeql)
[![Dependabot Updates](https://github.com/AlphaSphereDotAI/visualizr/actions/workflows/dependabot/dependabot-updates/badge.svg)](https://github.com/AlphaSphereDotAI/visualizr/actions/workflows/dependabot/dependabot-updates)
[![Release](https://github.com/AlphaSphereDotAI/visualizr/actions/workflows/release.yaml/badge.svg)](https://github.com/AlphaSphereDotAI/visualizr/actions/workflows/release.yaml)
[![Test](https://github.com/AlphaSphereDotAI/visualizr/actions/workflows/test.yaml/badge.svg)](https://github.com/AlphaSphereDotAI/visualizr/actions/workflows/test.yaml)

</div>

## Video Generator part of the Chatacter Backend
### Installations (uv)

```bash
uvx --python 3.10 visualizr
```

### Installations (Docker)

```bash
curl -o compose.yaml https://raw.githubusercontent.com/alphaspheredotai/visualizr/main/compose.yaml
docker compose up
```
ocr-mynhk 0.1.1
A versatile OCR and document processing command-line tool.
Requires Python: >=3.8

# My OCR Tool

A versatile OCR and document processing command-line tool, built with Python and the `docling` library. It uses **RapidOCR** by default and also supports EasyOCR.

## Features

- Process various file types: PDF, PNG, JPG, DOCX, XLSX, CSV.
- Supports `rapidocr` (default) and `easyocr` engines, configurable via YAML files.
- Outputs processed documents into Markdown, JSON, and YAML formats.

## Installation

First, ensure you have Python 3.8+ installed.

You can install the tool from PyPI. The default engine, `rapidocr`, is included automatically.

```bash
pip install myocr-tool
```
### Test the Optional Engine (EasyOCR)
```bash
my-ocr-tool --ocr-engine easyocr "path/to/your/image.png"
```

### Test with a Configuration File
```bash
my-ocr-tool --config rapidocr_config.yaml "path/to/your/image.png"
```
skarv 0.3.0
A single process, in-memory message queue written in python.
Requires Python: >=3.10

# skarv

> **skarv** is a Swedish noun that refers to the point where two things are joined together. Translations to English includes joint, splice, connection and similar words. Interestingly, it is also the swedish word for cormorant (the bird).

## What?

A simple, synchronous, thread-safe, single process, in-memory message "broker" written in python. 

## Why?

Because I wanted the most simplistic API (subjectively) I could possibly think of for processing real-time data from multiple sources to multiple sinks via any intermediate processing setup.

## How ?

By re-using the concept of [`Key Expression`](https://github.com/eclipse-zenoh/roadmap/blob/main/rfcs/ALL/Key%20Expressions.md)s from [`Zenoh`](https://zenoh.io/) and utilizing in-memory storage for a very simplistic implementation of a message "broker" that supports the following operations:
* Putting data to the broker
* Subscribing to data from the broker
* Getting the latest data from the broker

## Usage

Docs are available at https://freol35241.github.io/skarv

```python

import skarv

@skarv.subscribe("any/**")
def _(sample: skarv.Sample):
    print(sample.key_expr)
    print(sample.value)

skarv.put("any/thing", 42)

samples = skarv.get("any/**")

print(samples)
```

## Installation

```
pip install skarv
```

## License

Apache 2.0 - see [LICENSE](LICENSE) file for details.
faultdiagnosistoolbox 0.12.5
A toolbox for Model Based Fault Diagnosis of dynamic systems based on structural analysis
Requires Python: >=3.10

# Fault Diagnosis Toolbox
<p>
<img alt="PyPI - Python Version" src="https://img.shields.io/python/required-version-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2Ffaultdiagnosistoolbox%2Fpyfaultdiagnosistoolbox%2Fmaster%2Fpyproject.toml" />
<img alt="PyPI - License" src="https://img.shields.io/pypi/l/faultdiagnosistoolbox" />
</p>

Fault Diagnosis Toolbox is a Python package for the analysis and design of fault diagnosis systems for dynamic systems, 
primarily described by differential algebraic equations. Key features of the toolbox are extensive support for 
structural analysis of large-scale dynamic models, fault isolability analysis, sensor placement analysis, 
and code generation in C/C++ and Python. The toolbox is an adaptation of our Matlab toolbox that can be downloaded from https://faultdiagnosistoolbox.github.io.

The toolbox is freely available under an MIT license. 

## Documentation
The documentation is available at [readthedocs](https://faultdiagnosistoolbox.readthedocs.io/).

For a quick introduction, see the [use case](https://faultdiagnosistoolbox.readthedocs.io/en/latest/usecase.html) where an industrial 
size example, an automotive engine, is analyzed, C-code for residual generators is generated, and the resulting 
diagnosis system is evaluated on test-cell measurements from our engine laboratory.

## Installation 
The toolbox is available on [pip](https://pypi.org/project/faultdiagnosistoolbox/) and can be installed as:
```
pip install faultdiagnosistoolbox
```

## Publications

If you use this toolbox in your research, please cite 

   Erik Frisk, Mattias Krysander, and Daniel Jung. "_A Toolbox for Analysis and Design of Model Based Diagnosis Systems for Large Scale Models_" (https://doi.org/10.1016/j.ifacol.2017.08.504), IFAC World Congress. Toulouse, France, 2017.

and any relevant papers of ours. See a list of [key references](https://faultdiagnosistoolbox.readthedocs.io/) for details.
petsc-ts 1.4
Pattern-based Embedding for Time Series Classification
Requires Python: >=3.9

# PETSC #

Pattern-based Embedding for Time Series Classification (PETSC).

This repository contains a Python/C++ implementation of PETSC, that is compatible with [`aeon`](https://aeon-toolkit.org). Two variants of PETSC are supported as well: MR-PETSC and PETSC-SOFT.

# Installation
The easiest way to install `petsc-ts` is via pip:
```
pip install petsc-ts
```

If you want to run the tests locally (currently only an `aeon` test to check if the estimator complies with the required format), install the optional dependency:
```
pip install "petsc-ts[test]"
```

You can then import the `PetsClassifier` class as follows and use it as any other `scikit-learn`-compatible estimator:
```Python
from petsc_ts.classifier import PetsClassifier

clsf = PetsClassifier()
clsf.fit(X_train, y_train)
clsf.predict(X_test)
clsf.predict_proba(X_test)
```