glaip-sdk 0.0.5b1__py3-none-any.whl → 0.0.7__py3-none-any.whl

glaip_sdk/utils/client_utils.py

@@ -9,10 +9,10 @@ Authors:
 """
 
 import logging
-from collections.abc import AsyncGenerator
+from collections.abc import AsyncGenerator, Iterator
 from contextlib import ExitStack
 from pathlib import Path
-from typing import Any, BinaryIO
+from typing import Any, BinaryIO, NoReturn
 
 import httpx
 
@@ -36,14 +36,19 @@ class MultipartData:
         self.files = files
         self._exit_stack = ExitStack()
 
-    def close(self):
+    def close(self) -> None:
         """Close all opened file handles."""
         self._exit_stack.close()
 
-    def __enter__(self):
+    def __enter__(self) -> "MultipartData":
         return self
 
-    def __exit__(self, _exc_type, _exc_val, _exc_tb):
+    def __exit__(
+        self,
+        _exc_type: type[BaseException] | None,
+        _exc_val: BaseException | None,
+        _exc_tb: Any,
+    ) -> None:
         self.close()
 
 
@@ -115,12 +120,38 @@ def find_by_name(
     return find_by_name_new(items, name, case_sensitive)
 
 
-def _parse_sse_line(line: str, buf: list, event_type: str = None, event_id: str = None):
-    """Parse a single SSE line and return updated buffer and event metadata."""
-    # Normalize CRLF and treat whitespace-only as blank
-    line = line.rstrip("\r")
+def _handle_blank_line(
+    buf: list[str],
+    event_type: str | None,
+    event_id: str | None,
+) -> tuple[list[str], str | None, str | None, dict[str, Any] | None, bool]:
+    """Handle blank SSE lines by returning accumulated data if buffer exists."""
+    if buf:
+        data = "\n".join(buf)
+        return (
+            [],
+            None,
+            None,
+            {
+                "event": event_type or "message",
+                "id": event_id,
+                "data": data,
+            },
+            False,
+        )
+    return buf, event_type, event_id, None, False
 
-    if not line.strip():  # blank line
+
+def _handle_data_line(
+    line: str,
+    buf: list[str],
+    event_type: str | None,
+    event_id: str | None,
+) -> tuple[list[str], str | None, str | None, dict[str, Any] | None, bool]:
+    """Handle data: lines, including [DONE] sentinel marker."""
+    data_line = line[5:].lstrip()
+
+    if data_line.strip() == "[DONE]":
         if buf:
             data = "\n".join(buf)
             return (
@@ -132,42 +163,59 @@ def _parse_sse_line(line: str, buf: list, event_type: str = None, event_id: str
                     "id": event_id,
                     "data": data,
                 },
-                False,
-            )  # no completion
-        return buf, event_type, event_id, None, False
+                True,
+            )
+        return buf, event_type, event_id, None, True
+
+    buf.append(data_line)
+    return buf, event_type, event_id, None, False
+
+
+def _handle_field_line(
+    line: str,
+    field_type: str,
+    current_value: str | None,
+) -> str | None:
+    """Handle event: or id: field lines."""
+    if field_type == "event":
+        return line[6:].strip() or None
+    elif field_type == "id":
+        return line[3:].strip() or None
+    return current_value
+
+
+def _parse_sse_line(
+    line: str,
+    buf: list[str],
+    event_type: str | None = None,
+    event_id: str | None = None,
+) -> tuple[list[str], str | None, str | None, dict[str, Any] | None, bool]:
+    """Parse a single SSE line and return updated buffer and event metadata."""
+    # Normalize CRLF and treat whitespace-only as blank
+    line = line.rstrip("\r")
+
+    if not line.strip():  # blank line
+        return _handle_blank_line(buf, event_type, event_id)
 
     if line.startswith(":"):  # comment
         return buf, event_type, event_id, None, False
 
     if line.startswith("data:"):
-        data_line = line[5:].lstrip()
-        if data_line.strip() == "[DONE]":  # sentinel end marker
-            if buf:
-                data = "\n".join(buf)
-                return (
-                    [],
-                    None,
-                    None,
-                    {
-                        "event": event_type or "message",
-                        "id": event_id,
-                        "data": data,
-                    },
-                    True,
-                )  # signal completion
-            return buf, event_type, event_id, None, True
-        buf.append(data_line)
-    elif line.startswith("event:"):
-        event_type = line[6:].strip() or None
+        return _handle_data_line(line, buf, event_type, event_id)
+
+    if line.startswith("event:"):
+        event_type = _handle_field_line(line, "event", event_type)
     elif line.startswith("id:"):
-        event_id = line[3:].strip() or None
+        event_id = _handle_field_line(line, "id", event_id)
 
     return buf, event_type, event_id, None, False
 
 
 def _handle_streaming_error(
-    e: Exception, timeout_seconds: float = None, agent_name: str = None
-):
+    e: Exception,
+    timeout_seconds: float | None = None,
+    agent_name: str | None = None,
+) -> NoReturn:
     """Handle different types of streaming errors with appropriate logging and exceptions."""
     if isinstance(e, httpx.ReadTimeout):
         logger.error(f"Read timeout during streaming: {e}")
@@ -198,9 +246,38 @@ def _handle_streaming_error(
         raise
 
 
+def _process_sse_line(
+    line: str, buf: list[str], event_type: str | None, event_id: str | None
+) -> tuple[list[str], str | None, str | None, dict[str, Any] | None, bool]:
+    """Process a single SSE line and return updated state."""
+    result = _parse_sse_line(line, buf, event_type, event_id)
+    buf, event_type, event_id, event_data, completed = result
+    return buf, event_type, event_id, event_data, completed
+
+
+def _yield_event_data(event_data: dict[str, Any] | None) -> Iterator[dict[str, Any]]:
+    """Yield event data if available."""
+    if event_data:
+        yield event_data
+
+
+def _flush_remaining_buffer(
+    buf: list[str], event_type: str | None, event_id: str | None
+) -> Iterator[dict[str, Any]]:
+    """Flush any remaining data in buffer."""
+    if buf:
+        yield {
+            "event": event_type or "message",
+            "id": event_id,
+            "data": "\n".join(buf),
+        }
+
+
 def iter_sse_events(
-    response: httpx.Response, timeout_seconds: float = None, agent_name: str = None
-):
+    response: httpx.Response,
+    timeout_seconds: float | None = None,
+    agent_name: str | None = None,
+) -> Iterator[dict[str, Any]]:
     """Iterate over Server-Sent Events with proper parsing.
 
     Args:
@@ -226,25 +303,16 @@ def iter_sse_events(
             if line is None:
                 continue
 
-            result = _parse_sse_line(line, buf, event_type, event_id)
-            if len(result) == 5:  # completion signal included
-                buf, event_type, event_id, event_data, completed = result
-            else:  # normal case
-                buf, event_type, event_id, event_data = result
-                completed = False
+            buf, event_type, event_id, event_data, completed = _process_sse_line(
+                line, buf, event_type, event_id
+            )
 
-            if event_data:
-                yield event_data
+            yield from _yield_event_data(event_data)
             if completed:
                 return
 
         # Flush any remaining data
-        if buf:
-            yield {
-                "event": event_type or "message",
-                "id": event_id,
-                "data": "\n".join(buf),
-            }
+        yield from _flush_remaining_buffer(buf, event_type, event_id)
 
     except Exception as e:
         _handle_streaming_error(e, timeout_seconds, agent_name)
@@ -279,11 +347,7 @@ async def aiter_sse_events(
                 continue
 
             result = _parse_sse_line(line, buf, event_type, event_id)
-            if len(result) == 5:  # completion signal included
-                buf, event_type, event_id, event_data, completed = result
-            else:  # normal case
-                buf, event_type, event_id, event_data = result
-                completed = False
+            buf, event_type, event_id, event_data, completed = result
 
             if event_data:
                 yield event_data
@@ -302,6 +366,66 @@ async def aiter_sse_events(
         _handle_streaming_error(e, timeout_seconds, agent_name)
 
 
+def _create_form_data(message: str) -> dict[str, Any]:
+    """Create form data with message and stream flag."""
+    return {"input": message, "message": message, "stream": True}
+
+
+def _prepare_file_entry(
+    item: str | BinaryIO, stack: ExitStack
+) -> tuple[str, tuple[str, BinaryIO, str]]:
+    """Prepare a single file entry for multipart data."""
+    if isinstance(item, str):
+        return _prepare_path_entry(item, stack)
+    else:
+        return _prepare_stream_entry(item)
+
+
+def _prepare_path_entry(
+    path_str: str, stack: ExitStack
+) -> tuple[str, tuple[str, BinaryIO, str]]:
+    """Prepare a file path entry."""
+    file_path = Path(path_str)
+    if not file_path.exists():
+        raise FileNotFoundError(f"File not found: {path_str}")
+
+    handle = stack.enter_context(open(file_path, "rb"))
+    return (
+        "files",
+        (
+            file_path.name,
+            handle,
+            "application/octet-stream",
+        ),
+    )
+
+
+def _prepare_stream_entry(
+    file_obj: BinaryIO,
+) -> tuple[str, tuple[str, BinaryIO, str]]:
+    """Prepare a file object entry."""
+    if not hasattr(file_obj, "read"):
+        raise ValueError(f"Invalid file object: {file_obj}")
+
+    raw_name = getattr(file_obj, "name", "file")
+    filename = Path(raw_name).name if raw_name else "file"
+
+    try:
+        if hasattr(file_obj, "seek"):
+            file_obj.seek(0)
+    except (OSError, ValueError):
+        pass
+
+    return (
+        "files",
+        (
+            filename,
+            file_obj,
+            "application/octet-stream",
+        ),
+    )
+
+
 def prepare_multipart_data(message: str, files: list[str | BinaryIO]) -> MultipartData:
     """Prepare multipart form data for file uploads.
 
@@ -316,49 +440,15 @@ def prepare_multipart_data(message: str, files: list[str | BinaryIO]) -> Multipa
         FileNotFoundError: When a file path doesn't exist
         ValueError: When a file object is invalid
     """
-    # Backend expects 'input' for the main prompt. Keep 'message' for
-    # backward-compatibility with any legacy handlers.
-    form_data = {"input": message, "message": message, "stream": True}
-    file_list = []
-
-    with ExitStack() as stack:
-        multipart_data = MultipartData(form_data, [])
-        multipart_data._exit_stack = stack
-
-        for file_item in files:
-            if isinstance(file_item, str):
-                # File path - let httpx stream the file handle
-                file_path = Path(file_item)
-                if not file_path.exists():
-                    raise FileNotFoundError(f"File not found: {file_item}")
-
-                # Open file and register for cleanup
-                fh = stack.enter_context(open(file_path, "rb"))
-                file_list.append(
-                    (
-                        "files",
-                        (
-                            file_path.name,
-                            fh,
-                            "application/octet-stream",
-                        ),
-                    )
-                )
-            else:
-                # File-like object
-                if hasattr(file_item, "name"):
-                    filename = getattr(file_item, "name", "file")
-                else:
-                    filename = "file"
-
-                if hasattr(file_item, "read"):
-                    # For file-like objects, we need to read them since httpx expects bytes
-                    file_content = file_item.read()
-                    file_list.append(
-                        ("files", (filename, file_content, "application/octet-stream"))
-                    )
-                else:
-                    raise ValueError(f"Invalid file object: {file_item}")
-
-        multipart_data.files = file_list
+    form_data = _create_form_data(message)
+    stack = ExitStack()
+    multipart_data = MultipartData(form_data, [])
+    multipart_data._exit_stack = stack
+
+    try:
+        file_entries = [_prepare_file_entry(item, stack) for item in files]
+        multipart_data.files = file_entries
         return multipart_data
+    except Exception:
+        stack.close()
+        raise

glaip_sdk/utils/display.py

@@ -4,6 +4,8 @@ Authors:
     Raymond Christopher (raymond.christopher@gdplabs.id)
 """
 
+from typing import Any
+
 from glaip_sdk.utils.rich_utils import RICH_AVAILABLE
 
 
@@ -34,7 +36,7 @@ def print_agent_output(output: str, title: str = "Agent Output") -> None:
         print("=" * (len(title) + 8))
 
 
-def print_agent_created(agent, title: str = "🤖 Agent Created") -> None:
+def print_agent_created(agent: Any, title: str = "🤖 Agent Created") -> None:
     """Print agent creation success with rich formatting.
 
     Args:
@@ -68,7 +70,7 @@ def print_agent_created(agent, title: str = "🤖 Agent Created") -> None:
         print(f"Version: {getattr(agent, 'version', '1.0')}")
 
 
-def print_agent_updated(agent) -> None:
+def print_agent_updated(agent: Any) -> None:
     """Print agent update success with rich formatting.
 
     Args:

glaip_sdk/utils/general.py

@@ -5,7 +5,9 @@ Authors:
 """
 
 import re
+from collections.abc import Iterable, Iterator
 from datetime import datetime
+from typing import Any
 from uuid import UUID
 
 import click
@@ -58,7 +60,7 @@ def format_file_size(size_bytes: int) -> str:
     return f"{size_bytes:.1f} TB"
 
 
-def format_datetime(dt):
+def format_datetime(dt: datetime | str | None) -> str:
     """Format datetime object to readable string.
 
     Args:
@@ -74,7 +76,9 @@ def format_datetime(dt):
     return str(dt)
 
 
-def progress_bar(iterable, description: str = "Processing"):
+def progress_bar(
+    iterable: Iterable[Any], description: str = "Processing"
+) -> Iterator[Any]:
     """Simple progress bar using click.
 
     Args:
@@ -86,9 +90,7 @@ def progress_bar(iterable, description: str = "Processing"):
     """
     try:
         with click.progressbar(iterable, label=description) as bar:
-            for item in bar:
-                yield item
+            yield from bar
     except ImportError:
         # Fallback if click not available
-        for item in iterable:
-            yield item
+        yield from iterable

glaip_sdk/utils/import_export.py

@@ -40,7 +40,9 @@ def extract_ids_from_export(items: list[Any]) -> list[str]:
     return ids
 
 
-def convert_export_to_import_format(data: dict[str, Any]) -> dict[str, Any]:
+def convert_export_to_import_format(
+    data: dict[str, Any],
+) -> dict[str, Any]:
     """Convert export format to import-compatible format (extract IDs from objects).
 
     Args:
@@ -66,6 +68,58 @@ def convert_export_to_import_format(data: dict[str, Any]) -> dict[str, Any]:
     return import_data
 
 
+def _get_default_array_fields() -> list[str]:
+    """Get default array fields that should be merged."""
+    return ["tools", "agents"]
+
+
+def _should_use_cli_value(cli_value: Any) -> bool:
+    """Check if CLI value should be used."""
+    return cli_value is not None and (
+        not isinstance(cli_value, list | tuple) or len(cli_value) > 0
+    )
+
+
+def _handle_array_field_merge(
+    key: str, cli_value: Any, import_data: dict[str, Any]
+) -> Any:
+    """Handle merging of array fields."""
+    import_value = import_data[key]
+    if isinstance(import_value, list):
+        return list(cli_value) + import_value
+    else:
+        return cli_value
+
+
+def _merge_cli_values_with_import(
+    merged: dict[str, Any],
+    cli_args: dict[str, Any],
+    import_data: dict[str, Any],
+    array_fields: list[str],
+) -> None:
+    """Merge CLI values into merged dict."""
+    for key, cli_value in cli_args.items():
+        if _should_use_cli_value(cli_value):
+            # CLI value takes precedence (for non-empty values)
+            if key in array_fields and key in import_data:
+                # For array fields, combine CLI and imported values
+                merged[key] = _handle_array_field_merge(key, cli_value, import_data)
+            else:
+                merged[key] = cli_value
+        elif key in import_data:
+            # Use imported value if no CLI value
+            merged[key] = import_data[key]
+
+
+def _add_import_only_fields(
+    merged: dict[str, Any], import_data: dict[str, Any]
+) -> None:
+    """Add fields that exist only in import data."""
+    for key, import_value in import_data.items():
+        if key not in merged:
+            merged[key] = import_value
+
+
 def merge_import_with_cli_args(
     import_data: dict[str, Any],
     cli_args: dict[str, Any],
@@ -87,32 +141,11 @@ def merge_import_with_cli_args(
         - Empty arrays/lists are treated as None (no override)
     """
     if array_fields is None:
-        array_fields = ["tools", "agents"]
+        array_fields = _get_default_array_fields()
 
     merged = {}
-
-    for key, cli_value in cli_args.items():
-        if cli_value is not None and (
-            not isinstance(cli_value, list | tuple) or len(cli_value) > 0
-        ):
-            # CLI value takes precedence (for non-empty values)
-            if key in array_fields and key in import_data:
-                # For array fields, combine CLI and imported values
-                import_value = import_data[key]
-                if isinstance(import_value, list):
-                    merged[key] = list(cli_value) + import_value
-                else:
-                    merged[key] = cli_value
-            else:
-                merged[key] = cli_value
-        elif key in import_data:
-            # Use imported value if no CLI value
-            merged[key] = import_data[key]
-
-    # Add any import-only fields
-    for key, import_value in import_data.items():
-        if key not in merged:
-            merged[key] = import_value
+    _merge_cli_values_with_import(merged, cli_args, import_data, array_fields)
+    _add_import_only_fields(merged, import_data)
 
     return merged
 

glaip_sdk/utils/rendering/formatting.py

@@ -8,6 +8,8 @@ from __future__ import annotations
 
 import re
 import time
+from collections.abc import Callable
+from typing import Any
 
 # Constants for argument formatting
 DEFAULT_ARGS_MAX_LEN = 100
@@ -65,9 +67,7 @@ def redact_sensitive(text: str | dict | list) -> str | dict | list:
                 for sensitive in ["password", "secret", "token", "key", "api_key"]
             ):
                 result[key] = "••••••"
-            elif isinstance(value, dict | list):
-                result[key] = redact_sensitive(value)
-            elif isinstance(value, str):
+            elif isinstance(value, dict | list) or isinstance(value, str):
                 result[key] = redact_sensitive(value)
             else:
                 result[key] = value
@@ -156,7 +156,7 @@ def get_step_icon(step_kind: str) -> str:
     return ""
 
 
-def is_step_finished(step) -> bool:
+def is_step_finished(step: Any) -> bool:
     """Check if a step is finished.
 
     Args:
@@ -169,7 +169,9 @@ def is_step_finished(step) -> bool:
 
 
 def format_main_title(
-    header_text: str, has_running_steps: bool, get_spinner_char: callable
+    header_text: str,
+    has_running_steps: bool,
+    get_spinner_char: Callable[[], str],
 ) -> str:
     """Generate the main panel title with dynamic status indicators.
 
@@ -191,7 +193,11 @@ def format_main_title(
 
 
 def print_header_once(
-    console, text: str, last_header: str, rules_enabled: bool, style: str | None = None
+    console: Any,
+    text: str,
+    last_header: str,
+    rules_enabled: bool,
+    style: str | None = None,
 ) -> str:
     """Print header text only when it changes to avoid duplicate output.
 

glaip_sdk/utils/rendering/models.py

@@ -25,7 +25,7 @@ class Step:
     started_at: float = field(default_factory=monotonic)
     duration_ms: int | None = None
 
-    def finish(self, duration_raw: float | None):
+    def finish(self, duration_raw: float | None) -> None:
         if isinstance(duration_raw, int | float) and duration_raw > 0:
             # Use provided duration if it's a positive number (even if very small)
             self.duration_ms = round(float(duration_raw) * 1000)