blinkview 0.18.1__py3-none-any.whl

blinkview/__init__.py

@@ -0,0 +1,27 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+# Copyright (c) 2026 Roland Uuesoo
+
+import os
+from pathlib import Path
+
+__version__ = "0.18.1"
+__author__ = "Roland Uuesoo"
+
+__app_name__ = "BlinkView"
+__org_domain__ = "ee.incubator"
+
+# Your specific ID requirement
+__app_id__ = f"{__org_domain__}.{__app_name__.lower()}"
+
+
+# Robust icon path (relative to this file)
+ICON_PATH = (Path(__file__).parent / "assets" / "icon.png").absolute()
+
+
+# These must come BEFORE numpy, scipy, or any telemetry logic
+os.environ.setdefault("OPENBLAS_NUM_THREADS", "1")
+os.environ.setdefault("MKL_NUM_THREADS", "1")
+os.environ.setdefault("OMP_NUM_THREADS", "1")

blinkview/__main__.py

@@ -0,0 +1,205 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+# Copyright (c) 2026 Roland Uuesoo
+
+import faulthandler
+import sys
+from argparse import ArgumentParser
+
+from blinkview.ui.cli_args import setup_gui_parser, setup_replay_parser
+
+
+def run_init(args):
+    from blinkview.utils.project_settings import ProjectSettings
+
+    ProjectSettings.init(args.path)
+
+
+def run_gui(args):
+    from .gui import main
+
+    main(args)
+
+
+def run_cli(args):
+    from .cli import main
+
+    main()
+
+
+def run_daemon(args):
+    print(f"🔌 Starting Daemon on port: {args.port}")
+
+
+def apply_session_profile(args, session_info):
+    """Replays with the profile the session was recorded with (metadata.json config.profile)
+    unless --profile/--config was given explicitly. Only if that profile still exists in this
+    workspace - FileManager creates a missing profile dir on the fly, so a renamed/deleted
+    profile would otherwise silently open as a brand-new empty one."""
+    if args.profile is not None or args.config is not None or not session_info.profile:
+        return
+
+    from blinkview.utils.project_settings import get_workspace_dir
+
+    if (get_workspace_dir() / "profiles" / session_info.profile).is_dir():
+        args.profile = session_info.profile
+        print(f"Using session's profile '{session_info.profile}'.")
+    else:
+        print(f"Session's profile '{session_info.profile}' not found in this workspace - using the active profile.")
+
+
+def run_replay(args):
+    # utils/session_lister.py deliberately avoids importing anything from blinkview.storage/
+    # blinkview.parsers (the numba/id_registry cluster, ~600 modules) so --list stays fast.
+    from blinkview.utils.session_lister import list_sessions, resolve_log_root, resolve_session, unified_log_parts
+
+    log_dir, project_name = resolve_log_root(log_dir=args.logdir)
+
+    if args.list:
+        sessions = [s for s in list_sessions(log_dir, project_name) if unified_log_parts(s)]
+        if not sessions:
+            print(f"No replay sessions found for project '{project_name}' in {log_dir}.")
+            return
+        for s in sessions:
+            print(f"{s.session_id}  [{s.status}]  {s.display_name} (profile={s.profile}, created={s.created_at})")
+        return
+
+    session_info = resolve_session(log_dir, project_name, name=args.name, last=args.last)
+    if session_info is None:
+        print(f"No matching replay session found (name={args.name!r}, last={args.last}).")
+        sys.exit(1)
+
+    parts = unified_log_parts(session_info)
+    if not parts:
+        print(f"Session '{session_info.session_id}' has no unified log to replay.")
+        sys.exit(1)
+
+    apply_session_profile(args, session_info)
+
+    from blinkview.ui.run import run as run_gui
+
+    run_gui(args, replay_mode=True, replay_session_info=session_info)
+
+
+# --- Parser Setup ---
+def enable_fault_handler():
+    """Native crashes (Qt, numba, mmap) kill the process without a Python exception; with this enabled a fatal
+    signal prints every thread's Python stack (and the C stack of the faulting one) to stderr.
+
+    Best effort: faulthandler needs a real file descriptor on sys.stderr, which does not exist when stderr is
+    captured (tests) or missing (a GUI process started without a console)."""
+    try:
+        faulthandler.enable(all_threads=True)
+    except (RuntimeError, OSError, ValueError, AttributeError):  # io.UnsupportedOperation is an OSError
+        pass
+
+
+def main():
+    enable_fault_handler()
+
+    parser = ArgumentParser(description="BlinkView Telemetry Suite - 2026")
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    from blinkview import __version__
+
+    parser.add_argument("-v", "--version", action="version", version=f"BlinkView {__version__}")
+
+    # INIT Command
+    init_parser = subparsers.add_parser("init", help="Setup project")
+    init_parser.add_argument(
+        "path", nargs="?", default=".", help="Directory to initialize (default: current directory)"
+    )
+    init_parser.set_defaults(func=run_init)
+
+    # PROFILE Command
+    profile_parser = subparsers.add_parser("switch", help="Switch profiles")
+    from blinkview.utils.project_settings import handle_profile_args, setup_project_parser
+
+    setup_project_parser(profile_parser)
+    profile_parser.set_defaults(func=handle_profile_args)
+
+    # GUI Command
+    gui_parser = subparsers.add_parser("gui", help="Open Interface")
+    setup_gui_parser(gui_parser)
+
+    gui_parser.set_defaults(func=run_gui)
+
+    cli_parser = subparsers.add_parser("cli", help="Command Line Interface")
+    cli_parser.set_defaults(func=run_cli)
+
+    # DAEMON Command
+    daemon_parser = subparsers.add_parser("daemon", help="Background service")
+    daemon_parser.add_argument("--port", type=int, default=8000)
+    daemon_parser.set_defaults(func=run_daemon)
+
+    # REPLAY Command
+    replay_parser = subparsers.add_parser("replay", help="Load a previously recorded session")
+    setup_replay_parser(replay_parser)
+    replay_parser.set_defaults(func=run_replay)
+
+    config_parser = subparsers.add_parser("config", help="Get and set project or global options")
+
+    # Link to the handler
+    from blinkview.utils.config_handler import handle_config, setup_config_parser
+
+    setup_config_parser(config_parser)
+    config_parser.set_defaults(func=handle_config)
+
+    export_parser = subparsers.add_parser("export", prog="blink export", help="Write a recorded session's log out as filtered text")
+    from blinkview.utils.session_export import run_export, setup_export_parser
+
+    setup_export_parser(export_parser)
+    export_parser.set_defaults(func=run_export)
+
+    update_parser = subparsers.add_parser("update", help="Manage BlinkView versions")
+    from blinkview.utils.cli_updater import handle_update, setup_update_parser
+
+    setup_update_parser(update_parser)
+    update_parser.set_defaults(func=handle_update)
+
+    # --- ARGUMENT INJECTION LOGIC ---
+    # This checks if the first arg is a valid command.
+    # If not, it inserts 'gui' as the first argument so argparse handles it.
+    valid_commands = subparsers.choices.keys()
+
+    # sys.argv[0] is the script name. We check sys.argv[1].
+    if len(sys.argv) > 1:
+        # If it's not a command and not -v/--version/--help...
+        if sys.argv[1] not in valid_commands and sys.argv[1] not in ["-h", "--help", "-v", "--version"]:
+            sys.argv.insert(1, "gui")
+    elif len(sys.argv) == 1:
+        # No arguments at all? Default to gui.
+        sys.argv.append("gui")
+
+    args = parser.parse_args()
+
+    if args.command != "config":
+        from blinkview.utils.updater import get_update_notice
+
+        # stderr: a notice, not command output - `blink replay --list > file` (or an export to
+        # stdout) must not start with it.
+        msg = get_update_notice()
+        if msg:
+            print(f"[{msg}]\n", file=sys.stderr)
+
+    try:
+        # --- Execution ---
+        if args.command is None:
+            # Fallback if the user just types 'blinkview'
+            gui_args = gui_parser.parse_args(sys.argv[1:])
+            run_gui(gui_args)
+        else:
+            # This one line replaces the entire 'match' statement!
+            args.func(args)
+    except Exception:
+        # dump formatexc
+        from traceback import print_exc
+
+        print_exc()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

blinkview/cli.py

@@ -0,0 +1,134 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+# Copyright (c) 2026 Roland Uuesoo
+
+import signal
+from queue import Empty, Queue
+from threading import Thread
+
+import readchar
+from rich.console import Console
+
+# Internal BlinkView imports
+from blinkview.core.registry import Registry
+from blinkview.subscribers.console import ConsoleSubscriber  # noqa: F401 - registers "console" with SubscriberFactory
+from blinkview.utils.log_level import LogLevel
+
+
+class BlinkViewApp:
+    def __init__(self):
+        self.console = Console()
+        self.registry = Registry("test")
+        self.console_sub = None
+
+        self.input_queue = Queue()
+        self.running = False
+
+    def init_console(self, level=LogLevel.ALL):
+        """Lazy-loads and configures the console subscriber."""
+        if self.console_sub is None:
+            self.console_sub = self.registry.build_subscriber("CLI", "Console", console=self.console)
+            self.console_sub.start()
+
+        self.console_sub.set_level(level)
+
+    def _signal_handler(self, signum, frame):
+        """Catches OS signals to shut down cleanly."""
+        self.input_queue.put("q")
+
+    def _keyboard_listener(self):
+        """Background thread to catch raw keystrokes."""
+        while self.running:
+            try:
+                key = readchar.readkey().lower()
+                self.input_queue.put(key)
+                if key == "q":
+                    break
+            except KeyboardInterrupt:
+                self.input_queue.put("q")
+                break
+
+    def handle_input(self, key: str):
+        """Routes the parsed keystrokes to the correct actions."""
+        if key == "q":
+            self.console.print("\n[bold yellow]Quit signal received...[/bold yellow]")
+            self.running = False
+
+        elif key in ("i", "a", "d", "e", "w"):
+            # Map keys directly to LogLevels
+            level_map = {
+                "a": LogLevel.ALL,
+                "d": LogLevel.DEBUG,
+                "i": LogLevel.INFO,
+                "w": LogLevel.WARN,
+                "e": LogLevel.ERROR,
+            }
+            if self.console_sub:
+                self.console_sub.set_level(level_map[key])
+
+        elif key == "r":
+            # destroy and recreate registry
+            is_console_enabled = self.console_sub is not None
+            if is_console_enabled:
+                log_level = self.console_sub.log_level
+                self.console_sub.stop()
+            self.registry.stop()
+            self.console_sub = None
+            self.registry = Registry("test")
+            self.registry.start()
+            self.console.print("[bold cyan]Registry restarted.[/bold cyan]")
+            if is_console_enabled:
+                self.init_console(log_level)
+
+        elif key == "s":
+            if self.console_sub is None:
+                self.init_console()
+            else:
+                self.console_sub.streaming = not self.console_sub.streaming
+                state = "resumed" if self.console_sub.streaming else "paused"
+                self.console.print(f"Streaming {state}. Press 's' to toggle.")
+
+    def run(self):
+        """Main application loop."""
+        self.console.print("Starting BlinkView CLI...")
+
+        # Wire up OS signals
+        signal.signal(signal.SIGINT, self._signal_handler)
+        signal.signal(signal.SIGTERM, self._signal_handler)
+
+        self.registry.start()
+        self.init_console(LogLevel.WARN)
+
+        self.console.print('[bold green]BLINK ACTIVE[/bold green] | [dim]Press "s" to pause, "q" to quit[/dim]')
+
+        self.running = True
+        listener_thread = Thread(target=self._keyboard_listener, daemon=True)
+        listener_thread.start()
+
+        try:
+            while self.running:
+                try:
+                    # Timeout is required here to make the UI loop responsive
+                    key = self.input_queue.get(timeout=0.05)
+                    self.handle_input(key)
+                except Empty:
+                    # Do your 20Hz background UI updates here if needed
+                    pass
+
+        finally:
+            self.console.print("Exiting...")
+            if self.console_sub:
+                self.console_sub.stop()
+            self.registry.stop()
+            self.console.print("[grey50]BlinkView session ended.[/grey50]")
+
+
+def main():
+    app = BlinkViewApp()
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

blinkview/core/__init__.py

@@ -0,0 +1,6 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+# Copyright (c) 2026 Roland Uuesoo
+

blinkview/core/array_pool.py

@@ -0,0 +1,175 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+# Copyright (c) 2026 Roland Uuesoo
+
+import threading
+import time
+
+import numpy as np
+
+from blinkview.core import dtypes
+
+
+class PooledArrayHandle:
+    """
+    High-performance slotted handle.
+    Directly holds the raw power-of-two slab.
+    """
+
+    __slots__ = ("_pool", "array", "bucket_key", "_refcount", "_lock")
+
+    def __init__(self, pool, array, bucket_key):
+        self._pool = pool
+        self.array: np.ndarray = array
+        self.bucket_key = bucket_key
+        self._refcount = 1
+        self._lock = threading.Lock()
+
+    def retain(self):
+        with self._lock:
+            if self._refcount == 0:
+                raise RuntimeError("Cannot retain a released array.")
+            self._refcount += 1
+        return self
+
+    def release(self):
+        with self._lock:
+            if self._refcount <= 0:
+                return
+            self._refcount -= 1
+            if self._refcount == 0:
+                # Return the full, un-sliced slab
+                self._pool._put(self.bucket_key, self.array)
+                self.array = None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.release()
+
+    @property
+    def capacity(self) -> int:
+        """Returns the total allocated size of the raw slab."""
+        return a.shape[0] if (a := self.array) is not None else 0
+
+
+class NumpyArrayPool:
+    __slots__ = ("min_bytes", "max_bytes", "lock", "buckets")
+
+    def __init__(self, min_bytes=1024, max_bytes=1024 * 1024):
+        self.min_bytes = min_bytes
+        self.max_bytes = max_bytes
+        self.lock = threading.Lock()
+        self.buckets = {}
+
+    def _calc_slab_size(self, size_in_bytes):
+        """Always returns the next power of two, regardless of pool limits."""
+        # Force conversion to Python int to support .bit_length()
+        size_in_bytes = int(size_in_bytes)
+
+        if size_in_bytes <= self.min_bytes:
+            return self.min_bytes
+        # Round up to next power of 2
+        return 1 << (size_in_bytes - 1).bit_length()
+
+    def acquire(self, element_count, dtype=dtypes.BYTE):
+        """
+        Acquires an array capable of holding at least `element_count` items.
+        """
+        dt = np.dtype(dtype)
+        # Calculate the required bytes internally
+        size_in_bytes = int(element_count) * dt.itemsize
+
+        slab_size = self._calc_slab_size(size_in_bytes)
+        bucket_key = (slab_size, dt)
+
+        base_arr = None
+
+        # Try to fetch from pool if within limits
+        if self.min_bytes <= slab_size <= self.max_bytes:
+            with self.lock:
+                bucket = self.buckets.get(bucket_key)
+                if bucket:
+                    _, base_arr = bucket.pop()  # LIFO
+
+                    # --- DEBUG: POOL HIT ---
+                    # mb_size = slab_size / (1024 * 1024)
+                    # print(f"[POOL] ♻️ REUSE mb={mb_size:.4f} bytes={slab_size} dtype={dt.name}")
+
+        # Always allocate a full power-of-two slab if no pooled array was found
+        if base_arr is None:
+            num_elements = slab_size // dt.itemsize
+
+            # --- DEBUG: OS ALLOCATION ---
+            # mb_size = slab_size / (1024 * 1024)
+            # print(f"[POOL] 🚨 ALLOC mb={mb_size:.4f} bytes={slab_size} dtype={dt.name} elements={num_elements}")
+
+            base_arr = np.empty(num_elements, dtype=dt)
+
+        return PooledArrayHandle(self, base_arr, bucket_key)
+
+    def _put(self, bucket_key, array):
+        """Thread-safe return to pool with aging timestamp."""
+        slab_size, dtype = bucket_key
+        if self.min_bytes <= slab_size <= self.max_bytes:
+            with self.lock:
+                # Initialize bucket lazily to keep __init__ clean
+                try:
+                    bucket = self.buckets[bucket_key]
+                except KeyError:
+                    bucket = []
+                    self.buckets[bucket_key] = bucket
+
+                bucket.append((time.monotonic(), array))
+
+        #         mb_size = slab_size / (1024 * 1024)
+        #         print(f"[POOL] ♻️ RETUR mb={mb_size:.4f} bytes={slab_size} dtype={dtype}")
+        # else:
+        #     mb_size = slab_size / (1024 * 1024)
+        #     print(f"[POOL] 🚨 DELET  mb={mb_size:.4f} bytes={slab_size} dtype={dtype}")
+
+    def cleanup(self, max_age_seconds):
+        """Evicts arrays that have been idle for too long."""
+        now = time.monotonic()
+        with self.lock:
+            for key in list(self.buckets.keys()):
+                bucket = self.buckets[key]
+                # Filter bucket: keep only arrays returned within the time window
+                self.buckets[key] = [(ts, arr) for ts, arr in bucket if (now - ts) < max_age_seconds]
+
+    def get(self, element_count, dtype=dtypes.BYTE):
+        """Sugar for context manager usage."""
+        return self.acquire(element_count, dtype)
+
+    def create(self, wrapper_class, *args, **kwargs):
+        """
+        Instantiates a high-level wrapper object (like PooledLogBatch),
+        automatically injecting this pool as the first argument.
+        """
+        return wrapper_class(self, *args, **kwargs)
+
+    def audit(self):
+        print("\n" + "=" * 40)
+        print("      NUMPY POOL STORAGE AUDIT")
+        print("=" * 40)
+        total_mb = 0
+        total_count = 0
+
+        with self.lock:
+            for (size_bytes, dtype), bucket in self.buckets.items():
+                count = len(bucket)
+                mb = (size_bytes * count) / (1024 * 1024)
+                total_mb += mb
+                total_count += count
+                if count > 0:
+                    print(
+                        f"Bucket: {size_bytes:>7} bytes | Dtype: {dtype.name:<7} | Count: {count:>6} | Total: {mb:>7.2f} MB"
+                    )
+
+        print("-" * 40)
+        print(f"GRAND TOTAL POOLED: {total_mb:.2f} MB")
+        print(f"TOTAL ARRAY OBJECTS: {total_count:,}")
+        print("=" * 40 + "\n")