crystalwindow 4.4__tar.gz → 4.6__tar.gz

{crystalwindow-4.4/crystalwindow.egg-info → crystalwindow-4.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crystalwindow
-Version: 4.4
+Version: 4.6
 Summary: A Tkinter powered window + GUI toolkit made by Crystal (MEEEEEE)! Easier apps, smoother UI and all-in-one helpers!
 Home-page: https://pypi.org/project/crystalwindow/
 Author: CrystalBallyHereXD

{crystalwindow-4.4 → crystalwindow-4.6}/crystalwindow/__init__.py

@@ -32,8 +32,9 @@ from .collision import check_collision, resolve_collision
 from .gui import Button, Label, GUIManager, hex_to_rgb, Fade
 from .gui_ext import Toggle, Slider
 
-# === Time ===
-from .clock import Clock
+# === Time System ===
+# Includes upgraded Clock + all helper utilities
+from .clock import Clock, Stopwatch, CountdownTimer, Scheduler
 
 # === Drawing Helpers ===
 from .draw_helpers import gradient_rect, CameraShake
@@ -45,6 +46,7 @@ from .draw_tool import CrystalDraw
 from .fun_helpers import random_name, DebugOverlay, random_color, random_palette, lerp
 from .camera import Camera
 from .color_handler import Colors, Color
+from .websearch import WebSearchResult, WebSearch
 
 # === 3D Engine ===
 from .crystal3d import CW3D
@@ -52,6 +54,9 @@ from .crystal3d import CW3D
 # === AI Engine ===
 from .ai import AI
 
+# === Server Manager ===
+from .cw_client import CWClient
+
 __all__ = [
     # --- Core ---
     "Window", "Sprite", "TileMap", "Player", "Gravity", "FileHelper", "Mathematics",
@@ -77,18 +82,26 @@ __all__ = [
     # --- GUI Extensions ---
     "Toggle", "Slider",
 
-    # --- Time ---
+    # --- Time System ---
+    # FULL time system is now exposed
     "Clock",
+    "Stopwatch",
+    "CountdownTimer",
+    "Scheduler",
 
     # --- Drawing ---
     "gradient_rect", "CameraShake", "DrawHelper", "DrawTextManager", "CrystalDraw", 
 
     # --- Misc ---
-    "random_name", "DebugOverlay", "Camera", "Colors", "Color", "random_palette", "lerp"
+    "random_name", "DebugOverlay", "Camera", "Colors", "Color",
+    "random_palette", "lerp", "WebSearchResult", "WebSearch",
 
     # --- 3D ---
     "CW3D",
 
     # --- AI ---
     "AI",
+
+    # --- Server Client ---
+    "CWClient",
 ]

crystalwindow-4.6/crystalwindow/ai.py

@@ -0,0 +1,314 @@
+# ==========================================================
+# CrystalAI v0.7 — Stabilized & Corrected Engine
+# ----------------------------------------------------------
+
+import os
+import ast
+import difflib
+import requests
+import json
+from typing import Optional, Dict, Any
+
+
+# ==========================================================
+# Response Wrapper
+# ==========================================================
+class CrystalAIResponse:
+    def __init__(self, text: str, meta: Optional[Dict[str, Any]] = None):
+        self.text = text
+        self.meta = meta or {}
+
+    def __str__(self):
+        return self.text
+
+
+# ==========================================================
+# MAIN ENGINE
+# ==========================================================
+class AI:
+    DEFAULT_MODEL = "llama-3.1-70b-versatile"
+    DEFAULT_PERSONALITY = (
+        "You are CrystalWindow AI. You help users with Python code, "
+        "debugging, error analysis, documentation, and file analysis. "
+        "Be friendly, technical, clear, and precise."
+    )
+
+    PLACEHOLDER_KEY = "NO_KEY_PROVIDED"
+
+    # ------------------------------------------------------
+    def __init__(self, key=None, model=None):
+
+        # --- KEY VALIDATION ---
+        # If no key passed try common environment variables (makes key optional)
+        if not key:
+            key = (
+                os.environ.get("CRYSTALAI_API_KEY")
+                or os.environ.get("GROQ_API_KEY")
+                or os.environ.get("OPENAI_API_KEY")
+                or os.environ.get("API_KEY")
+            )
+            if key:
+                key = str(key).strip()
+
+        if not key or len(str(key).strip()) == 0:
+            print("[CrystalAI] No API key provided → using offline mode.")
+            self.key = None  # forces offline fallback
+            self.force_local = True
+        else:
+            self.key = key
+            self.force_local = False
+
+        # --- MODEL VALIDATION ---
+        # If model is omitted (None) use default silently; only warn if an invalid model is explicitly passed
+        if model is None:
+            self.model = self.DEFAULT_MODEL
+        elif not isinstance(model, str) or len(model) < 3:
+            print("[CrystalAI] Unknown model → using default.")
+            self.model = self.DEFAULT_MODEL
+        else:
+            self.model = model
+
+        self.personality = self.DEFAULT_PERSONALITY
+        self.memory = []
+        self.use_memory = True
+        self.library_context = ""
+
+    # ==========================================================
+    # PERSONALITY
+    # ==========================================================
+    def set_personality(self, txt):
+        if not isinstance(txt, str) or len(txt.strip()) < 10:
+            print("[CrystalAI] Personality too short → reverting to default.")
+            self.personality = self.DEFAULT_PERSONALITY
+            return
+
+        if len(txt) > 3000:
+            print("[CrystalAI] Personality too long → using default.")
+            self.personality = self.DEFAULT_PERSONALITY
+            return
+
+        self.personality = txt.strip()
+
+    # ==========================================================
+    # LIBRARY INGESTION
+    # ==========================================================
+    def index_library(self, folder):
+        """
+        Load all Python files as context for smarter answers.
+        """
+        if not os.path.exists(folder):
+            print("[CrystalAI] Library folder not found.")
+            return
+
+        collected = []
+        for root, _, files in os.walk(folder):
+            for f in files:
+                if f.endswith(".py"):
+                    try:
+                        p = os.path.join(root, f)
+                        with open(p, "r", encoding="utf8") as fp:
+                            collected.append(
+                                f"# FILE: {p}\n{fp.read()}\n\n"
+                            )
+                    except:
+                        pass
+
+        self.library_context = "\n".join(collected)[:120_000]   # trimmed
+
+    # ==========================================================
+    # FILE READER
+    # ==========================================================
+    def _read_file(self, path):
+        if not path:
+            return None
+        if not os.path.exists(path):
+            return f"[CrystalAI] file not found: {path}"
+        try:
+            with open(path, "r", encoding="utf8") as f:
+                return f.read()
+        except:
+            return "[CrystalAI] could not read file."
+
+    # ==========================================================
+    # PROMPT BUILDER
+    # ==========================================================
+    def _build_prompt(self, user_text, file_data):
+        final = (
+            f"[SYSTEM]\n{self.personality}\n\n"
+            f"[USER]\n{user_text}\n\n"
+        )
+
+        if self.use_memory and self.memory:
+            final += "[MEMORY]\n"
+            for m in self.memory[-6:]:
+                final += f"User: {m['user']}\nAI: {m['ai']}\n"
+            final += "\n"
+
+        if self.library_context:
+            final += f"[LIBRARY]\n{self.library_context}\n\n"
+
+        if file_data and not file_data.startswith("[CrystalAI]"):
+            final += f"[FILE]\n{file_data}\n\n"
+
+        return final[:190_000]   # safety limit
+
+    def _save_memory(self, user, ai):
+        self.memory.append({"user": user, "ai": ai})
+        if len(self.memory) > 60:
+            self.memory.pop(0)
+
+    # ==========================================================
+    # LOCAL FALLBACK AI
+    # ==========================================================
+    def _local_ai(self, user_text, file_data):
+        """
+        Much cleaner, more reliable fallback engine.
+        """
+
+        # --- AST SECTION ---
+        if file_data and not file_data.startswith("[CrystalAI]"):
+            try:
+                ast.parse(file_data)
+                return (
+                    "[LocalAI] File parsed successfully — no syntax errors.\n"
+                    "Ask for refactoring, explanation, or improvements."
+                )
+            except SyntaxError as se:
+                snippet = self._snippet(file_data, se.lineno)
+                return (
+                    "[LocalAI] SyntaxError found:\n"
+                    f"• {se.msg}\n"
+                    f"• Line {se.lineno}\n\n"
+                    f"{snippet}"
+                )
+
+        # --- GENERIC HELP ---
+        lower = user_text.lower()
+        if "python" in lower or "fix" in lower or "error" in lower:
+            return (
+                "[LocalAI] Offline mode: I can help with general Python logic.\n"
+                "If you provide a file, I can analyze it using AST."
+            )
+
+        return "[LocalAI] Offline mode active — limited responses available."
+
+    # ==========================================================
+    # MAIN "ASK" FUNCTION
+    # ==========================================================
+    def ask(self, text, file=None):
+        file_data = self._read_file(file)
+        prompt = self._build_prompt(text, file_data)
+
+        # If no API key → offline only
+        if self.force_local:
+            resp = self._local_ai(text, file_data)
+            self._save_memory(text, resp)
+            return CrystalAIResponse(resp)
+
+        # Online mode
+        try:
+            url = "https://api.groq.com/openai/v1/chat/completions"
+            headers = {
+                "Authorization": f"Bearer {self.key}",
+                "Content-Type": "application/json"
+            }
+
+            payload = {
+                "model": self.model,
+                "messages": [
+                    {"role": "system", "content": self.personality},
+                    {"role": "user", "content": prompt}
+                ],
+                "temperature": 0.3
+            }
+
+            r = requests.post(url, json=payload, headers=headers, timeout=8)
+            data = r.json()
+
+            if "error" in data:
+                raise RuntimeError(data["error"])
+
+            resp = data["choices"][0]["message"]["content"]
+
+        except Exception:
+            resp = self._local_ai(text, file_data)
+
+        self._save_memory(text, resp)
+        return CrystalAIResponse(resp)
+
+    # ==========================================================
+    # TERMINAL HELPER
+    # ==========================================================
+    def ask_t(self, text, file=None):
+        return self.ask(f"[TERMINAL] {text}", file)
+
+    # ==========================================================
+    # AUTO FIX CODE
+    # ==========================================================
+    def fix_code(self, file_path):
+        orig = self._read_file(file_path)
+
+        if not orig or orig.startswith("[CrystalAI]"):
+            return CrystalAIResponse(orig or "[CrystalAI] file missing")
+
+        try:
+            ast.parse(orig)
+            return CrystalAIResponse("[AI] No syntax errors found.")
+        except SyntaxError as se:
+            fixed, notes = self._simple_fix(orig, se)
+            diff = self._make_diff(orig, fixed)
+            msg = "[AI] Auto-fix result:\n" + "\n".join(notes) + "\n\n" + diff
+            return CrystalAIResponse(msg, {"diff": diff, "notes": notes})
+
+    # ==========================================================
+    # SIMPLE AUTO-FIX ENGINE
+    # ==========================================================
+    def _simple_fix(self, src, err):
+        notes = []
+        lines = src.splitlines()
+        msg = getattr(err, "msg", "")
+        lineno = err.lineno or 0
+
+        if "expected" in msg and ":" in msg:
+            if 1 <= lineno <= len(lines):
+                l = lines[lineno - 1].rstrip()
+                if not l.endswith(":"):
+                    lines[lineno - 1] = l + ":"
+                    notes.append("[fix] added missing ':'")
+                    candidate = "\n".join(lines)
+                    try:
+                        ast.parse(candidate)
+                        return candidate, notes
+                    except:
+                        pass
+
+        notes.append("[info] auto-fix could not fix the error")
+        return src, notes
+
+    # ==========================================================
+    # DIFF HELPER
+    # ==========================================================
+    def _make_diff(self, old, new):
+        return "\n".join(
+            difflib.unified_diff(
+                old.splitlines(), new.splitlines(),
+                fromfile="old", tofile="new", lineterm=""
+            )
+        )
+
+    # ==========================================================
+    # SNIPPET HELPER
+    # ==========================================================
+    def _snippet(self, src, lineno, ctx=2):
+        lines = src.splitlines()
+        start = max(0, lineno - ctx - 1)
+        end = min(len(lines), lineno + ctx)
+        out = []
+        for i in range(start, end):
+            mark = "->" if (i + 1) == lineno else "  "
+            out.append(f"{mark} {i+1:4}: {lines[i]}")
+        return "\n".join(out)
+
+# ==========================================================
+# END OF ENGINE
+# ==========================================================

crystalwindow-4.6/crystalwindow/clock.py

@@ -0,0 +1,189 @@
+import time
+from datetime import datetime
+from collections import deque
+
+
+# ============================================================
+# Stopwatch Helper
+# ============================================================
+class Stopwatch:
+    def __init__(self):
+        self.start_time = None
+        self.elapsed_time = 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 reset(self):
+        self.start_time = None
+        self.elapsed_time = 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 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
+
+
+# ============================================================
+# MAIN CLOCK
+# ============================================================
+class Clock:
+    def __init__(self, target_fps: int = 60, smooth_fps: int = 30):
+        self.last = time.perf_counter()
+        self.delta = 0.0
+
+        # FPS
+        self.target_fps = target_fps
+        self.min_frame_time = 1 / target_fps if target_fps else 0
+        self.frame_times = deque(maxlen=smooth_fps)
+
+        self.paused = False
+
+        # Utilities
+        self.stopwatch = Stopwatch()
+        self.timer = CountdownTimer()
+        self.scheduler = Scheduler()
+
+    # ----------------------------------------------------------
+    # TICK + FPS
+    # ----------------------------------------------------------
+    def tick(self, fps: int | None = None):
+        if fps:
+            self.target_fps = fps
+            self.min_frame_time = 1 / fps
+
+        now = time.perf_counter()
+        raw_delta = now - self.last
+        self.last = now
+
+        # Paused = no delta
+        if self.paused:
+            self.delta = 0.0
+            return 0.0
+
+        # FPS limiting
+        sleep_time = self.min_frame_time - raw_delta
+        if sleep_time > 0:
+            time.sleep(sleep_time)
+            now2 = time.perf_counter()
+            raw_delta = now2 - (self.last - raw_delta)
+
+        self.delta = raw_delta
+        self.frame_times.append(raw_delta)
+
+        # Scheduler update
+        self.scheduler.run_pending()
+
+        return self.delta
+
+    def get_fps(self):
+        if not self.frame_times:
+            return 0.0
+        avg = sum(self.frame_times) / len(self.frame_times)
+        return round(1 / avg, 2) if avg > 0 else 0
+
+    # ----------------------------------------------------------
+    # PAUSE / RESUME
+    # ----------------------------------------------------------
+    def pause(self):
+        self.paused = True
+
+    def resume(self):
+        self.paused = False
+        self.last = time.perf_counter()
+
+    # ----------------------------------------------------------
+    # TIME + DATE UTILITIES
+    # ----------------------------------------------------------
+    def time(self, milliseconds: bool = True, hour_12: bool = False):
+        now = datetime.now()
+
+        if hour_12:
+            fmt = "%I:%M:%S" + (" %p" if not milliseconds else ".%f %p")
+        else:
+            fmt = "%H:%M:%S" + (".%f" if milliseconds else "")
+
+        text = now.strftime(fmt)
+        if milliseconds:
+            # Trim microseconds to milliseconds
+            if hour_12:
+                # Example: "03:20:15.123000 PM" -> "03:20:15.123 PM"
+                parts = text.split(".")
+                ms = parts[1][:3] + parts[1][6:]  # keep .mmm, remove "000 PM"
+                text = parts[0] + "." + parts[1][:3] + " " + now.strftime("%p")
+            else:
+                text = text[:-3]  # remove last 3 microseconds digits
+
+        return text
+
+    def date(self, format: str = "%m/%d/%Y"):
+        return datetime.now().strftime(format)
+
+    def time_date(self, order: str = "time_first", **kwargs):
+        t = self.time(**kwargs)
+        d = self.date()
+        return f"{t}  |  {d}" if order == "time_first" else f"{d}  |  {t}"
+
+    # ----------------------------------------------------------
+    # CUSTOM FORMATTERS
+    # ----------------------------------------------------------
+    def format_time(self, fmt: str):
+        return datetime.now().strftime(fmt)
+
+    def format_date(self, fmt: str):
+        return datetime.now().strftime(fmt)
+
+    # ----------------------------------------------------------
+    # MONOTONIC TIMESTAMP
+    # ----------------------------------------------------------
+    def timestamp(self):
+        """High-precision monotonic timestamp."""
+        return time.perf_counter()

crystalwindow-4.6/crystalwindow/cw_client.py

@@ -0,0 +1,95 @@
+# cw_client.py
+# pip install websockets
+import asyncio
+import websockets
+import json
+import threading
+import time
+
+class CWClient:
+    """
+    Lightweight client wrapper. Usage:
+      c = CWClient("MyName", "ws://host:8765")
+      c.on_event = lambda ev: print("ev", ev)
+      c.start()
+      c.move(x,y)
+      c.chat("hi")
+    """
+    def __init__(self, pid, uri="ws://127.0.0.1:8765"):
+        self.pid = pid
+        self.uri = uri
+        self._send_q = asyncio.Queue()
+        self.on_event = None   # callback for incoming events: fn(dict)
+        self._running = False
+        self._loop_thread = None
+
+    async def _run(self):
+        try:
+            async with websockets.connect(self.uri) as ws:
+                # send join
+                await ws.send(json.dumps({"type":"join","id":self.pid}))
+                self._running = True
+                sender_task = asyncio.create_task(self._sender(ws))
+                try:
+                    async for raw in ws:
+                        try:
+                            data = json.loads(raw)
+                        except:
+                            continue
+                        if self.on_event:
+                            # run callback in same thread (safe)
+                            try:
+                                self.on_event(data)
+                            except Exception as cb_e:
+                                # swallow callback errors
+                                print("on_event callback error:", cb_e)
+                finally:
+                    sender_task.cancel()
+        except Exception as e:
+            # notify user on connection lost
+            if self.on_event:
+                try:
+                    self.on_event({"type":"sys","msg":f"connection_lost:{e}"})
+                except:
+                    pass
+        finally:
+            self._running = False
+
+    async def _sender(self, ws):
+        while True:
+            try:
+                obj = await self._send_q.get()
+                await ws.send(json.dumps(obj))
+            except Exception:
+                break
+
+    def start(self):
+        if self._loop_thread and self._loop_thread.is_alive():
+            return
+        def target():
+            asyncio.run(self._run())
+        self._loop_thread = threading.Thread(target=target, daemon=True)
+        self._loop_thread.start()
+        # give a bit of time to connect
+        time.sleep(0.05)
+
+    def send(self, obj):
+        # enqueue safely from any thread
+        async def push():
+            await self._send_q.put(obj)
+        try:
+            loop = asyncio.get_running_loop()
+            # if main thread has a loop, schedule
+            asyncio.run_coroutine_threadsafe(push(), loop)
+        except RuntimeError:
+            # no running loop in this thread: create a tiny loop to push
+            def run_push():
+                asyncio.run(push())
+            threading.Thread(target=run_push, daemon=True).start()
+
+    # convenience APIs
+    def move(self, x, y):
+        self.send({"type":"move","id":self.pid,"x":int(x),"y":int(y)})
+
+    def chat(self, msg):
+        self.send({"type":"chat","id":self.pid,"msg":str(msg)})