semvec/pypi-packages huggingface dataset:
colorspy 0.4
All main RGB color values for easy access
License: MIT
Requires Python: >=3.6

# ColorsPy

This is a simple python package that can be used for adding colors in PyGame or just to see the RGB values of almost any color.

Example Code:
- Basic use:
``` py
    from colorspy import *

    print(red)
    print(blue)
```

- For PyGame:
``` py
    import colorspy as colors
    import pygame

    pygame.init()

    win = pygame.display.set_mode((800, 600))
    run = True

    while run:
	"""
   	Rest of your code
	"""

    	win.fill(colors.red)

    	pygame.display.update
```

- Color Conversion:
``` py
    from colorspy import *

    converter = ColorConverter()

    """
    If you want any other color's HEX value, you could just pass a tuple of the RGB values.
    The hash variable is a boolean that tells that if you want a hash sign in the HEX value.
    """

    hex_red = converter.rgb2hex(red, hash=True) 

    """
    This will return the RGB value of blue.
    """

    rgb_blue = converter.hex2rgb("0000ff") 
```
- Color Picker
``` py
import colorspy as colors

my_color = colors.color_picker()

"""
This will return a list of the RGB value and the HEX value of the color you select. There is also a argument hex_value which is a boolean. You can use that to decide that whether you want the HEX value or not.
"""
```

v 0.1
- Added most basic colors.

v 0.2
- Added support for RGB to HEX and HEX to RGB color conversion.
- Added a few more colors.

v 0.2.1
- Fixed a minor bug

v 0.3
- Added a whole lot more colors.
- Added a color picker to choose colors easily.

v 0.4
- Fixed color values of some colors
snaptimer 0.0.5
A colorful timer which handling basic information and allow to add info manually.Note: the version was migrated into module ronchang
License: MIT
Requires Python: >=3.6

# SnapTimer
```
python_requires>=3.6
colorama>=0.4.3
```

## - How to use
- install
```bash
pip install snaptimer
```

- import
```python
from snaptimer import Timer

Timer(
    interval,  # unit: seconds
    start=None,
    is_error=False,
    exception=None,
    **kwargs
)
```

- see demo
```python
from snaptimer import Demo

Demo.Timer()
```

If you like my work, please consider buying me a coffee or [PayPal](https://paypal.me/RonDevStudio?locale.x=zh_TW)
Thanks for your support! Cheers! 🎉
<a href="https://www.buymeacoffee.com/ronchang" target="_blank"><img src="https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png" alt="Buy Me A Coffee" style="height: 41px !important;width: 174px !important;box-shadow: 0px 3px 2px 0px rgba(190, 190, 190, 0.5) !important;-webkit-box-shadow: 0px 3px 2px 0px rgba(190, 190, 190, 0.5) !important;" align="right"></a>
supress 1.3.1
A simple utility to supress output
License: MIT
Requires Python: >=3.4

# vcokltfre/Supress

## A simple utility to supress output

Usage:
```py
from supress import supressed

with supressed():
    print("This output is supressed!")

print("This output isn't!")
```

### This package exists as a result of certain libraries that force printing output when it's unwanted
dynamo-dao 0.0.7
Dynamo Dao
License: MIT

# Dynamo Dao

Typed library for interacting with DynamoDb tables.

## Installation

Available on [PyPI](https://pypi.org/project/dynamo-dao/)

```
pip install dynamo-dao
```

## Usage

The following example code shows some basic usage of this package. Note that the `ExampleDao` must define 4 abstract properties:

1. `table_name` - Name of the DynamoDb table resource (maps directly to what you'd see on the AWS console).
2. `unique_key` - The list of keys that together uniquely define an entry in the table.
3. `convert_to_dynamo` - A method which takes in the object and converts it to the entry in the DynamoDb table
4. `convert_from_dynamo` - The opposite of `convert_to_dynamo`

```
from typing import NamedTuple

from dynamo_dao import Dao, DynamoObject

class Example(NamedTuple):
    foo: str
    bar: int

class ExampleDao(Dao[Example]):
    table_name = "example"
    unique_key = ["foo"]

    def convert_to_dynamo(self, var: Example) -> DynamoObject:
        return {"foo": var.foo, "bar": var.bar}

    def convert_from_dynamo(self, var: DynamoObject) -> Example:
        return Example(foo=str(var["foo"]), bar=int(var["bar"]))


example_dao = ExampleDao()

example = Example(foo="hi", bar=1)

example_dao.create(example)
result = example_dao.read_one("foo", "hi")

assert example == result
```

## Why use?

The base dao is a [generic](https://mypy.readthedocs.io/en/stable/generics.html) object, which means child classes will benefit from type checking on functions like `read` and `create`.

In the example above, the type of `result` is `Example`.