catengine 0.5.7__tar.gz

catengine-0.5.7/LICENSE.txt

@@ -0,0 +1,25 @@
+---
+
+#### `LICENSE`
+```text
+MIT License
+
+Copyright (c) 2026 Catdows Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

catengine-0.5.7/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: catengine
+Version: 0.5.7
+Summary: A lightweight PySide6 HTML/CSS browser rendering engine widget.
+Author-email: PurrEmium Team <your-email@example.com>
+Project-URL: Homepage, https://github.com/yourusername/catengine
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: User Interfaces
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: PySide6>=6.0.0
+Dynamic: license-file
+
+# CatEngine 🐱
+
+A lightweight, custom PySide6 HTML/CSS rendering engine widget built on `QPainter` and `QJSEngine`.
+
+## Installation
+
+```bash
+pip install catengine

catengine-0.5.7/README.md

@@ -0,0 +1,8 @@
+# CatEngine 🐱
+
+A lightweight, custom PySide6 HTML/CSS rendering engine widget built on `QPainter` and `QJSEngine`.
+
+## Installation
+
+```bash
+pip install catengine

catengine-0.5.7/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "catengine"
+version = "0.5.7"
+authors = [
+  { name="PurrEmium Team", email="your-email@example.com" },
+]
+description = "A lightweight PySide6 HTML/CSS browser rendering engine widget."
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: User Interfaces",
+]
+dependencies = [
+    "PySide6>=6.0.0"
+]
+
+[project.urls]
+"Homepage" = "https://github.com/yourusername/catengine"

catengine-0.5.7/setup.cfg

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

catengine-0.5.7/src/catengine/__init__.py

@@ -0,0 +1,4 @@
+from .engine import CatEngine, Node, Parser
+
+__version__ = "0.5.7"
+__all__ = ["CatEngine", "Node", "Parser"]

catengine-0.5.7/src/catengine/catengine.py

@@ -0,0 +1,766 @@
+"""CatEngine Library — A lightweight HTML/CSS rendering and DOM engine widget 
+built on PySide6 and QPainter.
+"""
+import sys, re, json, urllib.request, urllib.error, threading
+from pathlib import Path
+from html.parser import HTMLParser
+from urllib.parse import urlparse, unquote, urljoin, quote_plus, urlencode, parse_qs
+
+from PySide6.QtCore import Qt, QRectF, QSize, Signal, QObject, Slot, QTimer, QRunnable, QThreadPool
+from PySide6.QtGui import QPainter, QColor, QFont, QFontMetrics, QPen, QPixmap, QKeyEvent
+from PySide6.QtWidgets import QWidget
+
+HAS_JS = False
+QJSEngine = None
+try:
+    from PySide6.QtQml import QJSEngine, QJSValue
+    HAS_JS = True
+except Exception:
+    QJSValue = None
+
+VOID = {"br", "hr", "img", "input", "meta", "link", "area", "base", "embed", "source", "wbr"}
+BLOCK = {"html", "body", "div", "section", "article", "header", "footer", "main", "nav", "aside", "figure", "figcaption", "h1", "h2", "h3", "h4", "h5", "h6", "p", "ul", "ol", "li", "blockquote", "pre", "table", "tr", "td", "th", "form"}
+SKIP = {"head", "title", "style", "meta", "script", "link"}
+DEFAULT = {
+    "body": {"margin":"16px", "font-size":"16px", "font-family":"Segoe UI, Arial", "color":"#202124", "background":"white"},
+    "h1":{"font-size":"32px","font-weight":"bold","margin":"16px 0 12px"},
+    "h2":{"font-size":"25px","font-weight":"bold","margin":"14px 0 10px"},
+    "h3":{"font-size":"21px","font-weight":"bold","margin":"12px 0 8px"},
+    "p":{"margin":"0 0 12px"}, "a":{"color":"#0759c7","text-decoration":"underline"},
+    "ul":{"padding-left":"22px","margin":"0 0 12px"}, "ol":{"padding-left":"22px","margin":"0 0 12px"},
+    "li":{"margin":"0 0 4px"}, "pre":{"background":"#f1f3f4","padding":"8px","font-family":"monospace"},
+    "code":{"background":"#f1f3f4","font-family":"monospace"},
+    "button":{"padding":"6px 10px","background":"#eeeeee","border":"1px solid #888"},
+    "input":{"padding":"6px 8px","background":"#ffffff","border":"1px solid #767676","width":"200px"}
+}
+
+class Node:
+    def __init__(self, tag="document", attrs=None, parent=None, text=""):
+        self.tag = tag
+        self.attrs = dict(attrs or [])
+        self.parent = parent
+        self.text = text
+        self.children = []
+        if parent is not None:
+            parent.children.append(self)
+
+    def text_content(self):
+        if self.tag == "#text":
+            return self.text
+        return "".join(c.text_content() for c in self.children)
+
+class Parser(HTMLParser):
+    def __init__(self):
+        super().__init__(convert_charrefs=True)
+        self.root = Node()
+        self.stack = [self.root]
+        self.css, self.scripts, self.links = [], [], []
+        self.mode = ""
+
+    def handle_starttag(self, tag, attrs):
+        tag = tag.lower(); ad = dict(attrs)
+        n = Node(tag, attrs, self.stack[-1])
+        if tag == "style": self.mode = "style"; self.css.append("")
+        elif tag == "script": self.mode = "script"; self.scripts.append("")
+        elif tag == "link" and ad.get("rel", "").lower() == "stylesheet" and ad.get("href"):
+            self.links.append(ad["href"])
+        if tag not in VOID: self.stack.append(n)
+
+    def handle_startendtag(self, tag, attrs):
+        tag = tag.lower(); ad = dict(attrs)
+        Node(tag, attrs, self.stack[-1])
+        if tag == "link" and ad.get("rel", "").lower() == "stylesheet" and ad.get("href"):
+            self.links.append(ad["href"])
+
+    def handle_endtag(self, tag):
+        tag = tag.lower()
+        if tag in ("style", "script"): self.mode = ""
+        for i in range(len(self.stack)-1, 0, -1):
+            if self.stack[i].tag == tag:
+                self.stack = self.stack[:i]
+                break
+
+    def handle_data(self, data):
+        if self.mode == "style":
+            if self.css: self.css[-1] += data
+        elif self.mode == "script":
+            if self.scripts: self.scripts[-1] += data
+        elif data:
+            Node("#text", parent=self.stack[-1], text=data)
+
+def px(v, d=0):
+    m = re.search(r"-?\d+(?:\.\d+)?", str(v or ""))
+    return float(m.group()) if m else float(d)
+
+def box(v, d=0):
+    a = [px(x, d) for x in str(v or "").split()[:4]]
+    if not a: return [d]*4
+    if len(a)==1: return a*4
+    if len(a)==2: return [a[0],a[1],a[0],a[1]]
+    if len(a)==3: return [a[0],a[1],a[2],a[1]]
+    return a
+
+def decl(s):
+    out = {}
+    for item in (s or "").split(";"):
+        if ":" in item:
+            k,v = item.split(":",1); out[k.strip().lower()] = v.strip()
+    return out
+
+def css_rules(css):
+    css = re.sub(r"/\*.*?\*/", "", css or "", flags=re.S)
+    out=[]
+    for sel,body in re.findall(r"([^{}]+)\{([^{}]*)\}", css)[:500]:
+        sel=sel.strip()
+        if sel.startswith("@"): continue
+        declarations=decl(body)
+        for item in sel.split(","):
+            item=item.strip()
+            if item: out.append((item,declarations))
+    return out
+
+def _simple_selector_matches(n, selector):
+    selector=selector.strip()
+    if not selector or n.tag in ("#text", "document"): return False
+    pseudos=re.findall(r":(first-child|last-child|only-child|nth-child\((\d+)\)|not\(([^()]*)\))", selector)
+    clean=re.sub(r":(?:first-child|last-child|only-child|nth-child\(\d+\)|not\([^()]*\))", "", selector)
+    attrs=re.findall(r"\[([\w:-]+)\s*(?:(\^=|\$=|\*=|~=|\|=|=)\s*([^\]]*))?\]", clean)
+    clean=re.sub(r"\[[^\]]+\]", "", clean).strip()
+    tag=re.match(r"^[a-zA-Z][\w-]*|^\*", clean)
+    if tag and tag.group() not in ("*",) and n.tag.lower()!=tag.group().lower(): return False
+    ident=re.search(r"#([\w-]+)",clean)
+    if ident and n.attrs.get("id")!=ident.group(1): return False
+    classes=re.findall(r"\.([\w-]+)",clean)
+    node_classes=n.attrs.get("class", "").split()
+    if any(c not in node_classes for c in classes): return False
+    for name,op,val in attrs:
+        if name not in n.attrs: return False
+        val=(val or "").strip().strip("\"'")
+        actual=str(n.attrs.get(name,""))
+        if not op: continue
+        if op=="=" and actual!=val: return False
+        if op=="^=" and not actual.startswith(val): return False
+        if op=="$=" and not actual.endswith(val): return False
+        if op=="*=" and val not in actual: return False
+        if op=="~=" and val not in actual.split(): return False
+        if op=="|=" and actual!=val and not actual.startswith(val+"-"): return False
+    for pseudo,arg,not_arg in pseudos:
+        siblings=[c for c in (n.parent.children if n.parent else []) if c.tag!="#text"]
+        if n not in siblings: return False
+        idx=siblings.index(n)+1
+        if pseudo=="first-child" and idx!=1: return False
+        if pseudo=="last-child" and idx!=len(siblings): return False
+        if pseudo=="only-child" and len(siblings)!=1: return False
+        if pseudo.startswith("nth-child") and idx!=int(arg): return False
+        if pseudo.startswith("not") and _simple_selector_matches(n,not_arg): return False
+    return bool(tag or ident or classes or attrs or pseudos or clean=="*")
+
+def matches(n, selector):
+    selector=re.sub(r"\s*([>+~])\s*",r" \1 ",(selector or "").strip())
+    tokens=re.findall(r"[^\s>+~]+|[>+~]",selector)
+    if not tokens: return False
+    compounds=[]; combinators=[]
+    for token in tokens:
+        if token in ("," , ">","+","~"):
+            if token in (">","+","~"):
+                if not compounds or len(combinators)!=len(compounds)-1: return False
+                combinators.append(token)
+        else:
+            if compounds and len(combinators)==len(compounds)-1: combinators.append(" ")
+            compounds.append(token)
+    if len(combinators)!=len(compounds)-1: return False
+    cur=n
+    if not _simple_selector_matches(cur,compounds[-1]): return False
+    for i in range(len(compounds)-2,-1,-1):
+        comb=combinators[i]
+        if comb==">":
+            cur=cur.parent
+            if cur is None or not _simple_selector_matches(cur,compounds[i]): return False
+        elif comb=="+":
+            sibs=[c for c in (cur.parent.children if cur.parent else []) if c.tag!="#text"]
+            try: cur=sibs[sibs.index(cur)-1] if sibs.index(cur)>0 else None
+            except ValueError: cur=None
+            if cur is None or not _simple_selector_matches(cur,compounds[i]): return False
+        elif comb=="~":
+            sibs=[c for c in (cur.parent.children if cur.parent else []) if c.tag!="#text"]
+            try: idx=sibs.index(cur)
+            except ValueError: idx=0
+            prev=next((x for x in reversed(sibs[:idx]) if _simple_selector_matches(x,compounds[i])),None)
+            if prev is None: return False
+            cur=prev
+        else:
+            anc=cur.parent
+            while anc is not None and not _simple_selector_matches(anc,compounds[i]): anc=anc.parent
+            if anc is None: return False
+            cur=anc
+    return True
+
+def color(v, default="#202124"):
+    c=QColor(v or default)
+    return c if c.isValid() else QColor(default)
+
+class FetchSignals(QObject):
+    finished = Signal(int, str, str)
+
+class FetchWorker(QRunnable):
+    def __init__(self, request_id, url, signals):
+        super().__init__(); self.request_id=request_id; self.url=url; self.signals=signals
+    def run(self):
+        try:
+            req=urllib.request.Request(self.url, headers={"User-Agent":"CatEngine/0.5.7"})
+            with urllib.request.urlopen(req, timeout=8) as resp:
+                data=resp.read().decode("utf-8", errors="replace")
+            self.signals.finished.emit(self.request_id, data, "")
+        except Exception as exc:
+            self.signals.finished.emit(self.request_id, "", str(exc))
+
+class JSConsole(QObject):
+    @Slot(str)
+    def log(self, msg): print("[JS Console]:", msg)
+    @Slot(str)
+    def error(self, msg): print("[JS Error]:", msg)
+
+class DOMBridge(QObject):
+    def __init__(self, view):
+        super().__init__(); self.view=view
+        self._next_request=1; self._pending_fetch={}
+        self.fetch_signals=FetchSignals()
+        self.fetch_signals.finished.connect(self._fetch_finished)
+
+    @Slot(str, str, result=str)
+    def getStyle(self, handle, prop):
+        node=self.view.resolve_node(handle)
+        if not node: return ""
+        return decl(node.attrs.get("style", "")).get(prop.strip().lower(), "")
+
+    @Slot(str, result=str)
+    def getParentHandle(self, handle):
+        node=self.view.resolve_node(handle)
+        return self.view.register_node(node.parent) if node and node.parent else ""
+
+    @Slot(str, result=str)
+    def getChildrenHandles(self, handle):
+        node=self.view.resolve_node(handle)
+        return json.dumps([self.view.register_node(c) for c in node.children if c.tag != "#text"]) if node else "[]"
+
+    @Slot(str, result=str)
+    def getChildNodeHandles(self, handle):
+        node=self.view.resolve_node(handle)
+        return json.dumps([self.view.register_node(c) for c in node.children]) if node else "[]"
+
+    @Slot(str, str, str)
+    def setStyle(self, elem_id, prop, val):
+        target=self.view.resolve_node(elem_id)
+        if target:
+            target.attrs.setdefault("style", "")
+            styles=decl(target.attrs.get("style", "")); styles[prop.lower().strip()]=val.strip()
+            target.attrs["style"]="; ".join(f"{k}: {v}" for k,v in styles.items())
+            self.view.recalculate_styles(); self.view.update()
+
+    @Slot(str, str)
+    def setInnerHTML(self, elem_id, html_content):
+        target=self.view.resolve_node(elem_id)
+        if target:
+            sub=Parser()
+            try:
+                sub.feed(html_content); sub.close()
+                target.children=[]
+                for child in sub.root.children:
+                    child.parent=target; target.children.append(child)
+                self.view.recalculate_styles(); self.view.update()
+            except Exception as exc: print("innerHTML error:", exc)
+
+    @Slot(str, result=str)
+    def findHandle(self, elem_id):
+        node = self.view.find_by_id(self.view.root, elem_id)
+        return self.view.register_node(node) if node else ""
+
+    @Slot(str, result=str)
+    def getTagName(self, handle):
+        node=self.view.resolve_node(handle)
+        return node.tag.upper() if node and node.tag != "#text" else "#text"
+
+    @Slot(str, str, result=str)
+    def getAttribute(self, handle, name):
+        node=self.view.resolve_node(handle)
+        if not node: return ""
+        name=name.lower().strip()
+        if name == "value" and node.tag == "input":
+            return node.attrs.get("_input_val", node.attrs.get("value", ""))
+        return str(node.attrs.get(name, ""))
+
+    @Slot(str, str)
+    def removeAttribute(self, handle, name):
+        node=self.view.resolve_node(handle)
+        name=name.lower().strip()
+        if node and name in node.attrs and not name.startswith("on") and not name.startswith("_"):
+            del node.attrs[name]
+            self.view.recalculate_styles(); self.view.update()
+
+    @Slot(str, result=str)
+    def querySelector(self, selector):
+        node=self.view.query_selector(selector)
+        return self.view.register_node(node) if node else ""
+
+    @Slot(str, result=str)
+    def querySelectorAll(self, selector):
+        nodes=self.view.query_selector_all(selector)
+        return json.dumps([self.view.register_node(node) for node in nodes])
+
+    @Slot(str, str)
+    def removeChild(self, parent_handle, child_handle):
+        parent=self.view.resolve_node(parent_handle); child=self.view.resolve_node(child_handle)
+        if parent and child and child.parent is parent and child in parent.children:
+            parent.children.remove(child); child.parent=None
+            self.view.recalculate_styles(); self.view.update()
+
+    @Slot(str, result=str)
+    def getTextContent(self, handle):
+        node = self.view.resolve_node(handle)
+        return node.text_content() if node else ""
+
+    @Slot(str, result=str)
+    def getInnerHTML(self, handle):
+        node = self.view.resolve_node(handle)
+        if not node: return ""
+        def serialize(n):
+            if n.tag == "#text":
+                return (n.text.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;"))
+            attrs = "".join(" " + k + '=\"' + str(v).replace("&", "&amp;").replace('\"', "&quot;") + '\"' for k, v in n.attrs.items() if not k.startswith("_"))
+            if n.tag in VOID: return "<" + n.tag + attrs + ">"
+            return "<" + n.tag + attrs + ">" + "".join(serialize(c) for c in n.children) + "</" + n.tag + ">"
+        return "".join(serialize(c) for c in node.children)
+
+    @Slot(str, result=str)
+    def createTextNode(self, text):
+        parent = self.view.find(self.view.root, "body") or self.view.root
+        node = Node("#text", parent=parent, text=text)
+        return self.view.register_node(node)
+
+    @Slot(str, str, result=str)
+    def createElement(self, tag_name, parent_id):
+        tag=tag_name.strip().lower()
+        if not re.fullmatch(r"[a-z][a-z0-9-]*", tag) or tag in ("script", "iframe", "object", "embed"):
+            return ""
+        parent=self.view.find_by_id(self.view.root, parent_id) if parent_id else (self.view.find(self.view.root,"body") or self.view.root)
+        if not parent: return ""
+        node=Node(tag=tag, parent=parent)
+        handle=self.view.register_node(node)
+        self.view.recalculate_styles(); self.view.update()
+        return handle
+
+    @Slot(str, str, str)
+    def insertBefore(self, parent_handle, child_handle, ref_handle):
+        parent=self.view.resolve_node(parent_handle); child=self.view.resolve_node(child_handle)
+        ref=self.view.resolve_node(ref_handle) if ref_handle else None
+        if not parent or not child or parent is child or (ref is not None and ref.parent is not parent): return
+        cur=parent
+        while cur:
+            if cur is child: return
+            cur=cur.parent
+        if child.parent and child in child.parent.children: child.parent.children.remove(child)
+        child.parent=parent
+        if ref is not None and ref in parent.children: parent.children.insert(parent.children.index(ref),child)
+        else: parent.children.append(child)
+        self.view.recalculate_styles(); self.view.update()
+
+    @Slot(str, str, result=bool)
+    def appendChild(self, parent_id, child_handle):
+        parent=self.view.resolve_node(parent_id)
+        child=self.view.resolve_node(child_handle)
+        if not parent or not child or parent is child: return False
+        cur=parent
+        while cur:
+            if cur is child: return False
+            cur=cur.parent
+        if child.parent and child in child.parent.children: child.parent.children.remove(child)
+        child.parent=parent; parent.children.append(child)
+        self.view.recalculate_styles(); self.view.update(); return True
+
+    @Slot(str, str)
+    def setTextContent(self, elem_id, text):
+        node=self.view.resolve_node(elem_id)
+        if node:
+            node.children=[]
+            Node("#text", parent=node, text=text)
+            self.view.recalculate_styles(); self.view.update()
+
+    @Slot(str, result=str)
+    def getInputValue(self, elem_id):
+        node = self.view.resolve_node(elem_id)
+        if not node or node.tag != "input": return ""
+        return node.attrs.get("_input_val", node.attrs.get("value", ""))
+
+    @Slot(str, str)
+    def setInputValue(self, elem_id, value):
+        node = self.view.resolve_node(elem_id)
+        if node and node.tag == "input":
+            node.attrs["_input_val"] = value
+            self.view.update()
+
+    @Slot(str, str)
+    def setAttribute(self, elem_id, name, value):
+        node=self.view.resolve_node(elem_id)
+        name=name.lower().strip()
+        if node and re.fullmatch(r"[a-z_:][a-z0-9_.:-]*", name) and not name.startswith("on"):
+            node.attrs[name]=value
+            self.view.recalculate_styles(); self.view.update()
+
+    @Slot(str, str, str)
+    def addEventListener(self, elem_id, event_type, callback_id):
+        node=self.view.resolve_node(elem_id)
+        event_type=event_type.lower().strip()
+        if node and event_type in ("click", "input", "change") and callback_id:
+            listeners = node.attrs.setdefault("_listeners", {})
+            existing = listeners.get(event_type, [])
+            if isinstance(existing, str): existing = [existing]
+            else: existing = list(existing)
+            existing.append(callback_id)
+            listeners[event_type] = existing
+
+    @Slot(str, str, int)
+    def setTimeout(self, callback_id, code, delay_ms):
+        delay=max(0, min(60000, int(delay_ms)))
+        QTimer.singleShot(delay, lambda: self.view.run_timeout(callback_id, code))
+
+    @Slot(str, result=int)
+    def startFetch(self, url):
+        full=urljoin(self.view.current_url or str(self.view.base), url)
+        parsed=urlparse(full)
+        if parsed.scheme not in ("http", "https"): return -1
+        request_id=self._next_request; self._next_request+=1
+        self._pending_fetch[request_id]=True
+        QThreadPool.globalInstance().start(FetchWorker(request_id, full, self.fetch_signals))
+        return request_id
+
+    @Slot(int, result=bool)
+    def hasFetchResult(self, request_id):
+        return request_id in self._pending_fetch and isinstance(self._pending_fetch[request_id], tuple)
+
+    @Slot(int, result=str)
+    def takeFetchResult(self, request_id):
+        item=self._pending_fetch.pop(request_id, None)
+        if not isinstance(item, tuple): return json.dumps({"error":"Request is not ready"})
+        body, error=item
+        return json.dumps({"ok": not bool(error), "text": body, "error": error})
+
+    @Slot(int, str, str)
+    def _fetch_finished(self, request_id, body, error):
+        if request_id in self._pending_fetch:
+            self._pending_fetch[request_id]=(body,error)
+
+class CatEngine(QWidget):
+    """Embeddable HTML rendering engine widget."""
+    linkClicked = Signal(str)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.root = Node()
+        self.styles = {}
+        self.hit = []
+        self.floats = []
+        self.base = Path.cwd()
+        self.current_url = ""
+        self.title = "CatEngine"
+        self.setMinimumSize(600, 450)
+        self.setMouseTracking(True)
+        self.setFocusPolicy(Qt.FocusPolicy.StrongFocus)
+        self.focused_input = None
+        self.js_engine = None
+        self._node_handles = {}
+        self._handle_nodes = {}
+        self._next_handle = 1
+        self.js_console = None
+        self.dom_bridge = None
+
+        if HAS_JS:
+            try:
+                self.js_engine = QJSEngine()
+                self.js_console = JSConsole()
+                self.dom_bridge = DOMBridge(self)
+                glob = self.js_engine.globalObject()
+                glob.setProperty("console", self.js_engine.newQObject(self.js_console))
+                glob.setProperty("__dom", self.js_engine.newQObject(self.dom_bridge))
+                bootstrap = r'''
+                  var __purremiumCallbackCounter = 1;
+                  var __purremiumCallbacks = {};
+                  function makeElement(handle, tag){
+                    var styleObject={
+                      setProperty:function(p,v){__dom.setStyle(handle,String(p),String(v));},
+                      getPropertyValue:function(p){return __dom.getStyle(handle,String(p));},
+                      removeProperty:function(p){var old=__dom.getStyle(handle,String(p));__dom.setStyle(handle,String(p),'');return old;},
+                      get cssText(){return __dom.getAttribute(handle,'style');},
+                      set cssText(v){__dom.setAttribute(handle,'style',String(v));}
+                    };
+                    ['color','background','backgroundColor','backgroundImage','fontSize','fontFamily','fontWeight','fontStyle','textDecoration','display','width','height','margin','padding','border','borderRadius','textAlign','lineHeight','float','gap','flexDirection','alignItems','justifyContent','overflow'].forEach(function(k){
+                      var cssName=k.replace(/[A-Z]/g,function(c){return '-'+c.toLowerCase();});
+                      Object.defineProperty(styleObject,k,{get:function(){return __dom.getStyle(handle,cssName);},set:function(v){__dom.setStyle(handle,cssName,String(v));},enumerable:true});
+                    });
+                    var wrapper = {__handle:handle, style:styleObject,
+                    setAttribute:function(n,v){__dom.setAttribute(handle,String(n),String(v));},
+                    getAttribute:function(n){return __dom.getAttribute(handle,String(n));},
+                    hasAttribute:function(n){return __dom.getAttribute(handle,String(n))!=='';},
+                    toggleAttribute:function(n,force){n=String(n);var has=this.hasAttribute(n);if(force===true||(!has&&force!==false)){__dom.setAttribute(handle,n,'');return true;}if(has)__dom.removeAttribute(handle,n);return false;},
+                    removeAttribute:function(n){__dom.removeAttribute(handle,String(n));},
+                    get tagName(){return __dom.getTagName(handle);},
+                    get id(){return __dom.getAttribute(handle,'id');},
+                    set id(v){__dom.setAttribute(handle,'id',String(v));},
+                    get className(){return __dom.getAttribute(handle,'class');},
+                    set className(v){__dom.setAttribute(handle,'class',String(v));},
+                    get classList(){
+                      var el=this;
+                      return {contains:function(c){return el.className.split(/\s+/).indexOf(String(c))>=0;},
+                        add:function(){var a=el.className.split(/\s+/).filter(Boolean);for(var i=0;i<arguments.length;i++)if(a.indexOf(String(arguments[i]))<0)a.push(String(arguments[i]));el.className=a.join(' ');},
+                        remove:function(){var a=el.className.split(/\s+/).filter(Boolean);for(var i=0;i<arguments.length;i++)a=a.filter(function(x){return x!==String(arguments[i]);});el.className=a.join(' ');},
+                        toggle:function(c,force){c=String(c);var has=this.contains(c);if(force===true||(!has&&force!==false)){this.add(c);return true;}if(has)this.remove(c);return false;},
+                        toString:function(){return el.className;}};
+                    },
+                    get value(){return __dom.getInputValue(handle);},
+                    set value(v){__dom.setInputValue(handle,String(v));},
+                    addEventListener:function(type,fn){
+                      if(typeof fn!=='function') return;
+                      var id='cb'+(__purremiumCallbackCounter++);
+                      __purremiumCallbacks[id]=fn;
+                      __dom.addEventListener(handle,String(type),id);
+                    },
+                    appendChild:function(child){if(child&&child.__handle)__dom.appendChild(handle,child.__handle);return child;},
+                    removeChild:function(child){if(child&&child.__handle)__dom.removeChild(handle,child.__handle);return child;},
+                    insertBefore:function(child,ref){if(child&&child.__handle)__dom.insertBefore(handle,child.__handle,ref&&ref.__handle?ref.__handle:'');return child;},
+                    remove:function(){var ph=__dom.getParentHandle(handle);if(ph)__dom.removeChild(ph,handle);},
+                    contains:function(other){var cur=other;while(cur){if(cur.__handle===handle)return true;var ph=__dom.getParentHandle(cur.__handle);cur=ph?makeElement(ph,__dom.getTagName(ph)):null;}return false;},
+                    get parentElement(){var h=__dom.getParentHandle(handle);return h?makeElement(h,__dom.getTagName(h)):null;},
+                    get children(){return simpleNodeList(JSON.parse(__dom.getChildrenHandles(handle)));},
+                    get childNodes(){return simpleNodeList(JSON.parse(__dom.getChildNodeHandles(handle)));},
+                    get firstElementChild(){var a=this.children;return a.length?a[0]:null;},
+                    get lastElementChild(){var a=this.children;return a.length?a[a.length-1]:null;},
+                    get childElementCount(){return this.children.length;},
+                    get innerText(){return __dom.getTextContent(handle);},
+                    set innerText(v){__dom.setTextContent(handle,String(v));},
+                    set textContent(v){__dom.setTextContent(handle,String(v));},
+                    get textContent(){return __dom.getTextContent(handle);},
+                    set innerHTML(v){__dom.setInnerHTML(handle,String(v));},
+                    get innerHTML(){return __dom.getInnerHTML(handle);}
+                    };
+                    return wrapper;
+                  }
+                  function wrapHandle(h){return h?makeElement(h,__dom.getTagName(h)):null;}
+                  function simpleNodeList(handles){
+                    var list=handles.map(wrapHandle);
+                    list.item=function(i){return list[i]||null;};
+                    return list;
+                  }
+                  var document={
+                    getElementById:function(id){return wrapHandle(__dom.findHandle(String(id)));},
+                    querySelector:function(selector){return wrapHandle(__dom.querySelector(String(selector)));},
+                    querySelectorAll:function(selector){return simpleNodeList(JSON.parse(__dom.querySelectorAll(String(selector))));},
+                    getElementsByTagName:function(tag){return document.querySelectorAll(String(tag));},
+                    getElementsByClassName:function(cls){return document.querySelectorAll('.'+String(cls).trim().split(/\s+/).join('.'));},
+                    getElementsByName:function(name){return document.querySelectorAll('[name="'+String(name).replace(/"/g,'\\"')+'"]');},
+                    createElement:function(tag){var h=__dom.createElement(String(tag),'');return h?makeElement(h,tag):null;},
+                    createTextNode:function(text){var h=__dom.createTextNode(String(text));return h?makeElement(h,'#text'):null;},
+                    body:null,
+                    write:function(text){console.log('document.write is not implemented.');}
+                  };
+                  function setTimeout(fn,delay){
+                    var id='cb'+(__purremiumCallbackCounter++);
+                    if(typeof fn==='function')__purremiumCallbacks[id]=fn;
+                    __dom.setTimeout(id,typeof fn==='string'?fn:'',Number(delay)||0);return id;
+                  }
+                  function __runCallback(id){
+                    var fn=__purremiumCallbacks[id];
+                    if(typeof fn!=='function'){console.error('Callback not found: '+id);return false;}
+                    try{fn();return true;}catch(e){console.error('Callback error: '+String(e));return false;}
+                  }
+                  function fetch(url){
+                    return new Promise(function(resolve,reject){
+                      var id=__dom.startFetch(String(url));
+                      if(id<0){reject(new Error('Only http and https supported'));return;}
+                      var poll=function(){
+                        if(__dom.hasFetchResult(id)){
+                          var result=JSON.parse(__dom.takeFetchResult(id));
+                          if(!result.ok){reject(new Error(result.error||'Fetch failed'));return;}
+                          resolve({ok:true,status:200,text:function(){return Promise.resolve(result.text);},json:function(){try{return Promise.resolve(JSON.parse(result.text));}catch(e){return Promise.reject(e);}}});
+                        }else{setTimeout(poll,25);}
+                      };poll();
+                    });
+                  }
+                  function alert(msg){console.log(String(msg));}
+                  this.document=document;this.setTimeout=setTimeout;this.fetch=fetch;this.alert=alert;
+                  this.__runCallback=__runCallback;
+                '''
+                self.js_engine.evaluate(bootstrap)
+            except Exception as exc:
+                print("JS initialization error:", exc)
+                self.js_engine = None
+
+    def register_node(self, node):
+        key = id(node)
+        if key not in self._node_handles:
+            handle = "node" + str(self._next_handle)
+            self._next_handle += 1
+            self._node_handles[key] = handle
+            self._handle_nodes[handle] = node
+        return self._node_handles[key]
+
+    def resolve_node(self, handle):
+        if not handle: return None
+        if handle in self._handle_nodes: return self._handle_nodes[handle]
+        return self.find_by_id(self.root, handle)
+
+    def find(self, n, tag):
+        if n.tag == tag: return n
+        for c in n.children:
+            found = self.find(c, tag)
+            if found: return found
+        return None
+
+    def find_by_id(self, n, elem_id):
+        if n.attrs.get("id") == elem_id: return n
+        for c in n.children:
+            found = self.find_by_id(c, elem_id)
+            if found: return found
+        return None
+
+    def query_selector_all(self, selector):
+        selector = (selector or "").strip()
+        if not selector or len(selector) > 300: return []
+        groups = [p.strip() for p in selector.split(",") if p.strip()]
+        if not groups: return []
+        found = []
+        def walk(node):
+            for child in node.children:
+                if child.tag != "#text" and any(matches(child, g) for g in groups):
+                    found.append(child)
+                walk(child)
+        walk(self.root)
+        return found
+
+    def query_selector(self, selector):
+        found = self.query_selector_all(selector)
+        return found[0] if found else None
+
+    def recalculate_styles(self):
+        css = []
+        def gather(n):
+            if n.tag == "style": css.append(n.text_content())
+            for ch in n.children: gather(ch)
+        gather(self.root)
+        rules = css_rules("\n".join(getattr(self, "external_css", []) + getattr(self, "inline_css", []) + css))
+        new_styles = {}
+        inherited = {"color", "font-family", "font-size", "font-weight", "font-style", "line-height", "text-align", "visibility", "white-space"}
+        def specificity(selector):
+            ids = len(re.findall(r"#[\w-]+", selector))
+            classes = len(re.findall(r"\.[\w-]+|\[[^\]]+\]|:(?!:)[\w-]+", selector))
+            tags = len(re.findall(r"(?:^|[ >+~])(?:[a-zA-Z][\w-]*)", selector))
+            return (ids, classes, tags)
+        ordered = sorted(enumerate(rules), key=lambda pair: (specificity(pair[1][0]), pair[0]))
+        def walk(n, parent_style=None):
+            if n.tag == "#text": return
+            st = {}
+            if parent_style:
+                st.update({k: v for k, v in parent_style.items() if k in inherited})
+            st.update(DEFAULT.get(n.tag, {}))
+            for _, (selector, declarations) in ordered:
+                if matches(n, selector): st.update(declarations)
+            st.update(decl(n.attrs.get("style", "")))
+            if n.attrs.get("hidden") is not None: st["display"] = "none"
+            new_styles[id(n)] = st
+            for ch in n.children: walk(ch, st)
+        walk(self.root)
+        self.styles = new_styles
+
+    def load_html(self, html, base=None, current_url=""):
+        self.current_url = current_url
+        self.setMinimumHeight(450)
+        parser = Parser()
+        try:
+            parser.feed(html)
+            parser.close()
+        except Exception as exc:
+            print("HTML parse warning:", exc)
+        self.root = parser.root
+        self.external_css = []
+        self.inline_css = list(parser.css[:20])
+        self.base = Path(base) if base else Path.cwd()
+        self._node_handles = {}
+        self._handle_nodes = {}
+        self._next_handle = 1
+        self.title = "CatEngine"
+        title_node = self.find(self.root, "title")
+        if title_node and title_node.text_content().strip():
+            self.title = title_node.text_content().strip()
+        self.recalculate_styles()
+        if self.js_engine:
+            self.js_engine.evaluate("__purremiumCallbacks = {}; __purremiumCallbackCounter = 1;")
+        if self.js_engine and parser.scripts:
+            body_handle = self.register_node(self.find(self.root, 'body') or self.root)
+            self.js_engine.evaluate("document.body = (function(){var h=" + json.dumps(body_handle) + ";return makeElement(h,__dom.getTagName(h));})();")
+            for script in parser.scripts:
+                if script.strip():
+                    try: self.js_engine.evaluate(script)
+                    except Exception as exc: print("JS error:", exc)
+        self.update()
+
+    def load_file(self, filename):
+        try:
+            path = Path(filename)
+            self.load_html(path.read_text(encoding="utf-8", errors="replace"), path.resolve().parent, str(path.resolve()))
+        except OSError as exc:
+            self.load_html(f"<h1>Could not open file</h1><p>{exc}</p>")
+
+    def st(self, n):
+        d = dict(DEFAULT.get(n.tag, {}))
+        d.update(self.styles.get(id(n), {}))
+        return d
+
+    def font(self, n, inh):
+        s = self.st(n)
+        old = inh.get("font", QFont("Segoe UI", 16))
+        f = QFont(s.get("font-family", inh.get("family", "Segoe UI")), int(max(8, min(72, px(s.get("font-size"), old.pointSize())))))
+        if s.get("font-weight", "").lower() in ("bold", "700", "800", "900") or n.tag in ("h1", "h2", "h3", "h4", "h5", "h6", "b", "strong", "th"): f.setBold(True)
+        if n.tag in ("i", "em"): f.setItalic(True)
+        if n.tag in ("u", "a") or "underline" in s.get("text-decoration", ""): f.setUnderline(True)
+        return f, color(s.get("color", inh.get("color", "#202124"))), s.get("font-family", inh.get("family", "Segoe UI")), s
+
+    def paintEvent(self, event):
+        p = QPainter(self)
+        p.setRenderHint(QPainter.RenderHint.TextAntialiasing)
+        p.fillRect(self.rect(), QColor("white"))
+        self.hit = []
+        self.floats = []
+        body = self.find(self.root, "body") or self.root
+        st = self.st(body)
+        p.fillRect(self.rect(), color(st.get("background", st.get("background-color", "white")), "white"))
+        margins = box(st.get("margin", "16px"), 16)
+        content_bottom = self.blocks(
+            p, body, margins[3], margins[0],
+            max(100, self.width() - margins[1] - margins[3]),
+            {"font": QFont("Segoe UI", 16), "color": QColor("#202124"), "family": "Segoe UI"}
+        )
+        p.end()
+        required_height = max(450, int(content_bottom + margins[2] + 24))
+        if self.minimumHeight() != required_height:
+            self.setMinimumHeight(required_height)
+
+    def edges(self, y, x, w):
+        left, right = x, x + w
+        for fx, fy, fw, fh, side in self.floats:
+            if fy <= y < fy + fh:
+                if side == "left": left = max(left, fx + fw + 8)
+                else: right = min(right, fx - 8)
+        return (left, right) if right - left > 35 else (x, x + w)
+
+    def blocks(self, p, parent, x, y, w, inh):
+        runs = []
+        def flush():
+            nonlocal y
+            if runs: y = self.inline(p, runs, x, y, w, inh); runs.clear()
+        for n in parent.children:
+            if n.tag == "#text": runs.append((n.text, parent, inh)); continue
+            if n.tag in SKIP: continue
+            if n.tag == "br": runs.append(("\n", n, inh)); continue
+            s = self.st(n)
+            display = s.get("display", "").lower()
+            block_display = display in ("block", "flex", "grid", "flow-root", "list-item", "table", "table-row", "table-cell")
+            inline_display = display in ("inline", "inline-block", "inline-flex", "inline-grid")
+            is_block =

catengine-0.5.7/src/catengine.egg-info/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: catengine
+Version: 0.5.7
+Summary: A lightweight PySide6 HTML/CSS browser rendering engine widget.
+Author-email: PurrEmium Team <your-email@example.com>
+Project-URL: Homepage, https://github.com/yourusername/catengine
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: User Interfaces
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: PySide6>=6.0.0
+Dynamic: license-file
+
+# CatEngine 🐱
+
+A lightweight, custom PySide6 HTML/CSS rendering engine widget built on `QPainter` and `QJSEngine`.
+
+## Installation
+
+```bash
+pip install catengine

catengine-0.5.7/src/catengine.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE.txt
+README.md
+pyproject.toml
+src/catengine/__init__.py
+src/catengine/catengine.py
+src/catengine.egg-info/PKG-INFO
+src/catengine.egg-info/SOURCES.txt
+src/catengine.egg-info/dependency_links.txt
+src/catengine.egg-info/requires.txt
+src/catengine.egg-info/top_level.txt

catengine-0.5.7/src/catengine.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

catengine-0.5.7/src/catengine.egg-info/requires.txt

@@ -0,0 +1 @@
+PySide6>=6.0.0

catengine-0.5.7/src/catengine.egg-info/top_level.txt

@@ -0,0 +1 @@
+catengine