gpp-client 26.10.8.dev2__tar.gz → 26.11.1.dev1__tar.gz

{gpp_client-26.10.8.dev2 → gpp_client-26.11.1.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: gpp-client
-Version: 26.10.8.dev2
+Version: 26.11.1.dev1
 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.10.8.dev2 → gpp_client-26.11.1.dev1}/src/gpp_client/generated/__init__.py

@@ -122,6 +122,7 @@ from .enums import (
     Flamingos2ReadMode,
     Flamingos2ReadoutMode,
     Flamingos2Reads,
+    Flamingos2WindowCover,
     FluxDensityContinuumIntegratedUnits,
     FluxDensityContinuumSurfaceUnits,
     FocalPlane,
@@ -193,6 +194,7 @@ from .enums import (
     MosSlitPriority,
     ObsActiveStatus,
     ObservationPriority,
+    ObservationQaState,
     ObservationValidationCode,
     ObservationValidationCodeSeverity,
     ObservationWorkflowState,
@@ -1349,6 +1351,7 @@ from .input_types import (
     WhereConfigurationRequest,
     WhereDataset,
     WhereDatasetChronicleEntry,
+    WhereDatasetQaCounts,
     WhereDatasetReference,
     WhereEqDatabaseOperation,
     WhereEqExecutionEventType,
@@ -1373,6 +1376,7 @@ from .input_types import (
     WhereGroup,
     WhereImagingConfigOption,
     WhereObservation,
+    WhereObservationQa,
     WhereObservationReference,
     WhereObservatoryEq,
     WhereOptionBoolean,
@@ -1383,6 +1387,7 @@ from .input_types import (
     WhereOptionEqGender,
     WhereOptionEqImagingCapability,
     WhereOptionEqInstrument,
+    WhereOptionEqObservationQaState,
     WhereOptionEqObservingModeType,
     WhereOptionEqPartner,
     WhereOptionEqQaState,
@@ -1406,6 +1411,7 @@ from .input_types import (
     WhereOrderGroupId,
     WhereOrderInt,
     WhereOrderLong,
+    WhereOrderNonNegInt,
     WhereOrderObservationId,
     WhereOrderObservationPriority,
     WhereOrderObservationWorkflowState,
@@ -1857,6 +1863,7 @@ __all__ = [
     "Flamingos2Reads",
     "Flamingos2StaticInput",
     "Flamingos2StepInput",
+    "Flamingos2WindowCover",
     "FluxDensity",
     "FluxDensityContinuumIntegratedInput",
     "FluxDensityContinuumIntegratedUnits",
@@ -2671,6 +2678,7 @@ __all__ = [
     "ObservationEditObservationEditValueTimingWindowsEndTimingWindowEndAt",
     "ObservationPriority",
     "ObservationPropertiesInput",
+    "ObservationQaState",
     "ObservationTimesInput",
     "ObservationValidationCode",
     "ObservationValidationCodeSeverity",
@@ -3035,6 +3043,7 @@ __all__ = [
     "WhereConfigurationRequest",
     "WhereDataset",
     "WhereDatasetChronicleEntry",
+    "WhereDatasetQaCounts",
     "WhereDatasetReference",
     "WhereEqDatabaseOperation",
     "WhereEqExecutionEventType",
@@ -3059,6 +3068,7 @@ __all__ = [
     "WhereGroup",
     "WhereImagingConfigOption",
     "WhereObservation",
+    "WhereObservationQa",
     "WhereObservationReference",
     "WhereObservatoryEq",
     "WhereOptionBoolean",
@@ -3069,6 +3079,7 @@ __all__ = [
     "WhereOptionEqGender",
     "WhereOptionEqImagingCapability",
     "WhereOptionEqInstrument",
+    "WhereOptionEqObservationQaState",
     "WhereOptionEqObservingModeType",
     "WhereOptionEqPartner",
     "WhereOptionEqQaState",
@@ -3092,6 +3103,7 @@ __all__ = [
     "WhereOrderGroupId",
     "WhereOrderInt",
     "WhereOrderLong",
+    "WhereOrderNonNegInt",
     "WhereOrderObservationId",
     "WhereOrderObservationPriority",
     "WhereOrderObservationWorkflowState",

{gpp_client-26.10.8.dev2 → gpp_client-26.11.1.dev1}/src/gpp_client/generated/custom_fields.py

@@ -62,8 +62,10 @@ from .custom_typing_fields import (
     ConditionsMeasurementGraphQLField,
     ConfigChangeEstimateGraphQLField,
     ConfigurationConditionsGraphQLField,
+    ConfigurationFlamingos2ImagingGraphQLField,
     ConfigurationFlamingos2LongSlitGraphQLField,
     ConfigurationFlamingos2MosGraphQLField,
+    ConfigurationGhostIfuGraphQLField,
     ConfigurationGmosNorthIfuGraphQLField,
     ConfigurationGmosNorthImagingGraphQLField,
     ConfigurationGmosNorthLongSlitGraphQLField,
@@ -73,6 +75,7 @@ from .custom_typing_fields import (
     ConfigurationGmosSouthLongSlitGraphQLField,
     ConfigurationGmosSouthMosGraphQLField,
     ConfigurationGnirsIfuGraphQLField,
+    ConfigurationGnirsImagingGraphQLField,
     ConfigurationGnirsLongSlitGraphQLField,
     ConfigurationGraphQLField,
     ConfigurationIgrins2LongSlitGraphQLField,
@@ -100,6 +103,7 @@ from .custom_typing_fields import (
     DatasetEstimateGraphQLField,
     DatasetEventGraphQLField,
     DatasetGraphQLField,
+    DatasetQaCountsGraphQLField,
     DatasetReferenceGraphQLField,
     DatasetSelectResultGraphQLField,
     DateIntervalGraphQLField,
@@ -280,6 +284,7 @@ from .custom_typing_fields import (
     MonitoringProgramReferenceGraphQLField,
     NonsiderealGraphQLField,
     ObservationGraphQLField,
+    ObservationQaGraphQLField,
     ObservationReferenceGraphQLField,
     ObservationSelectResultGraphQLField,
     ObservationTimeEstimateGraphQLField,
@@ -1723,11 +1728,16 @@ class CalibrationProgramReferenceFields(GraphQLField):
 class CalibrationSetFields(GraphQLField):
     """One row of a daytime calibration: a kind, an exposure count, the GCAL
     configuration (flats and arcs only) and one instrument setup.  The generator
-    expands it into one atom holding `count` identical DAY_CAL steps."""
+    expands it into one atom: `count` identical DAY_CAL steps for a manual kind,
+    the steps the Smart GCAL lookup returns for a smart kind."""
 
     kind: "CalibrationSetGraphQLField" = CalibrationSetGraphQLField("kind")
     count: "CalibrationSetGraphQLField" = CalibrationSetGraphQLField("count")
-    "Exposures taken with this setup."
+    "Steps this set contributes to the sequence: `explicitCount` for a manual\nstep, the number of steps the Smart GCAL lookup returns for a smart step, or\nnull when the lookup finds no mapping for the setup."
+    explicit_count: "CalibrationSetGraphQLField" = CalibrationSetGraphQLField(
+        "explicitCount"
+    )
+    "Exposures requested for this setup, as given on input.  Always present for\na manual step, always null for a smart step."
 
     @classmethod
     def gcal(cls) -> "CalibrationSetGcalFields":
@@ -1744,13 +1754,26 @@ class CalibrationSetFields(GraphQLField):
         """GMOS South setup, when the instrument is GMOS South."""
         return GmosSouthDynamicFields("gmosSouth")
 
+    @classmethod
+    def flamingos_2(cls) -> "Flamingos2DynamicFields":
+        """Flamingos 2 setup, when the instrument is Flamingos 2.  Its window cover
+        is exactly as entered; a set never defaults it."""
+        return Flamingos2DynamicFields("flamingos2")
+
+    @classmethod
+    def igrins_2(cls) -> "Igrins2DynamicFields":
+        """IGRINS-2 setup, when the instrument is IGRINS-2."""
+        return Igrins2DynamicFields("igrins2")
+
     def fields(
         self,
         *subfields: Union[
             CalibrationSetGraphQLField,
             "CalibrationSetGcalFields",
+            "Flamingos2DynamicFields",
             "GmosNorthDynamicFields",
             "GmosSouthDynamicFields",
+            "Igrins2DynamicFields",
         ],
     ) -> "CalibrationSetFields":
         """Subfields should come from the CalibrationSetFields class"""
@@ -2400,6 +2423,23 @@ class ConfigurationConditionsFields(GraphQLField):
         return self
 
 
+class ConfigurationFlamingos2ImagingFields(GraphQLField):
+    filters: "ConfigurationFlamingos2ImagingGraphQLField" = (
+        ConfigurationFlamingos2ImagingGraphQLField("filters")
+    )
+
+    def fields(
+        self, *subfields: ConfigurationFlamingos2ImagingGraphQLField
+    ) -> "ConfigurationFlamingos2ImagingFields":
+        """Subfields should come from the ConfigurationFlamingos2ImagingFields class"""
+        self._subfields.extend(subfields)
+        return self
+
+    def alias(self, alias: str) -> "ConfigurationFlamingos2ImagingFields":
+        self._alias = alias
+        return self
+
+
 class ConfigurationFlamingos2LongSlitFields(GraphQLField):
     disperser: "ConfigurationFlamingos2LongSlitGraphQLField" = (
         ConfigurationFlamingos2LongSlitGraphQLField("disperser")
@@ -2434,6 +2474,23 @@ class ConfigurationFlamingos2MosFields(GraphQLField):
         return self
 
 
+class ConfigurationGhostIfuFields(GraphQLField):
+    resolution_mode: "ConfigurationGhostIfuGraphQLField" = (
+        ConfigurationGhostIfuGraphQLField("resolutionMode")
+    )
+
+    def fields(
+        self, *subfields: ConfigurationGhostIfuGraphQLField
+    ) -> "ConfigurationGhostIfuFields":
+        """Subfields should come from the ConfigurationGhostIfuFields class"""
+        self._subfields.extend(subfields)
+        return self
+
+    def alias(self, alias: str) -> "ConfigurationGhostIfuFields":
+        self._alias = alias
+        return self
+
+
 class ConfigurationGmosNorthIfuFields(GraphQLField):
     grating: "ConfigurationGmosNorthIfuGraphQLField" = (
         ConfigurationGmosNorthIfuGraphQLField("grating")
@@ -2594,6 +2651,26 @@ class ConfigurationGnirsIfuFields(GraphQLField):
         return self
 
 
+class ConfigurationGnirsImagingFields(GraphQLField):
+    camera: "ConfigurationGnirsImagingGraphQLField" = (
+        ConfigurationGnirsImagingGraphQLField("camera")
+    )
+    filters: "ConfigurationGnirsImagingGraphQLField" = (
+        ConfigurationGnirsImagingGraphQLField("filters")
+    )
+
+    def fields(
+        self, *subfields: ConfigurationGnirsImagingGraphQLField
+    ) -> "ConfigurationGnirsImagingFields":
+        """Subfields should come from the ConfigurationGnirsImagingFields class"""
+        self._subfields.extend(subfields)
+        return self
+
+    def alias(self, alias: str) -> "ConfigurationGnirsImagingFields":
+        self._alias = alias
+        return self
+
+
 class ConfigurationGnirsLongSlitFields(GraphQLField):
     grating: "ConfigurationGnirsLongSlitGraphQLField" = (
         ConfigurationGnirsLongSlitGraphQLField("grating")
@@ -2674,6 +2751,10 @@ class ConfigurationObservingModeFields(GraphQLField):
     def gmos_south_imaging(cls) -> "ConfigurationGmosSouthImagingFields":
         return ConfigurationGmosSouthImagingFields("gmosSouthImaging")
 
+    @classmethod
+    def flamingos_2_imaging(cls) -> "ConfigurationFlamingos2ImagingFields":
+        return ConfigurationFlamingos2ImagingFields("flamingos2Imaging")
+
     @classmethod
     def flamingos_2_long_slit(cls) -> "ConfigurationFlamingos2LongSlitFields":
         return ConfigurationFlamingos2LongSlitFields("flamingos2LongSlit")
@@ -2682,6 +2763,10 @@ class ConfigurationObservingModeFields(GraphQLField):
     def flamingos_2_mos(cls) -> "ConfigurationFlamingos2MosFields":
         return ConfigurationFlamingos2MosFields("flamingos2Mos")
 
+    @classmethod
+    def ghost_ifu(cls) -> "ConfigurationGhostIfuFields":
+        return ConfigurationGhostIfuFields("ghostIfu")
+
     @classmethod
     def gnirs_long_slit(cls) -> "ConfigurationGnirsLongSlitFields":
         return ConfigurationGnirsLongSlitFields("gnirsLongSlit")
@@ -2690,6 +2775,10 @@ class ConfigurationObservingModeFields(GraphQLField):
     def gnirs_ifu(cls) -> "ConfigurationGnirsIfuFields":
         return ConfigurationGnirsIfuFields("gnirsIfu")
 
+    @classmethod
+    def gnirs_imaging(cls) -> "ConfigurationGnirsImagingFields":
+        return ConfigurationGnirsImagingFields("gnirsImaging")
+
     @classmethod
     def igrins_2_long_slit(cls) -> "ConfigurationIgrins2LongSlitFields":
         return ConfigurationIgrins2LongSlitFields("igrins2LongSlit")
@@ -2702,8 +2791,10 @@ class ConfigurationObservingModeFields(GraphQLField):
         self,
         *subfields: Union[
             ConfigurationObservingModeGraphQLField,
+            "ConfigurationFlamingos2ImagingFields",
             "ConfigurationFlamingos2LongSlitFields",
             "ConfigurationFlamingos2MosFields",
+            "ConfigurationGhostIfuFields",
             "ConfigurationGmosNorthIfuFields",
             "ConfigurationGmosNorthImagingFields",
             "ConfigurationGmosNorthLongSlitFields",
@@ -2713,6 +2804,7 @@ class ConfigurationObservingModeFields(GraphQLField):
             "ConfigurationGmosSouthLongSlitFields",
             "ConfigurationGmosSouthMosFields",
             "ConfigurationGnirsIfuFields",
+            "ConfigurationGnirsImagingFields",
             "ConfigurationGnirsLongSlitFields",
             "ConfigurationIgrins2LongSlitFields",
             "ConfigurationVisitorFields",
@@ -3536,6 +3628,36 @@ class DatasetEventFields(GraphQLField):
         return self
 
 
+class DatasetQaCountsFields(GraphQLField):
+    """The number of an observation's written science datasets in each QA state.
+    Datasets that were never written, such as those of aborted exposures, are not
+    counted."""
+
+    total: "DatasetQaCountsGraphQLField" = DatasetQaCountsGraphQLField("total")
+    "All science datasets."
+    pass_: "DatasetQaCountsGraphQLField" = DatasetQaCountsGraphQLField("pass")
+    "Science datasets whose QA state is PASS."
+    usable: "DatasetQaCountsGraphQLField" = DatasetQaCountsGraphQLField("usable")
+    "Science datasets whose QA state is USABLE."
+    fail: "DatasetQaCountsGraphQLField" = DatasetQaCountsGraphQLField("fail")
+    "Science datasets whose QA state is FAIL."
+    not_assessed: "DatasetQaCountsGraphQLField" = DatasetQaCountsGraphQLField(
+        "notAssessed"
+    )
+    "Science datasets with no QA state yet."
+
+    def fields(
+        self, *subfields: DatasetQaCountsGraphQLField
+    ) -> "DatasetQaCountsFields":
+        """Subfields should come from the DatasetQaCountsFields class"""
+        self._subfields.extend(subfields)
+        return self
+
+    def alias(self, alias: str) -> "DatasetQaCountsFields":
+        self._alias = alias
+        return self
+
+
 class DatasetReferenceFields(GraphQLField):
     """Dataset reference type, broken into its constituient parts and including
     a formatted label."""
@@ -4658,6 +4780,10 @@ class Flamingos2DynamicFields(GraphQLField):
     "Flamingos 2 readout mode."
     reads: "Flamingos2DynamicGraphQLField" = Flamingos2DynamicGraphQLField("reads")
     "Flamingos 2 reads."
+    window_cover: "Flamingos2DynamicGraphQLField" = Flamingos2DynamicGraphQLField(
+        "windowCover"
+    )
+    "Flamingos 2 window cover. Null means automatic."
 
     @classmethod
     def central_wavelength(cls) -> "WavelengthFields":
@@ -8927,6 +9053,14 @@ class GroupFields(GraphQLField):
 
     same_night: "GroupGraphQLField" = GroupGraphQLField("sameNight")
     "If true, all observations in this group must be scheduled on the same night.\nMutually exclusive with `maximumInterval`.\nOnly valid for AND groups."
+    minimum_observations_per_night: "GroupGraphQLField" = GroupGraphQLField(
+        "minimumObservationsPerNight"
+    )
+    "On any night when at least one of this group's observations completes, at\nleast this many must complete that night.  Nights on which none complete are\nunconstrained.  Null means no minimum.  Every completion counts, including an\nOR group's extras, through the night the group completes; later ones don't.\nA per-observation calibration group (a science observation with its\ncalibrations) counts as one observation.  Daytime calibrations are ignored,\nso it completes with its science observation and any tellurics.  Mutually\nexclusive with `sameNight`."
+    maximum_observations_per_night: "GroupGraphQLField" = GroupGraphQLField(
+        "maximumObservationsPerNight"
+    )
+    "No more than this many of this group's observations may complete on any one\nnight.  Null means no maximum.  Counted as for `minimumObservationsPerNight`.\nMutually exclusive with `sameNight`."
 
     @classmethod
     def elements(cls, include_deleted: bool) -> "GroupElementFields":
@@ -9023,13 +9157,39 @@ class GroupElementFields(GraphQLField):
 
 
 class GroupProgressFields(GraphQLField):
-    """A group's progress toward satisfying its constraints."""
+    """A group's progress toward satisfying its constraints.
+
+    An observation's timing is taken from its execution: it starts with its first
+    execution event other than a slew, and completes with its last event, as in
+    `ExecutionTimestamps`.  A visitor instrument observation, which records only
+    slews, is instead timed by its time charge: it starts with its first slew and
+    completes where its charge ends, as in its visits'
+    `timeChargeInvoice.interval`.  The charge end is recorded some time after the
+    fact (the charge runs until the next chargeable visit at the site starts or the
+    night ends), and until then the observation completes at its slew.
+
+    A complete observation whose QA state (see `ObservationQa.state`) is `USABLE`
+    or `FAIL` is rejected: it never counts as complete, and it isn't checked
+    against the group's constraints.  One not yet assessed counts, including one
+    with some datasets still unassessed: until a person settles its QA state, an
+    observation is assumed to be good, so that group progress never sends the
+    scheduler back into a group without a QA decision.  The calibrations in a
+    per-observation calibration group go with their science observation: they are
+    left out when it is, and rejected when it is.  A subgroup with only rejected
+    elements is itself rejected.  A group with no `minimumRequired` requires all of
+    its elements, rejected ones included, so it is `UNSCHEDULABLE` until a minimum
+    is set.  With a minimum, rejected elements are left out, and a replacement (a
+    new observation) may take a rejected one's place.  A rejection can still break
+    the group's time constraints (its intervals, same night, or observations per
+    night), or the order of an ordered group whose later elements are already
+    complete, since the completions left are checked without it, and a replacement
+    observed later can't undo that."""
 
     status: "GroupProgressGraphQLField" = GroupProgressGraphQLField("status")
     completed: "GroupProgressGraphQLField" = GroupProgressGraphQLField("completed")
-    "The number of the group's complete elements that count toward it, a subgroup\ncounting as one element.  An ordered group's elements after the first\n`required` don't count, nor do an unordered group's completions after it is\ncomplete.  Always zero while empty or pending, and fewer than `required` while\nongoing."
+    "The number of the group's complete elements that count toward it, a subgroup\ncounting as one element.  An ordered group's elements after the first\n`required` don't count, nor do an unordered group's completions after it is\ncomplete.  Always zero while empty or pending, and fewer than `required` while\nongoing, except in a group with a minimum observations per night whose night\nin progress is short of it and may still take an extra observation."
     required: "GroupProgressGraphQLField" = GroupProgressGraphQLField("required")
-    "The number of elements the group requires: its `minimumRequired`, or every\nviable (non-inactive) element when that is unset.  Zero only when empty."
+    "The number of elements the group requires: its `minimumRequired`, or, when\nthat is unset, every element that isn't left out (see `GroupStatus.EMPTY`),\nrejected ones included.  Zero only when empty."
 
     @classmethod
     def next_window(cls) -> "GroupWindowFields":
@@ -9059,9 +9219,9 @@ class GroupWindowFields(GraphQLField):
     scheduler to combine with it."""
 
     start: "GroupWindowGraphQLField" = GroupWindowGraphQLField("start")
-    "The earliest time the next element may start, per the minimum interval."
+    "The earliest time the next element may start, per the minimum interval, or\nthe end of the night in progress once it holds the group's maximum\nobservations per night."
     end: "GroupWindowGraphQLField" = GroupWindowGraphQLField("end")
-    "The latest time the next element may finish, per the maximum interval or the\nend of the night for a same-night group.  Null if there is no such limit.\nFitting an observation into the window (say, by its time estimate) is left to\nthe scheduler."
+    "The latest time the next element may finish, per the maximum interval, the\nend of the night for a same-night group, or the end of the night in progress\nwhile it is short of the group's minimum observations per night.  Null if\nthere is no such limit.\nFitting an observation into the window (say, by its time estimate) is left to\nthe scheduler."
 
     def fields(self, *subfields: GroupWindowGraphQLField) -> "GroupWindowFields":
         """Subfields should come from the GroupWindowFields class"""
@@ -9099,6 +9259,11 @@ class GroupedImagingVariantFields(GraphQLField):
         """Offset generator to use for the sky datasets."""
         return TelescopeConfigGeneratorFields("skyOffsets")
 
+    exposures_per_offset: "GroupedImagingVariantGraphQLField" = (
+        GroupedImagingVariantGraphQLField("exposuresPerOffset")
+    )
+    "Number of consecutive science exposures to collect at each object offset\nposition before moving to the next position.  The overall exposure count still\ncaps the total, so the final position may receive fewer exposures."
+
     def fields(
         self,
         *subfields: Union[
@@ -9868,6 +10033,11 @@ class InterleavedImagingVariantFields(GraphQLField):
         """Offset generator to use for the sky datasets."""
         return TelescopeConfigGeneratorFields("skyOffsets")
 
+    exposures_per_offset: "InterleavedImagingVariantGraphQLField" = (
+        InterleavedImagingVariantGraphQLField("exposuresPerOffset")
+    )
+    "Number of consecutive science exposures to collect in one filter at each\nobject offset position before moving on to the next filter and position.  A\nfilter's final position may receive fewer exposures so that its overall\nexposure count is honored."
+
     def fields(
         self,
         *subfields: Union[
@@ -10880,6 +11050,11 @@ class ObservationFields(GraphQLField):
         held around this observation's pointing."""
         return ArchiveDuplicationFields("archiveDuplication")
 
+    @classmethod
+    def qa(cls) -> "ObservationQaFields":
+        """The QA verdict for the observation as a whole."""
+        return ObservationQaFields("qa")
+
     def fields(
         self,
         *subfields: Union[
@@ -10892,6 +11067,7 @@ class ObservationFields(GraphQLField):
             "ConstraintSetFields",
             "ExecutionFields",
             "ItcInterface",
+            "ObservationQaFields",
             "ObservationReferenceFields",
             "ObservingModeFields",
             "PosAngleConstraintFields",
@@ -10912,6 +11088,45 @@ class ObservationFields(GraphQLField):
         return self
 
 
+class ObservationQaFields(GraphQLField):
+    """The QA verdict for an observation as a whole.  It is calculated from the QA
+    states of the observation's written science datasets unless staff override it.
+    Acquisition datasets are ignored, as are datasets that were never written
+    (such as those of aborted exposures):
+
+    * no science datasets, or any not yet assessed: no verdict (null)
+    * all datasets PASS: PASS
+    * all datasets FAIL: FAIL
+    * otherwise: USABLE
+
+    An override stays in place as datasets are added or their QA states change,
+    until staff clear it.  Even when some datasets fail, the observation as a
+    whole may pass."""
+
+    state: "ObservationQaGraphQLField" = ObservationQaGraphQLField("state")
+    "The effective QA state: the staff override when there is one, otherwise the\ncalculated state.  Null when the observation has no verdict."
+    computed: "ObservationQaGraphQLField" = ObservationQaGraphQLField("computed")
+    "The QA state calculated from the science datasets, ignoring any override.\nNull when there are no science datasets or any is not yet assessed."
+    override: "ObservationQaGraphQLField" = ObservationQaGraphQLField("override")
+    "The staff-assigned QA state, if any.  Set it with `qaStateOverride` in\n`ObservationPropertiesInput`."
+
+    @classmethod
+    def datasets(cls) -> "DatasetQaCountsFields":
+        """The number of science datasets in each QA state."""
+        return DatasetQaCountsFields("datasets")
+
+    def fields(
+        self, *subfields: Union[ObservationQaGraphQLField, "DatasetQaCountsFields"]
+    ) -> "ObservationQaFields":
+        """Subfields should come from the ObservationQaFields class"""
+        self._subfields.extend(subfields)
+        return self
+
+    def alias(self, alias: str) -> "ObservationQaFields":
+        self._alias = alias
+        return self
+
+
 class ObservationReferenceFields(GraphQLField):
     """Observation reference type, broken into its constituient parts and including
     a formatted label."""
@@ -11508,6 +11723,11 @@ class PreImagingVariantFields(GraphQLField):
     def offset_4(cls) -> "OffsetFields":
         return OffsetFields("offset4")
 
+    exposures_per_offset: "PreImagingVariantGraphQLField" = (
+        PreImagingVariantGraphQLField("exposuresPerOffset")
+    )
+    "Number of consecutive science exposures to collect in one filter at each\noffset position before moving on to the next position.  A filter's final\nposition may receive fewer exposures so that its overall exposure count is\nhonored."
+
     def fields(
         self, *subfields: Union[PreImagingVariantGraphQLField, "OffsetFields"]
     ) -> "PreImagingVariantFields":
@@ -14430,10 +14650,12 @@ class TargetEnvironmentFields(GraphQLField):
     @classmethod
     def guide_environment(cls) -> "GuideEnvironmentFields":
         """The guide target(s) and related information.
-        If a guide target has been set via `guideTargetName`, that target will be
-        returned. If it not found or not usable, an error will be returned.
-        If no guide target has been set, or it has been invalidated by observation/target
-        changes, Gaia will be searched for the best guide target available."""
+        If a guide target has been selected via `setGuideTargetName`, that target will
+        be returned. If it is not found or not usable, an error naming it will be
+        returned; select another guide target or clear the selection to return to
+        automatic selection. A selection is never discarded by observation or target
+        changes. If no guide target has been selected, Gaia will be searched for the
+        best guide target available."""
         return GuideEnvironmentFields("guideEnvironment")
 
     @classmethod
@@ -14462,7 +14684,7 @@ class TargetEnvironmentFields(GraphQLField):
     guide_target_name: "TargetEnvironmentGraphQLField" = TargetEnvironmentGraphQLField(
         "guideTargetName"
     )
-    "The name of the guide target, if any, set by `setGuideTargetName`.\nIf the name is no longer valid or a sequence cannot be generated, null will\nbe returned."
+    "The name of the guide target, if any, selected by `setGuideTargetName`. The\nselection is returned until it is cleared or replaced, whether or not the\nstar is usable with the current observation settings."
     use_blind_offset: "TargetEnvironmentGraphQLField" = TargetEnvironmentGraphQLField(
         "useBlindOffset"
     )
@@ -14900,6 +15122,17 @@ class TimeChargeInvoiceFields(GraphQLField):
     time along with any automatically applied discounts (e.g., for bad weather)
     and manual adjustments made by staff."""
 
+    @classmethod
+    def interval(cls) -> "TimestampIntervalFields":
+        """The interval over which the raw 'executionTime' was measured, before any
+        discounts.  For most visits this is the same as the visit's own 'interval',
+        from its first execution event to its last.  Visitor instrument visits,
+        which record only slew events, are charged from the slew until the next
+        chargeable visit at the site starts or, once the night is over, until
+        nautical dawn, so for them it extends to that point.  Null if the visit has
+        no events."""
+        return TimestampIntervalFields("interval")
+
     @classmethod
     def execution_time(cls) -> "CategorizedTimeFields":
         """Raw execution time."""
@@ -14928,6 +15161,7 @@ class TimeChargeInvoiceFields(GraphQLField):
             "CategorizedTimeFields",
             "TimeChargeCorrectionFields",
             "TimeChargeDiscountInterface",
+            "TimestampIntervalFields",
         ],
     ) -> "TimeChargeInvoiceFields":
         """Subfields should come from the TimeChargeInvoiceFields class"""
@@ -15897,7 +16131,9 @@ class VisitFields(GraphQLField):
 
     @classmethod
     def interval(cls) -> "TimestampIntervalFields":
-        """Time interval during which this visit executed."""
+        """Time interval from the visit's first execution event to its last.  For the
+        interval over which time is charged, which differs for visitor instrument
+        visits, see 'timeChargeInvoice.interval'."""
         return TimestampIntervalFields("interval")
 
     @classmethod

{gpp_client-26.10.8.dev2 → gpp_client-26.11.1.dev1}/src/gpp_client/generated/custom_typing_fields.py

@@ -1931,6 +1931,18 @@ class ObservationGraphQLField(GraphQLField):
         return self
 
 
+class ObservationQaGraphQLField(GraphQLField):
+    def alias(self, alias: str) -> "ObservationQaGraphQLField":
+        self._alias = alias
+        return self
+
+
+class DatasetQaCountsGraphQLField(GraphQLField):
+    def alias(self, alias: str) -> "DatasetQaCountsGraphQLField":
+        self._alias = alias
+        return self
+
+
 class ArchiveMatchGraphQLField(GraphQLField):
     def alias(self, alias: str) -> "ArchiveMatchGraphQLField":
         self._alias = alias
@@ -2009,6 +2021,12 @@ class ConfigurationGmosSouthImagingGraphQLField(GraphQLField):
         return self
 
 
+class ConfigurationFlamingos2ImagingGraphQLField(GraphQLField):
+    def alias(self, alias: str) -> "ConfigurationFlamingos2ImagingGraphQLField":
+        self._alias = alias
+        return self
+
+
 class ConfigurationFlamingos2LongSlitGraphQLField(GraphQLField):
     def alias(self, alias: str) -> "ConfigurationFlamingos2LongSlitGraphQLField":
         self._alias = alias
@@ -2045,6 +2063,18 @@ class ConfigurationGnirsIfuGraphQLField(GraphQLField):
         return self
 
 
+class ConfigurationGnirsImagingGraphQLField(GraphQLField):
+    def alias(self, alias: str) -> "ConfigurationGnirsImagingGraphQLField":
+        self._alias = alias
+        return self
+
+
+class ConfigurationGhostIfuGraphQLField(GraphQLField):
+    def alias(self, alias: str) -> "ConfigurationGhostIfuGraphQLField":
+        self._alias = alias
+        return self
+
+
 class ConfigurationIgrins2LongSlitGraphQLField(GraphQLField):
     def alias(self, alias: str) -> "ConfigurationIgrins2LongSlitGraphQLField":
         self._alias = alias