glaip-sdk 0.6.22__py3-none-any.whl → 0.6.24__py3-none-any.whl

glaip_sdk/agents/base.py

@@ -55,6 +55,7 @@ from glaip_sdk.registry import get_agent_registry, get_mcp_registry, get_tool_re
 from glaip_sdk.utils.resource_refs import is_uuid
 
 if TYPE_CHECKING:
+    from glaip_sdk.client.schedules import AgentScheduleManager
     from glaip_sdk.models import AgentResponse
     from glaip_sdk.registry import AgentRegistry, MCPRegistry, ToolRegistry
 
@@ -844,6 +845,36 @@ class Agent:
         self._client = client
         return self
 
+    @property
+    def schedule(self) -> AgentScheduleManager:
+        """Get the schedule manager for this agent.
+
+        Provides a convenient interface for managing schedules scoped to this agent.
+
+        Returns:
+            AgentScheduleManager for schedule operations
+
+        Raises:
+            ValueError: If agent is not deployed
+            RuntimeError: If agent is not bound to a client
+
+        Example:
+            >>> agent = client.get_agent_by_id("agent-id")
+            >>> schedules = agent.schedule.list()
+            >>> new_schedule = agent.schedule.create(
+            ...     input="Daily task",
+            ...     schedule="0 9 * * 1-5"
+            ... )
+        """
+        if not self.id:
+            raise ValueError(_AGENT_NOT_DEPLOYED_MSG)
+        if not self._client:
+            raise RuntimeError(_CLIENT_NOT_AVAILABLE_MSG)
+
+        from glaip_sdk.client.schedules import AgentScheduleManager  # noqa: PLC0415
+
+        return AgentScheduleManager(self, self._client.schedules)
+
     def _prepare_run_kwargs(
         self,
         message: str,

glaip_sdk/client/__init__.py

@@ -7,5 +7,6 @@ Authors:
 
 from glaip_sdk.client.agent_runs import AgentRunsClient
 from glaip_sdk.client.main import Client
+from glaip_sdk.client.schedules import AgentScheduleManager, ScheduleClient
 
-__all__ = ["AgentRunsClient", "Client"]
+__all__ = ["AgentRunsClient", "AgentScheduleManager", "Client", "ScheduleClient"]

glaip_sdk/client/_schedule_payloads.py

@@ -0,0 +1,89 @@
+"""Schedule request payload builders for AIP SDK.
+
+Authors:
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+"""
+
+from dataclasses import dataclass
+from typing import Any
+
+from glaip_sdk.models.schedule import ScheduleConfig
+
+
+@dataclass
+class ScheduleListParams:
+    """Parameters for listing schedules.
+
+    Args:
+        limit: Maximum number of schedules to return (1-100, default 50)
+        page: Page number for pagination (default 1)
+        agent_id: Filter schedules by agent ID
+    """
+
+    limit: int | None = None
+    page: int | None = None
+    agent_id: str | None = None
+
+    def to_query_params(self) -> dict[str, Any]:
+        """Convert to query parameters dictionary.
+
+        Returns:
+            Dictionary of non-None parameters for the API request
+        """
+        params: dict[str, Any] = {}
+        if self.limit is not None:
+            params["limit"] = self.limit
+        if self.page is not None:
+            params["page"] = self.page
+        if self.agent_id is not None:
+            params["agent_id"] = self.agent_id
+        return params
+
+
+def normalize_schedule(
+    schedule: ScheduleConfig | dict[str, str] | str | None,
+) -> dict[str, str] | None:
+    """Normalize schedule input to a dictionary for API requests.
+
+    Accepts multiple input formats for user convenience:
+    - ScheduleConfig: Pydantic model with cron fields
+    - dict: Dictionary with cron fields (minute, hour, etc.)
+    - str: Cron string like "0 9 * * 1-5"
+    - None: Returns None
+
+    Args:
+        schedule: Schedule in various formats
+
+    Returns:
+        Dictionary suitable for API request or None
+
+    Raises:
+        ValueError: If cron string format is invalid
+        TypeError: If schedule is an unsupported type
+
+    Examples:
+        >>> normalize_schedule(ScheduleConfig(minute="0", hour="9"))
+        {'minute': '0', 'hour': '9', 'day_of_month': '*', 'month': '*', 'day_of_week': '*'}
+
+        >>> normalize_schedule({"minute": "0", "hour": "9"})
+        {'minute': '0', 'hour': '9', 'day_of_month': '*', 'month': '*', 'day_of_week': '*'}
+
+        >>> normalize_schedule("0 9 * * 1-5")
+        {'minute': '0', 'hour': '9', 'day_of_month': '*', 'month': '*', 'day_of_week': '1-5'}
+    """
+    if schedule is None:
+        return None
+
+    if isinstance(schedule, ScheduleConfig):
+        return schedule.model_dump()
+
+    if isinstance(schedule, dict):
+        # Validate and merge with defaults
+        return ScheduleConfig(**schedule).model_dump()
+
+    if isinstance(schedule, str):
+        # Parse cron string
+        config = ScheduleConfig.from_cron_string(schedule)
+        return config.model_dump()
+
+    raise TypeError(f"schedule must be ScheduleConfig, dict, or str, got {type(schedule).__name__}")

glaip_sdk/client/agents.py

@@ -13,7 +13,10 @@ from collections.abc import AsyncGenerator, Callable, Iterator, Mapping
 from contextlib import asynccontextmanager
 from os import PathLike
 from pathlib import Path
-from typing import Any, BinaryIO
+from typing import TYPE_CHECKING, Any, BinaryIO
+
+if TYPE_CHECKING:
+    from glaip_sdk.client.schedules import ScheduleClient
 
 import httpx
 from glaip_sdk.agents import Agent
@@ -264,6 +267,7 @@ class AgentClient(BaseClient):
         self._tool_client: ToolClient | None = None
         self._mcp_client: MCPClient | None = None
         self._runs_client: AgentRunsClient | None = None
+        self._schedule_client: ScheduleClient | None = None
 
     def list_agents(
         self,
@@ -480,6 +484,20 @@ class AgentClient(BaseClient):
             self._mcp_client = MCPClient(parent_client=self)
         return self._mcp_client
 
+    @property
+    def schedules(self) -> "ScheduleClient":
+        """Get or create the schedule client instance.
+
+        Returns:
+            ScheduleClient instance.
+        """
+        if self._schedule_client is None:
+            # Import here to avoid circular import
+            from glaip_sdk.client.schedules import ScheduleClient  # noqa: PLC0415
+
+            self._schedule_client = ScheduleClient(parent_client=self)
+        return self._schedule_client
+
     def _normalise_reference_entry(
         self,
         entry: Any,

glaip_sdk/client/main.py

@@ -13,6 +13,7 @@ from typing import TYPE_CHECKING, Any
 from glaip_sdk.client.agents import AgentClient
 from glaip_sdk.client.base import BaseClient
 from glaip_sdk.client.mcps import MCPClient
+from glaip_sdk.client.schedules import ScheduleClient
 from glaip_sdk.client.shared import build_shared_config
 from glaip_sdk.client.tools import ToolClient
 
@@ -38,6 +39,7 @@ class Client(BaseClient):
         self.agents = AgentClient(**shared_config)
         self.tools = ToolClient(**shared_config)
         self.mcps = MCPClient(**shared_config)
+        self.schedules = ScheduleClient(**shared_config)
 
     # ---- Core API Methods (Public Interface) ----
 
@@ -236,6 +238,8 @@ class Client(BaseClient):
                 self.tools.http_client = self.http_client
             if hasattr(self, "mcps"):
                 self.mcps.http_client = self.http_client
+            if hasattr(self, "schedules"):
+                self.schedules.http_client = self.http_client
         except Exception:
             pass
 

glaip_sdk/client/schedules.py

@@ -0,0 +1,439 @@
+"""Schedule client for AIP SDK.
+
+Authors:
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+    Putu Ravindra Wiguna (putu.r.wiguna@gdplabs.id)
+"""
+
+from typing import TYPE_CHECKING, Any
+
+from glaip_sdk.client._schedule_payloads import ScheduleListParams, normalize_schedule
+from glaip_sdk.client.base import BaseClient
+from glaip_sdk.exceptions import APIError, NotFoundError
+from glaip_sdk.models.agent_runs import RunStatus
+from glaip_sdk.models.schedule import (
+    ScheduleConfig,
+    ScheduleResponse,
+    ScheduleRunResponse,
+    ScheduleRunResult,
+)
+from glaip_sdk.schedules import (
+    Schedule,
+    ScheduleListResult,
+    ScheduleRun,
+    ScheduleRunListResult,
+)
+
+if TYPE_CHECKING:
+    from glaip_sdk.models import Agent
+
+
+class ScheduleClient(BaseClient):
+    """Client for managing agent schedules.
+
+    Provides CRUD operations for scheduled agent executions.
+    Schedules allow agents to run automatically at specified times
+    using cron-like configurations.
+
+    Example:
+        >>> from glaip_sdk import Client
+        >>> from glaip_sdk.models.schedule import ScheduleConfig
+        >>>
+        >>> client = Client()
+        >>> # List all schedules
+        >>> result = client.schedules.list()
+        >>> for schedule in result:
+        ...     print(f"{schedule.id}: {schedule.next_run_time}")
+        >>>
+        >>> # Get a specific schedule
+        >>> schedule = client.schedules.get("schedule-id")
+        >>>
+        >>> # Create a schedule for an agent
+        >>> schedule = client.schedules.create(
+        ...     agent_id="agent-id",
+        ...     input="Generate daily report",
+        ...     schedule=ScheduleConfig(minute="0", hour="9", day_of_week="1-5")
+        ... )
+        >>>
+        >>> # Update a schedule
+        >>> schedule = client.schedules.update(
+        ...     schedule_id="schedule-id",
+        ...     input="Updated report input"
+        ... )
+        >>>
+        >>> # Delete a schedule
+        >>> client.schedules.delete("schedule-id")
+    """
+
+    def list(
+        self,
+        *,
+        limit: int | None = None,
+        page: int | None = None,
+        agent_id: str | None = None,
+    ) -> ScheduleListResult:
+        """List schedules with optional filtering and pagination.
+
+        Args:
+            limit: Maximum number of schedules to return (1-100)
+            page: Page number for pagination
+            agent_id: Filter schedules by agent ID
+
+        Returns:
+            ScheduleListResult containing schedules and pagination metadata
+        """
+        params = ScheduleListParams(limit=limit, page=page, agent_id=agent_id)
+
+        response = self._request_with_envelope(
+            "GET",
+            "/agents/schedules",
+            params=params.to_query_params(),
+        )
+
+        # Parse schedules from response data
+        schedules = [
+            Schedule.from_response(ScheduleResponse.model_validate(item), client=self)
+            for item in (response.get("data") or [])
+        ]
+
+        return ScheduleListResult(
+            items=schedules,
+            total=response.get("total"),
+            page=response.get("page"),
+            limit=response.get("limit"),
+            has_next=response.get("has_next"),
+            has_prev=response.get("has_prev"),
+        )
+
+    def get(self, schedule_id: str) -> Schedule:
+        """Get a schedule by ID.
+
+        Args:
+            schedule_id: The schedule ID to retrieve
+
+        Returns:
+            Schedule instance
+
+        Raises:
+            NotFoundError: If schedule is not found
+            AuthenticationError: If API key is invalid
+            APIError: If the API request fails
+        """
+        data = self._request("GET", f"/agents/schedules/{schedule_id}")
+
+        if data is None:
+            raise NotFoundError(f"Schedule not found: {schedule_id}")
+        return Schedule.from_response(ScheduleResponse.model_validate(data), client=self)
+
+    def create(
+        self,
+        *,
+        agent_id: str,
+        input: str,
+        schedule: ScheduleConfig | dict[str, str] | str,
+    ) -> Schedule:
+        """Create a new schedule for an agent.
+
+        Args:
+            agent_id: The agent ID to schedule
+            input: Input text for scheduled execution
+            schedule: Schedule configuration (ScheduleConfig, dict, or cron string)
+
+        Returns:
+            Created Schedule instance
+
+        Raises:
+            ValueError: If schedule format is invalid
+            NotFoundError: If agent is not found
+            ValidationError: If schedule configuration is invalid
+            AuthenticationError: If API key is invalid
+            APIError: If the API request fails
+        """
+        schedule_dict = normalize_schedule(schedule)
+        if schedule_dict is None:
+            raise ValueError("schedule is required")
+
+        payload = {
+            "input": input,
+            "schedule": schedule_dict,
+        }
+
+        response = self._request("POST", f"/agents/{agent_id}/schedule", json=payload)
+
+        # Response contains schedule_id, fetch the full schedule
+        schedule_id = response.get("schedule_id")
+        if not schedule_id:
+            raise APIError("Missing schedule_id in create response")
+
+        return self.get(schedule_id)
+
+    def update(
+        self,
+        schedule_id: str,
+        *,
+        input: str | None = None,
+        schedule: ScheduleConfig | dict[str, str] | str | None = None,
+    ) -> Schedule:
+        """Update an existing schedule.
+
+        Args:
+            schedule_id: The schedule ID to update
+            input: New input text for scheduled execution
+            schedule: New schedule configuration (ScheduleConfig, dict, or cron string)
+
+        Returns:
+            Updated Schedule instance
+
+        Raises:
+            NotFoundError: If schedule is not found
+            ValueError: If schedule config is required but not provided
+            ValidationError: If schedule configuration is invalid
+            AuthenticationError: If API key is invalid
+            APIError: If the API request fails
+
+        Note:
+            Updates use explicit replacement (not merge). The SDK normalizes partial
+            schedule dicts by filling missing cron fields with "*". This is intentional
+            for predictability - what you provide is what you get (plus wildcard defaults).
+            If the current schedule metadata is missing and no schedule parameter is
+            provided, a ValueError is raised.
+        """
+        # Get current schedule to merge with updates
+        current = self.get(schedule_id)
+
+        # Handle input - ensure we have valid input data
+        if current.input is None and input is None:
+            raise ValueError(
+                f"Schedule {schedule_id} has missing input metadata and no input parameter provided. "
+                "Please provide an input value to update this schedule."
+            )
+
+        # Handle schedule config - ensure we have complete schedule data
+        if current.schedule_config is None and schedule is None:
+            raise ValueError(
+                f"Schedule {schedule_id} has missing metadata and no schedule parameter provided. "
+                "Please provide a full schedule configuration to update this schedule."
+            )
+
+        current_input = current.input or ""
+        current_schedule = current.schedule_config.model_dump() if current.schedule_config else {}
+
+        payload: dict[str, Any] = {
+            "input": input if input is not None else current_input,
+            "schedule": normalize_schedule(schedule) or current_schedule,
+        }
+
+        data = self._request("PUT", f"/agents/schedules/{schedule_id}", json=payload)
+        return Schedule.from_response(ScheduleResponse.model_validate(data), client=self)
+
+    def delete(self, schedule_id: str) -> None:
+        """Delete a schedule.
+
+        Args:
+            schedule_id: The schedule ID to delete
+
+        Raises:
+            NotFoundError: If schedule is not found
+            AuthenticationError: If API key is invalid
+            APIError: If the API request fails
+        """
+        self._request("DELETE", f"/agents/schedules/{schedule_id}")
+
+    def list_runs(
+        self,
+        agent_id: str,
+        *,
+        schedule_id: str | None = None,
+        status: RunStatus | None = None,
+        limit: int | None = None,
+        page: int | None = None,
+    ) -> ScheduleRunListResult:
+        """List runs for an agent, optionally filtered by schedule ID.
+
+        Args:
+            agent_id: The agent ID to list runs for
+            schedule_id: Optional schedule ID to filter by
+            status: Optional status filter
+            limit: Maximum number of runs to return (1-100)
+            page: Page number for pagination
+
+        Returns:
+            ScheduleRunListResult containing runs and pagination metadata
+        """
+        params: dict[str, Any] = {"run_type": "schedule"}
+        if schedule_id is not None:
+            params["schedule_id"] = schedule_id
+        if status is not None:
+            params["status"] = status
+        if limit is not None:
+            params["limit"] = limit
+        if page is not None:
+            params["page"] = page
+
+        response = self._request_with_envelope(
+            "GET",
+            f"/agents/{agent_id}/runs",
+            params=params,
+        )
+
+        # Parse runs from response data
+        runs = [
+            ScheduleRun.from_response(ScheduleRunResponse.model_validate(item), client=self)
+            for item in (response.get("data") or [])
+        ]
+
+        return ScheduleRunListResult(
+            items=runs,
+            total=response.get("total"),
+            page=response.get("page"),
+            limit=response.get("limit"),
+            has_next=response.get("has_next"),
+            has_prev=response.get("has_prev"),
+        )
+
+    def get_run_result(self, agent_id: str, run_id: str) -> ScheduleRunResult:
+        """Get the full output payload for an agent run.
+
+        Args:
+            agent_id: The agent ID the run belongs to
+            run_id: The run ID to retrieve
+
+        Returns:
+            ScheduleRunResult containing run details and optional output
+        """
+        data = self._request("GET", f"/agents/{agent_id}/runs/{run_id}")
+        return ScheduleRunResult.model_validate(data)
+
+
+class AgentScheduleManager:
+    """Facade for agent-scoped schedule operations.
+
+    Provides a convenient interface for managing schedules through
+    an Agent instance, automatically scoping operations to that agent.
+
+    Example:
+        >>> agent = client.get_agent_by_id("agent-id")
+        >>> # List schedules for this agent
+        >>> schedules = agent.schedule.list()
+        >>> # Create a schedule for this agent
+        >>> schedule = agent.schedule.create(
+        ...     input="Daily task",
+        ...     schedule="0 9 * * 1-5"
+        ... )
+    """
+
+    def __init__(self, agent: "Agent", client: ScheduleClient) -> None:
+        """Initialize the schedule manager.
+
+        Args:
+            agent: The agent to manage schedules for
+            client: The ScheduleClient for API operations
+        """
+        self._agent = agent
+        self._client = client
+
+    def list(
+        self,
+        *,
+        limit: int | None = None,
+        page: int | None = None,
+    ) -> ScheduleListResult:
+        """List schedules for this agent.
+
+        Args:
+            limit: Maximum number of schedules to return (1-100)
+            page: Page number for pagination
+
+        Returns:
+            ScheduleListResult containing schedules for this agent
+        """
+        return self._client.list(limit=limit, page=page, agent_id=self._agent.id)
+
+    def create(
+        self,
+        *,
+        input: str,
+        schedule: ScheduleConfig | dict[str, str] | str,
+    ) -> Schedule:
+        """Create a schedule for this agent.
+
+        Args:
+            input: Input text for scheduled execution
+            schedule: Schedule configuration (ScheduleConfig, dict, or cron string)
+
+        Returns:
+            Created Schedule instance
+        """
+        return self._client.create(
+            agent_id=self._agent.id,
+            input=input,
+            schedule=schedule,
+        )
+
+    def get(self, schedule_id: str) -> Schedule:
+        """Get a schedule by ID.
+
+        Args:
+            schedule_id: The schedule ID to retrieve
+
+        Returns:
+            Schedule instance
+
+        Raises:
+            NotFoundError: If schedule is not found
+        """
+        return self._client.get(schedule_id)
+
+    def update(
+        self,
+        schedule_id: str,
+        *,
+        input: str | None = None,
+        schedule: ScheduleConfig | dict[str, str] | str | None = None,
+    ) -> Schedule:
+        """Update a schedule.
+
+        Args:
+            schedule_id: The schedule ID to update
+            input: New input text for scheduled execution
+            schedule: New schedule configuration
+
+        Returns:
+            Updated Schedule instance
+        """
+        return self._client.update(schedule_id, input=input, schedule=schedule)
+
+    def delete(self, schedule_id: str) -> None:
+        """Delete a schedule.
+
+        Args:
+            schedule_id: The schedule ID to delete
+        """
+        self._client.delete(schedule_id)
+
+    def list_runs(
+        self,
+        schedule_id: str | None = None,
+        *,
+        status: RunStatus | None = None,
+        limit: int | None = None,
+        page: int | None = None,
+    ) -> ScheduleRunListResult:
+        """List runs for this agent.
+
+        Args:
+            schedule_id: Optional schedule ID to filter by
+            status: Optional status filter
+            limit: Maximum number of runs to return (1-100)
+            page: Page number for pagination
+
+        Returns:
+            ScheduleRunListResult containing runs for this agent
+        """
+        return self._client.list_runs(
+            self._agent.id,
+            schedule_id=schedule_id,
+            status=status,
+            limit=limit,
+            page=page,
+        )

glaip_sdk/models/__init__.py

@@ -27,6 +27,16 @@ from glaip_sdk.models.agent_runs import (
 )
 from glaip_sdk.models.common import LanguageModelResponse, TTYRenderer
 from glaip_sdk.models.mcp import MCPResponse
+
+# Export schedule models
+from glaip_sdk.models.schedule import (  # noqa: F401
+    ScheduleConfig,
+    ScheduleMetadata,
+    ScheduleResponse,
+    ScheduleRunOutputChunk,
+    ScheduleRunResponse,
+    ScheduleRunResult,
+)
 from glaip_sdk.models.tool import ToolResponse
 
 
@@ -87,4 +97,11 @@ __all__ = [
     "RunsPage",
     "RunWithOutput",
     "RunOutputChunk",
+    # Schedule models
+    "ScheduleConfig",
+    "ScheduleMetadata",
+    "ScheduleResponse",
+    "ScheduleRunResponse",
+    "ScheduleRunOutputChunk",
+    "ScheduleRunResult",
 ]

glaip_sdk/models/agent_runs.py

@@ -13,6 +13,7 @@ from pydantic import BaseModel, Field, field_validator, model_validator
 
 # Type alias for SSE event dictionaries
 RunOutputChunk = dict[str, Any]
+RunStatus = Literal["started", "success", "failed", "cancelled", "aborted", "unavailable"]
 
 
 class RunSummary(BaseModel):
@@ -22,7 +23,7 @@ class RunSummary(BaseModel):
     agent_id: UUID
     run_type: Literal["manual", "schedule"]
     schedule_id: UUID | None = None
-    status: Literal["started", "success", "failed", "cancelled", "aborted", "unavailable"]
+    status: RunStatus
     started_at: datetime
     completed_at: datetime | None = None
     input: str | None = None

glaip_sdk/models/schedule.py

@@ -0,0 +1,224 @@
+#!/usr/bin/env python3
+"""Schedule DTO models for AIP SDK.
+
+These models represent API payloads and responses. They are intentionally DTO-only
+and do not contain runtime behavior.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+"""
+
+from datetime import datetime
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict
+
+from glaip_sdk.models.agent_runs import RunStatus
+
+
+class ScheduleConfig(BaseModel):
+    """Cron-like schedule configuration matching backend ScheduleConfig.
+
+    All fields accept cron-style values:
+    - Specific values: "0", "9", "1"
+    - Wildcards: "*"
+    - Intervals: "*/5", "*/2"
+    - Ranges: "1-5", "9-17"
+    - Lists: "1,3,5"
+
+    Note: day_of_week uses 0-6 where 0=Monday.
+    """
+
+    minute: str = "*"
+    hour: str = "*"
+    day_of_month: str = "*"
+    month: str = "*"
+    day_of_week: str = "*"
+
+    model_config = ConfigDict(from_attributes=True)
+
+    def to_cron_string(self) -> str:
+        """Convert to standard cron string format.
+
+        Returns:
+            Cron string in format "minute hour day_of_month month day_of_week"
+        """
+        return f"{self.minute} {self.hour} {self.day_of_month} {self.month} {self.day_of_week}"
+
+    @classmethod
+    def from_cron_string(cls, cron: str) -> "ScheduleConfig":
+        """Parse a cron string into ScheduleConfig.
+
+        Args:
+            cron: Cron string in format "minute hour day_of_month month day_of_week"
+
+        Returns:
+            ScheduleConfig instance
+
+        Raises:
+            ValueError: If cron string doesn't have exactly 5 fields
+        """
+        parts = cron.split()
+        if len(parts) != 5:
+            raise ValueError(f"Invalid cron string: expected 5 fields, got {len(parts)}")
+        return cls(
+            minute=parts[0],
+            hour=parts[1],
+            day_of_month=parts[2],
+            month=parts[3],
+            day_of_week=parts[4],
+        )
+
+
+class ScheduleMetadata(BaseModel):
+    """Metadata embedded in schedule responses.
+
+    Contains the agent association, input text, and cron configuration.
+    """
+
+    agent_id: str
+    input: str
+    schedule: ScheduleConfig
+
+    model_config = ConfigDict(from_attributes=True)
+
+
+class ScheduleResponse(BaseModel):
+    """Schedule response DTO.
+
+    Attributes:
+        id: Schedule ID.
+        next_run_time: Next run time as returned by the API.
+        time_until_next_run: Human-readable duration until next run.
+        metadata: Schedule metadata.
+        created_at: Creation timestamp.
+        updated_at: Update timestamp.
+        agent_id: Agent ID derived from metadata.
+        input: Input text derived from metadata.
+        schedule_config: ScheduleConfig derived from metadata.
+    """
+
+    id: str
+    next_run_time: str | None = None
+    time_until_next_run: str | None = None
+    metadata: ScheduleMetadata | None = None
+    created_at: datetime | None = None
+    updated_at: datetime | None = None
+
+    model_config = ConfigDict(from_attributes=True)
+
+    @property
+    def agent_id(self) -> str | None:
+        """Get the agent ID from metadata."""
+        return self.metadata.agent_id if self.metadata else None
+
+    @property
+    def input(self) -> str | None:
+        """Get the scheduled input text from metadata."""
+        return self.metadata.input if self.metadata else None
+
+    @property
+    def schedule_config(self) -> ScheduleConfig | None:
+        """Get the schedule configuration from metadata."""
+        return self.metadata.schedule if self.metadata else None
+
+    def __repr__(self) -> str:
+        """Return a readable representation of the schedule."""
+        parts = [f"ScheduleResponse(id={self.id!r}"]
+        if self.next_run_time:
+            parts.append(f"next_run_time={self.next_run_time!r}")
+        if self.time_until_next_run:
+            parts.append(f"time_until_next_run={self.time_until_next_run!r}")
+        if self.agent_id:
+            parts.append(f"agent_id={self.agent_id!r}")
+        if self.created_at:
+            parts.append(f"created_at={self.created_at!r}")
+        return ", ".join(parts) + ")"
+
+    def __str__(self) -> str:
+        """Return a readable string representation."""
+        return self.__repr__()
+
+
+# Type alias for SSE event dictionaries
+ScheduleRunOutputChunk = dict[str, Any]
+
+
+class ScheduleRunResponse(BaseModel):
+    """Schedule run response DTO."""
+
+    id: str
+    agent_id: str
+    schedule_id: str | None = None  # May be None for non-scheduled runs
+    status: RunStatus  # Backend uses lowercase.
+    run_type: str | None = None  # "schedule" for scheduled runs
+    started_at: datetime | None = None
+    completed_at: datetime | None = None
+    input: str | None = None  # Input used for the execution.
+    config: ScheduleConfig | dict[str, str] | None = None  # Schedule config used.
+    created_at: datetime | None = None
+    updated_at: datetime | None = None
+
+    model_config = ConfigDict(from_attributes=True, extra="ignore")
+
+    @property
+    def duration(self) -> str | None:
+        """Calculate the duration of the run.
+
+        Returns:
+            Formatted duration string (HH:MM:SS) or None if incomplete
+        """
+        if self.started_at and self.completed_at:
+            delta = self.completed_at - self.started_at
+            total_seconds = int(delta.total_seconds())
+            hours, remainder = divmod(total_seconds, 3600)
+            minutes, seconds = divmod(remainder, 60)
+            return f"{hours:02d}:{minutes:02d}:{seconds:02d}"
+        return None
+
+    def __repr__(self) -> str:
+        """Return a readable representation of the run."""
+        parts = [f"ScheduleRunResponse(id={self.id!r}"]
+        parts.append(f"status={self.status!r}")
+        if self.started_at:
+            parts.append(f"started_at={self.started_at.isoformat()!r}")
+        if self.duration:
+            parts.append(f"duration={self.duration!r}")
+        return ", ".join(parts) + ")"
+
+    def __str__(self) -> str:
+        """Return a readable string representation."""
+        return self.__repr__()
+
+
+class ScheduleRunResult(BaseModel):
+    """Full output payload for a schedule run.
+
+    Maps to the backend's AgentRunWithOutputResponse which includes
+    run metadata plus the output stream.
+    """
+
+    id: str
+    agent_id: str
+    schedule_id: str | None = None
+    status: RunStatus
+    run_type: str | None = None
+    started_at: datetime | None = None
+    completed_at: datetime | None = None
+    input: str | None = None  # Input used for the execution.
+    config: ScheduleConfig | dict[str, str] | None = None  # Schedule config used.
+    output: list[ScheduleRunOutputChunk] | None = None
+    created_at: datetime | None = None
+    updated_at: datetime | None = None
+
+    model_config = ConfigDict(from_attributes=True, extra="ignore")
+
+    def __repr__(self) -> str:
+        """Return a readable representation of the result."""
+        output_count = len(self.output) if self.output else 0
+        return f"ScheduleRunResult(id={self.id!r}, status={self.status!r}, output_chunks={output_count})"
+
+    def __str__(self) -> str:
+        """Return a readable string representation."""
+        return self.__repr__()

glaip_sdk/schedules/__init__.py

@@ -0,0 +1,22 @@
+"""Schedules runtime package.
+
+This package contains runtime schedule resource objects (class-based) that
+encapsulate behavior and API interactions via attached clients.
+
+Authors:
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+"""
+
+from glaip_sdk.schedules.base import (
+    Schedule,
+    ScheduleListResult,
+    ScheduleRun,
+    ScheduleRunListResult,
+)
+
+__all__ = [
+    "Schedule",
+    "ScheduleListResult",
+    "ScheduleRun",
+    "ScheduleRunListResult",
+]

glaip_sdk/schedules/base.py

@@ -0,0 +1,291 @@
+"""Schedule runtime resources.
+
+This module contains class-based runtime resources for schedules.
+
+The runtime resources:
+- Are not Pydantic models.
+- Are returned from public client APIs.
+- Delegate API operations to a bound ScheduleClient.
+
+Authors:
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+from glaip_sdk.models.agent_runs import RunStatus
+from glaip_sdk.models.schedule import (
+    ScheduleConfig,
+    ScheduleMetadata,
+    ScheduleResponse,
+    ScheduleRunResponse,
+    ScheduleRunResult,
+)
+
+if TYPE_CHECKING:  # pragma: no cover
+    from glaip_sdk.client.schedules import ScheduleClient
+
+_SCHEDULE_CLIENT_REQUIRED_MSG = "No client available. Use client.schedules.get() to get a client-connected schedule."
+_SCHEDULE_RUN_CLIENT_REQUIRED_MSG = (
+    "No client available. Use client.schedules.list_runs() to get a client-connected schedule run."
+)
+
+
+class Schedule:
+    """Runtime schedule resource.
+
+    Attributes:
+        id (str): The schedule ID.
+        next_run_time (str | None): Next run time as returned by the API.
+        time_until_next_run (str | None): Human readable duration until next run.
+        metadata (ScheduleMetadata | None): Schedule metadata.
+        created_at (datetime | None): Creation timestamp.
+        updated_at (datetime | None): Update timestamp.
+    """
+
+    def __init__(
+        self,
+        *,
+        id: str,
+        next_run_time: str | None = None,
+        time_until_next_run: str | None = None,
+        metadata: ScheduleMetadata | None = None,
+        created_at: datetime | None = None,
+        updated_at: datetime | None = None,
+        _client: ScheduleClient | None = None,
+    ) -> None:
+        """Initialize a runtime Schedule."""
+        self.id = id
+        self.next_run_time = next_run_time
+        self.time_until_next_run = time_until_next_run
+        self.metadata = metadata
+        self.created_at = created_at
+        self.updated_at = updated_at
+        self._client = _client
+
+    @classmethod
+    def from_response(cls, response: ScheduleResponse, *, client: ScheduleClient) -> Schedule:
+        """Build a runtime Schedule from a DTO response.
+
+        Args:
+            response: Parsed schedule response DTO.
+            client: ScheduleClient to bind.
+
+        Returns:
+            Runtime Schedule.
+        """
+        return cls(
+            id=response.id,
+            next_run_time=response.next_run_time,
+            time_until_next_run=response.time_until_next_run,
+            metadata=response.metadata,
+            created_at=response.created_at,
+            updated_at=response.updated_at,
+            _client=client,
+        )
+
+    @property
+    def agent_id(self) -> str | None:
+        """Agent ID derived from metadata."""
+        return self.metadata.agent_id if self.metadata else None
+
+    @property
+    def input(self) -> str | None:
+        """Input text derived from metadata."""
+        return self.metadata.input if self.metadata else None
+
+    @property
+    def schedule_config(self) -> ScheduleConfig | None:
+        """Schedule configuration derived from metadata."""
+        return self.metadata.schedule if self.metadata else None
+
+    def update(
+        self,
+        *,
+        input: str | None = None,
+        schedule: ScheduleConfig | dict[str, str] | str | None = None,
+    ) -> Schedule:
+        """Update this schedule."""
+        if self._client is None:
+            raise RuntimeError(_SCHEDULE_CLIENT_REQUIRED_MSG)
+        return self._client.update(self.id, input=input, schedule=schedule)
+
+    def delete(self) -> None:
+        """Delete this schedule."""
+        if self._client is None:
+            raise RuntimeError(_SCHEDULE_CLIENT_REQUIRED_MSG)
+        self._client.delete(self.id)
+
+    def list_runs(
+        self,
+        *,
+        status: RunStatus | None = None,
+        limit: int | None = None,
+        page: int | None = None,
+    ) -> ScheduleRunListResult:
+        """List runs for this schedule."""
+        if self._client is None:
+            raise RuntimeError(_SCHEDULE_CLIENT_REQUIRED_MSG)
+        if self.agent_id is None:
+            raise ValueError("Schedule has no agent_id")
+        return self._client.list_runs(
+            self.agent_id,
+            schedule_id=self.id,
+            status=status,
+            limit=limit,
+            page=page,
+        )
+
+    def __repr__(self) -> str:
+        """Return a developer-friendly representation."""
+        parts: list[str] = [f"id={self.id!r}"]
+        if self.agent_id is not None:
+            parts.append(f"agent_id={self.agent_id!r}")
+        if self.next_run_time is not None:
+            parts.append(f"next_run_time={self.next_run_time!r}")
+        if self.time_until_next_run is not None:
+            parts.append(f"time_until_next_run={self.time_until_next_run!r}")
+        if self.created_at is not None:
+            parts.append(f"created_at={self.created_at!r}")
+        return f"Schedule({', '.join(parts)})"
+
+    def __str__(self) -> str:
+        """Return a readable string representation."""
+        return self.__repr__()
+
+
+class ScheduleRun:
+    """Runtime schedule run resource."""
+
+    def __init__(
+        self,
+        *,
+        id: str,
+        agent_id: str,
+        schedule_id: str | None = None,
+        status: RunStatus,
+        run_type: str | None = None,
+        started_at: datetime | None = None,
+        completed_at: datetime | None = None,
+        input: str | None = None,
+        config: ScheduleConfig | dict[str, str] | None = None,
+        created_at: datetime | None = None,
+        updated_at: datetime | None = None,
+        _client: ScheduleClient | None = None,
+    ) -> None:
+        """Initialize a runtime ScheduleRun."""
+        self.id = id
+        self.agent_id = agent_id
+        self.schedule_id = schedule_id
+        self.status = status
+        self.run_type = run_type
+        self.started_at = started_at
+        self.completed_at = completed_at
+        self.input = input
+        self.config = config
+        self.created_at = created_at
+        self.updated_at = updated_at
+        self._client = _client
+
+    @classmethod
+    def from_response(cls, response: ScheduleRunResponse, *, client: ScheduleClient) -> ScheduleRun:
+        """Build a runtime ScheduleRun from a DTO response."""
+        return cls(
+            id=response.id,
+            agent_id=response.agent_id,
+            schedule_id=response.schedule_id,
+            status=response.status,
+            run_type=response.run_type,
+            started_at=response.started_at,
+            completed_at=response.completed_at,
+            input=response.input,
+            config=response.config,
+            created_at=response.created_at,
+            updated_at=response.updated_at,
+            _client=client,
+        )
+
+    def get_result(self) -> ScheduleRunResult:
+        """Retrieve the full output payload for this run."""
+        if self._client is None:
+            raise RuntimeError(_SCHEDULE_RUN_CLIENT_REQUIRED_MSG)
+        if self.agent_id is None:
+            raise ValueError("Schedule run has no agent_id")
+        return self._client.get_run_result(self.agent_id, self.id)
+
+    @property
+    def duration(self) -> str | None:
+        """Formatted duration (HH:MM:SS) when both timestamps are available."""
+        if not self.started_at or not self.completed_at:
+            return None
+
+        total_seconds = int((self.completed_at - self.started_at).total_seconds())
+        minutes, seconds = divmod(total_seconds, 60)
+        hours, minutes = divmod(minutes, 60)
+        return f"{hours:02d}:{minutes:02d}:{seconds:02d}"
+
+    def __repr__(self) -> str:
+        """Return a developer-friendly representation."""
+        parts: list[str] = [f"id={self.id!r}", f"status={self.status!r}"]
+        if self.started_at is not None:
+            parts.append(f"started_at={self.started_at.isoformat()!r}")
+        duration = self.duration
+        if duration is not None:
+            parts.append(f"duration={duration!r}")
+        return f"ScheduleRun({', '.join(parts)})"
+
+    def __str__(self) -> str:
+        """Return a readable string representation."""
+        return self.__repr__()
+
+
+@dataclass
+class ScheduleListResult:
+    """Paginated list wrapper for runtime schedules."""
+
+    items: list[Schedule]
+    total: int | None = field(default=None)
+    page: int | None = field(default=None)
+    limit: int | None = field(default=None)
+    has_next: bool | None = field(default=None)
+    has_prev: bool | None = field(default=None)
+
+    def __iter__(self):
+        """Iterate over schedules."""
+        yield from self.items
+
+    def __len__(self) -> int:
+        """Return the number of schedules in this page."""
+        return self.items.__len__()
+
+    def __getitem__(self, index: int) -> Schedule:
+        """Return the schedule at the given index."""
+        return self.items[index]
+
+
+@dataclass
+class ScheduleRunListResult:
+    """Paginated list wrapper for runtime schedule runs."""
+
+    items: list[ScheduleRun]
+    total: int | None = field(default=None)
+    page: int | None = field(default=None)
+    limit: int | None = field(default=None)
+    has_next: bool | None = field(default=None)
+    has_prev: bool | None = field(default=None)
+
+    def __iter__(self):
+        """Iterate over schedule runs."""
+        yield from self.items
+
+    def __len__(self) -> int:
+        """Return the number of runs in this page."""
+        return self.items.__len__()
+
+    def __getitem__(self, index: int) -> ScheduleRun:
+        """Return the run at the given index."""
+        return self.items[index]

{glaip_sdk-0.6.22.dist-info → glaip_sdk-0.6.24.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: glaip-sdk
-Version: 0.6.22
+Version: 0.6.24
 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
@@ -20,12 +20,11 @@ Requires-Dist: gllm-core-binary>=0.1.0
 Requires-Dist: langchain-core>=0.3.0
 Requires-Dist: gllm-tools-binary>=0.1.3
 Provides-Extra: local
-Requires-Dist: aip-agents-binary[local]>=0.5.17; (python_version >= "3.11" and python_version < "3.13") and extra == "local"
-Requires-Dist: gllm-docproc[docx,pdf,xlsx]<0.8.0,>=0.7.20; extra == "local"
+Requires-Dist: aip-agents-binary[local]>=0.5.18; (python_version >= "3.11" and python_version < "3.13") and extra == "local"
 Provides-Extra: memory
-Requires-Dist: aip-agents-binary[memory]>=0.5.17; (python_version >= "3.11" and python_version < "3.13") and extra == "memory"
+Requires-Dist: aip-agents-binary[memory]>=0.5.18; (python_version >= "3.11" and python_version < "3.13") and extra == "memory"
 Provides-Extra: privacy
-Requires-Dist: aip-agents-binary[privacy]>=0.5.17; (python_version >= "3.11" and python_version < "3.13") and extra == "privacy"
+Requires-Dist: aip-agents-binary[privacy]>=0.5.18; (python_version >= "3.11" and python_version < "3.13") and extra == "privacy"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"

{glaip_sdk-0.6.22.dist-info → glaip_sdk-0.6.24.dist-info}/RECORD

@@ -5,7 +5,7 @@ glaip_sdk/exceptions.py,sha256=iAChFClkytXRBLP0vZq1_YjoZxA9i4m4bW1gDLiGR1g,2321
 glaip_sdk/icons.py,sha256=J5THz0ReAmDwIiIooh1_G3Le-mwTJyEjhJDdJ13KRxM,524
 glaip_sdk/rich_components.py,sha256=44Z0V1ZQleVh9gUDGwRR5mriiYFnVGOhm7fFxZYbP8c,4052
 glaip_sdk/agents/__init__.py,sha256=VfYov56edbWuySXFEbWJ_jLXgwnFzPk1KB-9-mfsUCc,776
-glaip_sdk/agents/base.py,sha256=_KfxI11vM3GaABN5o7hxD2f1Wv7nalCivC11J3wh0VM,42502
+glaip_sdk/agents/base.py,sha256=D3Ll2l_uxv2kIwPCuDhfy_bbSxHrHPaxp6op2c7TBl0,43580
 glaip_sdk/cli/__init__.py,sha256=xCCfuF1Yc7mpCDcfhHZTX0vizvtrDSLeT8MJ3V7m5A0,156
 glaip_sdk/cli/account_store.py,sha256=TK4iTV93Q1uD9mCY_2ZMT6EazHKU2jX0qhgWfEM4V-4,18459
 glaip_sdk/cli/agent_config.py,sha256=YAbFKrTNTRqNA6b0i0Q3pH-01rhHDRi5v8dxSFwGSwM,2401
@@ -61,14 +61,16 @@ glaip_sdk/cli/transcript/export.py,sha256=reCvrZVzli8_LzYe5ZNdaa-MwZ1ov2RjnDzKZW
 glaip_sdk/cli/transcript/history.py,sha256=IAUaY41QCr9jKgQ1t8spDJiO3Me5r1vAoTX47QQu5z0,26217
 glaip_sdk/cli/transcript/launcher.py,sha256=z5ivkPXDQJpATIqtRLUK8jH3p3WIZ72PvOPqYRDMJvw,2327
 glaip_sdk/cli/transcript/viewer.py,sha256=Y4G40WR6v1g4TfxRbGSZqdrqhLcqBxoWkQgToQoGGxM,13198
-glaip_sdk/client/__init__.py,sha256=F-eE_dRSzA0cc1it06oi0tZetZBHmSUjWSHGhJMLCls,263
+glaip_sdk/client/__init__.py,sha256=s2REOumgE8Z8lA9dWJpwXqpgMdzSELSuCQkZ7sYngX0,381
 glaip_sdk/client/_agent_payloads.py,sha256=cH7CvNRn0JvudwKLr072E7W2QGWO9r-4xDxWMvXoPKE,17865
+glaip_sdk/client/_schedule_payloads.py,sha256=9BXa75CCx3clsKgwmG9AWyvhPY6kVwzQtoLvTTw40CQ,2759
 glaip_sdk/client/agent_runs.py,sha256=tZSFEZZ3Yx0uYRgnwkLe-X0TlmgKJQ-ivzb6SrVnxY8,4862
-glaip_sdk/client/agents.py,sha256=75uDLN85Smf67rw-jFhlVKyiToicAfcFyJHSvWJkAww,47631
+glaip_sdk/client/agents.py,sha256=s1qhn48mTP-lqx5HXbxznE5v5ZtibytrJ2qeR0qJcP0,48250
 glaip_sdk/client/base.py,sha256=BhNaC2TJJ2jVWRTYmfxD3WjYgAyIuWNz9YURdNXXjJo,18245
-glaip_sdk/client/main.py,sha256=RTREAOgGouYm4lFKkpNBQ9dmxalnBsIpSSaQLWVFSmU,9054
+glaip_sdk/client/main.py,sha256=wFJzPRagudeOBDWbANIuRKzZi4RsPcQaaggPfj6NL80,9270
 glaip_sdk/client/mcps.py,sha256=gFRuLOGeh6ieIhR4PeD6yNVT6NhvUMTqPq9iuu1vkAY,13019
 glaip_sdk/client/run_rendering.py,sha256=kERp78v50jojsNWHrjNEkbC8sgOpMacaqUdw5YZuK6A,26074
+glaip_sdk/client/schedules.py,sha256=ZfPzCYzk4YRuPkjkTTgLe5Rqa07mi-h2WmP4H91mMZ0,14113
 glaip_sdk/client/shared.py,sha256=esHlsR0LEfL-pFDaWebQjKKOLl09jsRY-2pllBUn4nU,522
 glaip_sdk/client/tools.py,sha256=kK0rBwX1e_5AlGQRjlO6rNz6gDlohhXWdlxN9AwotdE,22585
 glaip_sdk/client/validators.py,sha256=ioF9VCs-LG2yLkaRDd7Hff74lojDZZ0_Q3CiLbdm1RY,8381
@@ -77,11 +79,12 @@ glaip_sdk/hitl/__init__.py,sha256=sg92Rpu8_vJIGi1ZEhx0-qWa1nGdvfrKyJAxtoDSKzo,49
 glaip_sdk/hitl/local.py,sha256=rzmaRK15BxgRX7cmklUcGQUotMYg8x2Gd9BWf39k6hw,5661
 glaip_sdk/mcps/__init__.py,sha256=4jYrt8K__oxrxexHRcmnRBXt-W_tbJN61H9Kf2lVh4Q,551
 glaip_sdk/mcps/base.py,sha256=jWwHjDF67_mtDGRp9p5SolANjVeB8jt1PSwPBtX876M,11654
-glaip_sdk/models/__init__.py,sha256=-qO4Yr1-fkyaYC9RcT3nYhplDjoXATrIFZr4JrqflHI,2577
+glaip_sdk/models/__init__.py,sha256=Yfy5CKe9xt3MkyoRIiZ4PYy19LbEfv3GXi2PgqXW7iU,2973
 glaip_sdk/models/agent.py,sha256=vtmUSDrrib1hvm0xnofIuOebqlrs-gIaLsny8hzg1iE,1523
-glaip_sdk/models/agent_runs.py,sha256=MYgab07k8MfExjvI5_o6HxsksJZ3tl2TDZefVxzGc1g,3807
+glaip_sdk/models/agent_runs.py,sha256=rK0fTpivukyiqIxrS86evgNtfEwV8Xecq_NeUakFUFw,3829
 glaip_sdk/models/common.py,sha256=O30MEGO2nKcGhKbnPNkoGzwNvDVUBjM-uU-Tpigaz5Y,1180
 glaip_sdk/models/mcp.py,sha256=ti_8MUf4k7qbR1gPs9JhqhybMcLUhZxEELtHQrTv2-U,944
+glaip_sdk/models/schedule.py,sha256=gfL_b9abaWToMtnCD_iXOsmonQ1sq2dZoLcInvCzZ2o,7248
 glaip_sdk/models/tool.py,sha256=w3nL2DqyCtGgDPCd40Asi9obRGghQjLlC9Vt_p32Mpc,951
 glaip_sdk/payload_schemas/__init__.py,sha256=nTJmzwn2BbEpzZdq-8U24eVHQHxqYO3_-SABMV9lS_Q,142
 glaip_sdk/payload_schemas/agent.py,sha256=Nap68mI2Ba8eNGOhk79mGrYUoYUahcUJLof3DLWtVO4,3198
@@ -101,6 +104,8 @@ glaip_sdk/runner/mcp_adapter/mcp_config_builder.py,sha256=fQcRaueDuyUzXUSVn9N8Qx
 glaip_sdk/runner/tool_adapter/__init__.py,sha256=scv8sSPxSWjlSNEace03R230YbmWgphLgqINKvDjWmM,480
 glaip_sdk/runner/tool_adapter/base_tool_adapter.py,sha256=nL--eicV0St5_0PZZSEhRurHDZHNwhGN2cKOUh0C5IY,1400
 glaip_sdk/runner/tool_adapter/langchain_tool_adapter.py,sha256=goSSDOpubuplsKpfemlbesf_bZBdpDKSTqLILvApcjA,7438
+glaip_sdk/schedules/__init__.py,sha256=Ty__lE8ta3a6O7EiEsSXliVOwA3EBLKxKRsjAJt2WUg,482
+glaip_sdk/schedules/base.py,sha256=ZRKWknoxQOYMhX8mjQ7S7oqpy6Wr0xdbzcgIrycsEQ8,9727
 glaip_sdk/tools/__init__.py,sha256=rhGzEqQFCzeMrxmikBuNrMz4PyYczwic28boDKVmoHs,585
 glaip_sdk/tools/base.py,sha256=bvumLJ-DiQTmuYKgq2yCnlwrTZ9nYXpOwWU0e1vWR5g,15185
 glaip_sdk/utils/__init__.py,sha256=ntohV7cxlY2Yksi2nFuFm_Mg2XVJbBbSJVRej7Mi9YE,2770
@@ -155,8 +160,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.6.22.dist-info/METADATA,sha256=f0VCtMfGVoaWe3bA4KVUN3AmPZk0AFZtyw3GsOLA4ug,8375
-glaip_sdk-0.6.22.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-glaip_sdk-0.6.22.dist-info/entry_points.txt,sha256=65vNPUggyYnVGhuw7RhNJ8Fp2jygTcX0yxJBcBY3iLU,48
-glaip_sdk-0.6.22.dist-info/top_level.txt,sha256=td7yXttiYX2s94-4wFhv-5KdT0rSZ-pnJRSire341hw,10
-glaip_sdk-0.6.22.dist-info/RECORD,,
+glaip_sdk-0.6.24.dist-info/METADATA,sha256=mZ9OCm5VvtAtoEpJ7ATbyggUegM709JmEHVL1QjQAPc,8299
+glaip_sdk-0.6.24.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+glaip_sdk-0.6.24.dist-info/entry_points.txt,sha256=65vNPUggyYnVGhuw7RhNJ8Fp2jygTcX0yxJBcBY3iLU,48
+glaip_sdk-0.6.24.dist-info/top_level.txt,sha256=td7yXttiYX2s94-4wFhv-5KdT0rSZ-pnJRSire341hw,10
+glaip_sdk-0.6.24.dist-info/RECORD,,