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

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/ai.py

@@ -1,18 +1,14 @@
 # ==========================================================
-# CrystalAI v0.8 — Hybrid Engine (Groq + Symbolic Fallback)
+# CrystalAI v0.7 — Stabilized & Corrected Engine
 # ----------------------------------------------------------
-# Combines:
-#   - Groq API for general knowledge (Primary)
-#   - Pure Python Symbolic Engine for Code Analysis (Fallback)
-#   - Memory, File Reading, AST Parsing, and Diff Utilities
-# ==========================================================
 
 import os
 import ast
 import difflib
-import requests # Re-added for API communication
-from typing import Optional, Dict, Any, List
-# Removed groq import, using requests for simplicity
+import requests
+import json
+from typing import Optional, Dict, Any
+
 
 # ==========================================================
 # Response Wrapper
@@ -30,58 +26,64 @@ class CrystalAIResponse:
 # MAIN ENGINE
 # ==========================================================
 class AI:
-    DEFAULT_MODEL = "llama-3.1-8b"
+    DEFAULT_MODEL = "llama-3.1-70b-versatile"
     DEFAULT_PERSONALITY = (
         "You are CrystalWindow AI. You help users with Python code, "
-        "debugging, errors, docs, and file analysis. You are currently running in "
-        "Hybrid Mode. Be friendly, technical, clear, and precise."
+        "debugging, error analysis, documentation, and file analysis. "
+        "Be friendly, technical, clear, and precise."
     )
-    # Placeholder Key for testing or when user key is invalid
-    PLACEHOLDER_KEY = "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" 
+
+    PLACEHOLDER_KEY = "NO_KEY_PROVIDED"
 
     # ------------------------------------------------------
     def __init__(self, key=None, model=None):
+
         # --- KEY VALIDATION ---
-        if not key or len(key) < 20 or " " in key:
-            print("[CrystalAI] Warning: Invalid or missing key → using placeholder. To get a Fixed Key go to 'console.groq.com/keys'")
-            self.key = self.PLACEHOLDER_KEY
+        # 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 not model or not isinstance(model, str) or len(model) < 3:
-            print(f"[CrystalAI] Unknown model → using default: {self.DEFAULT_MODEL}.")
+        # 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
 
-        # Persona
         self.personality = self.DEFAULT_PERSONALITY
-
-        # Pure AI knowledge (used in symbolic fallback)
-        self.knowledge_graph: Dict[str, Any] = self._build_knowledge_graph()
-
-        # Library knowledge (loaded .py files)
-        self.library_context = ""
-
-        # Memory system
-        self.memory: List[Dict[str, str]] = []
+        self.memory = []
         self.use_memory = True
-
-        # Force local toggle (currently not used as logic is based on Groq success)
-        self.force_local = False 
+        self.library_context = ""
 
     # ==========================================================
     # PERSONALITY
     # ==========================================================
     def set_personality(self, txt):
         if not isinstance(txt, str) or len(txt.strip()) < 10:
-            print("Oops! that's not how to use it—reverting to default.")
+            print("[CrystalAI] Personality too short → reverting to default.")
             self.personality = self.DEFAULT_PERSONALITY
             return
 
         if len(txt) > 3000:
-            print("Oops, personality too long → using default.")
+            print("[CrystalAI] Personality too long → using default.")
             self.personality = self.DEFAULT_PERSONALITY
             return
 
@@ -94,22 +96,24 @@ class AI:
         """
         Load all Python files as context for smarter answers.
         """
-        out = []
         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:
-                        path = os.path.join(root, f)
-                        with open(path, "r", encoding="utf8") as fp:
-                            out.append(f"# FILE: {path}\n" + fp.read() + "\n\n")
-                    except Exception:
+                        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(out)
+        self.library_context = "\n".join(collected)[:120_000]   # trimmed
 
     # ==========================================================
     # FILE READER
@@ -122,13 +126,13 @@ class AI:
         try:
             with open(path, "r", encoding="utf8") as f:
                 return f.read()
-        except Exception:
-            return "[CrystalAI] couldn't read file."
+        except:
+            return "[CrystalAI] could not read file."
 
     # ==========================================================
-    # PROMPT BUILDER (Unified)
+    # PROMPT BUILDER
     # ==========================================================
-    def _build_prompt(self, user_text, file_data=None):
+    def _build_prompt(self, user_text, file_data):
         final = (
             f"[SYSTEM]\n{self.personality}\n\n"
             f"[USER]\n{user_text}\n\n"
@@ -143,10 +147,10 @@ class AI:
         if self.library_context:
             final += f"[LIBRARY]\n{self.library_context}\n\n"
 
-        if file_data:
+        if file_data and not file_data.startswith("[CrystalAI]"):
             final += f"[FILE]\n{file_data}\n\n"
 
-        return final
+        return final[:190_000]   # safety limit
 
     def _save_memory(self, user, ai):
         self.memory.append({"user": user, "ai": ai})
@@ -154,98 +158,54 @@ class AI:
             self.memory.pop(0)
 
     # ==========================================================
-    # PURE AI KNOWLEDGE BASE (Symbolic Core)
-    # ==========================================================
-    def _build_knowledge_graph(self) -> Dict[str, Any]:
-        """
-        Defines the internal knowledge the symbolic AI can reason with.
-        """
-        return {
-            "python": {
-                "desc": "A high-level, interpreted programming language.",
-                "keywords": ["language", "interpreted", "high-level"],
-                "syntax": {
-                    "if_statement": "if condition: ... else: ...",
-                    "loop": "for item in iterable: ..."
-                }
-            },
-            "ast": {
-                "desc": "Abstract Syntax Tree. Used for parsing code structure.",
-                "keywords": ["parsing", "code", "structure", "tree"]
-            },
-            "fix_code": {
-                "rule": "look for SyntaxError, especially missing colons or mismatched brackets",
-                "keywords": ["fix", "error", "bug", "syntax"]
-            }
-        }
-        
-    # ==========================================================
-    # PURE AI 'THINKING' ENGINE (Symbolic Fallback)
+    # LOCAL FALLBACK AI
     # ==========================================================
-    def _symbolic_engine(self, prompt: str, file_data: Optional[str]) -> str:
+    def _local_ai(self, user_text, file_data):
         """
-        Fallback logic: Simulates 'thinking' using only internal rules and AST.
+        Much cleaner, more reliable fallback engine.
         """
-        output = ["[Local/SymbolicEngine] Processing request..."]
-        lower_prompt = prompt.lower()
 
-        # --- Stage 1: File Analysis (Real Python AST) ---
+        # --- AST SECTION ---
         if file_data and not file_data.startswith("[CrystalAI]"):
-            output.append("\n[Stage 1: Code Parsing]")
             try:
                 ast.parse(file_data)
-                output.append("✅ **No Syntax Errors Detected** (via AST).")
-                output.append("The code is structurally sound. Ask for refactoring or explanation.")
-                return "\n".join(output)
+                return (
+                    "[LocalAI] File parsed successfully — no syntax errors.\n"
+                    "Ask for refactoring, explanation, or improvements."
+                )
             except SyntaxError as se:
-                fix_rule = self.knowledge_graph["fix_code"]["rule"]
-                lineno = se.lineno or 0
-                msg = (
-                    f"❌ **SyntaxError Detected** (via AST):\n"
-                    f"• Message: {se.msg}\n"
-                    f"• Line: {lineno}\n"
-                    f"• Rule suggestion: {fix_rule}"
+                snippet = self._snippet(file_data, se.lineno)
+                return (
+                    "[LocalAI] SyntaxError found:\n"
+                    f"• {se.msg}\n"
+                    f"• Line {se.lineno}\n\n"
+                    f"{snippet}"
                 )
-                output.append(msg)
-                output.append(self._snippet(file_data, lineno))
-                return "\n".join(output)
-
-        # --- Stage 2: Knowledge Graph Lookup (Rule-Based Reasoning) ---
-        output.append("\n[Stage 2: Symbolic Lookup]")
-
-        found_concept = False
-        for key, knowledge in self.knowledge_graph.items():
-            if key in lower_prompt or any(k in lower_prompt for k in knowledge.get("keywords", [])):
-                if key == "fix_code": continue
-
-                output.append(f"🧠 Found Concept: **{key.upper()}**")
-                output.append(f"Description: {knowledge.get('desc', 'No detailed description.')}")
-                
-                if 'syntax' in knowledge:
-                    output.append("Related Syntax:")
-                    for syn, code in knowledge['syntax'].items():
-                        output.append(f"  - {syn.replace('_', ' ')}: `{code}`")
-                
-                found_concept = True
-                break
-        
-        if not found_concept:
-            output.append("❓ Concept Unknown: I am currently offline and limited to my internal knowledge base (Python, AST, Fix Code).")
-            output.append("Please provide a file for AST analysis or try again later for a full Groq response.")
-
-        return "\n".join(output)
 
+        # --- 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."
 
     # ==========================================================
-    # ASK (Groq → Symbolic Fallback)
+    # MAIN "ASK" FUNCTION
     # ==========================================================
     def ask(self, text, file=None):
         file_data = self._read_file(file)
         prompt = self._build_prompt(text, file_data)
-        
-        resp = None
 
-        # --- Attempt 1: Call External API (Groq) ---
+        # 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 = {
@@ -254,7 +214,7 @@ class AI:
             }
 
             payload = {
-                "model": self.model, 
+                "model": self.model,
                 "messages": [
                     {"role": "system", "content": self.personality},
                     {"role": "user", "content": prompt}
@@ -262,35 +222,28 @@ class AI:
                 "temperature": 0.3
             }
 
-            r = requests.post(url, json=payload, headers=headers, timeout=10)
+            r = requests.post(url, json=payload, headers=headers, timeout=8)
             data = r.json()
 
             if "error" in data:
-                # If the API returns an error (e.g., bad key), we force the fallback
-                raise RuntimeError(f"API Error: {data['error'].get('message', 'Unknown API Error')}")
+                raise RuntimeError(data["error"])
 
             resp = data["choices"][0]["message"]["content"]
 
-        except Exception as e:
-            # This block handles API connection failures (timeout) or API-side errors (bad key)
-            print(f"[CrystalAI] Groq connection failed or returned error: {e.__class__.__name__}")
-            print("[CrystalAI] Falling back to self-contained Symbolic Engine...")
-            
-            # --- Attempt 2: Fallback to Symbolic Engine ---
-            resp = self._symbolic_engine(prompt, file_data)
-
+        except Exception:
+            resp = self._local_ai(text, file_data)
 
         self._save_memory(text, resp)
         return CrystalAIResponse(resp)
 
     # ==========================================================
-    # ASK (terminal)
+    # TERMINAL HELPER
     # ==========================================================
     def ask_t(self, text, file=None):
         return self.ask(f"[TERMINAL] {text}", file)
 
     # ==========================================================
-    # AUTO FIX CODE (v0.4)
+    # AUTO FIX CODE
     # ==========================================================
     def fix_code(self, file_path):
         orig = self._read_file(file_path)
@@ -304,47 +257,42 @@ class AI:
         except SyntaxError as se:
             fixed, notes = self._simple_fix(orig, se)
             diff = self._make_diff(orig, fixed)
-            pretty = "[AI] Auto-fix result:\n" + "\n".join(notes) + "\n\n" + diff
-            return CrystalAIResponse(pretty, {"diff": diff, "notes": notes})
+            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, syntax_error):
+    def _simple_fix(self, src, err):
         notes = []
         lines = src.splitlines()
-        msg = getattr(syntax_error, "msg", "")
-        lineno = syntax_error.lineno or 0
+        msg = getattr(err, "msg", "")
+        lineno = err.lineno or 0
 
-        # missing colon fix
         if "expected" in msg and ":" in msg:
             if 1 <= lineno <= len(lines):
-                line = lines[lineno - 1].rstrip()
-                if not line.endswith(":"):
-                    lines[lineno - 1] = line + ":"
+                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 Exception:
+                    except:
                         pass
 
-        # fallback
-        notes.append("[info] auto-fix could not fix everything")
+        notes.append("[info] auto-fix could not fix the error")
         return src, notes
 
     # ==========================================================
-    # DIFF UTIL
+    # DIFF HELPER
     # ==========================================================
     def _make_diff(self, old, new):
         return "\n".join(
             difflib.unified_diff(
-                old.splitlines(),
-                new.splitlines(),
-                fromfile="old",
-                tofile="new",
-                lineterm=""
+                old.splitlines(), new.splitlines(),
+                fromfile="old", tofile="new", lineterm=""
             )
         )
 
@@ -358,9 +306,9 @@ class AI:
         out = []
         for i in range(start, end):
             mark = "->" if (i + 1) == lineno else "  "
-            out.append(f"{mark} {i+1:<4}: {lines[i]}")
+            out.append(f"{mark} {i+1:4}: {lines[i]}")
         return "\n".join(out)
 
 # ==========================================================
-# END OF HYBRID ENGINE
-# ==========================================================
+# END OF ENGINE
+# ==========================================================

crystalwindow/clock.py

@@ -1,23 +1,189 @@
 import time
+from datetime import datetime
+from collections import deque
 
-class Clock:
+
+# ============================================================
+# 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.last = time.time()
-        self.delta = 0
-        self.fps = 60
+        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
 
-    def tick(self, fps=None):
-        now = time.time()
-        self.delta = now - self.last
+        now = time.perf_counter()
+        raw_delta = now - self.last
         self.last = now
 
-        if fps:  
-            self.fps = fps
-            sleep_for = (1 / fps) - self.delta
-            if sleep_for > 0:
-                time.sleep(sleep_for)
+        # 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):
-        return round(1 / self.delta, 2) if self.delta else 0
+        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/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)})

crystalwindow/websearch.py

@@ -0,0 +1,233 @@
+"""
+CrystalWindow WebSearch module — Google (Serper.dev) Edition
+"""
+
+from __future__ import annotations
+import requests
+import webbrowser
+from dataclasses import dataclass
+from typing import List, Tuple, Optional, Any
+
+# Optional Qt integration
+try:
+    from PySide6.QtWidgets import (
+        QWidget, QVBoxLayout, QLineEdit, QPushButton, QTextEdit,
+        QListWidget, QListWidgetItem, QLabel, QHBoxLayout
+    )
+    from PySide6.QtCore import Qt, QUrl
+    from PySide6.QtGui import QDesktopServices
+    PYSIDE6_AVAILABLE = True
+except Exception:
+    PYSIDE6_AVAILABLE = False
+
+
+# --------------------------
+# Data result structure
+# --------------------------
+
+@dataclass
+class WebSearchResult:
+    text: str
+    links: List[Tuple[str, str]]  # (title, url)
+    raw: Any = None
+
+
+# --------------------------
+# Main WebSearch class
+# --------------------------
+
+class WebSearch:
+    """ Real Web Search helper for CrystalWindow using Google (Serper.dev). """
+
+    # --- DuckDuckGo Instant Answer (kept for fallback) ---
+    DUCKDUCKGO_INSTANT = "https://api.duckduckgo.com/"
+
+    # --- Google Search (Serper.dev) ---
+    SERPER_URL = "https://google.serper.dev/search"
+    SERPER_API_KEY = "a8e02281a0c3b58bb29a3731b6a2aec1d8d8a487"  # <<<<<<<< REPLACE THIS
+
+    # --------------------------------------------------
+    # DuckDuckGo Instant Answer (old API)
+    # --------------------------------------------------
+    @classmethod
+    def _duckduckgo_instant(cls, query: str) -> WebSearchResult:
+        params = {
+            "q": query,
+            "format": "json",
+            "no_html": 1,
+            "no_redirect": 1,
+        }
+        try:
+            r = requests.get(cls.DUCKDUCKGO_INSTANT, params=params, timeout=8)
+            r.raise_for_status()
+        except Exception as e:
+            return WebSearchResult(text=f"DuckDuckGo error: {e}", links=[])
+
+        data = r.json()
+        abstract = data.get("AbstractText") or data.get("Abstract") or ""
+        links: List[Tuple[str, str]] = []
+
+        if data.get("AbstractURL"):
+            links.append((data.get("Heading", "Result"), data["AbstractURL"]))
+
+        def extract_related(rt):
+            if isinstance(rt, dict):
+                if rt.get("FirstURL") and rt.get("Text"):
+                    links.append((rt["Text"], rt["FirstURL"]))
+                for key in ("Topics", "RelatedTopics"):
+                    if isinstance(rt.get(key), list):
+                        for sub in rt[key]:
+                            extract_related(sub)
+            elif isinstance(rt, list):
+                for item in rt:
+                    extract_related(item)
+
+        extract_related(data.get("RelatedTopics", []))
+        if not abstract and links:
+            abstract = "\n".join([t for t, _ in links[:3]])
+
+        return WebSearchResult(text=abstract.strip(), links=links, raw=data)
+
+    # --------------------------------------------------
+    # Google Search via Serper.dev (NEW)
+    # --------------------------------------------------
+    @classmethod
+    def _google_serper(cls, query: str) -> WebSearchResult:
+        headers = {
+            "X-API-KEY": cls.SERPER_API_KEY,
+            "Content-Type": "application/json"
+        }
+        body = {"q": query}
+
+        try:
+            r = requests.post(cls.SERPER_URL, headers=headers, json=body, timeout=8)
+            r.raise_for_status()
+        except Exception as e:
+            return WebSearchResult(text=f"Google search error: {e}", links=[])
+
+        data = r.json()
+
+        links = []
+        summary_parts = []
+
+        for item in data.get("organic", []):
+            title = item.get("title", "Untitled")
+            url = item.get("link", "")
+            snippet = item.get("snippet", "")
+
+            links.append((title, url))
+            if snippet:
+                summary_parts.append(snippet)
+
+        summary = "\n".join(summary_parts[:3]).strip()
+        if not summary:
+            summary = "(no summary)"
+
+        return WebSearchResult(summary, links, data)
+
+    # --------------------------------------------------
+    # Main public search()
+    # --------------------------------------------------
+    @classmethod
+    def search(cls, query: str, engine: str = "google") -> WebSearchResult:
+        if not query or not query.strip():
+            return WebSearchResult(text="", links=[])
+
+        q = query.strip().lower()
+        engine = engine.lower()
+
+        if engine == "google":
+            return cls._google_serper(q)
+
+        if engine == "duckduckgo":
+            return cls._duckduckgo_instant(q)
+
+        return WebSearchResult(text=f"Unknown engine '{engine}'", links=[])
+
+    # --------------------------------------------------
+    # URL opener
+    # --------------------------------------------------
+    @staticmethod
+    def open_url(url: str) -> None:
+        try:
+            webbrowser.open(url)
+        except Exception:
+            pass
+
+    # --------------------------------------------------
+    # Optional PySide6 GUI
+    # --------------------------------------------------
+    if PYSIDE6_AVAILABLE:
+        class _CWWebTab(QWidget):
+            def __init__(self, parent=None):
+                super().__init__(parent)
+                self.setWindowTitle("WebSearch")
+
+                layout = QVBoxLayout(self)
+
+                # Search bar
+                bar = QHBoxLayout()
+                self.qbox = QLineEdit()
+                self.qbox.setPlaceholderText("Search the web...")
+                btn = QPushButton("Search")
+                btn.clicked.connect(self._do_search)
+                bar.addWidget(self.qbox)
+                bar.addWidget(btn)
+                layout.addLayout(bar)
+
+                # Summary text
+                self.summary = QTextEdit()
+                self.summary.setReadOnly(True)
+                self.summary.setFixedHeight(150)
+                layout.addWidget(self.summary)
+
+                # Links list
+                self.links = QListWidget()
+                self.links.itemActivated.connect(self._open_item)
+                layout.addWidget(self.links)
+
+                self.note = QLabel("Powered by Google (Serper.dev) API")
+                self.note.setAlignment(Qt.AlignCenter)
+                layout.addWidget(self.note)
+
+            def _populate(self, result: WebSearchResult):
+                self.summary.setPlainText(result.text)
+                self.links.clear()
+                for t, u in result.links:
+                    item = QListWidgetItem(f"{t}\n{u}")
+                    item.setData(Qt.UserRole, u)
+                    self.links.addItem(item)
+
+            def _open_item(self, item: QListWidgetItem):
+                url = item.data(Qt.UserRole)
+                if url:
+                    QDesktopServices.openUrl(QUrl(url))
+
+            def _do_search(self):
+                q = self.qbox.text().strip()
+                if not q:
+                    self.summary.setPlainText("Type something to search.")
+                    return
+                self.summary.setPlainText("Searching...")
+                res = WebSearch.search(q, engine="google")
+                self._populate(res)
+
+        @classmethod
+        def register_cw_tab(cls, window):
+            try:
+                tab = cls._CWWebTab()
+                if hasattr(window, "add_tab"):
+                    window.add_tab("WebSearch", tab)
+                elif hasattr(window, "addTab"):
+                    window.addTab(tab, "WebSearch")
+                else:
+                    if hasattr(window, "setCentralWidget"):
+                        window.setCentralWidget(tab)
+                return tab
+            except Exception:
+                return None
+
+    else:
+        @classmethod
+        def register_cw_tab(cls, window):
+            return None

crystalwindow/window.py

@@ -1,6 +1,8 @@
 # === Window Management (tkinter version) ===
 import tkinter as tk
 import base64, io, os, sys, contextlib, time
+from .websearch import WebSearch
+
 
 # === Boot ===
 main_file = os.path.basename(sys.argv[0])
@@ -117,6 +119,8 @@ class Window:
         self._key_last = {}  # new dict to store last press time per key
         self._key_cooldown = 0.00001  # seconds, tweak for faster/slower input
 
+        WebSearch.register_cw_tab(self)
+
         # === Event bindings ===
         self.root.bind("<KeyPress>", self._on_keydown)
         self.root.bind("<KeyRelease>", self._on_keyup)
@@ -163,7 +167,8 @@ class Window:
 
     def mouse_pressed(self, button=1):
         return self._mouse_pressed[button - 1]
-
+    def add_tab(self, title, widget):
+        self.tabs.addTab(widget, title)
     # === Drawing ===
     def fill(self, color):
         """Fill background with a color"""

{crystalwindow-4.4.dist-info → crystalwindow-4.6.dist-info}/METADATA

@@ -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.dist-info → crystalwindow-4.6.dist-info}/RECORD

@@ -1,13 +1,14 @@
 crystalwindow/FileHelper.py,sha256=aUnnRG7UwvzJt-idjWjmpwy3RM6nqLlC3-7Bae6Yb94,5471
-crystalwindow/__init__.py,sha256=a2kdMZ29QZ4kSQ3M8jLvCR6g3OUQxNhdaT3ycxoames,2264
-crystalwindow/ai.py,sha256=4CN3_Fi5zERxyqoHcUyXPvm4MVWaicA7JGK0lRb-ybQ,14661
+crystalwindow/__init__.py,sha256=Vr7Zd7Wgsu4id-3KaVuIkorRm80srd4zNR8fXWJZuhY,2662
+crystalwindow/ai.py,sha256=YIt6dNe1QljSAlNECCVa3DMUSIqQEJRIAAbQpYqFNNo,11525
 crystalwindow/animation.py,sha256=zHjrdBXQeyNaLAuaGPldJueX05OZ5j31YR8NizmR0uQ,427
 crystalwindow/assets.py,sha256=2Cj0zdhMWo3mWjdr9KU5n-9_8iKj_fJ9uShMFA-27HU,5193
 crystalwindow/camera.py,sha256=tbn4X-jxMIszAUg3Iu-89gJN5nij0mjPMEzGotcLbJI,712
-crystalwindow/clock.py,sha256=EAcNvxonD7ktkKSIbuVHqzhPhQqtUQtleMSBB_OuUQY,541
+crystalwindow/clock.py,sha256=P7Hzv6-_sHIwJRFcoMLMjQB2BnVjpQWQhRHotp6OPV0,6105
 crystalwindow/collision.py,sha256=hpkHTp_KparghVK-itp_rxuYdd2GbQMxICHlUBv0rSw,472
 crystalwindow/color_handler.py,sha256=ZnXnz8552GPiRAnCkW_8wycwRRMAaFRFLlCcsrv0j2E,4071
 crystalwindow/crystal3d.py,sha256=-Te9IJgbtzl8Mpuc4BPi2bn2apnvBNTI2GwxSLd8sqg,2006
+crystalwindow/cw_client.py,sha256=KxhvXtsTfrCupB2zi5e35ppKVPrOkVXTuhgCNT6V2eA,3264
 crystalwindow/draw_helpers.py,sha256=HqjI5fTbdnA55g4LKYEuMUdIjrWaBm2U8RmeUXjcQGw,821
 crystalwindow/draw_rects.py,sha256=o7siET3y35N2LPeNBGe8QhsQbOH8J-xF6fOUz07rymU,1484
 crystalwindow/draw_text_helper.py,sha256=qv5fFCuTCKWeGDk9Z_ZpOzrTFP8YYwlgQrrorwrq9Hg,1298
@@ -21,7 +22,8 @@ crystalwindow/player.py,sha256=4wpIdUZLTlRXV8fDRQ11yVJRbx_cv8Ekpn2y7pQGgAQ,3442
 crystalwindow/sprites.py,sha256=2kYW4QfSnyUwRLedZCkb99wUSxn2a0JdWOHcfkxcG0U,3411
 crystalwindow/tilemap.py,sha256=PHoKL1eWuNeHIf0w-Jh5MGdQGEgklVsxqqJOS-GNMKI,322
 crystalwindow/ver_warner.py,sha256=qEN3ulc1NixBy15FFx2R3Zu0DhyJTVJwiESGAPwpynM,3373
-crystalwindow/window.py,sha256=e6C8yIdVdjOduIeU0ZmlrNn8GmyvHuzKs473pRggkz0,18180
+crystalwindow/websearch.py,sha256=O98LfYPuovdU6ct8iStNpoEJLTc26av9bz4nqX6lyN4,8027
+crystalwindow/window.py,sha256=umJ8gNGS64N_mVzPBBxZKUNq0mDcGoy7ImJthLlZHSI,18337
 crystalwindow/Icons/default_icon.png,sha256=Loq27Pxb8Wb3Sz-XwtNF1RmlLNxR4TcfOWfK-1lWcII,7724
 crystalwindow/docs/getting_started.md,sha256=e_XEhJk8eatS22MX0nRX7hQNkYkwN9both1ObabZSTw,5759
 crystalwindow/docs/index.md,sha256=bd14uLWtRSeRBm28zngGyfGDI1J6bJRvHkQLDpYwgOE,747
@@ -33,8 +35,8 @@ crystalwindow/gametests/guitesting.py,sha256=SrOssY5peCQEV6TQ1AiOWtjb9phVGdRzW-Q
 crystalwindow/gametests/sandbox.py,sha256=Oo2tU2N0y3BPVa6T5vs_h9N6islhQrjSrr_78XLut5I,1007
 crystalwindow/gametests/squaremove.py,sha256=poP2Zjl2oc2HVvIAgIK34H2jVj6otL4jEdvAOR6L9sI,572
 crystalwindow/gametests/windowtesting.py,sha256=_9X6wnV1-_X_PtNS-0zu-k209NtFIwAc4vpxLPp7V2o,97
-crystalwindow-4.4.dist-info/licenses/LICENSE,sha256=Gt5cJRchdNt0guxyQMHKsATN5PM5mjuDhdO6Gzs9qQc,1096
-crystalwindow-4.4.dist-info/METADATA,sha256=8j8_X2PPPAo6OmZELS5-KpjARhkwJcnYcC4r2qur-7M,7338
-crystalwindow-4.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-crystalwindow-4.4.dist-info/top_level.txt,sha256=PeQSld4b19XWT-zvbYkvE2Xg8sakIMbDzSzSdOSRN8o,14
-crystalwindow-4.4.dist-info/RECORD,,
+crystalwindow-4.6.dist-info/licenses/LICENSE,sha256=Gt5cJRchdNt0guxyQMHKsATN5PM5mjuDhdO6Gzs9qQc,1096
+crystalwindow-4.6.dist-info/METADATA,sha256=PSVgwP0RGNqMC7PerNTZkFFH4KzslVZNDBCZ9MHrsww,7338
+crystalwindow-4.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+crystalwindow-4.6.dist-info/top_level.txt,sha256=PeQSld4b19XWT-zvbYkvE2Xg8sakIMbDzSzSdOSRN8o,14
+crystalwindow-4.6.dist-info/RECORD,,