gpp-client 26.9.0.dev2__tar.gz → 26.9.0.dev3__tar.gz

{gpp_client-26.9.0.dev2 → gpp_client-26.9.0.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: gpp-client
-Version: 26.9.0.dev2
+Version: 26.9.0.dev3
 Summary: Gemini Program Platform client.
 Project-URL: Homepage, https://github.com/gemini-hlsw/gpp-client
 Project-URL: Source, https://github.com/gemini-hlsw/gpp-client

{gpp_client-26.9.0.dev2 → gpp_client-26.9.0.dev3}/src/gpp_client/domains/scheduler.py

@@ -5,7 +5,7 @@ Module for retrieving scheduler information.
 __all__ = ["SchedulerDomain"]
 
 from datetime import datetime
-from typing import Any, AsyncIterator
+from typing import Any, AsyncIterator, Awaitable, Callable
 
 from gpp_client.domains.base import BaseDomain
 from gpp_client.rest.models import VisibilityChanges, parse_visibility_changes
@@ -16,40 +16,112 @@ from gpp_client.generated import (
 from gpp_client.generated.get_scheduler_all_programs_id import (
     GetSchedulerAllProgramsId,
 )
-from gpp_client.generated.get_scheduler_programs import GetSchedulerPrograms
+from gpp_client.generated.get_scheduler_programs import (
+    GetSchedulerPrograms,
+    GetSchedulerProgramsPrograms,
+)
 from gpp_client.generated.input_types import (
     ObservationWorkflowState,
     WhereCalculatedObservationWorkflow,
     WhereObservation,
-    WhereOrderObservationId,
     WhereOrderObservationWorkflowState,
+    WhereOrderProgramId,
+    WhereProgram,
 )
 
+# Each program carries its full group tree, so large pages are heavy for the ODB.
+PROGRAMS_PAGE_SIZE = 1000
+OBSERVATIONS_PAGE_SIZE = 1000
+
 
 class SchedulerDomain(BaseDomain):
     """
     Domain for retrieving scheduler information.
     """
 
+    @staticmethod
+    async def _fetch_all_pages(
+        fetch_page: Callable[[str | None, int], Awaitable[Any]],
+        page_size: int,
+    ) -> list[Any]:
+        """
+        Walk an ``OFFSET``/``LIMIT`` selection one page at a time and return
+        every match.
+
+        Parameters
+        ----------
+        fetch_page : Callable[[str | None, int], Awaitable[Any]]
+            Coroutine taking ``offset`` and ``limit`` and returning a select
+            result with ``matches`` and ``has_more``.
+        page_size : int
+            Number of matches requested per page. Must be at least 2.
+
+        Returns
+        -------
+        list[Any]
+            Every match across all pages, without repeats.
+
+        Raises
+        ------
+        ValueError
+            If ``page_size`` is lower than 2.
+        """
+        # OFFSET is inclusive, so every page after the first repeats the previous
+        # page's last match. A page of 1 would never advance.
+        if page_size < 2:
+            raise ValueError(f"page_size must be at least 2, got {page_size}.")
+
+        matches = []
+        offset = None
+        while True:
+            result = await fetch_page(offset, page_size)
+            page_matches = result.matches
+            if offset is not None and page_matches and page_matches[0].id == offset:
+                page_matches = page_matches[1:]
+            matches.extend(page_matches)
+
+            if not result.has_more or not page_matches:
+                return matches
+            offset = page_matches[-1].id
+
     async def get_programs(
         self,
         *,
         programs_list: list[str] | None = None,
+        page_size: int = PROGRAMS_PAGE_SIZE,
     ) -> GetSchedulerPrograms:
         """
-        Get scheduler programs.
+        Get scheduler programs, fetching every page so the result reads as a
+        single query.
 
         Parameters
         ----------
         programs_list : list[str] | None, optional
             Optional list of program IDs to restrict the result set.
+        page_size : int, optional
+            Number of programs requested per page. Must be at least 2.
 
         Returns
         -------
         GetSchedulerPrograms
-            The generated GraphQL response model.
+            The generated GraphQL response model holding every matching program.
+
+        Raises
+        ------
+        ValueError
+            If ``page_size`` is lower than 2.
         """
-        return await self._graphql.get_scheduler_programs(programs_list=programs_list)
+
+        async def fetch_page(offset: str | None, limit: int) -> Any:
+            page = await self._graphql.get_scheduler_programs(
+                programs_list=programs_list, offset=offset, limit=limit
+            )
+            return page.programs
+
+        matches = await self._fetch_all_pages(fetch_page, page_size)
+        return GetSchedulerPrograms(
+            programs=GetSchedulerProgramsPrograms(matches=matches, has_more=False)
+        )
 
     async def get_program_ids(
         self,
@@ -178,6 +250,7 @@ class SchedulerDomain(BaseDomain):
     async def get_all(
         self,
         programs_list: list | None = None,
+        exclude_programs: list[str] | None = None,
     ) -> list[dict[str, Any]]:
         """
         Fetch all programs with a complete group tree and observations.
@@ -186,6 +259,9 @@ class SchedulerDomain(BaseDomain):
         ----------
         programs_list : list, optional
             Optional filtering clause.
+        exclude_programs : list[str], optional
+            Program IDs to skip, e.g. one whose observations the ODB cannot
+            generate a sequence for, which otherwise fails the whole query.
 
         Returns
         -------
@@ -197,11 +273,13 @@ class SchedulerDomain(BaseDomain):
             programs_list = [
                 p.id for p in (await self.get_program_ids()).programs.matches
             ]
+        if exclude_programs:
+            excluded = set(exclude_programs)
+            programs_list = [p for p in programs_list if p not in excluded]
 
         response = await self.get_programs(programs_list=programs_list)
         response = response.model_dump()
         programs = response["programs"].get("matches", [])
-        observations = []
         for program in programs:
             # Create root group.
             root = {"name": "root", "elements": []}
@@ -220,16 +298,12 @@ class SchedulerDomain(BaseDomain):
                     elem = obs or g.get("group")
 
                     groups_elements_mapping[elem["id"]] = g
-                    if elem == obs:
-                        observations.append(elem["id"])
                 else:
                     children_map.setdefault(parent_id, []).append(g)
                     group = g.get("group")
                     if group:
                         # Subgroup that can contain children of their own.
                         groups_elements_mapping[group["id"]] = g
-                    else:
-                        observations.append(g["observation"]["id"])
 
             for parent_id, children in children_map.items():
                 if parent_id in groups_elements_mapping:
@@ -244,9 +318,10 @@ class SchedulerDomain(BaseDomain):
                     pass
             program["root"] = root
 
-        # If is in the list and status is Ready or OnGoing.
         where_observation = WhereObservation(
-            id=WhereOrderObservationId(in_=observations),
+            program=WhereProgram(
+                id=WhereOrderProgramId(in_=[p["id"] for p in programs])
+            ),
             workflow=WhereCalculatedObservationWorkflow(
                 workflow_state=WhereOrderObservationWorkflowState(
                     in_=[
@@ -260,17 +335,25 @@ class SchedulerDomain(BaseDomain):
             ),
         )
 
-        # Get observation data
-        obs_response = await self._graphql.get_observations(
-            where=where_observation, include_deleted=False
+        # Get observation data, only once every program page is in.
+        async def fetch_observations_page(offset: str | None, limit: int) -> Any:
+            page = await self._graphql.get_observations(
+                where=where_observation,
+                offset=offset,
+                limit=limit,
+                include_deleted=False,
+            )
+            return page.observations
+
+        obs_matches = await self._fetch_all_pages(
+            fetch_observations_page, OBSERVATIONS_PAGE_SIZE
         )
-        obs_payload = obs_response.observations.model_dump()
-        obs_mapping = {o["id"]: o for o in obs_payload["matches"]}
+        obs_mapping = {o.id: o.model_dump() for o in obs_matches}
 
-        # Get sequence
-        if observations:
+        # Get sequence for filtered observations (READY/ONGOING)
+        if obs_mapping:
             atom_digest_response = (
-                await self._rest.get_atom_digests(observations)
+                await self._rest.get_atom_digests(list(obs_mapping))
             ).split("\n")
             obs_atoms_mapping = self._parse_atom_digest(atom_digest_response)
         else:

{gpp_client-26.9.0.dev2 → gpp_client-26.9.0.dev3}/src/gpp_client/generated/client.py

@@ -14254,11 +14254,14 @@ class GraphQLClient(AsyncBaseClient):
     async def get_scheduler_programs(
         self,
         programs_list: Union[Optional[list[Any]], UnsetType] = UNSET,
+        offset: Union[Optional[Any], UnsetType] = UNSET,
+        limit: Union[Optional[Any], UnsetType] = UNSET,
         **kwargs: Any,
     ) -> GetSchedulerPrograms:
         query = gql("""
-            query GetSchedulerPrograms($programsList: [ProgramId!]) {
-              programs(WHERE: {id: {IN: $programsList}}) {
+            query GetSchedulerPrograms($programsList: [ProgramId!], $offset: ProgramId, $limit: NonNegInt) {
+              programs(WHERE: {id: {IN: $programsList}}, OFFSET: $offset, LIMIT: $limit) {
+                hasMore
                 matches {
                   id
                   name
@@ -14351,7 +14354,11 @@ class GraphQLClient(AsyncBaseClient):
               }
             }
             """)
-        variables: dict[str, object] = {"programsList": programs_list}
+        variables: dict[str, object] = {
+            "programsList": programs_list,
+            "offset": offset,
+            "limit": limit,
+        }
         response = await self.execute(
             query=query,
             operation_name="GetSchedulerPrograms",

{gpp_client-26.9.0.dev2 → gpp_client-26.9.0.dev3}/src/gpp_client/generated/get_scheduler_programs.py

@@ -18,6 +18,7 @@ class GetSchedulerPrograms(BaseModel):
 
 
 class GetSchedulerProgramsPrograms(BaseModel):
+    has_more: bool = Field(alias="hasMore")
     matches: list["GetSchedulerProgramsProgramsMatches"]