guli-tools 0.1.0__tar.gz

guli_tools-0.1.0/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: guli-tools
+Version: 0.1.0
+Summary: My reusable modules
+Requires-Python: >=3.8

guli_tools-0.1.0/guli_tools.egg-info/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: guli-tools
+Version: 0.1.0
+Summary: My reusable modules
+Requires-Python: >=3.8

guli_tools-0.1.0/guli_tools.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+pyproject.toml
+guli_tools.egg-info/PKG-INFO
+guli_tools.egg-info/SOURCES.txt
+guli_tools.egg-info/dependency_links.txt
+guli_tools.egg-info/top_level.txt
+modules/ANSI.py
+modules/G_anicurves.py
+modules/G_perlin.py
+modules/Goosefull.py
+modules/guli_progress_bar.py
+modules/render.py

guli_tools-0.1.0/guli_tools.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

guli_tools-0.1.0/guli_tools.egg-info/top_level.txt

@@ -0,0 +1 @@
+modules

guli_tools-0.1.0/modules/ANSI.py

@@ -0,0 +1,257 @@
+# usefull for projects that use the terminal allat
+filename = __file__.split("\\")[-1] 
+print(f"(Loading module: {filename}..")
+
+class F:
+    BOLD     = "\033[1m"
+    FAINT    = "\033[2m"
+    DIM      = "\033[22m"
+    ITALIC   = "\033[3m"
+    UNDERLINE= "\033[4m"
+    NEGATIVE = "\033[7m"
+    CROSSED  = "\033[9m"
+    END      = "\033[0m"
+
+def UP(lines):
+    return f"\033[{lines}A"
+
+def DOWN(lines):
+    return f"\033[{lines}B"
+
+def RIGHT(amount):
+    return f"\033[{amount}C"
+
+def LEFT(amount):
+    return f"\033[{amount}D"
+
+def COLUMN(column):
+    return f"\033[{column}G"
+
+def SET_POS(line, column):
+    return f"\033[{line};{column}H"
+
+def CLEAR_TERMINAL():
+    return f"\033[2J"
+
+def CLEAR_LINE():
+    return f"\r\033[2K"
+
+def grad(text="\nU DIDN'T ADD TEXT DUMBASS\n", color_list=[[200,200,200],[200,200,200]], size=0):
+    if size > 0:
+        color_list = list(color_list) + [color_list[0]]
+    steps = len(text)
+    num_segments = len(color_list) - 1
+    steps_per_segment = (size if size > 0 else steps) / num_segments
+    result = []
+    
+    for i, char in enumerate(text):
+        cycle_i = i % (size if size > 0 else steps)
+        if steps > 1:
+            segment = min(int(cycle_i / steps_per_segment), num_segments - 1)
+            seg_start = segment * steps_per_segment
+            seg_end = (segment + 1) * steps_per_segment
+            factor = (cycle_i - seg_start) / (seg_end - seg_start)
+        else:
+            segment, factor = 0, 0.0
+            
+        c1 = color_list[segment]
+        c2 = color_list[segment + 1]
+        
+        r = int(c1[0] + (c2[0] - c1[0]) * factor)
+        g = int(c1[1] + (c2[1] - c1[1]) * factor)
+        b = int(c1[2] + (c2[2] - c1[2]) * factor)
+        
+        result.append(f"\x1b[38;2;{r};{g};{b}m{char}")
+        
+    return "".join(result) + "\x1b[0m"
+
+def RGB_end():
+    return "\x1b[0m"
+
+class C:
+    # --- THE CLASSICS ---
+    RAINBOW      = [(255, 0, 0), (255, 127, 0), (255, 255, 0), (0, 255, 0), (0, 255, 255), (0, 0, 255), (139, 0, 255)]
+    SUNSET       = [(255, 94, 87), (255, 159, 67), (255, 205, 86), (253, 121, 168), (108, 92, 231)]
+    TWILIGHT     = [(15, 32, 67), (84, 90, 182), (179, 107, 202), (249, 133, 133), (255, 211, 153)]
+
+    # --- CYBER & SCI-FI ---
+    VAPORWAVE    = [(255, 113, 206), (1, 205, 254), (5, 255, 161), (185, 103, 255), (255, 251, 150)]
+    AURORA       = [(5, 230, 140), (0, 180, 216), (123, 44, 191), (224, 170, 255)]
+    MATRIX_DRIFT = [(0, 15, 0), (0, 75, 15), (0, 150, 30), (50, 255, 70), (200, 255, 210)]
+
+    # --- NATURE & MOODS ---
+    DEEP_OCEAN   = [(0, 7, 45), (0, 28, 85), (0, 53, 102), (0, 119, 182), (72, 202, 228)]
+    FOREST_FIRE  = [(34, 76, 56), (143, 184, 112), (247, 147, 30), (218, 44, 56), (106, 4, 15)]
+    GLACIER      = [(224, 251, 252), (152, 193, 217), (61, 90, 128), (41, 50, 65)]
+
+    # Standard
+    red_light    = (255, 100, 100)
+    red          = (255, 0,   0  )
+    red_dark     = (180, 0,   0  )
+    green_light  = (100, 255, 100)
+    green        = (0,   200, 0  )
+    green_dark   = (0,   120, 0  )
+    blue_light   = (70, 130, 255)
+    blue         = (10,   20,   255)
+    blue_dark    = (10,   10,   180)
+    cyan_light   = (100, 255, 255)
+    cyan         = (0,   255, 255)
+    cyan_dark    = (0,   180, 180)
+    yellow_light = (255, 255, 100)
+    yellow       = (255, 255, 0  )
+    yellow_dark  = (180, 180, 0  )
+    magenta_light= (255, 100, 255)
+    magenta      = (255, 0,   255)
+    magenta_dark = (180, 0,   180)
+    orange_light = (255, 180, 80 )
+    orange       = (255, 140, 0  )
+    orange_dark  = (180, 90,  0  )
+    white        = (255, 255, 255)
+    gray_light   = (200, 200, 200)
+    gray         = (128, 128, 128)
+    gray_dark    = (60,  60,  60 )
+    black        = (0,   0,   0  )
+
+    # Neon & Cyberpunk Colors
+    neon_pink    = (255, 0, 128)
+    neon_purple  = (187, 0, 255)
+    electric_cyan= (0, 225, 255)
+    toxic_green  = (57, 255, 20)
+
+    # Soft Pastels
+    pastel_pink  = (255, 179, 186)
+    pastel_peach = (255, 223, 186)
+    pastel_yellow= (255, 255, 186)
+    pastel_green = (186, 255, 201)
+    pastel_blue  = (186, 225, 255)
+
+    # Earthy & Rich Tones
+    crimson      = (220, 20, 60)
+    gold         = (255, 215, 0)
+    lime         = (50, 205, 50)
+    teal         = (0, 128, 128)
+    indigo       = (75, 0, 130)
+
+    # Monochromes
+    white        = (255, 255, 255)
+    gray         = (128, 128, 128)
+    black        = (0, 0, 0)
+
+def grad_x(x, color_list, length=100):
+    x = max(0.0, min(1.0, x / length))
+    num_segments = len(color_list) - 1
+    segment = min(int(x * num_segments), num_segments - 1)
+    factor = (x * num_segments) - segment
+
+    c1 = color_list[segment]
+    c2 = color_list[segment + 1]
+
+    r = int(c1[0] + (c2[0] - c1[0]) * factor)
+    g = int(c1[1] + (c2[1] - c1[1]) * factor)
+    b = int(c1[2] + (c2[2] - c1[2]) * factor)
+
+    result = f"\x1b[38;2;{r};{g};{b}m"
+    return result
+
+
+def rgb(r=200, g=200, b=200):
+    if isinstance(r, tuple):
+        r, g, b = r
+    return f"\x1b[38;2;{r};{g};{b}m"
+
+def progress_bar(percent, color_list, length=20):
+    filled = int((percent / 100) * length)
+    bar = "".join(
+        grad_x(i, color_list, length) + '█' if i < filled else rgb(C.gray_dark) + '░'
+        for i in range(length)
+    )
+    return f"[{bar}{F.END}] {grad(f'{percent}%', color_list)} {rgb(C.gray_dark)}| {rgb(C.red_light)}{100 - percent}% remaining{F.END}"
+
+def info_colors(show=["colors", "example", "use", "alternate", "class"]):
+    entries = [name for name, value in vars(C).items() if not name.startswith('_') and isinstance(value, list)]
+
+    if "colors" in show:
+        print()
+        for name in entries:
+            colors = colors = getattr(C, name)
+            print(grad(name, colors), end=" "*(15-len(name)))
+            print(grad("█"*40, colors), grad("█"*40, colors, 20))
+            print()
+        for name, value in vars(C).items():
+            if not name.startswith('_') and isinstance(value, tuple):
+                print(rgb(*value) + name, "▇"*(30-len(name)), F.END)
+                if "dark" in name or name == "black" or name in ("toxic_green", "pastel_blue", "lime", "white"):
+                    print()
+    
+    if "example" in show:
+        print(
+            f"\n  {F.BOLD}grad{F.END}(text, color_list, size=0)\n"
+            f"  {rgb(C.gray_dark)}basic   {F.END}{grad('grad(\"hello\", [(255,0,0),(0,0,255)])', [(255,0,0),(0,0,255)])}\n"
+            f"  {rgb(C.gray_dark)}G class {F.END}{grad('grad(\"hello\", C.RAINBOW)', C.RAINBOW)}\n"
+            f"  {rgb(C.gray_dark)}tiling  {F.END}{grad('grad(\"hello\", C.AURORA, 10)  ← cycle size, empty for no cycle', C.AURORA, 10)}\n"
+            f"\n  {F.BOLD}rgb{F.END}(r, g, b)\n"
+            f"  {rgb(C.gray_dark)}usage   {F.END}{rgb(255,100,50)}rgb(255,100,50) + your text{F.END}\n"
+            f"  {rgb(C.gray_dark)}C class {F.END}{rgb(C.neon_pink)}rgb(C.neon_pink) + your text{F.END}\n"
+            f"\n  {F.BOLD}grad_x{F.END}(x, color_list, length=100)\n"
+            f"  {rgb(C.gray_dark)}usage   {F.END}{grad_x(0, C.SUNSET, 3)}x=0 {grad_x(1, C.SUNSET, 3)}x=1 {grad_x(2, C.SUNSET, 3)}x=2{F.END}  ← x is position along length\n"
+            f"  {rgb(C.gray_dark)}tip     {F.END}{rgb(C.gray_dark)}use in loops: grad_x(i, C.SUNSET, total){F.END}\n"
+            f"\n  {F.BOLD}alternate{F.END}(text, colors)\n"
+            f"  {rgb(C.gray_dark)}basic   {F.END}{alternate('alternate(\"hello\", [C.cyan_light, C.blue_dark])', [C.cyan_light, C.blue_dark])}\n"
+            f"  {rgb(C.gray_dark)}multi   {F.END}{alternate('alternate(\"hello\", [C.pastel_blue, C.pastel_green, C.pastel_yellow, C.pastel_pink])', [C.pastel_blue, C.pastel_green, C.pastel_yellow, C.pastel_pink])}\n"
+            f"  {rgb(C.gray_dark)}tip     {F.END}{rgb(C.gray_dark)}cycles through colors per character{F.END}\n"
+        )
+    
+    if "use" in show:
+        print(
+            f"\n"
+            f"  {grad('  ANSI use 101  ', C.SUNSET)}\n"
+            f"\n"
+            f"  {rgb(C.gray_dark)}Solid color with rgb():{F.END}\n"
+            f"  {rgb(C.red_dark)}✦ error:{F.END} file not found\n"
+            f"  {rgb(C.toxic_green)}✦ success:{F.END} connected\n"
+            f"  {rgb(C.yellow)}✦ warning:{F.END} retrying in 3s\n"
+            f"\n"
+            f"  {rgb(C.gray_dark)}Gradient label with grad():{F.END}\n"
+            f"  {grad('  LOADING  ', C.AURORA)}  ← status badge\n"
+            f"  {grad('  WARNING  ', C.SUNSET)}  ← swap palette for tone\n"
+            f"  {grad('  SUCCESS  ', C.MATRIX_DRIFT)}  ← any color_list works\n"
+            f"\n"
+            f"  {rgb(C.gray_dark)}Progress_bar() made with grad_x():{F.END}\n"
+            f"  {(progress_bar(75, C.DEEP_OCEAN))}\n"
+            f"  {(progress_bar(40, C.SUNSET))}\n"
+            f"\n"
+            f"  {rgb(C.gray_dark)}Combine them:{F.END}\n"
+            f"  {grad('  ★ TOP SCORE  ', C.VAPORWAVE)} {rgb(C.gold)}{F.BOLD}9,420pts{F.END}\n"
+            f"  {rgb(C.gray_dark)}user:{F.END} {grad('guli', C.AURORA)}  {rgb(C.gray_dark)}status:{F.END} {grad('online', [(0,220,100),(0,180,80)])}\n"
+        )
+    if "class" in show:
+        print(
+            f"\n"
+            f"  {F.BOLD}Class Overview{F.END}\n"
+            f"  {rgb(C.gray_dark)}C {F.END}= Colors  {rgb(C.gray_dark)}→{F.END} tuples like {rgb(C.cyan)}(r, g, b){F.END} used with {F.BOLD}rgb(){F.END} or {F.BOLD}grad(){F.END}\n"
+            f"  {rgb(C.gray_dark)}F {F.END}= Formats {rgb(C.gray_dark)}→{F.END} ANSI escape codes for {F.BOLD}bold{F.END}, {F.ITALIC}italic{F.END}, {F.UNDERLINE}underline{F.END}, etc.\n"
+            f"  {rgb(C.gray_dark)}tip     {F.END}combine them: {rgb(C.neon_pink)+F.BOLD}rgb(C.neon_pink) + F.BOLD{F.END}\n"
+            f"\n"
+        )
+def alternate(text, colors):
+    result = []
+    color_len = len(colors)
+    for i in range(len(text)):
+        r = colors[i%color_len][0]
+        g = colors[i%color_len][1]
+        b = colors[i%color_len][2]
+        
+        result.append(f"\x1b[38;2;{r};{g};{b}m{text[i]}")
+    
+    return "".join(result) + "\x1b[0m"
+
+
+
+def credit():
+    print(
+        f"{UP(1)+CLEAR_LINE()+rgb(C.green_dark)}Loaded Module:{F.END} Guli's {F.BOLD+alternate("ANSI", [C.cyan_light, C.blue_light, C.red_light, C.yellow_light])} decoder."
+        )
+credit()
+
+if __name__ == "__main__":
+    info_colors()

guli_tools-0.1.0/modules/G_anicurves.py

@@ -0,0 +1,67 @@
+import math
+import ANSI
+import Goosefull as goose
+
+filename = __file__.split("\\")[-1] 
+print(f"(Loading module: {filename}..")
+
+# Definieer de tekst en RGB-kleuren
+blue = (0, 0, 255)
+green = (0, 255, 0)
+
+
+def _bounce_out(t):
+    n, d = 7.5625, 2.75
+    if t < 1/d:       return n * t * t
+    elif t < 2/d:     t -= 1.5/d;  return n*t*t + 0.75
+    elif t < 2.5/d:   t -= 2.25/d; return n*t*t + 0.9375
+    else:             t -= 2.625/d; return n*t*t + 0.984375
+
+def _ease_out(f, t):    return 1 - f(1 - t)
+def _ease_in_out(f, t): return f(2*t) / 2 if t < 0.5 else 1 - f(2 - 2*t) / 2
+
+_in = {
+    "Sine":    lambda t: 1 - math.cos((t * math.pi) / 2),
+    "Quad":    lambda t: t ** 2,
+    "Cubic":   lambda t: t ** 3,
+    "Quart":   lambda t: t ** 4,
+    "Quint":   lambda t: t ** 5,
+    "Expo":    lambda t: 0 if t == 0 else 2 ** (10*t - 10),
+    "Circ":    lambda t: 1 - math.sqrt(1 - t**2),
+    "Back":    lambda t: 2.70158*t**3 - 1.70158*t**2,
+    "Elastic": lambda t: 0 if t==0 else 1 if t==1 else -(2**(10*t-10)) * math.sin((t*10-10.75)*(2*math.pi)/3),
+    "Bounce":  lambda t: 1 - _bounce_out(1 - t),
+}
+
+_easings = {}
+for name, f in _in.items():
+    _easings[f"easeIn{name}"]    = f
+    _easings[f"easeOut{name}"]   = lambda t, f=f: _ease_out(f, t)
+    _easings[f"easeInOut{name}"] = lambda t, f=f: _ease_in_out(f, t)
+
+copya = _easings.copy()
+for k,v in copya.items():
+    _easings[k.lower()] = v
+
+def curve(x, ease="easeInSine", start=0, end=1, strength=1):
+    ease = ease.lower()
+    x = (x - start) / (end - start)
+    x = max(0.0, min(1.0, x))
+    t = _easings[ease](x)
+    t = t ** (1 / strength) if t >= 0 else -((-t) ** (1 / strength))
+    return start + (end - start) * t
+
+def lerp(progress, start, end):
+    return (end - start) * progress
+
+def curve_info():
+    goose.print_set(_in, True)
+
+
+def credit():
+    print(
+        f"{ANSI.UP(1)+ANSI.CLEAR_LINE()+ANSI.C.GREEN}Loaded Module:{ANSI.C.END} Guli's {ANSI.C.END}", end=""
+        )
+    print(ANSI.grad("AnimationCurves", [blue, green])+ANSI.C.END+".")
+credit()
+

guli_tools-0.1.0/modules/G_perlin.py

@@ -0,0 +1,3 @@
+import ANSI
+import G_anicurves as cruves
+import Goosefull

guli_tools-0.1.0/modules/Goosefull.py

@@ -0,0 +1,251 @@
+import time
+import math
+from datetime import datetime
+from . import ANSI
+import numpy as np
+import random
+from scipy.signal import fftconvolve
+from scipy import ndimage
+
+print("Loading module: Goosefull..")
+
+# this is basicly Juliano's trash bin of usefull stuff
+
+
+# =========================
+# -------GRID  STUFF-------
+# =========================
+
+opposite_dir = {0: 2, 1: 3, 2: 0, 3: 1}  # N<->S, E<->W
+
+def give_neighbours(grid, x, y, mode='+'):
+    result = []
+    if mode == '3x3':
+        offsets = [(dx, dy) for dx in [-1,0,1] for dy in [-1,0,1] if not (dx==0 and dy==0)]
+    elif mode == '+':
+        offsets = [(0,-1),(1,0),(0,1),(-1,0)]
+    
+    for i, (dx, dy) in enumerate(offsets):  # N E S W
+        nx, ny = x + dx, y + dy
+        if 0 <= nx < len(grid) and 0 <= ny < len(grid[0]):
+            val = grid[nx][ny]
+            if val != -1:
+                result.append((val, i))
+    return result
+
+def count_neighbours(grid, x, y, mode='3x3'):
+    counts = {}
+    if mode == '3x3':
+        offsets = [(dx, dy) for dx in [-1,0,1] for dy in [-1,0,1] if not (dx==0 and dy==0)]
+    elif mode == '+':
+        offsets = [(0,-1),(1,0),(0,1),(-1,0)]
+    elif mode == "5x5":
+        offsets = [(dx, dy) for dx in [-2,-1,0,1,2] for dy in [-2-1,0,1,2] if not (dx==0 and dy==0)]
+    
+    for dx, dy in offsets:
+        nx, ny = x + dx, y + dy
+        if 0 <= nx < len(grid) and 0 <= ny < len(grid[0]):
+            val = grid[nx][ny]
+            counts[val] = counts.get(val, 0) + 1
+    return counts
+
+def count_neighbours_np(grid_np, mode='3x3', max_val=None, kernel_cache={}):
+    if mode not in kernel_cache:
+        if mode[0] == 'c':
+            r = int(mode[1:])
+            size = 2*r + 1
+            center = r
+            kernel = np.zeros((size, size))
+            for dx in range(-r, r+1):
+                for dy in range(-r, r+1):
+                    if 0 < dx**2 + dy**2 <= r**2:
+                        kernel[dx+center, dy+center] = 1
+        elif mode == '3x3':
+            kernel = np.ones((3, 3)); kernel[1,1] = 0
+        elif mode == '+':
+            kernel = np.array([[0,1,0],[1,0,1],[0,1,0]])
+        elif mode == '5x5':
+            kernel = np.ones((5, 5)); kernel[2,2] = 0
+        kernel_cache[mode] = kernel
+    else:
+        kernel = kernel_cache[mode]
+
+    max_val = max(int(grid_np.max()), max_val) if max_val is not None else int(grid_np.max())
+    h, w = grid_np.shape
+    pad_h, pad_w = kernel.shape[0]//2, kernel.shape[1]//2
+
+    # tile-pad for toroidal wrap, then valid-convolve, avoids per-color loop overhead from mode='wrap' in ndimage
+    padded_grid = np.pad(grid_np, ((pad_h,pad_h),(pad_w,pad_w)), mode='wrap')
+
+    counts = np.zeros((max_val + 1, h, w), dtype=np.int32)
+    for v in range(max_val + 1):
+        mask = (padded_grid == v).astype(np.float32)
+        conv = fftconvolve(mask, kernel, mode='valid')
+        counts[v] = np.round(conv)
+
+    return counts
+
+def superposition_entropy(neighbours, all_superpos, biasses):
+    '''
+    neighbours acces:   neighbours[direction]       =  [neighbours]
+    all_superpos acces: all_superpos                =  [ter, ter, ter, ter, ter, ter]
+    biasses acces:      biasses[terrain][direction] =  [terrain, bias]
+    '''
+    allowed = set(all_superpos)
+    if not neighbours:
+        return allowed, len(allowed)
+
+    for direction, neighbour_list in neighbours.items():
+        allowed_from_dir = set()
+        for neighbour_terrain in neighbour_list:
+            for terrain, bias in biasses[neighbour_terrain][opposite_dir[direction]]:
+                if bias > 0:
+                    allowed_from_dir.add(terrain)
+        allowed &= allowed_from_dir  # intersect: must be valid from ALL directions
+
+    entropy = len(allowed)
+    return allowed, entropy
+
+def List_is_list_2D(list1, list2):
+    for x in range(len(list1)):
+        for y in range(len(list1[x])):
+            if list1[x][y] != list2[x][y]:
+                return False
+    return True
+
+def list_in_history(list, history):
+    for past in history:
+        if List_is_list_2D(list, past):
+            return True
+    return False
+    
+def leftover_2D(grid, search):
+    count = 0
+    for row in grid:
+        for item in row:
+            if item == search:
+                count += 1
+    return count
+
+def print_grid(grid, align=4):
+    height = len(grid)
+    width = len(grid[0])
+    print()
+    print("╋━"+"━"*(align*width)+"━━╋")
+    print("┃"," "*(align*width)," ┃")
+    for row in range(height):
+        print("┃ ", end="")
+        for column in range(width):
+                item = str(grid[row][column])
+                print(item.rjust(align), end="")
+        print("  ┃")
+        print("┃"," "*(align*width)," ┃")
+    print("╋━"+"━"*(align*width)+"━━╋", )
+
+def make_grid(length, width=None, values=(-1,), map_type=0, density=1.0, points=2):
+    if not width:
+        width = length
+
+    if map_type == 0:
+        return np.random.choice(values, size=(length, width))
+
+    if map_type == 1:
+        unique = [v for v in dict.fromkeys(values) if v != 0]
+        
+        if isinstance(density, float):
+            density = [density for _ in range(len(unique))]
+
+        seeds_yx = []
+        seeds_val = []
+        for v in unique:
+            for _ in range(points):
+                seeds_yx.append((random.randint(0, length - 1), random.randint(0, width - 1)))
+                seeds_val.append(v)
+
+        if not seeds_yx:
+            return np.zeros((length, width), dtype=int), np.zeros((length, width), dtype=int)
+
+        seeds_yx = np.array(seeds_yx)          # (N, 2)
+        seeds_val = np.array(seeds_val)        # (N,)
+
+        yy, xx = np.indices((length, width))   # (length, width) each
+
+        # toroidal distance per seed
+        dy = np.abs(yy[..., None] - seeds_yx[:, 0])      # (length, width, N)
+        dy = np.minimum(dy, length - dy)
+        dx = np.abs(xx[..., None] - seeds_yx[:, 1])
+        dx = np.minimum(dx, width - dx)
+        dist2 = dy**2 + dx**2
+
+        closest_idx = np.argmin(dist2, axis=-1)          # (length, width)
+        voronoi_map = seeds_val[closest_idx]
+
+        seed_to_value_idx = np.array([unique.index(v) for v in seeds_val])  # (N,)
+        density = np.array(density)
+        cell_density = density[seed_to_value_idx[closest_idx]]
+        mask = np.random.random((length, width)) < cell_density
+        grid = np.where(mask, voronoi_map, 0)
+
+        return grid, voronoi_map
+
+
+
+# =========================
+# -------INFO  STUFF-------
+# =========================
+
+def info_time(asc_start, time1, asc_end, time2, message="Total time is: {difference}"):
+    print("\nStarted at:",asc_start)
+    print("Finished at:", asc_end)
+
+    dt1 = datetime.fromtimestamp(time1)
+    dt2 = datetime.fromtimestamp(time2)
+
+    difference = dt2 - dt1
+    print(message.format(difference = difference))
+
+def print_set(a_set, name_only):
+    if not name_only:
+        for item in a_set:
+            print(f"{item}: {a_set[item]}")
+    else:
+        for item in a_set:
+            print(item)
+# =========================
+# -------MATH  STUFF-------
+# =========================
+
+def lerp(x, start, end):
+    return round((end-start)*x*0.01, 2)
+
+def smoothstep(x, start, end):
+    t = (x - start) / (end - start)
+    t = min(1, max(0, t))
+    return t * t * (3 - 2 * t)
+
+def ease_in_out_spring(x, start, end):
+    if start == end:
+        return 0.0
+
+    t = (x - start) / (end - start)
+    t = max(0.0, min(1.0, t))
+
+    # damped oscillator centered at 0.5
+    damping = 10
+    frequency = 8 * math.pi
+
+    if t == 0 or t == 1:
+        return t
+
+    return (
+        1
+        - math.exp(-damping * t)
+        * math.cos(frequency * t)
+    )
+
+
+def credit():
+    print(
+        f"{ANSI.UP(1)+ANSI.CLEAR_LINE()+ANSI.rgb(ANSI.C.green_dark)}Loaded Module:{ANSI.F.END} Guli's {ANSI.rgb(ANSI.C.neon_purple)}goose{ANSI.rgb(ANSI.C.blue)}full{ANSI.F.END} stuff."
+        )
+credit()

guli_tools-0.1.0/modules/guli_progress_bar.py

@@ -0,0 +1,83 @@
+import ANSI
+filename = __file__.split("\\")[-1] 
+print(f"(Loading module: {filename}..")
+
+# this is just cool
+
+def progress_bar(progress, max_progress, on="█", off="|", color_on=ANSI.C.GREEN, color_off=ANSI.C.RED, bar_width=5, bar_length=100, form=1, stick_out=0, name=""):
+    bar_width = max(3, bar_width)
+    print(ANSI.UP(bar_width + 2 + (1 if len(name) else 0)), end="")
+    padding = (bar_length + stick_out - len(name)) // 2
+    if len(name):
+        print(color_on +"=" * (padding+(len(name)%2==0)) + name + "=" * padding + ANSI.C.END)
+
+    on = on[0]
+    off = off[0]
+    if form==1:
+        bar_length += stick_out
+        percent = -(-progress*bar_length // max_progress)
+        print(color_on +"╔" + "═"*(bar_length-stick_out-1) + "╗")
+        print(color_on +"║"+on*min(percent, bar_length-stick_out-1) + color_off + off*(bar_length-percent-stick_out-1)+color_on+f"╚{"═"*stick_out}╗")
+
+        for i in range(bar_width-2):
+            print(color_on+"║" + on*percent +color_off + off*(bar_length-percent)+color_on+"║")
+
+        print(color_on +"║"+on*min(percent, bar_length-stick_out-1) + color_off + off*(bar_length-percent-stick_out-1)  + color_on +  f"╔{"═"*stick_out}╝")
+        print(color_on +"╚" + "═"*(bar_length-stick_out-1) + f"╝ {progress}/{max_progress}"+ANSI.C.END)
+    if form==0:
+        percent = -(-progress*bar_length // max_progress)
+        if percent == bar_length:
+            color_off = color_on
+            off = on # wouw
+        print(color_on+"╔" + "═"*bar_length + "╗")
+        for i in range(bar_width):
+            print(color_on+"║"+on*percent + color_off + off*(bar_length-percent)+ color_on +"║")
+        print(color_on+"╚" + "═"*bar_length + f"╝ {progress}/{max_progress}", color_off)
+
+def INFO():
+    print(
+        f"{ANSI.C.FAINT}{'='*80}{ANSI.C.END}\n"
+        f"{ANSI.C.BOLD}Welcome to {ANSI.C.GREEN}PROGRESS{ANSI.C.RED}BAR{ANSI.C.END}\n\n"
+        f"{ANSI.C.BOLD}Usage:{ANSI.C.END}\n"
+        f"  {ANSI.C.BLUE}progress_bar(progress, max_progress, [optional stuff]){ANSI.C.END}\n\n"
+        f"{ANSI.C.BOLD}Optional stuff:{ANSI.C.END}\n"
+        f"  on          Character for filled portion    (default: '█')\n"
+        f"  off         Character for empty portion     (default: '|')\n"
+        f"  color_on    Color for filled portion        (default: GREEN)\n"
+        f"  color_off   Color for empty portion         (default: RED)\n"
+        f"  bar_width   Height of the bar               (default: 5, min: 3)\n"
+        f"  bar_length  Width of the bar                (default: 100)\n"
+        f"  form        Shape: 0=flat, 1=battery        (default: 1)\n"
+        f"  stick_out   Battery end size                (default: 0)\n"
+        f"  name        Label shown above the bar       (default: '')\n\n"
+        f"{ANSI.C.RED}NOTE: Print empty lines before calling progress_bar() - at least (bar_width + 2).{ANSI.C.END}\n\n"
+        f"Made by {ANSI.C.BOLD}{ANSI.C.UNDERLINE}GULI GULI{ANSI.C.END}\n"
+        f"{ANSI.C.FAINT}{'='*80}{ANSI.C.END}\n"
+    )
+
+
+
+
+def main():
+    bigness = int(input("bigness: "))
+    width = 6  # AT LEAST 3
+    print("\n"*(width+2))
+    for i in range(bigness+1):
+        progress_bar(i, bigness, "█", "|", bar_width=width, bar_length=50, stick_out=1)
+        #time.sleep(0.1)
+    print("\n")
+
+
+
+def credit():
+    print(
+        f"{ANSI.UP(1)+ANSI.CLEAR_LINE()+ANSI.C.GREEN}Loaded Module:{ANSI.C.END} Guli's {ANSI.C.BOLD+ANSI.C.GREEN}PROGRESS{ANSI.C.RED}BAR{ANSI.C.END}."
+    )
+credit()
+
+if __name__ == "__main__":
+    main()
+    INFO()
+
+
+

guli_tools-0.1.0/modules/render.py

@@ -0,0 +1,53 @@
+import pygame as pyg
+import numpy as np
+
+
+def init_window():
+    global window
+    window = pyg.display.set_mode((1920, 1080), pyg.RESIZABLE)
+
+    background = window
+
+def resize_grid(grid, scale):
+    grid_scale = len(grid)
+    delta = scale - grid_scale
+
+    if delta > 0:
+        grid = [
+            row + [0] * delta
+            for row in grid
+        ]
+        grid.extend([[0] * scale for _ in range(delta)])
+
+    elif delta < 0:
+        grid = [
+            row[:scale]
+            for r, row in enumerate(grid)
+            if r < scale
+        ]
+
+    return grid  # fix: was missing
+
+
+def grid_to_surface(grid, colors, surface, grid_px, transparent_alive=0, transparent_dead=0, ghost=False):
+    alive_alpha = 255 - transparent_alive
+    dead_alpha  = 255 - transparent_dead
+    
+    arr = np.array(grid)
+    all_colors = np.array(colors, dtype=np.uint8)
+    
+    if ghost:
+        all_colors = (all_colors // 3).astype(np.uint8)
+    
+    mapped = np.where(arr == 0, len(colors) - 1, arr - 1)
+    mapped = np.where(arr > len(colors) - 1, arr - 1, mapped)
+    
+    rgb_array = all_colors[mapped]
+    surf = pyg.surfarray.make_surface(rgb_array.transpose(1, 0, 2))
+    
+    surf = surf.convert_alpha()
+    alpha = np.where(arr.T == 0, dead_alpha, alive_alpha).astype(np.uint8)
+    pyg.surfarray.pixels_alpha(surf)[:] = alpha
+    
+    scaled = pyg.transform.scale(surf, (grid_px, surface.get_height()))
+    surface.blit(scaled, (0, 0))

guli_tools-0.1.0/pyproject.toml

@@ -0,0 +1,9 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "guli-tools"
+version = "0.1.0"
+description = "My reusable modules"
+requires-python = ">=3.8"

guli_tools-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+