kigo-gui-framework 3.0__tar.gz → 3.2__tar.gz

kigo_gui_framework-3.2/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: kigo-gui-framework
+Version: 3.2
+Summary: Kigo has Time Freeze Debugging and a Visual Inspector now.
+Author: Anand Kumar
+License: Zlib
+Keywords: gui,qt,pyqt,webengine,opengl,wasm,android,chromeos,framework
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: License :: OSI Approved :: zlib/libpng License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS :: MacOS X
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: PyQt6
+Requires-Dist: pybullet
+Requires-Dist: pybullet-data
+Requires-Dist: PyQt6-WebEngine
+Requires-Dist: PyOpenGL
+Requires-Dist: wasmtime
+
+Kigo now has support for networking and
+SunOS
+Solaris
+FreeBSD
+Android
+Linux
+Mac 
+Windous
+ChromeOS
+Kigo also has two CLI commands:
+kigo run
+kigo doctor.
+CLASS 5 IS TOUGH. VERY TOUGH. but you will get updates

kigo_gui_framework-3.2/README.md

@@ -0,0 +1,13 @@
+Kigo now has support for networking and
+SunOS
+Solaris
+FreeBSD
+Android
+Linux
+Mac 
+Windous
+ChromeOS
+Kigo also has two CLI commands:
+kigo run
+kigo doctor.
+CLASS 5 IS TOUGH. VERY TOUGH. but you will get updates

kigo_gui_framework-3.2/README.txt

@@ -0,0 +1,2 @@
+Kigo now has time freeze debugging and a scene inspector using my Neolog
+engine (well, it is based off of Qt's things, but who cares, neolog is a good name)

kigo_gui_framework-3.2/kigo/android/__init__.py

@@ -0,0 +1,10 @@
+from .platform import is_android
+from .lifecycle import AndroidLifecycle
+from .info import device_info
+
+__all__ = [
+    "is_android",
+      "AndroidLifecycle",
+    "device_info",
+]
+   

kigo_gui_framework-3.2/kigo/android/info.py

@@ -0,0 +1,11 @@
+# kigo/android/info.py
+from kigo.android.platform import is_android, android_api_level
+
+def device_info():
+    if not is_android():
+        return None
+
+    return {
+        "api_level": android_api_level(),
+        "platform": "android",
+    }

kigo_gui_framework-3.2/kigo/android/lifecycle.py

@@ -0,0 +1,20 @@
+from kigo.qt.backend import QtCore
+
+# Alias Signal correctly for PyQt6 and PySide6
+Signal = getattr(QtCore, "Signal", QtCore.pyqtSignal)
+
+
+class AndroidLifecycle(QtCore.QObject):
+    paused = Signal()
+    resumed = Signal()
+
+    def __init__(self, app):
+        super().__init__()
+        self.app = app
+        app.applicationStateChanged.connect(self._on_state)
+
+    def _on_state(self, state):
+        if state == QtCore.Qt.ApplicationState.ApplicationSuspended:
+            self.paused.emit()
+        elif state == QtCore.Qt.ApplicationState.ApplicationActive:
+            self.resumed.emit()

kigo_gui_framework-3.2/kigo/android/ossupport.py

@@ -0,0 +1,181 @@
+# SPDX-License-Identifier: Zlib
+# kigo/platform_info.py
+
+import sys
+import os
+import platform as _platform
+
+
+# -------------------------------------------------
+# Mobile platforms
+# -------------------------------------------------
+
+def is_android() -> bool:
+    """True if running on Android (ARC++ or native)."""
+    return hasattr(sys, "getandroidapilevel")
+
+
+def android_api_level():
+    """Return Android API level or None."""
+    if hasattr(sys, "getandroidapilevel"):
+        return sys.getandroidapilevel()
+    return None
+
+
+def is_ios() -> bool:
+    """True if running on iOS (future-ready)."""
+    return sys.platform == "ios"
+
+
+# -------------------------------------------------
+# Desktop OS detection
+# -------------------------------------------------
+
+def is_windows() -> bool:
+    return sys.platform.startswith("win")
+
+
+def is_linux() -> bool:
+    return sys.platform.startswith("linux")
+
+
+def is_macos() -> bool:
+    return sys.platform == "darwin"
+
+
+def is_freebsd() -> bool:
+    return sys.platform.startswith("freebsd")
+
+
+def is_openbsd() -> bool:
+    return sys.platform.startswith("openbsd")
+
+
+def is_sunos() -> bool:
+    # Solaris reports as "sunos"
+    return sys.platform == "sunos"
+
+
+# -------------------------------------------------
+# ChromeOS detection (Crostini / ARC++)
+# -------------------------------------------------
+
+def is_chromeos() -> bool:
+    """
+    Detect ChromeOS.
+    Covers:
+    - Linux (Crostini)
+    - Android Runtime (ARC++)
+    """
+    # Crostini exposes this env var
+    if "SOMMELIER_VERSION" in os.environ:
+        return True
+
+    # Fallback: os-release check
+    try:
+        with open("/etc/os-release", "r", encoding="utf-8") as f:
+            data = f.read().lower()
+            if "chromeos" in data or "chromiumos" in data:
+                return True
+    except Exception:
+        pass
+
+    return False
+
+
+# -------------------------------------------------
+# Platform groups
+# -------------------------------------------------
+
+def is_mobile() -> bool:
+    return is_android() or is_ios()
+
+
+def is_desktop() -> bool:
+    return not is_mobile()
+
+
+def is_bsd() -> bool:
+    return is_freebsd() or is_openbsd()
+
+
+def is_unix_desktop() -> bool:
+    return (
+        is_linux()
+        or is_macos()
+        or is_bsd()
+        or is_sunos()
+        or is_chromeos()
+    )
+
+
+# -------------------------------------------------
+# Window system detection (X11 / Wayland)
+# -------------------------------------------------
+
+def window_system() -> str:
+    """
+    Returns:
+        'wayland', 'x11', or 'unknown'
+    """
+    if os.environ.get("WAYLAND_DISPLAY"):
+        return "wayland"
+    if os.environ.get("DISPLAY"):
+        return "x11"
+    return "unknown"
+
+
+# -------------------------------------------------
+# Qt backend decision
+# -------------------------------------------------
+
+def qt_backend() -> str:
+    """
+    Android → PySide6
+    Everything else → PyQt6
+    """
+    if is_android():
+        return "pyside"
+    return "pyqt"
+
+
+# -------------------------------------------------
+# Human-readable platform name
+# -------------------------------------------------
+
+def platform_name() -> str:
+    if is_android():
+        return "android"
+    if is_chromeos():
+        return "chromeos"
+    if is_ios():
+        return "ios"
+    if is_windows():
+        return "windows"
+    if is_macos():
+        return "macos"
+    if is_linux():
+        return "linux"
+    if is_freebsd():
+        return "freebsd"
+    if is_openbsd():
+        return "openbsd"
+    if is_sunos():
+        return "sunos/solaris"
+    return _platform.system().lower()
+
+
+# -------------------------------------------------
+# Debug / dev helper
+# -------------------------------------------------
+
+def summary() -> dict:
+    return {
+        "platform": platform_name(),
+        "chromeos": is_chromeos(),
+        "mobile": is_mobile(),
+        "desktop": is_desktop(),
+        "window_system": window_system(),
+        "qt_backend": qt_backend(),
+        "android_api": android_api_level(),
+    }

kigo_gui_framework-3.2/kigo/cli/__init__.py

@@ -0,0 +1 @@
+__all__=[]

kigo_gui_framework-3.2/kigo/cli/doctor.py

@@ -0,0 +1,90 @@
+# SPDX-License-Identifier: Zlib
+# kigo/cli/doctor.py
+
+import sys
+import os
+import importlib.util
+
+
+def ok(msg): print(f"✅ {msg}")
+def warn(msg): print(f"⚠️  {msg}")
+def err(msg): print(f"❌ {msg}")
+
+
+def run_doctor():
+    print("Kigo Doctor running…\n")
+
+    checks = [
+        check_python,
+        check_app_file,
+        check_kigo_import,
+        check_qt_backend,
+        check_platform_file,
+    ]
+
+    failed = False
+    for check in checks:
+        try:
+            result = check()
+            if result is False:
+                failed = True
+        except Exception as e:
+            err(f"{check.__name__} crashed: {e}")
+            failed = True
+
+    print()
+    if failed:
+        err("Problems detected. Fix the issues above.")
+        sys.exit(1)
+    else:
+        ok("No critical issues found. You’re good to go 🚀")
+
+
+# -------------------------
+# Individual checks
+# -------------------------
+
+def check_python():
+    if sys.version_info < (3, 9):
+        err("Python 3.9+ is required")
+        return False
+    ok(f"Python {sys.version.split()[0]}")
+    return True
+
+
+def check_app_file():
+    if not os.path.exists("app.py"):
+        err("app.py not found")
+        return False
+    ok("app.py found")
+    return True
+
+
+def check_kigo_import():
+    try:
+        import kigo
+        ok("Kigo importable")
+        return True
+    except Exception as e:
+        err(f"Kigo import failed: {e}")
+        return False
+
+
+def check_qt_backend():
+    try:
+        from kigo.qt.backend import QtCore
+        ok("Qt backend OK")
+        return True
+    except Exception as e:
+        err(f"Qt backend failed: {e}")
+        return False
+
+
+def check_platform_file():
+    try:
+        from kigo.platform_info import platform_name
+        ok(f"Platform detected: {platform_name()}")
+        return True
+    except Exception as e:
+        err(f"Platform detection failed: {e}")
+        return False

kigo_gui_framework-3.2/kigo/cli/main.py

@@ -0,0 +1,46 @@
+# SPDX-License-Identifier: Zlib
+# kigo/cli/main.py
+
+import sys
+import argparse
+
+from kigo.cli.doctor import run_doctor
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="kigo",
+        description="Kigo CLI"
+    )
+
+    sub = parser.add_subparsers(dest="command")
+
+    # kigo run
+    sub.add_parser("run", help="Run the Kigo app")
+
+    # kigo doctor
+    sub.add_parser("doctor", help="Diagnose common Kigo issues")
+
+    args = parser.parse_args()
+
+    if args.command == "run":
+        run_app()
+    elif args.command == "doctor":
+        run_doctor()
+    else:
+        parser.print_help()
+
+
+def run_app():
+    """
+    Runs app.py in the current directory.
+    """
+    try:
+        __import__("app")
+    except ModuleNotFoundError:
+        print("❌ No app.py found in current directory. Please rename your file to app.py and try again.")
+        sys.exit(1)
+    except Exception as e:
+        print("❌ Failed to run app:")
+        print(e)
+        sys.exit(1)

kigo_gui_framework-3.2/kigo/debug/__init__.py

@@ -0,0 +1,3 @@
+from .freeze import freeze
+
+__all__ = ["freeze"]

kigo_gui_framework-3.2/kigo/debug/freeze.py

@@ -0,0 +1,54 @@
+# SPDX-License-Identifier: Zlib
+# kigo/debug/freeze.py
+
+from kigo.qt.backend import QtCore, QtWidgets
+
+
+def freeze(reason: str = "Execution paused", *, data: dict | None = None):
+    """
+    Freeze execution while keeping the Qt event loop alive.
+    Used for visual + state debugging.
+
+    This does NOT crash or block Qt internally.
+    """
+
+    # Dialog shown during freeze
+    dialog = QtWidgets.QDialog()
+    dialog.setWindowTitle("Kigo Time Freeze")
+    dialog.setModal(False)
+    dialog.setWindowFlags(
+        QtCore.Qt.WindowType.WindowStaysOnTopHint
+        | QtCore.Qt.WindowType.Dialog
+    )
+
+    layout = QtWidgets.QVBoxLayout(dialog)
+
+    label = QtWidgets.QLabel(f"🧊 {reason}")
+    label.setStyleSheet("font-weight: bold; font-size: 14px;")
+    layout.addWidget(label)
+
+    if data:
+        text = QtWidgets.QPlainTextEdit()
+        text.setReadOnly(True)
+        pretty = "\n".join(f"{k}: {v}" for k, v in data.items())
+        text.setPlainText(pretty)
+        layout.addWidget(text)
+
+    btn = QtWidgets.QPushButton("Resume")
+    layout.addWidget(btn)
+
+    # Local event loop = time freeze
+    loop = QtCore.QEventLoop()
+
+    btn.clicked.connect(loop.quit)
+    dialog.finished.connect(loop.quit)
+
+    dialog.show()
+
+    # Process paint events before freezing
+    QtWidgets.QApplication.processEvents()
+
+    #  TIME FREEZE STARTS HERE
+    loop.exec()
+
+    dialog.close()

kigo_gui_framework-3.2/kigo/ecs/__init__.py

@@ -0,0 +1,6 @@
+from .world import World
+from .entity import EntityId
+from .component import Component
+from .system import System
+
+__all__ = ["World", "EntityId", "Component", "System"]

kigo_gui_framework-3.2/kigo/ecs/component.py

@@ -0,0 +1,5 @@
+class Component:
+    """
+    Base class for components (data-only).
+    """
+    pass

kigo_gui_framework-3.2/kigo/ecs/entity.py

@@ -0,0 +1 @@
+EntityId=int

kigo_gui_framework-3.2/kigo/ecs/render.py

@@ -0,0 +1,38 @@
+# kigo/ecs/render.py
+from kigo.ecs.system import System
+from kigo.ecs.world import World
+from kigo.qt.backend import QtGui
+from .render import Transform, Renderable
+
+
+class RenderSystem(System):
+    """
+    Pulls render data from ECS and issues draw calls.
+    """
+
+    def __init__(self, painter: QtGui.QPainter):
+        self.painter = painter
+
+    def update(self, world: World, dt: float):
+        entities = world.get_entities_with(Transform, Renderable)
+
+        for e in entities:
+            transform = world.get_component(e, Transform)
+            renderable = world.get_component(e, Renderable)
+
+            self._draw(transform, renderable)
+
+    def _draw(self, t: Transform, r: Renderable):
+        self.painter.save()
+        self.painter.translate(t.x, t.y)
+        self.painter.rotate(t.rotation)
+        self.painter.scale(t.scale, t.scale)
+
+        if r.kind == "rect":
+            self.painter.drawRect(0, 0, 50, 50)
+
+        elif r.kind == "image" and r.resource:
+            pix = QtGui.QPixmap(r.resource)
+            self.painter.drawPixmap(0, 0, pix)
+
+        self.painter.restore()

kigo_gui_framework-3.2/kigo/ecs/system.py

@@ -0,0 +1,10 @@
+class System:
+    """
+    Base class for systems.
+    """
+
+    def update(self, world, dt: float):
+        """
+        Override in subclasses.
+        """
+        pass

kigo_gui_framework-3.2/kigo/ecs/world.py

@@ -0,0 +1,59 @@
+from collections import defaultdict
+from typing import Dict, Type, Set
+
+from .entity import EntityId
+from .component import Component
+from .system import System
+
+
+class World:
+    def __init__(self):
+        self._next_entity: EntityId = 1
+        self._components: Dict[Type[Component], Dict[EntityId, Component]] = defaultdict(dict)
+        self._systems: list[System] = []
+
+    # ----------------------------
+    # Entity
+    # ----------------------------
+    def create_entity(self) -> EntityId:
+        eid = self._next_entity
+        self._next_entity += 1
+        return eid
+
+    def remove_entity(self, entity: EntityId):
+        for comp_map in self._components.values():
+            comp_map.pop(entity, None)
+
+    # ----------------------------
+    # Components
+    # ----------------------------
+    def add_component(self, entity: EntityId, component: Component):
+        self._components[type(component)][entity] = component
+
+    def remove_component(self, entity: EntityId, component_type: Type[Component]):
+        self._components[component_type].pop(entity, None)
+
+    def get_component(self, entity: EntityId, component_type: Type[Component]):
+        return self._components[component_type].get(entity)
+
+    def get_entities_with(self, *component_types: Type[Component]) -> Set[EntityId]:
+        if not component_types:
+            return set()
+
+        entity_sets = [
+            set(self._components[ct].keys())
+            for ct in component_types
+            if ct in self._components
+        ]
+
+        return set.intersection(*entity_sets) if entity_sets else set()
+
+    # ----------------------------
+    # Systems
+    # ----------------------------
+    def add_system(self, system: System):
+        self._systems.append(system)
+
+    def update(self, dt: float):
+        for system in self._systems:
+            system.update(self, dt)

kigo_gui_framework-3.2/kigo/inspector/__init__.py

@@ -0,0 +1,3 @@
+from .inspector import enable_inspector
+
+__all__ = ["enable_inspector"]

kigo_gui_framework-3.2/kigo/inspector/inspector.py

@@ -0,0 +1,50 @@
+# SPDX-License-Identifier: Zlib
+# kigo/inspector/inspector.py
+
+from kigo.qt.backend import QtCore, QtWidgets
+from kigo.inspector.overlay import Overlay
+from kigo.inspector.panel import InspectorPanel
+
+
+class Inspector(QtCore.QObject):
+    def __init__(self, app: QtWidgets.QApplication):
+        super().__init__()
+        self.app = app
+        self.overlay = Overlay()
+        self.panel = InspectorPanel()
+
+        self.app.installEventFilter(self)
+
+    def attach(self):
+        for w in self.app.topLevelWidgets():
+            if isinstance(w, QtWidgets.QMainWindow):
+                w.addDockWidget(
+                    QtCore.Qt.DockWidgetArea.RightDockWidgetArea,
+                    self.panel,
+                )
+                self.overlay.setParent(w)
+                self.overlay.resize(w.size())
+
+    def eventFilter(self, obj, event):
+        if isinstance(event, QtCore.QEvent):
+            if event.type() == QtCore.QEvent.Type.MouseMove:
+                widget = self.app.widgetAt(event.globalPosition().toPoint())
+                if widget:
+                    rect = widget.rect()
+                    top_left = widget.mapToGlobal(rect.topLeft())
+                    self.overlay.highlight(
+                        QtCore.QRect(top_left, rect.size())
+                    )
+
+            elif event.type() == QtCore.QEvent.Type.MouseButtonPress:
+                widget = self.app.widgetAt(event.globalPosition().toPoint())
+                self.panel.inspect(widget)
+                return True
+
+        return False
+
+
+def enable_inspector(app: QtWidgets.QApplication):
+    inspector = Inspector(app)
+    inspector.attach()
+    return inspector