semvec/pypi-packages huggingface dataset:
cleanPyData 0.1.8
A package for data cleaning and preprocessing
Requires Python: >=3.6

# cleanPyData

An awesome Python package for data cleaning and preprocessing.

cleanPyData is a robust and easy-to-use Python package designed to streamline the data cleaning and preprocessing phase of your data science projects. It provides essential functionalities for handling missing values, normalizing data, extracting important features, and detecting outliers, ensuring that your data is ready for analysis or machine learning.

## Features

- Handle Missing Values: Clean your dataset by filling in missing values using various strategies (mean, median, mode) or by dropping them entirely.
- Normalize Data: Apply normalization techniques such as Min-Max scaling and Z-score normalization to standardize your data.
- Feature Extraction: Select the most important features from your dataset to improve model performance and reduce overfitting.
- Outlier Detection: Detect and remove outliers using methods like Z-score and Interquartile Range (IQR).

### Built With

- Python
- Pandas
- NumPy
- sklearn

## Getting Started

To get a local copy up and running follow these simple steps.

### Prerequisites

- Python 3.x

### Installation

```sh
pip install cleanPyData
```

## Usage

```sh
import pandas as pd
from cleanPyData import (
    handle_missing_values,
    normalize_data,
    extract_features,
    detect_outliers
)

# Example DataFrame
data = {
    'A': [1, 2, None, 4],
    'B': [4, None, 6, 8],
    'C': [5, 6, 7, 8],
    'target': [1, 0, 1, 0]
}
df = pd.DataFrame(data)

# Handle missing values
df = handle_missing_values(df, strategy='mean')

# Normalize data
df = normalize_data(df, method='minmax')

# Extract features
df = extract_features(df, target='target', k=2)

# Detect outliers
df = detect_outliers(df, method='zscore', threshold=3)

print(df)
```

## Roadmap

- [ ] Add more cleaning and preprocessing functionalities
- [ ] Improve performance and efficiency
- [ ] Add more examples and documentation

## Contributing

Contributions are what make the open-source community such an amazing place to learn, inspire, and create. Any contributions you make are **greatly appreciated**.

1. Fork the Project
2. Create your Feature Branch (`git checkout -b feature/AmazingFeature`)
3. Commit your Changes (`git commit -m 'Add some AmazingFeature'`)
4. Push to the Branch (`git push origin feature/AmazingFeature`)
5. Open a Pull Request

## License

Distributed under the MIT License. See [MIT License](https://opensource.org/licenses/MIT) for more information.

## Contact

Kaddu Livingstone - kaddulivingston@gmail.com

Project Link: [https://github.com/Livingston-k/cleanPyData](https://github.com/Livingston-k/cleanPyData)

## Follow Me

- [Follow me on X](https://x.com/KadduLivingston)
- [Follow me on LinkedIn](https://www.linkedin.com/in/kaddu-livingstone/)
streamlit-qs 0.3.3
A small library to add extra functionality on top of streamlit's st.query_params API
Requires Python: !=3.9.7,>=3.8
Keywords: streamlit, query, url, query_params, widgets, extension, community, permalink, state, save, data

# QueryParams Widgets for Streamlit

[![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/asaurus1/streamlit-qs/pdm.yml)](https://github.com/Asaurus1/streamlit-qs/actions)
[![GitHub last commit](https://img.shields.io/github/last-commit/asaurus1/streamlit-qs)](https://github.com/Asaurus1/streamlit-qs)
[![PyPI - Version](https://img.shields.io/pypi/v/streamlit-qs)](https://pypi.org/project/streamlit-qs/)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/streamlit-qs)
![PyPI - Wheel](https://img.shields.io/pypi/wheel/streamlit-qs)
![PyPI - Implementation](https://img.shields.io/pypi/implementation/streamlit-qs)
![PyPI - Downloads](https://img.shields.io/pypi/dm/streamlit-qs)
[![Licence](https://img.shields.io/badge/licence-Apache%202.0-blue)](https://www.apache.org/licenses/LICENSE-2.0)
[![Streamlit Version](https://img.shields.io/badge/Streamlit->=1.30.0-blue)](https://github.com/streamlit/streamlit)
[![pdm-managed](https://img.shields.io/badge/pdm-managed-blueviolet)](https://pdm-project.org)

The functions in this library allow you to easily create "permalink-like" functionality in your application,
This can let users to share links with others that will populate streamlit with the same set of input values
that they were using. Or you can use the query string to pass data into your streamlit application from
another website or program.


## Installation

First install Streamlit (of course!) then install this library:

```bash
pip install streamlit-qs
```
Or, to install the latest source:
```bash
pip install git+https://github.com/Asaurus1/streamlit-qs.git@main
```

## Example

```python
import streamlit as st
import streamlit_qs as stqs

st.markdown("[Click this URL](?input_some_text=Hello+World)") 
stqs.text_input_qs("Enter Some Text", key="input_some_text")
```

For more examples, including :sparkles:**customization options**:sparkles:, see
[the demo app](https://query-string.streamlit.app/).


## Version Compatibility
For Streamlit v1.29.0 or below use release v0.2.0 of this app
For Streamlit v1.30.0 or above, use the latest released version of this app above v0.2.0
gibby-motifFinding 0.1
Process genomic data to extract peak sequences and compute PWMs.
Requires Python: >=3.6

# MyPackage

gibby_run is a Python package that processes genomic data to extract peak sequences and compute Position Weight Matrices (PWMs). This tool can be used for motif finding and other genomic analyses.

## Features

- Extract peak sequences from genomic data
- Compute Position Weight Matrices (PWMs)
- Run Gibbs Sampling for motif finding

## Installation

You can install the package via pip:

```sh
pip install gibby_run
yoli 0.0.0
A simply cli app that indexes videos using YOLOv10
Requires Python: <4.0,>=3.11

# yoli

A simply cli app that indexes videos using YOLOv10.

> [!WARNING]
> This is a work in progress. The code is not yet stable and just a quick sketch of an AI powered cli video indexer.

## Installation

```bash
pip install yoli
```

## Usage

```bash
yoli --help
```

# Video Indexing

```bash
yoli vindex data/city.mp4
Video file is valid: data/city.mp4
Processing frames: 100%|█████████████████████████████████████████████████████████████████| 275/275 [00:26<00:00, 10.45it/s]
Results saved to data/city.mp4.pt
```

# Most Common Objects

```bash
yoli common data/city.mp4.pt
car: 2364
person: 47
truck: 42
traffic light: 39
clock: 6
```

# Where and When an Object Appears

```bash
yoli where data/city.mp4.pt person
person appears between frames 0 and 40
```

## Development

some helpful commands for development

```bash
uv venv
source .venv/bin/activate
poetry build
poetry install
```
torchinterp1d 1.1
An interp1d implementation for pytorch
Keywords: interp1d torch

# torchinterp1d
## CUDA 1-D interpolation for Pytorch

Requires PyTorch >= 1.6 (due to [torch.searchsorted](https://pytorch.org/docs/master/generated/torch.searchsorted.html)).

## Presentation

This repository implements an `interp1d` function that overrides torch.autograd.Function, enabling
linear 1D interpolation on the GPU for Pytorch.

```
def interp1d(x, y, xnew, out=None)
```

This function returns interpolated values of a set of 1-D functions at the desired query points `xnew`.

It works similarly to Matlab™ or scipy functions with
the `linear` interpolation mode on, except that it parallelises over any number of desired interpolation problems and exploits CUDA on the GPU

### Parameters for `interp1d`

* `x` : a (N, ) or (D, N) Pytorch Tensor:
Either 1-D or 2-D. It contains the coordinates of the observed samples.

* `y` : (N,) or (D, N) Pytorch Tensor.
Either 1-D or 2-D. It contains the actual values that correspond to the coordinates given by `x`.
The length of `y` along its last dimension must be the same as that of `x`

* `xnew` : (P,) or (D, P) Pytorch Tensor.
Either 1-D or 2-D. If it is not 1-D, its length along the first dimension must be the same as that of whichever `x` and `y` is 2-D. x-coordinates for which we want the interpolated output.

* `out` : (D, P) Pytorch Tensor`
        Tensor for the output. If None: allocated automatically.

### Results

a Pytorch tensor of shape (D, P), containing the interpolated values.

## Installation

Type `pip install -e .` in the root folder of this repo.

## Usage

Basically simply calle `torchinterp1d.interp1d`.

Try out `python test.py` in the `examples` folder.
```
Solving 100000 interpolation problems: each with 100 observations and 30 desired values
CPU: 8060.260ms, GPU: 70.735ms, error: 0.000000%.
```