semvec/pypi-packages huggingface dataset:
willpyre 0.0.18
Willpyre. Fasten your seatbelts!

# Willpyre

--------------------------
<p align="center">
	<img src="https://raw.githubusercontent.com/re-masashi/willpyre/main/docs/assets/logo_big.png">
</p>

--------------------------

[![Documentation Status](https://readthedocs.org/projects/willpyre/badge/?version=latest)](https://willpyre.readthedocs.io/en/latest/?badge=latest)
[![Test and PEP8](https://github.com/Nafi-Amaan-Hossain/willpyre/actions/workflows/actions.yml/badge.svg)](https://github.com/Nafi-Amaan-Hossain/willpyre/actions/workflows/actions.yml)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/re-masashi/willpyre)


Willpyre is a micro ASGI framework. 
Willpyre gives flexibility and control, but abstracts ASGI to some extent and adds reusability to your code.
-------------------------

## [Quickstart](#Quickstart)

It is quite simple to use Willpyre.

```py
from willpyre import App, Router


router = Router()

@router.get('/')
async def index(req,res):
	res.body = "<h1>Please fasten your seatbelts!!</h1>"
	return res


app = App(router)
```

It should run with any ASGI server like ``Uvicorn``, ``Daphne``, ``Hypercorn``.

To run with Uvicorn, install Uvicorn using 
```bash
pip install uvicorn
```
and then
```bash
uvicorn <file>:app
```

The framework is written in pure-python and can run in PyPy or CPython.
Tested on version 3.6 and above.

---------------------------------
## [Features](#Features)

* Predefined response objects for fast development.
* Optional base response object passed to handlers.
* Async.
* Light and tiny.
* And lots more..

--------------
## Contributions

It is open to contributors willing to commit.
Please open issues if you find something wierd.
Fork this if you want to propose changes.

------------
dssatsim 0.1.3
Simple saptiotemporal DSSAT simulator
Requires Python: <4.0,>=3.10

# Simple DSSAT simulator


## Install
```
pipx install dssatsim
```

## Goal
Takes a small set of inputs in JSON and returns DSSAT's Summary.OUT as a JSON file.

### Required Set of Inputs:
```
{
    "farm_name": "farm_farm",
    "latitude": 42.4241716982,
    "longitude": -85.7411854356,
    "elevation": 200,
    "planting_date": "2023-05-15",
    "crop_name": "maize",
    "crop_variety": "Unknown",
    "is_irrigation_applied": "yes",
    "irrigation_application": [
        [
            "2023-05-15",
            80
        ],
        [
            "2023-05-20",
            100
        ]
    ]
}
```


## How to use it
```
from dssatsim import run_dssat_exp_cli
import json

input_file = "./sample_2024-09-30.json"
output_file = "./example_output.json"

with open(input_file, 'r', encoding='utf-8') as f:
    input_data = json.load(f)

_, explanations = run_dssat_exp_cli.exec(input_data, output_file)

```


## Limitations
* The geographic coverage is limited to Kalamazoo County, MI, USA
* Year of interest: only 2023
* Crops covered: Corn and Soybeans


## Acknowledgments

* [DSSAT Team](https://github.com/DSSAT/dssat-csm-os)
* [Py_DSSATTools](https://github.com/daquinterop/Py_DSSATTools)
python-deprecation-dates 0.2.6
A library to fetch Python version deprecation dates from endoflife.date.
Requires Python: >=3.6

# Python Deprecation Dates

#### A Python library to fetch and display Python version deprecation dates using data from the endoflife.date API.

## Features:
- Fetch Python version end-of-life dates
- Get the latest Python version
- Support for custom request settings, including proxies and headers

## Installation:
Install the library using pip:

```bash
pip install python-deprecation-dates
```

## Usage:

```python
from python_deprecation_dates import PythonEOLAPI
```

### Create an API client

```python
api_client = PythonEOLAPI()
```

### Get all deprecation dates

```python
deprecation_dates = api_client.get_deprecation_dates()
print(deprecation_dates)
```

### Get the latest Python version

```python
latest_version = api_client.get_latest_version()
print(f"The latest Python version is: {latest_version}")
```

### Setting Proxies:
You can configure proxies using the `request_settings` parameter:

```python
from python_deprecation_dates import PythonEOLAPI

# Define proxy settings
request_settings = {
    "proxies": {
        "http": "http://proxy.example.com:8080",
        "https": "http://proxy.example.com:8080"
    }
}

# Create an API client with proxy settings
api_client = PythonEOLAPI(request_settings=request_settings)

# Fetch deprecation dates through the proxy
deprecation_dates = api_client.get_deprecation_dates()
print(deprecation_dates)
```

### Custom Headers:
Add custom headers for requests:

```python
from python_deprecation_dates import PythonEOLAPI

# Define request settings with headers
request_settings = {
    "headers": {
        "User-Agent": "python-deprecation-dates/1.0"
    }
}

# Create an API client with custom headers
api_client = PythonEOLAPI(request_settings=request_settings)

# Fetch deprecation dates with custom headers
deprecation_dates = api_client.get_deprecation_dates()
print(deprecation_dates)
```

## Contributing:
Contributions are welcome! Please follow the contribution guidelines and ensure tests pass before submitting a pull request.

## License:
This library is licensed under the MIT License. See the LICENSE file for details.
almacen-app 1.0.0
Aplicación de gestión para almacenes
Requires Python: >=3.8

# AlmacÃ©n App

AplicaciÃ³n de escritorio para la gestiÃ³n de productos y operaciones en almacenes.

## InstalaciÃ³n

Puedes instalar la aplicaciÃ³n directamente desde PyPI con:

```bash
pip install almacen-app
dynamic-pong 1.0.8
Dynamic Pong: A Python-based modern twist on classic Pong
Keywords: python, pong, game, dynamic, resume project, pygame


# Dynamic Pong

Dynamic Pong is a modern rendition of the classic arcade game Pong, crafted with Python using the Pygame library. It offers an engaging and interactive gaming experience, featuring responsive paddle controls and dynamic game speed adjustments. This project is an excellent showcase of Python programming skills, game design, and software development principles.

## Features

- **Adaptive Gameplay**: The game's difficulty increases as you progress, offering a challenging and engaging experience.
- **Collision Detection**: Implements collision logic for paddles and game boundaries.
- **Score Tracking**: Real-time score display for both the player and the computer-controlled opponent.
- **Customizability**: Adjustable game window size and element proportions to fit various screens.

## Installation

To install and play Dynamic Pong, follow these simple steps:

1. Open a terminal or command prompt.
2. Run the command:
   ```sh
   pip install dynamic_pong
   ```
3. Wait for the installation to complete.

## How to Play

1. After installation, run the command:
   ```sh
   dynamic_pong
   ```
2. Control the left paddle using the `Up` and `Down` arrow keys or the `W` and `S` keys.
3. The game continues indefinitely until manually exited.

## Code Examples

```python
# Creating a block representing a paddle
block = Block("white", 20, 100, 50, 300)
```

```python
# Initializing a player paddle
player = Player("white", 20, 140, 5)
```

```python
# Handling a ball collision with the top edge of the screen
ball = Ball("white", 30, 30, paddle_group)
ball.rect.top = -5
ball.speed_y = -5
ball.collisions()
```

## Contributing

Contributions to Dynamic Pong are welcome! If you have suggestions for improvements or encounter any issues, please feel free to open an issue or submit a pull request.

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

## About the Author

Adamya Singh - Software developer with a passion for machine learning and functional programming. Feel free to connect with me on [LinkedIn](https://www.linkedin.com/in/adamya-singh-0a8746184/).
django-class-registry 1.1.2
Register any classes like Django's admin.

Allows you to create any Registry, similar to how django's admin
has you register classes, or their template library has you register tags.


Usage
======

::

    from class_registry import Registry

    site = Registry()

    @site.register
    class MyCoolClass(object):
      """
      My class that should be registered.
      """
      key = "ABC"


    >>> site["ABC"]
    <class 'MyCoolClass'>

Alternate use
-------------

Or, if you want your own key name, specify it when you register the class.::

    container = Registry(key_name="other_key")

    @container.register
    class MyCoolClass(object):
      other_key = "POL-COOL-CLS"