semvec/pypi-packages huggingface dataset:
gradientify 2.0.9
A Python package for gradient colors
Requires Python: >=3.11

# gradientify
A python color module focused on gradients

# Setup
```python
from gradientify import Colors

print(Colors.purple_to_white('Hello'))
print(Colors.red_to_blue('Hello'))
print(Colors.green_to_yellow('Hello'))
print(Colors.black_to_white('Hello'))
print(Colors.blue_to_cyan('Hello'))
print(Colors.orange_to_pink('Hello'))
print(Colors.mint('Hello'))
print(Colors.red_to_yellow('Hello'))
print(Colors.blue_to_green('Hello'))
print(Colors.purple_to_blue('Hello'))
print(Colors.pink_to_white('Hello'))
print(Colors.cyan_to_magenta('Hello'))
print(Colors.gray_to_black('Hello'))
print(Colors.blue_to_white('Hello'))
print(Colors.red_to_green('Hello'))
print(Colors.green_to_blue('Hello'))
print(Colors.blue_to_yellow('Hello'))
print(Colors.yellow_to_cyan('Hello'))
print(Colors.magenta_to_red('Hello'))
print(Colors.white_to_black('Hello'))
print(Colors.mystic('Hello'))
print(Colors.ash('Hello'))
```
Same for inputs and such

# colors
```
purple_to_white
red_to_blue
green_to_yellow
blue_to_cyan
orange_to_pink
mint
red_to_yellow
blue_to_green
purple_to_blue
pink_to_white
cyan_to_magenta
gray_to_black
blue_to_white
red_to_green
green_to_blue
blue_to_yellow
yellow_to_cyan
magenta_to_red
black_to_white
white_to_black
mystic
ash
red_to_white
```
some colors look bad others look good.
Feel free to suggest some colors by dming me on discord: virtual.cmd
poker-h 1.0.2
This is a library that will help you create a poker game.
Requires Python: >=3.6
Keywords: poker pokerh poker-h holdem texas game

<h1 align="center">PokerH</h1>

# About

## What is this?

This is a module that will help you create a poker game.

## Library Features

Creating deck, hand, board as a list

Print the above and any lists

Print what combos are on the table

Print outs

### Features of printing outs

Outs are calculated exclusively using a table taken from Roy Rounder's book

Outs can only be counted after using `check_hand.combos()`


----------


# Getting Started

## Installation

	pip install poker-h


## Usage


Using this module is very simple and intuitive.

First we have to import everything from the module

``` python
from poker_h import *
```

Examples of all functions:

Creating a deck or hand

``` python
d = deck.deck()
h = deck.hand(d)
```


To create a board, we must specify a number, this is the number of cards that the program will distribute to the table

``` python
number = 5 #any number
b = deck.board(d, number)
```


To print deck, hand, board, or any other cards in the list

``` python
print(deck.print_cards(d))
```


To print the combos and how many outs you have (be sure to write hand and board)

``` python
print(check_hand.combos(h, b))
print(check_hand.outs())
```


----------


## Example
``` python
from main import *

d = deck.deck()

b = deck.board(d, 5)
h = deck.hand(d)

print(f"Cards in hand: {deck.print_cards(h)}")
print(f"Cards on the table: {deck.print_cards(b)}")

print(f"\nCombination with cards: {check_hand.combos(h, b)}")
print(f"How many outs: {check_hand.outs()}")
```


----------


## Developer
Gimer

GitHub: [link](https://github.com/windgim)
bored-charts 0.13.1
Easy, minimal, PDF-able data reports with python and markdown.
Requires Python: >=3.12
Keywords: PDF, boredcharts, chart, dashboard, graph, plotly, visualization

# bored-charts

Build easy, minimal, PDF-able data reports with markdown and python.

The idea is you do your analysis in Python, as you normally would, and dumping your
figures into a nice report written in markdown is now super low-effort: you decorate
the function to generate the figure (that you already wrote when doing your analysis)
and it becomes available to bored-charts so you can present your findings clearly.

## Minimal example

Install bored-charts and uvicorn:

```bash
pip install bored-charts uvicorn
```

### Create your app

```python
# main.py

from pathlib import Path

import plotly.express as px
import plotly.graph_objects as go
from boredcharts import FigureRouter, boredcharts

figures = FigureRouter()


@figures.chart("population")
async def population(country: str) -> go.Figure:
    df = px.data.gapminder().query(f"country=='{country}'")
    fig = px.bar(df, x="year", y="pop")
    return fig


app = boredcharts(pages=Path(__file__).parent, figures=figures)
```

### Write a markdown report

```md
<!-- populations.md -->

## Populations

USA's population has been growing linearly for the last 70 years:

{{ figure("population", country="United States") }}
```

### Run your app

```bash
uvicorn main:app --reload
```

🎉Now you can view your reports at [http://localhost:8000](http://localhost:8000)!

## Going further

A more full project structure might look like this
(see the [full example here](https://github.com/oliverlambson/bored-charts/tree/main/examples/full)):

```
my-reports
├── analysis          <-- do your analysis and define your figures
│   ├── __init__.py
│   ├── figures.py
│   └── ...
├── pages             <-- write your markdown reports
│   ├── example.md
│   └── ...
├── app.py            <-- spin up the bored-charts app
├── pyproject.toml
└── README.md
```

## Supported charting libraries

- [matplotlib](https://matplotlib.org/)
- [plotly](https://plotly.com/python/)
- [vega-altair](https://altair-viz.github.io/)
- [seaborn](https://seaborn.pydata.org/)

## Extensibility

The bored-charts app is just a FastAPI (ASGI) app,
so you can integrate it into your existing projects or extend it as needed
with existing solutions (e.g., adding authentication).

## Roadmap

See the [Github repo](https://github.com/oliverlambson/bored-charts)