semvec/pypi-packages huggingface dataset:
imperio 0.1.5
Imperio is a python sci-kit learn inspired package for feature engineering.
License: MIT
Keywords: ml,machine learning,feature engineering,python,data science


# imperio

Imperio is a python sci-kit learn inspired package for feature engineering. It contains a some feature transformers to make your data more easy to learn from for Machine Learning Algorithms.

This version of imperio has the next methods of feature selection:
1. Box-Cox (BoxCoxTransformer).
2. Clusterize (ClusterizeTransformer).
3. Combinator (CombinatorTransformer).
4. Frequency Imputation Transformer (FrequencyImputationTransformer).
5. log Transformer (LogTransformer).
6. Smoothing (SmoothingTransformer).
7. Spatial-Sign Transformer (SpatialSignTransformer).
8. Target Imputation Transformer (TargetImputationTransformer).
9. Whitening (WhiteningTransformer).
10. Yeo-Johnson Transformer (YeoJohnsonTransformer).
11. ZCA (ZCATransformer).

All these methods work like normal sklearn transformers. They have fit, transform and fit_transform functions implemented.

Additionally every imperio transformer has an apply function which allows to apply an transformation on a pandas Data Frame.

# How to use imperio

To use a transformer from imperio you should just import the transformer from imperio in the following framework:
```python
from imperio import BoxCoxTransformer
```

class names are written above in parantheses.

Next create a object of this algorithm (Box-Cox is used as an example).

```python
method = BoxCoxTransformer()
```

Firstly you should fit the transformer, passing to it a feature matrix (X) and the target array (y).
NOTE: y argument is really used only by the Target-Imputation.

```python
method.fit(X, y)
```

After you fit the model, you can use it for transforming new data, using the transform function. To transform function you should pass only the feature matrix (X).

```python
X_transformed = method.transform(X)
```

Also you can fit and transform the data at the same time using the `fit_transform` function.

```python
X_transformed = method.fit_transform(X)
```

Also you can apply a transformation directly on a pandas DataFrame, choosing the columns that you want to change.

```python
new_df = method.apply(df, 'target', ['col1', 'col2']
```

Some advice:
1. Use `FrequencyImputationTransformer` or `TargetImputationTransformer` for categorical features.
2. Use `BoxCoxTransformer` or `YeoJohnsonTransformer` for numerical features to normalize a feature distribution.
3. Use `SpatialSignTransformer` on normalized data to bring outliers to normal samples.
4. Use `CombinatorTransformer` on tombine different transformers on categorical and numerical columns separately.

With <3 from Sigmoid!

We are open for feedback. Please send your impressions to vladimir.stojoc@gmail.com
fortnite-replay-parser 0.1.0
Minimal library intended to parse events in Fortnite replay files.
License: MIT
Requires Python: >=3.8,<4.0

# Fortnite Replay Parser

Minimal Python library intended to parse events in Fortnite replay files from Chapter 4 Season 1 with backwards compatibility for earlier versions.

## Example Usage

Here is an example function that will output match events regarding player eliminations and other statistics to a JSON file in the root directory.

This should help you get started with using the library and collecting data from game replays:
```python
import json
import os
from reader import FortniteReplayReader

from pydantic.json import pydantic_encoder

filename = os.path.join(os.path.dirname(__file__), "your_replay_file.replay")
with FortniteReplayReader(filename) as replay:
    header = replay.header.dict()
    metadata = replay.metadata.dict(exclude={"encryption_key"})

    output = {"header": header, "metadata": metadata, "events": replay.events}
    with open("replay_dump.json", "w") as f:
        json.dump(output, f, indent=4, default=pydantic_encoder)
```

## Credits

Credits to [Shiqan](https://github.com/Shiqan) for various protocol documentation and developing the original Python implementation. This library is a fork of [that project](https://github.com/Shiqan/fortnite-replay-reader).

Credits to [xNocken](https://github.com/xNocken) whose Node library proved to be a great reference in getting started with updating this project.
Mashup-Chitraksh-102017040 0.0.1
This module creates a mashup of songs of your favorite singer with a single click.
License: MIT
Keywords: MASHUP,YOUTUBE,PROJECT,UCS654,MUSIC,MP3

# Mashup Module by Chitraksh Kumar

## Roll No. 102017040

## Description
This module creates a mashup of songs of your favorite singer with a single click.

## Requirements
``` 
pip install pytube
pip install pydub
```

## Install
Download the code using pip
```
pip install Mashup-Chitraksh-102017040
```

## Running the code
```
102017040 102017040.py "Sharry Mann" 20 20 102017040-output.mp3
```
paichat 1.0.2
A Terminal experience
License: MIT
Requires Python: >=3.9,<4.0

# Python Open AI CLI Client [Un-official]

Published on pypi: https://pypi.org/project/paichat/
![PyPI - Downloads](https://img.shields.io/pypi/dm/paichat?style=for-the-badge) ![PyPI](https://img.shields.io/pypi/v/paichat?style=for-the-badge) ![PyPI - Format](https://img.shields.io/pypi/format/paichat?style=for-the-badge)

Supported ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/paichat?style=for-the-badge)

A Terminal Tool in Python

## Prerequisites
- `pipx`. If you don't have pipx installed, you can install like this:
  - `python3 -m pip install --user pipx`
  - `python3 -m pipx ensurepath`
- You'll also need to have your own OpenAi apikey:
  - Go to https://beta.openai.com/
  - Select you profile menu and go to Manage API Keys
  - Select + Create new secret key
  - Copy generated key

## Install:
`pipx install paichat`

## Usage:
`paichat --help`

```sh
 Usage: paichat [OPTIONS]

╭─ Options ───────────────────────────────────────╮
│ --help          Show this message and exit.     │
╰─────────────────────────────────────────────────╯
```

## Contribute:

![PyPI - License](https://img.shields.io/pypi/l/paichat?style=for-the-badge)

### Dev:

Start a virtualenv using poetry: `poetry shell`

If `poetry shell` does not activate the virtualenv, then use this:
`source $(poetry env info --path)/bin/activate`
When you're done, exit virtualenv shell: `deactivate`
reparo 0.0.6
Reparo is a python sci-kit learn inspired package for Missing Value Imputation.
License: MIT
Keywords: ml,machine learning,feature engineering,python,data science


# reparo

Reparo is a python sci-kit learn inspired package for Missing Value Imputation. It contains a some feature transformers to eliminate Missing Values (NaNs) from your data for Machine Learning Algorithms.

This version of reparo has the next methods of missing value imputation:
1) Cold-Deck Imputation (CDI).
2) Hot-Deck Imputation (HotDeckImputation).
3) Fuzzy-Rough Nearest Neighbor for Imputation (FRNNI).
4) K-Nearest Neighbors Imputation (KNNI).
5) Single Center Imputation from Multiple Chained Equation (SICE).
6) Predictive Mean Matching (PMM).
7) Multivariate Imputation by Chained Equation (MICE).

All these methods work like normal sklearn transformers. They have fit, transform and fit_transform functions implemented.

Additionally every reparo transformer has an apply function which allows to apply an transformation on a pandas Data Frame.

# How to use reparo
To use a transformer from reparo you should just import the transformer from reparo in the following framework:

```python
from reparo import MICE
```

class names are written above in parantheses.

Next create a object of this algorithm (I will use k-Nearest Neighbors Imputation as an example).

```python
method = KNNI()
```

Firstly you should fit the transformer, passing to it a feature matrix (X) and the target array (y). y argument is not really used (as it causes data leackage)

```python
method.fit(X, y)
```

After you fit the model, you can use it for transforming new data, using the transform function. To transform function you should pass only the feature matrix (X).

```python
X_transformed = method.transform(X)
```

Also you can fit and transform the data at the same time using the fit_transform function.

```python
X_transformed = method.fit_transform(X)
```

Also you can apply a transformation directly on a pandas DataFrame, choosing the columns that you want to change.

```python
new_df = method.apply(df, 'target', ['col1', 'col2'])
```

With <3 from Sigmoid.
We are open for feedback. Please send your impression to vladimir.stojoc@gmail.com