semvec/pypi-packages huggingface dataset:
nomad-docs 0.1.3
Add your description here
Requires Python: >=3.10

## `nomad-docs`

This repository contains the documentation for the central NOMAD distribution.

### Contributing

To contribute, please open a pull request (PR) with your changes.

#### Running the Docs Server Locally

You have two options to run the documentation server:

1. Use the [nomad-dev-distro](https://github.com/FAIRmat-NFDI/nomad-distro-dev?tab=readme-ov-file#day-to-day-development) command.

2. Or manually install the required dependencies and run:

```bash
uv run mkdocs serve
```

This will start a local server where you can preview your changes.
snapbox-api 0.1.1
A background removal CLI tool using InSPyReNet model
Requires Python: >=3.8

# RemoveBG CLI

A Python command-line tool for background removal from images and videos.

## Installation

```bash
pip install snapbox-api
```

## Usage

1. Process a single image:
```bash
snapbox-api image -i "input.jpg" -o "output.png"
```

2. Process a video:
```bash
snapbox-api video -i "input.mp4" -o "output.mp4"
```

3. Extract video mask only:
```bash
snapbox-api video -i "input.mp4" -mk -o "output.mp4"
```

## Requirements

- Python 3.8 or higher
- Dependencies are automatically installed with the package:
  - Pillow (for image processing)
  - rembg (for background removal)
  - OpenCV (for video processing)
  - NumPy (for array operations)

## License

MIT License
edict-iot 1.0.0
Simulator for IoT data flow performance
Requires Python: >=3.7

# EDICT

EDICT is a simulation tool for evaluating the performance of Edge interactions in IoT-enhanced environments.
It generates a performance metrics dataset as a CSV file by relying on queueing network models.


## Installation 
EDICT can be installed with the following command
```
$ pip install edict-iot
```

## Using EDICT

EDICT can be run either through the CLI, or can be called within your Python modules.
Running EDICT requires 4 arguments:
- an input file, which contains the IoT system specification. Note that the input file should be located in a subdirectory called `files`.
- an output file, which refers to the output dataset where response time metrics will be saved. This dataset will contain aggregated results for all simulation runs.
- a duration (in seconds), which refers for how long the simulation should be run for. We recommend running the simulation for a duration of 3 to 5 minutes to achieve confidence levels higher than 95%.
- an alias to identify the simulation. This alias will also be used to identify the simulation in the output file.

To run EDICT using the CLI, you can run the following command:

```
$ edict --input files/input_file.json --output output_file.csv --duration duration --alias alias
```

You can also import EDICT in your Python code and call the `simulate` function with the same arguments, as follows:

```
import edict

edict.simulate(input_file=input_file, output_file=output_file, simulation_duration=duration, alias=alias)
```

EDICT will generate 2 CSV files containing performanc metrics:
- A CSV file of the form `alias_input_file.csv`, located in the `files` directory. This file contains response time, throughput, and drop rate metrics per subscription. For each simulation, an individual file will be created.
- A CSV file of the form `output_file.csv`. This file will contain aggregated response time results for all simulations that you run and that have `output_file.csv` as their output file. This file can be used for performance optimization approaches, for instance.

For more information about EDICT, please check https://github.com/houssamhh/edict.
pythontextstats 0.1.3
A Python package for text analysis
Requires Python: >=3.6

# Python Text Stats

A simple Python module to analyze text and provide various statistics such as word count, sentence count, average word length, estimated reading time, character count, syllable count, and readability scores.

## Features

- Count words
- Count sentences
- Average word length
- Estimated reading time (default 200 WPM)
- Character count (excluding spaces)
- Estimate syllable count
- Calculate Flesch Reading Ease score
- Calculate Flesch-Kincaid Grade Level

## Installation

Simply download the `pip install pythontextstats` file into your project.

## Usage

```python
import pythontextstats as pts

text = "This is a simple example sentence. It has multiple words and sentences."

print("Words:", pts.word_count(text))
print("Sentences:", pts.sentence_count(text))
print("Average Word Length:", pts.average_word_length(text))
print("Reading Time (minutes):", pts.reading_time(text))
print("Character Count:", pts.character_count(text))
print("Syllable Count:", pts.syllable_count(text))
print("Flesch Reading Ease:", pts.flesch_reading_ease(text))
print("Flesch-Kincaid Grade Level:", pts.flesch_kincaid_grade(text))
mldataforge 0.6.10
swiss army knife of scripts for transforming and processing datasets for machine learning.
Requires Python: >=3.12

# mldataforge
swiss army knife of scripts for transforming and processing datasets for machine learning

## conversion
Currently, mldataforge provides space- and time-efficient conversions between JSONL (with or without compression), MosaiclML Dataset (MDS format), and Parquet. The implementations handle conversions by individual samples or small batches of samples and make efficient use of multi-core architectures where possible. Consequently, mldataforge is an excellent choice when transforming TB-scale datasets on data processing nodes with many cores.

## splitting
Currently, mldataforge provides space- and time-efficient splitting of JSONL (with or without compression). The implementations handle conversions by individual samples or small batches of samples and make efficient use of multi-core architectures where possible. The splitting function can take an already splitted dataset and re-split it with a different granularity.

## installation and general usage
```
pip install mldataforge
python -m mldataforge --help
```

## usage example: converting MosaiclML Dataset (MDS) to Parquet format
```
Usage: python -m mldataforge convert mds parquet [OPTIONS] OUTPUT_FILE
                                                 MDS_DIRECTORIES...

Options:
  --compression [snappy|gzip|zstd]
                                  Compress the output file (default: snappy).
  --overwrite                     Overwrite existing path.
  --yes                           Assume yes to all prompts. Use with caution
                                  as it will remove files or even entire
                                  directories without confirmation.
  --batch-size INTEGER            Batch size for loading data and writing
                                  files (default: 65536).
  --no-bulk                       Use a custom space and time-efficient bulk
                                  reader (only gzip and no compression).
  --help                          Show this message and exit.
```
dbis-magicmongo 0.1.0
RWTH Aachen Computer Science i5/dbis assets for Lecture Datenbanken und Informationssysteme
Requires Python: >=3.10

# dbis_magicmongo

An IPython extension providing custom magic commands to run MongoDB shell scripts (`mongosh`) directly within Jupyter notebooks.

## Installation

Install from PyPI 

```bash
pip install dbis_magicmongo
pytofi 0.0.1
Tests on Feature Importance
Requires Python: >=3.9

# TOFI: Tests on Feature Importance


## Overview
 
`tofi` is a python package for conducting tests on feature importance in machine learning. It is written on the basis of [`scikit-learn`](https://scikit-learn.org/stable/index.html). Hence, in principle, any regressor/classifier learned by `scikit-learn` can be inferred by `tofi`.

`tofi` provides two types of `Inferer` for making inferences: `CIT` for conditional independence test and `RIT` for risk invariance test. `CIT` can implement the holdout randomization test (HRT; Tansey et al., 2022), residual permutation test (RPT; Huang, 2024), and conditional predictive impact (CPI; Watson & Wright, 2021). On the other hand, `RIT` can conduct leave-one-covariate-out (LOCO; Lei et al., 2018) and plug-in estimation (PIE; Williamson et al., 2023). In addition, `tofi` also constructs a `Crosser` class. With the help of `Crosser`, cross-fitting and $p$-value combination can be easily implemented to improve the stability and even statistical power of the CITs and RITs.

## Installation
`tofi` can be installed via `pip`:
```
pip install pytofi
```

## Tutorial

Three Jupyter notebooks are available to learn the use of `sial`:

1. [Conditional Independence Tests](https://github.com/aipsylab/tofi/blob/main/tutorial/tutorial_1_cit.ipynb)
2. [Risk Invariance Tests](https://github.com/aipsylab/tofi/blob/main/tutorial/tutorial_2_rit.ipynb)
3. [Cross-Fitting and $p$-Value Combination](https://github.com/aipsylab/tofi/blob/main/tutorial/tutorial_3_crosser.ipynb)

These notebooks assume that readers have experiences in using `scikit-learn`.

## References

Huang, P.-H. (2024). Residual Permutation Tests for Feature Importance in Machine Learning. [Manuscript submitted for publication].

Lei, J., G’Sell, M., Rinaldo, A., Tibshirani, R. J., & Wasserman, L. (2018). Distribution-free predictive inference for regression. Journal of the American Statistical Association, 113(523), 1094–1111. doi: 10.1080/01621459.2017.1307116

Tansey, W., Veitch, V., Zhang, H., Rabadan, R., & Blei, D. M. (2022). The holdout randomization test for feature selection in black box models. Journal of Computational and Graphical Statistics, 31(1), 151–162. doi: 10.1080/10618600.2021.1923520

Watson, D., & Wright, M. (2021). Testing conditional independence in supervised learning algorithms. Machine Learning, 110, 1-23. doi: 10.1007/s10994-021-06030-6

Williamson, B. D., Gilbert, P. B., Simon, N. R., & Carone, M. (2023). A general framework for inference on algorithm-agnostic variable importance. Journal of the American Statistical Association, 118(543), 1645–1658. doi: 10.1080/01621459.2021.2003200
strike 0.0.1
Thrust is a library for building guardrails for your models.
Requires Python: <3.14,>=3.9

# 🤺 Enguard

One guardrail for all, all guardrails for one!

## Installation

```bash
pip install enguard
```

## Quick Start

## Guard Types

Guard types are focused on the type of guardrail you want to apply to your model.

- `input_guardrail`: Guardrail for the input of the model.
- `output_guardrail`: Guardrail for the output of the model.
- `both_guardrail`: Guardrail for both the input and output of the model.

## Guardrail Types

Guardrail types are focused on the type of guardrail you want to apply to your model.

- `input_guardrail`: Guardrail for the input of the model.
pggm-datalab-utils 2.19
Utilities created and used by the Datalab of PGGM
Requires Python: <4.0,>=3.9

# Datalab utils
Well-specified utilities from the Datalab of PGGM. Our aim with this package is to provide some tooling to make our lives a bit easier.
So far the package contains:
- Database utilities, allowing you to connect to cloud databases using pyodbc in a standard pattern.
- Helpers around nested lists (flattening and unflattening).
- Helpers to make working with lists of dictionaries a bit easier so you don't have to resort to Pandas as fast.

## How to use the database helpers
```python
from pggm_datalab_utils.db import cursor, query

bbg_id = 'WOW'

with cursor('pggm-sql-lre-o.database.windows.net', 'lre') as c:
    data = query(c, 'select sedol, name from portfolio where bbg_id=?', bbg_id)
```