semvec/pypi-packages huggingface dataset:
cleanops 0.1.7
A lightweight data cleaning and inspection toolkit.
Requires Python: >=3.8

# CleanOps

A lightweight toolkit for inspecting, cleaning, organizing, and exporting datasets.  
Designed for quick data quality checks, automated cleaning, and report generation.

---

## 📌 Project Overview

CleanOps provides a simple workflow for handling messy datasets.  
It includes tools for:

- Detecting missing values  
- Identifying duplicate rows  
- Detecting outliers (IQR-based or statistical)  
- Cleaning + automatic fixing  
- Organizing dataset columns and rows  
- Exporting cleaned data (CSV / Excel / JSON) 
- Running complete pipelines combining cleaning, exporting, and reporting  

The goal is to make data preprocessing easier and more consistent.

---

## 📦 Installation

Install via pip:

```bash
pip install cleanops
```

Or, if you're installing from source:

```bash
pip install .
```

---

## 🚀 Example Usage

### **1. Inspecting and Cleaning a Dataset**

```python
import pandas as pd
from cleanops import DataCleaner

df = pd.read_csv("test_data_150.csv")

cleaner = DataCleaner(df)

# Diagnose issues
issues = cleaner.diagnose()
print("Issues found:", issues)

# Apply cleaning (missing, duplicates, outliers)
cleaned_df = cleaner.treat()

print(cleaned_df.head())
```

---

### **2. Exporting Cleaned Data**

```python
from cleanops import DataExporter

exporter = DataExporter(cleaned_df)

exporter.to_csv("output.csv")
exporter.to_excel("output.xlsx")
exporter.to_json("output.json")

```

---

### **3. Generating a Data Report**

```python
from cleanops import ReportGenerator

reporter = ReportGenerator(cleaned_df)
report = reporter.report()

print("Report:", report)

reporter.export_report("dataset_report.json")
```

---

### **4. Running a Full Data Pipeline**

```python
from cleanops import DataCleaner, DataOutput, DataPipeline
import pandas as pd

df = pd.read_csv("test_data_150.csv")

cleaner = DataCleaner(df)
output = DataOutput(df)

pipeline = DataPipeline(
    cleaner=cleaner, 
    exporter=output.exporter, 
    reporter=output.reporter
)
pipeline.run()
```

---

## 📄 License

This project is released under the MIT License.

---
pyPRMS 0.9.8
Python library for Precipitation-Runoff Modeling System
Requires Python: <3.13,>=3.10
Keywords: PRMS, NHM, streamflow, hydrology, surface

pyPRMS
======
[![ci-badge](https://github.com/DOI-USGS/pyPRMS/actions/workflows/ci.yaml/badge.svg?branch=development)](https://github.com/DOI-USGS/pyPRMS/actions?query=workflows%3CI)

A Python library for working with the Precipitation-Runoff Modeling System (PRMS)

----

The pyPRMS library provides a set of python interfaces to read, modify, and write various files used by and for PRMS.

pip install
-----------
The library can be installed using pip. The development branch contains the most
up-to-date version of the software.

To install from development branch use the following command::

    pip install git+https://github.com/DOI-USGS/pyPRMS.git

To update from the development branch type::

    pip install git+https://github.com/DOI-USGS/pyPRMS.git --upgrade

To uninstall pyPRMS type::

    pip uninstall pyPRMS
eyekit 0.7.1
A Python package for analyzing reading behavior using eyetracking data
Requires Python: >=3.8

<img src='https://jwcarr.github.io/eyekit/images/logo.png' width='300'>

Eyekit is a Python package for analyzing reading behavior using eyetracking data. Eyekit aims to be entirely independent of any particular eyetracker hardware, experiment software, or data formats. It has an object-oriented style that defines three core objects – the TextBlock, InterestArea, and FixationSequence – that you bring into contact with a bit of coding.


Is Eyekit the Right Tool for Me?
--------------------------------

- You want to analyze which parts of a text someone is looking at and for how long.

- You need convenient tools for extracting areas of interest from texts, such as specific words, phrases, or letter combinations.

- You want to calculate common reading measures, such as gaze duration or initial landing position.

- You need support for arbitrary fonts, multiline passages, right-to-left text, or non-alphabetical scripts.

- You want the flexibility to define custom reading measures and to build your own reproducible processing pipeline.

- You would like tools for dealing with noise and calibration issues, and for discarding fixations according to your own criteria.

- You want to share your data in an open format and produce publication-ready vector graphics.


Installation
------------

Eyekit may be installed using `pip`:

```shell
$ pip install eyekit
```

Eyekit is compatible with Python 3.8+. Its main dependency is the graphics library [Cairo](https://cairographics.org), which you might also need to install if it's not already on your system. Many Linux distributions have Cairo built in. On a Mac, it can be installed using [Homebrew](https://brew.sh): `brew install cairo`. On Windows, it can be installed using [Anaconda](https://anaconda.org/anaconda/cairo): `conda install -c anaconda cairo`.


**[Full documentation and a usage guide is available here](https://jwcarr.github.io/eyekit/)**


Contributing
------------

This project is in the stable/maintenance phase and is not under active development. I am only aiming to fix bugs and keep it compatible with current versions of Python so that it remains useful to the community. With that in mind, contributions are very welcome, but please read the `CONTRIBUTING` file before submitting a pull request.
RTFDE 0.1.2.2
A library for extracting HTML content from RTF encapsulated HTML as commonly found in the exchange MSG email format.
Requires Python: >=3.8

# RTFDE: RTF De-Encapsulator

A python3 library for extracting encapsulated `HTML` & `plain text` content from the `RTF` bodies of .msg files.

De-encapsulation enables previously encapsulated HTML and plain text content to be extracted and rendered as HTML and plain text instead of the encapsulating RTF content. After de-encapsulation, the HTML and plain text should differ only minimally from the original HTML or plain text content.

# Features

- De-encapsulate HTML from RTF encapsulated HTML.
- De-encapsulate plain text from RTF encapsulated text.

# Known Issues

- This library *fully* unquotes text it de-encapsulates because it does not know which text was quoted in the RTF conversion process and which text was quoted in the original html/text. So, for instance escaped [Quoted-Printable](https://en.wikipedia.org/wiki/Quoted-printable) text will be returned un-escaped.
- This library currently can't [combine attachments](https://docs.microsoft.com/en-us/openspecs/exchange_server_protocols/ms-oxrtfex/b518f0bc-468c-4218-87a7-8f8859bf5773) from a .MSG Message object with the de-encapsulated HTML. This is mostly because I could not get a good set of examples of encapsulated HTML which had attachment objects that needed to be integrated back into the body of the HTML.

# Anti-Features (I don't intend to have this library do this.)

- Extract plain text from RTF encapsulated HTML. If you want this, then you will have to parse the HTML using another library.

# Installation

**To install from the pip package.**

```
pip3 install RTFDE

```

# Usage

## De-encapsulating HTML or TEXT

```python
from RTFDE.deencapsulate import DeEncapsulator

with open('rtf_file', 'rb') as fp:
    raw_rtf  = fp.read()
    rtf_obj = DeEncapsulator(raw_rtf)
    rtf_obj.deencapsulate()
    if rtf_obj.content_type == 'html':
        print(rtf_obj.html)
    else:
        print(rtf_obj.text)
```



# Enabling Logging

Any logging (including how verbose the logging is) can be handled by configuring logging. You can enable RTFDE's logging at the highest level by getting and setting the "RTFDE" logger.

```
log = logging.getLogger("RTFDE")
log.setLevel(logging.INFO)
```






To see how to enable more in-depth logging for debugging check out the CONTRIBUTING.md file.

```
# Now, get the log that you want
# The main logger is simply called RTFDE. That will get you all the *normal* logs.
requests_log = logging.getLogger("RTFDE")
requests_log.setLevel(logging.DEBUG)
requests_log.propagate = True
```


# Contribute

Please check the [contributing guidelines](./CONTRIBUTING.md)

# License

Please see the [license file](./LICENSE) for license information on RTFDE. If you have further questions related to licensing PLEASE create an issue about it on github.
my-entire-ml 0.1.3
A test package for ML explanation utilities
Requires Python: >=3.7
Keywords: machine-learning, explanation, test

# my-entire-ml

A test package for ML explanation utilities.

## Installation

```bash
pip install my-entire-ml
```

## Quick Start

```python
import meml

# Print a simple greeting
meml.hello()  # Output: Hello!
```

## Usage

```python
import meml

# Call the hello function
meml.hello()
```

## Development

### Setup Development Environment

```bash
git clone https://github.com/yourusername/my-entire-ml.git
cd my-entire-ml
pip install -e .
```

### Building the Package

```bash
pip install build
python -m build
```

### Publishing to PyPI

```bash
pip install twine
twine upload dist/*
```
decancer_py 0.4.1
Python bindings for decancer.
Requires Python: <3.15,>=3.10.0

# decancer_py

Python bindings for [decancer](https://github.com/null8626/decancer).

## Installation

You can get started with `decancer_py` by installing from PyPI:

```bash
pip install -U decancer-py
```

## Usage

`decancer_py` can be used to turn sketchy text strings into their more
basic counterparts.

A single function and class are exported from `decancer_py`:

- `CuredString` - A wrapper around a string object that can be used for comparisons.
- `parse` - Parse a jank string into a normal string wrapped in a `CuredString` object.

```py
from decancer_py import parse, CuredString

parsed: CuredString = parse("𝔂ＥＥ𝓣")

assert "ee" in parsed
assert parsed == "yeet"
assert parsed.contains("ee")
assert parsed.ends_with("et")
assert parsed.starts_with("ye")

# Implicit string conversion
print(parsed)
# yeet
```

## License

`decancer_py` is licensed under the
[MIT License](https://github.com/Jonxslays/decancer_py/blob/master/LICENSE).
rmvenv 0.3.0
Find and delete built environments
Requires Python: >=3.10
Keywords: venv, delete, manage, list, rust, target, archive

# rmvenv

Command line app to list and delete build environments. This only leaves
your source code and files to rebuild the environment, so they can be
easily backed up.

This software can identify build environments of multiple languages
directory, as well as Java's `.class` files. If deleted, this
can save gigabytes of space, and they can be easily recreated and the
packages re-downloaded and compiled when the code needs to run again. This
software can also show and delete files and folders over a given size.

The identification of build directories is done via regular expressions in a
`rmvenv_config.toml` file in your `.config` directory. This config looks like
this:

```toml
# The default size items are 'marked' when using the '--size' or '-s' flag
default_max_size = "100m"

# if a base filename matches one of these regexes, it'll be marked`
marked_files = [
  '\*.class' # Java
]

# Ignore any files in a directory matching these regexes
ignored = [
  '\.git'
]

[project.Python]
# If a directory contains a file who's able that matches this regex...
marker = '^((requirements\.txt)|(pyproject.toml))$'

# then mark any items who's name matches this expression, either for printing
# or deleting
marked = '.*venv'
```

Comes out-of-the-box with C++, C#, Java, Python, and Rust. Add new build
environments with as needed!

## Installation

### Requirements

- Python >= 3.10
- pip
- Linux

### Steps

Open the command line and run

```
pip install rmvenv
```

On some Linux distributions [pipx](https://pipx.pypa.io/latest/)
may have to be used:

```
pipx install rmvenv
```

## Example uses

On the command line, to list build environments in the currently
directory, simply use:

```
rmvenv
```

To delete (interactively) build environments, as well as large files and
folders over 1 gigabytes in the folder `my_code`:

```
rmvenv -s 1G --delete my_code
```
flex-data-sdk 1.1.1
Handy tools for data access
Requires Python: >=3.9

# Flexitricity Data Tool Kit 🛠️

![coverage](https://img.shields.io/badge/coverage-100-green)
![pylint-score](https://img.shields.io/badge/pylint-10-green)

Handy tools for data access within Flexitricity.

[Full documentation is available](https://flex-data-docs.azurewebsites.net/flexdata/data.html)

Note that for easier distribution this project is open source, although it's unlikely that functions within here would be of use as packaged, outside of the company context.
ppp-svc-helper 0.3.14
Utility library for singing voice conversion work
Requires Python: >=3.9

# What is this
Contains various utilities for common SVC (singing voice conversion) data
 tasks
based on popular singing voice conversion libraries--interfaces for
pitch extraction, speech feature extraction, singing voice conversion, data augmentation.

# Credits
* [RVC](https://github.com/RVC-Project/Retrieval-based-Voice-Conversion-WebUI)
* Black, Dawn A. A., Li, Ma and Tian, Mi. "Automatic Identification of Emotional Cues in Chinese Opera Singing", in Proc. of 13th Int. Conf. on Music Perception and Cognition and the 5th Conference for the Asian-Pacific Society for Cognitive Sciences of Music (ICMPC 13-APSC0M 5 2014), Seoul, South Korea, August 2014.