p5-python 0.5.4__py3-none-any.whl

p5/drawcurve.py

@@ -0,0 +1,146 @@
+# Splines/Curves from PAdLib - Ian Mallett - 2013
+
+from math import *
+import pygame
+from p5.renderer import *
+
+# math helper
+def rndint(num): return int(num+0.5)
+def clamp(num, low,high):
+    if num <  low: return  low
+    if num > high: return high
+    return num
+
+def vec_add(v1,v2):
+    return [v1[i]+v2[i] for i in range(len(v1))]
+def vec_sub(v1,v2):
+    return [v1[i]-v2[i] for i in range(len(v1))]
+def vec_dot(v1,v2):
+    return sum([v1[i]*v2[i] for i in range(len(v1))])
+def vec_scale(sc,v):
+    return [sc*v[i] for i in range(len(v))]
+def vec_negate(v):
+    return [-v[i] for i in range(len(v))]
+
+def vec_length_sq(vec):
+    return vec_dot(vec,vec)
+def vec_length(vec):
+    return vec_dot(vec,vec) ** 0.5
+def vec_norm(vec):
+    return vec_scale(1.0/vec_length(vec),vec)
+
+def vec_reflect(vec, norm):
+    v_dot_n = vec_dot(vec,norm)
+    sc = 2 * v_dot_n
+    return [sc*norm[i]-vec[i] for i in range(len(vec))]
+
+def point_project_line(p, l1,l2):
+    #Adapted from http://www.gamedev.net/topic/444154-closest-point-on-a-line/
+    p_l1 = vec_sub(p,l1)
+    l2_l1 = vec_sub(l2,l1)
+
+    t = vec_dot(p_l1,l2_l1) / vec_dot(l2_l1,l2_l1)
+
+    return vec_add(l1,vec_scale(t,l2_l1))
+
+# draw bezier curve
+def _draw_bezier(surface, color, controlpointslist, steps, aa, width, blend):
+    #Algorithm derived from geometric animations on
+    #http://en.wikipedia.org/wiki/B[e]zier_curve
+    #The "[e]" is actually an e with an inflection
+    #over it; removed for this file's portability.
+    
+    points = []
+    
+    def draw_curve(controlpointslist):
+        l = len(controlpointslist)
+        
+        def lerp(p1,p2):
+            return vec_add(
+                vec_scale(1.0-t,p1),
+                vec_scale(    t,p2)
+            )
+        if l == 2:
+            points.append(lerp(*controlpointslist))
+        else:
+            controlpointslist2 = []
+            for i in range(l-1):
+                controlpointslist2.append(lerp(
+                    controlpointslist[i],
+                    controlpointslist[i+1]
+                ))
+            draw_curve(controlpointslist2)
+                
+    for i in range(steps):
+        t = float(i) / float(steps-1)
+        draw_curve(controlpointslist)
+
+    points = [list(map(rndint,p)) for p in points]
+    draw_lines(surface,points)
+
+#draw spline curve
+def _draw_spline(surface, color, closed, pointslist, steps, t,b,c, aa, width, blend):
+    #Kochanek-Bartels spline implementation, written long ago and updated.
+    t_inc = 1.0/float(steps)
+
+    #This allows us to draw through all visible control points (normal Kochanek-Bartels
+    #splines do not draw through their last endpoints).
+    if closed:
+        pointslist = [pointslist[-2],pointslist[-1]] + pointslist + [pointslist[0],pointslist[1]]
+    else:
+        pointslist = [pointslist[0]] + pointslist + [pointslist[-1]]
+
+    cona = (1-t)*(1+b)*(1-c)*0.5
+    conb = (1-t)*(1-b)*(1+c)*0.5
+    conc = (1-t)*(1+b)*(1+c)*0.5
+    cond = (1-t)*(1-b)*(1-c)*0.5
+
+    tans = []
+    tand = []
+    for x in range(len(pointslist)-2):
+        tans.append([])
+        tand.append([])
+    i = 1
+    while i < len(pointslist)-1:
+        pa = pointslist[i-1]
+        pb = pointslist[i  ]
+        pc = pointslist[i+1]
+        x1 = pb[0] - pa[0]
+        y1 = pb[1] - pa[1]
+        x2 = pc[0] - pb[0]
+        y2 = pc[1] - pb[1]
+        tans[i-1] = (cona*x1+conb*x2, cona*y1+conb*y2)
+        tand[i-1] = (conc*x1+cond*x2, conc*y1+cond*y2)
+        i += 1
+
+    for i in range(1,len(pointslist)-2,1):
+        p0 = pointslist[i  ]
+        p1 = pointslist[i+1]
+        m0 = tand[i-1]
+        m1 = tans[i  ]
+        
+        #draw curve from p0 to p1
+        points = [(p0[0],p0[1])]
+        t_iter = t_inc
+        while t_iter < 1.0:
+            h00 = ( 2*(t_iter*t_iter*t_iter)) - ( 3*(t_iter*t_iter)) + 1
+            h10 = ( 1*(t_iter*t_iter*t_iter)) - ( 2*(t_iter*t_iter)) + t_iter
+            h01 = (-2*(t_iter*t_iter*t_iter)) + ( 3*(t_iter*t_iter))
+            h11 = ( 1*(t_iter*t_iter*t_iter)) - ( 1*(t_iter*t_iter))
+            px = h00*p0[0] + h10*m0[0] + h01*p1[0] + h11*m1[0]
+            py = h00*p0[1] + h10*m0[1] + h01*p1[1] + h11*m1[1]
+            points.append((px,py))
+            t_iter += t_inc
+        points.append((p1[0],p1[1]))
+        
+        points = [list(map(rndint,p)) for p in points]
+        draw_lines(surface,points)
+
+
+def bezier(surface, color, controlpointslist, steps, width=1):
+    _draw_bezier(surface, color, controlpointslist, steps, False, width, False)
+
+
+def spline(surface, color, closed, pointslist, steps, t=0.0,b=0.0,c=0.0, width=1):
+    _draw_spline(surface, color, closed, pointslist, steps, t,b,c, False, width, False)
+

p5/mathfunctions.py

@@ -0,0 +1,149 @@
+import math
+import builtins
+from p5.settings import *
+import random as randompy
+from random import randint, triangular, seed, gauss
+
+def randomSeed(var):
+    builtins.RANDOMSEED = var
+    randompy.seed(var)
+
+def random(*args):
+    if len(args)==0 :
+        return randompy.random()   
+    if len(args)==1 :
+        if type(args[0]) == 'list' or type(args[0]) == 'set' or type(args[0]) == 'tuple':
+            return randompy.choice(args[0])
+        else:
+            return randompy.uniform(0,args[0])
+    if len(args)==2 :
+        return randompy.uniform(args[0],args[1])
+
+def constrain(num, low, high):
+    if num <= high and num >= low:
+        return num
+    elif num < low:
+        return low
+    elif num > high:
+        return high
+    return -1
+
+def pow(x,exp):
+    return x**exp
+
+def floor(x):
+    return math.floor(x)
+
+def ceil(x):
+    return math.ceil(x)
+
+def dist(x, y):
+    return math.dist(x, y)
+
+def dist(x1, y1, x2, y2):
+    return math.dist((x1, y1), (x2, y2))
+
+def exp(x):
+    return math.exp(x)
+
+def lerp(a,b,t):
+    return (1 - t) * 1 + t * b
+
+def log(x):
+    return math.log(x)
+
+def log10(x):
+    return math.log(x, 10)
+
+def log2(x):
+    return math.log(x, 2)
+
+def logb(x, b):
+    return math.log(x, b)
+
+def mag(x, y):
+    return math.dist((0, 0), (x, y))
+
+def rerange(value, start1, stop1, start2, stop2, clamp=False):
+    n = (stop2 - start2)*value / (stop1 - start1) + start2
+    if clamp:
+        return constrain(n, start2, stop2)
+    else:
+        return n
+
+def map(val,srclow,srcup,destlow,destup):
+    return (val-srclow)/(srcup-srclow) * (destup-destlow) + destlow
+
+def norm(value, start, stop):
+    return rererange(value, start, stop, 0, 1)
+
+def sq(n):
+    return n*n
+
+def sqrt(x):
+    return math.sqrt(x)
+
+def frac(x):
+    return math.modf(x)[1]
+
+def sin(x):
+    return math.sin(x)
+
+def cos(x):
+    return math.cos(x)
+
+def tan(x):
+    return math.tan(x)
+
+def asin(x):
+    return math.asin(x)
+
+def acos(x):
+    return math.acos(x)
+
+def atan2(x):
+    return math.atan2(x)
+
+def atan(x):
+    return math.atan(x)
+
+def degrees(x):
+    return math.degrees(x)
+
+def radians(x):
+    return math.radians(x)
+
+def randomgaussian(mean,dev):
+    return gauss(mean,dev)
+
+def integral(f, a, b, n=100, type="midpoint"):
+    if type == "midpoint":
+        return _midpoint(f, a, b, n)
+    elif type == "trapezoid":
+        return _trapezoid(f, a, b, n)
+    elif type == "simpsons":
+        return _simpsons(f, a, b, n)
+    else:
+        return -1
+    pass
+
+def _midpoint(f, a, b, n):
+    dx = (b-a)/n
+    result = 0
+
+    xi = linspace(a + 0.5*dx, b - 0.5*dx, n)
+    result = dx*sum(f(xi))
+    return result
+
+def _trapezoid(f, a, b, n):
+    dx = (b-a)/n
+    result = 0
+
+    xi = linspace(a, b, n+1)
+    result = sum(f(xi)) - 0.5*f(a) - 0.5*f(b)
+    return result*dx
+
+def _simpsons(f, a, b, n):
+    if n % 2:
+        return -1
+    return (b-a)/6.0 * (f(a) + 4*f((a+b)/2) + f(b))

p5/renderer.py

@@ -0,0 +1,221 @@
+import math
+import cairo
+from p5.settings import *
+
+def bgra(color): #convert color RGBA 0-255 to BGRA 0-1
+    b_g_r_a = [0,0,0,0]
+    b_g_r_a[0] = color[2]/255
+    b_g_r_a[1] = color[1]/255
+    b_g_r_a[2] = color[0]/255
+
+    if len(color)<4:
+        b_g_r_a[3] = 1    
+    else:
+        b_g_r_a[3] = color[3]/255    
+    return b_g_r_a   
+
+def a_radians(a):
+    if builtins.ANGLEMODE == DEGREES:
+        return a * math.pi/180
+    else:
+        return a  
+def clear_background(surface, width, height, color):
+    
+    ctx = cairo.Context(surface)
+    ctx.set_source_rgba(*bgra(color))
+    ctx.rectangle(0, 0, width, height)
+    ctx.fill()
+
+def draw_line(surface, x1, y1, x2, y2):
+    rotate_angle = a_radians(settings["rotate_amnt"])
+    scale_xy     = settings["scale_amnt"]
+    origin_x     = settings["real_ox"]
+    origin_y     = settings["real_oy"]
+    stroke_color = settings["stroke_color"] 
+    thickness    = settings["stroke_weight"]
+    fill_color   = settings["fill_color"]
+    ctx = cairo.Context(surface)
+    ctx.translate(origin_x, origin_y)
+    ctx.rotate(rotate_angle)
+    ctx.set_line_width(thickness)
+    ctx.move_to(x1, y1)
+    ctx.line_to(x2, y2)
+    ctx.set_source_rgba(*bgra(stroke_color))
+    ctx.stroke()
+
+def draw_rect(surface, x, y, width, height):
+    rotate_angle = a_radians(settings["rotate_amnt"])
+    scale_xy     = settings["scale_amnt"]
+    origin_x     = settings["real_ox"]
+    origin_y     = settings["real_oy"]
+    stroke_color = settings["stroke_color"] 
+    thickness    = settings["stroke_weight"]
+    fill_color   = settings["fill_color"]
+    ctx = cairo.Context(surface)
+    ctx.translate(origin_x, origin_y)
+    ctx.rotate(rotate_angle)
+    ctx.rectangle(x, y, width, height)
+    ctx.set_line_width(thickness)
+    ctx.set_source_rgba(*bgra(fill_color))
+    ctx.fill_preserve() 
+    ctx.set_source_rgba(*bgra(stroke_color))
+    ctx.stroke()
+
+def draw_polygon(surface, vertices):
+    rotate_angle = a_radians(settings["rotate_amnt"])
+    scale_xy     = settings["scale_amnt"]
+    origin_x     = settings["real_ox"]
+    origin_y     = settings["real_oy"]
+    stroke_color = settings["stroke_color"] 
+    thickness    = settings["stroke_weight"]
+    fill_color   = settings["fill_color"]
+    ctx = cairo.Context(surface)
+    ctx.translate(origin_x, origin_y)
+    ctx.rotate(rotate_angle)
+    ctx.move_to(*vertices[0])
+    for n in range(1,len(vertices)):
+        ctx.line_to(*vertices[n])    
+    ctx.close_path() 
+    ctx.set_line_width(thickness)
+    ctx.set_source_rgba(*bgra(fill_color))
+    ctx.fill_preserve() 
+    ctx.set_source_rgba(*bgra(stroke_color))
+    ctx.stroke()
+
+def draw_lines(surface, vertices):
+    rotate_angle = a_radians(settings["rotate_amnt"])
+    scale_xy     = settings["scale_amnt"]
+    origin_x     = settings["real_ox"]
+    origin_y     = settings["real_oy"]
+    stroke_color = settings["stroke_color"] 
+    thickness    = settings["stroke_weight"]
+    ctx = cairo.Context(surface)
+    ctx.translate(origin_x, origin_y)
+    ctx.rotate(rotate_angle)
+    ctx.move_to(*vertices[0])
+    for n in range(1,len(vertices)):
+        ctx.line_to(*vertices[n])
+    ctx.set_line_width(thickness)
+    ctx.set_source_rgba(*bgra(stroke_color))
+    ctx.stroke()
+    
+def draw_circle(surface, x, y, radius):
+    rotate_angle = a_radians(settings["rotate_amnt"])
+    scale_xy     = settings["scale_amnt"]
+    origin_x     = settings["real_ox"]
+    origin_y     = settings["real_oy"]
+    stroke_color = settings["stroke_color"] 
+    thickness    = settings["stroke_weight"]
+    fill_color   = settings["fill_color"]
+    ctx = cairo.Context(surface)    
+    ctx.translate(origin_x, origin_y)
+    ctx.rotate(rotate_angle)
+    ctx.arc(x, y, radius, 0, 2.0 * math.pi)
+    ctx.set_line_width(thickness)
+    ctx.set_source_rgba(*bgra(fill_color))
+    ctx.fill_preserve() 
+    ctx.set_source_rgba(*bgra(stroke_color))
+    ctx.stroke()
+
+def draw_ellipse(surface, x, y, width, height):
+    rotate_angle = a_radians(settings["rotate_amnt"])
+    scale_xy     = settings["scale_amnt"]
+    origin_x     = settings["real_ox"]
+    origin_y     = settings["real_oy"]
+    stroke_color = settings["stroke_color"] 
+    thickness    = settings["stroke_weight"]
+    fill_color   = settings["fill_color"]
+    ctx = cairo.Context(surface)
+    ctx.translate(origin_x, origin_y)
+    ctx.rotate(rotate_angle)   
+    radius = width/2
+    scale_x = 1.0
+    scale_y = height / width
+    ctx.scale(scale_x, scale_y)
+    ctx.arc(x, y/scale_y, radius, 0, 2.0 * math.pi)
+    ctx.set_line_width(thickness)
+    ctx.set_source_rgba(*bgra(fill_color))
+    ctx.fill_preserve() 
+    ctx.set_source_rgba(*bgra(stroke_color))
+    ctx.stroke()    
+    
+def draw_arc(surface, x, y, width, height, angle1, angle2, mode):           
+    rotate_angle = a_radians(settings["rotate_amnt"])
+    scale_xy     = settings["scale_amnt"]
+    origin_x     = settings["real_ox"]
+    origin_y     = settings["real_oy"]
+    stroke_color = settings["stroke_color"] 
+    thickness    = settings["stroke_weight"]
+    fill_color   = settings["fill_color"]
+    ctx = cairo.Context(surface)
+    ctx.translate(origin_x, origin_y)
+    ctx.rotate(rotate_angle)   
+    if mode == "pie":
+        ctx.move_to(x, y)
+    radius = width/2
+    scale_x = 1.0
+    scale_y = height / width
+    ctx.scale(scale_x, scale_y)        
+    ctx.arc(x, y/scale_y, radius, angle1, angle2)
+    if (mode == "chord") or (mode == "pie"):
+        ctx.close_path()
+    if (mode == "chord") or (mode == "pie") or (mode == "open"):
+        ctx.set_source_rgba(*bgra(fill_color))
+        ctx.fill_preserve()
+    ctx.set_source_rgba(*bgra(stroke_color))
+    ctx.stroke()
+
+def draw_text(surface, txt, x, y, style):
+    rotate_angle = a_radians(settings["rotate_amnt"])
+    scale_xy     = settings["scale_amnt"]
+    origin_x     = settings["real_ox"]
+    origin_y     = settings["real_oy"]
+    stroke_color = settings["text_outline"] 
+    thickness    = settings["stroke_weight"]
+    fill_color   = settings["text_color"]
+    font_name    = settings["text_font"] 
+    font_size    = settings["text_size"]
+    ctx = cairo.Context(surface)
+    ctx.translate(origin_x, origin_y)
+    ctx.rotate(rotate_angle)    
+    font_options = cairo.FontOptions()
+    font_options.set_antialias(cairo.ANTIALIAS_DEFAULT)
+    ctx.set_font_options(font_options)
+    cairo_slant  = cairo.FONT_SLANT_NORMAL
+    cairo_weight = cairo.FONT_WEIGHT_NORMAL
+    if style == "italic" or style == "bolditalic":
+        cairo_slant = cairo.FONT_SLANT_ITALIC
+    if style == "bold" or style == "bolditalic":
+        cairo_weight = cairo.FONT_WEIGHT_BOLD
+    ctx = cairo.Context(surface)        
+    ctx.select_font_face(font_name, cairo_slant,cairo_weight)
+    ctx.set_font_size(font_size)
+    xbearing, ybearing, width, height, dx, dy = ctx.text_extents(txt)
+    if settings["text_align"] == RIGHT:
+        x = x - width 
+    if settings["text_align"] == CENTER:
+        x = x - width/2    
+    # Render outline
+    ctx.set_source_rgba(*bgra(stroke_color))
+    for i in range(-thickness, thickness+1):
+        for j in range(-thickness, thickness+1):
+            ctx.move_to(x + i, y + j)
+            ctx.show_text(txt)
+    
+    ctx.set_source_rgba(*bgra(fill_color))
+    ctx.move_to(x, y)
+    ctx.show_text(txt)
+    ctx.stroke()   
+'''    
+def draw_curve(surface,color):    
+    x, y = 100, 50
+    x1, y1 = 140, 50
+    x2, y2 = 60, 100
+    x3, y3 = 190, 150
+    ctx = cairo.Context(surface)
+    ctx.move_to(x, y)
+    ctx.curve_to(x1, y1, x2, y2, x3, y3)
+    ctx.set_source_rgba(*bgra(color))
+    ctx.stroke()
+'''    
+    

p5/settings.py

@@ -0,0 +1,58 @@
+import builtins
+from p5.constants import *
+
+pg_Screen = None
+clock = None
+
+builtins.mouseX         = 0
+builtins.mouseY         = 0
+builtins.pmouseX        = None
+builtins.pmouseY        = None
+builtins.movedX         = None
+builtins.movedY         = None
+builtins.mouseButton    = None
+builtins.mouseIsPressed = False
+builtins.keyIsPressed   = False
+builtins.key            = None
+builtins.keyCode        = None
+builtins.width          = 360
+builtins.height         = 360
+builtins.shape          = []
+builtins.framerate      = 60
+builtins.is_Looping     = True
+builtins.ANGLEMODE      = DEGREES
+builtins.RANDOMSEED     = 0
+builtins.MILLIS         = 0
+builtins.frameCount     = 0
+builtins.ellipse_mode   = CENTER
+builtins.rect_mode      = CORNER
+
+
+# variables
+stack = [] # store for settings
+settings = {
+    "fill_color"    : [255,255,255,255],
+    "no_fill"       : False,
+    "no_stroke"     : False,
+    "stroke_weight" : 1,
+    "stroke_color"  : [0,0,0,255],
+    "rotate_amnt"   : 0,
+    "scale_amnt"    : 1,
+    "text_size"     : 12,
+    "text_font"     : "Arial",
+    "text_bold"     : False,
+    "text_italic"   : False,
+    "text_align"    : LEFT,
+    "text_color"    : [0,0,0,255],
+    "text_outline"  : [0,0,0,0],
+    "origin_x"      : 0,
+    "origin_y"      : 0,
+    "real_ox"       : 0,
+    "real_oy"       : 0,
+}
+
+
+vertices      = []
+curvevertices = []
+shape         = None
+

p5/timedata.py

@@ -0,0 +1,30 @@
+from datetime import datetime
+import time
+import builtins
+from p5.settings import *
+
+def year():
+    return datetime.now().year
+
+def month():
+    return datetime.now().month
+
+def day():
+    return datetime.now().day
+
+def hour():
+    return datetime.now().hour
+
+def minute():
+    return datetime.now().minute
+
+def second():
+    return datetime.now().second
+
+    
+def milli_sec():
+    return int(round(time.time() * 1000))
+
+def millis():
+    return milli_sec() - builtins.MILLIS
+    pass

p5/transform.py

@@ -0,0 +1,78 @@
+# TRANSFORM
+from p5.settings import *
+import math
+
+def transform_canvas_reset(): # Transformations are reset at the beginning of the draw loop.
+    global settings
+    settings["rotate_amnt"] = 0
+    settings["scale_amnt"]  = 1
+    settings["origin_x"]    = 0
+    settings["origin_y"]    = 0
+    settings["real_ox"]     = 0
+    settings["real_oy"]     = 0 
+    pass
+
+def resetMatrix():
+    transform_canvas_reset()
+        
+def rotate(angle):
+    current_angle = settings["rotate_amnt"]
+    current_angle += angle
+    if current_angle < 0:
+        current_angle = 360 + current_angle
+    if current_angle > 359:
+        current_angle = current_angle % 360
+    settings["rotate_amnt"] = current_angle          
+    pass
+
+def scale(amnt):
+    settings["scale_amnt"] = amnt
+    pass    
+
+def real_oxy(xx,yy):   # calulate real x,y coordinate    
+    aa = settings["rotate_amnt"]
+    ox = settings["real_ox"]
+    oy = settings["real_oy"]
+    x = xx
+    y = yy
+    if builtins.ANGLEMODE == DEGREES:
+        aa = aa * math.pi/180
+    x = ox + int(xx * math.cos(aa)) - int(yy * math.sin(aa))
+    y = oy + int(yy * math.cos(aa)) + int(xx * math.sin(aa))   
+    settings["real_ox"] = x
+    settings["real_oy"] = y 
+    pass
+
+
+def translate(x, y):
+    global settings
+    settings["origin_x"] = settings["origin_x"] + x
+    settings["origin_y"] = settings["origin_y"] + y 
+    real_oxy(x, y) # calculate real origin x,y
+       
+    pass
+
+def push():
+    global stack,settings    
+    r  = settings["rotate_amnt"]
+    s  = settings["scale_amnt"]
+    ox = settings["origin_x"]
+    oy = settings["origin_y"]
+    rox= settings["real_ox"]
+    roy= settings["real_oy"]
+    stack.append(r)
+    stack.append(s)
+    stack.append(ox)
+    stack.append(oy)
+    stack.append(rox)
+    stack.append(roy)
+        
+def pop():
+    global stack,settings
+    settings["real_oy"]     = stack.pop()
+    settings["real_ox"]     = stack.pop()     
+    settings["origin_y"]    = stack.pop()
+    settings["origin_x"]    = stack.pop()
+    settings["scale_amnt"]  = stack.pop() 
+    settings["rotate_amnt"] = stack.pop()
+    

p5_python-0.5.4.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.1
+Name: p5-python
+Version: 0.5.4
+Summary: A package wrapping pygame functionality in p5.js calling conventions.
+Home-page: https://github.com/gromko/p5-python
+Author: Grygoriy Gromko
+Author-email: gr.gromko@gmail.com
+Maintainer: Grygoriy Gromko
+Maintainer-email: gr.gromko@gmail.com
+Requires-Python: >=3.8.0
+Requires-Dist: multipledispatch (<0.7.0,>=0.6.0)
+Requires-Dist: numpy (<2.0.0,>=1.22.2)
+Requires-Dist: pygame (<3.0.0,>=2.1.2)
+
+#p5 is a friendly tool for learning to code and make art. It is a free and open-source Python library built by an inclusive, nurturing community. p5 is a Python library that provides high level drawing functionality to help you quickly create simulations and interactive art using Python.