semvec/pypi-packages huggingface dataset:
RapidUseML 1.0.3
Minimalistic Machine Learning Toolset.
Keywords: machine learning, whittle laboratory


# RapidUseML

Minimalistic Machine Learning Toolset used for quick training and usage of various models. 
One click for training, one click for prediction.


## Usage:

### Basics:

Prepare basic necessities for usage.

```
import RapidUse                                            # Ensure class is imported.
ml = RapidUse.ML()                                         # Create instance of class.
from pandas import read_csv                                # Get pandas to read CSVs.
```


### Prediction:

Predicts target value(s) based on input data provided, with automated model identification.
Note: ML.prdict(...) checks the folder and all directories within the folder its located in for the relevant model. 

```
input_dataset = read_csv("input_dataset.csv")              # Load dataset for pred.
target_column = "column_d"                                 # Prediction target.
prediction_set = ml.predict(input_dataset, target_column)  # Try to obtain ML pred.
```

### Training:

Trains many models based on dataset, select top 3 and optimise them for better performance.

```
training_dataset = read_csv("training_dataset.csv")        # Load dataset for training.
input_column_names = ["column_a", "column_b", "column_c"]  # What features to predict with.
target_column = "column_d"                                 # What component you want predicted.
train_test_ratio = 0.8                                     # What data % to dedicate to training.
ml.train(training_dataset, input_column_names, target_column, train_test_ratio)
```
db-repository 0.0.2
Reusable SQLite + SQLAlchemy async repository module
Requires Python: >=3.8

# db_repository

A reusable Python module that integrates SQLite, SQLAlchemy (async), and the repository pattern.

## Features

- Async database access using SQLite and SQLAlchemy.
- Implements the repository pattern.
- Fully tested and reusable.


## Installation

```bash
pip install db-repository
```

## Usage locally
```
python -m venv local-venv
./local-venv/Scripts/activate
pip install -r requirements.txt 
OR
pip install .[build]      # Install build tools
pip install .[test]       # Install test tools
pip install .[dev]        # Install all dev tools

if python.exe access denied: Remove-Item -Recurse -Force E:\GitProjects\Python\db_repository\local-venv
```
bor2diggs 0.1.2
Convert BOR files to DIGGS
Requires Python: >=3.9

bor2diggs
=========

Convert `BOR files`_ to `DIGGS`_

Demo : `bor2diggs-demo.lim.eu`_

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

You can install, upgrade, uninstall borfile with these commands::

  $ pip install bor2diggs


Usage
-----

::

  Usage: bor2diggs [OPTIONS] BOR_INPUT

    Convert BOR file to a DIGGS.

  Options:
    -o, --output FILE
    --help             Show this message and exit.

::

  $ bor2diggs file.bor -o file.diggs


.. _`bor2diggs-demo.lim.eu`: https://bor2diggs-demo.lim.eu
.. _`BOR files`: https://bor-form.at/en/
.. _`DIGGS`: https://www.geoinstitute.org/special-projects/diggs
eotransform-pandas 1.1.2
Implements transformations on pandas DataFrame, to be used with eotransform streamed_process.

![Coverage badge](https://raw.githubusercontent.com/TUW-GEO/eotransform-pandas/python-coverage-comment-action-data/badge.svg)

# eotransform-pandas

Implements pandas specific transformations following the eotransform protocol.

WIP: More Doc
progzee 0.1.4
A Python tool for making HTTP requests with proxy rotation.
Requires Python: >=3.6

# progzee
Progzee is a Python library for simplifying IP proxy usage in HTTP requests, with proxy rotation. It simplifies handling proxies for web scraping, API interaction, and more.

<div align="center">

[![GitHub Repo stars](https://img.shields.io/github/stars/kiselitza/progzee?style=for-the-badge&logo=github&logoColor=EFBF04&color=EFBF04)](https://star-history.com/#kiselitza/progzee)
[![License](https://img.shields.io/github/license/kiselitza/progzee?style=for-the-badge&logo=gitbook&link=https%3A%2F%2Fgithub.com%kiselitza%2Fprogzee%2Fblob%2Fmain%2FLICENSE)](/LICENSE)

</div>

**Key Features**:
- IP Proxy rotation.
- Config file support for easy setup.
- CLI support for quick tasks.

## Installation
Install Progzee using pip:

```bash
pip install progzee
```

Usage with proxies passed in constructor:
```python
from progzee import Progzee

# Initialize with proxies explicitly
proxies = ["http://proxy1:port", "http://proxy2:port"]
pz = Progzee(proxies=proxies)

# Make a request
response = pz.get("https://example.com")
print(response.text)
```
Usage with `config.ini`:
```python
from progzee import Progzee

# Initialize with config file
pz = Progzee(config_file="config.ini")
```

CLI Usage:
```java
# Update proxies from a config file
progzee update-proxies --config "config.ini"

# Fetch data from a URL
progzee fetch --url "https://example.com"
```

An example of a `config.ini` file:
```
[progzee]
proxies = http://proxy1:port, http://proxy2:port
timeout_min = 5
timeout_max = 15
```

## Error handling
Progzee automatically retries failed requests with the next proxy in the rotation.

## Validate your proxies
Make sure that you're using valid proxies that you own, or from trusted vendors. One of the trusted vendors you can use is [ProxyScrape](https://proxyscrape.com/?ref=yzczyjq).

## License
Progzee is licensed under the Apache License 2.0. See [LICENSE](LICENSE) for more details.

## ⚠️ DISCLAIMER ⚠️
This tool is intended for ethical use cases only, including educational purposes, testing, and legitimate API interactions.

The tool is provided as-is, without any warranty. The author is not responsible for any damages or legal issues arising from its use.

Users are responsible for ensuring their usage complies with the Terms of Service of the APIs they interact with. Misuse of this tool, including but not limited to scraping without permission, bypassing rate limits, or engaging in malicious activities, is strictly prohibited.

By using this tool, you agree to use it responsibly and in compliance with all applicable laws and regulations.
nuwan-colors 0.1.2
A lightweight package for adding customizable text coloring and styling to terminal output, making console applications more visually appealing and readable

# NuwanColors

A lightweight package by Shashika Nuwan (DevNuwancat) for adding customizable text coloring and styling to terminal output.

## Installation

```bash
pip install nuwan_colors

## Usage

from nuwan_colors import Colors
print(Colors.red("Hello, World!"))
robotframework-mockserverlibrary 0.9.3
Robot framework library for MockServer
Keywords: testing robotframework mockserver mock stub

# MockServer Robot Framework Library

This project implements the Robot Framework keywords to interact with [MockServer](http://www.mock-server.com/) through HTTP.

## Installation

```sh
$ pip install robotframework-mockserverlibrary
```

## Usage

Add library to settings section:

```
*** Settings ***
Library  MockServerLibrary
```

[Keyword documentation for the latest release](https://frankvanderkuur.github.io/docs/robotframework-mockserverlibrary.html)

See tests/robot/tests/mock_server.robot for detailed usage examples.
muda-imagem-9-16 0.1.0
A tool to resize images to 9:16 format
Requires Python: >=3.6

# Image Resizer 9:16

Python script to automatically adjust images to a 9:16 aspect ratio.

## How to Use

1. Install dependencies: pip install -r requirements.txt


## Features

- Automatically resizes images to 9:16 aspect ratio
- Preserves image quality without distortion
- Ideal for preparing content for platforms like TikTok, Instagram and others


## Usage

1. Place the images you want to resize in the input_images folder
2. Run the script: python resize_images_9-16.py
3. Resized images will be saved in the output_images folder

### USING THE PIP Package###

pip install muda-imagem-9-16

muda-imagem input.jpg


## ðŸ§¹ Cleaning Input and Output Folders

To remove all files inside `input_images` and `output_images` while keeping the folders intact, run:

```bash
python clean_folders.py


## Contributing

Contributions are welcome! Please open an issue or submit a pull request.


## License? (No!) 

Iâ€™m committed to keeping this project open source and welcome contributions from anyone passionate about improving it!
asset-loader 0.0.1
Package for loading multiple assets of the same type in Python.
Requires Python: >=3.13.2

# py-asset-loader

Override the provided classes and implement your assets folder.

## Examples:

* You have multiple Python classes deriving from another python class that extend it, but aren't directly referenced by your code.

```
/project
|- task.py
|- task_list.py
/assets
  /tasks
  |- write_hello_world_every_minute.py # is descendant of a class from task.py
  |- daily_plan_for_world_dominance.py # is descendant of a class from task.py
  |- monthly_defeat_the_demon_king.py # is descendant of a class from task.py
```

* You have multiple yaml/json-Files that describe a workflow or a class in your code

```
/project
|- table.py
/assets
  /db_tables
  |- customer.yaml
  |- article.yaml
  |- shop.yaml
```

## Usage 1 - use the existing templates for Yaml/JSON/Py Files

### Yaml/JSON

* Override `YamlAsset`/`JSONAsset`.
    * you can access the `self.source` object for information retrieval.
    * I recommend you to make @properties for retrieving the information for cleaner code.
* Override `YamlAssetLoader[T]`/`JSONAssetLoader[T]` with your `YamlAsset`/`JSONAsset` derivative
    * define the `asset_folder_name()` and `asset_class()` methods.
* Create your yaml/json files inside the folder */assets/<asset_folder_name()>/
```py
class MyTable(YamlAsset):
    @property
    def some_field(self):
        return self.source.get("some_field")

class MyTables(YamlAssetLoader[MyTable]):
    @override
    def asset_class(self) -> Type[MyTable]: return MyTable
    @override
    def asset_folder_name(self) -> str: return 'db_tables'
```

### Python

* Override `PythonAsset` with your base Python class.
    * define the classmethod `base_asset_class_name` to return the class name of your main derivative.
    * define your properties and methods that you want to override in your asseted classes.
* Override `PythonAssetLoader[T]` with your `PythonAsset` derivative and define the `asset_folder_name()` method.
* Create your python files inside the folder */assets/<asset_folder_name()>/
    * These modules will only be loaded regardless of wheter they contain a derivative of your `PythonAsset` derivative or not.
    * The derivatives are automatically instantiated and added into your Loader's `loaded_assets`.

```py
class Task(PythonAsset):
    @abstractmethod
    def type(self) -> Enum: ...
    @abstractmethod
    async def execute(self) -> any:

class Tasks(PythonAssetLoader[Task]):
    @override
    def asset_folder_name(self) -> str: return 'tasks'

    def get_task(self, type: Enum) -> Task:
        return next([task for task in self.loaded_assets if task.type() == type])

assets/tasks/daily_plan_for_world_dominance.py
...

class PlanForWorldDominance(Task):
    @override
    def type(self) -> Enum: return ...
    @override
    async def execute(self) -> any: print('veni vidi vici')
```

## Usage 2 - implement your own loader

* Simply override the `LoadedAsset` and the `AssetLoader` in a similar manner to the existing derivatives.