semvec/pypi-packages huggingface dataset:
runefumbler 0.1.5
Don't be fumblin' no trades now
Requires Python: <4.0,>=3.11

# Runefumbler

The execution engine for interacting with runescape client.


## Project Development Setup

This project uses a Windows batch script, `dev.bat`, to simplify the management of the Python development environment. The script handles virtual environment creation, dependency management, formatting, and testing.


### Prerequisites

Ensure the following are installed on your machine:

- [Python 3.11](https://www.python.org/downloads/release/python-3110/)
- [Poetry](https://python-poetry.org/docs/#installation) (automatically installed if missing)

### Usage

#### 1. Setting up the Development Environment

To create a virtual environment and install the necessary dependencies, including development packages, run:

```bash
dev.bat create-dev
```

This will:
- Create a virtual environment in the `.venv` directory (if not already created).
- Install `poetry` inside the virtual environment (if not available).
- Install all project dependencies as defined in `pyproject.toml`, including the `dev` dependencies.
- run `.venv\Scripts\activate` to activate your env 


#### 2. Formatting Code

To automatically format your Python code using `black` and `isort`, run:

```bash
dev.bat format
```

This command applies both formatters across the project codebase.

#### 3. Checking Code Formatting

To check if your code adheres to the project's formatting standards without applying changes, run:

```bash
dev.bat format-check
```

This will verify that the code is formatted according to `black` and `isort` rules.

#### 4. Checking Dependencies

To check for any potential issues in your project dependencies, such as unused or incorrect packages, run:

```bash
dev.bat dep-check
```

#### 5. Updating the Development Environment

To update all the project dependencies to their latest compatible versions, run:

```bash
dev.bat update-dev
```

#### 6. Running Tests

To run the test suite with `pytest`, along with coverage reports, run:

```bash
dev.bat test
```

This command generates both terminal and HTML coverage reports, with coverage information for the `./runespreader` directory.

#### Available Commands

| Command         | Description                                                              |
|-----------------|--------------------------------------------------------------------------|
| `create-dev`    | Set up the virtual environment and install dependencies                  |
| `format`        | Format the code using `black` and `isort`                                |
| `format-check`  | Check the code formatting without making changes                         |
| `dep-check`     | Check for dependency issues using `deptry`                               |
| `update-dev`    | Update all project dependencies to their latest compatible versions      |
| `test`          | Run the test suite with `pytest` and generate coverage reports           |
pywithmysql 0.1.9
The library to work with MySQL databases for Python
Requires Python: >=3.6

## PyWithMySQL
PyWithMySQL is a simple and easy-to-use Python library for working with MySQL databases. It provides methods for connecting to the database, performing CRUD operations, and handling MySQL queries efficiently.

Installation
You can install the library using pip:

```pip install pywithmysql==0.1.7```
Features
Easy connection setup with MySQL Supports basic CRUD operations (Create, Read, Update, Delete) Flexible and extensible methods Error handling for database operations

Usage
Here is a quick example of how to use the library:

```python
from pywithmysql.settings import SettingsTable
from pywithmysql.config import DataBaseConfig

# Define your database configuration
config = DataBaseConfig(
    host="localhost",
    port=3306,
    user="root",
    password="password",
    db_name="test_db"
)

# Initialize the settings table with the table name
table = SettingsTable(config, "users")

# Connect to the database
table.connect()

# Create a new entry in the table
table.create(names=["name", "age"], values=["'Alice'", "30"])

# Read all entries from the table
rows = table.read_all()
for row in rows:
    print(row)

# Update an entry
table.update_data(names=("age",), values=("31",), id=1)

# Delete an entry by id
table.delete_for_id(id=1)

# Disconnect from the database
table.disconnect()
```
## Creating a Table
To create a table, use the Table class along with the Column class to define columns. Here’s a code example:

```python
from pywithmysql.table import Table, Column
from pywithmysql.types import IntegerField, CharField
from pywithmysql.config import DataBaseConfig

# Database connection settings
config = DataBaseConfig(
    host="localhost",
    port=3306,
    user="user",
    password="password",
    db_name="db_name"
)

# Initialize Table
table = Table(
    "users",
    config,
    Column("username", CharField, max_length=45, nullable=False, unique=True),
    Column("age", IntegerField, default=18),
    Column("email", CharField, max_length=100, unique=True, nullable=False),
    Column("phone_number", CharField, unique=True)

)

# Create the table
table.create_table()
```
## Methods
```connect()``` Establishes a connection to the MySQL database using the provided configuration.

```create(names: list, values: list)``` Inserts a new row into the table. You must provide column names and their corresponding values.

```read_all()``` Fetches all rows from the table.

```update_data(names: tuple, values: tuple, id: int)``` Updates specific fields for a row with the given id.

```delete_for_id(id: int)``` Deletes a row from the table based on the provided id.

```disconnect()``` Closes the connection to the MySQL database.

## License
This project is licensed under the MIT License.
pystdlib 0.0.3
A custom standard library module for Python
Requires Python: >=3.6

## PyStdlib 🐍

<img src="./img/logo.png">

This project is a set of pre-built modules, functions and classes that were made to make your life easier when programming in Python, it works like a Swiss army knife.

## Version

This library is still only in beta version, it is worth mentioning that this means that it is in constant development.

## Instalation

To install it is very simple, just install it via pip ```pip install pystdlib``` and then you can use it without any problems.

## Contributing

That said, there's a bunch of ways you can contribute to this project, like by:

* ⭐ Giving a star on this repository (this is very important and costs nothing)
* 🪲 Reporting a bug
* 📄 Improving this documentation
* 🚨 Sharing this project and recommending it to your friends
* ✏️ Or you can contribute code by following this <a href="./docs/CONTRIBUTING.md">guide.</a>

## Docs

** <a href="./docs/DOUBLE.md"> Double </a>
onsort 0.1.0
SOPA Algorithm, best possible probability sorting Algorithm
Requires Python: <4.0,>=3.11

[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
[![Checked with mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org/)


# Online Optimal Sort

Onsort is a small library providing utilities for online ranking (sorting) numbers comming from a know distribution at random.

It was inspired by the PlaceIt game and here you will find the algorithms to compute the probability of winning the game with the best strategy as well as the continuous variant.

## Content 

The library contains two modules:

- Continuous: where we have the scripts for calculating the probability of winning the continous version as well as one script for sorting numbers in a random continous distriboutin from 0 to 1.

- discrete: where we have a script for getting the probability for solving the original game.


As the probability can be calculated analytically the code is semi-symbolic, notice that the full symbolic solution for more than 8-10 slots can take very long time.

## Usage example:

If wanting to use the library for sorting we have the following script:

```python
from onsort.continuous.online_sort import sort

# the data can be generated randomly, comming from online stream
arr = [0.76931784, 0.06506234, 0.07066391, 0.70643678, 0.94615554]
sort_gen = sort(5)
slots = next(sort_gen) # initialize generator
for n in arr:
    slots = sort_gen.send(n)
    print(slots)
```




## Run test

> poetry shell

> pytest .

> pytest  --cov=pytrade tests/