Name,Species,Sex,Age (years),Fixed,Legs,Weight (lbs),Time to Adoption (weeks)
Sasha,cat,female,1,FALSE,4,6.5,3
Snuffles,rabbit,female,3,TRUE,4,3.5,8
Mittens,cat,female,2,TRUE,4,7.4,1
Sunflower,cat,female,5,TRUE,4,8.1,6
Felix,cat,male,16,TRUE,4,9.2,5
Sheba,cat,female,7,TRUE,4,8.4,6
Billie,snail,hermaphrodite,0.5,FALSE,0,0.1,3
Snowcone,cat,female,2,TRUE,4,6.5,5
Wade,cat,male,1,FALSE,4,3.2,1
Hercules,cat,male,3,FALSE,4,13.4,2
Toggle,dog,female,3,TRUE,4,48,1
Boo-boo,dog,male,11,TRUE,4,123,24
Fritz,dog,male,4,TRUE,4,92,3
Midnight,dog,female,5,FALSE,4,112,4
Rex,dog,male,1,FALSE,4,28.9,9
Gir,dog,male,8,FALSE,4,88,5
Max,dog,male,3,FALSE,4,52.8,8
Nori,dog,female,3,TRUE,4,35.3,1
Mr. Peanutbutter,dog,male,10,FALSE,4,161,6
Lucky,dog,male,3,TRUE,3,45.4,9
Kujo,dog,male,8,FALSE,4,172,30
Buddy,lizard,male,2,FALSE,4,0.3,3
Gila,lizard,female,3,TRUE,4,1.2,4
Bo,dog,male,8,TRUE,4,76.1,10
Nibblet,rabbit,male,6,FALSE,4,4.3,2
Snuggles,tarantula,female,2,FALSE,8,0.1,1
Daisy,dog,female,5,TRUE,4,68,8
Ada,dog,female,2,TRUE,4,32,3
Miaulis,cat,male,7,FALSE,4,8.8,4
Heathcliff,cat,male,1,TRUE,4,2.1,2
Tinkles,cat,female,1,TRUE,4,1.7,3
Maple,dog,female,3,TRUE,4,51.6,4

animals.csv

Animal Leg Chart

Tierbein Diagramm

DictReader

Color

blue

magenta

Graphic

empty_graphic

ellipse

beside

show_graphic

text

white

rectangle

graphic_width

above

compose

center_left

center_right

Grafik

blau

rechteck

fixiere

kombiniere

zeige_grafik

Bar Chart

bottom_left

bottom_right

Barcode

Codice a barre

black

rettangolo

accanto

bianco

nero

visualizza_grafica

Grafica

Base Colors

green

cyan

yellow

Battery Indicator

overlay

rounded_rectangle

Bellinzona Market Stall

rgb_color

transparent

save_graphic

Binary Numbers

Binomial Products

show_animation

save_animation

Cantor Dust

Captain America Shield

triangle

rotate

bottom_center

Chessboard

Circle Wave Pattern

circular_sector

Circled Checkmark

Circled X

Kreise

Cercles

Circles

rouge

montre_graphique

bleu

Clover

top_left

top_right

Cogwheel

Color Flower

Farben-Blume

hsv_color

hsl_farbe

mitte_links

drehe

leere_grafik

Color Swirl

Color Wheel

log2

Compass

isosceles_triangle

circle

top_center

Countdown Timer

center

Czech Flag

Margritli

weiss

rgb_farbe

from functools import reduce
from pytamaro import (
    Graphic, Color, 
    transparent,
    empty_graphic, rectangle, ellipse,
    compose, pin, center_left, center_right,
    rotate
)

def _push_right(radius: float, piece: Graphic) -> Graphic:
  spoke = rectangle(radius, 0, transparent)
  return pin(center_left, compose(pin(center_right, spoke), piece))

def _ring(diameter: float, count: int, piece: Graphic) -> Graphic:
  pushed_piece = _push_right(diameter / 2, piece)
  result = empty_graphic()
  for i in range(count):
    angle = 360 / count * i
    rotated_piece = rotate(angle, pushed_piece)
    result = compose(result, rotated_piece)
  return result

# export:
def circle(diameter, color):
    return ellipse(diameter, diameter, color)

def dot_ring(ring_diameter: float, dot_diameter: float, dot_count: int, dot_color: Color, angle_offset: float = 0) -> Graphic:
    return rotate(
        360 / dot_count * angle_offset, 
        _ring(ring_diameter, dot_count, circle(dot_diameter, dot_color))
    )

def compose_multiple(graphics: list[Graphic]) -> Graphic:
    return reduce(lambda a, g: compose(a, g), graphics, empty_graphic())


mandala.py

Dot Mandala

dot_ring

compose_multiple

Double Black Diamond

Double Circle

sqrt

Eyes

Fibonacci

graphic_height

Flag Semaphore

Flat Design Bird

Flat Design Penguin

Four Petal Flower

French Flag

German Flag

Deutsche Flagge

ueber

Ghosts

Grid Heat Map

Hammer

Heart

House

HSV Cylinder

color_wheel

Hue Bar

Hue Ring

Intermodal Container

Isometric Bars

Isosceles Trapezoid

Italian Flag

Bandiera dell'Italia

colore_rgb

grafica_vuota

Japanese Flag

Kite

L-Schild

ueberlagere

oben_links

unten_links

unten_rechts

Labeled Color Bar Chart

dataclass

Callable

Ladybug

Himugüegeli

schwarz

mitte_rechts

mitte

neben

kreis_sektor

Light Bulb

rounded_edge

isosceles_trapezoid

corner_loop

Looped Square

Lugano Market Stall

Mandala Flower

Market Stall

Morse Code

Multiplication Table

Nested Flower

hsl_color

Number Grid

Pac-Man

Pac-Man Animation

pacman

Pacman Film

Pac-Man Maze

Pac-Man Maze Tiles

from pytamaro import (
    Color, Graphic,
    black, white, red, green, blue, rgb_color, hsv_color, hsl_color, transparent,
    graphic_width,
    ellipse, rectangle, empty_graphic,
    rotate, compose, pin, 
    top_left, top_center, top_right,
    center_left, center, center_right,
    bottom_left, bottom_center, bottom_right,
    show_graphic, show_animation
)
from typing import Callable
from collections.abc import Iterable
from math import sin, cos, tan, radians, degrees, pi, sqrt, isnan


# internal functions
def _place(origin_pin, area_dot_pin, area, dot):
    placed = compose(
        pin(area_dot_pin, dot),
        pin(area_dot_pin, area)
    )
    return pin(origin_pin, placed)

def _cartesian_dot(dot_diameter: float, dot_color: Color, x: float, y: float) -> Graphic:
    dot = ellipse(dot_diameter, dot_diameter, dot_color)
    dot_radius = dot_diameter / 2
    strut_width = abs(x) + dot_radius
    strut_height = abs(y) + dot_radius
    straddles_x0 = abs(x) < dot_radius
    straddles_y0 = abs(y) < dot_radius
    area_width = strut_width * (2 if straddles_x0 else 1)
    area_height = strut_height * (2 if straddles_y0 else 1)
    area = rectangle(area_width, area_height, transparent)
    if x >= 0 and y >= 0:
        if straddles_x0 and straddles_y0:
            origin_pin = center
        elif straddles_x0:
            origin_pin = bottom_center
        elif straddles_y0:
            origin_pin = center_left
        else:
            origin_pin = bottom_left
        return _place(origin_pin, top_right, area, dot)
    elif x < 0 and y >= 0:
        if straddles_x0 and straddles_y0:
            origin_pin = center
        elif straddles_x0:
            origin_pin = bottom_center
        elif straddles_y0:
            origin_pin = center_right
        else:
            origin_pin = bottom_right
        return _place(origin_pin, top_left, area, dot)
    elif x < 0 and y < 0:
        if straddles_x0 and straddles_y0:
            origin_pin = center
        elif straddles_x0:
            origin_pin = top_center
        elif straddles_y0:
            origin_pin = center_right
        else:
            origin_pin = top_right
        return _place(origin_pin, bottom_left, area, dot)
    else: # x >= 0 and y < 0:
        if straddles_x0 and straddles_y0:
            origin_pin = center
        elif straddles_x0:
            origin_pin = top_center
        elif straddles_y0:
            origin_pin = center_left
        else:
            origin_pin = top_left
        return _place(origin_pin, bottom_right, area, dot)


# export:
def compose_multiple(graphics: list[Graphic]) -> Graphic:
    result = empty_graphic()
    for graphic in graphics:
        result = compose(result, graphic)
    return result

def float_range(start: float, stop: float, step: float) -> Iterable[float]:
    value = start
    while value < stop:
        yield value
        value += step


def parametric_color_thickness_plot(
    p_to_x: Callable[[float],float], 
    p_to_y: Callable[[float],float], 
    ps: Iterable[float],
    p_to_color: Callable[[float],Color] = lambda p: black, 
    p_to_thickness: Callable[[float],float] = lambda p: 10, 
    scale: float = 1.0,
) -> Graphic:
    """
    Create a parametric plot,
    where x and y are defined as functions of p,
    and ps defines the values of p for which to plot a point.
    Optionally specify the dot color as a function of p (default: black)
    and the dot diameter as a function of p (default: 10).
    """
    x_min = 0
    x_max = 0
    y_min = 0
    y_max = 0
    thickness_max = 0
    dots = empty_graphic()
    for p in ps:
        x = p_to_x(p) * scale
        y = p_to_y(p) * scale
        #print(f"{x=} {y=}")
        color = p_to_color(p)
        thickness = p_to_thickness(p) * scale
        if isnan(x) or isnan(y) or isnan(thickness):
            continue
        thickness_max = max(thickness_max, thickness)
        x_max = max(x_max, x)
        x_min = min(x_min, x)
        y_max = max(y_max, y)
        y_min = min(y_min, y)
        dot = _cartesian_dot(thickness, color, x, y)
        dots = compose(dot, dots)
    # print(f"{x_min=}")
    # print(f"{x_max=}")
    # print(f"{y_min=}")
    # print(f"{y_max=}")
    x_max += thickness_max
    x_min -= thickness_max
    y_max += thickness_max
    y_min -= thickness_max
    # X/Y Axes
    grey = rgb_color(200, 200, 200)
    x_axis_neg = pin(center_right, rectangle(-x_min, 1, grey))
    x_axis_pos = pin(center_left, rectangle(x_max, 1, grey))
    y_axis_neg = pin(top_center, rectangle(1, -y_min, grey))
    y_axis_pos = pin(bottom_center, rectangle(1, y_max, grey))
    grid = compose_multiple([
        x_axis_neg,
        x_axis_pos,
        y_axis_neg,
        y_axis_pos,
    ])
    # Background
    q1 = pin(bottom_left, rectangle(x_max, y_max, white))
    q2 = pin(bottom_right, rectangle(-x_min, y_max, white))
    q3 = pin(top_right, rectangle(-x_min, -y_min, white))
    q4 = pin(top_left, rectangle(x_max, -y_min, white))
    bg = compose_multiple([q1, q2, q3, q4])
    result = compose_multiple([
        dots,
        grid,
        bg
    ])
    return result

def parametric_plot(
    p_to_x: Callable[[float],float], 
    p_to_y: Callable[[float],float], 
    ps: Iterable[float],
    dot_color: Color = black,
    dot_width: float = 10,
    scale: float = 1.0,
) -> Graphic:
    """
    Create a plot where x and y are defined as functions of p, 
    and ps defines the values of p for which to plot a point.
    Optionally specify the color (default: black) and diameter (default: 10) of the dots.
    """
    return parametric_color_thickness_plot(
        p_to_x, 
        p_to_y, 
        ps,
        lambda p: dot_color,
        lambda p: dot_width,
        scale
    )

def cartesian_plot(
    x_to_y: Callable[[float],float], 
    xs: Iterable[float], 
    dot_color: Color = black,
    dot_width: float = 10,
    scale: float = 1.0,
) -> Graphic:
    """
    Create a Cartesian plot where y is defined as function of x, 
    and xs defines the values of x for which to plot a point.
    Optionally specify the color (default: black) and diameter (default: 10) of the dots.
    """
    return parametric_color_thickness_plot(
        lambda p: p,
        lambda p: x_to_y(p),
        xs,
        lambda p: dot_color,
        lambda p: dot_width,
        scale
    )

def polar_plot(
    angle_rad_to_radius: Callable[[float],float], 
    angles_rad: Iterable[float], 
    dot_color: Color = black,
    dot_width: float = 10,
    scale: float = 1.0,
) -> Graphic:
    """
    Create a polar plot where the radius is defined as function of the angle (in radians), 
    and angles defines the values of angles (in radians) for which to plot a point.
    Optionally specify the color (default: black) and diameter (default: 10) of the dots.
    """
    def angle_rad_to_x(a):
        r = angle_rad_to_radius(a)
        return cos(a) * r
    def angle_rad_to_y(a):
        r = angle_rad_to_radius(a)
        return sin(a) * r
    return parametric_color_thickness_plot(
        lambda a: angle_rad_to_x(a),
        lambda a: angle_rad_to_y(a),
        angles_rad,
        lambda a: dot_color,
        lambda a: dot_width,
        scale
    )

Playground