glaip-sdk 0.7.26__py3-none-any.whl → 0.7.28__py3-none-any.whl

glaip_sdk/cli/slash/tui/toast.py

@@ -9,6 +9,7 @@ from enum import Enum
 from typing import Any, cast
 
 from rich.text import Text
+from textual.app import ComposeResult
 from textual.message import Message
 from textual.widget import Widget
 from textual.widgets import Static
@@ -55,13 +56,25 @@ class ToastBus:
         """Initialize the toast bus with optional change callback."""
         self._state: ToastState | None = None
         self._dismiss_task: asyncio.Task[None] | None = None
-        self._on_change = on_change
+        self._subscribers: list[Callable[[ToastBus.Changed], None]] = []
+        if on_change is not None:
+            self._subscribers.append(on_change)
 
     @property
     def state(self) -> ToastState | None:
         """Return the current toast state, or None if no toast is shown."""
         return self._state
 
+    def subscribe(self, callback: Callable[[ToastBus.Changed], None]) -> None:
+        """Register a callback to be notified of toast state changes."""
+        if callback not in self._subscribers:
+            self._subscribers.append(callback)
+
+    def unsubscribe(self, callback: Callable[[ToastBus.Changed], None]) -> None:
+        """Unregister a toast callback."""
+        if callback in self._subscribers:
+            self._subscribers.remove(callback)
+
     def show(
         self,
         message: str,
@@ -146,8 +159,12 @@ class ToastBus:
         self._notify_changed()
 
     def _notify_changed(self) -> None:
-        if self._on_change:
-            self._on_change(ToastBus.Changed(self._state))
+        message = ToastBus.Changed(self._state)
+        for callback in tuple(self._subscribers):
+            try:
+                callback(message)
+            except Exception:
+                pass
 
 
 class ToastHandlerMixin:
@@ -303,6 +320,15 @@ class ToastContainer(Widget):
         yield ToastContainer(Toast(), id="toast-container")
     """
 
+    def __init__(self, toast: Toast, id: str | None = None) -> None:
+        """Initialize the toast container with a toast widget."""
+        super().__init__(id=id)
+        self._toast = toast
+
+    def compose(self) -> ComposeResult:
+        """Compose the container by yielding the toast widget."""
+        yield self._toast
+
 
 class Toast(Static):
     """A Textual widget that displays toast notifications at the top-right of the screen.

glaip_sdk/utils/import_resolver.py

@@ -15,6 +15,8 @@ from pathlib import Path
 
 from glaip_sdk.utils.tool_detection import is_tool_plugin_decorator
 
+INIT_FILE = "__init__.py"
+
 
 class ImportResolver:
     """Resolves and categorizes Python imports for tool bundling.
@@ -46,6 +48,36 @@ class ImportResolver:
         """
         self.tool_dir = tool_dir
         self._processed_modules: set[str] = set()
+        self._package_root: Path = self._find_package_root(tool_dir)
+
+    def _find_package_root(self, start_path: Path) -> Path:
+        """Find package root using standard project markers.
+
+        Searches upward from start_path for common Python project markers:
+        - pyproject.toml (modern Python standard)
+        - setup.py (legacy setuptools)
+        - .git (version control root)
+
+        Falls back to start_path.parent if no markers found.
+
+        Args:
+            start_path: Starting directory to search from.
+
+        Returns:
+            Path to the identified package root.
+        """
+        # Check current directory and all parents
+        for parent in [start_path, *start_path.parents]:
+            if (parent / "pyproject.toml").exists():
+                return parent
+            if (parent / "setup.py").exists():
+                return parent
+            if (parent / ".git").exists():
+                return parent
+
+        # Fallback: return parent of start_path
+        # This maintains backward compatibility with original behavior
+        return start_path.parent
 
     def categorize_imports(self, tree: ast.AST) -> tuple[list, list]:
         """Categorize imports into local and external.
@@ -63,7 +95,7 @@ class ImportResolver:
         for node in ast.walk(tree):
             if isinstance(node, ast.ImportFrom):
                 if self.is_local_import(node):
-                    module_file = self.resolve_module_path(node.module)
+                    module_file = self._resolve_import_path(node)
                     local_imports.append((node.module, module_file, node))
                 else:
                     external_imports.append(node)
@@ -72,6 +104,25 @@ class ImportResolver:
 
         return local_imports, external_imports
 
+    def _resolve_import_path(self, node: ast.ImportFrom) -> Path:
+        """Resolve import node to file path.
+
+        Handles both absolute and relative imports.
+
+        Args:
+            node: ImportFrom AST node.
+
+        Returns:
+            Path to the module file.
+        """
+        if node.level > 0:
+            return self.resolve_relative_import_path(node)
+
+        if not node.module:
+            return self.tool_dir / INIT_FILE
+
+        return self.resolve_module_path(node.module)
+
     def is_local_import(self, node: ast.ImportFrom) -> bool:
         """Check if import is local to the tool directory.
 
@@ -81,16 +132,83 @@ class ImportResolver:
         Returns:
             True if import is local.
         """
+        # Handle relative imports (level > 0)
+        if node.level > 0:
+            return self._is_local_relative_import(node)
+
+        # Handle absolute imports with no module name
         if not node.module:
             return False
 
-        # Handle package imports
+        # Handle dotted package imports
         if "." in node.module:
             return self._is_local_package_import(node.module)
 
+        # Handle simple module imports
         potential_file = self.tool_dir / f"{node.module}.py"
         return potential_file.exists()
 
+    def _is_local_relative_import(self, node: ast.ImportFrom) -> bool:
+        """Check if a relative import is local.
+
+        Args:
+            node: ImportFrom node with node.level > 0.
+
+        Returns:
+            True if the relative import resolves to a local file.
+        """
+        if node.level == 0:
+            return False
+
+        base_dir = self._calculate_relative_base_dir(node.level)
+        if not base_dir:
+            return False
+
+        if node.module is None:
+            return self._is_init_file_present(base_dir)
+
+        return self._check_module_exists(base_dir, node.module)
+
+    def _calculate_relative_base_dir(self, level: int) -> Path | None:
+        """Calculate base directory for relative import.
+
+        Args:
+            level: Relative import level (1=current, 2=parent, etc.).
+
+        Returns:
+            Base directory path or None if exceeds filesystem root.
+        """
+        base_dir = self.tool_dir
+        for _ in range(level - 1):
+            if base_dir == base_dir.parent:
+                return None
+            base_dir = base_dir.parent
+        return base_dir
+
+    def _is_init_file_present(self, base_dir: Path) -> bool:
+        """Check if __init__.py exists in directory.
+
+        Args:
+            base_dir: Directory to check.
+
+        Returns:
+            True if __init__.py exists.
+        """
+        return (base_dir / INIT_FILE).exists()
+
+    def _check_module_exists(self, base_dir: Path, module: str) -> bool:
+        """Check if module exists in base directory.
+
+        Args:
+            base_dir: Base directory to search from.
+            module: Module name (dotted or simple).
+
+        Returns:
+            True if module file or package exists.
+        """
+        parts = module.split(".")
+        return self._module_parts_exist(base_dir, parts)
+
     def _is_local_package_import(self, module: str) -> bool:
         """Check if a dotted module path is local.
 
@@ -102,29 +220,141 @@ class ImportResolver:
         """
         parts = module.split(".")
 
-        # Case 1: First part matches current directory name
-        if parts[0] == self.tool_dir.name:
-            remaining_parts = parts[1:]
-            if len(remaining_parts) == 1:
-                module_path = self.tool_dir / f"{remaining_parts[0]}.py"
-                if module_path.exists():
-                    return True
-            elif len(remaining_parts) > 1:
-                module_path = self.tool_dir / "/".join(remaining_parts[:-1]) / f"{remaining_parts[-1]}.py"
-                if module_path.exists():
-                    return True
-
-        # Case 2: First part is a subdirectory of tool_dir
+        if self._check_module_in_tool_dir(parts):
+            return True
+
+        if self._check_module_in_subdirectory(parts):
+            return True
+
+        if self._check_module_in_ancestor_packages(parts):
+            return True
+
+        return False
+
+    def _check_module_in_tool_dir(self, parts: list[str]) -> bool:
+        """Check if module is in the current tool directory (Case 1).
+
+        Args:
+            parts: Module path split into components.
+
+        Returns:
+            True if module is found in tool_dir.
+        """
+        if parts[0] != self.tool_dir.name:
+            return False
+
+        remaining_parts = parts[1:]
+        if not remaining_parts:
+            return False
+
+        return self._module_parts_exist(self.tool_dir, remaining_parts)
+
+    def _check_module_in_subdirectory(self, parts: list[str]) -> bool:
+        """Check if module is in a subdirectory of tool_dir (Case 2).
+
+        Args:
+            parts: Module path split into components.
+
+        Returns:
+            True if module is found in a subdirectory.
+        """
         package_dir = self.tool_dir / parts[0]
-        if package_dir.is_dir():
-            module_path = self.tool_dir / "/".join(parts[:-1]) / f"{parts[-1]}.py"
-            if module_path.exists():
-                return True
-            module_path = self.tool_dir / "/".join(parts) / "__init__.py"
-            return module_path.exists()
+        if not package_dir.is_dir():
+            return False
+
+        return self._module_parts_exist(self.tool_dir, parts)
+
+    def _check_module_in_ancestor_packages(self, parts: list[str]) -> bool:
+        """Check if module is in the package root.
+
+        Uses the discovered package root (via project markers) to resolve
+        imports from the package root. Also falls back to directory name
+        matching for backward compatibility.
+
+        Args:
+            parts: Module path split into components.
+
+        Returns:
+            True if module is found in the package root.
+        """
+        # Strategy 1: Check if package root contains the module
+        if self._check_module_in_package_root(parts):
+            return True
+
+        # Strategy 2: Fallback to directory name matching (backward compatibility)
+        return self._check_module_by_directory_name(parts)
+
+    def _check_module_in_package_root(self, parts: list[str]) -> bool:
+        """Check if module exists in the discovered package root.
+
+        Args:
+            parts: Module path split into components.
+
+        Returns:
+            True if module exists in package root.
+        """
+        # Resolve module from package root
+        module_path = self._resolve_from_package_root_path(self._package_root, parts)
+        return module_path.exists()
+
+    def _check_module_by_directory_name(self, parts: list[str]) -> bool:
+        """Check module by matching directory names (legacy fallback).
+
+        Args:
+            parts: Module path split into components.
+
+        Returns:
+            True if module found by directory name matching.
+        """
+        current = self.tool_dir
+
+        while current != current.parent:
+            if parts[0] == current.name:
+                return self._resolve_from_package_root(current, parts)
+            current = current.parent
 
         return False
 
+    def _resolve_from_package_root(self, package_root: Path, parts: list[str]) -> bool:
+        """Resolve module from a found package root directory.
+
+        Args:
+            package_root: The identified package root directory.
+            parts: Module path split into components.
+
+        Returns:
+            True if module exists in the package root.
+        """
+        remaining_parts = parts[1:]
+
+        if not remaining_parts:
+            return (package_root / INIT_FILE).exists()
+
+        return self._module_parts_exist(package_root, remaining_parts)
+
+    def _module_parts_exist(self, base_dir: Path, parts: list[str]) -> bool:
+        """Check if module parts exist as a file or package.
+
+        Args:
+            base_dir: Base directory to search from.
+            parts: Remaining module path components.
+
+        Returns:
+            True if module file or package exists.
+        """
+        if len(parts) == 1:
+            module_file = base_dir / f"{parts[0]}.py"
+            if module_file.exists():
+                return True
+
+        if len(parts) > 1:
+            module_file = base_dir / "/".join(parts[:-1]) / f"{parts[-1]}.py"
+            if module_file.exists():
+                return True
+
+        init_file = base_dir / "/".join(parts) / INIT_FILE
+        return init_file.exists()
+
     def resolve_module_path(self, module_name: str) -> Path:
         """Resolve module name to file path.
 
@@ -138,6 +368,40 @@ class ImportResolver:
             return self._resolve_dotted_module_path(module_name)
         return self.tool_dir / f"{module_name}.py"
 
+    def resolve_relative_import_path(self, node: ast.ImportFrom) -> Path:
+        """Resolve relative import to file path.
+
+        Args:
+            node: ImportFrom node with node.level > 0.
+
+        Returns:
+            Path to the module file.
+
+        Raises:
+            ValueError: If relative import level exceeds directory depth.
+        """
+        base_dir = self._calculate_relative_base_dir(node.level)
+        if base_dir is None:
+            raise ValueError(f"Invalid relative import: level {node.level} exceeds directory depth")
+
+        if node.module is None:
+            return base_dir / INIT_FILE
+
+        return self._resolve_dotted_module_path_from_base(base_dir, node.module)
+
+    def _resolve_dotted_module_path_from_base(self, base_dir: Path, module_name: str) -> Path:
+        """Resolve dotted module path from a specific base directory.
+
+        Args:
+            base_dir: Base directory to resolve from.
+            module_name: Dotted module path (e.g., 'package.module').
+
+        Returns:
+            Path to the module file.
+        """
+        parts = module_name.split(".")
+        return self._build_module_path(base_dir, parts)
+
     def _resolve_dotted_module_path(self, module_name: str) -> Path:
         """Resolve a dotted module path to a file path.
 
@@ -149,25 +413,107 @@ class ImportResolver:
         """
         parts = module_name.split(".")
 
-        # Case 1: First part matches current directory name
-        if parts[0] == self.tool_dir.name:
-            remaining_parts = parts[1:]
-            if len(remaining_parts) == 1:
-                module_path = self.tool_dir / f"{remaining_parts[0]}.py"
-                if module_path.exists():
-                    return module_path
-            elif len(remaining_parts) > 1:
-                module_path = self.tool_dir / "/".join(remaining_parts[:-1]) / f"{remaining_parts[-1]}.py"
-                if module_path.exists():
-                    return module_path
-
-        # Case 2: Standard package/module.py
-        module_path = self.tool_dir / "/".join(parts[:-1]) / f"{parts[-1]}.py"
+        module_path = self._resolve_from_tool_dir(parts)
+        if module_path and module_path.exists():
+            return module_path
+
+        module_path = self._resolve_from_subdir(parts)
         if module_path.exists():
             return module_path
 
-        # Try package/__init__.py
-        return self.tool_dir / "/".join(parts) / "__init__.py"
+        module_path = self._resolve_from_ancestor_packages(parts)
+        if module_path and module_path.exists():
+            return module_path
+
+        return self.tool_dir / "/".join(parts) / INIT_FILE
+
+    def _resolve_from_tool_dir(self, parts: list[str]) -> Path | None:
+        """Resolve module from current tool directory.
+
+        Args:
+            parts: Module path split into components.
+
+        Returns:
+            Path to potential module file, or None if not applicable.
+        """
+        if parts[0] != self.tool_dir.name:
+            return None
+
+        remaining_parts = parts[1:]
+        if not remaining_parts:
+            return self.tool_dir / INIT_FILE
+
+        return self._build_module_path(self.tool_dir, remaining_parts)
+
+    def _resolve_from_subdir(self, parts: list[str]) -> Path:
+        """Resolve module from a subdirectory.
+
+        Args:
+            parts: Module path split into components.
+
+        Returns:
+            Path to potential module file.
+        """
+        return self._build_module_path(self.tool_dir, parts)
+
+    def _resolve_from_ancestor_packages(self, parts: list[str]) -> Path | None:
+        """Resolve module from an ancestor directory (Package Root Traversal).
+
+        Traverses up the directory tree looking for a matching package root.
+
+        Args:
+            parts: Module path split into components.
+
+        Returns:
+            Path to module if found in ancestor, None otherwise.
+        """
+        current = self.tool_dir
+
+        while current != current.parent:
+            if parts[0] == current.name:
+                return self._resolve_from_package_root_path(current, parts)
+            current = current.parent
+
+        return None
+
+    def _resolve_from_package_root_path(self, package_root: Path, parts: list[str]) -> Path:
+        """Build module path from a found package root.
+
+        Args:
+            package_root: The identified package root directory.
+            parts: Module path split into components.
+
+        Returns:
+            Path to potential module file.
+        """
+        remaining_parts = parts[1:]
+
+        if not remaining_parts:
+            return package_root / INIT_FILE
+
+        return self._build_module_path(package_root, remaining_parts)
+
+    def _build_module_path(self, base_dir: Path, parts: list[str]) -> Path:
+        """Build potential module file path from parts.
+
+        Args:
+            base_dir: Base directory to search from.
+            parts: Module path components.
+
+        Returns:
+            Path to potential module file.
+        """
+        if len(parts) == 1:
+            module_path = base_dir / f"{parts[0]}.py"
+            if module_path.exists():
+                return module_path
+
+        if len(parts) > 1:
+            module_path = base_dir / "/".join(parts[:-1]) / f"{parts[-1]}.py"
+            if module_path.exists():
+                return module_path
+
+        return base_dir / "/".join(parts) / INIT_FILE
 
     def format_external_imports(self, external_imports: list) -> list[str]:
         """Format external imports as code strings.
@@ -421,7 +767,7 @@ class ImportResolver:
             The node if external, None if local.
         """
         if isinstance(node, ast.ImportFrom):
-            if node.module and node.module.startswith("."):
+            if node.level > 0:
                 return None
             temp_resolver = ImportResolver(tool_dir)
             if temp_resolver.is_local_import(node):

{glaip_sdk-0.7.26.dist-info → glaip_sdk-0.7.28.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: glaip-sdk
-Version: 0.7.26
+Version: 0.7.28
 Summary: Python SDK and CLI for GL AIP (GDP Labs AI Agent Package) - Build, run, and manage AI agents
 Author-email: Raymond Christopher <raymond.christopher@gdplabs.id>
 License: MIT

{glaip_sdk-0.7.26.dist-info → glaip_sdk-0.7.28.dist-info}/RECORD

@@ -81,18 +81,18 @@ glaip_sdk/cli/slash/agent_session.py,sha256=tuVOme-NbEyr6rwJvsBEKZYWQmsaRf4piJeR
 glaip_sdk/cli/slash/prompt.py,sha256=q4f1c2zr7ZMUeO6AgOBF2Nz4qgMOXrVPt6WzPRQMbAM,8501
 glaip_sdk/cli/slash/remote_runs_controller.py,sha256=iLl4a-mu9QU7dcedgEILewPtDIVtFUJkbKGtcx1F66U,21445
 glaip_sdk/cli/slash/session.py,sha256=lWK4iCb4HGnHZf251kP_1iyH8J0BaTlwSs3XJWfYOuI,76146
-glaip_sdk/cli/slash/tui/__init__.py,sha256=N0nRo_IGIQ3l5LikZTDrwbK5HX9nqYNzwpFeM9crJQg,1109
+glaip_sdk/cli/slash/tui/__init__.py,sha256=mhX89VfkWFLCvSnu7ffIssbBgtqeTAJ3s90uf11HoFs,1107
 glaip_sdk/cli/slash/tui/accounts.tcss,sha256=5iVZZfS10CTJhnoZ9AFJejtj8nyQXH9xV7u9k8jSkGE,2411
-glaip_sdk/cli/slash/tui/accounts_app.py,sha256=CFjAHV0JbTSMoMoCQ0CIGa_8C8xypjHgV-VLDji-uzk,73590
+glaip_sdk/cli/slash/tui/accounts_app.py,sha256=TXAs2VmXvBeK0r09InL1H5liean789r4iTii9kRLm7Q,75578
 glaip_sdk/cli/slash/tui/background_tasks.py,sha256=SAe1mV2vXB3mJcSGhelU950vf8Lifjhws9iomyIVFKw,2422
 glaip_sdk/cli/slash/tui/clipboard.py,sha256=Rb1n6nYsjTgMfSMTVo4HisW8ZM3na2REtd3OHEy-Lz0,11255
 glaip_sdk/cli/slash/tui/context.py,sha256=mzI4TDXnfZd42osACp5uo10d10y1_A0z6IxRK1KVoVk,3320
 glaip_sdk/cli/slash/tui/indicators.py,sha256=jV3fFvEVWQ0inWJJ-B1fMsdkF0Uq2zwX3xcl0YWPHSE,11768
 glaip_sdk/cli/slash/tui/keybind_registry.py,sha256=_rK05BxTxNudYc4iJ9gDxpgeUkjDAq8rarIT-9A-jyM,6739
 glaip_sdk/cli/slash/tui/loading.py,sha256=Ku7HyQ_h-r2dJQ5aIEaCOi5PUu5gSsYle8oiKHIxfKI,2336
-glaip_sdk/cli/slash/tui/remote_runs_app.py,sha256=HtjrSKC_mqrzVBmK3ycehaRtaBEK3HsqDDkDp16kbvc,30356
+glaip_sdk/cli/slash/tui/remote_runs_app.py,sha256=Rm_Fo8WNyTHWNj2aGwTnYsV-QVUCCSbT380D8Cio3uM,40618
 glaip_sdk/cli/slash/tui/terminal.py,sha256=ZAC3sB17TGpl-GFeRVm_nI8DQTN3pyti3ynlZ41wT_A,12323
-glaip_sdk/cli/slash/tui/toast.py,sha256=3M7mtJAZfEWtMNhC8f1SpUCDZ_jlqhXRt_ll2Mohfg8,12435
+glaip_sdk/cli/slash/tui/toast.py,sha256=UmP0_UAQcp0mOdX1iIS8W3gGDb14Z3kYGmbN_NvYDls,13494
 glaip_sdk/cli/slash/tui/layouts/__init__.py,sha256=KT77pZHa7Wz84QlHYT2mfhQ_AXUA-T0eHv_HtAvc1ac,473
 glaip_sdk/cli/slash/tui/layouts/harlequin.py,sha256=JOsaK18jTojzZ-Py-87foxfijuRDWwi8LIWmqM6qS0k,5644
 glaip_sdk/cli/slash/tui/theme/__init__.py,sha256=rtM2ik83YNCRcI1qh_Sf3rnxco2OvCNNT3NbHY6cLvw,432
@@ -179,7 +179,7 @@ glaip_sdk/utils/display.py,sha256=zu3SYqxj9hPyEN8G1vIXv_yXBkV8jLLCXEg2rs8NlzM,44
 glaip_sdk/utils/export.py,sha256=1NxxE3wGsA1auzecG5oJw5ELB4VmPljoeIkGhrGOh1I,5006
 glaip_sdk/utils/general.py,sha256=3HSVIopUsIymPaim-kP2lqLX75TkkdIVLe6g3UKabZ0,1507
 glaip_sdk/utils/import_export.py,sha256=RCvoydm_6_L7_J1igcE6IYDunqgS5mQUbWT4VGrytMw,5510
-glaip_sdk/utils/import_resolver.py,sha256=X2qUV4_XmwStccGjnQ0YcxXAFyxZzwaKpfxjAW4Ev2o,17159
+glaip_sdk/utils/import_resolver.py,sha256=82kSV9eAlzBiwPI8rkeXVrNjlpXa5q9fvRoJxE6b-6U,27706
 glaip_sdk/utils/instructions.py,sha256=MTk93lsq3I8aRnvnRMSXXNMzcpnaIM_Pm3Aiiiq3GBc,2997
 glaip_sdk/utils/resource_refs.py,sha256=vF34kyAtFBLnaKnQVrsr2st1JiSxVbIZ4yq0DelJvCI,5966
 glaip_sdk/utils/run_renderer.py,sha256=d_VMI6LbvHPUUeRmGqh5wK_lHqDEIAcym2iqpbtDad0,1365
@@ -220,8 +220,8 @@ glaip_sdk/utils/rendering/steps/format.py,sha256=Chnq7OBaj8XMeBntSBxrX5zSmrYeGcO
 glaip_sdk/utils/rendering/steps/manager.py,sha256=BiBmTeQMQhjRMykgICXsXNYh1hGsss-fH9BIGVMWFi0,13194
 glaip_sdk/utils/rendering/viewer/__init__.py,sha256=XrxmE2cMAozqrzo1jtDFm8HqNtvDcYi2mAhXLXn5CjI,457
 glaip_sdk/utils/rendering/viewer/presenter.py,sha256=mlLMTjnyeyPVtsyrAbz1BJu9lFGQSlS-voZ-_Cuugv0,5725
-glaip_sdk-0.7.26.dist-info/METADATA,sha256=iydaDNjNqhBN5VqrlmWkAH7sYMZ90gttuMCIMnKCSbM,8686
-glaip_sdk-0.7.26.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-glaip_sdk-0.7.26.dist-info/entry_points.txt,sha256=NkhO6FfgX9Zrjn63GuKphf-dLw7KNJvucAcXc7P3aMk,54
-glaip_sdk-0.7.26.dist-info/top_level.txt,sha256=td7yXttiYX2s94-4wFhv-5KdT0rSZ-pnJRSire341hw,10
-glaip_sdk-0.7.26.dist-info/RECORD,,
+glaip_sdk-0.7.28.dist-info/METADATA,sha256=NLsPQhywv5Gba0deG2zIQX3FRZc0p_LZoDAp82Dawzg,8686
+glaip_sdk-0.7.28.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+glaip_sdk-0.7.28.dist-info/entry_points.txt,sha256=NkhO6FfgX9Zrjn63GuKphf-dLw7KNJvucAcXc7P3aMk,54
+glaip_sdk-0.7.28.dist-info/top_level.txt,sha256=td7yXttiYX2s94-4wFhv-5KdT0rSZ-pnJRSire341hw,10
+glaip_sdk-0.7.28.dist-info/RECORD,,