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

glaip_sdk/client/tools.py

@@ -208,6 +208,44 @@ class ToolClient(BaseClient):
 
         return payload
 
+    def _handle_description_update(
+        self, update_data: dict[str, Any], description: str | None, current_tool: Tool
+    ) -> None:
+        """Handle description field in update payload."""
+        if description is not None:
+            update_data["description"] = description.strip()
+        elif hasattr(current_tool, "description") and current_tool.description:
+            update_data["description"] = current_tool.description
+
+    def _handle_tags_update(
+        self, update_data: dict[str, Any], kwargs: dict[str, Any], current_tool: Tool
+    ) -> None:
+        """Handle tags field in update payload."""
+        if kwargs.get("tags"):
+            if isinstance(kwargs["tags"], list):
+                update_data["tags"] = ",".join(
+                    str(tag).strip() for tag in kwargs["tags"]
+                )
+            else:
+                update_data["tags"] = str(kwargs["tags"])
+        elif hasattr(current_tool, "tags") and current_tool.tags:
+            # Preserve existing tags if present
+            if isinstance(current_tool.tags, list):
+                update_data["tags"] = ",".join(
+                    str(tag).strip() for tag in current_tool.tags
+                )
+            else:
+                update_data["tags"] = str(current_tool.tags)
+
+    def _handle_additional_kwargs(
+        self, update_data: dict[str, Any], kwargs: dict[str, Any]
+    ) -> None:
+        """Handle additional kwargs in update payload."""
+        excluded_keys = {"tags", "framework", "version"}
+        for key, value in kwargs.items():
+            if key not in excluded_keys:
+                update_data[key] = value
+
     def _build_update_payload(
         self,
         current_tool: Tool,
@@ -242,34 +280,14 @@ class ToolClient(BaseClient):
             ),
         }
 
-        # Handle description with proper None handling
-        if description is not None:
-            update_data["description"] = description.strip()
-        elif hasattr(current_tool, "description") and current_tool.description:
-            update_data["description"] = current_tool.description
+        # Handle description update
+        self._handle_description_update(update_data, description, current_tool)
 
-        # Handle tags - convert list to comma-separated string for API
-        if kwargs.get("tags"):
-            if isinstance(kwargs["tags"], list):
-                update_data["tags"] = ",".join(
-                    str(tag).strip() for tag in kwargs["tags"]
-                )
-            else:
-                update_data["tags"] = str(kwargs["tags"])
-        elif hasattr(current_tool, "tags") and current_tool.tags:
-            # Preserve existing tags if present
-            if isinstance(current_tool.tags, list):
-                update_data["tags"] = ",".join(
-                    str(tag).strip() for tag in current_tool.tags
-                )
-            else:
-                update_data["tags"] = str(current_tool.tags)
+        # Handle tags update
+        self._handle_tags_update(update_data, kwargs, current_tool)
 
-        # Add any other kwargs (excluding already handled ones)
-        excluded_keys = {"tags", "framework", "version"}
-        for key, value in kwargs.items():
-            if key not in excluded_keys:
-                update_data[key] = value
+        # Handle additional kwargs
+        self._handle_additional_kwargs(update_data, kwargs)
 
         return update_data
 

glaip_sdk/models.py

@@ -119,6 +119,7 @@ class Tool(BaseModel):
     version: str | None = None
     tool_script: str | None = None
     tool_file: str | None = None
+    tags: str | list[str] | None = None
     _client: Any = None  # Will hold client reference
 
     def _set_client(self, client: Any) -> "Tool":

glaip_sdk/utils/client_utils.py

@@ -246,6 +246,33 @@ 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 = None,
@@ -276,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)
@@ -329,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
@@ -352,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.
 
@@ -366,63 +440,13 @@ 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
     """
-
-    def _prepare_path_entry(
-        path_str: str, stack: ExitStack
-    ) -> tuple[str, tuple[str, BinaryIO, str]]:
-        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]]:
-        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",
-            ),
-        )
-
-    # Backend expects 'input' for the main prompt. Keep 'message' for
-    # backward-compatibility with any legacy handlers.
-    form_data = {"input": message, "message": message, "stream": True}
+    form_data = _create_form_data(message)
     stack = ExitStack()
     multipart_data = MultipartData(form_data, [])
     multipart_data._exit_stack = stack
 
     try:
-        file_entries = []
-        for item in files:
-            if isinstance(item, str):
-                file_entries.append(_prepare_path_entry(item, stack))
-            else:
-                file_entries.append(_prepare_stream_entry(item))
-
+        file_entries = [_prepare_file_entry(item, stack) for item in files]
         multipart_data.files = file_entries
         return multipart_data
     except Exception:

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: