semvec/pypi-packages huggingface dataset:
pygame-event-handler 0.0.2
A small package that helps handling events in pygame-ce.
Requires Python: >=3.9

## Pygame Event Handler

A simple python package that helps with handling events in pygame-ce.

### Features
 - Provides easy-to-use interface for checking if a key is pressed,held, or released (keyboard and mouse buttons)
 - Provides easy-to-use interface to find the location of the mouse cursor
 - Calculates delta time and real time FPS
 - Checks window and mouse focus

### Usage
```python
import pygame as pg
from pygame_event_handler.event_handler import EventHandler

pg.init()
screen = pg.display.set_mode([800,600])

event_handler = EventHandler()

while not event_handler.should_quit:
    event_handler.get_events()
```

### [Example](example/main.py)
#### In this Video, you can see the features in action, especially window and mouse focus, and held keys.
https://github.com/user-attachments/assets/b8e183ae-26c6-4057-a869-ecc986e25688
rynput 1.0.3
Python tools for typed input validation.
Requires Python: >=3.9

# Rynput
Python tools for strongly typed input validation.

## Description
Rynput is focused on validating strings and converting them to a specific type, if possible.
It is particularily effective when configuring a large list of properties which may have
very different requirements for their values.

## Installation
Run `pip install rynput`.

## Usage
It is recommended to use the following import statement:
```python
from rynput import Property, PropertyGroup, validators
```
From there, create the list of properties to validate.
The constructor for `Property` takes a name (`str`), type (`Validator`), and
optionally a default value and description. Omitting a default value means
that the property is marked as "required," and thus cannot be omitted by
the input method.
```python
properties = PropertyGroup([
    Property("Option", validators.Option(["Foo", "Bar", "Baz"]), "Foo"), # Default value provided
    Property("Integer", validators.Integer(4, 8)), # Required
    ...
])
```
The input strings may come from anywhere. However, typical examples may include a user configuration wizard
(see `examples/input_example.py`) or from a config file (`examples/json_example.py`).
aio-nookipedia 0.1.9
A simple, easy to use python wrapper for the Nookipedia API
Requires Python: >=3.13.7

# AIO-Nookipedia
A simple, all-in-one python wrapper for the Nookipedia API with caching

Nookipedia is a community-driven Animal Crossing wiki.
The main page of the Nookipedia wiki can be found [here](https://nookipedia.com/wiki/Main_Page).

## Installation
The wrapper can be installed via pip using 
`pip install aio-nookipedia`

## General Usage:
Every endpoint in the API is accessible through the `get` functions inside `NookClient` found in [client.py](https://github.com/FormlessDuck/aio-nookipedia/blob/main/src/aionookipedia/client.py)
These functions each return an object or list of objects containing all the data stored in the API.

Example Usage:
```python
import asyncio
from aionookipedia.client import NookClient 
        
async def main():
    async with NookClient("YOUR_API_KEY") as client:
        data = await client.getFish('pike')
        print(data.name) # will return "Pike"

asyncio.run(main())
```

Most attributes (eg. name, species, rarity, etc.) follow the same naming scheme as the API. The only exception to this is the "from" attribute in the `Availability` object that is stored in items. Since `from` is a keyword in Python, this can be accessed with .availability.location instead.

```python
async def getFurnitureByLocation(client, location: str):
    data = await getAllFurniture()
    furniture = []
    for x in data:
        if x.availability.location == location.title():
            furniture.append(x)
    return furniture # returns a list of all furniture that is available from the specified location
```

There is also a custom object called `FossilSet` that accesses an endpoint containing the `FossilGroup` objects with their respective fossils. I modified the objects stored here to contain an array of `Fossil` objects that are identical to the objects at the "Single New Horizons Fossil" endpoint.


For security in your own project, it is best if you use `python-dotenv` to load your api key, but you can pass the api key into `NookClient()` 
manually if you wish.


### Requirements
- Python >= 3.13.7
- [aiohttp-client-cache](https://aiohttp-client-cache.readthedocs.io/en/stable/user_guide.html)

### Issues and Feature Requests
If you have any issues using the wrapper, or want to request a new feature, feel free to use the issue system on [GitHub](https://github.com/FormlessDuck/aio-nookipedia/issues/new)
ev-sdk 0.1.5
The Python SDK for the EV Cloud.
Requires Python: <3.13,>=3.10

# Daft Cloud SDK

## Usage

```sh
# Initialize a project
ev init

# Run a workflow
ev run my_module.py

# Configure a profile e.g. staging with endpoint overrides
ev configure
```

## Installation

The CLI is installed in the project's virtualenv. It can also be added to a project's `pyproject.toml` with `ev-sdk = { path = "../ev-cloud/ev-sdk", editable = true }`.
You can also run CLI with uv via `uv run ev <command>`.

```toml
dependencies = [ "ev-sdk" ]

[tool.uv.sources]
ev-sdk = { path = "../ev-cloud/ev-sdk", editable = true }
```

## Configuration

The configuration uses profiles and is located at `~/.ev/config.toml` (or `$EV_HOME/config.toml`).

```toml
[default]
profile = "default"

[profiles.default]
endpoint_url = "https://api.daft.ai"
dashboard_url = "https://cloud.daft.ai"

[profiles.development]
endpoint_url = "http://localhost:3000"
dashboard_url = "http://localhost:3003"

[profiles.staging]
endpoint_url = "https://staging.api.daft.ai"
dashboard_url = "https://staging.cloud.daft.ai"
```

### Configuration Fields

- `endpoint_url`: API endpoint URL (defaults to `https://api.daft.ai` if not specified)
- `dashboard_url`: Dashboard UI URL for run links (defaults to `https://cloud.daft.ai` if not specified)

### Manual Configuration

While `ev configure` sets up profile configuration, you can manually edit your config file to:
- Add custom `endpoint_url` and `dashboard_url` values for different environments
- Create multiple profiles for testing, staging, and production
- Switch between local development and hosted environments

## Commands

```sh
# Interactive configuration wizard
ev configure

# Initialize project in current repository
ev init [--template TEMPLATE]

# Run python scripts on Daft Cloud
ev run script.py                    # Python file
ev run module                       # Python module
ev run module:function --key=value  # Function with args

# List resources
ev list projects

# Use specific profile
ev --profile work run script.py
```

## Provider

The Daft Provider is a simple implementation of the Provider interface with
a set of known implementations that are resolved against our control plane.

We can move this into open source post launch, but it doesn't make a difference.

## Configuration

We inject these environment variables to trigger using the Daft Provider.

```sh
DAFT_PROVIDER="daft"
DAFT_PROVIDER_BASE_URL="https://...."
DAFT_PROVIDER_API_KEY="sk-..."
```

| Stage      | Endpoint                                           |
| ---------- | -------------------------------------------------- |
| Tilt       | n/a                                                |
| Staging    | https://ai-eventual-provider-staging.onrender.com/ |
| Production | n/a                                                |