crystalwindow 4.6__py3-none-any.whl → 4.8__py3-none-any.whl

crystalwindow/assets.py

@@ -1,6 +1,5 @@
-# assets.py
 import os
-import random
+import random, json, pickle
 from tkinter import PhotoImage
 
 try:
@@ -15,90 +14,129 @@ ASSETS = {}  # cache for all loaded images
 # --------------------------------------------------------
 # MAIN IMAGE LOADER
 # --------------------------------------------------------
-def load_image(path, flip_h=False, flip_v=False):
+def load_image(path=None, flip_h=False, flip_v=False, size=None, color=None):
     """
-    Loads an image and returns a Tk PhotoImage.
-    Supports flipping using Pillow.
+    Unified image loader w/ caching, flips, and fallback.
+    Handles:
+      - path images
+      - solid color gens
+      - missing textures
+      - Pillow and pure-tk fallback
     """
 
-    key = f"{path}|h={flip_h}|v={flip_v}"
+    # ----------------------------------------------------
+    # NO PATH → GENERATE STATIC IMAGE
+    # ----------------------------------------------------
+    if path is None:
+        if Image is None:
+            # basic tk only
+            w, h = size if size else (64, 64)
+            img = PhotoImage(width=w, height=h)
+            return img
+
+        w, h = size if size else (64, 64)
+
+        # solid or missing texture
+        pil_img = (
+            Image.new("RGB", (w, h), color) if color
+            else generate_missing_texture((w, h))
+        )
+
+        # flips BEFORE resize
+        if flip_h:
+            pil_img = pil_img.transpose(Image.FLIP_LEFT_RIGHT)
+        if flip_v:
+            pil_img = pil_img.transpose(Image.FLIP_TOP_BOTTOM)
+
+        if size:
+            pil_img = pil_img.resize(size, Image.Resampling.LANCZOS)
+
+        return ImageTk.PhotoImage(pil_img)
+
+    # ----------------------------------------------------
+    # USE FULL KEY AS CACHE
+    # ----------------------------------------------------
+    key = f"{path}|h={flip_h}|v={flip_v}|size={size}|color={color}"
     if key in ASSETS:
         return ASSETS[key]
 
+    # ----------------------------------------------------
+    # INVALID PATH → MISSING TEXTURE
+    # ----------------------------------------------------
     if not os.path.exists(path):
-        print(f"⚠️ Missing file: {path}")
-        img = generate_fallback(path)
-        ASSETS[key] = img
-        return img
+        print(f"⚠ Missing image: {path}")
+        fb = load_image(None, size=size, color=color)
+        ASSETS[key] = fb
+        return fb
 
-    # If Pillow is missing → load normal image
-    if Image is None or ImageTk is None:
+    # ----------------------------------------------------
+    # PIL NOT INSTALLED → PURE TK LOADING
+    # ----------------------------------------------------
+    if Image is None:
         try:
             img = PhotoImage(file=path)
+            # cannot flip or resize without PIL, soz
             ASSETS[key] = img
             return img
         except:
-            fb = generate_fallback(path)
+            fb = load_image(None, size=size, color=color)
             ASSETS[key] = fb
             return fb
 
-    # Load with PIL to allow flipping
+    # ----------------------------------------------------
+    # LOAD USING PIL (BEST MODE)
+    # ----------------------------------------------------
     try:
-        pil_img = Image.open(path)
+        pil_img = Image.open(path).convert("RGBA")
 
+        # flips
         if flip_h:
             pil_img = pil_img.transpose(Image.FLIP_LEFT_RIGHT)
         if flip_v:
             pil_img = pil_img.transpose(Image.FLIP_TOP_BOTTOM)
 
-        tk_img = ImageTk.PhotoImage(pil_img)
-        ASSETS[key] = tk_img
-        return tk_img
+        # resize AFTER flip
+        if size:
+            pil_img = pil_img.resize(size, Image.Resampling.LANCZOS)
+
+        tk = ImageTk.PhotoImage(pil_img)
+        ASSETS[key] = tk
+        return tk
 
     except Exception as e:
-        print(f"⚠️ Error loading {path}: {e}")
-        fb = generate_fallback(path)
+        print(f"⚠ Error loading {path}: {e}")
+        fb = load_image(None, size=size, color=color)
         ASSETS[key] = fb
         return fb
 
 
-# --------------------------------------------------------
-# FALLBACK NODE
-# --------------------------------------------------------
-def generate_fallback(path):
-    """Fallback colored block used when an image is missing."""
-    rand_color = (
-        random.randint(50, 255),
-        random.randint(50, 255),
-        random.randint(50, 255),
-    )
-
-    if Image:
-        try:
-            pil_img = Image.open(path)
-            w, h = pil_img.size
-        except:
-            w, h = 64, 64
-    else:
-        w, h = 64, 64
+# ========================================================
+# MISSING TEXTURE GENERATOR
+# ========================================================
+def generate_missing_texture(size):
+    w, h = size
+    img = Image.new("RGB", (w, h))
+    px = img.load()
 
-    return {
-        "fallback": True,
-        "size": (w, h),
-        "color": rand_color
-    }
+    pink = (255, 0, 255)
+    black = (0, 0, 0)
 
+    for y in range(h):
+        for x in range(w):
+            if (x // 8 + y // 8) % 2 == 0:
+                px[x, y] = pink
+            else:
+                px[x, y] = black
 
-# --------------------------------------------------------
-# PYGAME-STYLE FLIP HELPERS
-# --------------------------------------------------------
+    return img
+
+
+# ========================================================
+# PYGAME-STYLE FLIP HELPERS (FOR ALREADY-TK IMAGES)
+# ========================================================
 def flip_image(img, flip_h=False, flip_v=False):
-    """
-    Returns a NEW flipped PhotoImage.
-    Like pygame.transform.flip().
-    """
     if Image is None or ImageTk is None:
-        print("⚠️ Pillow not installed; cannot flip images.")
+        print("⚠ Pillow not installed; cannot flip images.")
         return img
 
     pil_img = ImageTk.getimage(img)
@@ -117,9 +155,8 @@ def flip_horizontal(img):
 
 def flip_vertical(img):
     return flip_image(img, flip_v=True)
-
 # --------------------------------------------------------
-# LOOPING ANIMAITONS/IMAGES
+# LOOPING ANIMATIONS / IMAGES
 # --------------------------------------------------------
 class LoopAnim:
     def __init__(self, frames, speed=0.2):
@@ -144,8 +181,6 @@ def loop_image(*imgs, speed=0.2):
     Usage:
         anim = loop_image(img1, img2, img3)
         anim = loop_image(load_image("p1.png"), load_image("p2.png"))
-
-    Returns a LoopAnim object.
     """
     frames = [x for x in imgs if x is not None]
 
@@ -180,12 +215,168 @@ def load_folder_images(folder, nested=True):
 
     return result
 
+#=========================================================
+# LOAD FILES 
+#=========================================================
+def load_file(path):
+    """
+    Smart auto-loader for multiple formats.
+    Reads:
+      - .txt, .md, .cfg → text
+      - .json           → parsed json
+      - .py             → raw text
+      - .bin, .dat      → raw bytes
+      - .pickle, .pkl   → python objects
+      - .png/.gif       → forwarded to load_image()
+      - .pdf            → reads metadata only (no full extract)
+    """
+
+    if not os.path.exists(path):
+        print(f"⚠️ Missing file: {path}")
+        return None
+
+    ext = path.lower().split(".")[-1]
+
+    # ---------------- TEXT FILES ----------------
+    if ext in ("txt", "md", "cfg", "ini", "py"):
+        try:
+            with open(path, "r", encoding="utf-8") as f:
+                return {
+                    "type": "text",
+                    "content": f.read()
+                }
+        except Exception as e:
+            print(f"⚠️ Error reading text file: {e}")
+            return None
+
+    # ---------------- JSON ----------------
+    if ext == "json":
+        try:
+            with open(path, "r", encoding="utf-8") as f:
+                return {
+                    "type": "json",
+                    "content": json.load(f)
+                }
+        except Exception as e:
+            print(f"⚠️ JSON error: {e}")
+            return None
+
+    # ---------------- PICKLE ----------------
+    if ext in ("pickle", "pkl"):
+        try:
+            with open(path, "rb") as f:
+                return {
+                    "type": "pickle",
+                    "content": pickle.load(f)
+                }
+        except Exception as e:
+            print(f"⚠️ Pickle error: {e}")
+            return None
+
+    # ---------------- BINARY ----------------
+    if ext in ("bin", "dat"):
+        try:
+            with open(path, "rb") as f:
+                return {
+                    "type": "binary",
+                    "content": f.read()
+                }
+        except Exception as e:
+            print(f"⚠️ Binary read error: {e}")
+            return None
+
+    # ---------------- PDF ----------------
+    if ext == "pdf":
+        try:
+            with open(path, "rb") as f:
+                head = f.read(1024)  # first 1KB for metadata
+            return {
+                "type": "pdf",
+                "meta_preview": head,
+                "note": "only metadata preview, not full pdf extract"
+            }
+        except Exception as e:
+            print(f"⚠️ PDF read error: {e}")
+            return None
+
+    # ---------------- IMAGE ----------------
+    if ext in ("png", "gif", "jpg", "jpeg"):
+        try:
+            return {
+                "type": "image",
+                "content": load_image(path)
+            }
+        except Exception as e:
+            print(f"⚠️ Image load error: {e}")
+            return None
+
+    # ---------------- UNKNOWN TYPE ----------------
+    try:
+        with open(path, "rb") as f:
+            raw = f.read()
+        return {
+            "type": "unknown",
+            "content": raw
+        }
+    except:
+        print("⚠️ Unknown file load failed")
+        return None
 
 # --------------------------------------------------------
-# MUSIC PLACEHOLDER
+# MUSIC PLACEHOLDER (REPLACED BY NEW SOUND ENGINE)
 # --------------------------------------------------------
+from matplotlib.pylab import size
+import sounddevice as sd
+import soundfile as sf
+import threading
+
+
+class Sound:
+    def __init__(self, path, vol=1.0):
+        self.path = path
+        self.data, self.sr = sf.read(path, dtype="float32")
+        self.volume = vol
+        self._looping = False
+        self._thread = None
+
+    def _play_audio(self, loop=False):
+        self._looping = loop
+        while True:
+            sd.play(self.data * self.volume, self.sr)
+            sd.wait()
+            if not self._looping:
+                break
+
+    def play(self):
+        threading.Thread(target=self._play_audio, daemon=True).start()
+
+    def play_once(self):
+        self.stop()
+        threading.Thread(target=self._play_audio, daemon=True).start()
+
+    def loop(self):
+        self.stop()
+        self._thread = threading.Thread(
+            target=self._play_audio, args=(True,), daemon=True
+        )
+        self._thread.start()
+
+    def stop(self):
+        self._looping = False
+        sd.stop()
+
+    def set_volume(self, v):
+        self.volume = max(0, min(1, float(v)))
+
+
+def load_sfx(path, vol=1.0):
+    return Sound(path, vol)
+
+
+# backwards compat but not real music engine
 def load_music(path):
-    print(f"[assets] Music load not supported: {path}")
+    print(f"[assets] use load_sfx() instead: {path}")
+
 
 def play_music(loop=-1):
-    print("[assets] Music playback not supported.")
+    print("[assets] play_music() disabled, use SoundObject.loop()")

crystalwindow/clock.py

@@ -2,74 +2,37 @@ import time
 from datetime import datetime
 from collections import deque
 
-
 # ============================================================
-# Stopwatch Helper
+# Timer/Wait for a specific duration
 # ============================================================
-class Stopwatch:
+class CountdownTimer:
     def __init__(self):
-        self.start_time = None
-        self.elapsed_time = 0.0
+        self.start_time = 0.0
+        self.duration = 0.0
         self.running = False
 
-    def start(self):
-        if not self.running:
-            self.start_time = time.perf_counter()
-            self.running = True
-
-    def stop(self):
-        if self.running:
-            self.elapsed_time += time.perf_counter() - self.start_time
-            self.running = False
+    def start(self, duration: float):
+        self.duration = duration
+        self.start_time = time.perf_counter()
+        self.running = True
 
     def reset(self):
-        self.start_time = None
-        self.elapsed_time = 0.0
+        self.start_time = 0.0
+        self.duration = 0.0
         self.running = False
 
-    def elapsed(self):
-        if self.running:
-            return self.elapsed_time + (time.perf_counter() - self.start_time)
-        return self.elapsed_time
-
-
-# ============================================================
-# Countdown Timer Helper
-# ============================================================
-class CountdownTimer:
-    def __init__(self):
-        self.target_time = None
-
-    def start(self, seconds: float):
-        self.target_time = time.perf_counter() + seconds
-
-    def remaining(self):
-        if not self.target_time:
-            return 0
-        return max(0, self.target_time - time.perf_counter())
-
-    def done(self):
-        return self.remaining() == 0
-
-
-# ============================================================
-# Event Scheduler Helper
-# ============================================================
-class Scheduler:
-    def __init__(self):
-        self.events = []  # list of (interval, last_run, function)
-
-    def schedule(self, interval: float, func):
-        """Run function every `interval` seconds."""
-        self.events.append([interval, time.perf_counter(), func])
+    def is_finished(self):
+        if not self.running:
+            return True
+        elapsed = time.perf_counter() - self.start_time
+        return elapsed >= self.duration
 
-    def run_pending(self):
-        now = time.perf_counter()
-        for event in self.events:
-            interval, last_run, func = event
-            if now - last_run >= interval:
-                func()
-                event[1] = now  # update last_run
+    def get_remaining(self):
+        if not self.running:
+            return 0.0
+        elapsed = time.perf_counter() - self.start_time
+        remaining = self.duration - elapsed
+        return max(0.0, remaining)
 
 
 # ============================================================
@@ -87,11 +50,6 @@ class Clock:
 
         self.paused = False
 
-        # Utilities
-        self.stopwatch = Stopwatch()
-        self.timer = CountdownTimer()
-        self.scheduler = Scheduler()
-
     # ----------------------------------------------------------
     # TICK + FPS
     # ----------------------------------------------------------

crystalwindow/color_handler.py

@@ -28,20 +28,14 @@ class Color:
                    if not name.startswith("__")}
 
     def __init__(self, r=None, g=None, b=None, a=255, hex_value=None):
-        # -------------------------------------------------
-        # 1) raw tuple variable: Color(Blue)
-        # -------------------------------------------------
         if isinstance(r, (tuple, list)):
-            if len(r) == 3:    # rgb
+            if len(r) == 3:
                 self.r, self.g, self.b = r
                 self.a = a
-            elif len(r) == 4:  # rgba
+            elif len(r) == 4:
                 self.r, self.g, self.b, self.a = r
             return
 
-        # -------------------------------------------------
-        # 2) name string: Color("blue")
-        # -------------------------------------------------
         if isinstance(r, str):
             name = r.lower()
             if name not in self.COLOR_NAMES:
@@ -54,22 +48,15 @@ class Color:
                 self.a = a
             return
 
-        # -------------------------------------------------
-        # 3) HEX input
-        # -------------------------------------------------
         if hex_value is not None:
             self.r, self.g, self.b, self.a = self.hex_to_rgba(hex_value)
             return
 
-        # -------------------------------------------------
-        # 4) manual RGB
-        # -------------------------------------------------
         self.r = r or 0
         self.g = g or 0
         self.b = b or 0
         self.a = a
 
-    # convert hex -> rgba
     @staticmethod
     def hex_to_rgba(hex_value: str):
         hex_value = hex_value.replace("#", "")
@@ -84,23 +71,19 @@ class Color:
             b = int(hex_value[4:6], 16)
             a = int(hex_value[6:8], 16)
         else:
-            raise ValueError("bad hex bruh")
+            raise ValueError("bad hex")
         return r, g, b, a
 
-    # return pygame-friendly color tuple
     def to_tuple(self):
         return (self.r, self.g, self.b, self.a)
 
-    # rgba -> hex
     def to_hex(self):
         return "#{:02X}{:02X}{:02X}{:02X}".format(self.r, self.g, self.b, self.a)
 
-    # quick alpha edit
     def set_alpha(self, a):
         self.a = max(0, min(255, a))
         return self
 
-    # color math
     def brighten(self, amt=30):
         self.r = min(255, self.r + amt)
         self.g = min(255, self.g + amt)
@@ -115,7 +98,6 @@ class Color:
 
     @staticmethod
     def lerp(c1, c2, t: float):
-        """blend between two colors"""
         r = c1.r + (c2.r - c1.r) * t
         g = c1.g + (c2.g - c1.g) * t
         b = c1.b + (c2.b - c1.b) * t