semvec/pypi-packages huggingface dataset:
rumax 0.1
A powerful, fast and optimal library for making robots in Rubika with sync and async support.
Requires Python: ~=3.7
Keywords: rubika, rubpy, chat, bot, robot, asyncio

<p align="center">
    <a href="github.address">
        <img src="https://raw.githubusercontent.com/shayanheidari01/rubika/master/icon.png" alt="Rubpy" width="128">
    </a>
    <br>
    <b>Rubika API Framework for Python</b>
    <br>
    <a href="https://github.com/rumaxproject/rumax">
        Homepage
    </a>
    •
    <a href="">
        Documentation
    </a>
    •
    <a href="https://pypi.org/project/rubpy/#history">
        Releases
    </a>
    •
    <a href="https://t.me/rubika_library">
        News
    </a>
</p>

## Rubpy

> Elegant, modern and asynchronous Rubika API framework in Python for users and bots

### Using Async
```python
from rubpy import Client, filters, utils
from rubpy.types import Updates

bot = Client(name='rubpy')

@bot.on_message_updates(filters.text)
async def updates(update: Updates):
    await update.reply('`hello` __from__ **rubpy**')

bot.run()
```

**Using Async**
```python
from rubpy import Client
import asyncio

async def main():
    async with Client(name='rubpy') as bot:
        result = await bot.send_message('me', '`hello` __from__ **rubpy**')
        print(result)

asyncio.run(main())
```

### Using Sync
```python
from rubpy import Client

bot = Client('rubpy')

@bot.on_message_updates()
def updates(message):
    message.reply('`hello` __from__ **rubpy**')

bot.run()
```

**Using Sync:**
```python
from rubpy import Client

with Client(name='rubpy') as client:
    result = client.send_message('me', '`hello` __from__ **rubpy**')
    print(result)
```

**Rubpy** is a modern, elegant and asynchronous framework. It enables you to easily interact with the main Rubika API through a user account (custom client) or a bot
identity (bot API alternative) using Python.


### Key Features

- **Ready**: Install Rubpy with pip and start building your applications right away.
- **Easy**: Makes the Rubika API simple and intuitive, while still allowing advanced usages.
- **Elegant**: Low-level details are abstracted and re-presented in a more convenient way.
- **Fast**: Boosted up by pycryptodome, a high-performance cryptography library written in C.
- **Async**: Fully asynchronous (also usable synchronously if wanted, for convenience).
- **Powerful**: Full access to Rubika's API to execute any official client action and more.

### Installing

``` bash
pip3 install -U rubpy
```
cricket-scoring 1.0.1
A library for cricket scoring logic.


# Cricket Scoring Library

A Python library for managing cricket scoring logic. This library provides utility functions for updating batting stats, bowling stats, and switching batting teams.

## Features

- Update batting statistics (runs, balls, boundaries, dismissals).
- Update bowling statistics (runs conceded, wickets, overs bowled).
- Switch batting teams during a match.

## Installation

Install the library via pip:

```bash
pip install cricket-scoring
```

## Usage

### Updating Batting Stats

```python
from cricket_scoring.batting import update_batting_stats

player_stats = {
    'runs': 10,
    'balls': 5,
    'fours': 1,
    'sixes': 0,
    'is_out': False
}

updated_stats = update_batting_stats(player_stats, runs=4, balls=1, is_out=False, is_four=True, is_six=False)
print(updated_stats)
```

### Updating Bowling Stats

```python
from cricket_scoring.bowling import update_bowling_stats

bowler_stats = {
    'runs_conceded': 20,
    'balls_bowled': 12,
    'wickets': 1,
    'overs': 2.0
}

updated_stats = update_bowling_stats(bowler_stats, runs=4, balls=1, is_wicket=False)
print(updated_stats)
```

### Switching Batting Teams

```python
from cricket_scoring.match import switch_batting_team

current_team = "Team A"
team1 = "Team A"
team2 = "Team B"

new_batting_team = switch_batting_team(current_team, team1, team2)
print(new_batting_team)
```

## Development

### Running Tests

Install `pytest`:

```bash
pip install pytest
```

Run tests:

```bash
pytest tests/
```

## License

This project is licensed under the MIT License.
miplib_benchmark 0.1.2
Add your description here
Requires Python: >=3.12

# MIPLIB Benchmark 
This python package allows the user to download and solve instances from the MIPLIB benchmark. 
We refer to the website (https://miplib.zib.de/) for more information on this dataset.

# Installation 

    pip install miplib_benchmark 
    miplib --help 

# Setup 
To download and unzip the dataset: 

    miplib setup 

Set the env variable MIPLIB_BENCHMARK_DIR to specify where to download it.

# Shows instances 
To show the first 5 instances: 

    miplib instances -c 5 

You can also call `miplib_benchmark.get_instances` to get the dataframe itself.

# Solve 
Via the CLI

    miplib solve -i "instance_name"

or in python 

    miplib_benchmark.solve("instance_name")
biddmanager-pkg 0.1.0
this libarbary is for managing the bids of user
Requires Python: >=3.6

The bidding_manager.py library is a key component of the application that manages all bidding-related functionalities for the property management system. It provides seamless integration with AWS DynamoDB to handle essential operations such as placing bids, retrieving all bids for a property, determining the highest bid, and accepting bids for properties.

Key Features:

•	Placing Bids: Ensures buyers can place valid bids that are higher than the current highest bid for a property.
•	Fetching Bids: Retrieves all bids associated with a property and sorts them in descending order based on bid amount.
•	Determining the Highest Bid: Quickly identifies the highest bid placed on a property for validation and display purposes.
•	Accepting Bids: Allows sellers to accept a specific bid, marking the bid as “accepted” and updating the associated property’s status to “sold.”
•	Efficient Data Handling: Utilizes DynamoDB to store and query bid and property data efficiently, ensuring scalability and reliability.