glaip-sdk 0.0.6a0__py3-none-any.whl → 0.0.8__py3-none-any.whl

glaip_sdk/utils/rendering/renderer/base.py

@@ -121,40 +121,68 @@ class RichStreamRenderer:
         self.stream_processor.streaming_started_at = self._started_at
 
         # Print compact header and user request (parity with old renderer)
+        self._render_header(meta)
+        self._render_user_query(meta)
+
+    def _render_header(self, meta: dict[str, Any]) -> None:
+        """Render the agent header with metadata."""
+        parts = self._build_header_parts(meta)
+        self.header_text = " ".join(parts)
+
+        if not self.header_text:
+            return
+
+        # Use a rule-like header for readability with fallback
+        if not self._render_header_rule():
+            self._render_header_fallback()
+
+    def _build_header_parts(self, meta: dict[str, Any]) -> list[str]:
+        """Build header text parts from metadata."""
+        parts: list[str] = ["🤖"]
+        agent_name = meta.get("agent_name", "agent")
+        if agent_name:
+            parts.append(agent_name)
+
+        model = meta.get("model", "")
+        if model:
+            parts.extend(["•", model])
+
+        run_id = meta.get("run_id", "")
+        if run_id:
+            parts.extend(["•", run_id])
+
+        return parts
+
+    def _render_header_rule(self) -> bool:
+        """Render header as a rule. Returns True if successful."""
         try:
-            parts: list[str] = ["🤖"]
-            agent_name = meta.get("agent_name", "agent")
-            if agent_name:
-                parts.append(agent_name)
-            model = meta.get("model", "")
-            if model:
-                parts.extend(["•", model])
-            run_id = meta.get("run_id", "")
-            if run_id:
-                parts.extend(["•", run_id])
-            self.header_text = " ".join(parts)
-            if self.header_text:
-                try:
-                    # Use a rule-like header for readability
-                    self.console.rule(self.header_text)
-                except Exception:
-                    self.console.print(self.header_text)
+            self.console.rule(self.header_text)
+            return True
+        except Exception:  # pragma: no cover - defensive fallback
+            logger.exception("Failed to render header rule")
+            return False
 
-            query = (
-                meta.get("input_message") or meta.get("query") or meta.get("message")
-            )
-            if query:
-                self.console.print(
-                    AIPPanel(
-                        Markdown(f"**Query:** {query}"),
-                        title="User Request",
-                        border_style="yellow",
-                        padding=(0, 1),
-                    )
-                )
+    def _render_header_fallback(self) -> None:
+        """Fallback header rendering."""
+        try:
+            self.console.print(self.header_text)
         except Exception:
-            # Non-fatal: header is nice-to-have
-            pass
+            logger.exception("Failed to print header fallback")
+
+    def _render_user_query(self, meta: dict[str, Any]) -> None:
+        """Render the user query panel."""
+        query = meta.get("input_message") or meta.get("query") or meta.get("message")
+        if not query:
+            return
+
+        self.console.print(
+            AIPPanel(
+                Markdown(f"**Query:** {query}"),
+                title="User Request",
+                border_style="#d97706",
+                padding=(0, 1),
+            )
+        )
 
     def on_event(self, ev: dict[str, Any]) -> None:
         """Handle streaming events from the backend."""
@@ -230,50 +258,77 @@ class RichStreamRenderer:
         # Update live display
         self._ensure_live()
 
+    def _finish_running_steps(self) -> None:
+        """Mark any running steps as finished to avoid lingering spinners."""
+        for st in list(self.steps.by_id.values()):
+            if not is_step_finished(st):
+                st.finish(None)
+
+    def _finish_tool_panels(self) -> None:
+        """Mark unfinished tool panels as finished."""
+        try:
+            items = list(self.tool_panels.items())
+        except Exception:  # pragma: no cover - defensive guard
+            logger.exception("Failed to iterate tool panels during cleanup")
+            return
+
+        for _sid, meta in items:
+            if meta.get("status") != "finished":
+                meta["status"] = "finished"
+
+    def _stop_live_display(self) -> None:
+        """Stop live display and clean up."""
+        self._shutdown_live()
+
+    def _print_final_panel_if_needed(self) -> None:
+        """Print final result panel if verbose mode and content available."""
+        if self.verbose and not self.state.printed_final_panel:
+            body = ("".join(self.state.buffer) or "").strip()
+            if body:
+                final_panel = create_final_panel(body, theme=self.cfg.theme)
+                self.console.print(final_panel)
+                self.state.printed_final_panel = True
+
     def on_complete(self, _stats: RunStats) -> None:
         """Handle completion event."""
         self.state.finalizing_ui = True
 
         # Mark any running steps as finished to avoid lingering spinners
-        try:
-            for st in list(self.steps.by_id.values()):
-                if not is_step_finished(st):
-                    st.finish(None)
-        except Exception:
-            pass
+        self._finish_running_steps()
 
         # Mark unfinished tool panels as finished
-        try:
-            for _sid, meta in list(self.tool_panels.items()):
-                if meta.get("status") != "finished":
-                    meta["status"] = "finished"
-        except Exception:
-            pass
+        self._finish_tool_panels()
 
         # Final refresh
         self._ensure_live()
 
         # Stop live display
-        if self.live:
-            self.live.stop()
-            self.live = None
+        self._stop_live_display()
 
-        # If no explicit final_response was printed, but we have buffered content,
-        # print a final result panel so users still see the outcome (especially in --verbose).
-        try:
-            if self.verbose and not self.state.printed_final_panel:
-                body = ("".join(self.state.buffer) or "").strip()
-                if body:
-                    final_panel = create_final_panel(body, theme=self.cfg.theme)
-                    self.console.print(final_panel)
-                    self.state.printed_final_panel = True
-        except Exception:
-            # Non-fatal; renderer best-effort
-            pass
+        # Print final panel if needed
+        self._print_final_panel_if_needed()
 
     def _ensure_live(self) -> None:
         """Ensure live display is updated."""
         # Lazily create Live if needed
+        # Rich's Live expects the console to maintain a _live_stack list. When tests
+        # or callers provide a lightweight console double (e.g. unittest.mock.Mock),
+        # the attribute might be missing or replaced with another type which breaks
+        # the background refresh thread. Normal Rich consoles always expose
+        # _live_stack as a list, so we defensively initialise it if needed.
+        live_stack = getattr(self.console, "_live_stack", None)
+        if not isinstance(live_stack, list):
+            try:
+                self.console._live_stack = []  # type: ignore[attr-defined]
+            except Exception:
+                # If the console forbids attribute assignment we simply skip the
+                # live update for this cycle and fall back to buffered printing.
+                logger.debug(
+                    "Console missing _live_stack; skipping live UI initialisation",
+                    exc_info=True,
+                )
+                return
+
         if self.live is None and self.cfg.live:
             try:
                 self.live = Live(
@@ -441,22 +496,24 @@ class RichStreamRenderer:
 
     def _calculate_tool_duration(self, meta: dict[str, Any]) -> float | None:
         """Calculate tool duration from metadata."""
-        try:
-            server_now = self.stream_processor.server_elapsed_time
-            server_start = meta.get("server_started_at")
-            dur = None
+        server_now = self.stream_processor.server_elapsed_time
+        server_start = meta.get("server_started_at")
+        dur = None
 
-            if isinstance(server_now, int | float) and isinstance(
-                server_start, int | float
-            ):
+        try:
+            if isinstance(server_now, (int, float)) and server_start is not None:
                 dur = max(0.0, float(server_now) - float(server_start))
-            elif meta.get("started_at") is not None:
-                dur = max(0.0, float(monotonic() - meta.get("started_at")))
-
-            return dur
-        except Exception:
+            else:
+                started_at = meta.get("started_at")
+                if started_at is not None:
+                    started_at_float = float(started_at)
+                    dur = max(0.0, float(monotonic()) - started_at_float)
+        except (TypeError, ValueError):
+            logger.exception("Failed to calculate tool duration")
             return None
 
+        return dur
+
     def _update_tool_metadata(self, meta: dict[str, Any], dur: float | None) -> None:
         """Update tool metadata with duration information."""
         if dur is not None:
@@ -510,10 +567,7 @@ class RichStreamRenderer:
     ) -> float | None:
         """Get step duration from tool panels."""
         tool_sid = f"tool_{finished_tool_name}_{task_id}_{context_id}"
-        try:
-            return self.tool_panels.get(tool_sid, {}).get("duration_seconds")
-        except Exception:
-            return None
+        return self.tool_panels.get(tool_sid, {}).get("duration_seconds")
 
     def _finish_delegation_step(
         self,
@@ -647,27 +701,23 @@ class RichStreamRenderer:
         self, finished_tool_name: str, task_id: str, context_id: str
     ) -> None:
         """Create and print a snapshot for a finished tool."""
-        try:
-            tool_sid = f"tool_{finished_tool_name}_{task_id}_{context_id}"
-
-            if not self._should_create_snapshot(tool_sid):
-                return
+        tool_sid = f"tool_{finished_tool_name}_{task_id}_{context_id}"
 
-            meta = self.tool_panels[tool_sid]
-            adjusted_title = self._get_snapshot_title(meta, finished_tool_name)
+        if not self._should_create_snapshot(tool_sid):
+            return
 
-            # Compose body from chunks and clamp
-            body_text = "".join(meta.get("chunks") or [])
-            body_text = self._clamp_snapshot_body(body_text)
+        meta = self.tool_panels[tool_sid]
+        adjusted_title = self._get_snapshot_title(meta, finished_tool_name)
 
-            snapshot_panel = self._create_snapshot_panel(
-                adjusted_title, body_text, finished_tool_name
-            )
+        # Compose body from chunks and clamp
+        body_text = "".join(meta.get("chunks") or [])
+        body_text = self._clamp_snapshot_body(body_text)
 
-            self._print_and_mark_snapshot(tool_sid, snapshot_panel)
+        snapshot_panel = self._create_snapshot_panel(
+            adjusted_title, body_text, finished_tool_name
+        )
 
-        except Exception:
-            pass
+        self._print_and_mark_snapshot(tool_sid, snapshot_panel)
 
     def _handle_agent_step(
         self,
@@ -725,21 +775,30 @@ class RichStreamRenderer:
 
     def close(self) -> None:
         """Gracefully stop any live rendering and release resources."""
+        self._shutdown_live()
+
+    def __del__(self) -> None:
+        # Destructors must never raise
         try:
-            if self.live:
-                try:
-                    self.live.stop()
-                finally:
-                    self.live = None
-        except Exception:
+            self._shutdown_live(reset_attr=False)
+        except Exception:  # pragma: no cover - destructor safety net
             pass
 
-    def __del__(self) -> None:
+    def _shutdown_live(self, reset_attr: bool = True) -> None:
+        """Stop the live renderer without letting exceptions escape."""
+        live = getattr(self, "live", None)
+        if not live:
+            if reset_attr and not hasattr(self, "live"):
+                self.live = None
+            return
+
         try:
-            if self.live:
-                self.live.stop()
+            live.stop()
         except Exception:
-            pass
+            logger.exception("Failed to stop live display")
+        finally:
+            if reset_attr:
+                self.live = None
 
     def _get_analysis_progress_info(self) -> dict[str, Any]:
         total_steps = len(self.steps.order)
@@ -754,15 +813,9 @@ class RichStreamRenderer:
         # Prefer server elapsed time when available
         elapsed = 0.0
         if isinstance(self.stream_processor.server_elapsed_time, int | float):
-            try:
-                elapsed = float(self.stream_processor.server_elapsed_time)
-            except Exception:
-                elapsed = 0.0
+            elapsed = float(self.stream_processor.server_elapsed_time)
         elif self._started_at is not None:
-            try:
-                elapsed = monotonic() - self._started_at
-            except Exception:
-                elapsed = 0.0
+            elapsed = monotonic() - self._started_at
         progress_percent = (
             int((completed_steps / total_steps) * 100) if total_steps else 0
         )
@@ -913,10 +966,7 @@ class RichStreamRenderer:
         ):
             elapsed = max(0.0, float(server_elapsed) - float(server_start))
         else:
-            try:
-                elapsed = max(0.0, monotonic() - (meta.get("started_at") or 0.0))
-            except Exception:
-                elapsed = 0.0
+            elapsed = max(0.0, monotonic() - (meta.get("started_at") or 0.0))
 
         return self._format_elapsed_time(elapsed)
 
@@ -1025,17 +1075,14 @@ class RichStreamRenderer:
         if not (tool_name and is_delegation_tool(tool_name)):
             return output
 
-        try:
-            sub = tool_name
-            if tool_name.startswith("delegate_to_"):
-                sub = tool_name.replace("delegate_to_", "")
-            elif tool_name.startswith("delegate_"):
-                sub = tool_name.replace("delegate_", "")
-            prefix = f"[{sub}]"
-            if output.startswith(prefix):
-                return output[len(prefix) :].lstrip()
-        except Exception:
-            pass
+        sub = tool_name
+        if tool_name.startswith("delegate_to_"):
+            sub = tool_name.replace("delegate_to_", "")
+        elif tool_name.startswith("delegate_"):
+            sub = tool_name.replace("delegate_", "")
+        prefix = f"[{sub}]"
+        if output.startswith(prefix):
+            return output[len(prefix) :].lstrip()
 
         return output
 
@@ -1080,5 +1127,3 @@ class RichStreamRenderer:
             return self._format_string_output(output_value, tool_name)
         else:
             return self._format_other_output(output_value)
-
-    # No legacy surface helpers are exposed; use modern interfaces only

glaip_sdk/utils/serialization.py

@@ -8,7 +8,7 @@ Authors:
 """
 
 import json
-from collections.abc import Iterable
+from collections.abc import Callable, Iterable
 from pathlib import Path
 from typing import Any
 
@@ -184,7 +184,9 @@ def collect_attributes_for_export(resource: Any) -> dict[str, Any]:
     """
 
     mapping = _coerce_resource_to_mapping(resource)
-    if mapping is None:
+    if (
+        mapping is None
+    ):  # pragma: no cover - defensive fallback when attribute introspection fails
         items = (
             (name, _safe_getattr(resource, name))
             for name in _iter_public_attribute_names(resource)
@@ -215,11 +217,13 @@ def _coerce_resource_to_mapping(resource: Any) -> dict[str, Any] | None:
     if isinstance(resource, dict):
         return resource
 
-    if hasattr(resource, "__dict__"):
-        try:
+    try:
+        if hasattr(resource, "__dict__"):
             return dict(resource.__dict__)
-        except Exception:
-            return None
+    except (
+        Exception
+    ):  # pragma: no cover - pathological objects can still defeat coercion
+        return None
 
     return None
 
@@ -231,27 +235,59 @@ def _iter_public_attribute_names(resource: Any) -> Iterable[str]:
     names: list[str] = []
 
     def _collect(candidates: Iterable[str] | None) -> None:
-        if candidates is None:
-            return
-        for candidate in candidates:
+        for candidate in candidates or ():
             if candidate not in seen:
                 seen.add(candidate)
                 names.append(candidate)
 
-    _collect(
-        getattr(resource, "__dict__", {}).keys()
-        if hasattr(resource, "__dict__")
-        else None
-    )
-    _collect(getattr(resource, "__annotations__", {}).keys())
+    # Collect from __dict__
+    _collect_from_dict(resource, _collect)
+
+    # Collect from __annotations__
+    _collect_from_annotations(resource, _collect)
+
+    # Collect from __slots__
     _collect(getattr(resource, "__slots__", ()))
 
+    # Fallback to dir() if no names found
     if not names:
-        _collect(name for name in dir(resource) if not name.startswith("__"))
+        _collect_from_dir(resource, _collect)
 
     return iter(names)
 
 
+def _collect_from_dict(
+    resource: Any, collect_func: Callable[[Iterable[str]], None]
+) -> None:
+    """Safely collect attribute names from __dict__."""
+    try:
+        if hasattr(resource, "__dict__"):
+            dict_keys = getattr(resource, "__dict__", {})
+            if dict_keys:
+                collect_func(dict_keys.keys())
+    except Exception:  # pragma: no cover - defensive programming
+        pass
+
+
+def _collect_from_annotations(
+    resource: Any, collect_func: Callable[[Iterable[str]], None]
+) -> None:
+    """Safely collect attribute names from __annotations__."""
+    annotations = getattr(resource, "__annotations__", {})
+    if annotations:
+        collect_func(annotations.keys())
+
+
+def _collect_from_dir(
+    resource: Any, collect_func: Callable[[Iterable[str]], None]
+) -> None:
+    """Safely collect attribute names from dir()."""
+    try:
+        collect_func(name for name in dir(resource) if not name.startswith("__"))
+    except Exception:  # pragma: no cover - defensive programming
+        pass
+
+
 def _safe_getattr(resource: Any, name: str) -> Any:
     try:
         return getattr(resource, name)

{glaip_sdk-0.0.6a0.dist-info → glaip_sdk-0.0.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: glaip-sdk
-Version: 0.0.6a0
+Version: 0.0.8
 Summary: Python SDK for GL AIP (GDP Labs AI Agent Package) - Simplified CLI Design
 License: MIT
 Author: Raymond Christopher

{glaip_sdk-0.0.6a0.dist-info → glaip_sdk-0.0.8.dist-info}/RECORD

@@ -1,42 +1,46 @@
 glaip_sdk/__init__.py,sha256=FD-oTyFUKsTB9xTuGiqvkhuFXfeZ-TspjkeXERglha8,370
-glaip_sdk/_version.py,sha256=Rb9YLDvK1DXCVFrjlLDbtucpwKh_PyCnmZ-ia9VX3Cc,1650
-glaip_sdk/branding.py,sha256=d-yGCYbUcdOlEH87E5PmGIyj6uBywsnf-Yd7zs__mUs,5371
+glaip_sdk/_version.py,sha256=tGkFWAVu2ry4Hy7j-u7ophGbPRX8y-ngBbXDhN1VBIQ,2007
+glaip_sdk/branding.py,sha256=_TiQtiwH3ZSWaQhooWPHioriL0goTiYANeN6DT8lQX8,5398
 glaip_sdk/cli/__init__.py,sha256=xCCfuF1Yc7mpCDcfhHZTX0vizvtrDSLeT8MJ3V7m5A0,156
 glaip_sdk/cli/agent_config.py,sha256=VHjebw68wAdhGUzYdPH8qz10oADZPRgUQcPW6F7iHIU,2421
 glaip_sdk/cli/commands/__init__.py,sha256=x0CZlZbZHoHvuzfoTWIyEch6WmNnbPzxajrox6riYp0,173
-glaip_sdk/cli/commands/agents.py,sha256=cYkNAFDFTH5EDP4KTcJ8gEdLDxzEMI0OZQDkeyNs-TY,37378
-glaip_sdk/cli/commands/configure.py,sha256=SQziXzUE4-6G6Prd6rPizV1kFN9uCuUjDhfVAn8cAWU,7469
-glaip_sdk/cli/commands/mcps.py,sha256=USSjitNOmlLw8Jgt0WqnhnMBmuuoQRXiJjARD9qS_l0,12868
+glaip_sdk/cli/commands/agents.py,sha256=1xGSoH6C9hSaGglXf4pnloqX5gJQIPsgHhkliiWQQcY,39988
+glaip_sdk/cli/commands/configure.py,sha256=eRDzsaKV4fl2lJt8ieS4g2-xRnaa02eAAPW8xBf-tqA,7507
+glaip_sdk/cli/commands/mcps.py,sha256=ZfmFkisXHHqgFH6WU7W5qPvfdt5Dxd5ZFZb_Ml3POoQ,12794
 glaip_sdk/cli/commands/models.py,sha256=lHEVuXT8Sq239C_2LneV8PimVZSm9DXJKajdSVO-N50,1496
-glaip_sdk/cli/commands/tools.py,sha256=ubzSKornMTCVkCvIvMPvWj2vOwGZzIyKysoR5mL20PY,16817
-glaip_sdk/cli/display.py,sha256=vFSj385MuesgyUJ7UnXIg6a9N9gL_XJzXjUnFUB6Ufs,8649
+glaip_sdk/cli/commands/tools.py,sha256=Xm_qCe0h2EqhbqNuKTBvow1HMc7MbLYx6j92A6rLwu0,16743
+glaip_sdk/cli/display.py,sha256=jE20swoRKzpYUmc0jgbeonaXKeE9x95hfjWAEdnBYRc,8727
 glaip_sdk/cli/io.py,sha256=GPkw3pQMLBGoD5GH-KlbKpNRlVWFZOXHE17F7V3kQsI,3343
-glaip_sdk/cli/main.py,sha256=Z1uMlmU72FFXC2ushNTWpemhQWKbIJNFJauH6FOCPqA,11059
-glaip_sdk/cli/resolution.py,sha256=4PEW_KZfN13k7GGEWpx3dOTywE_d-ujSlUhO4liov5w,1673
-glaip_sdk/cli/utils.py,sha256=bm4NqTlHsNXzZbFjXmHJMoV0qv9JPUMVSee47cH3bVw,36667
+glaip_sdk/cli/main.py,sha256=1RSR3YmJECnpErD_y9NXqCHjyho3JkYkVc26J6NAbzE,12694
+glaip_sdk/cli/resolution.py,sha256=BOw2NchReLKewAwBAZLWw_3_bI7u3tfzQEO7kQbIiGE,2067
+glaip_sdk/cli/slash/__init__.py,sha256=Vdv6Y8bu-pA8dxDlyP4XrhudBPivztUozhLAz9vaLig,682
+glaip_sdk/cli/slash/agent_session.py,sha256=JFIFBxB4xzigqHtpLGbl2fgg7RHNwy3e-kUMPMK9MdM,5006
+glaip_sdk/cli/slash/prompt.py,sha256=QFWYgNt5AhBRYGGyUkH30ToZE7B6LS-eZGzoyibYrK8,6064
+glaip_sdk/cli/slash/session.py,sha256=GtnnBqV79KtFJHeLfCKKnCXJ6SU1AmeXquPjy72T20E,24215
+glaip_sdk/cli/utils.py,sha256=Jhjv9ggwZGQ8oJZGIPIpOc29LqSZAks9FLVWtTpklYU,40629
 glaip_sdk/cli/validators.py,sha256=USbBgY86AwuDHO-Q_g8g7hu-ot4NgITBsWjTWIl62ms,5569
 glaip_sdk/client/__init__.py,sha256=nYLXfBVTTWwKjP0e63iumPYO4k5FifwWaELQPaPIKIg,188
-glaip_sdk/client/agents.py,sha256=SRcj_fvMWjN_AOpOv8iVyF0LuiZqWMidW9pg8O2J3Xc,33892
-glaip_sdk/client/base.py,sha256=rn5qPsi-1UzRy2So0Uffg9CBnVY2QUld4suNgSHET_I,12409
+glaip_sdk/client/agents.py,sha256=FSKubF40wptMNIheC3_iawiX2CRbhTcNLFiz4qkPC6k,34659
+glaip_sdk/client/base.py,sha256=O3dv3I7PqY91gH1FehBMRZcSXjwimfeBcJuiXidDmqw,13700
 glaip_sdk/client/main.py,sha256=LlvYHP7-Hy7Eq1ep1kfk337K-Oue5SdKWJpqYfX9eXY,7993
 glaip_sdk/client/mcps.py,sha256=yxwrAtztElYDEGhp2EHRpeYUxNsOlTLTqtw9jSKJmcI,8936
-glaip_sdk/client/tools.py,sha256=ZvRRbXHvd33XUKqmKAIFSvz_IO-1glTvJNyxOeivK9Q,15962
+glaip_sdk/client/tools.py,sha256=n8DIiOOf1YU_j9JK3Bx2-rDnkpckPi0MI9Ok2s1kwa4,16634
 glaip_sdk/client/validators.py,sha256=NtPsWjQLjj25LiUnmR-WuS8lL5p4MVRaYT9UVRmj9bo,8809
 glaip_sdk/config/constants.py,sha256=NgmPqJmpK1wgEds7T-_B6CDUBsvcsmIy27ms-Z8GFgY,902
 glaip_sdk/exceptions.py,sha256=QTVtwxRHMN4e8gGn0icXphZvdugiRvcSrlMYylwGsDc,1993
-glaip_sdk/models.py,sha256=HkX9jwC3eh2bjL4Hj7uwQR1RSz63tzxbMe_n0gLJHjE,8782
+glaip_sdk/models.py,sha256=Ry_Ihd6FuC0JGb0Obd5T3A22AOp2r9xStQisfE8uo8c,8822
 glaip_sdk/rich_components.py,sha256=pmJd-81OQE8bC9UOXtga5rsax4zphKlzCZ1JoWbbQzQ,803
 glaip_sdk/utils/__init__.py,sha256=fmVGcUFa7G0CCfSMSqfNU2BqFl36G1gOFyDfTvtJfVw,926
 glaip_sdk/utils/agent_config.py,sha256=b7_J5DELyk0b_XEoi7tsxbS3wqzAKbMa-3_C-65pPIY,6791
-glaip_sdk/utils/client_utils.py,sha256=W1TBD8-f5RRh3CyiSYcTOtn_e6A_msIFXmgHQ0m-YMo,13072
+glaip_sdk/utils/client_utils.py,sha256=M6rZloMKyONaZfI0RtU5tnkibwrIJL5Udw4wPMKkJcw,13588
 glaip_sdk/utils/display.py,sha256=94s9lYF_8ra8jpeqOkbVrUm8oidtCE6OtucyxLQPKmU,3105
 glaip_sdk/utils/general.py,sha256=V5hJrIpYDvDsldU_nChHpuvV2AwhFLUI7Qvcaihq_8A,2270
-glaip_sdk/utils/import_export.py,sha256=KJ_8wy-Ol92HiKAqO5vUz3Gn257jqWFsq3XEdRH-NXM,5393
+glaip_sdk/utils/import_export.py,sha256=Wxt2QuWI7JexSkkcBOdTgeYs1nly35yppaTNeF28XJo,5400
 glaip_sdk/utils/rendering/__init__.py,sha256=vXjwk5rPhhfPyD8S0DnV4GFFEtPJp4HCCg1Um9SXfs0,70
 glaip_sdk/utils/rendering/formatting.py,sha256=_k8tkcobctmHvdygMljZF7-ALGXpD9-hHF1CNtM2KMU,7201
 glaip_sdk/utils/rendering/models.py,sha256=SS34_00FaoGuSYn-viBkAtIbq7cJNwwPjpxnvyeUmxI,1567
 glaip_sdk/utils/rendering/renderer/__init__.py,sha256=EXwVBmGkSYcype4ocAXo69Z1kXu0gpNXmhH5LW0_B7A,2939
-glaip_sdk/utils/rendering/renderer/base.py,sha256=DgZW55Eu6uj_NsCKa-O4unb7ujnNNaWD-54aPd7y5gU,38872
+glaip_sdk/utils/rendering/renderer/base.py,sha256=OqRBfdE1cwYhaB-1wXwc4pyGaagnX2duistDOIaVsD0,40969
 glaip_sdk/utils/rendering/renderer/config.py,sha256=E4ER8TJJbqr1hcWjkwG7XROqLuccQy4EL99CbuLvSXE,783
 glaip_sdk/utils/rendering/renderer/console.py,sha256=4cLOw4Q1fkHkApuj6dWW8eYpeYdcT0t2SO5MbVt5UTc,1844
 glaip_sdk/utils/rendering/renderer/debug.py,sha256=FEYxAu4ZB0CjrJKevqQ2TKDgElA2cf6GqZXCNm12sNQ,3721
@@ -47,9 +51,9 @@ glaip_sdk/utils/rendering/steps.py,sha256=4zdeyKxMbUzCal4-yv8yf18144cs5wwXaxhe6m
 glaip_sdk/utils/resource_refs.py,sha256=0YzblJNfRhz9xhpaKE9aE68XEV-6_ssr0fIkiMVOka0,5489
 glaip_sdk/utils/rich_utils.py,sha256=-Ij-1bIJvnVAi6DrfftchIlMcvOTjVmSE0Qqax0EY_s,763
 glaip_sdk/utils/run_renderer.py,sha256=d_VMI6LbvHPUUeRmGqh5wK_lHqDEIAcym2iqpbtDad0,1365
-glaip_sdk/utils/serialization.py,sha256=WlWhvA2PDFGYXVw-OJG3zSKoXCv6gSh2YXgQmah490g,7866
+glaip_sdk/utils/serialization.py,sha256=cUE6PxqTsfJuEEmsk_Li3QmaDavTIPotEA-BQ-v5exY,9043
 glaip_sdk/utils/validation.py,sha256=QNORcdyvuliEs4EH2_mkDgmoyT9utgl7YNhaf45SEf8,6992
-glaip_sdk-0.0.6a0.dist-info/METADATA,sha256=k7ejh3C-HH1B3wTtlzaoxQyv_3CbsEBlvwElArwVQnE,4944
-glaip_sdk-0.0.6a0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-glaip_sdk-0.0.6a0.dist-info/entry_points.txt,sha256=EGs8NO8J1fdFMWA3CsF7sKBEvtHb_fujdCoNPhfMouE,47
-glaip_sdk-0.0.6a0.dist-info/RECORD,,
+glaip_sdk-0.0.8.dist-info/METADATA,sha256=yWuZjBH9LvHlgsGZ8NP8GsUpsAM2X2ScE9uNCDnRPls,4942
+glaip_sdk-0.0.8.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+glaip_sdk-0.0.8.dist-info/entry_points.txt,sha256=EGs8NO8J1fdFMWA3CsF7sKBEvtHb_fujdCoNPhfMouE,47
+glaip_sdk-0.0.8.dist-info/RECORD,,