crystalwindow 4.3__py3-none-any.whl → 4.5__py3-none-any.whl

crystalwindow/__init__.py

@@ -45,6 +45,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 +53,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",
@@ -84,11 +88,14 @@ __all__ = [
     "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,20 +1,14 @@
 # ==========================================================
-# CrystalAI v0.7 — Self-Contained Symbolic Engine
+# CrystalAI v0.7 — Stabilized & Corrected Engine
 # ----------------------------------------------------------
-# Focus: Pure Python 'thinking' (Knowledge Graph/Rule-Based)
-# Changes:
-#   - Refactored _local_ai to _symbolic_engine
-#   - Added a simple knowledge base (K-Graph)
-#   - Added context/intent matching for 'thinking'
-#   - Removed Groq/External API integration
-# ==========================================================
 
 import os
 import ast
 import difflib
-from typing import Optional, Dict, Any, List
-# Removed requests and groq imports as they are no longer needed
-# Removed import groq (if it was present)
+import requests
+import json
+from typing import Optional, Dict, Any
+
 
 # ==========================================================
 # Response Wrapper
@@ -32,33 +26,51 @@ class CrystalAIResponse:
 # MAIN ENGINE
 # ==========================================================
 class AI:
-    DEFAULT_MODEL = "PURE_SYMBOLIC"
+    DEFAULT_MODEL = "llama-3.1-70b-versatile"
     DEFAULT_PERSONALITY = (
-        "You are CrystalMind AI, a completely self-coded, symbolic engine. "
-        "I process information using an internal rule-base and knowledge graph. "
-        "I can reason about simple code and defined concepts."
+        "You are CrystalWindow AI. You help users with Python code, "
+        "debugging, error analysis, documentation, and file analysis. "
+        "Be friendly, technical, clear, and precise."
     )
-    # Key is ignored in this self-contained mode, but kept for signature consistency
-    PLACEHOLDER_KEY = "PURE_SYMBOLIC_KEY_IGNORED" 
+
+    PLACEHOLDER_KEY = "NO_KEY_PROVIDED"
 
     # ------------------------------------------------------
     def __init__(self, key=None, model=None):
-        # --- KEY/MODEL SETUP (for consistency, though ignored) ---
-        self.key = self.PLACEHOLDER_KEY
-        self.model = self.DEFAULT_MODEL
-        self.personality = self.DEFAULT_PERSONALITY
 
-        # --- PURE AI KNOWLEDGE BASE (The 'Thinking' Core) ---
-        self.knowledge_graph: Dict[str, Any] = self._build_knowledge_graph()
+        # --- 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
 
-        # v0.4 memory system (optional)
-        self.memory: List[Dict[str, str]] = []
+        self.personality = self.DEFAULT_PERSONALITY
+        self.memory = []
         self.use_memory = True
-
-        # v0.4 toggle for forcing local engine
-        self.force_local = True # Always True for a self-contained AI
-
-        # Library knowledge (loaded .py files)
         self.library_context = ""
 
     # ==========================================================
@@ -66,12 +78,12 @@ class AI:
     # ==========================================================
     def set_personality(self, txt):
         if not isinstance(txt, str) or len(txt.strip()) < 10:
-            print("Oops! thats 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
 
@@ -83,24 +95,25 @@ class AI:
     def index_library(self, folder):
         """
         Load all Python files as context for smarter answers.
-        (Context is used in prompt but processed by local engine's rules)
         """
-        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")
+                        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
@@ -114,12 +127,12 @@ class AI:
             with open(path, "r", encoding="utf8") as f:
                 return f.read()
         except:
-            return "[CrystalAI] couldnt read file."
+            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"
@@ -134,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})
@@ -145,114 +158,92 @@ class AI:
             self.memory.pop(0)
 
     # ==========================================================
-    # PURE AI KNOWLEDGE BASE (Self-Contained 'Knowledge')
-    # ==========================================================
-    def _build_knowledge_graph(self) -> Dict[str, Any]:
-        """
-        Defines the internal knowledge the pure 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 (Replaces _local_ai)
+    # LOCAL FALLBACK AI
     # ==========================================================
-    def _symbolic_engine(self, prompt: str, file_data: Optional[str]) -> str:
+    def _local_ai(self, user_text, file_data):
         """
-        Simulates 'thinking' using only internal rules and the knowledge graph.
+        Much cleaner, more reliable fallback engine.
         """
-        output = ["[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:
-                # Use the built-in fix rule from the knowledge graph
-                fix_rule = self.knowledge_graph["fix_code"]["rule"]
-                lineno = se.lineno or 0
-                offset = se.offset or 0
-                msg = (
-                    f"❌ **SyntaxError Detected** (via AST):\n"
-                    f"• Message: {se.msg}\n"
-                    f"• Line: {lineno}\n"
-                    f"• Column: {offset}\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]")
-
-        # Check for concepts the AI 'knows'
-        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 # Already handled in Stage 1
-
-                output.append(f"🧠 Found Concept: **{key.upper()}**")
-                output.append(f"Description: {knowledge.get('desc', 'No detailed description.')}")
-                
-                # Simple reasoning about related syntax
-                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 limited to my internal knowledge base (Python, AST, Fix Code).")
-            output.append("Please ask about a defined concept or provide a file for AST analysis.")
-
-
-        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 (Pure Symbolic Engine)
+    # MAIN "ASK" FUNCTION
     # ==========================================================
     def ask(self, text, file=None):
         file_data = self._read_file(file)
         prompt = self._build_prompt(text, file_data)
-        
-        # We skip the external API call entirely, relying on the symbolic engine
-        resp = self._symbolic_engine(prompt, 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)
 
     # ==========================================================
-    # 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)
@@ -266,24 +257,23 @@ 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
         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:
@@ -292,21 +282,17 @@ class AI:
                     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=""
             )
         )
 
@@ -320,10 +306,9 @@ class AI:
         out = []
         for i in range(start, end):
             mark = "->" if (i + 1) == lineno else "  "
-            # Adjusted line formatting for clarity
-            out.append(f"{mark} {i+1:<4}: {lines[i]}")
+            out.append(f"{mark} {i+1:4}: {lines[i]}")
         return "\n".join(out)
 
 # ==========================================================
-# END OF PURE SYMBOLIC ENGINE
-# ==========================================================
+# END OF ENGINE
+# ==========================================================

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.3.dist-info → crystalwindow-4.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crystalwindow
-Version: 4.3
+Version: 4.5
 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.3.dist-info → crystalwindow-4.5.dist-info}/RECORD

@@ -1,6 +1,6 @@
 crystalwindow/FileHelper.py,sha256=aUnnRG7UwvzJt-idjWjmpwy3RM6nqLlC3-7Bae6Yb94,5471
-crystalwindow/__init__.py,sha256=a2kdMZ29QZ4kSQ3M8jLvCR6g3OUQxNhdaT3ycxoames,2264
-crystalwindow/ai.py,sha256=k-3MVOKZwAIMLB6ifyR0Gcuo4Fh0-JvoDVA9_j-PJSQ,13293
+crystalwindow/__init__.py,sha256=nOEUvoB4OpcYq_le1Kee0Uef3Jq38bYYapOI1u1CN2E,2457
+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
@@ -8,6 +8,7 @@ crystalwindow/clock.py,sha256=EAcNvxonD7ktkKSIbuVHqzhPhQqtUQtleMSBB_OuUQY,541
 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.3.dist-info/licenses/LICENSE,sha256=Gt5cJRchdNt0guxyQMHKsATN5PM5mjuDhdO6Gzs9qQc,1096
-crystalwindow-4.3.dist-info/METADATA,sha256=gYbWholGWviaRGXpVc1zaOZ0wQ6KWB9lvw2ZdWbBDrY,7338
-crystalwindow-4.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-crystalwindow-4.3.dist-info/top_level.txt,sha256=PeQSld4b19XWT-zvbYkvE2Xg8sakIMbDzSzSdOSRN8o,14
-crystalwindow-4.3.dist-info/RECORD,,
+crystalwindow-4.5.dist-info/licenses/LICENSE,sha256=Gt5cJRchdNt0guxyQMHKsATN5PM5mjuDhdO6Gzs9qQc,1096
+crystalwindow-4.5.dist-info/METADATA,sha256=nWirrrZxkZMaUYGi8BbZQ3fGFCh0d0OZTtLReJHzYls,7338
+crystalwindow-4.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+crystalwindow-4.5.dist-info/top_level.txt,sha256=PeQSld4b19XWT-zvbYkvE2Xg8sakIMbDzSzSdOSRN8o,14
+crystalwindow-4.5.dist-info/RECORD,,