semvec/pypi-packages huggingface dataset:
pygame-core 0.1.32
A modular core library for Pygame-based 2D games.
License: MIT
Keywords: pygame game development engine

# Pygame Core

## Overview

**Pygame Core** is a modular and reusable library designed to simplify the development of 2D games using the Pygame library. It provides essential components for managing game loops, scenes, input handling, and utility functions, allowing developers to focus on building their game's unique features.

## Features

- **Game Loop Management**: Simplifies the main game loop with FPS control.
- **Scene Management**: Enables seamless transitions between game scenes (e.g., menus, gameplay).
- **Input Handling**: Centralized input management for keyboards or other devices.
- **Utilities**: Provides tools like collision detection and default settings.
- **Extensibility**: Designed for easy customization and expansion.

## Installation

Install the package using `pip`:

```bash
pip install pygame-core
```

## Usage

### Setting Up Your Game

Below is an example of how to use **Pygame Core** to create a simple game:

```python
import pygame
from core import Game, Scene, SceneManager

class MainMenu(Scene):
    def update(self, input_manager):
        if input_manager.is_pressed(pygame.K_RETURN):
            return Gameplay(self.screen)

    def render(self):
        self.screen.fill((0, 0, 0))
        font = pygame.font.Font(None, 74)
        text = font.render("Press Enter to Start", True, (255, 255, 255))
        self.screen.blit(text, (150, 300))

class Gameplay(Scene):
    def update(self, input_manager):
        # Game logic goes here
        pass

    def render(self):
        self.screen.fill((30, 30, 30))

if __name__ == "__main__":
    pygame.init()
    screen = pygame.display.set_mode((800, 600))
    pygame.display.set_caption("Pygame Core Example")

    manager = SceneManager(MainMenu(screen))
    game = Game(screen)
    game.run(manager)
    pygame.quit()
```

### Key Components

- **`Game`**: Manages the main game loop and FPS control.
- **`Scene`**: A base class for creating game scenes with `update` and `render` methods.
- **`SceneManager`**: Handles scene transitions.
- **`InputManager`**: Provides a clean interface for checking key states.
- **`Utils`**: Includes common utilities like collision detection.

## Contributing

Contributions are welcome! To contribute:

1. Fork the repository.
2. Create a new branch for your feature or bug fix.
3. Make your changes.
4. Run a pylint `pylint core`
5. Submit a pull request.

Please ensure all tests pass before submitting your PR.

## License

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for more details.

## Upload

> Remember to update version number in `VERSION` file and delete the dist folder before uploading.

Build:

```bash
python -m build
```

Upload:

```bash
python -m twine upload dist/*
```
cjkcms-color-panel 1.5.2
Forked & published on pypi for use in cjkcms and in any wagtail 6.x project that needs an updated version of wagtail-color-panel
License: MIT
Requires Python: >=3.9

[![Test and publish](https://github.com/marteinn/wagtail-color-panel/actions/workflows/main.yml/badge.svg)](https://github.com/marteinn/wagtail-color-panel/actions/workflows/main.yml) [![PyPI version](https://badge.fury.io/py/wagtail-color-panel.svg)](https://badge.fury.io/py/wagtail-color-panel)

# Wagtail-Color-Panel

Introduces panels for selecting colors in Wagtail.

![Screen1](https://raw.githubusercontent.com/marteinn/wagtail-color-panel/develop/img/img-in-streamfield.png)


## Features

- NativeColorPanel that can be used in your edit handler
- NativeColorBlock for usage in a StreamField
- Based on the native HTML5 color picker
- A custom db field for improved validation
- PolyfillColorPanel for cases that require IE11 support (built on [Spectrum](https://github.com/bgrins/spectrum))


## Example

```python
from wagtail.models import Page

from wagtail_color_panel.fields import ColorField
from wagtail_color_panel.edit_handlers import NativeColorPanel


class MyPage(Page):
    color = ColorField()

    content_panels = Page.content_panels + [
        NativeColorPanel('color'),
    ]
```


## Documentation

- [Getting started](./docs/1_getting_started.md)
- [Adding panel to a Page](./docs/2_adding_to_a_page.md)
- [Adding to a StreamField](./docs/3_adding_to_a_streamfield.md)
- [Reference](./docs/4_reference.md)

## Contributing

Want to contribute? Awesome. Just send a pull request.


## License

Wagtail-Color-Panel is released under the [MIT License](http://www.opensource.org/licenses/MIT).
pyfair 0.1a13
Open FAIR Monte Carlo creator
License: MIT
Requires Python: >=3.6
Keywords: FAIR, risk, monte carlo, cyber risk, risk analysis


        Factor Analysis of Information Risk (Open FAIR) model in Python.

        This package endeavors to create a simple API for automating the
        creation of FAIR Monte Carlo risk simulations.

        This is based on the terms found in:

        1. Open FAIR™ RISK TAXONOMY (O-RT); and,
        2. Open FAIR™ RISK ANALYSIS (O-RA).

        "Open FAIR" is a trademark of the Open Group.