from typing import Any, Optional, Union
from .base_operation import GraphQLField
from .custom_typing_fields import (
AddConditionsEntryResultGraphQLField,
AddDatasetEventResultGraphQLField,
AddProgramUserResultGraphQLField,
AddSequenceEventResultGraphQLField,
AddSlewEventResultGraphQLField,
AddStepEventResultGraphQLField,
AddTimeChargeCorrectionResultGraphQLField,
AirMassRangeGraphQLField,
AllConfigChangeEstimatesGraphQLField,
AllDetectorEstimatesGraphQLField,
AllocationGraphQLField,
AngleGraphQLField,
AsterismGroupGraphQLField,
AsterismGroupSelectResultGraphQLField,
AtomEventGraphQLField,
AtomRecordGraphQLField,
AtomRecordSelectResultGraphQLField,
AttachmentGraphQLField,
BandBrightnessIntegratedGraphQLField,
BandBrightnessSurfaceGraphQLField,
BandedTimeGraphQLField,
BandNormalizedGraphQLField,
BandNormalizedIntegratedGraphQLField,
BandNormalizedSurfaceGraphQLField,
BiasGraphQLField,
CalculatedBandedTimeGraphQLField,
CalculatedCategorizedTimeRangeGraphQLField,
CalculatedExecutionDigestGraphQLField,
CalculatedObservationWorkflowGraphQLField,
CalibrationProgramReferenceGraphQLField,
CallForProposalsGraphQLField,
CallForProposalsPartnerGraphQLField,
CallsForProposalsSelectResultGraphQLField,
CatalogInfoGraphQLField,
CategorizedTimeGraphQLField,
CategorizedTimeRangeGraphQLField,
ChangeProgramUserRoleResultGraphQLField,
ClassicalGraphQLField,
CloneGroupResultGraphQLField,
CloneObservationResultGraphQLField,
CloneTargetResultGraphQLField,
CommissioningProgramReferenceGraphQLField,
ConditionsEntryGraphQLField,
ConditionsExpectationGraphQLField,
ConditionsIntuitionGraphQLField,
ConditionsMeasurementGraphQLField,
ConfigChangeEstimateGraphQLField,
ConfigurationConditionsGraphQLField,
ConfigurationFlamingos2LongSlitGraphQLField,
ConfigurationGmosNorthImagingGraphQLField,
ConfigurationGmosNorthLongSlitGraphQLField,
ConfigurationGmosSouthImagingGraphQLField,
ConfigurationGmosSouthLongSlitGraphQLField,
ConfigurationGraphQLField,
ConfigurationIgrins2LongSlitGraphQLField,
ConfigurationObservingModeGraphQLField,
ConfigurationRequestGraphQLField,
ConfigurationRequestSelectResultGraphQLField,
ConfigurationTargetGraphQLField,
ConfigurationVisitorGraphQLField,
ConstraintSetGraphQLField,
ConstraintSetGroupGraphQLField,
ConstraintSetGroupSelectResultGraphQLField,
CoordinateLimitsGraphQLField,
CoordinatesGraphQLField,
CreateCallForProposalsResultGraphQLField,
CreateGroupResultGraphQLField,
CreateObservationResultGraphQLField,
CreateProgramNoteResultGraphQLField,
CreateProgramResultGraphQLField,
CreateProposalResultGraphQLField,
CreateTargetResultGraphQLField,
CreateUserInvitationResultGraphQLField,
DarkGraphQLField,
DatasetChronicleEntryGraphQLField,
DatasetChronicleEntrySelectResultGraphQLField,
DatasetEstimateGraphQLField,
DatasetEventGraphQLField,
DatasetGraphQLField,
DatasetReferenceGraphQLField,
DatasetSelectResultGraphQLField,
DateIntervalGraphQLField,
DeclinationArcGraphQLField,
DeclinationGraphQLField,
DeleteProgramUserResultGraphQLField,
DeleteProposalResultGraphQLField,
DemoScienceGraphQLField,
DetectorEstimateGraphQLField,
DirectorsTimeGraphQLField,
ElevationRangeGraphQLField,
EmailGraphQLField,
EmissionLineIntegratedGraphQLField,
EmissionLinesIntegratedGraphQLField,
EmissionLinesSurfaceGraphQLField,
EmissionLineSurfaceGraphQLField,
EngineeringProgramReferenceGraphQLField,
EnumeratedTelescopeConfigGeneratorGraphQLField,
ExampleProgramReferenceGraphQLField,
ExecutionConfigGraphQLField,
ExecutionDigestGraphQLField,
ExecutionEventGraphQLField,
ExecutionEventSelectResultGraphQLField,
ExecutionGraphQLField,
ExposureTimeModeGraphQLField,
FastTurnaroundGraphQLField,
FilterTypeMetaGraphQLField,
Flamingos2AtomGraphQLField,
Flamingos2CustomMaskGraphQLField,
Flamingos2DynamicGraphQLField,
Flamingos2ExecutionConfigGraphQLField,
Flamingos2ExecutionSequenceGraphQLField,
Flamingos2FpuMaskGraphQLField,
Flamingos2LongSlitAcquisitionGraphQLField,
Flamingos2LongSlitGraphQLField,
Flamingos2StaticGraphQLField,
Flamingos2StepGraphQLField,
FluxDensityContinuumIntegratedGraphQLField,
FluxDensityContinuumSurfaceGraphQLField,
FluxDensityEntryGraphQLField,
GaussianSourceGraphQLField,
GcalGraphQLField,
GhostAtomGraphQLField,
GhostDetectorConfigGraphQLField,
GhostDetectorGraphQLField,
GhostDynamicGraphQLField,
GhostExecutionConfigGraphQLField,
GhostExecutionSequenceGraphQLField,
GhostIfuGraphQLField,
GhostStaticGraphQLField,
GhostStepGraphQLField,
GmosCcdModeGraphQLField,
GmosCustomMaskGraphQLField,
GmosGroupedImagingVariantGraphQLField,
GmosImagingVariantGraphQLField,
GmosInterleavedImagingVariantGraphQLField,
GmosNodAndShuffleGraphQLField,
GmosNorthAtomGraphQLField,
GmosNorthDynamicGraphQLField,
GmosNorthExecutionConfigGraphQLField,
GmosNorthExecutionSequenceGraphQLField,
GmosNorthFpuGraphQLField,
GmosNorthGratingConfigGraphQLField,
GmosNorthImagingFilterGraphQLField,
GmosNorthImagingGraphQLField,
GmosNorthLongSlitAcquisitionGraphQLField,
GmosNorthLongSlitGraphQLField,
GmosNorthStaticGraphQLField,
GmosNorthStepGraphQLField,
GmosPreImagingVariantGraphQLField,
GmosSouthAtomGraphQLField,
GmosSouthDynamicGraphQLField,
GmosSouthExecutionConfigGraphQLField,
GmosSouthExecutionSequenceGraphQLField,
GmosSouthFpuGraphQLField,
GmosSouthGratingConfigGraphQLField,
GmosSouthImagingFilterGraphQLField,
GmosSouthImagingGraphQLField,
GmosSouthLongSlitAcquisitionGraphQLField,
GmosSouthLongSlitGraphQLField,
GmosSouthStaticGraphQLField,
GmosSouthStepGraphQLField,
GoaPropertiesGraphQLField,
GroupElementGraphQLField,
GroupGraphQLField,
GuideAvailabilityPeriodGraphQLField,
GuideEnvironmentGraphQLField,
GuideTargetGraphQLField,
HasNonPartnerGraphQLField,
HasPartnerGraphQLField,
HasUnspecifiedPartnerGraphQLField,
HourAngleRangeGraphQLField,
Igrins2AtomGraphQLField,
Igrins2DynamicGraphQLField,
Igrins2ExecutionConfigGraphQLField,
Igrins2ExecutionSequenceGraphQLField,
Igrins2LongSlitGraphQLField,
Igrins2StaticGraphQLField,
Igrins2StepGraphQLField,
ImagingConfigOptionGmosNorthGraphQLField,
ImagingConfigOptionGmosSouthGraphQLField,
ImagingConfigOptionGraphQLField,
ImagingScienceRequirementsGraphQLField,
ItcGhostIfuGraphQLField,
ItcGmosNorthImagingGraphQLField,
ItcGmosNorthImagingResultSetGraphQLField,
ItcGmosSouthImagingGraphQLField,
ItcGmosSouthImagingResultSetGraphQLField,
ItcGraphQLField,
ItcIgrins2SpectroscopyGraphQLField,
ItcResultGraphQLField,
ItcResultSetGraphQLField,
ItcSpectroscopyGraphQLField,
LargeProgramGraphQLField,
LibraryProgramReferenceGraphQLField,
LineFluxIntegratedGraphQLField,
LineFluxSurfaceGraphQLField,
LinkUserResultGraphQLField,
MonitoringProgramReferenceGraphQLField,
NonsiderealGraphQLField,
ObservationGraphQLField,
ObservationReferenceGraphQLField,
ObservationSelectResultGraphQLField,
ObservationValidationGraphQLField,
ObservationWorkflowGraphQLField,
ObservingModeGraphQLField,
ObservingModeGroupGraphQLField,
ObservingModeGroupSelectResultGraphQLField,
OffsetGraphQLField,
OffsetPGraphQLField,
OffsetQGraphQLField,
OpportunityGraphQLField,
ParallaxGraphQLField,
PartnerLinkGraphQLField,
PartnerSplitGraphQLField,
PoorWeatherGraphQLField,
PosAngleConstraintGraphQLField,
ProgramGraphQLField,
ProgramNoteGraphQLField,
ProgramNoteSelectResultGraphQLField,
ProgramReferenceGraphQLField,
ProgramSelectResultGraphQLField,
ProgramUserGraphQLField,
ProgramUserSelectResultGraphQLField,
ProperMotionDeclinationGraphQLField,
ProperMotionGraphQLField,
ProperMotionRAGraphQLField,
ProposalGraphQLField,
ProposalReferenceGraphQLField,
ProposalStatusMetaGraphQLField,
ProposalTypeGraphQLField,
QueueGraphQLField,
RadialVelocityGraphQLField,
RandomTelescopeConfigGeneratorGraphQLField,
RecordDatasetResultGraphQLField,
RecordFlamingos2VisitResultGraphQLField,
RecordGmosNorthVisitResultGraphQLField,
RecordGmosSouthVisitResultGraphQLField,
RecordIgrins2VisitResultGraphQLField,
RecordVisitResultGraphQLField,
RedeemUserInvitationResultGraphQLField,
RegionGraphQLField,
ReplaceFlamingos2SequenceResultGraphQLField,
ReplaceGmosNorthSequenceResultGraphQLField,
ReplaceGmosSouthSequenceResultGraphQLField,
ReplaceIgrins2SequenceResultGraphQLField,
ResetAcquisitionResultGraphQLField,
RevokeUserInvitationResultGraphQLField,
RightAscensionArcGraphQLField,
RightAscensionGraphQLField,
ScienceGraphQLField,
ScienceProgramReferenceGraphQLField,
ScienceRequirementsGraphQLField,
SequenceDigestGraphQLField,
SequenceEventGraphQLField,
SetAllocationsResultGraphQLField,
SetGuideTargetNameResultGraphQLField,
SetProgramReferenceResultGraphQLField,
SetProposalStatusResultGraphQLField,
SetupTimeGraphQLField,
SiderealGraphQLField,
SignalToNoiseAtGraphQLField,
SignalToNoiseExposureTimeModeGraphQLField,
SiteCoordinateLimitsGraphQLField,
SlewEventGraphQLField,
SmartGcalGraphQLField,
SourceProfileGraphQLField,
SpectralDefinitionIntegratedGraphQLField,
SpectralDefinitionSurfaceGraphQLField,
SpectroscopyConfigOptionFlamingos2GraphQLField,
SpectroscopyConfigOptionGhostGraphQLField,
SpectroscopyConfigOptionGmosNorthGraphQLField,
SpectroscopyConfigOptionGmosSouthGraphQLField,
SpectroscopyConfigOptionGnirsGraphQLField,
SpectroscopyConfigOptionGraphQLField,
SpectroscopyScienceRequirementsGraphQLField,
SpiralTelescopeConfigGeneratorGraphQLField,
StepConfigGraphQLField,
StepEstimateGraphQLField,
StepEventGraphQLField,
StepRecordGraphQLField,
StepRecordSelectResultGraphQLField,
SystemProgramReferenceGraphQLField,
SystemVerificationGraphQLField,
TargetEnvironmentGraphQLField,
TargetGraphQLField,
TargetGroupGraphQLField,
TargetGroupSelectResultGraphQLField,
TargetSelectResultGraphQLField,
TelescopeConfigGeneratorGraphQLField,
TelescopeConfigGraphQLField,
TelluricTypeGraphQLField,
TimeAndCountExposureTimeModeGraphQLField,
TimeChargeCorrectionGraphQLField,
TimeChargeDaylightDiscountGraphQLField,
TimeChargeDiscountGraphQLField,
TimeChargeInvoiceGraphQLField,
TimeChargeNoDataDiscountGraphQLField,
TimeChargeOverlapDiscountGraphQLField,
TimeChargeQaDiscountGraphQLField,
TimeSpanGraphQLField,
TimestampIntervalGraphQLField,
TimingWindowEndAfterGraphQLField,
TimingWindowEndAtGraphQLField,
TimingWindowEndUnion,
TimingWindowGraphQLField,
TimingWindowRepeatGraphQLField,
UniformTelescopeConfigGeneratorGraphQLField,
UnlinkUserResultGraphQLField,
UnnormalizedSedGraphQLField,
UpdateAsterismsResultGraphQLField,
UpdateAttachmentsResultGraphQLField,
UpdateCallsForProposalsResultGraphQLField,
UpdateConfigurationRequestsResultGraphQLField,
UpdateDatasetsResultGraphQLField,
UpdateGroupsResultGraphQLField,
UpdateObservationsResultGraphQLField,
UpdateProgramNotesResultGraphQLField,
UpdateProgramsResultGraphQLField,
UpdateProgramUsersResultGraphQLField,
UpdateProposalResultGraphQLField,
UpdateTargetsResultGraphQLField,
UserGraphQLField,
UserInvitationGraphQLField,
UserProfileGraphQLField,
VisitGraphQLField,
VisitorGraphQLField,
VisitSelectResultGraphQLField,
WavelengthDitherGraphQLField,
WavelengthGraphQLField,
)
[docs]
class AddConditionsEntryResultFields(GraphQLField):
[docs]
@classmethod
def conditions_entry(cls) -> "ConditionsEntryFields":
return ConditionsEntryFields("conditionsEntry")
[docs]
def fields(
self,
*subfields: Union[
AddConditionsEntryResultGraphQLField, "ConditionsEntryFields"
],
) -> "AddConditionsEntryResultFields":
"""Subfields should come from the AddConditionsEntryResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "AddConditionsEntryResultFields":
self._alias = alias
return self
[docs]
class AddDatasetEventResultFields(GraphQLField):
"""The result of adding a dataset event."""
[docs]
@classmethod
def event(cls) -> "DatasetEventFields":
"""The new dataset event that was added."""
return DatasetEventFields("event")
[docs]
def fields(
self, *subfields: Union[AddDatasetEventResultGraphQLField, "DatasetEventFields"]
) -> "AddDatasetEventResultFields":
"""Subfields should come from the AddDatasetEventResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "AddDatasetEventResultFields":
self._alias = alias
return self
[docs]
class AddProgramUserResultFields(GraphQLField):
[docs]
@classmethod
def program_user(cls) -> "ProgramUserFields":
return ProgramUserFields("programUser")
[docs]
def fields(
self, *subfields: Union[AddProgramUserResultGraphQLField, "ProgramUserFields"]
) -> "AddProgramUserResultFields":
"""Subfields should come from the AddProgramUserResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "AddProgramUserResultFields":
self._alias = alias
return self
[docs]
class AddSequenceEventResultFields(GraphQLField):
"""The result of adding a sequence event."""
[docs]
@classmethod
def event(cls) -> "SequenceEventFields":
"""The new sequence event that was added."""
return SequenceEventFields("event")
[docs]
def fields(
self,
*subfields: Union[AddSequenceEventResultGraphQLField, "SequenceEventFields"],
) -> "AddSequenceEventResultFields":
"""Subfields should come from the AddSequenceEventResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "AddSequenceEventResultFields":
self._alias = alias
return self
[docs]
class AddSlewEventResultFields(GraphQLField):
"""The result of adding a slew event."""
[docs]
@classmethod
def event(cls) -> "SlewEventFields":
"""The new slew event that was added."""
return SlewEventFields("event")
[docs]
def fields(
self, *subfields: Union[AddSlewEventResultGraphQLField, "SlewEventFields"]
) -> "AddSlewEventResultFields":
"""Subfields should come from the AddSlewEventResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "AddSlewEventResultFields":
self._alias = alias
return self
[docs]
class AddStepEventResultFields(GraphQLField):
"""The result of adding a step event."""
[docs]
@classmethod
def event(cls) -> "StepEventFields":
"""The new step event that was added."""
return StepEventFields("event")
[docs]
def fields(
self, *subfields: Union[AddStepEventResultGraphQLField, "StepEventFields"]
) -> "AddStepEventResultFields":
"""Subfields should come from the AddStepEventResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "AddStepEventResultFields":
self._alias = alias
return self
[docs]
class AddTimeChargeCorrectionResultFields(GraphQLField):
"""The result of the 'addTimeChargeCorrection' mutation. It contains the
visit's updated TimeChargeInvoice after applying the correction."""
[docs]
@classmethod
def time_charge_invoice(cls) -> "TimeChargeInvoiceFields":
return TimeChargeInvoiceFields("timeChargeInvoice")
[docs]
def fields(
self,
*subfields: Union[
AddTimeChargeCorrectionResultGraphQLField, "TimeChargeInvoiceFields"
],
) -> "AddTimeChargeCorrectionResultFields":
"""Subfields should come from the AddTimeChargeCorrectionResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "AddTimeChargeCorrectionResultFields":
self._alias = alias
return self
[docs]
class AirMassRangeFields(GraphQLField):
min: "AirMassRangeGraphQLField" = AirMassRangeGraphQLField("min")
"Minimum AirMass (unitless)"
max: "AirMassRangeGraphQLField" = AirMassRangeGraphQLField("max")
"Maximum AirMass (unitless)"
[docs]
def fields(self, *subfields: AirMassRangeGraphQLField) -> "AirMassRangeFields":
"""Subfields should come from the AirMassRangeFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "AirMassRangeFields":
self._alias = alias
return self
[docs]
class AllConfigChangeEstimatesFields(GraphQLField):
"""Time taken to update the configuration before a step is executed."""
[docs]
@classmethod
def selected(cls) -> "ConfigChangeEstimateFields":
"""The selected ConfigChangeEstimate is a maximum of all the config change
estimates. In other words, one that takes the longest."""
return ConfigChangeEstimateFields("selected")
index: "AllConfigChangeEstimatesGraphQLField" = (
AllConfigChangeEstimatesGraphQLField("index")
)
"Index of the selected config change estimate amongst all the estimates in\n`all`."
[docs]
@classmethod
def all(cls) -> "ConfigChangeEstimateFields":
"""Complete collection of items that changed. The selected estimate will be
one of the longest (there may be multiple estimates tied for the longest)."""
return ConfigChangeEstimateFields("all")
[docs]
@classmethod
def estimate(cls) -> "TimeSpanFields":
"""Time required for the collection of estimates in `all`. This should
be the max of the individual entries because the execution happens in
parallel."""
return TimeSpanFields("estimate")
[docs]
def fields(
self,
*subfields: Union[
AllConfigChangeEstimatesGraphQLField,
"ConfigChangeEstimateFields",
"TimeSpanFields",
],
) -> "AllConfigChangeEstimatesFields":
"""Subfields should come from the AllConfigChangeEstimatesFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "AllConfigChangeEstimatesFields":
self._alias = alias
return self
[docs]
class AllDetectorEstimatesFields(GraphQLField):
"""The collection of detector estimates involved in an individual step."""
[docs]
@classmethod
def selected(cls) -> "DetectorEstimateFields":
"""The selected DetectorEstimate is a maximum of all the detector estimates.
In other words, one that takes the longest."""
return DetectorEstimateFields("selected")
index: "AllDetectorEstimatesGraphQLField" = AllDetectorEstimatesGraphQLField(
"index"
)
"Index of the selected detector estimate amongst all the estimates in\n`all`."
[docs]
@classmethod
def all(cls) -> "DetectorEstimateFields":
"""Complete collection of detectors involved in a step. The selected estimate
will be one of the longest (there may be multiple estimates tied for the
longest)."""
return DetectorEstimateFields("all")
[docs]
@classmethod
def estimate(cls) -> "TimeSpanFields":
"""Time required for the collection of estimates in `all`. This should
be the max of the individual entries because the execution happens in
parallel."""
return TimeSpanFields("estimate")
[docs]
def fields(
self,
*subfields: Union[
AllDetectorEstimatesGraphQLField, "DetectorEstimateFields", "TimeSpanFields"
],
) -> "AllDetectorEstimatesFields":
"""Subfields should come from the AllDetectorEstimatesFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "AllDetectorEstimatesFields":
self._alias = alias
return self
[docs]
class AllocationFields(GraphQLField):
"""An individual time allocation."""
category: "AllocationGraphQLField" = AllocationGraphQLField("category")
science_band: "AllocationGraphQLField" = AllocationGraphQLField("scienceBand")
[docs]
@classmethod
def duration(cls) -> "TimeSpanFields":
return TimeSpanFields("duration")
[docs]
def fields(
self, *subfields: Union[AllocationGraphQLField, "TimeSpanFields"]
) -> "AllocationFields":
"""Subfields should come from the AllocationFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "AllocationFields":
self._alias = alias
return self
[docs]
class AngleFields(GraphQLField):
microarcseconds: "AngleGraphQLField" = AngleGraphQLField("microarcseconds")
"Angle in µas"
microseconds: "AngleGraphQLField" = AngleGraphQLField("microseconds")
"Angle in µs"
milliarcseconds: "AngleGraphQLField" = AngleGraphQLField("milliarcseconds")
"Angle in mas"
milliseconds: "AngleGraphQLField" = AngleGraphQLField("milliseconds")
"Angle in ms"
arcseconds: "AngleGraphQLField" = AngleGraphQLField("arcseconds")
"Angle in asec"
seconds: "AngleGraphQLField" = AngleGraphQLField("seconds")
"Angle in sec"
arcminutes: "AngleGraphQLField" = AngleGraphQLField("arcminutes")
"Angle in amin"
minutes: "AngleGraphQLField" = AngleGraphQLField("minutes")
"Angle in min"
degrees: "AngleGraphQLField" = AngleGraphQLField("degrees")
"Angle in deg"
hours: "AngleGraphQLField" = AngleGraphQLField("hours")
"Angle in hrs"
hms: "AngleGraphQLField" = AngleGraphQLField("hms")
"Angle in HH:MM:SS"
dms: "AngleGraphQLField" = AngleGraphQLField("dms")
"Angle in DD:MM:SS"
[docs]
def fields(self, *subfields: AngleGraphQLField) -> "AngleFields":
"""Subfields should come from the AngleFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "AngleFields":
self._alias = alias
return self
[docs]
class AsterismGroupFields(GraphQLField):
[docs]
@classmethod
def program(cls) -> "ProgramFields":
return ProgramFields("program")
[docs]
@classmethod
def observations(
cls,
include_deleted: bool,
*,
offset: Optional[Any] = None,
limit: Optional[Any] = None,
) -> "ObservationSelectResultFields":
"""Observations associated with the common value"""
arguments: dict[str, dict[str, Any]] = {
"includeDeleted": {"type": "Boolean!", "value": include_deleted},
"OFFSET": {"type": "ObservationId", "value": offset},
"LIMIT": {"type": "NonNegInt", "value": limit},
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return ObservationSelectResultFields(
"observations", arguments=cleared_arguments
)
[docs]
@classmethod
def asterism(cls) -> "TargetFields":
"""Commonly held value across the observations"""
return TargetFields("asterism")
[docs]
def fields(
self,
*subfields: Union[
AsterismGroupGraphQLField,
"ObservationSelectResultFields",
"ProgramFields",
"TargetFields",
],
) -> "AsterismGroupFields":
"""Subfields should come from the AsterismGroupFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "AsterismGroupFields":
self._alias = alias
return self
[docs]
class AsterismGroupSelectResultFields(GraphQLField):
"""The matching asterismGroup results, limited to a maximum of 1000 entries."""
[docs]
@classmethod
def matches(cls) -> "AsterismGroupFields":
"""Matching asterismGroups up to the return size limit of 1000"""
return AsterismGroupFields("matches")
has_more: "AsterismGroupSelectResultGraphQLField" = (
AsterismGroupSelectResultGraphQLField("hasMore")
)
"`true` when there were additional matches that were not returned."
[docs]
def fields(
self,
*subfields: Union[AsterismGroupSelectResultGraphQLField, "AsterismGroupFields"],
) -> "AsterismGroupSelectResultFields":
"""Subfields should come from the AsterismGroupSelectResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "AsterismGroupSelectResultFields":
self._alias = alias
return self
[docs]
class AtomEventFields(GraphQLField):
"""Atom-level events. The execution of a single atom will generate multiple events."""
id: "AtomEventGraphQLField" = AtomEventGraphQLField("id")
"Event id."
[docs]
@classmethod
def visit(cls) -> "VisitFields":
"""Visit associated with the event."""
return VisitFields("visit")
[docs]
@classmethod
def observation(cls) -> "ObservationFields":
"""Observation whose execution produced this event."""
return ObservationFields("observation")
received: "AtomEventGraphQLField" = AtomEventGraphQLField("received")
"Time at which this event was received."
event_type: "AtomEventGraphQLField" = AtomEventGraphQLField("eventType")
"Event type."
[docs]
@classmethod
def atom(cls) -> "AtomRecordFields":
"""Atom record associated with this event, if any. Atom records only materialize
when the steps they contain execute."""
return AtomRecordFields("atom")
atom_stage: "AtomEventGraphQLField" = AtomEventGraphQLField("atomStage")
"Atom execution stage."
idempotency_key: "AtomEventGraphQLField" = AtomEventGraphQLField("idempotencyKey")
"Idempotency key, if any. The IdempotencyKey may be provided by clients when\nthe event is created and is used to enable problem-free retry in the case of\nfailure."
[docs]
def fields(
self,
*subfields: Union[
AtomEventGraphQLField,
"AtomRecordFields",
"ObservationFields",
"VisitFields",
],
) -> "AtomEventFields":
"""Subfields should come from the AtomEventFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "AtomEventFields":
self._alias = alias
return self
[docs]
class AtomRecordFields(GraphQLField):
"""The portion of an atom that executed in a particular visit."""
id: "AtomRecordGraphQLField" = AtomRecordGraphQLField("id")
"Atom ID."
[docs]
@classmethod
def visit(cls) -> "VisitFields":
"""Visit in which this atom executed."""
return VisitFields("visit")
index: "AtomRecordGraphQLField" = AtomRecordGraphQLField("index")
"Atom execution order -- the index of its first executed step."
description: "AtomRecordGraphQLField" = AtomRecordGraphQLField("description")
"Description, if any."
instrument: "AtomRecordGraphQLField" = AtomRecordGraphQLField("instrument")
"The instrument associated with this atom."
[docs]
@classmethod
def observation(cls) -> "ObservationFields":
"""Observation containing this atom."""
return ObservationFields("observation")
execution_state: "AtomRecordGraphQLField" = AtomRecordGraphQLField("executionState")
"The execution state of this atom, according to events received (if any) from\nObserve."
[docs]
@classmethod
def interval(cls) -> "TimestampIntervalFields":
"""Time interval during which this atom executed."""
return TimestampIntervalFields("interval")
sequence_type: "AtomRecordGraphQLField" = AtomRecordGraphQLField("sequenceType")
"Sequence type."
[docs]
@classmethod
def steps(
cls, *, offset: Optional[Any] = None, limit: Optional[Any] = None
) -> "StepRecordSelectResultFields":
"""Recorded steps associated with this atom, ordered by execution order."""
arguments: dict[str, dict[str, Any]] = {
"OFFSET": {"type": "PosInt", "value": offset},
"LIMIT": {"type": "NonNegInt", "value": limit},
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return StepRecordSelectResultFields("steps", arguments=cleared_arguments)
[docs]
def fields(
self,
*subfields: Union[
AtomRecordGraphQLField,
"ObservationFields",
"StepRecordSelectResultFields",
"TimestampIntervalFields",
"VisitFields",
],
) -> "AtomRecordFields":
"""Subfields should come from the AtomRecordFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "AtomRecordFields":
self._alias = alias
return self
[docs]
class AtomRecordSelectResultFields(GraphQLField):
"""AtomRecord query results, limited to a maximum of 1000 entries."""
[docs]
@classmethod
def matches(cls) -> "AtomRecordFields":
"""Matching atom records up to the return size limit of 1000."""
return AtomRecordFields("matches")
has_more: "AtomRecordSelectResultGraphQLField" = AtomRecordSelectResultGraphQLField(
"hasMore"
)
"`true` when there were additional matches that were not returned."
[docs]
def fields(
self, *subfields: Union[AtomRecordSelectResultGraphQLField, "AtomRecordFields"]
) -> "AtomRecordSelectResultFields":
"""Subfields should come from the AtomRecordSelectResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "AtomRecordSelectResultFields":
self._alias = alias
return self
[docs]
class AttachmentFields(GraphQLField):
"""Attachment"""
id: "AttachmentGraphQLField" = AttachmentGraphQLField("id")
attachment_type: "AttachmentGraphQLField" = AttachmentGraphQLField("attachmentType")
file_name: "AttachmentGraphQLField" = AttachmentGraphQLField("fileName")
description: "AttachmentGraphQLField" = AttachmentGraphQLField("description")
checked: "AttachmentGraphQLField" = AttachmentGraphQLField("checked")
file_size: "AttachmentGraphQLField" = AttachmentGraphQLField("fileSize")
updated_at: "AttachmentGraphQLField" = AttachmentGraphQLField("updatedAt")
[docs]
@classmethod
def program(cls) -> "ProgramFields":
return ProgramFields("program")
[docs]
def fields(
self, *subfields: Union[AttachmentGraphQLField, "ProgramFields"]
) -> "AttachmentFields":
"""Subfields should come from the AttachmentFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "AttachmentFields":
self._alias = alias
return self
[docs]
class BandBrightnessIntegratedFields(GraphQLField):
band: "BandBrightnessIntegratedGraphQLField" = BandBrightnessIntegratedGraphQLField(
"band"
)
"Magnitude band"
value: "BandBrightnessIntegratedGraphQLField" = (
BandBrightnessIntegratedGraphQLField("value")
)
units: "BandBrightnessIntegratedGraphQLField" = (
BandBrightnessIntegratedGraphQLField("units")
)
error: "BandBrightnessIntegratedGraphQLField" = (
BandBrightnessIntegratedGraphQLField("error")
)
"Error, if any"
[docs]
def fields(
self, *subfields: BandBrightnessIntegratedGraphQLField
) -> "BandBrightnessIntegratedFields":
"""Subfields should come from the BandBrightnessIntegratedFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "BandBrightnessIntegratedFields":
self._alias = alias
return self
[docs]
class BandBrightnessSurfaceFields(GraphQLField):
band: "BandBrightnessSurfaceGraphQLField" = BandBrightnessSurfaceGraphQLField(
"band"
)
"Magnitude band"
value: "BandBrightnessSurfaceGraphQLField" = BandBrightnessSurfaceGraphQLField(
"value"
)
units: "BandBrightnessSurfaceGraphQLField" = BandBrightnessSurfaceGraphQLField(
"units"
)
error: "BandBrightnessSurfaceGraphQLField" = BandBrightnessSurfaceGraphQLField(
"error"
)
"Error, if any"
[docs]
def fields(
self, *subfields: BandBrightnessSurfaceGraphQLField
) -> "BandBrightnessSurfaceFields":
"""Subfields should come from the BandBrightnessSurfaceFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "BandBrightnessSurfaceFields":
self._alias = alias
return self
[docs]
class BandNormalizedInterface(GraphQLField):
"""Band normalized common interface"""
[docs]
@classmethod
def sed(cls) -> "UnnormalizedSedFields":
"""Un-normalized spectral energy distribution"""
return UnnormalizedSedFields("sed")
[docs]
def fields(
self, *subfields: Union[BandNormalizedGraphQLField, "UnnormalizedSedFields"]
) -> "BandNormalizedInterface":
"""Subfields should come from the BandNormalizedInterface class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "BandNormalizedInterface":
self._alias = alias
return self
[docs]
def on(self, type_name: str, *subfields: GraphQLField) -> "BandNormalizedInterface":
self._inline_fragments[type_name] = subfields
return self
[docs]
class BandNormalizedIntegratedFields(GraphQLField):
[docs]
@classmethod
def brightnesses(cls) -> "BandBrightnessIntegratedFields":
return BandBrightnessIntegratedFields("brightnesses")
[docs]
@classmethod
def sed(cls) -> "UnnormalizedSedFields":
"""Un-normalized spectral energy distribution"""
return UnnormalizedSedFields("sed")
[docs]
def fields(
self,
*subfields: Union[
BandNormalizedIntegratedGraphQLField,
"BandBrightnessIntegratedFields",
"UnnormalizedSedFields",
],
) -> "BandNormalizedIntegratedFields":
"""Subfields should come from the BandNormalizedIntegratedFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "BandNormalizedIntegratedFields":
self._alias = alias
return self
[docs]
class BandNormalizedSurfaceFields(GraphQLField):
[docs]
@classmethod
def brightnesses(cls) -> "BandBrightnessSurfaceFields":
return BandBrightnessSurfaceFields("brightnesses")
[docs]
@classmethod
def sed(cls) -> "UnnormalizedSedFields":
"""Un-normalized spectral energy distribution"""
return UnnormalizedSedFields("sed")
[docs]
def fields(
self,
*subfields: Union[
BandNormalizedSurfaceGraphQLField,
"BandBrightnessSurfaceFields",
"UnnormalizedSedFields",
],
) -> "BandNormalizedSurfaceFields":
"""Subfields should come from the BandNormalizedSurfaceFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "BandNormalizedSurfaceFields":
self._alias = alias
return self
[docs]
class BandedTimeFields(GraphQLField):
"""CategorizedTime grouped with a ScienceBand. A program may contain multiple
observations in distinct bands. Time accounting at the program level must
distinguish time spent in observations of each of these bands."""
band: "BandedTimeGraphQLField" = BandedTimeGraphQLField("band")
"ScienceBand associated with the time, if any."
[docs]
@classmethod
def time(cls) -> "CategorizedTimeFields":
"""Time distributed across the program and non-charged categories."""
return CategorizedTimeFields("time")
[docs]
def fields(
self, *subfields: Union[BandedTimeGraphQLField, "CategorizedTimeFields"]
) -> "BandedTimeFields":
"""Subfields should come from the BandedTimeFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "BandedTimeFields":
self._alias = alias
return self
[docs]
class BiasFields(GraphQLField):
"""Bias calibration step"""
step_type: "BiasGraphQLField" = BiasGraphQLField("stepType")
"Step type"
[docs]
def fields(self, *subfields: BiasGraphQLField) -> "BiasFields":
"""Subfields should come from the BiasFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "BiasFields":
self._alias = alias
return self
[docs]
class CalculatedBandedTimeFields(GraphQLField):
"""A BandedTime that is automatically updated by a background process."""
calculation_state: "CalculatedBandedTimeGraphQLField" = (
CalculatedBandedTimeGraphQLField("calculationState")
)
"The current state of the background calculation."
state: "CalculatedBandedTimeGraphQLField" = CalculatedBandedTimeGraphQLField(
"state"
)
"The current state of the background calculation."
[docs]
@classmethod
def value(cls) -> "BandedTimeFields":
return BandedTimeFields("value")
[docs]
def fields(
self, *subfields: Union[CalculatedBandedTimeGraphQLField, "BandedTimeFields"]
) -> "CalculatedBandedTimeFields":
"""Subfields should come from the CalculatedBandedTimeFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "CalculatedBandedTimeFields":
self._alias = alias
return self
[docs]
class CalculatedCategorizedTimeRangeFields(GraphQLField):
"""A CategorizedTimeRange that is automatically updated by a background process."""
calculation_state: "CalculatedCategorizedTimeRangeGraphQLField" = (
CalculatedCategorizedTimeRangeGraphQLField("calculationState")
)
"The current state of the background calculation."
state: "CalculatedCategorizedTimeRangeGraphQLField" = (
CalculatedCategorizedTimeRangeGraphQLField("state")
)
"The current state of the background calculation."
[docs]
@classmethod
def value(cls) -> "CategorizedTimeRangeFields":
return CategorizedTimeRangeFields("value")
[docs]
def fields(
self,
*subfields: Union[
CalculatedCategorizedTimeRangeGraphQLField, "CategorizedTimeRangeFields"
],
) -> "CalculatedCategorizedTimeRangeFields":
"""Subfields should come from the CalculatedCategorizedTimeRangeFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "CalculatedCategorizedTimeRangeFields":
self._alias = alias
return self
[docs]
class CalculatedExecutionDigestFields(GraphQLField):
"""Wraps an ExecutionDigest with the background calculation state."""
calculation_state: "CalculatedExecutionDigestGraphQLField" = (
CalculatedExecutionDigestGraphQLField("calculationState")
)
"Background calculation state."
state: "CalculatedExecutionDigestGraphQLField" = (
CalculatedExecutionDigestGraphQLField("state")
)
"Background calculation state."
[docs]
@classmethod
def value(cls) -> "ExecutionDigestFields":
"""The current execution digest itself."""
return ExecutionDigestFields("value")
[docs]
def fields(
self,
*subfields: Union[
CalculatedExecutionDigestGraphQLField, "ExecutionDigestFields"
],
) -> "CalculatedExecutionDigestFields":
"""Subfields should come from the CalculatedExecutionDigestFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "CalculatedExecutionDigestFields":
self._alias = alias
return self
[docs]
class CalculatedObservationWorkflowFields(GraphQLField):
calculation_state: "CalculatedObservationWorkflowGraphQLField" = (
CalculatedObservationWorkflowGraphQLField("calculationState")
)
"The current state of the background calculation."
state: "CalculatedObservationWorkflowGraphQLField" = (
CalculatedObservationWorkflowGraphQLField("state")
)
"The current state of the background calculation."
[docs]
@classmethod
def value(cls) -> "ObservationWorkflowFields":
return ObservationWorkflowFields("value")
[docs]
def fields(
self,
*subfields: Union[
CalculatedObservationWorkflowGraphQLField, "ObservationWorkflowFields"
],
) -> "CalculatedObservationWorkflowFields":
"""Subfields should come from the CalculatedObservationWorkflowFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "CalculatedObservationWorkflowFields":
self._alias = alias
return self
[docs]
class CalibrationProgramReferenceFields(GraphQLField):
label: "CalibrationProgramReferenceGraphQLField" = (
CalibrationProgramReferenceGraphQLField("label")
)
type_: "CalibrationProgramReferenceGraphQLField" = (
CalibrationProgramReferenceGraphQLField("type")
)
instrument: "CalibrationProgramReferenceGraphQLField" = (
CalibrationProgramReferenceGraphQLField("instrument")
)
semester: "CalibrationProgramReferenceGraphQLField" = (
CalibrationProgramReferenceGraphQLField("semester")
)
semester_index: "CalibrationProgramReferenceGraphQLField" = (
CalibrationProgramReferenceGraphQLField("semesterIndex")
)
[docs]
def fields(
self, *subfields: CalibrationProgramReferenceGraphQLField
) -> "CalibrationProgramReferenceFields":
"""Subfields should come from the CalibrationProgramReferenceFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "CalibrationProgramReferenceFields":
self._alias = alias
return self
[docs]
class CallForProposalsFields(GraphQLField):
"""A single Call for Proposals definition."""
id: "CallForProposalsGraphQLField" = CallForProposalsGraphQLField("id")
"The unique Call for Proposals id associated with this Call."
title: "CallForProposalsGraphQLField" = CallForProposalsGraphQLField("title")
"The title of this Call for Proposals."
type_: "CallForProposalsGraphQLField" = CallForProposalsGraphQLField("type")
"Describes which type of proposals are being accepted."
semester: "CallForProposalsGraphQLField" = CallForProposalsGraphQLField("semester")
"The semester associated with the Call. Some types may have multiple Calls\nper semester."
[docs]
@classmethod
def coordinate_limits(cls) -> "SiteCoordinateLimitsFields":
"""Coordinate limits for targets that may be observed in this Call for Proposals."""
return SiteCoordinateLimitsFields("coordinateLimits")
[docs]
@classmethod
def active(cls) -> "DateIntervalFields":
"""The active period during which accepted observations for this call may be
observed."""
return DateIntervalFields("active")
submission_deadline_default: "CallForProposalsGraphQLField" = (
CallForProposalsGraphQLField("submissionDeadlineDefault")
)
"The submission deadline to use for any partners without an explicit partner\ndeadline."
[docs]
@classmethod
def partners(cls) -> "CallForProposalsPartnerFields":
"""Partners that may participate in this Call."""
return CallForProposalsPartnerFields("partners")
allows_non_partner_pi: "CallForProposalsGraphQLField" = (
CallForProposalsGraphQLField("allowsNonPartnerPi")
)
"Whether this Call allows PIs without a partner to participate."
non_partner_deadline: "CallForProposalsGraphQLField" = CallForProposalsGraphQLField(
"nonPartnerDeadline"
)
"The submission deadline for non-partner PIs, when allowed to participate."
instruments: "CallForProposalsGraphQLField" = CallForProposalsGraphQLField(
"instruments"
)
"When specified, the observations executed in this Call will only use these\ninstruments. When not specified, all otherwise available instruments may be\nused."
proprietary_months: "CallForProposalsGraphQLField" = CallForProposalsGraphQLField(
"proprietaryMonths"
)
"Default proprietary period to use for propograms linked to this Call."
existence: "CallForProposalsGraphQLField" = CallForProposalsGraphQLField(
"existence"
)
"Whether this Call is PRESENT or has been DELETED."
[docs]
def fields(
self,
*subfields: Union[
CallForProposalsGraphQLField,
"CallForProposalsPartnerFields",
"DateIntervalFields",
"SiteCoordinateLimitsFields",
],
) -> "CallForProposalsFields":
"""Subfields should come from the CallForProposalsFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "CallForProposalsFields":
self._alias = alias
return self
[docs]
class CallForProposalsPartnerFields(GraphQLField):
"""Groups a partner with its submission deadline."""
partner: "CallForProposalsPartnerGraphQLField" = (
CallForProposalsPartnerGraphQLField("partner")
)
submission_deadline_override: "CallForProposalsPartnerGraphQLField" = (
CallForProposalsPartnerGraphQLField("submissionDeadlineOverride")
)
"Sets the submission deadline for this partner, overriding the\n'submissionDeadlineDefault' for the Call for Proposals."
submission_deadline: "CallForProposalsPartnerGraphQLField" = (
CallForProposalsPartnerGraphQLField("submissionDeadline")
)
"The submission deadline for this partner. This will be the\n'submissionDeadlineOverride' if specified, but otherwise the\n'submissionDeadlineDefault' of the Call for Proposals itself."
[docs]
def fields(
self, *subfields: CallForProposalsPartnerGraphQLField
) -> "CallForProposalsPartnerFields":
"""Subfields should come from the CallForProposalsPartnerFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "CallForProposalsPartnerFields":
self._alias = alias
return self
[docs]
class CallsForProposalsSelectResultFields(GraphQLField):
[docs]
@classmethod
def matches(cls) -> "CallForProposalsFields":
return CallForProposalsFields("matches")
has_more: "CallsForProposalsSelectResultGraphQLField" = (
CallsForProposalsSelectResultGraphQLField("hasMore")
)
[docs]
def fields(
self,
*subfields: Union[
CallsForProposalsSelectResultGraphQLField, "CallForProposalsFields"
],
) -> "CallsForProposalsSelectResultFields":
"""Subfields should come from the CallsForProposalsSelectResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "CallsForProposalsSelectResultFields":
self._alias = alias
return self
[docs]
class CatalogInfoFields(GraphQLField):
name: "CatalogInfoGraphQLField" = CatalogInfoGraphQLField("name")
"Catalog name option"
id: "CatalogInfoGraphQLField" = CatalogInfoGraphQLField("id")
"Catalog id string"
object_type: "CatalogInfoGraphQLField" = CatalogInfoGraphQLField("objectType")
"Catalog description of object morphology"
[docs]
def fields(self, *subfields: CatalogInfoGraphQLField) -> "CatalogInfoFields":
"""Subfields should come from the CatalogInfoFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "CatalogInfoFields":
self._alias = alias
return self
[docs]
class CategorizedTimeFields(GraphQLField):
"""A time amount broken into charge class categories."""
[docs]
@classmethod
def program(cls) -> "TimeSpanFields":
"""Time charged to the program / PI."""
return TimeSpanFields("program")
[docs]
@classmethod
def non_charged(cls) -> "TimeSpanFields":
"""Execution time that is not charged."""
return TimeSpanFields("nonCharged")
[docs]
@classmethod
def total(cls) -> "TimeSpanFields":
"""Total of program and uncharged times."""
return TimeSpanFields("total")
[docs]
def fields(
self, *subfields: Union[CategorizedTimeGraphQLField, "TimeSpanFields"]
) -> "CategorizedTimeFields":
"""Subfields should come from the CategorizedTimeFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "CategorizedTimeFields":
self._alias = alias
return self
[docs]
class CategorizedTimeRangeFields(GraphQLField):
"""A minimum to maximum categorized time estimate. The actual execution time
should vary between the two extremes, depending upon which observations and
groups are ultimately completed."""
[docs]
@classmethod
def minimum(cls) -> "CategorizedTimeFields":
"""Minimum remaining time estimate."""
return CategorizedTimeFields("minimum")
[docs]
@classmethod
def maximum(cls) -> "CategorizedTimeFields":
"""Maximum remaining time estimate."""
return CategorizedTimeFields("maximum")
[docs]
def fields(
self,
*subfields: Union[CategorizedTimeRangeGraphQLField, "CategorizedTimeFields"],
) -> "CategorizedTimeRangeFields":
"""Subfields should come from the CategorizedTimeRangeFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "CategorizedTimeRangeFields":
self._alias = alias
return self
[docs]
class ChangeProgramUserRoleResultFields(GraphQLField):
"""Result of the program user role update, which is the updated program user itself."""
[docs]
@classmethod
def program_user(cls) -> "ProgramUserFields":
return ProgramUserFields("programUser")
[docs]
def fields(
self,
*subfields: Union[ChangeProgramUserRoleResultGraphQLField, "ProgramUserFields"],
) -> "ChangeProgramUserRoleResultFields":
"""Subfields should come from the ChangeProgramUserRoleResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ChangeProgramUserRoleResultFields":
self._alias = alias
return self
[docs]
class ClassicalFields(GraphQLField):
"""Proposal properties for Regular Semester (Classical) CallForProposals."""
science_subtype: "ClassicalGraphQLField" = ClassicalGraphQLField("scienceSubtype")
"The science type of this Call for Proposals."
min_percent_time: "ClassicalGraphQLField" = ClassicalGraphQLField("minPercentTime")
"Minimum percentage of observing time required to consider this proposal\nsuccessful."
[docs]
@classmethod
def partner_splits(cls) -> "PartnerSplitFields":
"""Describes how time for the program will be apportioned across partners."""
return PartnerSplitFields("partnerSplits")
aeon_multi_facility: "ClassicalGraphQLField" = ClassicalGraphQLField(
"aeonMultiFacility"
)
"Whether this proposal is part of the AEON/Multi-facility program."
jwst_synergy: "ClassicalGraphQLField" = ClassicalGraphQLField("jwstSynergy")
"Whether this proposal has JWST synergy."
us_long_term: "ClassicalGraphQLField" = ClassicalGraphQLField("usLongTerm")
"Whether this is a US Long Term proposal."
consider_for_band_3: "ClassicalGraphQLField" = ClassicalGraphQLField(
"considerForBand3"
)
"Whether this proposal should be considered for Band 3. Defaults to UNSET\non creation; must be CONSIDER or DO_NOT_CONSIDER before the proposal can\nbe submitted."
[docs]
def fields(
self, *subfields: Union[ClassicalGraphQLField, "PartnerSplitFields"]
) -> "ClassicalFields":
"""Subfields should come from the ClassicalFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ClassicalFields":
self._alias = alias
return self
[docs]
class CloneGroupResultFields(GraphQLField):
[docs]
@classmethod
def new_group(cls) -> "GroupFields":
return GroupFields("newGroup")
[docs]
def fields(
self, *subfields: Union[CloneGroupResultGraphQLField, "GroupFields"]
) -> "CloneGroupResultFields":
"""Subfields should come from the CloneGroupResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "CloneGroupResultFields":
self._alias = alias
return self
[docs]
class CloneObservationResultFields(GraphQLField):
"""The result of cloning an observation, containing the new observation."""
[docs]
@classmethod
def new_observation(cls) -> "ObservationFields":
"""The new cloned (but possibly modified) observation."""
return ObservationFields("newObservation")
[docs]
def fields(
self, *subfields: Union[CloneObservationResultGraphQLField, "ObservationFields"]
) -> "CloneObservationResultFields":
"""Subfields should come from the CloneObservationResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "CloneObservationResultFields":
self._alias = alias
return self
[docs]
class CloneTargetResultFields(GraphQLField):
"""The result of cloning a target, containing the original and new targets."""
[docs]
@classmethod
def new_target(cls) -> "TargetFields":
"""The new cloned (but possibly modified) target"""
return TargetFields("newTarget")
[docs]
def fields(
self, *subfields: Union[CloneTargetResultGraphQLField, "TargetFields"]
) -> "CloneTargetResultFields":
"""Subfields should come from the CloneTargetResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "CloneTargetResultFields":
self._alias = alias
return self
[docs]
class CommissioningProgramReferenceFields(GraphQLField):
label: "CommissioningProgramReferenceGraphQLField" = (
CommissioningProgramReferenceGraphQLField("label")
)
type_: "CommissioningProgramReferenceGraphQLField" = (
CommissioningProgramReferenceGraphQLField("type")
)
instrument: "CommissioningProgramReferenceGraphQLField" = (
CommissioningProgramReferenceGraphQLField("instrument")
)
semester: "CommissioningProgramReferenceGraphQLField" = (
CommissioningProgramReferenceGraphQLField("semester")
)
semester_index: "CommissioningProgramReferenceGraphQLField" = (
CommissioningProgramReferenceGraphQLField("semesterIndex")
)
[docs]
def fields(
self, *subfields: CommissioningProgramReferenceGraphQLField
) -> "CommissioningProgramReferenceFields":
"""Subfields should come from the CommissioningProgramReferenceFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "CommissioningProgramReferenceFields":
self._alias = alias
return self
[docs]
class ConditionsEntryFields(GraphQLField):
id: "ConditionsEntryGraphQLField" = ConditionsEntryGraphQLField("id")
transaction_id: "ConditionsEntryGraphQLField" = ConditionsEntryGraphQLField(
"transactionId"
)
[docs]
@classmethod
def user(cls) -> "UserFields":
return UserFields("user")
timestamp: "ConditionsEntryGraphQLField" = ConditionsEntryGraphQLField("timestamp")
[docs]
@classmethod
def measurement(cls) -> "ConditionsMeasurementFields":
return ConditionsMeasurementFields("measurement")
[docs]
@classmethod
def intuition(cls) -> "ConditionsIntuitionFields":
return ConditionsIntuitionFields("intuition")
[docs]
def fields(
self,
*subfields: Union[
ConditionsEntryGraphQLField,
"ConditionsIntuitionFields",
"ConditionsMeasurementFields",
"UserFields",
],
) -> "ConditionsEntryFields":
"""Subfields should come from the ConditionsEntryFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ConditionsEntryFields":
self._alias = alias
return self
[docs]
class ConditionsExpectationFields(GraphQLField):
type_: "ConditionsExpectationGraphQLField" = ConditionsExpectationGraphQLField(
"type"
)
[docs]
@classmethod
def timeframe(cls) -> "TimeSpanFields":
return TimeSpanFields("timeframe")
[docs]
def fields(
self, *subfields: Union[ConditionsExpectationGraphQLField, "TimeSpanFields"]
) -> "ConditionsExpectationFields":
"""Subfields should come from the ConditionsExpectationFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ConditionsExpectationFields":
self._alias = alias
return self
[docs]
class ConditionsIntuitionFields(GraphQLField):
[docs]
@classmethod
def expectation(cls) -> "ConditionsExpectationFields":
return ConditionsExpectationFields("expectation")
seeing_trend: "ConditionsIntuitionGraphQLField" = ConditionsIntuitionGraphQLField(
"seeingTrend"
)
[docs]
def fields(
self,
*subfields: Union[
ConditionsIntuitionGraphQLField, "ConditionsExpectationFields"
],
) -> "ConditionsIntuitionFields":
"""Subfields should come from the ConditionsIntuitionFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ConditionsIntuitionFields":
self._alias = alias
return self
[docs]
class ConditionsMeasurementFields(GraphQLField):
source: "ConditionsMeasurementGraphQLField" = ConditionsMeasurementGraphQLField(
"source"
)
[docs]
@classmethod
def seeing(cls) -> "AngleFields":
return AngleFields("seeing")
extinction: "ConditionsMeasurementGraphQLField" = ConditionsMeasurementGraphQLField(
"extinction"
)
[docs]
@classmethod
def wavelength(cls) -> "WavelengthFields":
return WavelengthFields("wavelength")
[docs]
@classmethod
def azimuth(cls) -> "AngleFields":
return AngleFields("azimuth")
[docs]
@classmethod
def elevation(cls) -> "AngleFields":
return AngleFields("elevation")
[docs]
def fields(
self,
*subfields: Union[
ConditionsMeasurementGraphQLField, "AngleFields", "WavelengthFields"
],
) -> "ConditionsMeasurementFields":
"""Subfields should come from the ConditionsMeasurementFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ConditionsMeasurementFields":
self._alias = alias
return self
[docs]
class ConfigChangeEstimateFields(GraphQLField):
"""An individual configuration change before a step is executed. Multiple
items may change simultaneously (e.g., the science fold may move while the
Gcal filter is updated). ConfigChangeEstimate identifies a single item that will
be updated."""
name: "ConfigChangeEstimateGraphQLField" = ConfigChangeEstimateGraphQLField("name")
"Name of the item that changed."
description: "ConfigChangeEstimateGraphQLField" = ConfigChangeEstimateGraphQLField(
"description"
)
"A possibly longer description of what was updated."
[docs]
@classmethod
def estimate(cls) -> "TimeSpanFields":
"""Estimated time required to effectuate the change."""
return TimeSpanFields("estimate")
[docs]
def fields(
self, *subfields: Union[ConfigChangeEstimateGraphQLField, "TimeSpanFields"]
) -> "ConfigChangeEstimateFields":
"""Subfields should come from the ConfigChangeEstimateFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ConfigChangeEstimateFields":
self._alias = alias
return self
[docs]
class ConfigurationFields(GraphQLField):
[docs]
@classmethod
def conditions(cls) -> "ConfigurationConditionsFields":
return ConfigurationConditionsFields("conditions")
[docs]
@classmethod
def target(cls) -> "ConfigurationTargetFields":
return ConfigurationTargetFields("target")
[docs]
@classmethod
def observing_mode(cls) -> "ConfigurationObservingModeFields":
return ConfigurationObservingModeFields("observingMode")
[docs]
def fields(
self,
*subfields: Union[
ConfigurationGraphQLField,
"ConfigurationConditionsFields",
"ConfigurationObservingModeFields",
"ConfigurationTargetFields",
],
) -> "ConfigurationFields":
"""Subfields should come from the ConfigurationFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ConfigurationFields":
self._alias = alias
return self
[docs]
class ConfigurationConditionsFields(GraphQLField):
image_quality: "ConfigurationConditionsGraphQLField" = (
ConfigurationConditionsGraphQLField("imageQuality")
)
cloud_extinction: "ConfigurationConditionsGraphQLField" = (
ConfigurationConditionsGraphQLField("cloudExtinction")
)
sky_background: "ConfigurationConditionsGraphQLField" = (
ConfigurationConditionsGraphQLField("skyBackground")
)
water_vapor: "ConfigurationConditionsGraphQLField" = (
ConfigurationConditionsGraphQLField("waterVapor")
)
[docs]
def fields(
self, *subfields: ConfigurationConditionsGraphQLField
) -> "ConfigurationConditionsFields":
"""Subfields should come from the ConfigurationConditionsFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ConfigurationConditionsFields":
self._alias = alias
return self
[docs]
class ConfigurationFlamingos2LongSlitFields(GraphQLField):
disperser: "ConfigurationFlamingos2LongSlitGraphQLField" = (
ConfigurationFlamingos2LongSlitGraphQLField("disperser")
)
[docs]
def fields(
self, *subfields: ConfigurationFlamingos2LongSlitGraphQLField
) -> "ConfigurationFlamingos2LongSlitFields":
"""Subfields should come from the ConfigurationFlamingos2LongSlitFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ConfigurationFlamingos2LongSlitFields":
self._alias = alias
return self
[docs]
class ConfigurationGmosNorthImagingFields(GraphQLField):
filters: "ConfigurationGmosNorthImagingGraphQLField" = (
ConfigurationGmosNorthImagingGraphQLField("filters")
)
[docs]
def fields(
self, *subfields: ConfigurationGmosNorthImagingGraphQLField
) -> "ConfigurationGmosNorthImagingFields":
"""Subfields should come from the ConfigurationGmosNorthImagingFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ConfigurationGmosNorthImagingFields":
self._alias = alias
return self
[docs]
class ConfigurationGmosNorthLongSlitFields(GraphQLField):
grating: "ConfigurationGmosNorthLongSlitGraphQLField" = (
ConfigurationGmosNorthLongSlitGraphQLField("grating")
)
[docs]
def fields(
self, *subfields: ConfigurationGmosNorthLongSlitGraphQLField
) -> "ConfigurationGmosNorthLongSlitFields":
"""Subfields should come from the ConfigurationGmosNorthLongSlitFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ConfigurationGmosNorthLongSlitFields":
self._alias = alias
return self
[docs]
class ConfigurationGmosSouthImagingFields(GraphQLField):
filters: "ConfigurationGmosSouthImagingGraphQLField" = (
ConfigurationGmosSouthImagingGraphQLField("filters")
)
[docs]
def fields(
self, *subfields: ConfigurationGmosSouthImagingGraphQLField
) -> "ConfigurationGmosSouthImagingFields":
"""Subfields should come from the ConfigurationGmosSouthImagingFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ConfigurationGmosSouthImagingFields":
self._alias = alias
return self
[docs]
class ConfigurationGmosSouthLongSlitFields(GraphQLField):
grating: "ConfigurationGmosSouthLongSlitGraphQLField" = (
ConfigurationGmosSouthLongSlitGraphQLField("grating")
)
[docs]
def fields(
self, *subfields: ConfigurationGmosSouthLongSlitGraphQLField
) -> "ConfigurationGmosSouthLongSlitFields":
"""Subfields should come from the ConfigurationGmosSouthLongSlitFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ConfigurationGmosSouthLongSlitFields":
self._alias = alias
return self
[docs]
class ConfigurationIgrins2LongSlitFields(GraphQLField):
ignore: "ConfigurationIgrins2LongSlitGraphQLField" = (
ConfigurationIgrins2LongSlitGraphQLField("ignore")
)
[docs]
def fields(
self, *subfields: ConfigurationIgrins2LongSlitGraphQLField
) -> "ConfigurationIgrins2LongSlitFields":
"""Subfields should come from the ConfigurationIgrins2LongSlitFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ConfigurationIgrins2LongSlitFields":
self._alias = alias
return self
[docs]
class ConfigurationObservingModeFields(GraphQLField):
instrument: "ConfigurationObservingModeGraphQLField" = (
ConfigurationObservingModeGraphQLField("instrument")
)
mode: "ConfigurationObservingModeGraphQLField" = (
ConfigurationObservingModeGraphQLField("mode")
)
[docs]
@classmethod
def gmos_north_long_slit(cls) -> "ConfigurationGmosNorthLongSlitFields":
return ConfigurationGmosNorthLongSlitFields("gmosNorthLongSlit")
[docs]
@classmethod
def gmos_south_long_slit(cls) -> "ConfigurationGmosSouthLongSlitFields":
return ConfigurationGmosSouthLongSlitFields("gmosSouthLongSlit")
[docs]
@classmethod
def gmos_north_imaging(cls) -> "ConfigurationGmosNorthImagingFields":
return ConfigurationGmosNorthImagingFields("gmosNorthImaging")
[docs]
@classmethod
def gmos_south_imaging(cls) -> "ConfigurationGmosSouthImagingFields":
return ConfigurationGmosSouthImagingFields("gmosSouthImaging")
[docs]
@classmethod
def flamingos_2_long_slit(cls) -> "ConfigurationFlamingos2LongSlitFields":
return ConfigurationFlamingos2LongSlitFields("flamingos2LongSlit")
[docs]
@classmethod
def igrins_2_long_slit(cls) -> "ConfigurationIgrins2LongSlitFields":
return ConfigurationIgrins2LongSlitFields("igrins2LongSlit")
[docs]
@classmethod
def visitor(cls) -> "ConfigurationVisitorFields":
return ConfigurationVisitorFields("visitor")
[docs]
def fields(
self,
*subfields: Union[
ConfigurationObservingModeGraphQLField,
"ConfigurationFlamingos2LongSlitFields",
"ConfigurationGmosNorthImagingFields",
"ConfigurationGmosNorthLongSlitFields",
"ConfigurationGmosSouthImagingFields",
"ConfigurationGmosSouthLongSlitFields",
"ConfigurationIgrins2LongSlitFields",
"ConfigurationVisitorFields",
],
) -> "ConfigurationObservingModeFields":
"""Subfields should come from the ConfigurationObservingModeFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ConfigurationObservingModeFields":
self._alias = alias
return self
[docs]
class ConfigurationRequestFields(GraphQLField):
id: "ConfigurationRequestGraphQLField" = ConfigurationRequestGraphQLField("id")
[docs]
@classmethod
def program(cls) -> "ProgramFields":
return ProgramFields("program")
status: "ConfigurationRequestGraphQLField" = ConfigurationRequestGraphQLField(
"status"
)
justification: "ConfigurationRequestGraphQLField" = (
ConfigurationRequestGraphQLField("justification")
)
[docs]
@classmethod
def configuration(cls) -> "ConfigurationFields":
return ConfigurationFields("configuration")
applicable_observations: "ConfigurationRequestGraphQLField" = (
ConfigurationRequestGraphQLField("applicableObservations")
)
[docs]
def fields(
self,
*subfields: Union[
ConfigurationRequestGraphQLField, "ConfigurationFields", "ProgramFields"
],
) -> "ConfigurationRequestFields":
"""Subfields should come from the ConfigurationRequestFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ConfigurationRequestFields":
self._alias = alias
return self
[docs]
class ConfigurationRequestSelectResultFields(GraphQLField):
"""The matching configuration requests, limited to a maximum of 1000 entries."""
[docs]
@classmethod
def matches(cls) -> "ConfigurationRequestFields":
"""Matching configuration requests up to the return size limit of 1000"""
return ConfigurationRequestFields("matches")
has_more: "ConfigurationRequestSelectResultGraphQLField" = (
ConfigurationRequestSelectResultGraphQLField("hasMore")
)
"`true` when there were additional matches that were not returned."
[docs]
def fields(
self,
*subfields: Union[
ConfigurationRequestSelectResultGraphQLField, "ConfigurationRequestFields"
],
) -> "ConfigurationRequestSelectResultFields":
"""Subfields should come from the ConfigurationRequestSelectResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ConfigurationRequestSelectResultFields":
self._alias = alias
return self
[docs]
class ConfigurationTargetFields(GraphQLField):
"""A configuration target will define either coordinates or a region."""
[docs]
@classmethod
def coordinates(cls) -> "CoordinatesFields":
return CoordinatesFields("coordinates")
[docs]
@classmethod
def region(cls) -> "RegionFields":
return RegionFields("region")
[docs]
def fields(
self,
*subfields: Union[
ConfigurationTargetGraphQLField, "CoordinatesFields", "RegionFields"
],
) -> "ConfigurationTargetFields":
"""Subfields should come from the ConfigurationTargetFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ConfigurationTargetFields":
self._alias = alias
return self
[docs]
class ConfigurationVisitorFields(GraphQLField):
mode: "ConfigurationVisitorGraphQLField" = ConfigurationVisitorGraphQLField("mode")
[docs]
@classmethod
def radius(cls) -> "AngleFields":
return AngleFields("radius")
[docs]
def fields(
self, *subfields: Union[ConfigurationVisitorGraphQLField, "AngleFields"]
) -> "ConfigurationVisitorFields":
"""Subfields should come from the ConfigurationVisitorFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ConfigurationVisitorFields":
self._alias = alias
return self
[docs]
class ConstraintSetFields(GraphQLField):
image_quality: "ConstraintSetGraphQLField" = ConstraintSetGraphQLField(
"imageQuality"
)
"Image quality"
cloud_extinction: "ConstraintSetGraphQLField" = ConstraintSetGraphQLField(
"cloudExtinction"
)
"Cloud extinction"
sky_background: "ConstraintSetGraphQLField" = ConstraintSetGraphQLField(
"skyBackground"
)
"Sky background"
water_vapor: "ConstraintSetGraphQLField" = ConstraintSetGraphQLField("waterVapor")
"Water vapor"
[docs]
@classmethod
def elevation_range(cls) -> "ElevationRangeFields":
"""Either air mass range or elevation range"""
return ElevationRangeFields("elevationRange")
[docs]
def fields(
self, *subfields: Union[ConstraintSetGraphQLField, "ElevationRangeFields"]
) -> "ConstraintSetFields":
"""Subfields should come from the ConstraintSetFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ConstraintSetFields":
self._alias = alias
return self
[docs]
class ConstraintSetGroupFields(GraphQLField):
[docs]
@classmethod
def observations(
cls,
include_deleted: bool,
*,
offset: Optional[Any] = None,
limit: Optional[Any] = None,
) -> "ObservationSelectResultFields":
"""Observations associated with the common value"""
arguments: dict[str, dict[str, Any]] = {
"includeDeleted": {"type": "Boolean!", "value": include_deleted},
"OFFSET": {"type": "ObservationId", "value": offset},
"LIMIT": {"type": "NonNegInt", "value": limit},
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return ObservationSelectResultFields(
"observations", arguments=cleared_arguments
)
[docs]
@classmethod
def constraint_set(cls) -> "ConstraintSetFields":
"""Commonly held value across the observations"""
return ConstraintSetFields("constraintSet")
[docs]
@classmethod
def program(cls) -> "ProgramFields":
"""Link back to program."""
return ProgramFields("program")
[docs]
def fields(
self,
*subfields: Union[
ConstraintSetGroupGraphQLField,
"ConstraintSetFields",
"ObservationSelectResultFields",
"ProgramFields",
],
) -> "ConstraintSetGroupFields":
"""Subfields should come from the ConstraintSetGroupFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ConstraintSetGroupFields":
self._alias = alias
return self
[docs]
class ConstraintSetGroupSelectResultFields(GraphQLField):
"""The matching constraintSetGroup results, limited to a maximum of 1000 entries."""
[docs]
@classmethod
def matches(cls) -> "ConstraintSetGroupFields":
"""Matching constraintSetGroups up to the return size limit of 1000"""
return ConstraintSetGroupFields("matches")
has_more: "ConstraintSetGroupSelectResultGraphQLField" = (
ConstraintSetGroupSelectResultGraphQLField("hasMore")
)
"`true` when there were additional matches that were not returned."
[docs]
def fields(
self,
*subfields: Union[
ConstraintSetGroupSelectResultGraphQLField, "ConstraintSetGroupFields"
],
) -> "ConstraintSetGroupSelectResultFields":
"""Subfields should come from the ConstraintSetGroupSelectResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ConstraintSetGroupSelectResultFields":
self._alias = alias
return self
[docs]
class CoordinateLimitsFields(GraphQLField):
"""RA/Dec limits."""
[docs]
@classmethod
def ra_start(cls) -> "RightAscensionFields":
"""The start limit defines the beginning (inclusive) of an RA range in which
observations will be accepted."""
return RightAscensionFields("raStart")
[docs]
@classmethod
def ra_end(cls) -> "RightAscensionFields":
"""The end limit defines the end (inclusive) of an RA range in which observations
will be accepted."""
return RightAscensionFields("raEnd")
[docs]
@classmethod
def dec_start(cls) -> "DeclinationFields":
"""The start limit defines the beginning (inclusive) of a declination range in
which observations will be accepted."""
return DeclinationFields("decStart")
[docs]
@classmethod
def dec_end(cls) -> "DeclinationFields":
"""The end limit defines the end (inclusive) of a declination range in which
observations will be accepted."""
return DeclinationFields("decEnd")
[docs]
def fields(
self,
*subfields: Union[
CoordinateLimitsGraphQLField, "DeclinationFields", "RightAscensionFields"
],
) -> "CoordinateLimitsFields":
"""Subfields should come from the CoordinateLimitsFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "CoordinateLimitsFields":
self._alias = alias
return self
[docs]
class CoordinatesFields(GraphQLField):
[docs]
@classmethod
def ra(cls) -> "RightAscensionFields":
"""Right Ascension"""
return RightAscensionFields("ra")
[docs]
@classmethod
def dec(cls) -> "DeclinationFields":
"""Declination"""
return DeclinationFields("dec")
[docs]
def fields(
self,
*subfields: Union[
CoordinatesGraphQLField, "DeclinationFields", "RightAscensionFields"
],
) -> "CoordinatesFields":
"""Subfields should come from the CoordinatesFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "CoordinatesFields":
self._alias = alias
return self
[docs]
class CreateCallForProposalsResultFields(GraphQLField):
[docs]
@classmethod
def call_for_proposals(cls) -> "CallForProposalsFields":
return CallForProposalsFields("callForProposals")
[docs]
def fields(
self,
*subfields: Union[
CreateCallForProposalsResultGraphQLField, "CallForProposalsFields"
],
) -> "CreateCallForProposalsResultFields":
"""Subfields should come from the CreateCallForProposalsResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "CreateCallForProposalsResultFields":
self._alias = alias
return self
[docs]
class CreateGroupResultFields(GraphQLField):
"""The result of creating a new group."""
[docs]
@classmethod
def group(cls) -> "GroupFields":
"""The newly created group."""
return GroupFields("group")
[docs]
def fields(
self, *subfields: Union[CreateGroupResultGraphQLField, "GroupFields"]
) -> "CreateGroupResultFields":
"""Subfields should come from the CreateGroupResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "CreateGroupResultFields":
self._alias = alias
return self
[docs]
class CreateObservationResultFields(GraphQLField):
"""The result of creating a new observation."""
[docs]
@classmethod
def observation(cls) -> "ObservationFields":
"""The newly created observation."""
return ObservationFields("observation")
[docs]
def fields(
self,
*subfields: Union[CreateObservationResultGraphQLField, "ObservationFields"],
) -> "CreateObservationResultFields":
"""Subfields should come from the CreateObservationResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "CreateObservationResultFields":
self._alias = alias
return self
[docs]
class CreateProgramNoteResultFields(GraphQLField):
[docs]
@classmethod
def program_note(cls) -> "ProgramNoteFields":
"""The newly create program note."""
return ProgramNoteFields("programNote")
[docs]
def fields(
self,
*subfields: Union[CreateProgramNoteResultGraphQLField, "ProgramNoteFields"],
) -> "CreateProgramNoteResultFields":
"""Subfields should come from the CreateProgramNoteResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "CreateProgramNoteResultFields":
self._alias = alias
return self
[docs]
class CreateProgramResultFields(GraphQLField):
"""The result of creating a new program."""
[docs]
@classmethod
def program(cls) -> "ProgramFields":
"""The newly created program."""
return ProgramFields("program")
[docs]
def fields(
self, *subfields: Union[CreateProgramResultGraphQLField, "ProgramFields"]
) -> "CreateProgramResultFields":
"""Subfields should come from the CreateProgramResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "CreateProgramResultFields":
self._alias = alias
return self
[docs]
class CreateProposalResultFields(GraphQLField):
"""The result of creating new proposal"""
[docs]
@classmethod
def proposal(cls) -> "ProposalFields":
"""The newly created proposal."""
return ProposalFields("proposal")
[docs]
def fields(
self, *subfields: Union[CreateProposalResultGraphQLField, "ProposalFields"]
) -> "CreateProposalResultFields":
"""Subfields should come from the CreateProposalResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "CreateProposalResultFields":
self._alias = alias
return self
[docs]
class CreateTargetResultFields(GraphQLField):
"""The result of creating a new target."""
[docs]
@classmethod
def target(cls) -> "TargetFields":
"""The newly created target."""
return TargetFields("target")
[docs]
def fields(
self, *subfields: Union[CreateTargetResultGraphQLField, "TargetFields"]
) -> "CreateTargetResultFields":
"""Subfields should come from the CreateTargetResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "CreateTargetResultFields":
self._alias = alias
return self
[docs]
class CreateUserInvitationResultFields(GraphQLField):
[docs]
@classmethod
def invitation(cls) -> "UserInvitationFields":
"""The created invitation."""
return UserInvitationFields("invitation")
key: "CreateUserInvitationResultGraphQLField" = (
CreateUserInvitationResultGraphQLField("key")
)
"Give this key to the person you wish to invite. They can later redeem the invitation."
[docs]
def fields(
self,
*subfields: Union[
CreateUserInvitationResultGraphQLField, "UserInvitationFields"
],
) -> "CreateUserInvitationResultFields":
"""Subfields should come from the CreateUserInvitationResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "CreateUserInvitationResultFields":
self._alias = alias
return self
[docs]
class DarkFields(GraphQLField):
"""Dark calibration step"""
step_type: "DarkGraphQLField" = DarkGraphQLField("stepType")
"Step type"
[docs]
def fields(self, *subfields: DarkGraphQLField) -> "DarkFields":
"""Subfields should come from the DarkFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "DarkFields":
self._alias = alias
return self
[docs]
class DatasetFields(GraphQLField):
id: "DatasetGraphQLField" = DatasetGraphQLField("id")
"Dataset id."
[docs]
@classmethod
def step(cls) -> "StepRecordFields":
"""The corresponding step."""
return StepRecordFields("step")
index: "DatasetGraphQLField" = DatasetGraphQLField("index")
"Exposure index within the step."
[docs]
@classmethod
def reference(cls) -> "DatasetReferenceFields":
"""Dataset reference, assuming the observation has an observation reference."""
return DatasetReferenceFields("reference")
[docs]
@classmethod
def observation(cls) -> "ObservationFields":
"""Observation associated with this dataset."""
return ObservationFields("observation")
[docs]
@classmethod
def visit(cls) -> "VisitFields":
"""Visit associated with this dataset."""
return VisitFields("visit")
[docs]
@classmethod
def events(
cls, *, offset: Optional[Any] = None, limit: Optional[Any] = None
) -> "ExecutionEventSelectResultFields":
"""Events associated with the dataset."""
arguments: dict[str, dict[str, Any]] = {
"OFFSET": {"type": "ExecutionEventId", "value": offset},
"LIMIT": {"type": "NonNegInt", "value": limit},
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return ExecutionEventSelectResultFields("events", arguments=cleared_arguments)
filename: "DatasetGraphQLField" = DatasetGraphQLField("filename")
"Dataset filename."
qa_state: "DatasetGraphQLField" = DatasetGraphQLField("qaState")
"Dataset QA state, if any has been set."
comment: "DatasetGraphQLField" = DatasetGraphQLField("comment")
"Dataset comment, if any has been set."
idempotency_key: "DatasetGraphQLField" = DatasetGraphQLField("idempotencyKey")
"Idempotency key, if any. The IdempotencyKey may be provided by clients when\nthe dataset is created and is used to enable problem-free retry in the case of\nfailure."
[docs]
@classmethod
def interval(cls) -> "TimestampIntervalFields":
"""Dataset time interval, if the dataset collection has started."""
return TimestampIntervalFields("interval")
is_written: "DatasetGraphQLField" = DatasetGraphQLField("isWritten")
"Has the dataset been written to disk? Note, we assume the dataset has been\nwritten when an `END_WRITE` event is received from Observe."
[docs]
def fields(
self,
*subfields: Union[
DatasetGraphQLField,
"DatasetReferenceFields",
"ExecutionEventSelectResultFields",
"ObservationFields",
"StepRecordFields",
"TimestampIntervalFields",
"VisitFields",
],
) -> "DatasetFields":
"""Subfields should come from the DatasetFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "DatasetFields":
self._alias = alias
return self
[docs]
class DatasetChronicleEntryFields(GraphQLField):
"""The Chronicle entry for dataset updates."""
id: "DatasetChronicleEntryGraphQLField" = DatasetChronicleEntryGraphQLField("id")
transaction_id: "DatasetChronicleEntryGraphQLField" = (
DatasetChronicleEntryGraphQLField("transactionId")
)
[docs]
@classmethod
def user(cls) -> "UserFields":
"""The user who performed the insertion or update."""
return UserFields("user")
timestamp: "DatasetChronicleEntryGraphQLField" = DatasetChronicleEntryGraphQLField(
"timestamp"
)
"When the update happened."
operation: "DatasetChronicleEntryGraphQLField" = DatasetChronicleEntryGraphQLField(
"operation"
)
"The database operation that was performed."
[docs]
@classmethod
def dataset(cls) -> "DatasetFields":
"""The dataset that was inserted or updated."""
return DatasetFields("dataset")
mod_dataset_id: "DatasetChronicleEntryGraphQLField" = (
DatasetChronicleEntryGraphQLField("modDatasetId")
)
mod_step_id: "DatasetChronicleEntryGraphQLField" = (
DatasetChronicleEntryGraphQLField("modStepId")
)
mod_observation_id: "DatasetChronicleEntryGraphQLField" = (
DatasetChronicleEntryGraphQLField("modObservationId")
)
mod_visit_id: "DatasetChronicleEntryGraphQLField" = (
DatasetChronicleEntryGraphQLField("modVisitId")
)
mod_reference: "DatasetChronicleEntryGraphQLField" = (
DatasetChronicleEntryGraphQLField("modReference")
)
mod_filename: "DatasetChronicleEntryGraphQLField" = (
DatasetChronicleEntryGraphQLField("modFilename")
)
mod_qa_state: "DatasetChronicleEntryGraphQLField" = (
DatasetChronicleEntryGraphQLField("modQaState")
)
mod_interval: "DatasetChronicleEntryGraphQLField" = (
DatasetChronicleEntryGraphQLField("modInterval")
)
mod_comment: "DatasetChronicleEntryGraphQLField" = (
DatasetChronicleEntryGraphQLField("modComment")
)
new_dataset_id: "DatasetChronicleEntryGraphQLField" = (
DatasetChronicleEntryGraphQLField("newDatasetId")
)
new_step_id: "DatasetChronicleEntryGraphQLField" = (
DatasetChronicleEntryGraphQLField("newStepId")
)
new_observation_id: "DatasetChronicleEntryGraphQLField" = (
DatasetChronicleEntryGraphQLField("newObservationId")
)
new_visit_id: "DatasetChronicleEntryGraphQLField" = (
DatasetChronicleEntryGraphQLField("newVisitId")
)
new_reference: "DatasetChronicleEntryGraphQLField" = (
DatasetChronicleEntryGraphQLField("newReference")
)
new_filename: "DatasetChronicleEntryGraphQLField" = (
DatasetChronicleEntryGraphQLField("newFilename")
)
new_qa_state: "DatasetChronicleEntryGraphQLField" = (
DatasetChronicleEntryGraphQLField("newQaState")
)
[docs]
@classmethod
def new_interval(cls) -> "TimestampIntervalFields":
return TimestampIntervalFields("newInterval")
new_comment: "DatasetChronicleEntryGraphQLField" = (
DatasetChronicleEntryGraphQLField("newComment")
)
[docs]
def fields(
self,
*subfields: Union[
DatasetChronicleEntryGraphQLField,
"DatasetFields",
"TimestampIntervalFields",
"UserFields",
],
) -> "DatasetChronicleEntryFields":
"""Subfields should come from the DatasetChronicleEntryFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "DatasetChronicleEntryFields":
self._alias = alias
return self
[docs]
class DatasetChronicleEntrySelectResultFields(GraphQLField):
[docs]
@classmethod
def matches(cls) -> "DatasetChronicleEntryFields":
"""Matching entries up to the return size limit of 1000"""
return DatasetChronicleEntryFields("matches")
has_more: "DatasetChronicleEntrySelectResultGraphQLField" = (
DatasetChronicleEntrySelectResultGraphQLField("hasMore")
)
"`true` when there were additional matches that were not returned."
[docs]
def fields(
self,
*subfields: Union[
DatasetChronicleEntrySelectResultGraphQLField, "DatasetChronicleEntryFields"
],
) -> "DatasetChronicleEntrySelectResultFields":
"""Subfields should come from the DatasetChronicleEntrySelectResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "DatasetChronicleEntrySelectResultFields":
self._alias = alias
return self
[docs]
class DatasetEstimateFields(GraphQLField):
"""Time estimate for taking an individual dataset."""
[docs]
@classmethod
def exposure(cls) -> "TimeSpanFields":
"""The exposure time itself"""
return TimeSpanFields("exposure")
[docs]
@classmethod
def readout(cls) -> "TimeSpanFields":
"""Time required to readout the detector"""
return TimeSpanFields("readout")
[docs]
@classmethod
def write(cls) -> "TimeSpanFields":
"""Time required to write the data to the storage system"""
return TimeSpanFields("write")
[docs]
@classmethod
def estimate(cls) -> "TimeSpanFields":
"""Total estimate for the dataset, summing exposure, readout and write"""
return TimeSpanFields("estimate")
[docs]
def fields(
self, *subfields: Union[DatasetEstimateGraphQLField, "TimeSpanFields"]
) -> "DatasetEstimateFields":
"""Subfields should come from the DatasetEstimateFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "DatasetEstimateFields":
self._alias = alias
return self
[docs]
class DatasetEventFields(GraphQLField):
"""Dataset-level events. A single dataset will be associated with multiple events
as it makes its way through observe, readout and write stages."""
id: "DatasetEventGraphQLField" = DatasetEventGraphQLField("id")
"Event id."
[docs]
@classmethod
def visit(cls) -> "VisitFields":
"""Visit associated with the event."""
return VisitFields("visit")
[docs]
@classmethod
def observation(cls) -> "ObservationFields":
"""Observation whose execution produced this event."""
return ObservationFields("observation")
received: "DatasetEventGraphQLField" = DatasetEventGraphQLField("received")
"Time at which this event was received."
event_type: "DatasetEventGraphQLField" = DatasetEventGraphQLField("eventType")
"Event type."
[docs]
@classmethod
def atom(cls) -> "AtomRecordFields":
"""Atom associated with this event."""
return AtomRecordFields("atom")
[docs]
@classmethod
def step(cls) -> "StepRecordFields":
"""The associated step."""
return StepRecordFields("step")
dataset_stage: "DatasetEventGraphQLField" = DatasetEventGraphQLField("datasetStage")
"Dataset execution stage."
[docs]
@classmethod
def dataset(cls) -> "DatasetFields":
"""The associated dataset."""
return DatasetFields("dataset")
idempotency_key: "DatasetEventGraphQLField" = DatasetEventGraphQLField(
"idempotencyKey"
)
"Idempotency key, if any. The IdempotencyKey may be provided by clients when\nthe event is created and is used to enable problem-free retry in the case of\nfailure."
[docs]
def fields(
self,
*subfields: Union[
DatasetEventGraphQLField,
"AtomRecordFields",
"DatasetFields",
"ObservationFields",
"StepRecordFields",
"VisitFields",
],
) -> "DatasetEventFields":
"""Subfields should come from the DatasetEventFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "DatasetEventFields":
self._alias = alias
return self
[docs]
class DatasetReferenceFields(GraphQLField):
"""Dataset reference type, broken into its constituient parts and including
a formatted label."""
label: "DatasetReferenceGraphQLField" = DatasetReferenceGraphQLField("label")
"Formatted dataset reference label."
[docs]
@classmethod
def observation(cls) -> "ObservationReferenceFields":
"""The observation reference."""
return ObservationReferenceFields("observation")
step_index: "DatasetReferenceGraphQLField" = DatasetReferenceGraphQLField(
"stepIndex"
)
"The step index relative to its observation."
exposure_index: "DatasetReferenceGraphQLField" = DatasetReferenceGraphQLField(
"exposureIndex"
)
"The exposure index relative to its step."
[docs]
def fields(
self,
*subfields: Union[DatasetReferenceGraphQLField, "ObservationReferenceFields"],
) -> "DatasetReferenceFields":
"""Subfields should come from the DatasetReferenceFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "DatasetReferenceFields":
self._alias = alias
return self
[docs]
class DatasetSelectResultFields(GraphQLField):
"""The matching dataset results, limited to a maximum of 1000 entries."""
[docs]
@classmethod
def matches(cls) -> "DatasetFields":
"""Matching datasets up to the return size limit of 1000"""
return DatasetFields("matches")
has_more: "DatasetSelectResultGraphQLField" = DatasetSelectResultGraphQLField(
"hasMore"
)
"`true` when there were additional matches that were not returned."
[docs]
def fields(
self, *subfields: Union[DatasetSelectResultGraphQLField, "DatasetFields"]
) -> "DatasetSelectResultFields":
"""Subfields should come from the DatasetSelectResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "DatasetSelectResultFields":
self._alias = alias
return self
[docs]
class DateIntervalFields(GraphQLField):
"""Date interval marked by a start 'Date' (inclusive) and an end 'Date' (exclusive).
Dates are interpreted as local dates."""
start: "DateIntervalGraphQLField" = DateIntervalGraphQLField("start")
"Start date, local to the observation site, of the interval (inclusive)."
end: "DateIntervalGraphQLField" = DateIntervalGraphQLField("end")
"End date, local to the observation site, of the interval (exclusive)."
[docs]
def fields(self, *subfields: DateIntervalGraphQLField) -> "DateIntervalFields":
"""Subfields should come from the DateIntervalFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "DateIntervalFields":
self._alias = alias
return self
[docs]
class DeclinationFields(GraphQLField):
dms: "DeclinationGraphQLField" = DeclinationGraphQLField("dms")
"Declination in DD:MM:SS.SS format"
degrees: "DeclinationGraphQLField" = DeclinationGraphQLField("degrees")
"Declination in signed degrees"
microarcseconds: "DeclinationGraphQLField" = DeclinationGraphQLField(
"microarcseconds"
)
"Declination in signed µas"
[docs]
def fields(self, *subfields: DeclinationGraphQLField) -> "DeclinationFields":
"""Subfields should come from the DeclinationFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "DeclinationFields":
self._alias = alias
return self
[docs]
class DeclinationArcFields(GraphQLField):
type_: "DeclinationArcGraphQLField" = DeclinationArcGraphQLField("type")
[docs]
@classmethod
def start(cls) -> "DeclinationFields":
return DeclinationFields("start")
[docs]
@classmethod
def end(cls) -> "DeclinationFields":
return DeclinationFields("end")
[docs]
def fields(
self, *subfields: Union[DeclinationArcGraphQLField, "DeclinationFields"]
) -> "DeclinationArcFields":
"""Subfields should come from the DeclinationArcFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "DeclinationArcFields":
self._alias = alias
return self
[docs]
class DeleteProgramUserResultFields(GraphQLField):
"""The result of deleting a program user."""
result: "DeleteProgramUserResultGraphQLField" = DeleteProgramUserResultGraphQLField(
"result"
)
"`true` if a program user was deleted, `false` otherwise."
[docs]
def fields(
self, *subfields: DeleteProgramUserResultGraphQLField
) -> "DeleteProgramUserResultFields":
"""Subfields should come from the DeleteProgramUserResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "DeleteProgramUserResultFields":
self._alias = alias
return self
[docs]
class DeleteProposalResultFields(GraphQLField):
"""The result of deleting a proposal."""
result: "DeleteProposalResultGraphQLField" = DeleteProposalResultGraphQLField(
"result"
)
"`true` if a proposal was deleted, `false` otherwise."
[docs]
def fields(
self, *subfields: DeleteProposalResultGraphQLField
) -> "DeleteProposalResultFields":
"""Subfields should come from the DeleteProposalResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "DeleteProposalResultFields":
self._alias = alias
return self
[docs]
class DemoScienceFields(GraphQLField):
"""Proposal properties for Demo Science CallForProposals."""
science_subtype: "DemoScienceGraphQLField" = DemoScienceGraphQLField(
"scienceSubtype"
)
"The science type of this Call for Proposals."
to_o_activation: "DemoScienceGraphQLField" = DemoScienceGraphQLField(
"toOActivation"
)
"Whether (and how) the observations in this proposal are available for Target\nof Opportunity triggering."
min_percent_time: "DemoScienceGraphQLField" = DemoScienceGraphQLField(
"minPercentTime"
)
"Minimum percentage of observing time required to consider this proposal\nsuccessful."
[docs]
def fields(self, *subfields: DemoScienceGraphQLField) -> "DemoScienceFields":
"""Subfields should come from the DemoScienceFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "DemoScienceFields":
self._alias = alias
return self
[docs]
class DetectorEstimateFields(GraphQLField):
"""Time estimate for a single detector. Some instruments will employ multiple
detectors per step."""
name: "DetectorEstimateGraphQLField" = DetectorEstimateGraphQLField("name")
"Indicates which detector is estimated here"
description: "DetectorEstimateGraphQLField" = DetectorEstimateGraphQLField(
"description"
)
"Detector description"
[docs]
@classmethod
def dataset(cls) -> "DatasetEstimateFields":
"""Time estimate for a single dataset produced by this detector"""
return DatasetEstimateFields("dataset")
count: "DetectorEstimateGraphQLField" = DetectorEstimateGraphQLField("count")
"Count of datasets to be produced by the detector"
[docs]
@classmethod
def estimate(cls) -> "TimeSpanFields":
"""Total time estimate for the detector, which is the sum of the individual
dataset estimate multiplied by the count."""
return TimeSpanFields("estimate")
[docs]
def fields(
self,
*subfields: Union[
DetectorEstimateGraphQLField, "DatasetEstimateFields", "TimeSpanFields"
],
) -> "DetectorEstimateFields":
"""Subfields should come from the DetectorEstimateFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "DetectorEstimateFields":
self._alias = alias
return self
[docs]
class DirectorsTimeFields(GraphQLField):
"""Proposal properties for Director's Time CallForProposals."""
science_subtype: "DirectorsTimeGraphQLField" = DirectorsTimeGraphQLField(
"scienceSubtype"
)
"The science type of this Call for Proposals."
to_o_activation: "DirectorsTimeGraphQLField" = DirectorsTimeGraphQLField(
"toOActivation"
)
"Whether (and how) the observations in this proposal are available for Target\nof Opportunity triggering."
min_percent_time: "DirectorsTimeGraphQLField" = DirectorsTimeGraphQLField(
"minPercentTime"
)
"Minimum percentage of observing time required to consider this proposal\nsuccessful."
[docs]
def fields(self, *subfields: DirectorsTimeGraphQLField) -> "DirectorsTimeFields":
"""Subfields should come from the DirectorsTimeFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "DirectorsTimeFields":
self._alias = alias
return self
[docs]
class ElevationRangeFields(GraphQLField):
"""Either air mass range or elevation range"""
[docs]
@classmethod
def air_mass(cls) -> "AirMassRangeFields":
"""AirMass range if elevation range is an Airmass range"""
return AirMassRangeFields("airMass")
[docs]
@classmethod
def hour_angle(cls) -> "HourAngleRangeFields":
"""Hour angle range if elevation range is an Hour angle range"""
return HourAngleRangeFields("hourAngle")
[docs]
def fields(
self,
*subfields: Union[
ElevationRangeGraphQLField, "AirMassRangeFields", "HourAngleRangeFields"
],
) -> "ElevationRangeFields":
"""Subfields should come from the ElevationRangeFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ElevationRangeFields":
self._alias = alias
return self
[docs]
class EmailFields(GraphQLField):
sender_email: "EmailGraphQLField" = EmailGraphQLField("senderEmail")
"Sender email address"
recipient_email: "EmailGraphQLField" = EmailGraphQLField("recipientEmail")
"Recipient email address"
subject: "EmailGraphQLField" = EmailGraphQLField("subject")
"Email subject"
text_message: "EmailGraphQLField" = EmailGraphQLField("textMessage")
"Text format message"
html_message: "EmailGraphQLField" = EmailGraphQLField("htmlMessage")
"Html format message"
original_time: "EmailGraphQLField" = EmailGraphQLField("originalTime")
"Original time of the email sending attempt"
status: "EmailGraphQLField" = EmailGraphQLField("status")
"The status of the email"
status_time: "EmailGraphQLField" = EmailGraphQLField("statusTime")
"The time of the last status update"
[docs]
def fields(self, *subfields: EmailGraphQLField) -> "EmailFields":
"""Subfields should come from the EmailFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "EmailFields":
self._alias = alias
return self
[docs]
class EmissionLineIntegratedFields(GraphQLField):
[docs]
@classmethod
def wavelength(cls) -> "WavelengthFields":
return WavelengthFields("wavelength")
line_width: "EmissionLineIntegratedGraphQLField" = (
EmissionLineIntegratedGraphQLField("lineWidth")
)
"km/s"
[docs]
@classmethod
def line_flux(cls) -> "LineFluxIntegratedFields":
return LineFluxIntegratedFields("lineFlux")
[docs]
def fields(
self,
*subfields: Union[
EmissionLineIntegratedGraphQLField,
"LineFluxIntegratedFields",
"WavelengthFields",
],
) -> "EmissionLineIntegratedFields":
"""Subfields should come from the EmissionLineIntegratedFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "EmissionLineIntegratedFields":
self._alias = alias
return self
[docs]
class EmissionLineSurfaceFields(GraphQLField):
[docs]
@classmethod
def wavelength(cls) -> "WavelengthFields":
return WavelengthFields("wavelength")
line_width: "EmissionLineSurfaceGraphQLField" = EmissionLineSurfaceGraphQLField(
"lineWidth"
)
"km/s"
[docs]
@classmethod
def line_flux(cls) -> "LineFluxSurfaceFields":
return LineFluxSurfaceFields("lineFlux")
[docs]
def fields(
self,
*subfields: Union[
EmissionLineSurfaceGraphQLField, "LineFluxSurfaceFields", "WavelengthFields"
],
) -> "EmissionLineSurfaceFields":
"""Subfields should come from the EmissionLineSurfaceFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "EmissionLineSurfaceFields":
self._alias = alias
return self
[docs]
class EmissionLinesIntegratedFields(GraphQLField):
[docs]
@classmethod
def lines(cls) -> "EmissionLineIntegratedFields":
return EmissionLineIntegratedFields("lines")
[docs]
@classmethod
def flux_density_continuum(cls) -> "FluxDensityContinuumIntegratedFields":
return FluxDensityContinuumIntegratedFields("fluxDensityContinuum")
[docs]
def fields(
self,
*subfields: Union[
EmissionLinesIntegratedGraphQLField,
"EmissionLineIntegratedFields",
"FluxDensityContinuumIntegratedFields",
],
) -> "EmissionLinesIntegratedFields":
"""Subfields should come from the EmissionLinesIntegratedFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "EmissionLinesIntegratedFields":
self._alias = alias
return self
[docs]
class EmissionLinesSurfaceFields(GraphQLField):
[docs]
@classmethod
def lines(cls) -> "EmissionLineSurfaceFields":
return EmissionLineSurfaceFields("lines")
[docs]
@classmethod
def flux_density_continuum(cls) -> "FluxDensityContinuumSurfaceFields":
return FluxDensityContinuumSurfaceFields("fluxDensityContinuum")
[docs]
def fields(
self,
*subfields: Union[
EmissionLinesSurfaceGraphQLField,
"EmissionLineSurfaceFields",
"FluxDensityContinuumSurfaceFields",
],
) -> "EmissionLinesSurfaceFields":
"""Subfields should come from the EmissionLinesSurfaceFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "EmissionLinesSurfaceFields":
self._alias = alias
return self
[docs]
class EngineeringProgramReferenceFields(GraphQLField):
label: "EngineeringProgramReferenceGraphQLField" = (
EngineeringProgramReferenceGraphQLField("label")
)
type_: "EngineeringProgramReferenceGraphQLField" = (
EngineeringProgramReferenceGraphQLField("type")
)
instrument: "EngineeringProgramReferenceGraphQLField" = (
EngineeringProgramReferenceGraphQLField("instrument")
)
semester: "EngineeringProgramReferenceGraphQLField" = (
EngineeringProgramReferenceGraphQLField("semester")
)
semester_index: "EngineeringProgramReferenceGraphQLField" = (
EngineeringProgramReferenceGraphQLField("semesterIndex")
)
[docs]
def fields(
self, *subfields: EngineeringProgramReferenceGraphQLField
) -> "EngineeringProgramReferenceFields":
"""Subfields should come from the EngineeringProgramReferenceFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "EngineeringProgramReferenceFields":
self._alias = alias
return self
[docs]
class EnumeratedTelescopeConfigGeneratorFields(GraphQLField):
"""In the `ENUMERATED` option offsets are explicitly specified instead of calculated."""
[docs]
@classmethod
def values(cls) -> "TelescopeConfigFields":
return TelescopeConfigFields("values")
[docs]
def fields(
self,
*subfields: Union[
EnumeratedTelescopeConfigGeneratorGraphQLField, "TelescopeConfigFields"
],
) -> "EnumeratedTelescopeConfigGeneratorFields":
"""Subfields should come from the EnumeratedTelescopeConfigGeneratorFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "EnumeratedTelescopeConfigGeneratorFields":
self._alias = alias
return self
[docs]
class ExampleProgramReferenceFields(GraphQLField):
label: "ExampleProgramReferenceGraphQLField" = ExampleProgramReferenceGraphQLField(
"label"
)
type_: "ExampleProgramReferenceGraphQLField" = ExampleProgramReferenceGraphQLField(
"type"
)
instrument: "ExampleProgramReferenceGraphQLField" = (
ExampleProgramReferenceGraphQLField("instrument")
)
[docs]
def fields(
self, *subfields: ExampleProgramReferenceGraphQLField
) -> "ExampleProgramReferenceFields":
"""Subfields should come from the ExampleProgramReferenceFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ExampleProgramReferenceFields":
self._alias = alias
return self
[docs]
class ExecutionFields(GraphQLField):
[docs]
@classmethod
def digest(cls) -> "CalculatedExecutionDigestFields":
"""Calculations dependent on the sequence, such as planned time and offsets.
If a sequence cannot be generated for this observation, `null` is returned
along with warning messages."""
return CalculatedExecutionDigestFields("digest")
execution_state: "ExecutionGraphQLField" = ExecutionGraphQLField("executionState")
"Determines the execution state as a whole of this observation."
[docs]
@classmethod
def atom_records(
cls, *, offset: Optional[Any] = None, limit: Optional[Any] = None
) -> "AtomRecordSelectResultFields":
"""Executed (or at least partially executed) atom records, across all visits,
ordered by execution order of the first contained step."""
arguments: dict[str, dict[str, Any]] = {
"OFFSET": {"type": "PosInt", "value": offset},
"LIMIT": {"type": "NonNegInt", "value": limit},
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return AtomRecordSelectResultFields("atomRecords", arguments=cleared_arguments)
[docs]
@classmethod
def datasets(
cls, *, offset: Optional[Any] = None, limit: Optional[Any] = None
) -> "DatasetSelectResultFields":
"""Datasets associated with the observation, across all visits."""
arguments: dict[str, dict[str, Any]] = {
"OFFSET": {"type": "DatasetId", "value": offset},
"LIMIT": {"type": "NonNegInt", "value": limit},
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return DatasetSelectResultFields("datasets", arguments=cleared_arguments)
[docs]
@classmethod
def events(
cls, *, offset: Optional[Any] = None, limit: Optional[Any] = None
) -> "ExecutionEventSelectResultFields":
"""Events associated with the observation, across all visits."""
arguments: dict[str, dict[str, Any]] = {
"OFFSET": {"type": "ExecutionEventId", "value": offset},
"LIMIT": {"type": "NonNegInt", "value": limit},
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return ExecutionEventSelectResultFields("events", arguments=cleared_arguments)
[docs]
@classmethod
def visits(
cls, *, offset: Optional[Any] = None, limit: Optional[Any] = None
) -> "VisitSelectResultFields":
"""Visits associated with the observation."""
arguments: dict[str, dict[str, Any]] = {
"OFFSET": {"type": "VisitId", "value": offset},
"LIMIT": {"type": "NonNegInt", "value": limit},
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return VisitSelectResultFields("visits", arguments=cleared_arguments)
[docs]
@classmethod
def time_charge(cls) -> "CategorizedTimeFields":
"""Time accounting calculation for this observation."""
return CategorizedTimeFields("timeCharge")
[docs]
def fields(
self,
*subfields: Union[
ExecutionGraphQLField,
"AtomRecordSelectResultFields",
"CalculatedExecutionDigestFields",
"CategorizedTimeFields",
"DatasetSelectResultFields",
"ExecutionEventSelectResultFields",
"VisitSelectResultFields",
],
) -> "ExecutionFields":
"""Subfields should come from the ExecutionFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ExecutionFields":
self._alias = alias
return self
[docs]
class ExecutionConfigFields(GraphQLField):
"""Execution configuration. All but one of the instruments will be `null`."""
instrument: "ExecutionConfigGraphQLField" = ExecutionConfigGraphQLField(
"instrument"
)
"Instrument type. This will indicate which of the instrument-specific fields\nis defined."
[docs]
@classmethod
def flamingos_2(cls) -> "Flamingos2ExecutionConfigFields":
"""Flamingos 2 execution config. This will be null unless the `instrument` is
`FLAMINGOS2`."""
return Flamingos2ExecutionConfigFields("flamingos2")
[docs]
@classmethod
def ghost(cls) -> "GhostExecutionConfigFields":
"""GHOST execution config. This will be null unless the `instrument` is `GHOST`."""
return GhostExecutionConfigFields("ghost")
[docs]
@classmethod
def gmos_north(cls) -> "GmosNorthExecutionConfigFields":
"""GMOS North execution config. This will be null unless the `instrument` is
`GMOS_NORTH`."""
return GmosNorthExecutionConfigFields("gmosNorth")
[docs]
@classmethod
def gmos_south(cls) -> "GmosSouthExecutionConfigFields":
"""GMOS South execution config. This will be null unless the `instrument` is
`GMOS_SOUTH`."""
return GmosSouthExecutionConfigFields("gmosSouth")
[docs]
@classmethod
def igrins_2(cls) -> "Igrins2ExecutionConfigFields":
"""IGRINS-2 execution config. This will be null unless the `instrument` is
`IGRINS2`."""
return Igrins2ExecutionConfigFields("igrins2")
[docs]
def fields(
self,
*subfields: Union[
ExecutionConfigGraphQLField,
"Flamingos2ExecutionConfigFields",
"GhostExecutionConfigFields",
"GmosNorthExecutionConfigFields",
"GmosSouthExecutionConfigFields",
"Igrins2ExecutionConfigFields",
],
) -> "ExecutionConfigFields":
"""Subfields should come from the ExecutionConfigFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ExecutionConfigFields":
self._alias = alias
return self
[docs]
class ExecutionDigestFields(GraphQLField):
"""Summarizes the execution setup time and sequences."""
[docs]
@classmethod
def setup(cls) -> "SetupTimeFields":
"""Setup time calculations."""
return SetupTimeFields("setup")
setup_count: "ExecutionDigestGraphQLField" = ExecutionDigestGraphQLField(
"setupCount"
)
"Estimated number of setups required to complete this observation."
[docs]
@classmethod
def acquisition(cls) -> "SequenceDigestFields":
"""Acquisition sequence summary."""
return SequenceDigestFields("acquisition")
[docs]
@classmethod
def science(cls) -> "SequenceDigestFields":
"""Science sequence summary."""
return SequenceDigestFields("science")
[docs]
def fields(
self,
*subfields: Union[
ExecutionDigestGraphQLField, "SequenceDigestFields", "SetupTimeFields"
],
) -> "ExecutionDigestFields":
"""Subfields should come from the ExecutionDigestFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ExecutionDigestFields":
self._alias = alias
return self
[docs]
class ExecutionEventInterface(GraphQLField):
"""Execution event (sequence, step, or dataset events)"""
id: "ExecutionEventGraphQLField" = ExecutionEventGraphQLField("id")
"Event id."
[docs]
@classmethod
def visit(cls) -> "VisitFields":
"""Visit associated with the event."""
return VisitFields("visit")
[docs]
@classmethod
def observation(cls) -> "ObservationFields":
"""Observation whose execution produced this event."""
return ObservationFields("observation")
received: "ExecutionEventGraphQLField" = ExecutionEventGraphQLField("received")
"Time at which this event was received."
event_type: "ExecutionEventGraphQLField" = ExecutionEventGraphQLField("eventType")
"Event type."
idempotency_key: "ExecutionEventGraphQLField" = ExecutionEventGraphQLField(
"idempotencyKey"
)
"Idempotency key, if any. The IdempotencyKey may be provided by clients when\nthe event is created and is used to enable problem-free retry in the case of\nfailure."
[docs]
def fields(
self,
*subfields: Union[
ExecutionEventGraphQLField, "ObservationFields", "VisitFields"
],
) -> "ExecutionEventInterface":
"""Subfields should come from the ExecutionEventInterface class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ExecutionEventInterface":
self._alias = alias
return self
[docs]
def on(self, type_name: str, *subfields: GraphQLField) -> "ExecutionEventInterface":
self._inline_fragments[type_name] = subfields
return self
[docs]
class ExecutionEventSelectResultFields(GraphQLField):
"""The matching ExecutionEvent results, limited to a maximum of 1000 entries."""
[docs]
@classmethod
def matches(cls) -> "ExecutionEventInterface":
"""Matching ExecutionEvents up to the return size limit of 1000"""
return ExecutionEventInterface("matches")
has_more: "ExecutionEventSelectResultGraphQLField" = (
ExecutionEventSelectResultGraphQLField("hasMore")
)
"`true` when there were additional matches that were not returned."
[docs]
def fields(
self,
*subfields: Union[
ExecutionEventSelectResultGraphQLField, "ExecutionEventInterface"
],
) -> "ExecutionEventSelectResultFields":
"""Subfields should come from the ExecutionEventSelectResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ExecutionEventSelectResultFields":
self._alias = alias
return self
[docs]
class ExposureTimeModeFields(GraphQLField):
"""Exposure time mode, either signal to noise or fixed"""
[docs]
@classmethod
def signal_to_noise(cls) -> "SignalToNoiseExposureTimeModeFields":
"""Signal to noise exposure time mode data, if applicable."""
return SignalToNoiseExposureTimeModeFields("signalToNoise")
[docs]
@classmethod
def time_and_count(cls) -> "TimeAndCountExposureTimeModeFields":
"""Time and Count mode data, if applicable."""
return TimeAndCountExposureTimeModeFields("timeAndCount")
[docs]
def fields(
self,
*subfields: Union[
ExposureTimeModeGraphQLField,
"SignalToNoiseExposureTimeModeFields",
"TimeAndCountExposureTimeModeFields",
],
) -> "ExposureTimeModeFields":
"""Subfields should come from the ExposureTimeModeFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ExposureTimeModeFields":
self._alias = alias
return self
[docs]
class FastTurnaroundFields(GraphQLField):
"""Proposal properties for Fast Turnaround CallForProposals."""
science_subtype: "FastTurnaroundGraphQLField" = FastTurnaroundGraphQLField(
"scienceSubtype"
)
"The science type of this Call for Proposals."
to_o_activation: "FastTurnaroundGraphQLField" = FastTurnaroundGraphQLField(
"toOActivation"
)
"Whether (and how) the observations in this proposal are available for Target\nof Opportunity triggering."
min_percent_time: "FastTurnaroundGraphQLField" = FastTurnaroundGraphQLField(
"minPercentTime"
)
"Minimum percentage of observing time required to consider this proposal\nsuccessful."
[docs]
@classmethod
def reviewer(cls) -> "ProgramUserFields":
"""Program User that will be selected as a reviewer for this program"""
return ProgramUserFields("reviewer")
[docs]
@classmethod
def mentor(cls) -> "ProgramUserFields":
"""Program User that will be selected as a mentor for this program.
Required when the reviewer does not have PhD educational status."""
return ProgramUserFields("mentor")
[docs]
def fields(
self, *subfields: Union[FastTurnaroundGraphQLField, "ProgramUserFields"]
) -> "FastTurnaroundFields":
"""Subfields should come from the FastTurnaroundFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "FastTurnaroundFields":
self._alias = alias
return self
[docs]
class Flamingos2AtomFields(GraphQLField):
"""Flamingos 2 atom, a collection of steps that should be executed in their entirety"""
id: "Flamingos2AtomGraphQLField" = Flamingos2AtomGraphQLField("id")
"Atom id"
description: "Flamingos2AtomGraphQLField" = Flamingos2AtomGraphQLField(
"description"
)
"Optional description of the atom."
observe_class: "Flamingos2AtomGraphQLField" = Flamingos2AtomGraphQLField(
"observeClass"
)
"Observe class for this atom as a whole (combined observe class for each of\nits steps)."
[docs]
@classmethod
def steps(cls) -> "Flamingos2StepFields":
"""Individual steps that comprise the atom"""
return Flamingos2StepFields("steps")
[docs]
def fields(
self, *subfields: Union[Flamingos2AtomGraphQLField, "Flamingos2StepFields"]
) -> "Flamingos2AtomFields":
"""Subfields should come from the Flamingos2AtomFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "Flamingos2AtomFields":
self._alias = alias
return self
[docs]
class Flamingos2CustomMaskFields(GraphQLField):
"""Flamingos 2 Custom Mask"""
filename: "Flamingos2CustomMaskGraphQLField" = Flamingos2CustomMaskGraphQLField(
"filename"
)
"Custom Mask Filename"
slit_width: "Flamingos2CustomMaskGraphQLField" = Flamingos2CustomMaskGraphQLField(
"slitWidth"
)
"Custom Slit Width"
[docs]
def fields(
self, *subfields: Flamingos2CustomMaskGraphQLField
) -> "Flamingos2CustomMaskFields":
"""Subfields should come from the Flamingos2CustomMaskFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "Flamingos2CustomMaskFields":
self._alias = alias
return self
[docs]
class Flamingos2DynamicFields(GraphQLField):
"""Flamingos 2 dynamic step configuration"""
[docs]
@classmethod
def exposure(cls) -> "TimeSpanFields":
"""Flamingos 2 exposure time"""
return TimeSpanFields("exposure")
disperser: "Flamingos2DynamicGraphQLField" = Flamingos2DynamicGraphQLField(
"disperser"
)
"Flamingos 2 disperser, if any."
filter_: "Flamingos2DynamicGraphQLField" = Flamingos2DynamicGraphQLField("filter")
"Flamingos 2 filter."
read_mode: "Flamingos2DynamicGraphQLField" = Flamingos2DynamicGraphQLField(
"readMode"
)
"Flamingos 2 read mode."
lyot_wheel: "Flamingos2DynamicGraphQLField" = Flamingos2DynamicGraphQLField(
"lyotWheel"
)
"Flamingos 2 Lyot Wheel."
[docs]
@classmethod
def fpu(cls) -> "Flamingos2FpuMaskFields":
"""Flamingos 2 FPU, if any."""
return Flamingos2FpuMaskFields("fpu")
decker: "Flamingos2DynamicGraphQLField" = Flamingos2DynamicGraphQLField("decker")
"Flamingos 2 decker."
readout_mode: "Flamingos2DynamicGraphQLField" = Flamingos2DynamicGraphQLField(
"readoutMode"
)
"Flamingos 2 readout mode."
reads: "Flamingos2DynamicGraphQLField" = Flamingos2DynamicGraphQLField("reads")
"Flamingos 2 reads."
[docs]
@classmethod
def central_wavelength(cls) -> "WavelengthFields":
"""Central wavelength, which is taken from the filter wavelength."""
return WavelengthFields("centralWavelength")
[docs]
def fields(
self,
*subfields: Union[
Flamingos2DynamicGraphQLField,
"Flamingos2FpuMaskFields",
"TimeSpanFields",
"WavelengthFields",
],
) -> "Flamingos2DynamicFields":
"""Subfields should come from the Flamingos2DynamicFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "Flamingos2DynamicFields":
self._alias = alias
return self
[docs]
class Flamingos2ExecutionConfigFields(GraphQLField):
"""Flamingos 2 Execution Config"""
[docs]
@classmethod
def static(cls) -> "Flamingos2StaticFields":
"""Flamingos 2 static configuration"""
return Flamingos2StaticFields("static")
[docs]
@classmethod
def acquisition(cls) -> "Flamingos2ExecutionSequenceFields":
"""Flamingos 2 acquisition execution sequence"""
return Flamingos2ExecutionSequenceFields("acquisition")
[docs]
@classmethod
def science(cls) -> "Flamingos2ExecutionSequenceFields":
"""Flamingos 2 science execution"""
return Flamingos2ExecutionSequenceFields("science")
[docs]
def fields(
self,
*subfields: Union[
Flamingos2ExecutionConfigGraphQLField,
"Flamingos2ExecutionSequenceFields",
"Flamingos2StaticFields",
],
) -> "Flamingos2ExecutionConfigFields":
"""Subfields should come from the Flamingos2ExecutionConfigFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "Flamingos2ExecutionConfigFields":
self._alias = alias
return self
[docs]
class Flamingos2ExecutionSequenceFields(GraphQLField):
"""Next atom to execute and potential future atoms."""
[docs]
@classmethod
def next_atom(cls) -> "Flamingos2AtomFields":
"""Next atom to execute."""
return Flamingos2AtomFields("nextAtom")
[docs]
@classmethod
def possible_future(cls) -> "Flamingos2AtomFields":
"""(Prefix of the) remaining atoms to execute, if any."""
return Flamingos2AtomFields("possibleFuture")
has_more: "Flamingos2ExecutionSequenceGraphQLField" = (
Flamingos2ExecutionSequenceGraphQLField("hasMore")
)
"Whether there are more anticipated atoms than those that appear in\n'possibleFuture'."
[docs]
def fields(
self,
*subfields: Union[
Flamingos2ExecutionSequenceGraphQLField, "Flamingos2AtomFields"
],
) -> "Flamingos2ExecutionSequenceFields":
"""Subfields should come from the Flamingos2ExecutionSequenceFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "Flamingos2ExecutionSequenceFields":
self._alias = alias
return self
[docs]
class Flamingos2FpuMaskFields(GraphQLField):
"""Flamingos 2 mask option, either builtin or custom mask"""
[docs]
@classmethod
def custom_mask(cls) -> "Flamingos2CustomMaskFields":
"""The custom mask, if in use"""
return Flamingos2CustomMaskFields("customMask")
builtin: "Flamingos2FpuMaskGraphQLField" = Flamingos2FpuMaskGraphQLField("builtin")
"Flamingos 2 builtin FPU, if in use"
[docs]
def fields(
self,
*subfields: Union[Flamingos2FpuMaskGraphQLField, "Flamingos2CustomMaskFields"],
) -> "Flamingos2FpuMaskFields":
"""Subfields should come from the Flamingos2FpuMaskFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "Flamingos2FpuMaskFields":
self._alias = alias
return self
[docs]
class Flamingos2LongSlitFields(GraphQLField):
"""Flamingos2 Long Slit mode"""
disperser: "Flamingos2LongSlitGraphQLField" = Flamingos2LongSlitGraphQLField(
"disperser"
)
"Flamingos2 Disperser"
filter_: "Flamingos2LongSlitGraphQLField" = Flamingos2LongSlitGraphQLField("filter")
"Flamingos2 Filter"
fpu: "Flamingos2LongSlitGraphQLField" = Flamingos2LongSlitGraphQLField("fpu")
"Flamingos2 FPU"
[docs]
@classmethod
def exposure_time_mode(cls) -> "ExposureTimeModeFields":
"""The exposure time mode used for ITC lookup for the science sequence."""
return ExposureTimeModeFields("exposureTimeMode")
explicit_read_mode: "Flamingos2LongSlitGraphQLField" = (
Flamingos2LongSlitGraphQLField("explicitReadMode")
)
"Optional explicitly specified F2 ReadMode. If set it overrides the\ndefault."
explicit_reads: "Flamingos2LongSlitGraphQLField" = Flamingos2LongSlitGraphQLField(
"explicitReads"
)
"Optional explicitly specified F2 Reads. If set it overrides the\ndefault."
decker: "Flamingos2LongSlitGraphQLField" = Flamingos2LongSlitGraphQLField("decker")
"The decker field is either explicitly specified in explicitDecker or else taken\nfrom defaultDecker"
default_decker: "Flamingos2LongSlitGraphQLField" = Flamingos2LongSlitGraphQLField(
"defaultDecker"
)
"Default decker, calculated based on the exposure time"
explicit_decker: "Flamingos2LongSlitGraphQLField" = Flamingos2LongSlitGraphQLField(
"explicitDecker"
)
"Optional explicitly specified F2 Decker. If set it overrides the\ndefault."
readout_mode: "Flamingos2LongSlitGraphQLField" = Flamingos2LongSlitGraphQLField(
"readoutMode"
)
"The readoutMode field is either explicitly specified in explicitReadoutMode or else taken\nfrom defaultReadoutMode"
default_readout_mode: "Flamingos2LongSlitGraphQLField" = (
Flamingos2LongSlitGraphQLField("defaultReadoutMode")
)
"Default readout mode, science"
explicit_readout_mode: "Flamingos2LongSlitGraphQLField" = (
Flamingos2LongSlitGraphQLField("explicitReadoutMode")
)
"Optional explicitly specified F2 Readout mode. If set it overrides the\ndefault."
[docs]
@classmethod
def offsets(cls) -> "OffsetFields":
"""Offsets, either explicitly specified in explicitOffsets
or else taken from defaultOffsets"""
return OffsetFields("offsets")
[docs]
@classmethod
def default_offsets(cls) -> "OffsetFields":
"""Default offsets."""
return OffsetFields("defaultOffsets")
[docs]
@classmethod
def explicit_offsets(cls) -> "OffsetFields":
"""Optional explicitly specified offsets. If set it overrides the
the default."""
return OffsetFields("explicitOffsets")
[docs]
@classmethod
def telluric_type(cls) -> "TelluricTypeFields":
"""Telluric type configuration for this observation."""
return TelluricTypeFields("telluricType")
[docs]
@classmethod
def acquisition(cls) -> "Flamingos2LongSlitAcquisitionFields":
"""Acquisition properties."""
return Flamingos2LongSlitAcquisitionFields("acquisition")
initial_disperser: "Flamingos2LongSlitGraphQLField" = (
Flamingos2LongSlitGraphQLField("initialDisperser")
)
"The disperser as it was initially selected. See the `disperser` field for the\ndisperser that will be used in the observation."
initial_filter: "Flamingos2LongSlitGraphQLField" = Flamingos2LongSlitGraphQLField(
"initialFilter"
)
"The filter as it was initially selected (if any). See the `filter` field\nfor the filter that will be used in the observation."
initial_fpu: "Flamingos2LongSlitGraphQLField" = Flamingos2LongSlitGraphQLField(
"initialFpu"
)
"The FPU as it was initially selected. See the `fpu` field for the FPU that\nwill be used in the observation."
[docs]
def fields(
self,
*subfields: Union[
Flamingos2LongSlitGraphQLField,
"ExposureTimeModeFields",
"Flamingos2LongSlitAcquisitionFields",
"OffsetFields",
"TelluricTypeFields",
],
) -> "Flamingos2LongSlitFields":
"""Subfields should come from the Flamingos2LongSlitFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "Flamingos2LongSlitFields":
self._alias = alias
return self
[docs]
class Flamingos2LongSlitAcquisitionFields(GraphQLField):
"""Flamingos2 Long Slit acquisition settings."""
filter_: "Flamingos2LongSlitAcquisitionGraphQLField" = (
Flamingos2LongSlitAcquisitionGraphQLField("filter")
)
"The filter that will be used in the acquisition sequence. This will be the\n`explicitFilter` if specified, but otherwise the `defaultFilter`."
default_filter: "Flamingos2LongSlitAcquisitionGraphQLField" = (
Flamingos2LongSlitAcquisitionGraphQLField("defaultFilter")
)
"The filter that will be used by default, if an explicit acquisition filter was\nnot specified. The default is calculated as the acquisition filter closest in\nwavelength to the observation's science filter."
explicit_filter: "Flamingos2LongSlitAcquisitionGraphQLField" = (
Flamingos2LongSlitAcquisitionGraphQLField("explicitFilter")
)
"An explicitly specified filter to use in acquisition (if any)."
[docs]
@classmethod
def exposure_time_mode(cls) -> "ExposureTimeModeFields":
"""The exposure time mode used for ITC lookup for the acquisition sequence."""
return ExposureTimeModeFields("exposureTimeMode")
[docs]
def fields(
self,
*subfields: Union[
Flamingos2LongSlitAcquisitionGraphQLField, "ExposureTimeModeFields"
],
) -> "Flamingos2LongSlitAcquisitionFields":
"""Subfields should come from the Flamingos2LongSlitAcquisitionFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "Flamingos2LongSlitAcquisitionFields":
self._alias = alias
return self
[docs]
class Flamingos2StaticFields(GraphQLField):
"""Unchanging (over the course of the sequence) configuration values"""
mos_pre_imaging: "Flamingos2StaticGraphQLField" = Flamingos2StaticGraphQLField(
"mosPreImaging"
)
"Is MOS Pre-Imaging Observation"
use_electronic_offsetting: "Flamingos2StaticGraphQLField" = (
Flamingos2StaticGraphQLField("useElectronicOffsetting")
)
"Whether to use electronic offsetting"
[docs]
def fields(
self, *subfields: Flamingos2StaticGraphQLField
) -> "Flamingos2StaticFields":
"""Subfields should come from the Flamingos2StaticFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "Flamingos2StaticFields":
self._alias = alias
return self
[docs]
class Flamingos2StepFields(GraphQLField):
"""Flmaingos 2 step with potential breakpoint"""
[docs]
@classmethod
def instrument_config(cls) -> "Flamingos2DynamicFields":
"""Instrument configuration for this step"""
return Flamingos2DynamicFields("instrumentConfig")
id: "Flamingos2StepGraphQLField" = Flamingos2StepGraphQLField("id")
"Step id"
breakpoint: "Flamingos2StepGraphQLField" = Flamingos2StepGraphQLField("breakpoint")
"Whether to pause before the execution of this step"
[docs]
@classmethod
def step_config(cls) -> "StepConfigInterface":
"""The sequence step itself"""
return StepConfigInterface("stepConfig")
[docs]
@classmethod
def telescope_config(cls) -> "TelescopeConfigFields":
"""The telescope configuration at this step."""
return TelescopeConfigFields("telescopeConfig")
[docs]
@classmethod
def estimate(cls) -> "StepEstimateFields":
"""Time estimate for this step's execution"""
return StepEstimateFields("estimate")
observe_class: "Flamingos2StepGraphQLField" = Flamingos2StepGraphQLField(
"observeClass"
)
"Observe class for this step"
[docs]
def fields(
self,
*subfields: Union[
Flamingos2StepGraphQLField,
"Flamingos2DynamicFields",
"StepConfigInterface",
"StepEstimateFields",
"TelescopeConfigFields",
],
) -> "Flamingos2StepFields":
"""Subfields should come from the Flamingos2StepFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "Flamingos2StepFields":
self._alias = alias
return self
[docs]
class FluxDensityContinuumIntegratedFields(GraphQLField):
value: "FluxDensityContinuumIntegratedGraphQLField" = (
FluxDensityContinuumIntegratedGraphQLField("value")
)
units: "FluxDensityContinuumIntegratedGraphQLField" = (
FluxDensityContinuumIntegratedGraphQLField("units")
)
error: "FluxDensityContinuumIntegratedGraphQLField" = (
FluxDensityContinuumIntegratedGraphQLField("error")
)
[docs]
def fields(
self, *subfields: FluxDensityContinuumIntegratedGraphQLField
) -> "FluxDensityContinuumIntegratedFields":
"""Subfields should come from the FluxDensityContinuumIntegratedFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "FluxDensityContinuumIntegratedFields":
self._alias = alias
return self
[docs]
class FluxDensityContinuumSurfaceFields(GraphQLField):
value: "FluxDensityContinuumSurfaceGraphQLField" = (
FluxDensityContinuumSurfaceGraphQLField("value")
)
units: "FluxDensityContinuumSurfaceGraphQLField" = (
FluxDensityContinuumSurfaceGraphQLField("units")
)
error: "FluxDensityContinuumSurfaceGraphQLField" = (
FluxDensityContinuumSurfaceGraphQLField("error")
)
[docs]
def fields(
self, *subfields: FluxDensityContinuumSurfaceGraphQLField
) -> "FluxDensityContinuumSurfaceFields":
"""Subfields should come from the FluxDensityContinuumSurfaceFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "FluxDensityContinuumSurfaceFields":
self._alias = alias
return self
[docs]
class FluxDensityEntryFields(GraphQLField):
[docs]
@classmethod
def wavelength(cls) -> "WavelengthFields":
return WavelengthFields("wavelength")
density: "FluxDensityEntryGraphQLField" = FluxDensityEntryGraphQLField("density")
[docs]
def fields(
self, *subfields: Union[FluxDensityEntryGraphQLField, "WavelengthFields"]
) -> "FluxDensityEntryFields":
"""Subfields should come from the FluxDensityEntryFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "FluxDensityEntryFields":
self._alias = alias
return self
[docs]
class GaussianSourceFields(GraphQLField):
"""Gaussian source, one of bandNormalized and emissionLines will be defined."""
[docs]
@classmethod
def fwhm(cls) -> "AngleFields":
"""full width at half maximum"""
return AngleFields("fwhm")
[docs]
@classmethod
def band_normalized(cls) -> "BandNormalizedIntegratedFields":
"""Band normalized spectral definition"""
return BandNormalizedIntegratedFields("bandNormalized")
[docs]
@classmethod
def emission_lines(cls) -> "EmissionLinesIntegratedFields":
"""Emission lines spectral definition"""
return EmissionLinesIntegratedFields("emissionLines")
[docs]
def fields(
self,
*subfields: Union[
GaussianSourceGraphQLField,
"AngleFields",
"BandNormalizedIntegratedFields",
"EmissionLinesIntegratedFields",
],
) -> "GaussianSourceFields":
"""Subfields should come from the GaussianSourceFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GaussianSourceFields":
self._alias = alias
return self
[docs]
class GcalFields(GraphQLField):
"""GCAL calibration step (flat / arc)"""
continuum: "GcalGraphQLField" = GcalGraphQLField("continuum")
"GCAL continuum, present if no arcs are used"
arcs: "GcalGraphQLField" = GcalGraphQLField("arcs")
"GCAL arcs, one or more present if no continuum is used"
filter_: "GcalGraphQLField" = GcalGraphQLField("filter")
"GCAL filter"
diffuser: "GcalGraphQLField" = GcalGraphQLField("diffuser")
"GCAL diffuser"
shutter: "GcalGraphQLField" = GcalGraphQLField("shutter")
"GCAL shutter"
step_type: "GcalGraphQLField" = GcalGraphQLField("stepType")
"Step type"
[docs]
def fields(self, *subfields: GcalGraphQLField) -> "GcalFields":
"""Subfields should come from the GcalFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GcalFields":
self._alias = alias
return self
[docs]
class GhostAtomFields(GraphQLField):
"""GHOST atom, a collection of steps that should be executed in their entirety"""
id: "GhostAtomGraphQLField" = GhostAtomGraphQLField("id")
"Atom id"
description: "GhostAtomGraphQLField" = GhostAtomGraphQLField("description")
"Optional description of the atom."
observe_class: "GhostAtomGraphQLField" = GhostAtomGraphQLField("observeClass")
"Observe class for this atom as a whole (combined observe class for each of\nits steps)."
[docs]
@classmethod
def steps(cls) -> "GhostStepFields":
"""Individual steps that comprise the atom"""
return GhostStepFields("steps")
[docs]
def fields(
self, *subfields: Union[GhostAtomGraphQLField, "GhostStepFields"]
) -> "GhostAtomFields":
"""Subfields should come from the GhostAtomFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GhostAtomFields":
self._alias = alias
return self
[docs]
class GhostDetectorFields(GraphQLField):
"""GHOST detector configuration for a single step."""
[docs]
@classmethod
def exposure_time(cls) -> "TimeSpanFields":
return TimeSpanFields("exposureTime")
exposure_count: "GhostDetectorGraphQLField" = GhostDetectorGraphQLField(
"exposureCount"
)
binning: "GhostDetectorGraphQLField" = GhostDetectorGraphQLField("binning")
read_mode: "GhostDetectorGraphQLField" = GhostDetectorGraphQLField("readMode")
[docs]
def fields(
self, *subfields: Union[GhostDetectorGraphQLField, "TimeSpanFields"]
) -> "GhostDetectorFields":
"""Subfields should come from the GhostDetectorFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GhostDetectorFields":
self._alias = alias
return self
[docs]
class GhostDetectorConfigFields(GraphQLField):
[docs]
@classmethod
def exposure_time_mode(cls) -> "ExposureTimeModeFields":
"""Exposure time mode for the detector."""
return ExposureTimeModeFields("exposureTimeMode")
binning: "GhostDetectorConfigGraphQLField" = GhostDetectorConfigGraphQLField(
"binning"
)
"Binning that will be used, either explicitly specified or default."
default_binning: "GhostDetectorConfigGraphQLField" = (
GhostDetectorConfigGraphQLField("defaultBinning")
)
"Default binning that will be used for the detector, if not explicitly\nspecified."
explicit_binning: "GhostDetectorConfigGraphQLField" = (
GhostDetectorConfigGraphQLField("explicitBinning")
)
"Explicit binning to use for the detector, if specified."
read_mode: "GhostDetectorConfigGraphQLField" = GhostDetectorConfigGraphQLField(
"readMode"
)
"Read mode for the detector, either explicitly specified or default."
default_read_mode: "GhostDetectorConfigGraphQLField" = (
GhostDetectorConfigGraphQLField("defaultReadMode")
)
"Default read mode that will be used for the detector, if not explicitly\nspecified."
explicit_read_mode: "GhostDetectorConfigGraphQLField" = (
GhostDetectorConfigGraphQLField("explicitReadMode")
)
"Explicit read mode for the detector, if specified."
[docs]
def fields(
self,
*subfields: Union[GhostDetectorConfigGraphQLField, "ExposureTimeModeFields"],
) -> "GhostDetectorConfigFields":
"""Subfields should come from the GhostDetectorConfigFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GhostDetectorConfigFields":
self._alias = alias
return self
[docs]
class GhostDynamicFields(GraphQLField):
"""GHOST instrument configuration for a single step."""
[docs]
@classmethod
def red(cls) -> "GhostDetectorFields":
return GhostDetectorFields("red")
[docs]
@classmethod
def blue(cls) -> "GhostDetectorFields":
return GhostDetectorFields("blue")
ifu_1_fiber_agitator: "GhostDynamicGraphQLField" = GhostDynamicGraphQLField(
"ifu1FiberAgitator"
)
ifu_2_fiber_agitator: "GhostDynamicGraphQLField" = GhostDynamicGraphQLField(
"ifu2FiberAgitator"
)
[docs]
@classmethod
def central_wavelength(cls) -> "WavelengthFields":
"""Central wavelength, which is fixed at 655 nm."""
return WavelengthFields("centralWavelength")
[docs]
def fields(
self,
*subfields: Union[
GhostDynamicGraphQLField, "GhostDetectorFields", "WavelengthFields"
],
) -> "GhostDynamicFields":
"""Subfields should come from the GhostDynamicFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GhostDynamicFields":
self._alias = alias
return self
[docs]
class GhostExecutionConfigFields(GraphQLField):
"""GHOST Execution Config"""
[docs]
@classmethod
def static(cls) -> "GhostStaticFields":
"""GHOST static configuration"""
return GhostStaticFields("static")
[docs]
@classmethod
def science(cls) -> "GhostExecutionSequenceFields":
"""GHOST science execution"""
return GhostExecutionSequenceFields("science")
[docs]
def fields(
self,
*subfields: Union[
GhostExecutionConfigGraphQLField,
"GhostExecutionSequenceFields",
"GhostStaticFields",
],
) -> "GhostExecutionConfigFields":
"""Subfields should come from the GhostExecutionConfigFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GhostExecutionConfigFields":
self._alias = alias
return self
[docs]
class GhostExecutionSequenceFields(GraphQLField):
"""Next atom to execute and potential future atoms."""
[docs]
@classmethod
def next_atom(cls) -> "GhostAtomFields":
"""Next atom to execute."""
return GhostAtomFields("nextAtom")
[docs]
@classmethod
def possible_future(cls) -> "GhostAtomFields":
"""(Prefix of the) remaining atoms to execute, if any."""
return GhostAtomFields("possibleFuture")
has_more: "GhostExecutionSequenceGraphQLField" = GhostExecutionSequenceGraphQLField(
"hasMore"
)
"Whether there are more anticipated atoms than those that appear in\n'possibleFuture'."
[docs]
def fields(
self, *subfields: Union[GhostExecutionSequenceGraphQLField, "GhostAtomFields"]
) -> "GhostExecutionSequenceFields":
"""Subfields should come from the GhostExecutionSequenceFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GhostExecutionSequenceFields":
self._alias = alias
return self
[docs]
class GhostIfuFields(GraphQLField):
"""GHOST IFU observing mode."""
step_count: "GhostIfuGraphQLField" = GhostIfuGraphQLField("stepCount")
"Number of steps requested."
resolution_mode: "GhostIfuGraphQLField" = GhostIfuGraphQLField("resolutionMode")
"Resolution mode."
[docs]
@classmethod
def red(cls) -> "GhostDetectorConfigFields":
"""Red detector config."""
return GhostDetectorConfigFields("red")
[docs]
@classmethod
def blue(cls) -> "GhostDetectorConfigFields":
"""Blue detector config."""
return GhostDetectorConfigFields("blue")
[docs]
@classmethod
def slit_viewing_camera_exposure_time(cls) -> "TimeSpanFields":
"""Slit viewing camera exposure time (if specified)."""
return TimeSpanFields("slitViewingCameraExposureTime")
ifu_1_agitator: "GhostIfuGraphQLField" = GhostIfuGraphQLField("ifu1Agitator")
"IFU 1 fiber agitator setting, either explicitly specified or else default."
default_ifu_1_agitator: "GhostIfuGraphQLField" = GhostIfuGraphQLField(
"defaultIfu1Agitator"
)
"Default IFU 1 fiber agitator setting, used if not explicitly specified."
explicit_ifu_1_agitator: "GhostIfuGraphQLField" = GhostIfuGraphQLField(
"explicitIfu1Agitator"
)
"IFU 1 fiber agitator setting, if explicitly specified."
ifu_2_agitator: "GhostIfuGraphQLField" = GhostIfuGraphQLField("ifu2Agitator")
"IFU 2 fiber agitator setting, either explicitly specified or else default."
default_ifu_2_agitator: "GhostIfuGraphQLField" = GhostIfuGraphQLField(
"defaultIfu2Agitator"
)
"Default IFU 2 fiber agitator setting, used if not explicitly specified."
explicit_ifu_2_agitator: "GhostIfuGraphQLField" = GhostIfuGraphQLField(
"explicitIfu2Agitator"
)
"IFU 2 fiber agitator setting, if explicitly specified."
[docs]
def fields(
self,
*subfields: Union[
GhostIfuGraphQLField, "GhostDetectorConfigFields", "TimeSpanFields"
],
) -> "GhostIfuFields":
"""Subfields should come from the GhostIfuFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GhostIfuFields":
self._alias = alias
return self
[docs]
class GhostStaticFields(GraphQLField):
"""GHOST configuration that applies across all steps."""
resolution_mode: "GhostStaticGraphQLField" = GhostStaticGraphQLField(
"resolutionMode"
)
[docs]
@classmethod
def slit_viewing_camera_exposure_time(cls) -> "TimeSpanFields":
return TimeSpanFields("slitViewingCameraExposureTime")
[docs]
def fields(
self, *subfields: Union[GhostStaticGraphQLField, "TimeSpanFields"]
) -> "GhostStaticFields":
"""Subfields should come from the GhostStaticFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GhostStaticFields":
self._alias = alias
return self
[docs]
class GhostStepFields(GraphQLField):
"""GHOST step with potential breakpoint."""
[docs]
@classmethod
def instrument_config(cls) -> "GhostDynamicFields":
"""Instrument configuration for this step"""
return GhostDynamicFields("instrumentConfig")
id: "GhostStepGraphQLField" = GhostStepGraphQLField("id")
"Step id"
breakpoint: "GhostStepGraphQLField" = GhostStepGraphQLField("breakpoint")
"Whether to pause before the execution of this step"
[docs]
@classmethod
def step_config(cls) -> "StepConfigInterface":
"""The sequence step itself"""
return StepConfigInterface("stepConfig")
[docs]
@classmethod
def telescope_config(cls) -> "TelescopeConfigFields":
"""The telescope configuration at this step."""
return TelescopeConfigFields("telescopeConfig")
[docs]
@classmethod
def estimate(cls) -> "StepEstimateFields":
"""Time estimate for this step's execution"""
return StepEstimateFields("estimate")
observe_class: "GhostStepGraphQLField" = GhostStepGraphQLField("observeClass")
"Observe class for this step"
[docs]
def fields(
self,
*subfields: Union[
GhostStepGraphQLField,
"GhostDynamicFields",
"StepConfigInterface",
"StepEstimateFields",
"TelescopeConfigFields",
],
) -> "GhostStepFields":
"""Subfields should come from the GhostStepFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GhostStepFields":
self._alias = alias
return self
[docs]
class GmosCcdModeFields(GraphQLField):
"""CCD Readout Configuration"""
x_bin: "GmosCcdModeGraphQLField" = GmosCcdModeGraphQLField("xBin")
"GMOS X-binning"
y_bin: "GmosCcdModeGraphQLField" = GmosCcdModeGraphQLField("yBin")
"GMOS Y-binning"
amp_count: "GmosCcdModeGraphQLField" = GmosCcdModeGraphQLField("ampCount")
"GMOS Amp Count"
amp_gain: "GmosCcdModeGraphQLField" = GmosCcdModeGraphQLField("ampGain")
"GMOS Amp Gain"
amp_read_mode: "GmosCcdModeGraphQLField" = GmosCcdModeGraphQLField("ampReadMode")
"GMOS Amp Read Mode"
[docs]
def fields(self, *subfields: GmosCcdModeGraphQLField) -> "GmosCcdModeFields":
"""Subfields should come from the GmosCcdModeFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GmosCcdModeFields":
self._alias = alias
return self
[docs]
class GmosCustomMaskFields(GraphQLField):
"""GMOS Custom Mask"""
filename: "GmosCustomMaskGraphQLField" = GmosCustomMaskGraphQLField("filename")
"Custom Mask Filename"
slit_width: "GmosCustomMaskGraphQLField" = GmosCustomMaskGraphQLField("slitWidth")
"Custom Slit Width"
[docs]
def fields(self, *subfields: GmosCustomMaskGraphQLField) -> "GmosCustomMaskFields":
"""Subfields should come from the GmosCustomMaskFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GmosCustomMaskFields":
self._alias = alias
return self
[docs]
class GmosGroupedImagingVariantFields(GraphQLField):
"""When doing "grouped" filter imaging, datasets associated with a particular
filter are collected consecutively before moving on to other filters (if any).
Sky datasets may be collected before and after each group of object datasets."""
order: "GmosGroupedImagingVariantGraphQLField" = (
GmosGroupedImagingVariantGraphQLField("order")
)
"Whether the filters should appear in the sequence in increasing or decreasing\norder by their wavelength."
[docs]
@classmethod
def offsets(cls) -> "TelescopeConfigGeneratorFields":
"""Offset generator for the science object datasets. The same offset sequence is
created for each filter using the specified generator."""
return TelescopeConfigGeneratorFields("offsets")
sky_count: "GmosGroupedImagingVariantGraphQLField" = (
GmosGroupedImagingVariantGraphQLField("skyCount")
)
"Number of sky positions to collect before and after object datasets. For\nexample, if set to 2 there will be two sky positions before a group of object\nexposures and two more after using the same filter as the object datasets."
[docs]
@classmethod
def sky_offsets(cls) -> "TelescopeConfigGeneratorFields":
"""Offset generator to use for the sky datasets."""
return TelescopeConfigGeneratorFields("skyOffsets")
[docs]
def fields(
self,
*subfields: Union[
GmosGroupedImagingVariantGraphQLField, "TelescopeConfigGeneratorFields"
],
) -> "GmosGroupedImagingVariantFields":
"""Subfields should come from the GmosGroupedImagingVariantFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GmosGroupedImagingVariantFields":
self._alias = alias
return self
[docs]
class GmosImagingVariantFields(GraphQLField):
"""The specific imaging sub-type, one of which will be defined and the remaining
options null."""
variant_type: "GmosImagingVariantGraphQLField" = GmosImagingVariantGraphQLField(
"variantType"
)
[docs]
@classmethod
def grouped(cls) -> "GmosGroupedImagingVariantFields":
"""Grouped mode collects all datasets for each filter before changing filters."""
return GmosGroupedImagingVariantFields("grouped")
[docs]
@classmethod
def interleaved(cls) -> "GmosInterleavedImagingVariantFields":
"""Interleaved mode cycles through all filters repeatedly."""
return GmosInterleavedImagingVariantFields("interleaved")
[docs]
@classmethod
def pre_imaging(cls) -> "GmosPreImagingVariantFields":
"""PreImaging mode is used for MOS mask creation."""
return GmosPreImagingVariantFields("preImaging")
[docs]
def fields(
self,
*subfields: Union[
GmosImagingVariantGraphQLField,
"GmosGroupedImagingVariantFields",
"GmosInterleavedImagingVariantFields",
"GmosPreImagingVariantFields",
],
) -> "GmosImagingVariantFields":
"""Subfields should come from the GmosImagingVariantFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GmosImagingVariantFields":
self._alias = alias
return self
[docs]
class GmosInterleavedImagingVariantFields(GraphQLField):
"""When doing "interleaved" filter imaging, the sequence repeatedly alternates
through the set of filters in use."""
[docs]
@classmethod
def offsets(cls) -> "TelescopeConfigGeneratorFields":
"""Offset generator for the science object datasets. The offset pattern is
applied to the sequence of science datasets as a whole."""
return TelescopeConfigGeneratorFields("offsets")
sky_count: "GmosInterleavedImagingVariantGraphQLField" = (
GmosInterleavedImagingVariantGraphQLField("skyCount")
)
"Number of sky positions to collect, per filter, before and after a series of\nobject datasets. For example, if set to 2 and 2 filters are in use, there\nwould be 4 sky positions before (2 per filter) and 4 after (2 per filter)."
[docs]
@classmethod
def sky_offsets(cls) -> "TelescopeConfigGeneratorFields":
"""Offset generator to use for the sky datasets."""
return TelescopeConfigGeneratorFields("skyOffsets")
[docs]
def fields(
self,
*subfields: Union[
GmosInterleavedImagingVariantGraphQLField, "TelescopeConfigGeneratorFields"
],
) -> "GmosInterleavedImagingVariantFields":
"""Subfields should come from the GmosInterleavedImagingVariantFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GmosInterleavedImagingVariantFields":
self._alias = alias
return self
[docs]
class GmosNodAndShuffleFields(GraphQLField):
[docs]
@classmethod
def pos_a(cls) -> "OffsetFields":
"""Offset position A"""
return OffsetFields("posA")
[docs]
@classmethod
def pos_b(cls) -> "OffsetFields":
"""Offset position B"""
return OffsetFields("posB")
e_offset: "GmosNodAndShuffleGraphQLField" = GmosNodAndShuffleGraphQLField("eOffset")
"Whether to use electronic offsetting"
shuffle_offset: "GmosNodAndShuffleGraphQLField" = GmosNodAndShuffleGraphQLField(
"shuffleOffset"
)
"Shuffle offset"
shuffle_cycles: "GmosNodAndShuffleGraphQLField" = GmosNodAndShuffleGraphQLField(
"shuffleCycles"
)
"Shuffle cycles"
[docs]
def fields(
self, *subfields: Union[GmosNodAndShuffleGraphQLField, "OffsetFields"]
) -> "GmosNodAndShuffleFields":
"""Subfields should come from the GmosNodAndShuffleFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GmosNodAndShuffleFields":
self._alias = alias
return self
[docs]
class GmosNorthAtomFields(GraphQLField):
"""GmosNorth atom, a collection of steps that should be executed in their entirety"""
id: "GmosNorthAtomGraphQLField" = GmosNorthAtomGraphQLField("id")
"Atom id"
description: "GmosNorthAtomGraphQLField" = GmosNorthAtomGraphQLField("description")
"Optional description of the atom."
observe_class: "GmosNorthAtomGraphQLField" = GmosNorthAtomGraphQLField(
"observeClass"
)
"Observe class for this atom as a whole (combined observe class for each of\nits steps)."
[docs]
@classmethod
def steps(cls) -> "GmosNorthStepFields":
"""Individual steps that comprise the atom"""
return GmosNorthStepFields("steps")
[docs]
def fields(
self, *subfields: Union[GmosNorthAtomGraphQLField, "GmosNorthStepFields"]
) -> "GmosNorthAtomFields":
"""Subfields should come from the GmosNorthAtomFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GmosNorthAtomFields":
self._alias = alias
return self
[docs]
class GmosNorthDynamicFields(GraphQLField):
"""GMOS North dynamic step configuration"""
[docs]
@classmethod
def exposure(cls) -> "TimeSpanFields":
"""GMOS exposure time"""
return TimeSpanFields("exposure")
[docs]
@classmethod
def readout(cls) -> "GmosCcdModeFields":
"""GMOS CCD Readout"""
return GmosCcdModeFields("readout")
dtax: "GmosNorthDynamicGraphQLField" = GmosNorthDynamicGraphQLField("dtax")
"GMOS detector x offset"
roi: "GmosNorthDynamicGraphQLField" = GmosNorthDynamicGraphQLField("roi")
"GMOS region of interest"
[docs]
@classmethod
def grating_config(cls) -> "GmosNorthGratingConfigFields":
"""GMOS North grating"""
return GmosNorthGratingConfigFields("gratingConfig")
filter_: "GmosNorthDynamicGraphQLField" = GmosNorthDynamicGraphQLField("filter")
"GMOS North filter"
[docs]
@classmethod
def fpu(cls) -> "GmosNorthFpuFields":
"""GMOS North FPU"""
return GmosNorthFpuFields("fpu")
[docs]
@classmethod
def central_wavelength(cls) -> "WavelengthFields":
"""Central wavelength, which is taken from the grating (if defined) or else
from the filter (if defined)."""
return WavelengthFields("centralWavelength")
[docs]
def fields(
self,
*subfields: Union[
GmosNorthDynamicGraphQLField,
"GmosCcdModeFields",
"GmosNorthFpuFields",
"GmosNorthGratingConfigFields",
"TimeSpanFields",
"WavelengthFields",
],
) -> "GmosNorthDynamicFields":
"""Subfields should come from the GmosNorthDynamicFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GmosNorthDynamicFields":
self._alias = alias
return self
[docs]
class GmosNorthExecutionConfigFields(GraphQLField):
"""GMOS North Execution Config"""
[docs]
@classmethod
def static(cls) -> "GmosNorthStaticFields":
"""GMOS North static configuration"""
return GmosNorthStaticFields("static")
[docs]
@classmethod
def acquisition(cls) -> "GmosNorthExecutionSequenceFields":
"""GMOS North acquisition execution sequence"""
return GmosNorthExecutionSequenceFields("acquisition")
[docs]
@classmethod
def science(cls) -> "GmosNorthExecutionSequenceFields":
"""GMOS North science execution"""
return GmosNorthExecutionSequenceFields("science")
[docs]
def fields(
self,
*subfields: Union[
GmosNorthExecutionConfigGraphQLField,
"GmosNorthExecutionSequenceFields",
"GmosNorthStaticFields",
],
) -> "GmosNorthExecutionConfigFields":
"""Subfields should come from the GmosNorthExecutionConfigFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GmosNorthExecutionConfigFields":
self._alias = alias
return self
[docs]
class GmosNorthExecutionSequenceFields(GraphQLField):
"""Next atom to execute and potential future atoms."""
[docs]
@classmethod
def next_atom(cls) -> "GmosNorthAtomFields":
"""Next atom to execute."""
return GmosNorthAtomFields("nextAtom")
[docs]
@classmethod
def possible_future(cls) -> "GmosNorthAtomFields":
"""(Prefix of the) remaining atoms to execute, if any."""
return GmosNorthAtomFields("possibleFuture")
has_more: "GmosNorthExecutionSequenceGraphQLField" = (
GmosNorthExecutionSequenceGraphQLField("hasMore")
)
"Whether there are more anticipated atoms than those that appear in\n'possibleFuture'."
[docs]
def fields(
self,
*subfields: Union[
GmosNorthExecutionSequenceGraphQLField, "GmosNorthAtomFields"
],
) -> "GmosNorthExecutionSequenceFields":
"""Subfields should come from the GmosNorthExecutionSequenceFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GmosNorthExecutionSequenceFields":
self._alias = alias
return self
[docs]
class GmosNorthFpuFields(GraphQLField):
"""GMOS North FPU option, either builtin or custom mask"""
[docs]
@classmethod
def custom_mask(cls) -> "GmosCustomMaskFields":
"""The custom mask, if in use"""
return GmosCustomMaskFields("customMask")
builtin: "GmosNorthFpuGraphQLField" = GmosNorthFpuGraphQLField("builtin")
"GMOS North builtin FPU, if in use"
[docs]
def fields(
self, *subfields: Union[GmosNorthFpuGraphQLField, "GmosCustomMaskFields"]
) -> "GmosNorthFpuFields":
"""Subfields should come from the GmosNorthFpuFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GmosNorthFpuFields":
self._alias = alias
return self
[docs]
class GmosNorthGratingConfigFields(GraphQLField):
"""GMOS North Grating Configuration"""
grating: "GmosNorthGratingConfigGraphQLField" = GmosNorthGratingConfigGraphQLField(
"grating"
)
"GMOS North Grating"
order: "GmosNorthGratingConfigGraphQLField" = GmosNorthGratingConfigGraphQLField(
"order"
)
"GMOS grating order"
[docs]
@classmethod
def wavelength(cls) -> "WavelengthFields":
"""Grating wavelength"""
return WavelengthFields("wavelength")
[docs]
def fields(
self, *subfields: Union[GmosNorthGratingConfigGraphQLField, "WavelengthFields"]
) -> "GmosNorthGratingConfigFields":
"""Subfields should come from the GmosNorthGratingConfigFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GmosNorthGratingConfigFields":
self._alias = alias
return self
[docs]
class GmosNorthImagingFields(GraphQLField):
"""GMOS North Imaging mode"""
[docs]
@classmethod
def variant(cls) -> "GmosImagingVariantFields":
"""Details specific to the type of imaging being performed."""
return GmosImagingVariantFields("variant")
[docs]
@classmethod
def filters(cls) -> "GmosNorthImagingFilterFields":
"""The filters (at least one is required) to be used for data collection. How
they are used depends on the imaging variant configuration."""
return GmosNorthImagingFilterFields("filters")
[docs]
@classmethod
def initial_filters(cls) -> "GmosNorthImagingFilterFields":
"""Initial GMOS North Filters that were used when creating the imaging mode."""
return GmosNorthImagingFilterFields("initialFilters")
bin: "GmosNorthImagingGraphQLField" = GmosNorthImagingGraphQLField("bin")
"GMOS Binning, either explicitly specified in explicitBin or else taken\nfrom the defaultBin. XBinning == YBinning = Binning"
default_bin: "GmosNorthImagingGraphQLField" = GmosNorthImagingGraphQLField(
"defaultBin"
)
"Default GMOS Binning (TWO)."
explicit_bin: "GmosNorthImagingGraphQLField" = GmosNorthImagingGraphQLField(
"explicitBin"
)
"Optional explicitly specified GMOS Binning. If set it overrides the\ndefault."
amp_read_mode: "GmosNorthImagingGraphQLField" = GmosNorthImagingGraphQLField(
"ampReadMode"
)
"GMOS amp read mode, either explicitly specified in explicitAmpReadMode or\nelse taken from the defaultAmpReadMode."
default_amp_read_mode: "GmosNorthImagingGraphQLField" = (
GmosNorthImagingGraphQLField("defaultAmpReadMode")
)
"Default GmosAmpReadMode (SLOW)."
explicit_amp_read_mode: "GmosNorthImagingGraphQLField" = (
GmosNorthImagingGraphQLField("explicitAmpReadMode")
)
"Optional explicitly specified GMOS amp read mode. If set it overrides the\ndefault."
amp_gain: "GmosNorthImagingGraphQLField" = GmosNorthImagingGraphQLField("ampGain")
"GMOS amp read gain, either explicitly specified in explicitAmpGain or else\ntaken from the defaultAmpGain."
default_amp_gain: "GmosNorthImagingGraphQLField" = GmosNorthImagingGraphQLField(
"defaultAmpGain"
)
"Default GMOS amp gain (LOW)."
explicit_amp_gain: "GmosNorthImagingGraphQLField" = GmosNorthImagingGraphQLField(
"explicitAmpGain"
)
"Optional explicitly specified GMOS amp gain. If set it override the default."
roi: "GmosNorthImagingGraphQLField" = GmosNorthImagingGraphQLField("roi")
"GMOS ROI, either explicitly specified in explicitRoi or else taken from the\ndefaultRoi."
default_roi: "GmosNorthImagingGraphQLField" = GmosNorthImagingGraphQLField(
"defaultRoi"
)
"Default GMOS ROI (FULL_FRAME)."
explicit_roi: "GmosNorthImagingGraphQLField" = GmosNorthImagingGraphQLField(
"explicitRoi"
)
"Optional explicitly specified GMOS ROI. If set it overrides the default."
[docs]
def fields(
self,
*subfields: Union[
GmosNorthImagingGraphQLField,
"GmosImagingVariantFields",
"GmosNorthImagingFilterFields",
],
) -> "GmosNorthImagingFields":
"""Subfields should come from the GmosNorthImagingFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GmosNorthImagingFields":
self._alias = alias
return self
[docs]
class GmosNorthImagingFilterFields(GraphQLField):
"""Imaging filters combine an actual filter with an exposure time mode."""
filter_: "GmosNorthImagingFilterGraphQLField" = GmosNorthImagingFilterGraphQLField(
"filter"
)
[docs]
@classmethod
def exposure_time_mode(cls) -> "ExposureTimeModeFields":
return ExposureTimeModeFields("exposureTimeMode")
[docs]
def fields(
self,
*subfields: Union[GmosNorthImagingFilterGraphQLField, "ExposureTimeModeFields"],
) -> "GmosNorthImagingFilterFields":
"""Subfields should come from the GmosNorthImagingFilterFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GmosNorthImagingFilterFields":
self._alias = alias
return self
[docs]
class GmosNorthLongSlitFields(GraphQLField):
"""GMOS North Long Slit mode"""
grating: "GmosNorthLongSlitGraphQLField" = GmosNorthLongSlitGraphQLField("grating")
"GMOS North Grating"
filter_: "GmosNorthLongSlitGraphQLField" = GmosNorthLongSlitGraphQLField("filter")
"GMOS North Filter"
fpu: "GmosNorthLongSlitGraphQLField" = GmosNorthLongSlitGraphQLField("fpu")
"GMOS North FPU"
[docs]
@classmethod
def central_wavelength(cls) -> "WavelengthFields":
"""The central wavelength, either explicitly specified in `explicitCentralWavelength`
or else taken from the `defaultCentralWavelength`."""
return WavelengthFields("centralWavelength")
[docs]
@classmethod
def exposure_time_mode(cls) -> "ExposureTimeModeFields":
"""The exposure time mode used for ITC lookup for the science sequence."""
return ExposureTimeModeFields("exposureTimeMode")
x_bin: "GmosNorthLongSlitGraphQLField" = GmosNorthLongSlitGraphQLField("xBin")
"GMOS X-Binning, either explicitly specified in explicitXBin or else taken\nfrom the defaultXBin."
default_x_bin: "GmosNorthLongSlitGraphQLField" = GmosNorthLongSlitGraphQLField(
"defaultXBin"
)
"Default GMOS X-Binning, calculated from the effective slit size which in\nturn is based on the selected FPU, target source profile and image quality."
explicit_x_bin: "GmosNorthLongSlitGraphQLField" = GmosNorthLongSlitGraphQLField(
"explicitXBin"
)
"Optional explicitly specified GMOS X-Binning. If set it overrides the\ndefault."
y_bin: "GmosNorthLongSlitGraphQLField" = GmosNorthLongSlitGraphQLField("yBin")
"GMOS Y-Binning, either explicitly specified in explicitYBin or else taken\nfrom the defaultYBin."
default_y_bin: "GmosNorthLongSlitGraphQLField" = GmosNorthLongSlitGraphQLField(
"defaultYBin"
)
"Default GMOS Y-Binning (TWO)."
explicit_y_bin: "GmosNorthLongSlitGraphQLField" = GmosNorthLongSlitGraphQLField(
"explicitYBin"
)
"Optional explicitly specified GMOS Y-Binning. If set it overrides the\ndefault."
amp_read_mode: "GmosNorthLongSlitGraphQLField" = GmosNorthLongSlitGraphQLField(
"ampReadMode"
)
"GMOS amp read mode, either explicitly specified in explicitAmpReadMode or\nelse taken from the defaultAmpReadMode."
default_amp_read_mode: "GmosNorthLongSlitGraphQLField" = (
GmosNorthLongSlitGraphQLField("defaultAmpReadMode")
)
"Default GmosAmpReadMode (SLOW)."
explicit_amp_read_mode: "GmosNorthLongSlitGraphQLField" = (
GmosNorthLongSlitGraphQLField("explicitAmpReadMode")
)
"Optional explicitly specified GMOS amp read mode. If set it overrides the\ndefault."
amp_gain: "GmosNorthLongSlitGraphQLField" = GmosNorthLongSlitGraphQLField("ampGain")
"GMOS amp read gain, either explicitly specified in explicitAmpGain or else\ntaken from the defaultAmpGain."
default_amp_gain: "GmosNorthLongSlitGraphQLField" = GmosNorthLongSlitGraphQLField(
"defaultAmpGain"
)
"Default GMOS amp gain (LOW)."
explicit_amp_gain: "GmosNorthLongSlitGraphQLField" = GmosNorthLongSlitGraphQLField(
"explicitAmpGain"
)
"Optional explicitly specified GMOS amp gain. If set it override the default."
roi: "GmosNorthLongSlitGraphQLField" = GmosNorthLongSlitGraphQLField("roi")
"GMOS ROI, either explicitly specified in explicitRoi or else taken from the\ndefaultRoi."
default_roi: "GmosNorthLongSlitGraphQLField" = GmosNorthLongSlitGraphQLField(
"defaultRoi"
)
"Default GMOS ROI (FULL_FRAME)."
explicit_roi: "GmosNorthLongSlitGraphQLField" = GmosNorthLongSlitGraphQLField(
"explicitRoi"
)
"Optional explicitly specified GMOS ROI. If set it overrides the default."
[docs]
@classmethod
def wavelength_dithers(cls) -> "WavelengthDitherFields":
"""Wavelength dithers required to fill in the chip gaps. This value is either
explicitly specified in explicitWavelengthDithers or else taken from
defaultWavelengthDithers"""
return WavelengthDitherFields("wavelengthDithers")
[docs]
@classmethod
def default_wavelength_dithers(cls) -> "WavelengthDitherFields":
"""Default wavelength dithers, calculated based on the grating dispersion."""
return WavelengthDitherFields("defaultWavelengthDithers")
[docs]
@classmethod
def explicit_wavelength_dithers(cls) -> "WavelengthDitherFields":
"""Optional explicitly specified wavelength dithers. If set it overrides the
default."""
return WavelengthDitherFields("explicitWavelengthDithers")
[docs]
@classmethod
def offsets(cls) -> "OffsetQFields":
"""Q offsets, either explicitly specified in explicitOffsets
or else taken from defaultOffsets"""
return OffsetQFields("offsets")
[docs]
@classmethod
def default_offsets(cls) -> "OffsetQFields":
"""Default offsets."""
return OffsetQFields("defaultOffsets")
[docs]
@classmethod
def explicit_offsets(cls) -> "OffsetQFields":
"""Optional explicitly specified q offsets. If set it overrides the
the default."""
return OffsetQFields("explicitOffsets")
[docs]
@classmethod
def spatial_offsets(cls) -> "OffsetQFields":
"""Spacial q offsets, either explicitly specified in explicitSpatialOffsets
or else taken from defaultSpatialOffsets"""
return OffsetQFields("spatialOffsets")
[docs]
@classmethod
def default_spatial_offsets(cls) -> "OffsetQFields":
"""Default spatial offsets."""
return OffsetQFields("defaultSpatialOffsets")
[docs]
@classmethod
def explicit_spatial_offsets(cls) -> "OffsetQFields":
"""Optional explicitly specified spatial q offsets. If set it overrides the
the default."""
return OffsetQFields("explicitSpatialOffsets")
[docs]
@classmethod
def acquisition(cls) -> "GmosNorthLongSlitAcquisitionFields":
"""Settings that apply to the acquisition sequence."""
return GmosNorthLongSlitAcquisitionFields("acquisition")
initial_grating: "GmosNorthLongSlitGraphQLField" = GmosNorthLongSlitGraphQLField(
"initialGrating"
)
"The grating as it was initially selected. See the `grating` field for the\ngrating that will be used in the observation."
initial_filter: "GmosNorthLongSlitGraphQLField" = GmosNorthLongSlitGraphQLField(
"initialFilter"
)
"The filter as it was initially selected (if any). See the `filter` field\nfor the filter that will be used in the observation."
initial_fpu: "GmosNorthLongSlitGraphQLField" = GmosNorthLongSlitGraphQLField(
"initialFpu"
)
"The FPU as it was initially selected. See the `fpu` field for the FPU that\nwill be used in the observation."
[docs]
@classmethod
def initial_central_wavelength(cls) -> "WavelengthFields":
"""The central wavelength as initially selected. See the `centralWavelength`
field for the wavelength that will be used in the observation."""
return WavelengthFields("initialCentralWavelength")
[docs]
def fields(
self,
*subfields: Union[
GmosNorthLongSlitGraphQLField,
"ExposureTimeModeFields",
"GmosNorthLongSlitAcquisitionFields",
"OffsetQFields",
"WavelengthDitherFields",
"WavelengthFields",
],
) -> "GmosNorthLongSlitFields":
"""Subfields should come from the GmosNorthLongSlitFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GmosNorthLongSlitFields":
self._alias = alias
return self
[docs]
class GmosNorthLongSlitAcquisitionFields(GraphQLField):
"""Acquisition settings for GMOS North long slit acquisition."""
filter_: "GmosNorthLongSlitAcquisitionGraphQLField" = (
GmosNorthLongSlitAcquisitionGraphQLField("filter")
)
"The GMOS North filter that will be used in the acquisition sequence. This will\nbe the `explicitFilter` if specified, but otherwise the `defaultFilter`."
default_filter: "GmosNorthLongSlitAcquisitionGraphQLField" = (
GmosNorthLongSlitAcquisitionGraphQLField("defaultFilter")
)
"The GMOS Nouth filter that will be used by default, if an explicit acquisition\nfilter was not specified. The default is calculated as the broadband filter\nclosest in wavelength to the observation's `centralWavelength`."
explicit_filter: "GmosNorthLongSlitAcquisitionGraphQLField" = (
GmosNorthLongSlitAcquisitionGraphQLField("explicitFilter")
)
"An explicitly specified GMOS North filter to use in acquisition (if any)."
roi: "GmosNorthLongSlitAcquisitionGraphQLField" = (
GmosNorthLongSlitAcquisitionGraphQLField("roi")
)
"The ROI(s) that will be used for the acquisition sequence. In the case of a\ncompound ROI such as `CCD2_STAMP`, the first will be used for the imaging step\nand the second for the remainder of the steps."
default_roi: "GmosNorthLongSlitAcquisitionGraphQLField" = (
GmosNorthLongSlitAcquisitionGraphQLField("defaultRoi")
)
"The acquisition ROI(s) that will be used by default, if an explicit ROI was\nnot specified."
explicit_roi: "GmosNorthLongSlitAcquisitionGraphQLField" = (
GmosNorthLongSlitAcquisitionGraphQLField("explicitRoi")
)
"An explicitly specified ROI to use in acquisition (if any)."
[docs]
@classmethod
def exposure_time_mode(cls) -> "ExposureTimeModeFields":
"""The exposure time mode used for ITC lookup for the acquisition sequence."""
return ExposureTimeModeFields("exposureTimeMode")
[docs]
def fields(
self,
*subfields: Union[
GmosNorthLongSlitAcquisitionGraphQLField, "ExposureTimeModeFields"
],
) -> "GmosNorthLongSlitAcquisitionFields":
"""Subfields should come from the GmosNorthLongSlitAcquisitionFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GmosNorthLongSlitAcquisitionFields":
self._alias = alias
return self
[docs]
class GmosNorthStaticFields(GraphQLField):
"""Unchanging (over the course of the sequence) configuration values"""
stage_mode: "GmosNorthStaticGraphQLField" = GmosNorthStaticGraphQLField("stageMode")
"Stage mode"
detector: "GmosNorthStaticGraphQLField" = GmosNorthStaticGraphQLField("detector")
"Detector in use (always HAMAMATSU for recent and new observations)"
mos_pre_imaging: "GmosNorthStaticGraphQLField" = GmosNorthStaticGraphQLField(
"mosPreImaging"
)
"Is MOS Pre-Imaging Observation"
[docs]
@classmethod
def nod_and_shuffle(cls) -> "GmosNodAndShuffleFields":
"""Nod-and-shuffle configuration. This is currently not used and will always
return null."""
return GmosNodAndShuffleFields("nodAndShuffle")
[docs]
def fields(
self, *subfields: Union[GmosNorthStaticGraphQLField, "GmosNodAndShuffleFields"]
) -> "GmosNorthStaticFields":
"""Subfields should come from the GmosNorthStaticFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GmosNorthStaticFields":
self._alias = alias
return self
[docs]
class GmosNorthStepFields(GraphQLField):
"""GmosNorth step with potential breakpoint"""
[docs]
@classmethod
def instrument_config(cls) -> "GmosNorthDynamicFields":
"""Instrument configuration for this step"""
return GmosNorthDynamicFields("instrumentConfig")
id: "GmosNorthStepGraphQLField" = GmosNorthStepGraphQLField("id")
"Step id"
breakpoint: "GmosNorthStepGraphQLField" = GmosNorthStepGraphQLField("breakpoint")
"Whether to pause before the execution of this step"
[docs]
@classmethod
def step_config(cls) -> "StepConfigInterface":
"""The sequence step itself"""
return StepConfigInterface("stepConfig")
[docs]
@classmethod
def telescope_config(cls) -> "TelescopeConfigFields":
"""The telescope configuration at this step."""
return TelescopeConfigFields("telescopeConfig")
[docs]
@classmethod
def estimate(cls) -> "StepEstimateFields":
"""Time estimate for this step's execution"""
return StepEstimateFields("estimate")
observe_class: "GmosNorthStepGraphQLField" = GmosNorthStepGraphQLField(
"observeClass"
)
"Observe class for this step"
[docs]
def fields(
self,
*subfields: Union[
GmosNorthStepGraphQLField,
"GmosNorthDynamicFields",
"StepConfigInterface",
"StepEstimateFields",
"TelescopeConfigFields",
],
) -> "GmosNorthStepFields":
"""Subfields should come from the GmosNorthStepFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GmosNorthStepFields":
self._alias = alias
return self
[docs]
class GmosPreImagingVariantFields(GraphQLField):
"""A special imaging case, MOS pre-imaging is defined by an offset region."""
[docs]
@classmethod
def offset_1(cls) -> "OffsetFields":
return OffsetFields("offset1")
[docs]
@classmethod
def offset_2(cls) -> "OffsetFields":
return OffsetFields("offset2")
[docs]
@classmethod
def offset_3(cls) -> "OffsetFields":
return OffsetFields("offset3")
[docs]
@classmethod
def offset_4(cls) -> "OffsetFields":
return OffsetFields("offset4")
[docs]
def fields(
self, *subfields: Union[GmosPreImagingVariantGraphQLField, "OffsetFields"]
) -> "GmosPreImagingVariantFields":
"""Subfields should come from the GmosPreImagingVariantFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GmosPreImagingVariantFields":
self._alias = alias
return self
[docs]
class GmosSouthAtomFields(GraphQLField):
"""GmosSouth atom, a collection of steps that should be executed in their entirety"""
id: "GmosSouthAtomGraphQLField" = GmosSouthAtomGraphQLField("id")
"Atom id"
description: "GmosSouthAtomGraphQLField" = GmosSouthAtomGraphQLField("description")
"Optional description of the atom."
observe_class: "GmosSouthAtomGraphQLField" = GmosSouthAtomGraphQLField(
"observeClass"
)
"Observe class for this atom as a whole (combined observe class for each of\nits steps)."
[docs]
@classmethod
def steps(cls) -> "GmosSouthStepFields":
"""Individual steps that comprise the atom"""
return GmosSouthStepFields("steps")
[docs]
def fields(
self, *subfields: Union[GmosSouthAtomGraphQLField, "GmosSouthStepFields"]
) -> "GmosSouthAtomFields":
"""Subfields should come from the GmosSouthAtomFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GmosSouthAtomFields":
self._alias = alias
return self
[docs]
class GmosSouthDynamicFields(GraphQLField):
"""GMOS South dynamic step configuration"""
[docs]
@classmethod
def exposure(cls) -> "TimeSpanFields":
"""GMOS exposure time"""
return TimeSpanFields("exposure")
[docs]
@classmethod
def readout(cls) -> "GmosCcdModeFields":
"""GMOS CCD Readout"""
return GmosCcdModeFields("readout")
dtax: "GmosSouthDynamicGraphQLField" = GmosSouthDynamicGraphQLField("dtax")
"GMOS detector x offset"
roi: "GmosSouthDynamicGraphQLField" = GmosSouthDynamicGraphQLField("roi")
"GMOS region of interest"
[docs]
@classmethod
def grating_config(cls) -> "GmosSouthGratingConfigFields":
"""GMOS South grating"""
return GmosSouthGratingConfigFields("gratingConfig")
filter_: "GmosSouthDynamicGraphQLField" = GmosSouthDynamicGraphQLField("filter")
"GMOS South filter"
[docs]
@classmethod
def fpu(cls) -> "GmosSouthFpuFields":
"""GMOS South FPU"""
return GmosSouthFpuFields("fpu")
[docs]
@classmethod
def central_wavelength(cls) -> "WavelengthFields":
"""Central wavelength, which is taken from the grating (if defined) or else
from the filter (if defined)."""
return WavelengthFields("centralWavelength")
[docs]
def fields(
self,
*subfields: Union[
GmosSouthDynamicGraphQLField,
"GmosCcdModeFields",
"GmosSouthFpuFields",
"GmosSouthGratingConfigFields",
"TimeSpanFields",
"WavelengthFields",
],
) -> "GmosSouthDynamicFields":
"""Subfields should come from the GmosSouthDynamicFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GmosSouthDynamicFields":
self._alias = alias
return self
[docs]
class GmosSouthExecutionConfigFields(GraphQLField):
"""GMOS South Execution Config"""
[docs]
@classmethod
def static(cls) -> "GmosSouthStaticFields":
"""GMOS South static configuration"""
return GmosSouthStaticFields("static")
[docs]
@classmethod
def acquisition(cls) -> "GmosSouthExecutionSequenceFields":
"""GMOS South acquisition execution sequence."""
return GmosSouthExecutionSequenceFields("acquisition")
[docs]
@classmethod
def science(cls) -> "GmosSouthExecutionSequenceFields":
"""GMOS South science execution"""
return GmosSouthExecutionSequenceFields("science")
[docs]
def fields(
self,
*subfields: Union[
GmosSouthExecutionConfigGraphQLField,
"GmosSouthExecutionSequenceFields",
"GmosSouthStaticFields",
],
) -> "GmosSouthExecutionConfigFields":
"""Subfields should come from the GmosSouthExecutionConfigFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GmosSouthExecutionConfigFields":
self._alias = alias
return self
[docs]
class GmosSouthExecutionSequenceFields(GraphQLField):
"""Next atom to execute and potential future atoms."""
[docs]
@classmethod
def next_atom(cls) -> "GmosSouthAtomFields":
"""Next atom to execute."""
return GmosSouthAtomFields("nextAtom")
[docs]
@classmethod
def possible_future(cls) -> "GmosSouthAtomFields":
"""(Prefix of the) remaining atoms to execute, if any."""
return GmosSouthAtomFields("possibleFuture")
has_more: "GmosSouthExecutionSequenceGraphQLField" = (
GmosSouthExecutionSequenceGraphQLField("hasMore")
)
"Whether there are more anticipated atoms than those that appear in\n'possibleFuture'."
[docs]
def fields(
self,
*subfields: Union[
GmosSouthExecutionSequenceGraphQLField, "GmosSouthAtomFields"
],
) -> "GmosSouthExecutionSequenceFields":
"""Subfields should come from the GmosSouthExecutionSequenceFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GmosSouthExecutionSequenceFields":
self._alias = alias
return self
[docs]
class GmosSouthFpuFields(GraphQLField):
"""GMOS South FPU option, either builtin or custom mask"""
[docs]
@classmethod
def custom_mask(cls) -> "GmosCustomMaskFields":
"""The custom mask, if in use"""
return GmosCustomMaskFields("customMask")
builtin: "GmosSouthFpuGraphQLField" = GmosSouthFpuGraphQLField("builtin")
"GMOS South builtin FPU, if in use"
[docs]
def fields(
self, *subfields: Union[GmosSouthFpuGraphQLField, "GmosCustomMaskFields"]
) -> "GmosSouthFpuFields":
"""Subfields should come from the GmosSouthFpuFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GmosSouthFpuFields":
self._alias = alias
return self
[docs]
class GmosSouthGratingConfigFields(GraphQLField):
"""GMOS South Grating Configuration"""
grating: "GmosSouthGratingConfigGraphQLField" = GmosSouthGratingConfigGraphQLField(
"grating"
)
"GMOS South Grating"
order: "GmosSouthGratingConfigGraphQLField" = GmosSouthGratingConfigGraphQLField(
"order"
)
"GMOS grating order"
[docs]
@classmethod
def wavelength(cls) -> "WavelengthFields":
"""Grating wavelength"""
return WavelengthFields("wavelength")
[docs]
def fields(
self, *subfields: Union[GmosSouthGratingConfigGraphQLField, "WavelengthFields"]
) -> "GmosSouthGratingConfigFields":
"""Subfields should come from the GmosSouthGratingConfigFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GmosSouthGratingConfigFields":
self._alias = alias
return self
[docs]
class GmosSouthImagingFields(GraphQLField):
"""GMOS South Imaging mode"""
[docs]
@classmethod
def variant(cls) -> "GmosImagingVariantFields":
"""Details specific to the type of imaging being performed."""
return GmosImagingVariantFields("variant")
[docs]
@classmethod
def filters(cls) -> "GmosSouthImagingFilterFields":
"""The filters (at least one is required) to be used for data collection. How
they are used depends on the imaging variant configuration."""
return GmosSouthImagingFilterFields("filters")
[docs]
@classmethod
def initial_filters(cls) -> "GmosSouthImagingFilterFields":
"""Initial GMOS North Filters that were used when creating the imaging mode."""
return GmosSouthImagingFilterFields("initialFilters")
bin: "GmosSouthImagingGraphQLField" = GmosSouthImagingGraphQLField("bin")
"GMOS Binning, either explicitly specified in explicitBin or else taken\nfrom the defaultBin. XBinning == YBinning = Binning"
default_bin: "GmosSouthImagingGraphQLField" = GmosSouthImagingGraphQLField(
"defaultBin"
)
"Default GMOS Binning (TWO)."
explicit_bin: "GmosSouthImagingGraphQLField" = GmosSouthImagingGraphQLField(
"explicitBin"
)
"Optional explicitly specified GMOS Binning. If set it overrides the\ndefault."
amp_read_mode: "GmosSouthImagingGraphQLField" = GmosSouthImagingGraphQLField(
"ampReadMode"
)
"GMOS amp read mode, either explicitly specified in explicitAmpReadMode or\nelse taken from the defaultAmpReadMode."
default_amp_read_mode: "GmosSouthImagingGraphQLField" = (
GmosSouthImagingGraphQLField("defaultAmpReadMode")
)
"Default GmosAmpReadMode (SLOW)."
explicit_amp_read_mode: "GmosSouthImagingGraphQLField" = (
GmosSouthImagingGraphQLField("explicitAmpReadMode")
)
"Optional explicitly specified GMOS amp read mode. If set it overrides the\ndefault."
amp_gain: "GmosSouthImagingGraphQLField" = GmosSouthImagingGraphQLField("ampGain")
"GMOS amp read gain, either explicitly specified in explicitAmpGain or else\ntaken from the defaultAmpGain."
default_amp_gain: "GmosSouthImagingGraphQLField" = GmosSouthImagingGraphQLField(
"defaultAmpGain"
)
"Default GMOS amp gain (LOW)."
explicit_amp_gain: "GmosSouthImagingGraphQLField" = GmosSouthImagingGraphQLField(
"explicitAmpGain"
)
"Optional explicitly specified GMOS amp gain. If set it override the default."
roi: "GmosSouthImagingGraphQLField" = GmosSouthImagingGraphQLField("roi")
"GMOS ROI, either explicitly specified in explicitRoi or else taken from the\ndefaultRoi."
default_roi: "GmosSouthImagingGraphQLField" = GmosSouthImagingGraphQLField(
"defaultRoi"
)
"Default GMOS ROI (FULL_FRAME)."
explicit_roi: "GmosSouthImagingGraphQLField" = GmosSouthImagingGraphQLField(
"explicitRoi"
)
"Optional explicitly specified GMOS ROI. If set it overrides the default."
[docs]
def fields(
self,
*subfields: Union[
GmosSouthImagingGraphQLField,
"GmosImagingVariantFields",
"GmosSouthImagingFilterFields",
],
) -> "GmosSouthImagingFields":
"""Subfields should come from the GmosSouthImagingFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GmosSouthImagingFields":
self._alias = alias
return self
[docs]
class GmosSouthImagingFilterFields(GraphQLField):
"""Imaging filters combine an actual filter with an exposure time mode."""
filter_: "GmosSouthImagingFilterGraphQLField" = GmosSouthImagingFilterGraphQLField(
"filter"
)
[docs]
@classmethod
def exposure_time_mode(cls) -> "ExposureTimeModeFields":
return ExposureTimeModeFields("exposureTimeMode")
[docs]
def fields(
self,
*subfields: Union[GmosSouthImagingFilterGraphQLField, "ExposureTimeModeFields"],
) -> "GmosSouthImagingFilterFields":
"""Subfields should come from the GmosSouthImagingFilterFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GmosSouthImagingFilterFields":
self._alias = alias
return self
[docs]
class GmosSouthLongSlitFields(GraphQLField):
"""GMOS South Long Slit mode"""
grating: "GmosSouthLongSlitGraphQLField" = GmosSouthLongSlitGraphQLField("grating")
"GMOS South Grating"
filter_: "GmosSouthLongSlitGraphQLField" = GmosSouthLongSlitGraphQLField("filter")
"GMOS South Filter"
fpu: "GmosSouthLongSlitGraphQLField" = GmosSouthLongSlitGraphQLField("fpu")
"GMOS South FPU"
[docs]
@classmethod
def central_wavelength(cls) -> "WavelengthFields":
"""The central wavelength, either explicitly specified in `explicitCentralWavelength`
or else taken from the `defaultCentralWavelength`."""
return WavelengthFields("centralWavelength")
[docs]
@classmethod
def exposure_time_mode(cls) -> "ExposureTimeModeFields":
"""The exposure time mode used for ITC lookup for the science sequence."""
return ExposureTimeModeFields("exposureTimeMode")
x_bin: "GmosSouthLongSlitGraphQLField" = GmosSouthLongSlitGraphQLField("xBin")
"GMOS X-Binning, either explicitly specified in explicitXBin or else taken\nfrom the defaultXBin."
default_x_bin: "GmosSouthLongSlitGraphQLField" = GmosSouthLongSlitGraphQLField(
"defaultXBin"
)
"Default GMOS X-Binning, calculated from the effective slit size which in\nturn is based on the selected FPU, target source profile and image quality."
explicit_x_bin: "GmosSouthLongSlitGraphQLField" = GmosSouthLongSlitGraphQLField(
"explicitXBin"
)
"Optional explicitly specified GMOS X-Binning. If set it overrides the\ndefault."
y_bin: "GmosSouthLongSlitGraphQLField" = GmosSouthLongSlitGraphQLField("yBin")
"GMOS Y-Binning, either explicitly specified in explicitYBin or else taken\nfrom the defaultYBin."
default_y_bin: "GmosSouthLongSlitGraphQLField" = GmosSouthLongSlitGraphQLField(
"defaultYBin"
)
"Default GMOS Y-Binning (TWO)."
explicit_y_bin: "GmosSouthLongSlitGraphQLField" = GmosSouthLongSlitGraphQLField(
"explicitYBin"
)
"Optional explicitly specified GMOS Y-Binning. If set it overrides the\ndefault."
amp_read_mode: "GmosSouthLongSlitGraphQLField" = GmosSouthLongSlitGraphQLField(
"ampReadMode"
)
"GMOS amp read mode, either explicitly specified in explicitAmpReadMode or\nelse taken from the defaultAmpReadMode."
default_amp_read_mode: "GmosSouthLongSlitGraphQLField" = (
GmosSouthLongSlitGraphQLField("defaultAmpReadMode")
)
"Default GmosAmpReadMode (SLOW)."
explicit_amp_read_mode: "GmosSouthLongSlitGraphQLField" = (
GmosSouthLongSlitGraphQLField("explicitAmpReadMode")
)
"Optional explicitly specified GMOS amp read mode. If set it overrides the\ndefault."
amp_gain: "GmosSouthLongSlitGraphQLField" = GmosSouthLongSlitGraphQLField("ampGain")
"GMOS amp read gain, either explicitly specified in explicitAmpGain or else\ntaken from the defaultAmpGain."
default_amp_gain: "GmosSouthLongSlitGraphQLField" = GmosSouthLongSlitGraphQLField(
"defaultAmpGain"
)
"Default GMOS amp gain (LOW)."
explicit_amp_gain: "GmosSouthLongSlitGraphQLField" = GmosSouthLongSlitGraphQLField(
"explicitAmpGain"
)
"Optional explicitly specified GMOS amp gain. If set it override the default."
roi: "GmosSouthLongSlitGraphQLField" = GmosSouthLongSlitGraphQLField("roi")
"GMOS ROI, either explicitly specified in explicitRoi or else taken from the\ndefaultRoi."
default_roi: "GmosSouthLongSlitGraphQLField" = GmosSouthLongSlitGraphQLField(
"defaultRoi"
)
"Default GMOS ROI (FULL_FRAME)."
explicit_roi: "GmosSouthLongSlitGraphQLField" = GmosSouthLongSlitGraphQLField(
"explicitRoi"
)
"Optional explicitly specified GMOS ROI. If set it overrides the default."
[docs]
@classmethod
def wavelength_dithers(cls) -> "WavelengthDitherFields":
"""Wavelength dithers required to fill in the chip gaps. This value is either
explicitly specified in explicitWavelengthDithers or else taken from
defaultWavelengthDithers"""
return WavelengthDitherFields("wavelengthDithers")
[docs]
@classmethod
def default_wavelength_dithers(cls) -> "WavelengthDitherFields":
"""Default wavelength dithers, calculated based on the grating dispersion."""
return WavelengthDitherFields("defaultWavelengthDithers")
[docs]
@classmethod
def explicit_wavelength_dithers(cls) -> "WavelengthDitherFields":
"""Optional explicitly specified wavelength dithers. If set it overrides the
default."""
return WavelengthDitherFields("explicitWavelengthDithers")
[docs]
@classmethod
def offsets(cls) -> "OffsetQFields":
"""Q offsets, either explicitly specified in explicitOffsets
or else taken from defaultOffsets"""
return OffsetQFields("offsets")
[docs]
@classmethod
def default_offsets(cls) -> "OffsetQFields":
"""Default offsets."""
return OffsetQFields("defaultOffsets")
[docs]
@classmethod
def explicit_offsets(cls) -> "OffsetQFields":
"""Optional explicitly specified q offsets. If set it overrides the
the default."""
return OffsetQFields("explicitOffsets")
[docs]
@classmethod
def spatial_offsets(cls) -> "OffsetQFields":
"""Spacial q offsets, either explicitly specified in explicitSpatialOffsets
or else taken from defaultSpatialOffsets"""
return OffsetQFields("spatialOffsets")
[docs]
@classmethod
def default_spatial_offsets(cls) -> "OffsetQFields":
"""Default spatial offsets."""
return OffsetQFields("defaultSpatialOffsets")
[docs]
@classmethod
def explicit_spatial_offsets(cls) -> "OffsetQFields":
"""Optional explicitly specified spatial q offsets. If set it overrides the
the default."""
return OffsetQFields("explicitSpatialOffsets")
[docs]
@classmethod
def acquisition(cls) -> "GmosSouthLongSlitAcquisitionFields":
"""Settings that apply to the acquisition sequence."""
return GmosSouthLongSlitAcquisitionFields("acquisition")
initial_grating: "GmosSouthLongSlitGraphQLField" = GmosSouthLongSlitGraphQLField(
"initialGrating"
)
"The grating as it was initially selected. See the `grating` field for the\ngrating that will be used in the observation."
initial_filter: "GmosSouthLongSlitGraphQLField" = GmosSouthLongSlitGraphQLField(
"initialFilter"
)
"The filter as it was initially selected (if any). See the `filter` field\nfor the filter that will be used in the observation."
initial_fpu: "GmosSouthLongSlitGraphQLField" = GmosSouthLongSlitGraphQLField(
"initialFpu"
)
"The FPU as it was initially selected. See the `fpu` field for the FPU that\nwill be used in the observation."
[docs]
@classmethod
def initial_central_wavelength(cls) -> "WavelengthFields":
"""The central wavelength as initially selected. See the `centralWavelength`
field for the wavelength that will be used in the observation."""
return WavelengthFields("initialCentralWavelength")
[docs]
def fields(
self,
*subfields: Union[
GmosSouthLongSlitGraphQLField,
"ExposureTimeModeFields",
"GmosSouthLongSlitAcquisitionFields",
"OffsetQFields",
"WavelengthDitherFields",
"WavelengthFields",
],
) -> "GmosSouthLongSlitFields":
"""Subfields should come from the GmosSouthLongSlitFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GmosSouthLongSlitFields":
self._alias = alias
return self
[docs]
class GmosSouthLongSlitAcquisitionFields(GraphQLField):
"""Acquisition settings for GMOS South long slit acquisition."""
filter_: "GmosSouthLongSlitAcquisitionGraphQLField" = (
GmosSouthLongSlitAcquisitionGraphQLField("filter")
)
"The GMOS South filter that will be used in the acquisition sequence. This will\nbe the `explicitFilter` if specified, but otherwise the `defaultFilter`."
default_filter: "GmosSouthLongSlitAcquisitionGraphQLField" = (
GmosSouthLongSlitAcquisitionGraphQLField("defaultFilter")
)
"The GMOS South filter that will be used by default, if an explicit acquisition\nfilter was not specified. The default is calculated as the broadband filter\nclosest in wavelength to the observation's `centralWavelength`."
explicit_filter: "GmosSouthLongSlitAcquisitionGraphQLField" = (
GmosSouthLongSlitAcquisitionGraphQLField("explicitFilter")
)
"An explicitly specified GMOS South filter to use in acquisition (if any)."
roi: "GmosSouthLongSlitAcquisitionGraphQLField" = (
GmosSouthLongSlitAcquisitionGraphQLField("roi")
)
"The ROI(s) that will be used for the acquisition sequence. In the case of a\ncompound ROI such as `CCD2_STAMP`, the first will be used for the imaging step\nand the second for the remainder of the steps."
default_roi: "GmosSouthLongSlitAcquisitionGraphQLField" = (
GmosSouthLongSlitAcquisitionGraphQLField("defaultRoi")
)
"The acquisition ROI(s) that will be used by default, if an explicit ROI was\nnot specified."
explicit_roi: "GmosSouthLongSlitAcquisitionGraphQLField" = (
GmosSouthLongSlitAcquisitionGraphQLField("explicitRoi")
)
"An explicitly specified ROI to use in acquisition (if any)."
[docs]
@classmethod
def exposure_time_mode(cls) -> "ExposureTimeModeFields":
"""The exposure time mode used for ITC lookup for the acquisition sequence."""
return ExposureTimeModeFields("exposureTimeMode")
[docs]
def fields(
self,
*subfields: Union[
GmosSouthLongSlitAcquisitionGraphQLField, "ExposureTimeModeFields"
],
) -> "GmosSouthLongSlitAcquisitionFields":
"""Subfields should come from the GmosSouthLongSlitAcquisitionFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GmosSouthLongSlitAcquisitionFields":
self._alias = alias
return self
[docs]
class GmosSouthStaticFields(GraphQLField):
"""Unchanging (over the course of the sequence) configuration values"""
stage_mode: "GmosSouthStaticGraphQLField" = GmosSouthStaticGraphQLField("stageMode")
"Stage mode"
detector: "GmosSouthStaticGraphQLField" = GmosSouthStaticGraphQLField("detector")
"Detector in use (always HAMAMATSU for recent and new observations)"
mos_pre_imaging: "GmosSouthStaticGraphQLField" = GmosSouthStaticGraphQLField(
"mosPreImaging"
)
"Is MOS Pre-Imaging Observation"
[docs]
@classmethod
def nod_and_shuffle(cls) -> "GmosNodAndShuffleFields":
"""#Nod-and-shuffle configuration
Nod-and-shuffle configuration. This is currently not used and will always
return null."""
return GmosNodAndShuffleFields("nodAndShuffle")
[docs]
def fields(
self, *subfields: Union[GmosSouthStaticGraphQLField, "GmosNodAndShuffleFields"]
) -> "GmosSouthStaticFields":
"""Subfields should come from the GmosSouthStaticFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GmosSouthStaticFields":
self._alias = alias
return self
[docs]
class GmosSouthStepFields(GraphQLField):
"""GmosSouth step with potential breakpoint"""
[docs]
@classmethod
def instrument_config(cls) -> "GmosSouthDynamicFields":
"""Instrument configuration for this step"""
return GmosSouthDynamicFields("instrumentConfig")
id: "GmosSouthStepGraphQLField" = GmosSouthStepGraphQLField("id")
"Step id"
breakpoint: "GmosSouthStepGraphQLField" = GmosSouthStepGraphQLField("breakpoint")
"Whether to pause before the execution of this step"
[docs]
@classmethod
def step_config(cls) -> "StepConfigInterface":
"""The sequence step itself"""
return StepConfigInterface("stepConfig")
[docs]
@classmethod
def telescope_config(cls) -> "TelescopeConfigFields":
"""The telescope configuration at this step."""
return TelescopeConfigFields("telescopeConfig")
[docs]
@classmethod
def estimate(cls) -> "StepEstimateFields":
"""Time estimate for this step's execution"""
return StepEstimateFields("estimate")
observe_class: "GmosSouthStepGraphQLField" = GmosSouthStepGraphQLField(
"observeClass"
)
"Observe class for this step"
[docs]
def fields(
self,
*subfields: Union[
GmosSouthStepGraphQLField,
"GmosSouthDynamicFields",
"StepConfigInterface",
"StepEstimateFields",
"TelescopeConfigFields",
],
) -> "GmosSouthStepFields":
"""Subfields should come from the GmosSouthStepFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GmosSouthStepFields":
self._alias = alias
return self
[docs]
class GoaPropertiesFields(GraphQLField):
"""Gemini Observatory Archive properties for a particular program."""
proprietary_months: "GoaPropertiesGraphQLField" = GoaPropertiesGraphQLField(
"proprietaryMonths"
)
"How many months to withhold public access to the data. This property is\napplicable to science programs, defaults to the proprietary period associated\nwith the Call for Proposals if any; 0 months otherwise."
should_notify: "GoaPropertiesGraphQLField" = GoaPropertiesGraphQLField(
"shouldNotify"
)
"Whether the PI wishes to be notified when new data are received. This property\nis applicable to science programs and defaults to true."
private_header: "GoaPropertiesGraphQLField" = GoaPropertiesGraphQLField(
"privateHeader"
)
"Whether the header (as well as the data itself) should remain private. This\nproperty is applicable to science programs and defaults to false."
[docs]
def fields(self, *subfields: GoaPropertiesGraphQLField) -> "GoaPropertiesFields":
"""Subfields should come from the GoaPropertiesFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GoaPropertiesFields":
self._alias = alias
return self
[docs]
class GroupFields(GraphQLField):
"""A group of observations and other groups."""
id: "GroupGraphQLField" = GroupGraphQLField("id")
parent_id: "GroupGraphQLField" = GroupGraphQLField("parentId")
"Id of this group's parent, or null if this group is at the top level."
parent_index: "GroupGraphQLField" = GroupGraphQLField("parentIndex")
"Position of this group in its parent group (or at the top level)."
[docs]
@classmethod
def program(cls) -> "ProgramFields":
"""The program in which this group is found."""
return ProgramFields("program")
name: "GroupGraphQLField" = GroupGraphQLField("name")
"Optionally, a name"
description: "GroupGraphQLField" = GroupGraphQLField("description")
"Optionally, a description."
minimum_required: "GroupGraphQLField" = GroupGraphQLField("minimumRequired")
"How many do we need to complete? If this is null then it means we have to complete them all"
ordered: "GroupGraphQLField" = GroupGraphQLField("ordered")
"Do they need to be completed in order?"
[docs]
@classmethod
def minimum_interval(cls) -> "TimeSpanFields":
"""Is there a minimum required and/or maximum allowed timespan between observations?"""
return TimeSpanFields("minimumInterval")
[docs]
@classmethod
def maximum_interval(cls) -> "TimeSpanFields":
return TimeSpanFields("maximumInterval")
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."
[docs]
@classmethod
def elements(cls, include_deleted: bool) -> "GroupElementFields":
"""Contained elements"""
arguments: dict[str, dict[str, Any]] = {
"includeDeleted": {"type": "Boolean!", "value": include_deleted}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return GroupElementFields("elements", arguments=cleared_arguments)
[docs]
@classmethod
def time_estimate_range(cls) -> "CalculatedCategorizedTimeRangeFields":
"""Remaining execution time estimate range, assuming it can be calculated. In
order for an observation to have an estimate, it must be fully defined such
that a sequence can be generated for it. If a group has observations that
are required and which are not fully defined, the remaining time estimate
cannot be calculated."""
return CalculatedCategorizedTimeRangeFields("timeEstimateRange")
[docs]
@classmethod
def time_estimate_banded(cls) -> "CalculatedBandedTimeFields":
"""Prepared time by band ignoring `minimumRequired`, for observations that can be
calculated. In order for an observation to have an estimate, it must be
fully defined such that a sequence can be generated for it. All defined
observations in every band present in the group are included."""
return CalculatedBandedTimeFields("timeEstimateBanded")
existence: "GroupGraphQLField" = GroupGraphQLField("existence")
system: "GroupGraphQLField" = GroupGraphQLField("system")
"This group is managed by the system and not user-editable"
calibration_roles: "GroupGraphQLField" = GroupGraphQLField("calibrationRoles")
"Calibration roles supported by this group (system groups only).\nThis field is system-managed and not user-editable."
[docs]
def fields(
self,
*subfields: Union[
GroupGraphQLField,
"CalculatedBandedTimeFields",
"CalculatedCategorizedTimeRangeFields",
"GroupElementFields",
"ProgramFields",
"TimeSpanFields",
],
) -> "GroupFields":
"""Subfields should come from the GroupFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GroupFields":
self._alias = alias
return self
[docs]
class GroupElementFields(GraphQLField):
"""Groups contain observations and other groups. Exactly one will be defined."""
parent_group_id: "GroupElementGraphQLField" = GroupElementGraphQLField(
"parentGroupId"
)
parent_index: "GroupElementGraphQLField" = GroupElementGraphQLField("parentIndex")
[docs]
@classmethod
def group(cls) -> "GroupFields":
return GroupFields("group")
[docs]
@classmethod
def observation(cls) -> "ObservationFields":
return ObservationFields("observation")
existence: "GroupElementGraphQLField" = GroupElementGraphQLField("existence")
[docs]
def fields(
self,
*subfields: Union[GroupElementGraphQLField, "GroupFields", "ObservationFields"],
) -> "GroupElementFields":
"""Subfields should come from the GroupElementFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GroupElementFields":
self._alias = alias
return self
[docs]
class GuideAvailabilityPeriodFields(GraphQLField):
"""A period of time showing which position angles have guide stars available during the period.
The position angles are tested every 10 degrees."""
start: "GuideAvailabilityPeriodGraphQLField" = GuideAvailabilityPeriodGraphQLField(
"start"
)
"The start time of the availability period."
end: "GuideAvailabilityPeriodGraphQLField" = GuideAvailabilityPeriodGraphQLField(
"end"
)
"Then end time of the availability period."
[docs]
@classmethod
def pos_angles(cls) -> "AngleFields":
"""The position angles available during this period."""
return AngleFields("posAngles")
[docs]
def fields(
self, *subfields: Union[GuideAvailabilityPeriodGraphQLField, "AngleFields"]
) -> "GuideAvailabilityPeriodFields":
"""Subfields should come from the GuideAvailabilityPeriodFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GuideAvailabilityPeriodFields":
self._alias = alias
return self
[docs]
class GuideEnvironmentFields(GraphQLField):
"""The guide star(s) and related information"""
[docs]
@classmethod
def pos_angle(cls) -> "AngleFields":
"""The position angle"""
return AngleFields("posAngle")
[docs]
@classmethod
def guide_targets(cls) -> "GuideTargetFields":
"""A list of GuideProbeTargets, which essentially provides a mapping from guide probes to targets."""
return GuideTargetFields("guideTargets")
[docs]
def fields(
self,
*subfields: Union[
GuideEnvironmentGraphQLField, "AngleFields", "GuideTargetFields"
],
) -> "GuideEnvironmentFields":
"""Subfields should come from the GuideEnvironmentFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GuideEnvironmentFields":
self._alias = alias
return self
[docs]
class GuideTargetFields(GraphQLField):
"""Type that contains a guide probe and guide target information for use in the GuideEnvironment"""
probe: "GuideTargetGraphQLField" = GuideTargetGraphQLField("probe")
"The guide probe"
name: "GuideTargetGraphQLField" = GuideTargetGraphQLField("name")
"Target name."
[docs]
@classmethod
def source_profile(cls) -> "SourceProfileFields":
"""source profile"""
return SourceProfileFields("sourceProfile")
[docs]
@classmethod
def sidereal(cls) -> "SiderealFields":
"""Sidereal tracking information, if this is a sidereal target"""
return SiderealFields("sidereal")
[docs]
@classmethod
def nonsidereal(cls) -> "NonsiderealFields":
"""Nonsidereal tracking information, if this is a nonsidereal target"""
return NonsiderealFields("nonsidereal")
[docs]
def fields(
self,
*subfields: Union[
GuideTargetGraphQLField,
"NonsiderealFields",
"SiderealFields",
"SourceProfileFields",
],
) -> "GuideTargetFields":
"""Subfields should come from the GuideTargetFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "GuideTargetFields":
self._alias = alias
return self
[docs]
class HasNonPartnerFields(GraphQLField):
"""A `PartnerLink` employed when a user is explicitly associated with
no `Partner`."""
link_type: "HasNonPartnerGraphQLField" = HasNonPartnerGraphQLField("linkType")
"Partner link discriminator."
[docs]
def fields(self, *subfields: HasNonPartnerGraphQLField) -> "HasNonPartnerFields":
"""Subfields should come from the HasNonPartnerFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "HasNonPartnerFields":
self._alias = alias
return self
[docs]
class HasPartnerFields(GraphQLField):
"""A `PartnerLink` employed when a user is associated with a specific
`Partner`."""
link_type: "HasPartnerGraphQLField" = HasPartnerGraphQLField("linkType")
"Partner link discriminator."
partner: "HasPartnerGraphQLField" = HasPartnerGraphQLField("partner")
"The associated partner."
[docs]
def fields(self, *subfields: HasPartnerGraphQLField) -> "HasPartnerFields":
"""Subfields should come from the HasPartnerFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "HasPartnerFields":
self._alias = alias
return self
[docs]
class HasUnspecifiedPartnerFields(GraphQLField):
"""A `PartnerLink` employed when a user's `PartnerLink` has not
(yet) been made."""
link_type: "HasUnspecifiedPartnerGraphQLField" = HasUnspecifiedPartnerGraphQLField(
"linkType"
)
"Partner link discriminator."
[docs]
def fields(
self, *subfields: HasUnspecifiedPartnerGraphQLField
) -> "HasUnspecifiedPartnerFields":
"""Subfields should come from the HasUnspecifiedPartnerFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "HasUnspecifiedPartnerFields":
self._alias = alias
return self
[docs]
class HourAngleRangeFields(GraphQLField):
min_hours: "HourAngleRangeGraphQLField" = HourAngleRangeGraphQLField("minHours")
"Minimum Hour Angle (hours)"
max_hours: "HourAngleRangeGraphQLField" = HourAngleRangeGraphQLField("maxHours")
"Maximum Hour Angle (hours)"
[docs]
def fields(self, *subfields: HourAngleRangeGraphQLField) -> "HourAngleRangeFields":
"""Subfields should come from the HourAngleRangeFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "HourAngleRangeFields":
self._alias = alias
return self
[docs]
class Igrins2AtomFields(GraphQLField):
"""IGRINS-2 atom, a collection of steps that should be executed in their entirety"""
id: "Igrins2AtomGraphQLField" = Igrins2AtomGraphQLField("id")
"Atom id"
description: "Igrins2AtomGraphQLField" = Igrins2AtomGraphQLField("description")
"Atom description, if any"
observe_class: "Igrins2AtomGraphQLField" = Igrins2AtomGraphQLField("observeClass")
"Observe class for this atom"
[docs]
@classmethod
def steps(cls) -> "Igrins2StepFields":
"""Individual steps that comprise the atom"""
return Igrins2StepFields("steps")
[docs]
def fields(
self, *subfields: Union[Igrins2AtomGraphQLField, "Igrins2StepFields"]
) -> "Igrins2AtomFields":
"""Subfields should come from the Igrins2AtomFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "Igrins2AtomFields":
self._alias = alias
return self
[docs]
class Igrins2DynamicFields(GraphQLField):
"""IGRINS-2 dynamic step configuration"""
[docs]
@classmethod
def exposure(cls) -> "TimeSpanFields":
"""IGRINS-2 exposure time"""
return TimeSpanFields("exposure")
[docs]
def fields(
self, *subfields: Union[Igrins2DynamicGraphQLField, "TimeSpanFields"]
) -> "Igrins2DynamicFields":
"""Subfields should come from the Igrins2DynamicFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "Igrins2DynamicFields":
self._alias = alias
return self
[docs]
class Igrins2ExecutionConfigFields(GraphQLField):
"""IGRINS-2 Execution Config"""
[docs]
@classmethod
def static(cls) -> "Igrins2StaticFields":
"""IGRINS-2 static configuration"""
return Igrins2StaticFields("static")
[docs]
@classmethod
def science(cls) -> "Igrins2ExecutionSequenceFields":
"""IGRINS-2 science execution"""
return Igrins2ExecutionSequenceFields("science")
[docs]
def fields(
self,
*subfields: Union[
Igrins2ExecutionConfigGraphQLField,
"Igrins2ExecutionSequenceFields",
"Igrins2StaticFields",
],
) -> "Igrins2ExecutionConfigFields":
"""Subfields should come from the Igrins2ExecutionConfigFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "Igrins2ExecutionConfigFields":
self._alias = alias
return self
[docs]
class Igrins2ExecutionSequenceFields(GraphQLField):
"""Next atom to execute and potential future atoms."""
[docs]
@classmethod
def next_atom(cls) -> "Igrins2AtomFields":
"""Next atom to execute."""
return Igrins2AtomFields("nextAtom")
[docs]
@classmethod
def possible_future(cls) -> "Igrins2AtomFields":
"""(Prefix of the) remaining atoms to execute, if any."""
return Igrins2AtomFields("possibleFuture")
has_more: "Igrins2ExecutionSequenceGraphQLField" = (
Igrins2ExecutionSequenceGraphQLField("hasMore")
)
"Whether there are additional atoms beyond those listed in possibleFuture."
[docs]
def fields(
self,
*subfields: Union[Igrins2ExecutionSequenceGraphQLField, "Igrins2AtomFields"],
) -> "Igrins2ExecutionSequenceFields":
"""Subfields should come from the Igrins2ExecutionSequenceFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "Igrins2ExecutionSequenceFields":
self._alias = alias
return self
[docs]
class Igrins2LongSlitFields(GraphQLField):
"""IGRINS-2 Long Slit mode"""
[docs]
@classmethod
def exposure_time_mode(cls) -> "ExposureTimeModeFields":
"""The exposure time mode used for ITC lookup for the science sequence."""
return ExposureTimeModeFields("exposureTimeMode")
offset_mode: "Igrins2LongSlitGraphQLField" = Igrins2LongSlitGraphQLField(
"offsetMode"
)
"The offset mode is either explicitly specified in explicitOffsetMode or else\ntaken from defaultOffsetMode"
default_offset_mode: "Igrins2LongSlitGraphQLField" = Igrins2LongSlitGraphQLField(
"defaultOffsetMode"
)
"Default offset mode"
explicit_offset_mode: "Igrins2LongSlitGraphQLField" = Igrins2LongSlitGraphQLField(
"explicitOffsetMode"
)
"Optional explicitly specified offset mode. If set it overrides the default."
save_svc_images: "Igrins2LongSlitGraphQLField" = Igrins2LongSlitGraphQLField(
"saveSVCImages"
)
"Whether to save SVC images, either explicitly specified in\nexplicitSaveSVCImages or else taken from defaultSaveSVCImages"
default_save_svc_images: "Igrins2LongSlitGraphQLField" = (
Igrins2LongSlitGraphQLField("defaultSaveSVCImages")
)
"Default save SVC images setting"
explicit_save_svc_images: "Igrins2LongSlitGraphQLField" = (
Igrins2LongSlitGraphQLField("explicitSaveSVCImages")
)
"Optional explicitly specified save SVC images setting. If set it overrides\nthe default."
[docs]
@classmethod
def offsets(cls) -> "OffsetFields":
"""Spatial offsets, either explicitly specified in explicitOffsets or else
taken from defaultOffsets"""
return OffsetFields("offsets")
[docs]
@classmethod
def default_offsets(cls) -> "OffsetFields":
"""Default spatial offsets
(ABBA pattern, q = -1.25, +1.25, +1.25, -1.25 arcsec) for NodAlongSlit, or
(p = 0, q = 0), (p = 10, q = 10), (p = 0, q = 0) for NodToSky."""
return OffsetFields("defaultOffsets")
[docs]
@classmethod
def explicit_offsets(cls) -> "OffsetFields":
"""Optional explicitly specified spatial offsets. If set, overrides the default."""
return OffsetFields("explicitOffsets")
[docs]
@classmethod
def telluric_type(cls) -> "TelluricTypeFields":
"""Telluric type configuration for this observation."""
return TelluricTypeFields("telluricType")
[docs]
def fields(
self,
*subfields: Union[
Igrins2LongSlitGraphQLField,
"ExposureTimeModeFields",
"OffsetFields",
"TelluricTypeFields",
],
) -> "Igrins2LongSlitFields":
"""Subfields should come from the Igrins2LongSlitFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "Igrins2LongSlitFields":
self._alias = alias
return self
[docs]
class Igrins2StaticFields(GraphQLField):
"""IGRINS-2 static configuration"""
save_svc_images: "Igrins2StaticGraphQLField" = Igrins2StaticGraphQLField(
"saveSVCImages"
)
"Whether to save SVC images."
offset_mode: "Igrins2StaticGraphQLField" = Igrins2StaticGraphQLField("offsetMode")
"Offset mode."
[docs]
def fields(self, *subfields: Igrins2StaticGraphQLField) -> "Igrins2StaticFields":
"""Subfields should come from the Igrins2StaticFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "Igrins2StaticFields":
self._alias = alias
return self
[docs]
class Igrins2StepFields(GraphQLField):
"""IGRINS-2 step with potential breakpoint"""
[docs]
@classmethod
def instrument_config(cls) -> "Igrins2DynamicFields":
"""Instrument configuration for this step"""
return Igrins2DynamicFields("instrumentConfig")
id: "Igrins2StepGraphQLField" = Igrins2StepGraphQLField("id")
"Step id"
breakpoint: "Igrins2StepGraphQLField" = Igrins2StepGraphQLField("breakpoint")
"Whether to pause before the execution of this step"
[docs]
@classmethod
def step_config(cls) -> "StepConfigInterface":
"""The sequence step itself"""
return StepConfigInterface("stepConfig")
[docs]
@classmethod
def telescope_config(cls) -> "TelescopeConfigFields":
"""The telescope configuration at this step."""
return TelescopeConfigFields("telescopeConfig")
[docs]
@classmethod
def estimate(cls) -> "StepEstimateFields":
"""Time estimate for this step's execution"""
return StepEstimateFields("estimate")
observe_class: "Igrins2StepGraphQLField" = Igrins2StepGraphQLField("observeClass")
"Observe class for this step"
[docs]
def fields(
self,
*subfields: Union[
Igrins2StepGraphQLField,
"Igrins2DynamicFields",
"StepConfigInterface",
"StepEstimateFields",
"TelescopeConfigFields",
],
) -> "Igrins2StepFields":
"""Subfields should come from the Igrins2StepFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "Igrins2StepFields":
self._alias = alias
return self
[docs]
class ImagingConfigOptionFields(GraphQLField):
"""Describes an instrument configuration option for imaging."""
instrument: "ImagingConfigOptionGraphQLField" = ImagingConfigOptionGraphQLField(
"instrument"
)
filter_label: "ImagingConfigOptionGraphQLField" = ImagingConfigOptionGraphQLField(
"filterLabel"
)
adaptive_optics: "ImagingConfigOptionGraphQLField" = (
ImagingConfigOptionGraphQLField("adaptiveOptics")
)
site: "ImagingConfigOptionGraphQLField" = ImagingConfigOptionGraphQLField("site")
[docs]
@classmethod
def fov(cls) -> "AngleFields":
return AngleFields("fov")
[docs]
@classmethod
def gmos_north(cls) -> "ImagingConfigOptionGmosNorthFields":
"""For GMOS North options, the GMOS North configuration. Null for other
instruments."""
return ImagingConfigOptionGmosNorthFields("gmosNorth")
[docs]
@classmethod
def gmos_south(cls) -> "ImagingConfigOptionGmosSouthFields":
"""For GMOS South options, the GMOS South configuration. Null for other
instruments."""
return ImagingConfigOptionGmosSouthFields("gmosSouth")
[docs]
def fields(
self,
*subfields: Union[
ImagingConfigOptionGraphQLField,
"AngleFields",
"ImagingConfigOptionGmosNorthFields",
"ImagingConfigOptionGmosSouthFields",
],
) -> "ImagingConfigOptionFields":
"""Subfields should come from the ImagingConfigOptionFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ImagingConfigOptionFields":
self._alias = alias
return self
[docs]
class ImagingConfigOptionGmosNorthFields(GraphQLField):
filter_: "ImagingConfigOptionGmosNorthGraphQLField" = (
ImagingConfigOptionGmosNorthGraphQLField("filter")
)
[docs]
def fields(
self, *subfields: ImagingConfigOptionGmosNorthGraphQLField
) -> "ImagingConfigOptionGmosNorthFields":
"""Subfields should come from the ImagingConfigOptionGmosNorthFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ImagingConfigOptionGmosNorthFields":
self._alias = alias
return self
[docs]
class ImagingConfigOptionGmosSouthFields(GraphQLField):
filter_: "ImagingConfigOptionGmosSouthGraphQLField" = (
ImagingConfigOptionGmosSouthGraphQLField("filter")
)
[docs]
def fields(
self, *subfields: ImagingConfigOptionGmosSouthGraphQLField
) -> "ImagingConfigOptionGmosSouthFields":
"""Subfields should come from the ImagingConfigOptionGmosSouthFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ImagingConfigOptionGmosSouthFields":
self._alias = alias
return self
[docs]
class ImagingScienceRequirementsFields(GraphQLField):
[docs]
@classmethod
def minimum_fov(cls) -> "AngleFields":
"""minimumFov, which may be unset by assigning a null value, or ignored by
skipping it altogether."""
return AngleFields("minimumFov")
narrow_filters: "ImagingScienceRequirementsGraphQLField" = (
ImagingScienceRequirementsGraphQLField("narrowFilters")
)
"narrowFilters, which may be unset by assigning a null value, or ignored by\nskipping it altogether."
broad_filters: "ImagingScienceRequirementsGraphQLField" = (
ImagingScienceRequirementsGraphQLField("broadFilters")
)
"broadFilters, which may be unset by assigning a null value, or ignored by\nskipping it altogether."
combined_filters: "ImagingScienceRequirementsGraphQLField" = (
ImagingScienceRequirementsGraphQLField("combinedFilters")
)
"combinedFilters, which may be unset by assigning a null value, or ignored by\nskipping it altogether."
[docs]
def fields(
self, *subfields: Union[ImagingScienceRequirementsGraphQLField, "AngleFields"]
) -> "ImagingScienceRequirementsFields":
"""Subfields should come from the ImagingScienceRequirementsFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ImagingScienceRequirementsFields":
self._alias = alias
return self
[docs]
class ItcInterface(GraphQLField):
"""ITC results for a particular observation, including relevant instrument
configurations and targets. There are specific instances for each `ItcType`."""
itc_type: "ItcGraphQLField" = ItcGraphQLField("itcType")
"The type of the Itc results."
[docs]
def fields(self, *subfields: ItcGraphQLField) -> "ItcInterface":
"""Subfields should come from the ItcInterface class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ItcInterface":
self._alias = alias
return self
[docs]
def on(self, type_name: str, *subfields: GraphQLField) -> "ItcInterface":
self._inline_fragments[type_name] = subfields
return self
[docs]
class ItcGhostIfuFields(GraphQLField):
"""GHOST IFU ITC results. Each channel is paired with its result set."""
itc_type: "ItcGhostIfuGraphQLField" = ItcGhostIfuGraphQLField("itcType")
"The type of the Itc results."
[docs]
@classmethod
def red(cls) -> "ItcResultSetFields":
return ItcResultSetFields("red")
[docs]
@classmethod
def blue(cls) -> "ItcResultSetFields":
return ItcResultSetFields("blue")
[docs]
def fields(
self, *subfields: Union[ItcGhostIfuGraphQLField, "ItcResultSetFields"]
) -> "ItcGhostIfuFields":
"""Subfields should come from the ItcGhostIfuFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ItcGhostIfuFields":
self._alias = alias
return self
[docs]
class ItcGmosNorthImagingFields(GraphQLField):
"""GMOS North imaging ITC results. Here each filter is paired with its result
set."""
itc_type: "ItcGmosNorthImagingGraphQLField" = ItcGmosNorthImagingGraphQLField(
"itcType"
)
"The type of the Itc results."
[docs]
@classmethod
def gmos_north_imaging_science(cls) -> "ItcGmosNorthImagingResultSetFields":
return ItcGmosNorthImagingResultSetFields("gmosNorthImagingScience")
[docs]
def fields(
self,
*subfields: Union[
ItcGmosNorthImagingGraphQLField, "ItcGmosNorthImagingResultSetFields"
],
) -> "ItcGmosNorthImagingFields":
"""Subfields should come from the ItcGmosNorthImagingFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ItcGmosNorthImagingFields":
self._alias = alias
return self
[docs]
class ItcGmosNorthImagingResultSetFields(GraphQLField):
"""Combines a GMOS North filter with an `ItcResultSet`. In other words, ITC
results for all targets but a single filter."""
filter_: "ItcGmosNorthImagingResultSetGraphQLField" = (
ItcGmosNorthImagingResultSetGraphQLField("filter")
)
[docs]
@classmethod
def results(cls) -> "ItcResultSetFields":
return ItcResultSetFields("results")
[docs]
def fields(
self,
*subfields: Union[
ItcGmosNorthImagingResultSetGraphQLField, "ItcResultSetFields"
],
) -> "ItcGmosNorthImagingResultSetFields":
"""Subfields should come from the ItcGmosNorthImagingResultSetFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ItcGmosNorthImagingResultSetFields":
self._alias = alias
return self
[docs]
class ItcGmosSouthImagingFields(GraphQLField):
"""GMOS South imaging ITC results. Here each filter is paired with its result
set."""
itc_type: "ItcGmosSouthImagingGraphQLField" = ItcGmosSouthImagingGraphQLField(
"itcType"
)
"The type of the Itc results."
[docs]
@classmethod
def gmos_south_imaging_science(cls) -> "ItcGmosSouthImagingResultSetFields":
return ItcGmosSouthImagingResultSetFields("gmosSouthImagingScience")
[docs]
def fields(
self,
*subfields: Union[
ItcGmosSouthImagingGraphQLField, "ItcGmosSouthImagingResultSetFields"
],
) -> "ItcGmosSouthImagingFields":
"""Subfields should come from the ItcGmosSouthImagingFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ItcGmosSouthImagingFields":
self._alias = alias
return self
[docs]
class ItcGmosSouthImagingResultSetFields(GraphQLField):
"""Combines a GMOS South filter with an `ItcResultSet`. In other words, ITC
results for all targets but a single filter."""
filter_: "ItcGmosSouthImagingResultSetGraphQLField" = (
ItcGmosSouthImagingResultSetGraphQLField("filter")
)
[docs]
@classmethod
def results(cls) -> "ItcResultSetFields":
return ItcResultSetFields("results")
[docs]
def fields(
self,
*subfields: Union[
ItcGmosSouthImagingResultSetGraphQLField, "ItcResultSetFields"
],
) -> "ItcGmosSouthImagingResultSetFields":
"""Subfields should come from the ItcGmosSouthImagingResultSetFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ItcGmosSouthImagingResultSetFields":
self._alias = alias
return self
[docs]
class ItcIgrins2SpectroscopyFields(GraphQLField):
"""ITC results for IGRINS-2 spectroscopy observations (no acquisition)."""
itc_type: "ItcIgrins2SpectroscopyGraphQLField" = ItcIgrins2SpectroscopyGraphQLField(
"itcType"
)
"The type of the Itc results."
[docs]
@classmethod
def spectroscopy_science(cls) -> "ItcResultSetFields":
return ItcResultSetFields("spectroscopyScience")
[docs]
def fields(
self,
*subfields: Union[ItcIgrins2SpectroscopyGraphQLField, "ItcResultSetFields"],
) -> "ItcIgrins2SpectroscopyFields":
"""Subfields should come from the ItcIgrins2SpectroscopyFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ItcIgrins2SpectroscopyFields":
self._alias = alias
return self
[docs]
class ItcResultFields(GraphQLField):
"""An ITC result for a single target."""
target_id: "ItcResultGraphQLField" = ItcResultGraphQLField("targetId")
[docs]
@classmethod
def exposure_time(cls) -> "TimeSpanFields":
return TimeSpanFields("exposureTime")
exposure_count: "ItcResultGraphQLField" = ItcResultGraphQLField("exposureCount")
[docs]
@classmethod
def signal_to_noise_at(cls) -> "SignalToNoiseAtFields":
return SignalToNoiseAtFields("signalToNoiseAt")
[docs]
def fields(
self,
*subfields: Union[
ItcResultGraphQLField, "SignalToNoiseAtFields", "TimeSpanFields"
],
) -> "ItcResultFields":
"""Subfields should come from the ItcResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ItcResultFields":
self._alias = alias
return self
[docs]
class ItcResultSetFields(GraphQLField):
"""Contains the result of calling the ITC for all targets, but a single instrument
configuration. Since the observation may contain multiple targets, there may
be multiple results. The "result" field contains the selected, representative,
result for all targets. If there are multiple successful results, this will
be the one that prescribes the longest observation. If there is a mix of
failures and successes, the overall "result" will be a failure. The "all" field
contains results for all targets regardless."""
[docs]
@classmethod
def selected(cls) -> "ItcResultFields":
return ItcResultFields("selected")
[docs]
@classmethod
def all(cls) -> "ItcResultFields":
return ItcResultFields("all")
index: "ItcResultSetGraphQLField" = ItcResultSetGraphQLField("index")
[docs]
def fields(
self, *subfields: Union[ItcResultSetGraphQLField, "ItcResultFields"]
) -> "ItcResultSetFields":
"""Subfields should come from the ItcResultSetFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ItcResultSetFields":
self._alias = alias
return self
[docs]
class ItcSpectroscopyFields(GraphQLField):
"""ITC results for spectroscopy observations."""
itc_type: "ItcSpectroscopyGraphQLField" = ItcSpectroscopyGraphQLField("itcType")
"The type of the Itc results."
[docs]
@classmethod
def acquisition(cls) -> "ItcResultSetFields":
return ItcResultSetFields("acquisition")
[docs]
@classmethod
def spectroscopy_science(cls) -> "ItcResultSetFields":
return ItcResultSetFields("spectroscopyScience")
[docs]
def fields(
self, *subfields: Union[ItcSpectroscopyGraphQLField, "ItcResultSetFields"]
) -> "ItcSpectroscopyFields":
"""Subfields should come from the ItcSpectroscopyFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ItcSpectroscopyFields":
self._alias = alias
return self
[docs]
class LargeProgramFields(GraphQLField):
"""Proposal properties for Large Program CallForProposals."""
science_subtype: "LargeProgramGraphQLField" = LargeProgramGraphQLField(
"scienceSubtype"
)
"The science type of this Call for Proposals."
to_o_activation: "LargeProgramGraphQLField" = LargeProgramGraphQLField(
"toOActivation"
)
"Whether (and how) the observations in this proposal are available for Target\nof Opportunity triggering."
min_percent_time: "LargeProgramGraphQLField" = LargeProgramGraphQLField(
"minPercentTime"
)
"Minimum percentage of observing time (first semester) required to consider this\nproposal successful."
min_percent_total_time: "LargeProgramGraphQLField" = LargeProgramGraphQLField(
"minPercentTotalTime"
)
"Minimum percentage of the total observing time (over all semesters) required\nto consider this proposal successful."
[docs]
@classmethod
def total_time(cls) -> "TimeSpanFields":
"""Total time requested (over multiple all semesters) for this proposal."""
return TimeSpanFields("totalTime")
aeon_multi_facility: "LargeProgramGraphQLField" = LargeProgramGraphQLField(
"aeonMultiFacility"
)
"Whether this proposal is part of the AEON/Multi-facility program."
jwst_synergy: "LargeProgramGraphQLField" = LargeProgramGraphQLField("jwstSynergy")
"Whether this proposal has JWST synergy."
[docs]
def fields(
self, *subfields: Union[LargeProgramGraphQLField, "TimeSpanFields"]
) -> "LargeProgramFields":
"""Subfields should come from the LargeProgramFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "LargeProgramFields":
self._alias = alias
return self
[docs]
class LibraryProgramReferenceFields(GraphQLField):
label: "LibraryProgramReferenceGraphQLField" = LibraryProgramReferenceGraphQLField(
"label"
)
type_: "LibraryProgramReferenceGraphQLField" = LibraryProgramReferenceGraphQLField(
"type"
)
description: "LibraryProgramReferenceGraphQLField" = (
LibraryProgramReferenceGraphQLField("description")
)
instrument: "LibraryProgramReferenceGraphQLField" = (
LibraryProgramReferenceGraphQLField("instrument")
)
[docs]
def fields(
self, *subfields: LibraryProgramReferenceGraphQLField
) -> "LibraryProgramReferenceFields":
"""Subfields should come from the LibraryProgramReferenceFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "LibraryProgramReferenceFields":
self._alias = alias
return self
[docs]
class LineFluxIntegratedFields(GraphQLField):
value: "LineFluxIntegratedGraphQLField" = LineFluxIntegratedGraphQLField("value")
units: "LineFluxIntegratedGraphQLField" = LineFluxIntegratedGraphQLField("units")
[docs]
def fields(
self, *subfields: LineFluxIntegratedGraphQLField
) -> "LineFluxIntegratedFields":
"""Subfields should come from the LineFluxIntegratedFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "LineFluxIntegratedFields":
self._alias = alias
return self
[docs]
class LineFluxSurfaceFields(GraphQLField):
value: "LineFluxSurfaceGraphQLField" = LineFluxSurfaceGraphQLField("value")
units: "LineFluxSurfaceGraphQLField" = LineFluxSurfaceGraphQLField("units")
[docs]
def fields(
self, *subfields: LineFluxSurfaceGraphQLField
) -> "LineFluxSurfaceFields":
"""Subfields should come from the LineFluxSurfaceFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "LineFluxSurfaceFields":
self._alias = alias
return self
[docs]
class LinkUserResultFields(GraphQLField):
[docs]
@classmethod
def user(cls) -> "ProgramUserFields":
return ProgramUserFields("user")
[docs]
def fields(
self, *subfields: Union[LinkUserResultGraphQLField, "ProgramUserFields"]
) -> "LinkUserResultFields":
"""Subfields should come from the LinkUserResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "LinkUserResultFields":
self._alias = alias
return self
[docs]
class MonitoringProgramReferenceFields(GraphQLField):
label: "MonitoringProgramReferenceGraphQLField" = (
MonitoringProgramReferenceGraphQLField("label")
)
type_: "MonitoringProgramReferenceGraphQLField" = (
MonitoringProgramReferenceGraphQLField("type")
)
instrument: "MonitoringProgramReferenceGraphQLField" = (
MonitoringProgramReferenceGraphQLField("instrument")
)
semester: "MonitoringProgramReferenceGraphQLField" = (
MonitoringProgramReferenceGraphQLField("semester")
)
semester_index: "MonitoringProgramReferenceGraphQLField" = (
MonitoringProgramReferenceGraphQLField("semesterIndex")
)
[docs]
def fields(
self, *subfields: MonitoringProgramReferenceGraphQLField
) -> "MonitoringProgramReferenceFields":
"""Subfields should come from the MonitoringProgramReferenceFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "MonitoringProgramReferenceFields":
self._alias = alias
return self
[docs]
class NonsiderealFields(GraphQLField):
des: "NonsiderealGraphQLField" = NonsiderealGraphQLField("des")
"Human readable designation that discriminates among ephemeris keys of the same type."
key_type: "NonsiderealGraphQLField" = NonsiderealGraphQLField("keyType")
"Nonsidereal target lookup type."
key: "NonsiderealGraphQLField" = NonsiderealGraphQLField("key")
"Synthesis of `keyType` and `des`"
[docs]
def fields(self, *subfields: NonsiderealGraphQLField) -> "NonsiderealFields":
"""Subfields should come from the NonsiderealFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "NonsiderealFields":
self._alias = alias
return self
[docs]
class ObservationFields(GraphQLField):
id: "ObservationGraphQLField" = ObservationGraphQLField("id")
"Observation ID"
existence: "ObservationGraphQLField" = ObservationGraphQLField("existence")
"DELETED or PRESENT"
[docs]
@classmethod
def reference(cls) -> "ObservationReferenceFields":
"""Observation reference, if any (requires the existence of a reference for the
program itself)."""
return ObservationReferenceFields("reference")
index: "ObservationGraphQLField" = ObservationGraphQLField("index")
"Observation index, relative to other observations in the same program."
title: "ObservationGraphQLField" = ObservationGraphQLField("title")
"Observation title generated from id and targets"
subtitle: "ObservationGraphQLField" = ObservationGraphQLField("subtitle")
"User-supplied observation-identifying detail information"
science_band: "ObservationGraphQLField" = ObservationGraphQLField("scienceBand")
"Observations are associated with a science band once time has been allocated\nto a program."
observation_time: "ObservationGraphQLField" = ObservationGraphQLField(
"observationTime"
)
"Reference time used for execution and visualization and time-dependent calculations\n(e.g., average parallactic angle and guide star selection)"
[docs]
@classmethod
def observation_duration(cls) -> "TimeSpanFields":
"""Used in conjunction with observationTime for time-dependentent calulations. If not
set, the remaining observation execution time will be used."""
return TimeSpanFields("observationDuration")
[docs]
@classmethod
def pos_angle_constraint(cls) -> "PosAngleConstraintFields":
"""Position angle constraint, if any."""
return PosAngleConstraintFields("posAngleConstraint")
[docs]
@classmethod
def program(cls) -> "ProgramFields":
"""The program that contains this observation"""
return ProgramFields("program")
[docs]
@classmethod
def target_environment(cls) -> "TargetEnvironmentFields":
"""The observation's target(s)"""
return TargetEnvironmentFields("targetEnvironment")
[docs]
@classmethod
def constraint_set(cls) -> "ConstraintSetFields":
"""The constraint set for the observation"""
return ConstraintSetFields("constraintSet")
[docs]
@classmethod
def timing_windows(cls) -> "TimingWindowFields":
"""Observation timing windows"""
return TimingWindowFields("timingWindows")
[docs]
@classmethod
def attachments(cls) -> "AttachmentFields":
"""attachments"""
return AttachmentFields("attachments")
[docs]
@classmethod
def science_requirements(cls) -> "ScienceRequirementsFields":
"""The top level science requirements"""
return ScienceRequirementsFields("scienceRequirements")
[docs]
@classmethod
def observing_mode(cls) -> "ObservingModeFields":
"""The science configuration"""
return ObservingModeFields("observingMode")
instrument: "ObservationGraphQLField" = ObservationGraphQLField("instrument")
"The instrument in use for this observation, if the observing mode is set."
[docs]
@classmethod
def execution(cls) -> "ExecutionFields":
"""Execution sequence and runtime artifacts"""
return ExecutionFields("execution")
[docs]
@classmethod
def itc(cls) -> "ItcInterface":
"""The ITC result for this observation, assuming it has associated target(s)
and a selected observing mode."""
return ItcInterface("itc")
group_id: "ObservationGraphQLField" = ObservationGraphQLField("groupId")
"Enclosing group, if any."
group_index: "ObservationGraphQLField" = ObservationGraphQLField("groupIndex")
"Index in enclosing group or at the top level if ungrouped. If left unspecified on creation, observation will be added last in its enclosing group or at the top level. Cannot be set to null."
calibration_role: "ObservationGraphQLField" = ObservationGraphQLField(
"calibrationRole"
)
"The Calibration role of this observation"
observer_notes: "ObservationGraphQLField" = ObservationGraphQLField("observerNotes")
"Notes for the observer"
[docs]
@classmethod
def configuration(cls) -> "ConfigurationFields":
"""Parameters relevant to approved configurations."""
return ConfigurationFields("configuration")
[docs]
@classmethod
def configuration_requests(cls) -> "ConfigurationRequestFields":
"""Program configuration requests applicable to this observation."""
return ConfigurationRequestFields("configurationRequests")
[docs]
@classmethod
def workflow(cls) -> "CalculatedObservationWorkflowFields":
"""Obtains the current observation workflow state and valid transitions (and any
validation errors). Because this calculation is expensive, it is performed in
the background when something relevant changes and may be in a state of flux
when queried. The calculation state in the result can be used to determine
whether a pending update is expected."""
return CalculatedObservationWorkflowFields("workflow")
[docs]
def fields(
self,
*subfields: Union[
ObservationGraphQLField,
"AttachmentFields",
"CalculatedObservationWorkflowFields",
"ConfigurationFields",
"ConfigurationRequestFields",
"ConstraintSetFields",
"ExecutionFields",
"ItcInterface",
"ObservationReferenceFields",
"ObservingModeFields",
"PosAngleConstraintFields",
"ProgramFields",
"ScienceRequirementsFields",
"TargetEnvironmentFields",
"TimeSpanFields",
"TimingWindowFields",
],
) -> "ObservationFields":
"""Subfields should come from the ObservationFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ObservationFields":
self._alias = alias
return self
[docs]
class ObservationReferenceFields(GraphQLField):
"""Observation reference type, broken into its constituient parts and including
a formatted label."""
label: "ObservationReferenceGraphQLField" = ObservationReferenceGraphQLField(
"label"
)
"Formatted observation reference label."
[docs]
@classmethod
def program(cls) -> "ProgramReferenceInterface":
"""The program reference."""
return ProgramReferenceInterface("program")
index: "ObservationReferenceGraphQLField" = ObservationReferenceGraphQLField(
"index"
)
"The observation index relative to its program."
[docs]
def fields(
self,
*subfields: Union[
ObservationReferenceGraphQLField, "ProgramReferenceInterface"
],
) -> "ObservationReferenceFields":
"""Subfields should come from the ObservationReferenceFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ObservationReferenceFields":
self._alias = alias
return self
[docs]
class ObservationSelectResultFields(GraphQLField):
"""The matching observation results, limited to a maximum of 1000 entries."""
[docs]
@classmethod
def matches(cls) -> "ObservationFields":
"""Matching observations up to the return size limit of 1000"""
return ObservationFields("matches")
has_more: "ObservationSelectResultGraphQLField" = (
ObservationSelectResultGraphQLField("hasMore")
)
"`true` when there were additional matches that were not returned."
[docs]
def fields(
self,
*subfields: Union[ObservationSelectResultGraphQLField, "ObservationFields"],
) -> "ObservationSelectResultFields":
"""Subfields should come from the ObservationSelectResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ObservationSelectResultFields":
self._alias = alias
return self
[docs]
class ObservationValidationFields(GraphQLField):
"""An observation validation problem"""
code: "ObservationValidationGraphQLField" = ObservationValidationGraphQLField(
"code"
)
"The type of validation problem"
messages: "ObservationValidationGraphQLField" = ObservationValidationGraphQLField(
"messages"
)
"Particular errors for this validation type"
[docs]
def fields(
self, *subfields: ObservationValidationGraphQLField
) -> "ObservationValidationFields":
"""Subfields should come from the ObservationValidationFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ObservationValidationFields":
self._alias = alias
return self
[docs]
class ObservationWorkflowFields(GraphQLField):
state: "ObservationWorkflowGraphQLField" = ObservationWorkflowGraphQLField("state")
valid_transitions: "ObservationWorkflowGraphQLField" = (
ObservationWorkflowGraphQLField("validTransitions")
)
[docs]
@classmethod
def validation_errors(cls) -> "ObservationValidationFields":
return ObservationValidationFields("validationErrors")
[docs]
def fields(
self,
*subfields: Union[
ObservationWorkflowGraphQLField, "ObservationValidationFields"
],
) -> "ObservationWorkflowFields":
"""Subfields should come from the ObservationWorkflowFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ObservationWorkflowFields":
self._alias = alias
return self
[docs]
class ObservingModeFields(GraphQLField):
"""Base science mode"""
instrument: "ObservingModeGraphQLField" = ObservingModeGraphQLField("instrument")
"Instrument"
mode: "ObservingModeGraphQLField" = ObservingModeGraphQLField("mode")
"Mode type"
[docs]
@classmethod
def flamingos_2_long_slit(cls) -> "Flamingos2LongSlitFields":
"""Flamingos 2 Long Slit mode"""
return Flamingos2LongSlitFields("flamingos2LongSlit")
[docs]
@classmethod
def ghost_ifu(cls) -> "GhostIfuFields":
"""GHOST IFU mode"""
return GhostIfuFields("ghostIfu")
[docs]
@classmethod
def gmos_north_imaging(cls) -> "GmosNorthImagingFields":
"""GMOS North Imaging mode"""
return GmosNorthImagingFields("gmosNorthImaging")
[docs]
@classmethod
def gmos_north_long_slit(cls) -> "GmosNorthLongSlitFields":
"""GMOS North Long Slit mode"""
return GmosNorthLongSlitFields("gmosNorthLongSlit")
[docs]
@classmethod
def gmos_south_imaging(cls) -> "GmosSouthImagingFields":
"""GMOS South Imaging mode"""
return GmosSouthImagingFields("gmosSouthImaging")
[docs]
@classmethod
def gmos_south_long_slit(cls) -> "GmosSouthLongSlitFields":
"""GMOS South Long Slit mode"""
return GmosSouthLongSlitFields("gmosSouthLongSlit")
[docs]
@classmethod
def igrins_2_long_slit(cls) -> "Igrins2LongSlitFields":
"""IGRINS-2 Long Slit mode"""
return Igrins2LongSlitFields("igrins2LongSlit")
[docs]
@classmethod
def visitor(cls) -> "VisitorFields":
return VisitorFields("visitor")
[docs]
def fields(
self,
*subfields: Union[
ObservingModeGraphQLField,
"Flamingos2LongSlitFields",
"GhostIfuFields",
"GmosNorthImagingFields",
"GmosNorthLongSlitFields",
"GmosSouthImagingFields",
"GmosSouthLongSlitFields",
"Igrins2LongSlitFields",
"VisitorFields",
],
) -> "ObservingModeFields":
"""Subfields should come from the ObservingModeFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ObservingModeFields":
self._alias = alias
return self
[docs]
class ObservingModeGroupFields(GraphQLField):
[docs]
@classmethod
def observations(
cls,
include_deleted: bool,
*,
offset: Optional[Any] = None,
limit: Optional[Any] = None,
) -> "ObservationSelectResultFields":
"""Observations associated with the common value"""
arguments: dict[str, dict[str, Any]] = {
"includeDeleted": {"type": "Boolean!", "value": include_deleted},
"OFFSET": {"type": "ObservationId", "value": offset},
"LIMIT": {"type": "NonNegInt", "value": limit},
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return ObservationSelectResultFields(
"observations", arguments=cleared_arguments
)
[docs]
@classmethod
def observing_mode(cls) -> "ObservingModeFields":
"""Commonly held value across the observations"""
return ObservingModeFields("observingMode")
[docs]
@classmethod
def program(cls) -> "ProgramFields":
"""Link back to program."""
return ProgramFields("program")
[docs]
def fields(
self,
*subfields: Union[
ObservingModeGroupGraphQLField,
"ObservationSelectResultFields",
"ObservingModeFields",
"ProgramFields",
],
) -> "ObservingModeGroupFields":
"""Subfields should come from the ObservingModeGroupFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ObservingModeGroupFields":
self._alias = alias
return self
[docs]
class ObservingModeGroupSelectResultFields(GraphQLField):
"""The matching ObservingModeGroup results, limited to a maximum of 1000 entries."""
[docs]
@classmethod
def matches(cls) -> "ObservingModeGroupFields":
"""Matching ObservingModeGroups up to the return size limit of 1000"""
return ObservingModeGroupFields("matches")
has_more: "ObservingModeGroupSelectResultGraphQLField" = (
ObservingModeGroupSelectResultGraphQLField("hasMore")
)
"`true` when there were additional matches that were not returned."
[docs]
def fields(
self,
*subfields: Union[
ObservingModeGroupSelectResultGraphQLField, "ObservingModeGroupFields"
],
) -> "ObservingModeGroupSelectResultFields":
"""Subfields should come from the ObservingModeGroupSelectResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ObservingModeGroupSelectResultFields":
self._alias = alias
return self
[docs]
class OffsetFields(GraphQLField):
[docs]
@classmethod
def p(cls) -> "OffsetPFields":
"""Offset in p"""
return OffsetPFields("p")
[docs]
@classmethod
def q(cls) -> "OffsetQFields":
"""Offset in q"""
return OffsetQFields("q")
[docs]
def fields(
self, *subfields: Union[OffsetGraphQLField, "OffsetPFields", "OffsetQFields"]
) -> "OffsetFields":
"""Subfields should come from the OffsetFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "OffsetFields":
self._alias = alias
return self
[docs]
class OffsetPFields(GraphQLField):
microarcseconds: "OffsetPGraphQLField" = OffsetPGraphQLField("microarcseconds")
"p offset in µas"
milliarcseconds: "OffsetPGraphQLField" = OffsetPGraphQLField("milliarcseconds")
"p offset in mas"
arcseconds: "OffsetPGraphQLField" = OffsetPGraphQLField("arcseconds")
"p offset in arcsec"
[docs]
def fields(self, *subfields: OffsetPGraphQLField) -> "OffsetPFields":
"""Subfields should come from the OffsetPFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "OffsetPFields":
self._alias = alias
return self
[docs]
class OffsetQFields(GraphQLField):
microarcseconds: "OffsetQGraphQLField" = OffsetQGraphQLField("microarcseconds")
"q offset in µas"
milliarcseconds: "OffsetQGraphQLField" = OffsetQGraphQLField("milliarcseconds")
"q offset in mas"
arcseconds: "OffsetQGraphQLField" = OffsetQGraphQLField("arcseconds")
"q offset in arcsec"
[docs]
def fields(self, *subfields: OffsetQGraphQLField) -> "OffsetQFields":
"""Subfields should come from the OffsetQFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "OffsetQFields":
self._alias = alias
return self
[docs]
class OpportunityFields(GraphQLField):
[docs]
@classmethod
def region(cls) -> "RegionFields":
return RegionFields("region")
[docs]
def fields(
self, *subfields: Union[OpportunityGraphQLField, "RegionFields"]
) -> "OpportunityFields":
"""Subfields should come from the OpportunityFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "OpportunityFields":
self._alias = alias
return self
[docs]
class ParallaxFields(GraphQLField):
microarcseconds: "ParallaxGraphQLField" = ParallaxGraphQLField("microarcseconds")
"Parallax in microarcseconds"
milliarcseconds: "ParallaxGraphQLField" = ParallaxGraphQLField("milliarcseconds")
"Parallax in milliarcseconds"
[docs]
def fields(self, *subfields: ParallaxGraphQLField) -> "ParallaxFields":
"""Subfields should come from the ParallaxFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ParallaxFields":
self._alias = alias
return self
[docs]
class PartnerLinkInterface(GraphQLField):
"""Represents the association of a user with a `Partner`, if any."""
link_type: "PartnerLinkGraphQLField" = PartnerLinkGraphQLField("linkType")
"Partner link discriminator."
[docs]
def fields(self, *subfields: PartnerLinkGraphQLField) -> "PartnerLinkInterface":
"""Subfields should come from the PartnerLinkInterface class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "PartnerLinkInterface":
self._alias = alias
return self
[docs]
def on(self, type_name: str, *subfields: GraphQLField) -> "PartnerLinkInterface":
self._inline_fragments[type_name] = subfields
return self
[docs]
class PartnerSplitFields(GraphQLField):
"""Partner splits detail how requested time for a Queue or Classical proposal
should be distributed amongst Gemini partners."""
partner: "PartnerSplitGraphQLField" = PartnerSplitGraphQLField("partner")
percent: "PartnerSplitGraphQLField" = PartnerSplitGraphQLField("percent")
"Percentage of requested time that should be associated with the partner."
[docs]
def fields(self, *subfields: PartnerSplitGraphQLField) -> "PartnerSplitFields":
"""Subfields should come from the PartnerSplitFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "PartnerSplitFields":
self._alias = alias
return self
[docs]
class PoorWeatherFields(GraphQLField):
"""Proposal properties for Regular Semester (Poor Weather) CallForProposals."""
science_subtype: "PoorWeatherGraphQLField" = PoorWeatherGraphQLField(
"scienceSubtype"
)
"The science type of this Call for Proposals."
[docs]
def fields(self, *subfields: PoorWeatherGraphQLField) -> "PoorWeatherFields":
"""Subfields should come from the PoorWeatherFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "PoorWeatherFields":
self._alias = alias
return self
[docs]
class PosAngleConstraintFields(GraphQLField):
"""Constraints (if any) on the observation's position angle."""
mode: "PosAngleConstraintGraphQLField" = PosAngleConstraintGraphQLField("mode")
"The position angle constraint mode in use. The value will determine whether\nthe angle is respected or ignored."
[docs]
@classmethod
def angle(cls) -> "AngleFields":
"""The fixed position angle. This will be kept but ignored for UNBOUNDED and
AVERAGE_PARALLACTIC modes."""
return AngleFields("angle")
[docs]
def fields(
self, *subfields: Union[PosAngleConstraintGraphQLField, "AngleFields"]
) -> "PosAngleConstraintFields":
"""Subfields should come from the PosAngleConstraintFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "PosAngleConstraintFields":
self._alias = alias
return self
[docs]
class ProgramFields(GraphQLField):
id: "ProgramGraphQLField" = ProgramGraphQLField("id")
"Program ID"
existence: "ProgramGraphQLField" = ProgramGraphQLField("existence")
"DELETED or PRESENT"
name: "ProgramGraphQLField" = ProgramGraphQLField("name")
"Program name / title."
description: "ProgramGraphQLField" = ProgramGraphQLField("description")
"Program description / abstract."
[docs]
@classmethod
def notes(cls, include_deleted: bool) -> "ProgramNoteFields":
"""Notes associated with the program, if any."""
arguments: dict[str, dict[str, Any]] = {
"includeDeleted": {"type": "Boolean!", "value": include_deleted}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return ProgramNoteFields("notes", arguments=cleared_arguments)
type_: "ProgramGraphQLField" = ProgramGraphQLField("type")
"Program type"
[docs]
@classmethod
def reference(cls) -> "ProgramReferenceInterface":
"""Program reference, if any."""
return ProgramReferenceInterface("reference")
[docs]
@classmethod
def proposal(cls) -> "ProposalFields":
"""Program proposal"""
return ProposalFields("proposal")
[docs]
@classmethod
def active(cls) -> "DateIntervalFields":
"""Active period for this program. Observations must be completed during this
time interval. By default, if there is an associated proposal tied to a
particular Call for Proposals (CfP), the active period will correspond to the
Cfp active period."""
return DateIntervalFields("active")
proposal_status: "ProgramGraphQLField" = ProgramGraphQLField("proposalStatus")
"Proposal status of the program"
[docs]
@classmethod
def pi(cls) -> "ProgramUserFields":
"""Principal Investigator"""
return ProgramUserFields("pi")
[docs]
@classmethod
def users(cls) -> "ProgramUserFields":
"""Users assigned to this science program"""
return ProgramUserFields("users")
[docs]
@classmethod
def observations(
cls,
include_deleted: bool,
*,
offset: Optional[Any] = None,
limit: Optional[Any] = None,
) -> "ObservationSelectResultFields":
"""All observations associated with the program."""
arguments: dict[str, dict[str, Any]] = {
"includeDeleted": {"type": "Boolean!", "value": include_deleted},
"OFFSET": {"type": "ObservationId", "value": offset},
"LIMIT": {"type": "NonNegInt", "value": limit},
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return ObservationSelectResultFields(
"observations", arguments=cleared_arguments
)
[docs]
@classmethod
def configuration_requests(
cls, *, offset: Optional[Any] = None, limit: Optional[Any] = None
) -> "ConfigurationRequestSelectResultFields":
"""All configuration requests associated with the program."""
arguments: dict[str, dict[str, Any]] = {
"OFFSET": {"type": "ConfigurationRequestId", "value": offset},
"LIMIT": {"type": "NonNegInt", "value": limit},
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return ConfigurationRequestSelectResultFields(
"configurationRequests", arguments=cleared_arguments
)
[docs]
@classmethod
def attachments(cls) -> "AttachmentFields":
"""Attachments assocated with the program"""
return AttachmentFields("attachments")
[docs]
@classmethod
def group_elements(cls, include_deleted: bool) -> "GroupElementFields":
"""Top-level group elements (observations and sub-groups) in the program."""
arguments: dict[str, dict[str, Any]] = {
"includeDeleted": {"type": "Boolean!", "value": include_deleted}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return GroupElementFields("groupElements", arguments=cleared_arguments)
[docs]
@classmethod
def all_group_elements(cls, include_deleted: bool) -> "GroupElementFields":
"""All group elements (observations and sub-groups) in the program."""
arguments: dict[str, dict[str, Any]] = {
"includeDeleted": {"type": "Boolean!", "value": include_deleted}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return GroupElementFields("allGroupElements", arguments=cleared_arguments)
[docs]
@classmethod
def time_estimate_range(cls) -> "CalculatedCategorizedTimeRangeFields":
"""Remaining execution time estimate range, assuming it can be calculated. In
order for an observation to have an estimate, it must be fully defined such
that a sequence can be generated for it. If a program has observations that
are required and which are not fully defined, the remaining time estimate
cannot be calculated."""
return CalculatedCategorizedTimeRangeFields("timeEstimateRange")
[docs]
@classmethod
def time_estimate_banded(cls) -> "CalculatedBandedTimeFields":
"""Prepared time by band ignoring `minimumRequired` in groups, for observations
that can be calculated. In order for an observation to have an estimate, it
must be fully defined such that a sequence can be generated for it. All
defined observations in every band present in the program are included."""
return CalculatedBandedTimeFields("timeEstimateBanded")
[docs]
@classmethod
def time_charge(cls) -> "BandedTimeFields":
"""Program-wide time charge, summing all corrected observation time charges."""
return BandedTimeFields("timeCharge")
[docs]
@classmethod
def user_invitations(cls) -> "UserInvitationFields":
"""All user invitations associated with this program."""
return UserInvitationFields("userInvitations")
[docs]
@classmethod
def allocations(cls) -> "AllocationFields":
"""All partner time allocations."""
return AllocationFields("allocations")
calibration_role: "ProgramGraphQLField" = ProgramGraphQLField("calibrationRole")
"Calibration role of the program"
[docs]
@classmethod
def goa(cls) -> "GoaPropertiesFields":
"""Observatory archive properties related to this program."""
return GoaPropertiesFields("goa")
[docs]
def fields(
self,
*subfields: Union[
ProgramGraphQLField,
"AllocationFields",
"AttachmentFields",
"BandedTimeFields",
"CalculatedBandedTimeFields",
"CalculatedCategorizedTimeRangeFields",
"ConfigurationRequestSelectResultFields",
"DateIntervalFields",
"GoaPropertiesFields",
"GroupElementFields",
"ObservationSelectResultFields",
"ProgramNoteFields",
"ProgramReferenceInterface",
"ProgramUserFields",
"ProposalFields",
"UserInvitationFields",
],
) -> "ProgramFields":
"""Subfields should come from the ProgramFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ProgramFields":
self._alias = alias
return self
[docs]
class ProgramNoteFields(GraphQLField):
"""Program notes are arbitrary titled text messages associated with a particular
program. Notes may be private, in which case they are only visible to staff."""
id: "ProgramNoteGraphQLField" = ProgramNoteGraphQLField("id")
"This note's unique id."
[docs]
@classmethod
def program(cls) -> "ProgramFields":
"""The program with which this note is associated."""
return ProgramFields("program")
title: "ProgramNoteGraphQLField" = ProgramNoteGraphQLField("title")
"The note title."
text: "ProgramNoteGraphQLField" = ProgramNoteGraphQLField("text")
"The note text, if any."
is_private: "ProgramNoteGraphQLField" = ProgramNoteGraphQLField("isPrivate")
"Whether the note is only available to Gemini staff."
existence: "ProgramNoteGraphQLField" = ProgramNoteGraphQLField("existence")
"DELETED or PRESENT"
[docs]
def fields(
self, *subfields: Union[ProgramNoteGraphQLField, "ProgramFields"]
) -> "ProgramNoteFields":
"""Subfields should come from the ProgramNoteFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ProgramNoteFields":
self._alias = alias
return self
[docs]
class ProgramNoteSelectResultFields(GraphQLField):
[docs]
@classmethod
def matches(cls) -> "ProgramNoteFields":
"""Matching notes up to the return size limit of 1000."""
return ProgramNoteFields("matches")
has_more: "ProgramNoteSelectResultGraphQLField" = (
ProgramNoteSelectResultGraphQLField("hasMore")
)
"`true` when there were additional matches that were not returned."
[docs]
def fields(
self,
*subfields: Union[ProgramNoteSelectResultGraphQLField, "ProgramNoteFields"],
) -> "ProgramNoteSelectResultFields":
"""Subfields should come from the ProgramNoteSelectResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ProgramNoteSelectResultFields":
self._alias = alias
return self
[docs]
class ProgramReferenceInterface(GraphQLField):
"""Defines the category of program references, where specific implementations exist
for calibration, engineering, etc."""
label: "ProgramReferenceGraphQLField" = ProgramReferenceGraphQLField("label")
type_: "ProgramReferenceGraphQLField" = ProgramReferenceGraphQLField("type")
[docs]
def fields(
self, *subfields: ProgramReferenceGraphQLField
) -> "ProgramReferenceInterface":
"""Subfields should come from the ProgramReferenceInterface class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ProgramReferenceInterface":
self._alias = alias
return self
[docs]
def on(
self, type_name: str, *subfields: GraphQLField
) -> "ProgramReferenceInterface":
self._inline_fragments[type_name] = subfields
return self
[docs]
class ProgramSelectResultFields(GraphQLField):
"""The matching program results, limited to a maximum of 1000 entries."""
[docs]
@classmethod
def matches(cls) -> "ProgramFields":
"""Matching programs up to the return size limit of 1000"""
return ProgramFields("matches")
has_more: "ProgramSelectResultGraphQLField" = ProgramSelectResultGraphQLField(
"hasMore"
)
"`true` when there were additional matches that were not returned."
[docs]
def fields(
self, *subfields: Union[ProgramSelectResultGraphQLField, "ProgramFields"]
) -> "ProgramSelectResultFields":
"""Subfields should come from the ProgramSelectResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ProgramSelectResultFields":
self._alias = alias
return self
[docs]
class ProgramUserFields(GraphQLField):
"""An assignment of a user to a program."""
id: "ProgramUserGraphQLField" = ProgramUserGraphQLField("id")
role: "ProgramUserGraphQLField" = ProgramUserGraphQLField("role")
[docs]
@classmethod
def program(cls) -> "ProgramFields":
return ProgramFields("program")
[docs]
@classmethod
def user(cls) -> "UserFields":
return UserFields("user")
[docs]
@classmethod
def partner_link(cls) -> "PartnerLinkInterface":
"""How the partner is associated with a partner."""
return PartnerLinkInterface("partnerLink")
[docs]
@classmethod
def preferred_profile(cls) -> "UserProfileFields":
"""The preferred profile overrides any values that may be in the Orcid profile (user.profile)."""
return UserProfileFields("preferredProfile")
educational_status: "ProgramUserGraphQLField" = ProgramUserGraphQLField(
"educationalStatus"
)
"User educational status. PHD/Undergrad/Grad/Other."
gender: "ProgramUserGraphQLField" = ProgramUserGraphQLField("gender")
"Users' reported gender."
thesis: "ProgramUserGraphQLField" = ProgramUserGraphQLField("thesis")
"Flag indicating whether the user's proposal is part of a thesis."
[docs]
@classmethod
def invitations(cls) -> "UserInvitationFields":
"""User invitations, if any, associated with this program user."""
return UserInvitationFields("invitations")
affiliation: "ProgramUserGraphQLField" = ProgramUserGraphQLField("affiliation")
"Investigator affiliation."
has_data_access: "ProgramUserGraphQLField" = ProgramUserGraphQLField(
"hasDataAccess"
)
"Has access to data."
display_name: "ProgramUserGraphQLField" = ProgramUserGraphQLField("displayName")
"Name created preferentially from the fields of the preferred profile, falling back\nto the Orcid profile if the preferred fields are not set."
email: "ProgramUserGraphQLField" = ProgramUserGraphQLField("email")
"The user's email address from the preferred profile, falling back to the Orcid profile\nif the preferred email is not set."
[docs]
def fields(
self,
*subfields: Union[
ProgramUserGraphQLField,
"PartnerLinkInterface",
"ProgramFields",
"UserFields",
"UserInvitationFields",
"UserProfileFields",
],
) -> "ProgramUserFields":
"""Subfields should come from the ProgramUserFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ProgramUserFields":
self._alias = alias
return self
[docs]
class ProgramUserSelectResultFields(GraphQLField):
"""The matching program user results, limited to a maximum of 1000 entries."""
[docs]
@classmethod
def matches(cls) -> "ProgramUserFields":
"""Matching program users up to the return size limit of 1000"""
return ProgramUserFields("matches")
has_more: "ProgramUserSelectResultGraphQLField" = (
ProgramUserSelectResultGraphQLField("hasMore")
)
"`true` when there were additional matches that were not returned."
[docs]
def fields(
self,
*subfields: Union[ProgramUserSelectResultGraphQLField, "ProgramUserFields"],
) -> "ProgramUserSelectResultFields":
"""Subfields should come from the ProgramUserSelectResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ProgramUserSelectResultFields":
self._alias = alias
return self
[docs]
class ProperMotionFields(GraphQLField):
[docs]
@classmethod
def ra(cls) -> "ProperMotionRAFields":
"""Proper motion in RA"""
return ProperMotionRAFields("ra")
[docs]
@classmethod
def dec(cls) -> "ProperMotionDeclinationFields":
"""Proper motion in declination"""
return ProperMotionDeclinationFields("dec")
[docs]
def fields(
self,
*subfields: Union[
ProperMotionGraphQLField,
"ProperMotionDeclinationFields",
"ProperMotionRAFields",
],
) -> "ProperMotionFields":
"""Subfields should come from the ProperMotionFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ProperMotionFields":
self._alias = alias
return self
[docs]
class ProperMotionDeclinationFields(GraphQLField):
microarcseconds_per_year: "ProperMotionDeclinationGraphQLField" = (
ProperMotionDeclinationGraphQLField("microarcsecondsPerYear")
)
"Proper motion in properMotion μas/year"
milliarcseconds_per_year: "ProperMotionDeclinationGraphQLField" = (
ProperMotionDeclinationGraphQLField("milliarcsecondsPerYear")
)
"Proper motion in properMotion mas/year"
[docs]
def fields(
self, *subfields: ProperMotionDeclinationGraphQLField
) -> "ProperMotionDeclinationFields":
"""Subfields should come from the ProperMotionDeclinationFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ProperMotionDeclinationFields":
self._alias = alias
return self
[docs]
class ProperMotionRAFields(GraphQLField):
microarcseconds_per_year: "ProperMotionRAGraphQLField" = ProperMotionRAGraphQLField(
"microarcsecondsPerYear"
)
"Proper motion in properMotion μas/year"
milliarcseconds_per_year: "ProperMotionRAGraphQLField" = ProperMotionRAGraphQLField(
"milliarcsecondsPerYear"
)
"Proper motion in properMotion mas/year"
[docs]
def fields(self, *subfields: ProperMotionRAGraphQLField) -> "ProperMotionRAFields":
"""Subfields should come from the ProperMotionRAFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ProperMotionRAFields":
self._alias = alias
return self
[docs]
class ProposalFields(GraphQLField):
[docs]
@classmethod
def reference(cls) -> "ProposalReferenceFields":
"""The proposal reference, assuming the proposal has been submitted and
assigned a semester."""
return ProposalReferenceFields("reference")
[docs]
@classmethod
def call(cls) -> "CallForProposalsFields":
"""The corresponding CallForProposals definition itself, if the call id has been
set."""
return CallForProposalsFields("call")
category: "ProposalGraphQLField" = ProposalGraphQLField("category")
"Proposal TAC category"
[docs]
@classmethod
def type_(cls) -> "ProposalTypeInterface":
"""Properties of this proposal that are dependent upon the Call for Proposals
type."""
return ProposalTypeInterface("type")
[docs]
def fields(
self,
*subfields: Union[
ProposalGraphQLField,
"CallForProposalsFields",
"ProposalReferenceFields",
"ProposalTypeInterface",
],
) -> "ProposalFields":
"""Subfields should come from the ProposalFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ProposalFields":
self._alias = alias
return self
[docs]
class ProposalReferenceFields(GraphQLField):
label: "ProposalReferenceGraphQLField" = ProposalReferenceGraphQLField("label")
semester: "ProposalReferenceGraphQLField" = ProposalReferenceGraphQLField(
"semester"
)
semester_index: "ProposalReferenceGraphQLField" = ProposalReferenceGraphQLField(
"semesterIndex"
)
[docs]
def fields(
self, *subfields: ProposalReferenceGraphQLField
) -> "ProposalReferenceFields":
"""Subfields should come from the ProposalReferenceFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ProposalReferenceFields":
self._alias = alias
return self
[docs]
class ProposalTypeInterface(GraphQLField):
"""Proposal properties that depend on the particular call for proposals associated
with this proposal."""
science_subtype: "ProposalTypeGraphQLField" = ProposalTypeGraphQLField(
"scienceSubtype"
)
"The science type of this Call for Proposals."
[docs]
def fields(self, *subfields: ProposalTypeGraphQLField) -> "ProposalTypeInterface":
"""Subfields should come from the ProposalTypeInterface class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ProposalTypeInterface":
self._alias = alias
return self
[docs]
def on(self, type_name: str, *subfields: GraphQLField) -> "ProposalTypeInterface":
self._inline_fragments[type_name] = subfields
return self
[docs]
class QueueFields(GraphQLField):
"""Proposal properties for Regular Semester (Queue) CallForProposals."""
science_subtype: "QueueGraphQLField" = QueueGraphQLField("scienceSubtype")
"The science type of this Call for Proposals."
to_o_activation: "QueueGraphQLField" = QueueGraphQLField("toOActivation")
"Whether (and how) the observations in this proposal are available for Target\nof Opportunity triggering."
min_percent_time: "QueueGraphQLField" = QueueGraphQLField("minPercentTime")
"Minimum percentage of observing time required to consider this proposal\nsuccessful."
[docs]
@classmethod
def partner_splits(cls) -> "PartnerSplitFields":
"""Describes how time for the program will be apportioned across partners."""
return PartnerSplitFields("partnerSplits")
consider_for_band_3: "QueueGraphQLField" = QueueGraphQLField("considerForBand3")
"Whether this proposal should be considered for Band 3. Defaults to UNSET\non creation; must be CONSIDER or DO_NOT_CONSIDER before the proposal can\nbe submitted."
aeon_multi_facility: "QueueGraphQLField" = QueueGraphQLField("aeonMultiFacility")
"Whether this proposal is part of the AEON/Multi-facility program."
jwst_synergy: "QueueGraphQLField" = QueueGraphQLField("jwstSynergy")
"Whether this proposal has JWST synergy."
us_long_term: "QueueGraphQLField" = QueueGraphQLField("usLongTerm")
"Whether this is a US Long Term proposal."
[docs]
def fields(
self, *subfields: Union[QueueGraphQLField, "PartnerSplitFields"]
) -> "QueueFields":
"""Subfields should come from the QueueFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "QueueFields":
self._alias = alias
return self
[docs]
class RadialVelocityFields(GraphQLField):
centimeters_per_second: "RadialVelocityGraphQLField" = RadialVelocityGraphQLField(
"centimetersPerSecond"
)
"Radial velocity in cm/s"
meters_per_second: "RadialVelocityGraphQLField" = RadialVelocityGraphQLField(
"metersPerSecond"
)
"Radial velocity in m/s"
kilometers_per_second: "RadialVelocityGraphQLField" = RadialVelocityGraphQLField(
"kilometersPerSecond"
)
"Radial velocity in km/s"
[docs]
def fields(self, *subfields: RadialVelocityGraphQLField) -> "RadialVelocityFields":
"""Subfields should come from the RadialVelocityFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "RadialVelocityFields":
self._alias = alias
return self
[docs]
class RandomTelescopeConfigGeneratorFields(GraphQLField):
[docs]
@classmethod
def size(cls) -> "AngleFields":
return AngleFields("size")
[docs]
@classmethod
def center(cls) -> "OffsetFields":
return OffsetFields("center")
seed: "RandomTelescopeConfigGeneratorGraphQLField" = (
RandomTelescopeConfigGeneratorGraphQLField("seed")
)
[docs]
def fields(
self,
*subfields: Union[
RandomTelescopeConfigGeneratorGraphQLField, "AngleFields", "OffsetFields"
],
) -> "RandomTelescopeConfigGeneratorFields":
"""Subfields should come from the RandomTelescopeConfigGeneratorFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "RandomTelescopeConfigGeneratorFields":
self._alias = alias
return self
[docs]
class RecordDatasetResultFields(GraphQLField):
"""The result of recording a new dataset."""
[docs]
@classmethod
def dataset(cls) -> "DatasetFields":
"""The new dataset that was added."""
return DatasetFields("dataset")
[docs]
def fields(
self, *subfields: Union[RecordDatasetResultGraphQLField, "DatasetFields"]
) -> "RecordDatasetResultFields":
"""Subfields should come from the RecordDatasetResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "RecordDatasetResultFields":
self._alias = alias
return self
[docs]
class RecordFlamingos2VisitResultFields(GraphQLField):
"""Result for recordFlamingos2Visit mutation."""
[docs]
@classmethod
def visit(cls) -> "VisitFields":
"""The newly added visit record itself."""
return VisitFields("visit")
[docs]
def fields(
self, *subfields: Union[RecordFlamingos2VisitResultGraphQLField, "VisitFields"]
) -> "RecordFlamingos2VisitResultFields":
"""Subfields should come from the RecordFlamingos2VisitResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "RecordFlamingos2VisitResultFields":
self._alias = alias
return self
[docs]
class RecordGmosNorthVisitResultFields(GraphQLField):
"""The result of recording a GmosNorth visit."""
[docs]
@classmethod
def visit(cls) -> "VisitFields":
"""The newly added visit record itself."""
return VisitFields("visit")
[docs]
def fields(
self, *subfields: Union[RecordGmosNorthVisitResultGraphQLField, "VisitFields"]
) -> "RecordGmosNorthVisitResultFields":
"""Subfields should come from the RecordGmosNorthVisitResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "RecordGmosNorthVisitResultFields":
self._alias = alias
return self
[docs]
class RecordGmosSouthVisitResultFields(GraphQLField):
"""The result of recording a GmosSouth visit."""
[docs]
@classmethod
def visit(cls) -> "VisitFields":
"""The newly added visit record itself."""
return VisitFields("visit")
[docs]
def fields(
self, *subfields: Union[RecordGmosSouthVisitResultGraphQLField, "VisitFields"]
) -> "RecordGmosSouthVisitResultFields":
"""Subfields should come from the RecordGmosSouthVisitResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "RecordGmosSouthVisitResultFields":
self._alias = alias
return self
[docs]
class RecordIgrins2VisitResultFields(GraphQLField):
"""Result for recordIgrins2Visit mutation."""
[docs]
@classmethod
def visit(cls) -> "VisitFields":
"""The newly added visit record itself."""
return VisitFields("visit")
[docs]
def fields(
self, *subfields: Union[RecordIgrins2VisitResultGraphQLField, "VisitFields"]
) -> "RecordIgrins2VisitResultFields":
"""Subfields should come from the RecordIgrins2VisitResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "RecordIgrins2VisitResultFields":
self._alias = alias
return self
[docs]
class RecordVisitResultFields(GraphQLField):
"""The result of recording a new Visit."""
[docs]
@classmethod
def visit(cls) -> "VisitFields":
return VisitFields("visit")
[docs]
def fields(
self, *subfields: Union[RecordVisitResultGraphQLField, "VisitFields"]
) -> "RecordVisitResultFields":
"""Subfields should come from the RecordVisitResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "RecordVisitResultFields":
self._alias = alias
return self
[docs]
class RedeemUserInvitationResultFields(GraphQLField):
[docs]
@classmethod
def invitation(cls) -> "UserInvitationFields":
"""The redeemed invitation."""
return UserInvitationFields("invitation")
[docs]
def fields(
self,
*subfields: Union[
RedeemUserInvitationResultGraphQLField, "UserInvitationFields"
],
) -> "RedeemUserInvitationResultFields":
"""Subfields should come from the RedeemUserInvitationResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "RedeemUserInvitationResultFields":
self._alias = alias
return self
[docs]
class RegionFields(GraphQLField):
[docs]
@classmethod
def right_ascension_arc(cls) -> "RightAscensionArcFields":
return RightAscensionArcFields("rightAscensionArc")
[docs]
@classmethod
def declination_arc(cls) -> "DeclinationArcFields":
return DeclinationArcFields("declinationArc")
[docs]
def fields(
self,
*subfields: Union[
RegionGraphQLField, "DeclinationArcFields", "RightAscensionArcFields"
],
) -> "RegionFields":
"""Subfields should come from the RegionFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "RegionFields":
self._alias = alias
return self
[docs]
class ReplaceFlamingos2SequenceResultFields(GraphQLField):
"""The result of a replace sequence mutation, consisting of the newly inserted
sequence."""
[docs]
@classmethod
def sequence(cls) -> "Flamingos2AtomFields":
return Flamingos2AtomFields("sequence")
[docs]
def fields(
self,
*subfields: Union[
ReplaceFlamingos2SequenceResultGraphQLField, "Flamingos2AtomFields"
],
) -> "ReplaceFlamingos2SequenceResultFields":
"""Subfields should come from the ReplaceFlamingos2SequenceResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ReplaceFlamingos2SequenceResultFields":
self._alias = alias
return self
[docs]
class ReplaceGmosNorthSequenceResultFields(GraphQLField):
"""The result of a replace sequence mutation, consisting of the newly inserted
sequence."""
[docs]
@classmethod
def sequence(cls) -> "GmosNorthAtomFields":
return GmosNorthAtomFields("sequence")
[docs]
def fields(
self,
*subfields: Union[
ReplaceGmosNorthSequenceResultGraphQLField, "GmosNorthAtomFields"
],
) -> "ReplaceGmosNorthSequenceResultFields":
"""Subfields should come from the ReplaceGmosNorthSequenceResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ReplaceGmosNorthSequenceResultFields":
self._alias = alias
return self
[docs]
class ReplaceGmosSouthSequenceResultFields(GraphQLField):
"""The result of a replace sequence mutation, consisting of the newly inserted
sequence."""
[docs]
@classmethod
def sequence(cls) -> "GmosSouthAtomFields":
return GmosSouthAtomFields("sequence")
[docs]
def fields(
self,
*subfields: Union[
ReplaceGmosSouthSequenceResultGraphQLField, "GmosSouthAtomFields"
],
) -> "ReplaceGmosSouthSequenceResultFields":
"""Subfields should come from the ReplaceGmosSouthSequenceResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ReplaceGmosSouthSequenceResultFields":
self._alias = alias
return self
[docs]
class ReplaceIgrins2SequenceResultFields(GraphQLField):
"""The result of a replace sequence mutation, consisting of the newly inserted
sequence."""
[docs]
@classmethod
def sequence(cls) -> "Igrins2AtomFields":
return Igrins2AtomFields("sequence")
[docs]
def fields(
self,
*subfields: Union[
ReplaceIgrins2SequenceResultGraphQLField, "Igrins2AtomFields"
],
) -> "ReplaceIgrins2SequenceResultFields":
"""Subfields should come from the ReplaceIgrins2SequenceResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ReplaceIgrins2SequenceResultFields":
self._alias = alias
return self
[docs]
class ResetAcquisitionResultFields(GraphQLField):
"""The result of resetting the acquisition sequence."""
[docs]
@classmethod
def observation(cls) -> "ObservationFields":
"""The observation whose acquisition was reset."""
return ObservationFields("observation")
[docs]
def fields(
self, *subfields: Union[ResetAcquisitionResultGraphQLField, "ObservationFields"]
) -> "ResetAcquisitionResultFields":
"""Subfields should come from the ResetAcquisitionResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ResetAcquisitionResultFields":
self._alias = alias
return self
[docs]
class RevokeUserInvitationResultFields(GraphQLField):
[docs]
@classmethod
def invitation(cls) -> "UserInvitationFields":
"""The revoked invitation."""
return UserInvitationFields("invitation")
[docs]
def fields(
self,
*subfields: Union[
RevokeUserInvitationResultGraphQLField, "UserInvitationFields"
],
) -> "RevokeUserInvitationResultFields":
"""Subfields should come from the RevokeUserInvitationResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "RevokeUserInvitationResultFields":
self._alias = alias
return self
[docs]
class RightAscensionFields(GraphQLField):
hms: "RightAscensionGraphQLField" = RightAscensionGraphQLField("hms")
"Right Ascension (RA) in HH:MM:SS.SSS format"
hours: "RightAscensionGraphQLField" = RightAscensionGraphQLField("hours")
"Right Ascension (RA) in hours"
degrees: "RightAscensionGraphQLField" = RightAscensionGraphQLField("degrees")
"Right Ascension (RA) in degrees"
microseconds: "RightAscensionGraphQLField" = RightAscensionGraphQLField(
"microseconds"
)
"Right Ascension (RA) in µs"
[docs]
def fields(self, *subfields: RightAscensionGraphQLField) -> "RightAscensionFields":
"""Subfields should come from the RightAscensionFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "RightAscensionFields":
self._alias = alias
return self
[docs]
class RightAscensionArcFields(GraphQLField):
type_: "RightAscensionArcGraphQLField" = RightAscensionArcGraphQLField("type")
[docs]
@classmethod
def start(cls) -> "RightAscensionFields":
return RightAscensionFields("start")
[docs]
@classmethod
def end(cls) -> "RightAscensionFields":
return RightAscensionFields("end")
[docs]
def fields(
self, *subfields: Union[RightAscensionArcGraphQLField, "RightAscensionFields"]
) -> "RightAscensionArcFields":
"""Subfields should come from the RightAscensionArcFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "RightAscensionArcFields":
self._alias = alias
return self
[docs]
class ScienceFields(GraphQLField):
"""Science step"""
step_type: "ScienceGraphQLField" = ScienceGraphQLField("stepType")
"Step type"
[docs]
def fields(self, *subfields: ScienceGraphQLField) -> "ScienceFields":
"""Subfields should come from the ScienceFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ScienceFields":
self._alias = alias
return self
[docs]
class ScienceProgramReferenceFields(GraphQLField):
label: "ScienceProgramReferenceGraphQLField" = ScienceProgramReferenceGraphQLField(
"label"
)
type_: "ScienceProgramReferenceGraphQLField" = ScienceProgramReferenceGraphQLField(
"type"
)
science_subtype: "ScienceProgramReferenceGraphQLField" = (
ScienceProgramReferenceGraphQLField("scienceSubtype")
)
semester: "ScienceProgramReferenceGraphQLField" = (
ScienceProgramReferenceGraphQLField("semester")
)
semester_index: "ScienceProgramReferenceGraphQLField" = (
ScienceProgramReferenceGraphQLField("semesterIndex")
)
[docs]
def fields(
self, *subfields: ScienceProgramReferenceGraphQLField
) -> "ScienceProgramReferenceFields":
"""Subfields should come from the ScienceProgramReferenceFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ScienceProgramReferenceFields":
self._alias = alias
return self
[docs]
class ScienceRequirementsFields(GraphQLField):
mode: "ScienceRequirementsGraphQLField" = ScienceRequirementsGraphQLField("mode")
"Science mode"
[docs]
@classmethod
def exposure_time_mode(cls) -> "ExposureTimeModeFields":
"""Requested exposure time mode."""
return ExposureTimeModeFields("exposureTimeMode")
[docs]
@classmethod
def spectroscopy(cls) -> "SpectroscopyScienceRequirementsFields":
"""Spectroscopy requirements, if mode is Spectroscopy, this mode must be set"""
return SpectroscopyScienceRequirementsFields("spectroscopy")
[docs]
@classmethod
def imaging(cls) -> "ImagingScienceRequirementsFields":
"""Imaging requirements, if mode is Imaging, this mode must be set"""
return ImagingScienceRequirementsFields("imaging")
[docs]
def fields(
self,
*subfields: Union[
ScienceRequirementsGraphQLField,
"ExposureTimeModeFields",
"ImagingScienceRequirementsFields",
"SpectroscopyScienceRequirementsFields",
],
) -> "ScienceRequirementsFields":
"""Subfields should come from the ScienceRequirementsFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "ScienceRequirementsFields":
self._alias = alias
return self
[docs]
class SequenceDigestFields(GraphQLField):
observe_class: "SequenceDigestGraphQLField" = SequenceDigestGraphQLField(
"observeClass"
)
"ObserveClass of the whole sequence."
[docs]
@classmethod
def time_estimate(cls) -> "CategorizedTimeFields":
"""Time estimate for the whole sequence."""
return CategorizedTimeFields("timeEstimate")
[docs]
@classmethod
def telescope_configs(cls) -> "TelescopeConfigFields":
"""TelescopeConfig (offset + guiding) for each step."""
return TelescopeConfigFields("telescopeConfigs")
atom_count: "SequenceDigestGraphQLField" = SequenceDigestGraphQLField("atomCount")
"Total count of anticipated atoms, including the 'nextAtom', 'possibleFuture'\nand any remaining atoms not included in 'possibleFuture'."
execution_state: "SequenceDigestGraphQLField" = SequenceDigestGraphQLField(
"executionState"
)
"Execution state for the sequence. Note, acquisition sequences are never\n'COMPLETED'. The execution state for the observation as a whole is that of\nthe science sequence."
[docs]
def fields(
self,
*subfields: Union[
SequenceDigestGraphQLField, "CategorizedTimeFields", "TelescopeConfigFields"
],
) -> "SequenceDigestFields":
"""Subfields should come from the SequenceDigestFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "SequenceDigestFields":
self._alias = alias
return self
[docs]
class SequenceEventFields(GraphQLField):
"""Sequence-level events. As commands are issued to execute a sequence, corresponding events are generated."""
id: "SequenceEventGraphQLField" = SequenceEventGraphQLField("id")
"Event id."
[docs]
@classmethod
def visit(cls) -> "VisitFields":
"""Visit associated with the event."""
return VisitFields("visit")
[docs]
@classmethod
def observation(cls) -> "ObservationFields":
"""Observation whose execution produced this event."""
return ObservationFields("observation")
received: "SequenceEventGraphQLField" = SequenceEventGraphQLField("received")
"Time at which this event was received."
event_type: "SequenceEventGraphQLField" = SequenceEventGraphQLField("eventType")
"Event type."
command: "SequenceEventGraphQLField" = SequenceEventGraphQLField("command")
"Sequence event data."
idempotency_key: "SequenceEventGraphQLField" = SequenceEventGraphQLField(
"idempotencyKey"
)
"Idempotency key, if any. The IdempotencyKey may be provided by clients when\nthe event is created and is used to enable problem-free retry in the case of\nfailure."
[docs]
def fields(
self,
*subfields: Union[
SequenceEventGraphQLField, "ObservationFields", "VisitFields"
],
) -> "SequenceEventFields":
"""Subfields should come from the SequenceEventFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "SequenceEventFields":
self._alias = alias
return self
[docs]
class SetAllocationsResultFields(GraphQLField):
[docs]
@classmethod
def allocations(cls) -> "AllocationFields":
return AllocationFields("allocations")
[docs]
def fields(
self, *subfields: Union[SetAllocationsResultGraphQLField, "AllocationFields"]
) -> "SetAllocationsResultFields":
"""Subfields should come from the SetAllocationsResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "SetAllocationsResultFields":
self._alias = alias
return self
[docs]
class SetGuideTargetNameResultFields(GraphQLField):
"""The result of setting the guide target name for an observation."""
[docs]
@classmethod
def observation(cls) -> "ObservationFields":
return ObservationFields("observation")
[docs]
def fields(
self,
*subfields: Union[SetGuideTargetNameResultGraphQLField, "ObservationFields"],
) -> "SetGuideTargetNameResultFields":
"""Subfields should come from the SetGuideTargetNameResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "SetGuideTargetNameResultFields":
self._alias = alias
return self
[docs]
class SetProgramReferenceResultFields(GraphQLField):
[docs]
@classmethod
def reference(cls) -> "ProgramReferenceInterface":
"""The resulting program reference, if any."""
return ProgramReferenceInterface("reference")
[docs]
def fields(
self,
*subfields: Union[
SetProgramReferenceResultGraphQLField, "ProgramReferenceInterface"
],
) -> "SetProgramReferenceResultFields":
"""Subfields should come from the SetProgramReferenceResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "SetProgramReferenceResultFields":
self._alias = alias
return self
[docs]
class SetProposalStatusResultFields(GraphQLField):
"""The result of setting the proposal status."""
[docs]
@classmethod
def program(cls) -> "ProgramFields":
"""The program on which the proposal status was set. Returning the program allows checking
the proposal reference, program reference and other values that can be affected by changing
the proposal status."""
return ProgramFields("program")
[docs]
def fields(
self, *subfields: Union[SetProposalStatusResultGraphQLField, "ProgramFields"]
) -> "SetProposalStatusResultFields":
"""Subfields should come from the SetProposalStatusResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "SetProposalStatusResultFields":
self._alias = alias
return self
[docs]
class SetupTimeFields(GraphQLField):
[docs]
@classmethod
def full(cls) -> "TimeSpanFields":
"""Full setup time estimate, including slew, configuration and target acquisition"""
return TimeSpanFields("full")
[docs]
@classmethod
def reacquisition(cls) -> "TimeSpanFields":
"""A reduced setup time contemplating reacquiring a previously acquired target"""
return TimeSpanFields("reacquisition")
[docs]
def fields(
self, *subfields: Union[SetupTimeGraphQLField, "TimeSpanFields"]
) -> "SetupTimeFields":
"""Subfields should come from the SetupTimeFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "SetupTimeFields":
self._alias = alias
return self
[docs]
class SiderealFields(GraphQLField):
[docs]
@classmethod
def ra(cls) -> "RightAscensionFields":
"""Right ascension at epoch"""
return RightAscensionFields("ra")
[docs]
@classmethod
def dec(cls) -> "DeclinationFields":
"""Declination at epoch"""
return DeclinationFields("dec")
epoch: "SiderealGraphQLField" = SiderealGraphQLField("epoch")
"Epoch, time of base observation"
[docs]
@classmethod
def proper_motion(cls) -> "ProperMotionFields":
"""Proper motion per year in right ascension and declination"""
return ProperMotionFields("properMotion")
[docs]
@classmethod
def radial_velocity(cls) -> "RadialVelocityFields":
"""Radial velocity"""
return RadialVelocityFields("radialVelocity")
[docs]
@classmethod
def parallax(cls) -> "ParallaxFields":
"""Parallax"""
return ParallaxFields("parallax")
[docs]
@classmethod
def catalog_info(cls) -> "CatalogInfoFields":
"""Catalog info, if any, describing from where the information in this target was obtained"""
return CatalogInfoFields("catalogInfo")
[docs]
def fields(
self,
*subfields: Union[
SiderealGraphQLField,
"CatalogInfoFields",
"DeclinationFields",
"ParallaxFields",
"ProperMotionFields",
"RadialVelocityFields",
"RightAscensionFields",
],
) -> "SiderealFields":
"""Subfields should come from the SiderealFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "SiderealFields":
self._alias = alias
return self
[docs]
class SignalToNoiseAtFields(GraphQLField):
"""Calculated signal to noise at a specific wavelength"""
single: "SignalToNoiseAtGraphQLField" = SignalToNoiseAtGraphQLField("single")
"Single exposure signal to noise"
total: "SignalToNoiseAtGraphQLField" = SignalToNoiseAtGraphQLField("total")
"Total exposure signal to noise"
[docs]
@classmethod
def wavelength(cls) -> "WavelengthFields":
"""Wavelength sn was calculated at"""
return WavelengthFields("wavelength")
[docs]
def fields(
self, *subfields: Union[SignalToNoiseAtGraphQLField, "WavelengthFields"]
) -> "SignalToNoiseAtFields":
"""Subfields should come from the SignalToNoiseAtFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "SignalToNoiseAtFields":
self._alias = alias
return self
[docs]
class SignalToNoiseExposureTimeModeFields(GraphQLField):
"""Signal to noise exposure time mode"""
value: "SignalToNoiseExposureTimeModeGraphQLField" = (
SignalToNoiseExposureTimeModeGraphQLField("value")
)
"Signal/Noise value"
[docs]
@classmethod
def at(cls) -> "WavelengthFields":
"""Signal/Noise wavelength"""
return WavelengthFields("at")
[docs]
def fields(
self,
*subfields: Union[
SignalToNoiseExposureTimeModeGraphQLField, "WavelengthFields"
],
) -> "SignalToNoiseExposureTimeModeFields":
"""Subfields should come from the SignalToNoiseExposureTimeModeFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "SignalToNoiseExposureTimeModeFields":
self._alias = alias
return self
[docs]
class SiteCoordinateLimitsFields(GraphQLField):
"""Coordinate limits per site."""
[docs]
@classmethod
def north(cls) -> "CoordinateLimitsFields":
"""Gemini North coordinate limits."""
return CoordinateLimitsFields("north")
[docs]
@classmethod
def south(cls) -> "CoordinateLimitsFields":
"""Gemini South coordinate limits."""
return CoordinateLimitsFields("south")
[docs]
def fields(
self,
*subfields: Union[SiteCoordinateLimitsGraphQLField, "CoordinateLimitsFields"],
) -> "SiteCoordinateLimitsFields":
"""Subfields should come from the SiteCoordinateLimitsFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "SiteCoordinateLimitsFields":
self._alias = alias
return self
[docs]
class SlewEventFields(GraphQLField):
"""Slew events."""
id: "SlewEventGraphQLField" = SlewEventGraphQLField("id")
"Event id."
[docs]
@classmethod
def visit(cls) -> "VisitFields":
"""Visit associated with the event."""
return VisitFields("visit")
[docs]
@classmethod
def observation(cls) -> "ObservationFields":
"""Observation whose execution produced this event."""
return ObservationFields("observation")
received: "SlewEventGraphQLField" = SlewEventGraphQLField("received")
"Time at which this event was received."
event_type: "SlewEventGraphQLField" = SlewEventGraphQLField("eventType")
"Event type."
slew_stage: "SlewEventGraphQLField" = SlewEventGraphQLField("slewStage")
"Slew event data."
idempotency_key: "SlewEventGraphQLField" = SlewEventGraphQLField("idempotencyKey")
"Idempotency key, if any. The IdempotencyKey may be provided by clients when\nthe event is created and is used to enable problem-free retry in the case of\nfailure."
[docs]
def fields(
self,
*subfields: Union[SlewEventGraphQLField, "ObservationFields", "VisitFields"],
) -> "SlewEventFields":
"""Subfields should come from the SlewEventFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "SlewEventFields":
self._alias = alias
return self
[docs]
class SmartGcalFields(GraphQLField):
"""SmartGcal step configuration."""
smart_gcal_type: "SmartGcalGraphQLField" = SmartGcalGraphQLField("smartGcalType")
step_type: "SmartGcalGraphQLField" = SmartGcalGraphQLField("stepType")
"Step type"
[docs]
def fields(self, *subfields: SmartGcalGraphQLField) -> "SmartGcalFields":
"""Subfields should come from the SmartGcalFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "SmartGcalFields":
self._alias = alias
return self
[docs]
class SourceProfileFields(GraphQLField):
"""Source profile, exactly one of the fields will be defined"""
[docs]
@classmethod
def point(cls) -> "SpectralDefinitionIntegratedFields":
"""point source, integrated units"""
return SpectralDefinitionIntegratedFields("point")
[docs]
@classmethod
def gaussian(cls) -> "GaussianSourceFields":
"""gaussian source, integrated units"""
return GaussianSourceFields("gaussian")
[docs]
def fields(
self,
*subfields: Union[
SourceProfileGraphQLField,
"GaussianSourceFields",
"SpectralDefinitionIntegratedFields",
"SpectralDefinitionSurfaceFields",
],
) -> "SourceProfileFields":
"""Subfields should come from the SourceProfileFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "SourceProfileFields":
self._alias = alias
return self
[docs]
class SpectralDefinitionIntegratedFields(GraphQLField):
"""Spectral definition integrated. Exactly one of the fields will be defined."""
[docs]
@classmethod
def band_normalized(cls) -> "BandNormalizedIntegratedFields":
"""Band normalized spectral definition"""
return BandNormalizedIntegratedFields("bandNormalized")
[docs]
@classmethod
def emission_lines(cls) -> "EmissionLinesIntegratedFields":
"""Emission lines spectral definition"""
return EmissionLinesIntegratedFields("emissionLines")
[docs]
def fields(
self,
*subfields: Union[
SpectralDefinitionIntegratedGraphQLField,
"BandNormalizedIntegratedFields",
"EmissionLinesIntegratedFields",
],
) -> "SpectralDefinitionIntegratedFields":
"""Subfields should come from the SpectralDefinitionIntegratedFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "SpectralDefinitionIntegratedFields":
self._alias = alias
return self
[docs]
class SpectralDefinitionSurfaceFields(GraphQLField):
"""Spectral definition surface. Exactly one of the fields will be defined."""
[docs]
@classmethod
def band_normalized(cls) -> "BandNormalizedSurfaceFields":
"""Band normalized spectral definition"""
return BandNormalizedSurfaceFields("bandNormalized")
[docs]
@classmethod
def emission_lines(cls) -> "EmissionLinesSurfaceFields":
"""Emission lines spectral definition"""
return EmissionLinesSurfaceFields("emissionLines")
[docs]
def fields(
self,
*subfields: Union[
SpectralDefinitionSurfaceGraphQLField,
"BandNormalizedSurfaceFields",
"EmissionLinesSurfaceFields",
],
) -> "SpectralDefinitionSurfaceFields":
"""Subfields should come from the SpectralDefinitionSurfaceFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "SpectralDefinitionSurfaceFields":
self._alias = alias
return self
[docs]
class SpectroscopyConfigOptionFields(GraphQLField):
"""Describes an instrument configuration option for spectroscopy."""
name: "SpectroscopyConfigOptionGraphQLField" = SpectroscopyConfigOptionGraphQLField(
"name"
)
instrument: "SpectroscopyConfigOptionGraphQLField" = (
SpectroscopyConfigOptionGraphQLField("instrument")
)
focal_plane: "SpectroscopyConfigOptionGraphQLField" = (
SpectroscopyConfigOptionGraphQLField("focalPlane")
)
fpu_label: "SpectroscopyConfigOptionGraphQLField" = (
SpectroscopyConfigOptionGraphQLField("fpuLabel")
)
[docs]
@classmethod
def slit_width(cls) -> "AngleFields":
return AngleFields("slitWidth")
[docs]
@classmethod
def slit_length(cls) -> "AngleFields":
return AngleFields("slitLength")
disperser_label: "SpectroscopyConfigOptionGraphQLField" = (
SpectroscopyConfigOptionGraphQLField("disperserLabel")
)
filter_label: "SpectroscopyConfigOptionGraphQLField" = (
SpectroscopyConfigOptionGraphQLField("filterLabel")
)
[docs]
@classmethod
def wavelength_min(cls) -> "WavelengthFields":
return WavelengthFields("wavelengthMin")
[docs]
@classmethod
def wavelength_max(cls) -> "WavelengthFields":
return WavelengthFields("wavelengthMax")
[docs]
@classmethod
def wavelength_optimal(cls) -> "WavelengthFields":
return WavelengthFields("wavelengthOptimal")
[docs]
@classmethod
def wavelength_coverage(cls) -> "WavelengthFields":
return WavelengthFields("wavelengthCoverage")
resolution: "SpectroscopyConfigOptionGraphQLField" = (
SpectroscopyConfigOptionGraphQLField("resolution")
)
adaptive_optics: "SpectroscopyConfigOptionGraphQLField" = (
SpectroscopyConfigOptionGraphQLField("adaptiveOptics")
)
capability: "SpectroscopyConfigOptionGraphQLField" = (
SpectroscopyConfigOptionGraphQLField("capability")
)
"A special capability (if any) that the configuration may have."
site: "SpectroscopyConfigOptionGraphQLField" = SpectroscopyConfigOptionGraphQLField(
"site"
)
[docs]
@classmethod
def flamingos_2(cls) -> "SpectroscopyConfigOptionFlamingos2Fields":
"""For Flamingos2 options, the Flamingos 2configuration. Null for other
instruments."""
return SpectroscopyConfigOptionFlamingos2Fields("flamingos2")
[docs]
@classmethod
def ghost(cls) -> "SpectroscopyConfigOptionGhostFields":
"""For GHOST options, the GHOST configuration. Null for other instruments."""
return SpectroscopyConfigOptionGhostFields("ghost")
[docs]
@classmethod
def gmos_north(cls) -> "SpectroscopyConfigOptionGmosNorthFields":
"""For GMOS North options, the GMOS North configuration. Null for other
instruments."""
return SpectroscopyConfigOptionGmosNorthFields("gmosNorth")
[docs]
@classmethod
def gmos_south(cls) -> "SpectroscopyConfigOptionGmosSouthFields":
"""For GMOS South options, the GMOS South configuration. Null for other
instruments."""
return SpectroscopyConfigOptionGmosSouthFields("gmosSouth")
[docs]
@classmethod
def gnirs(cls) -> "SpectroscopyConfigOptionGnirsFields":
"""For GNIRS options, the GNIRS configuration. Null for other instruments."""
return SpectroscopyConfigOptionGnirsFields("gnirs")
[docs]
def fields(
self,
*subfields: Union[
SpectroscopyConfigOptionGraphQLField,
"AngleFields",
"SpectroscopyConfigOptionFlamingos2Fields",
"SpectroscopyConfigOptionGhostFields",
"SpectroscopyConfigOptionGmosNorthFields",
"SpectroscopyConfigOptionGmosSouthFields",
"SpectroscopyConfigOptionGnirsFields",
"WavelengthFields",
],
) -> "SpectroscopyConfigOptionFields":
"""Subfields should come from the SpectroscopyConfigOptionFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "SpectroscopyConfigOptionFields":
self._alias = alias
return self
[docs]
class SpectroscopyConfigOptionFlamingos2Fields(GraphQLField):
fpu: "SpectroscopyConfigOptionFlamingos2GraphQLField" = (
SpectroscopyConfigOptionFlamingos2GraphQLField("fpu")
)
disperser: "SpectroscopyConfigOptionFlamingos2GraphQLField" = (
SpectroscopyConfigOptionFlamingos2GraphQLField("disperser")
)
filter_: "SpectroscopyConfigOptionFlamingos2GraphQLField" = (
SpectroscopyConfigOptionFlamingos2GraphQLField("filter")
)
[docs]
def fields(
self, *subfields: SpectroscopyConfigOptionFlamingos2GraphQLField
) -> "SpectroscopyConfigOptionFlamingos2Fields":
"""Subfields should come from the SpectroscopyConfigOptionFlamingos2Fields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "SpectroscopyConfigOptionFlamingos2Fields":
self._alias = alias
return self
[docs]
class SpectroscopyConfigOptionGhostFields(GraphQLField):
resolution_mode: "SpectroscopyConfigOptionGhostGraphQLField" = (
SpectroscopyConfigOptionGhostGraphQLField("resolutionMode")
)
binning: "SpectroscopyConfigOptionGhostGraphQLField" = (
SpectroscopyConfigOptionGhostGraphQLField("binning")
)
[docs]
def fields(
self, *subfields: SpectroscopyConfigOptionGhostGraphQLField
) -> "SpectroscopyConfigOptionGhostFields":
"""Subfields should come from the SpectroscopyConfigOptionGhostFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "SpectroscopyConfigOptionGhostFields":
self._alias = alias
return self
[docs]
class SpectroscopyConfigOptionGmosNorthFields(GraphQLField):
fpu: "SpectroscopyConfigOptionGmosNorthGraphQLField" = (
SpectroscopyConfigOptionGmosNorthGraphQLField("fpu")
)
grating: "SpectroscopyConfigOptionGmosNorthGraphQLField" = (
SpectroscopyConfigOptionGmosNorthGraphQLField("grating")
)
filter_: "SpectroscopyConfigOptionGmosNorthGraphQLField" = (
SpectroscopyConfigOptionGmosNorthGraphQLField("filter")
)
[docs]
def fields(
self, *subfields: SpectroscopyConfigOptionGmosNorthGraphQLField
) -> "SpectroscopyConfigOptionGmosNorthFields":
"""Subfields should come from the SpectroscopyConfigOptionGmosNorthFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "SpectroscopyConfigOptionGmosNorthFields":
self._alias = alias
return self
[docs]
class SpectroscopyConfigOptionGmosSouthFields(GraphQLField):
fpu: "SpectroscopyConfigOptionGmosSouthGraphQLField" = (
SpectroscopyConfigOptionGmosSouthGraphQLField("fpu")
)
grating: "SpectroscopyConfigOptionGmosSouthGraphQLField" = (
SpectroscopyConfigOptionGmosSouthGraphQLField("grating")
)
filter_: "SpectroscopyConfigOptionGmosSouthGraphQLField" = (
SpectroscopyConfigOptionGmosSouthGraphQLField("filter")
)
[docs]
def fields(
self, *subfields: SpectroscopyConfigOptionGmosSouthGraphQLField
) -> "SpectroscopyConfigOptionGmosSouthFields":
"""Subfields should come from the SpectroscopyConfigOptionGmosSouthFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "SpectroscopyConfigOptionGmosSouthFields":
self._alias = alias
return self
[docs]
class SpectroscopyConfigOptionGnirsFields(GraphQLField):
grating: "SpectroscopyConfigOptionGnirsGraphQLField" = (
SpectroscopyConfigOptionGnirsGraphQLField("grating")
)
filter_: "SpectroscopyConfigOptionGnirsGraphQLField" = (
SpectroscopyConfigOptionGnirsGraphQLField("filter")
)
fpu: "SpectroscopyConfigOptionGnirsGraphQLField" = (
SpectroscopyConfigOptionGnirsGraphQLField("fpu")
)
prism: "SpectroscopyConfigOptionGnirsGraphQLField" = (
SpectroscopyConfigOptionGnirsGraphQLField("prism")
)
camera: "SpectroscopyConfigOptionGnirsGraphQLField" = (
SpectroscopyConfigOptionGnirsGraphQLField("camera")
)
[docs]
def fields(
self, *subfields: SpectroscopyConfigOptionGnirsGraphQLField
) -> "SpectroscopyConfigOptionGnirsFields":
"""Subfields should come from the SpectroscopyConfigOptionGnirsFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "SpectroscopyConfigOptionGnirsFields":
self._alias = alias
return self
[docs]
class SpectroscopyScienceRequirementsFields(GraphQLField):
[docs]
@classmethod
def wavelength(cls) -> "WavelengthFields":
"""Requested central wavelength"""
return WavelengthFields("wavelength")
resolution: "SpectroscopyScienceRequirementsGraphQLField" = (
SpectroscopyScienceRequirementsGraphQLField("resolution")
)
"Requested resolution"
[docs]
@classmethod
def wavelength_coverage(cls) -> "WavelengthFields":
"""Wavelength range"""
return WavelengthFields("wavelengthCoverage")
focal_plane: "SpectroscopyScienceRequirementsGraphQLField" = (
SpectroscopyScienceRequirementsGraphQLField("focalPlane")
)
"Focal plane choice"
[docs]
@classmethod
def focal_plane_angle(cls) -> "AngleFields":
"""Focal plane angle"""
return AngleFields("focalPlaneAngle")
capability: "SpectroscopyScienceRequirementsGraphQLField" = (
SpectroscopyScienceRequirementsGraphQLField("capability")
)
"Spectroscopy Capabilities"
[docs]
def fields(
self,
*subfields: Union[
SpectroscopyScienceRequirementsGraphQLField,
"AngleFields",
"WavelengthFields",
],
) -> "SpectroscopyScienceRequirementsFields":
"""Subfields should come from the SpectroscopyScienceRequirementsFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "SpectroscopyScienceRequirementsFields":
self._alias = alias
return self
[docs]
class SpiralTelescopeConfigGeneratorFields(GraphQLField):
[docs]
@classmethod
def size(cls) -> "AngleFields":
return AngleFields("size")
[docs]
@classmethod
def center(cls) -> "OffsetFields":
return OffsetFields("center")
seed: "SpiralTelescopeConfigGeneratorGraphQLField" = (
SpiralTelescopeConfigGeneratorGraphQLField("seed")
)
[docs]
def fields(
self,
*subfields: Union[
SpiralTelescopeConfigGeneratorGraphQLField, "AngleFields", "OffsetFields"
],
) -> "SpiralTelescopeConfigGeneratorFields":
"""Subfields should come from the SpiralTelescopeConfigGeneratorFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "SpiralTelescopeConfigGeneratorFields":
self._alias = alias
return self
[docs]
class StepConfigInterface(GraphQLField):
"""Step (bias, dark, gcal, science, etc.)"""
step_type: "StepConfigGraphQLField" = StepConfigGraphQLField("stepType")
"Step type"
[docs]
def fields(self, *subfields: StepConfigGraphQLField) -> "StepConfigInterface":
"""Subfields should come from the StepConfigInterface class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "StepConfigInterface":
self._alias = alias
return self
[docs]
def on(self, type_name: str, *subfields: GraphQLField) -> "StepConfigInterface":
self._inline_fragments[type_name] = subfields
return self
[docs]
class StepEstimateFields(GraphQLField):
"""Time estimate for an individual step, including configuration changes and
dataset production."""
[docs]
@classmethod
def config_change(cls) -> "AllConfigChangeEstimatesFields":
"""Configuration changes required before the step is executed. This will
obviously depend not only on the step configuration but also the previous
step configuration."""
return AllConfigChangeEstimatesFields("configChange")
[docs]
@classmethod
def detector(cls) -> "AllDetectorEstimatesFields":
"""Time for producing the datasets for this step."""
return AllDetectorEstimatesFields("detector")
[docs]
@classmethod
def total(cls) -> "TimeSpanFields":
"""Total time estimate for the step."""
return TimeSpanFields("total")
[docs]
def fields(
self,
*subfields: Union[
StepEstimateGraphQLField,
"AllConfigChangeEstimatesFields",
"AllDetectorEstimatesFields",
"TimeSpanFields",
],
) -> "StepEstimateFields":
"""Subfields should come from the StepEstimateFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "StepEstimateFields":
self._alias = alias
return self
[docs]
class StepEventFields(GraphQLField):
"""Step-level events. The execution of a single step will generate multiple events."""
id: "StepEventGraphQLField" = StepEventGraphQLField("id")
"Event id."
[docs]
@classmethod
def visit(cls) -> "VisitFields":
"""Visit associated with the event."""
return VisitFields("visit")
[docs]
@classmethod
def observation(cls) -> "ObservationFields":
"""Observation whose execution produced this event."""
return ObservationFields("observation")
received: "StepEventGraphQLField" = StepEventGraphQLField("received")
"Time at which this event was received."
event_type: "StepEventGraphQLField" = StepEventGraphQLField("eventType")
"Event type."
[docs]
@classmethod
def atom(cls) -> "AtomRecordFields":
"""Atom associated with this event."""
return AtomRecordFields("atom")
[docs]
@classmethod
def step(cls) -> "StepRecordFields":
"""Step associated with this event."""
return StepRecordFields("step")
step_stage: "StepEventGraphQLField" = StepEventGraphQLField("stepStage")
"Step execution stage."
idempotency_key: "StepEventGraphQLField" = StepEventGraphQLField("idempotencyKey")
"Idempotency key, if any. The IdempotencyKey may be provided by clients when\nthe event is created and is used to enable problem-free retry in the case of\nfailure."
[docs]
def fields(
self,
*subfields: Union[
StepEventGraphQLField,
"AtomRecordFields",
"ObservationFields",
"StepRecordFields",
"VisitFields",
],
) -> "StepEventFields":
"""Subfields should come from the StepEventFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "StepEventFields":
self._alias = alias
return self
[docs]
class StepRecordFields(GraphQLField):
"""A step as recorded by Observe. There will be one instrument configuration per
instrument, all but one of which will be null."""
id: "StepRecordGraphQLField" = StepRecordGraphQLField("id")
"Step ID."
index: "StepRecordGraphQLField" = StepRecordGraphQLField("index")
"Step Index, relative to other step records in the observation."
instrument: "StepRecordGraphQLField" = StepRecordGraphQLField("instrument")
"Instrument associated with the step. This will indicate which of the\ninstrument-specific dynamic fields (e.g., `gmosNorth: GmosNorthDynamic`) is\ndefined."
[docs]
@classmethod
def atom(cls) -> "AtomRecordFields":
"""The atom in which the step was executed."""
return AtomRecordFields("atom")
execution_state: "StepRecordGraphQLField" = StepRecordGraphQLField("executionState")
"The execution state of this step, according to events received (if any) from\nObserve."
[docs]
@classmethod
def interval(cls) -> "TimestampIntervalFields":
"""Time interval during which this step executed. This measures the range of
time from the first event to the last, whether or not the step ever
actually completed."""
return TimestampIntervalFields("interval")
[docs]
@classmethod
def step_config(cls) -> "StepConfigInterface":
"""The step configuration, apart from instrument details found in the
instrument-specific 'StepRecord' implementation."""
return StepConfigInterface("stepConfig")
[docs]
@classmethod
def telescope_config(cls) -> "TelescopeConfigFields":
"""The telescope configuration for this step."""
return TelescopeConfigFields("telescopeConfig")
observe_class: "StepRecordGraphQLField" = StepRecordGraphQLField("observeClass")
"The observe class of this step."
[docs]
@classmethod
def estimate(cls) -> "TimeSpanFields":
"""Original time estimate for executing this step."""
return TimeSpanFields("estimate")
qa_state: "StepRecordGraphQLField" = StepRecordGraphQLField("qaState")
"QA state based on a combination of dataset QA states. The worst QA state is\ntaken as the overall step QA state. For example, one FAIL dataset will\nresult in the step having a FAIL QA state. Unset QA states are ignored, but\nif none are set the result will be null."
[docs]
@classmethod
def datasets(
cls, *, offset: Optional[Any] = None, limit: Optional[Any] = None
) -> "DatasetSelectResultFields":
"""Datasets associated with this step."""
arguments: dict[str, dict[str, Any]] = {
"OFFSET": {"type": "DatasetId", "value": offset},
"LIMIT": {"type": "NonNegInt", "value": limit},
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return DatasetSelectResultFields("datasets", arguments=cleared_arguments)
[docs]
@classmethod
def events(
cls, *, offset: Optional[Any] = None, limit: Optional[Any] = None
) -> "ExecutionEventSelectResultFields":
"""Execution events associated with this step."""
arguments: dict[str, dict[str, Any]] = {
"OFFSET": {"type": "ExecutionEventId", "value": offset},
"LIMIT": {"type": "NonNegInt", "value": limit},
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return ExecutionEventSelectResultFields("events", arguments=cleared_arguments)
[docs]
@classmethod
def flamingos_2(cls) -> "Flamingos2DynamicFields":
"""Flamingos 2 instrument configuration for this step, if any. This will be null
unless the `instrument` discriminator is "FLAMINGOS2"."""
return Flamingos2DynamicFields("flamingos2")
[docs]
@classmethod
def ghost(cls) -> "GhostDynamicFields":
"""Ghost instrument configuration for this step, if any. This will be null unless
the `instrument` discriminator is "GHOST"."""
return GhostDynamicFields("ghost")
[docs]
@classmethod
def gmos_north(cls) -> "GmosNorthDynamicFields":
"""GMOS North instrument configuration for this step, if any. This will be null
unless the `instrument` discriminator is "GMOS_NORTH"."""
return GmosNorthDynamicFields("gmosNorth")
[docs]
@classmethod
def gmos_south(cls) -> "GmosSouthDynamicFields":
"""GMOS South instrument configuration for this step, if any. This will be null
unless the `instrument` discriminator is "GMOS_SOUTH"."""
return GmosSouthDynamicFields("gmosSouth")
[docs]
@classmethod
def igrins_2(cls) -> "Igrins2DynamicFields":
"""IGRINS-2 instrument configuration for this step, if any. This will be null
unless the `instrument` discriminator is "IGRINS2"."""
return Igrins2DynamicFields("igrins2")
[docs]
def fields(
self,
*subfields: Union[
StepRecordGraphQLField,
"AtomRecordFields",
"DatasetSelectResultFields",
"ExecutionEventSelectResultFields",
"Flamingos2DynamicFields",
"GhostDynamicFields",
"GmosNorthDynamicFields",
"GmosSouthDynamicFields",
"Igrins2DynamicFields",
"StepConfigInterface",
"TelescopeConfigFields",
"TimeSpanFields",
"TimestampIntervalFields",
],
) -> "StepRecordFields":
"""Subfields should come from the StepRecordFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "StepRecordFields":
self._alias = alias
return self
[docs]
class StepRecordSelectResultFields(GraphQLField):
"""StepRecord query results, limited to a maximum of 1000 entries."""
[docs]
@classmethod
def matches(cls) -> "StepRecordFields":
"""Matching step records up to the return size limit of 1000."""
return StepRecordFields("matches")
has_more: "StepRecordSelectResultGraphQLField" = StepRecordSelectResultGraphQLField(
"hasMore"
)
"`true` when there were additional matches that were not returned."
[docs]
def fields(
self, *subfields: Union[StepRecordSelectResultGraphQLField, "StepRecordFields"]
) -> "StepRecordSelectResultFields":
"""Subfields should come from the StepRecordSelectResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "StepRecordSelectResultFields":
self._alias = alias
return self
[docs]
class SystemProgramReferenceFields(GraphQLField):
label: "SystemProgramReferenceGraphQLField" = SystemProgramReferenceGraphQLField(
"label"
)
type_: "SystemProgramReferenceGraphQLField" = SystemProgramReferenceGraphQLField(
"type"
)
[docs]
def fields(
self, *subfields: SystemProgramReferenceGraphQLField
) -> "SystemProgramReferenceFields":
"""Subfields should come from the SystemProgramReferenceFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "SystemProgramReferenceFields":
self._alias = alias
return self
[docs]
class SystemVerificationFields(GraphQLField):
"""Proposal properties for System Verification CallForProposals."""
science_subtype: "SystemVerificationGraphQLField" = SystemVerificationGraphQLField(
"scienceSubtype"
)
"The science type of this Call for Proposals."
to_o_activation: "SystemVerificationGraphQLField" = SystemVerificationGraphQLField(
"toOActivation"
)
"Whether (and how) the observations in this proposal are available for Target\nof Opportunity triggering."
min_percent_time: "SystemVerificationGraphQLField" = SystemVerificationGraphQLField(
"minPercentTime"
)
"Minimum percentage of observing time required to consider this proposal\nsuccessful."
[docs]
def fields(
self, *subfields: SystemVerificationGraphQLField
) -> "SystemVerificationFields":
"""Subfields should come from the SystemVerificationFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "SystemVerificationFields":
self._alias = alias
return self
[docs]
class TargetFields(GraphQLField):
"""Target description"""
id: "TargetGraphQLField" = TargetGraphQLField("id")
"Target ID"
existence: "TargetGraphQLField" = TargetGraphQLField("existence")
"DELETED or PRESENT"
[docs]
@classmethod
def program(cls, include_deleted: bool) -> "ProgramFields":
"""Program that contains this target"""
arguments: dict[str, dict[str, Any]] = {
"includeDeleted": {"type": "Boolean!", "value": include_deleted}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return ProgramFields("program", arguments=cleared_arguments)
name: "TargetGraphQLField" = TargetGraphQLField("name")
"Target name."
disposition: "TargetGraphQLField" = TargetGraphQLField("disposition")
"Target disposition. See TargetDisposition for more information."
calibration_role: "TargetGraphQLField" = TargetGraphQLField("calibrationRole")
"calibration role"
[docs]
@classmethod
def source_profile(cls) -> "SourceProfileFields":
"""source profile"""
return SourceProfileFields("sourceProfile")
[docs]
@classmethod
def sidereal(cls) -> "SiderealFields":
"""Sidereal tracking information, if this is a sidereal target"""
return SiderealFields("sidereal")
[docs]
@classmethod
def nonsidereal(cls) -> "NonsiderealFields":
"""Nonsidereal tracking information, if this is a nonsidereal target"""
return NonsiderealFields("nonsidereal")
[docs]
@classmethod
def opportunity(cls) -> "OpportunityFields":
"""Target of opportunity range information, if this a TOO target"""
return OpportunityFields("opportunity")
[docs]
def fields(
self,
*subfields: Union[
TargetGraphQLField,
"NonsiderealFields",
"OpportunityFields",
"ProgramFields",
"SiderealFields",
"SourceProfileFields",
],
) -> "TargetFields":
"""Subfields should come from the TargetFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "TargetFields":
self._alias = alias
return self
[docs]
class TargetEnvironmentFields(GraphQLField):
[docs]
@classmethod
def asterism(cls, include_deleted: bool) -> "TargetFields":
"""All the observation's science targets, if any"""
arguments: dict[str, dict[str, Any]] = {
"includeDeleted": {"type": "Boolean!", "value": include_deleted}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return TargetFields("asterism", arguments=cleared_arguments)
[docs]
@classmethod
def first_science_target(cls, include_deleted: bool) -> "TargetFields":
"""First, perhaps only, science target in the asterism"""
arguments: dict[str, dict[str, Any]] = {
"includeDeleted": {"type": "Boolean!", "value": include_deleted}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return TargetFields("firstScienceTarget", arguments=cleared_arguments)
[docs]
@classmethod
def base_position(cls, observation_time: Any) -> "CoordinatesFields":
"""Explicit (if defined) or computed base position at the specified time, if known."""
arguments: dict[str, dict[str, Any]] = {
"observationTime": {"type": "Timestamp!", "value": observation_time}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return CoordinatesFields("basePosition", arguments=cleared_arguments)
[docs]
@classmethod
def guide_environments(cls, observation_time: Any) -> "GuideEnvironmentFields":
"""The guide star(s) and related information"""
arguments: dict[str, dict[str, Any]] = {
"observationTime": {"type": "Timestamp!", "value": observation_time}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return GuideEnvironmentFields("guideEnvironments", arguments=cleared_arguments)
[docs]
@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."""
return GuideEnvironmentFields("guideEnvironment")
[docs]
@classmethod
def guide_availability(
cls, start: Any, end: Any
) -> "GuideAvailabilityPeriodFields":
"""Availability of guide stars during a specified time range.
There can be multiple `GuideAvailabilityPeriod`s returned if availability changes over the time
range. In this case, the `end` of one period will be the same as the `start` of the next period."""
arguments: dict[str, dict[str, Any]] = {
"start": {"type": "Timestamp!", "value": start},
"end": {"type": "Timestamp!", "value": end},
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return GuideAvailabilityPeriodFields(
"guideAvailability", arguments=cleared_arguments
)
[docs]
@classmethod
def explicit_base(cls) -> "CoordinatesFields":
"""When set, overrides the default base position of the target group"""
return CoordinatesFields("explicitBase")
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."
use_blind_offset: "TargetEnvironmentGraphQLField" = TargetEnvironmentGraphQLField(
"useBlindOffset"
)
"Whether blind offset is enabled for this observation"
[docs]
@classmethod
def blind_offset_target(cls) -> "TargetFields":
"""The target used for blind offset acquisition, if any"""
return TargetFields("blindOffsetTarget")
blind_offset_type: "TargetEnvironmentGraphQLField" = TargetEnvironmentGraphQLField(
"blindOffsetType"
)
"The type of blind offset (automatic or manual) if a blind offset exists."
[docs]
def fields(
self,
*subfields: Union[
TargetEnvironmentGraphQLField,
"CoordinatesFields",
"GuideAvailabilityPeriodFields",
"GuideEnvironmentFields",
"TargetFields",
],
) -> "TargetEnvironmentFields":
"""Subfields should come from the TargetEnvironmentFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "TargetEnvironmentFields":
self._alias = alias
return self
[docs]
class TargetGroupFields(GraphQLField):
[docs]
@classmethod
def observations(
cls,
include_deleted: bool,
*,
offset: Optional[Any] = None,
limit: Optional[Any] = None,
) -> "ObservationSelectResultFields":
"""Observations associated with the common value"""
arguments: dict[str, dict[str, Any]] = {
"includeDeleted": {"type": "Boolean!", "value": include_deleted},
"OFFSET": {"type": "ObservationId", "value": offset},
"LIMIT": {"type": "NonNegInt", "value": limit},
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return ObservationSelectResultFields(
"observations", arguments=cleared_arguments
)
[docs]
@classmethod
def target(cls) -> "TargetFields":
"""Commonly held value across the observations"""
return TargetFields("target")
[docs]
@classmethod
def program(cls) -> "ProgramFields":
"""Link back to program."""
return ProgramFields("program")
[docs]
def fields(
self,
*subfields: Union[
TargetGroupGraphQLField,
"ObservationSelectResultFields",
"ProgramFields",
"TargetFields",
],
) -> "TargetGroupFields":
"""Subfields should come from the TargetGroupFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "TargetGroupFields":
self._alias = alias
return self
[docs]
class TargetGroupSelectResultFields(GraphQLField):
"""The matching targetGroup results, limited to a maximum of 1000 entries."""
[docs]
@classmethod
def matches(cls) -> "TargetGroupFields":
"""Matching targetGroups up to the return size limit of 1000"""
return TargetGroupFields("matches")
has_more: "TargetGroupSelectResultGraphQLField" = (
TargetGroupSelectResultGraphQLField("hasMore")
)
"`true` when there were additional matches that were not returned."
[docs]
def fields(
self,
*subfields: Union[TargetGroupSelectResultGraphQLField, "TargetGroupFields"],
) -> "TargetGroupSelectResultFields":
"""Subfields should come from the TargetGroupSelectResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "TargetGroupSelectResultFields":
self._alias = alias
return self
[docs]
class TargetSelectResultFields(GraphQLField):
"""The matching target results, limited to a maximum of 1000 entries."""
[docs]
@classmethod
def matches(cls) -> "TargetFields":
"""Matching targets up to the return size limit of 1000"""
return TargetFields("matches")
has_more: "TargetSelectResultGraphQLField" = TargetSelectResultGraphQLField(
"hasMore"
)
"`true` when there were additional matches that were not returned."
[docs]
def fields(
self, *subfields: Union[TargetSelectResultGraphQLField, "TargetFields"]
) -> "TargetSelectResultFields":
"""Subfields should come from the TargetSelectResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "TargetSelectResultFields":
self._alias = alias
return self
[docs]
class TelescopeConfigFields(GraphQLField):
[docs]
@classmethod
def offset(cls) -> "OffsetFields":
"""Offset"""
return OffsetFields("offset")
guiding: "TelescopeConfigGraphQLField" = TelescopeConfigGraphQLField("guiding")
"Guide State (whether guiding is enabled for this step)"
[docs]
def fields(
self, *subfields: Union[TelescopeConfigGraphQLField, "OffsetFields"]
) -> "TelescopeConfigFields":
"""Subfields should come from the TelescopeConfigFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "TelescopeConfigFields":
self._alias = alias
return self
[docs]
class TelescopeConfigGeneratorFields(GraphQLField):
"""An offset generator produces a series of offsets according to generator-specific
parameters. Only (at most) one of `enumerated`, `random`, `spiral` or `uniform`
will be defined. All others will be `null`. The `generatorType` corresponds to
the entry (if any) that is defined. If the generator type of `NONE`, then none
of the entries will be defined."""
generator_type: "TelescopeConfigGeneratorGraphQLField" = (
TelescopeConfigGeneratorGraphQLField("generatorType")
)
[docs]
@classmethod
def enumerated(cls) -> "EnumeratedTelescopeConfigGeneratorFields":
return EnumeratedTelescopeConfigGeneratorFields("enumerated")
[docs]
@classmethod
def random(cls) -> "RandomTelescopeConfigGeneratorFields":
return RandomTelescopeConfigGeneratorFields("random")
[docs]
@classmethod
def spiral(cls) -> "SpiralTelescopeConfigGeneratorFields":
return SpiralTelescopeConfigGeneratorFields("spiral")
[docs]
def fields(
self,
*subfields: Union[
TelescopeConfigGeneratorGraphQLField,
"EnumeratedTelescopeConfigGeneratorFields",
"RandomTelescopeConfigGeneratorFields",
"SpiralTelescopeConfigGeneratorFields",
"UniformTelescopeConfigGeneratorFields",
],
) -> "TelescopeConfigGeneratorFields":
"""Subfields should come from the TelescopeConfigGeneratorFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "TelescopeConfigGeneratorFields":
self._alias = alias
return self
[docs]
class TelluricTypeFields(GraphQLField):
"""Telluric calibration type"""
tag: "TelluricTypeGraphQLField" = TelluricTypeGraphQLField("tag")
star_types: "TelluricTypeGraphQLField" = TelluricTypeGraphQLField("starTypes")
[docs]
def fields(self, *subfields: TelluricTypeGraphQLField) -> "TelluricTypeFields":
"""Subfields should come from the TelluricTypeFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "TelluricTypeFields":
self._alias = alias
return self
[docs]
class TimeAndCountExposureTimeModeFields(GraphQLField):
"""Time and Count exposure time mode."""
[docs]
@classmethod
def time(cls) -> "TimeSpanFields":
"""Exposure time."""
return TimeSpanFields("time")
count: "TimeAndCountExposureTimeModeGraphQLField" = (
TimeAndCountExposureTimeModeGraphQLField("count")
)
"Exposure count."
[docs]
@classmethod
def at(cls) -> "WavelengthFields":
"""S/N at Wavelength."""
return WavelengthFields("at")
[docs]
def fields(
self,
*subfields: Union[
TimeAndCountExposureTimeModeGraphQLField,
"TimeSpanFields",
"WavelengthFields",
],
) -> "TimeAndCountExposureTimeModeFields":
"""Subfields should come from the TimeAndCountExposureTimeModeFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "TimeAndCountExposureTimeModeFields":
self._alias = alias
return self
[docs]
class TimeChargeCorrectionFields(GraphQLField):
"""A manual correction to time accounting calculations. Note that the
application of a correction is bounded by a zero time span and the
maximum time span."""
created: "TimeChargeCorrectionGraphQLField" = TimeChargeCorrectionGraphQLField(
"created"
)
"When the correction was made."
charge_class: "TimeChargeCorrectionGraphQLField" = TimeChargeCorrectionGraphQLField(
"chargeClass"
)
"The charge class to be corrected."
op: "TimeChargeCorrectionGraphQLField" = TimeChargeCorrectionGraphQLField("op")
"The operation (add or subtract) to perform."
[docs]
@classmethod
def amount(cls) -> "TimeSpanFields":
"""The amount of time to add or subtract (respecting the min and max time span)."""
return TimeSpanFields("amount")
[docs]
@classmethod
def user(cls) -> "UserFields":
"""The user responsible for the change."""
return UserFields("user")
comment: "TimeChargeCorrectionGraphQLField" = TimeChargeCorrectionGraphQLField(
"comment"
)
"Optional justification for the correction."
[docs]
def fields(
self,
*subfields: Union[
TimeChargeCorrectionGraphQLField, "TimeSpanFields", "UserFields"
],
) -> "TimeChargeCorrectionFields":
"""Subfields should come from the TimeChargeCorrectionFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "TimeChargeCorrectionFields":
self._alias = alias
return self
[docs]
class TimeChargeDaylightDiscountFields(GraphQLField):
"""A time charge discount that is applied when part of the observation is executed
outside of nautical twilight boundaries. The portion that occurs during day
time is not charged."""
[docs]
@classmethod
def interval(cls) -> "TimestampIntervalFields":
"""The interval during which this discount applies."""
return TimestampIntervalFields("interval")
[docs]
@classmethod
def amount(cls) -> "TimeSpanFields":
"""Time amount to discount from the program."""
return TimeSpanFields("amount")
comment: "TimeChargeDaylightDiscountGraphQLField" = (
TimeChargeDaylightDiscountGraphQLField("comment")
)
"Additional detail."
site: "TimeChargeDaylightDiscountGraphQLField" = (
TimeChargeDaylightDiscountGraphQLField("site")
)
"The site where the observation was executed."
[docs]
def fields(
self,
*subfields: Union[
TimeChargeDaylightDiscountGraphQLField,
"TimeSpanFields",
"TimestampIntervalFields",
],
) -> "TimeChargeDaylightDiscountFields":
"""Subfields should come from the TimeChargeDaylightDiscountFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "TimeChargeDaylightDiscountFields":
self._alias = alias
return self
[docs]
class TimeChargeDiscountInterface(GraphQLField):
"""Describes a time charge discount, broken out by charge class. For each class,
the associated time is subtracted and then added to uncharged."""
[docs]
@classmethod
def interval(cls) -> "TimestampIntervalFields":
"""The interval during which this discount applies."""
return TimestampIntervalFields("interval")
[docs]
@classmethod
def amount(cls) -> "TimeSpanFields":
"""Time amount to discount from the program."""
return TimeSpanFields("amount")
comment: "TimeChargeDiscountGraphQLField" = TimeChargeDiscountGraphQLField(
"comment"
)
"Additional detail."
[docs]
def fields(
self,
*subfields: Union[
TimeChargeDiscountGraphQLField, "TimeSpanFields", "TimestampIntervalFields"
],
) -> "TimeChargeDiscountInterface":
"""Subfields should come from the TimeChargeDiscountInterface class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "TimeChargeDiscountInterface":
self._alias = alias
return self
[docs]
def on(
self, type_name: str, *subfields: GraphQLField
) -> "TimeChargeDiscountInterface":
self._inline_fragments[type_name] = subfields
return self
[docs]
class TimeChargeInvoiceFields(GraphQLField):
"""Detailed time accounting information for a visit, showing the raw execution
time along with any automatically applied discounts (e.g., for bad weather)
and manual adjustments made by staff."""
[docs]
@classmethod
def execution_time(cls) -> "CategorizedTimeFields":
"""Raw execution time."""
return CategorizedTimeFields("executionTime")
[docs]
@classmethod
def discounts(cls) -> "TimeChargeDiscountInterface":
"""Automatic discounts for weather loss, fault reports, and non-passing datasets."""
return TimeChargeDiscountInterface("discounts")
[docs]
@classmethod
def corrections(cls) -> "TimeChargeCorrectionFields":
"""Any manual corrections to the execution time."""
return TimeChargeCorrectionFields("corrections")
[docs]
@classmethod
def final_charge(cls) -> "CategorizedTimeFields":
"""Final time charge once discounts and corrections have been applied to the
initial 'executionTime'."""
return CategorizedTimeFields("finalCharge")
[docs]
def fields(
self,
*subfields: Union[
TimeChargeInvoiceGraphQLField,
"CategorizedTimeFields",
"TimeChargeCorrectionFields",
"TimeChargeDiscountInterface",
],
) -> "TimeChargeInvoiceFields":
"""Subfields should come from the TimeChargeInvoiceFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "TimeChargeInvoiceFields":
self._alias = alias
return self
[docs]
class TimeChargeNoDataDiscountFields(GraphQLField):
"""A time charge discount that is applied when no data is collected during the
entirety of the visit."""
[docs]
@classmethod
def interval(cls) -> "TimestampIntervalFields":
"""The interval during which this discount applies."""
return TimestampIntervalFields("interval")
[docs]
@classmethod
def amount(cls) -> "TimeSpanFields":
"""Time amount to discount from the program."""
return TimeSpanFields("amount")
comment: "TimeChargeNoDataDiscountGraphQLField" = (
TimeChargeNoDataDiscountGraphQLField("comment")
)
"Additional detail."
[docs]
def fields(
self,
*subfields: Union[
TimeChargeNoDataDiscountGraphQLField,
"TimeSpanFields",
"TimestampIntervalFields",
],
) -> "TimeChargeNoDataDiscountFields":
"""Subfields should come from the TimeChargeNoDataDiscountFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "TimeChargeNoDataDiscountFields":
self._alias = alias
return self
[docs]
class TimeChargeOverlapDiscountFields(GraphQLField):
"""A time charge discount that is applied when part of the observation is executed
after an overlapping chargeable observation is started. For example, when
writing out datasets while slewing to a new target."""
[docs]
@classmethod
def interval(cls) -> "TimestampIntervalFields":
"""The interval during which this discount applies."""
return TimestampIntervalFields("interval")
[docs]
@classmethod
def amount(cls) -> "TimeSpanFields":
"""Time amount to discount from the program."""
return TimeSpanFields("amount")
comment: "TimeChargeOverlapDiscountGraphQLField" = (
TimeChargeOverlapDiscountGraphQLField("comment")
)
"Additional detail."
[docs]
@classmethod
def observation(cls) -> "ObservationFields":
"""The overlapping observation."""
return ObservationFields("observation")
[docs]
def fields(
self,
*subfields: Union[
TimeChargeOverlapDiscountGraphQLField,
"ObservationFields",
"TimeSpanFields",
"TimestampIntervalFields",
],
) -> "TimeChargeOverlapDiscountFields":
"""Subfields should come from the TimeChargeOverlapDiscountFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "TimeChargeOverlapDiscountFields":
self._alias = alias
return self
[docs]
class TimeChargeQaDiscountFields(GraphQLField):
[docs]
@classmethod
def interval(cls) -> "TimestampIntervalFields":
"""The interval during which this discount applies."""
return TimestampIntervalFields("interval")
[docs]
@classmethod
def amount(cls) -> "TimeSpanFields":
"""Time amount to discount from the program."""
return TimeSpanFields("amount")
comment: "TimeChargeQaDiscountGraphQLField" = TimeChargeQaDiscountGraphQLField(
"comment"
)
"Additional detail."
[docs]
@classmethod
def datasets(cls) -> "DatasetFields":
"""Datasets associated with the discount."""
return DatasetFields("datasets")
[docs]
def fields(
self,
*subfields: Union[
TimeChargeQaDiscountGraphQLField,
"DatasetFields",
"TimeSpanFields",
"TimestampIntervalFields",
],
) -> "TimeChargeQaDiscountFields":
"""Subfields should come from the TimeChargeQaDiscountFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "TimeChargeQaDiscountFields":
self._alias = alias
return self
[docs]
class TimeSpanFields(GraphQLField):
"""Equivalent time amount in several unit options (e.g., 120 seconds or 2 minutes)"""
microseconds: "TimeSpanGraphQLField" = TimeSpanGraphQLField("microseconds")
"TimeSpan in µs"
milliseconds: "TimeSpanGraphQLField" = TimeSpanGraphQLField("milliseconds")
"TimeSpan in ms"
seconds: "TimeSpanGraphQLField" = TimeSpanGraphQLField("seconds")
"TimeSpan in seconds"
minutes: "TimeSpanGraphQLField" = TimeSpanGraphQLField("minutes")
"TimeSpan in minutes"
hours: "TimeSpanGraphQLField" = TimeSpanGraphQLField("hours")
"TimeSpan in hours"
iso: "TimeSpanGraphQLField" = TimeSpanGraphQLField("iso")
"TimeSpan as an ISO-8601 string"
[docs]
def fields(self, *subfields: TimeSpanGraphQLField) -> "TimeSpanFields":
"""Subfields should come from the TimeSpanFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "TimeSpanFields":
self._alias = alias
return self
[docs]
class TimestampIntervalFields(GraphQLField):
"""Time interval marked by a start 'Timestamp' (inclusive) and an end 'Timestamp'
(exclusive)."""
start: "TimestampIntervalGraphQLField" = TimestampIntervalGraphQLField("start")
"Start time of the interval (inclusive)."
end: "TimestampIntervalGraphQLField" = TimestampIntervalGraphQLField("end")
"End time of the interval (exclusive)."
[docs]
@classmethod
def duration(cls) -> "TimeSpanFields":
"""Duration of the interval."""
return TimeSpanFields("duration")
[docs]
def fields(
self, *subfields: Union[TimestampIntervalGraphQLField, "TimeSpanFields"]
) -> "TimestampIntervalFields":
"""Subfields should come from the TimestampIntervalFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "TimestampIntervalFields":
self._alias = alias
return self
[docs]
class TimingWindowFields(GraphQLField):
inclusion: "TimingWindowGraphQLField" = TimingWindowGraphQLField("inclusion")
"Whether this is an INCLUDE or EXCLUDE window."
start_utc: "TimingWindowGraphQLField" = TimingWindowGraphQLField("startUtc")
"Window start time, in UTC."
end: "TimingWindowEndUnion" = TimingWindowEndUnion("end")
"Window end. If absent, the window will never end."
[docs]
def fields(
self, *subfields: Union[TimingWindowGraphQLField, "TimingWindowEndUnion"]
) -> "TimingWindowFields":
"""Subfields should come from the TimingWindowFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "TimingWindowFields":
self._alias = alias
return self
[docs]
class TimingWindowEndAfterFields(GraphQLField):
"""Timing window end after a period of time."""
[docs]
@classmethod
def after(cls) -> "TimeSpanFields":
"""Window duration."""
return TimeSpanFields("after")
[docs]
@classmethod
def repeat(cls) -> "TimingWindowRepeatFields":
"""Window repetetion. If absent, will not repeat."""
return TimingWindowRepeatFields("repeat")
[docs]
def fields(
self,
*subfields: Union[
TimingWindowEndAfterGraphQLField,
"TimeSpanFields",
"TimingWindowRepeatFields",
],
) -> "TimingWindowEndAfterFields":
"""Subfields should come from the TimingWindowEndAfterFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "TimingWindowEndAfterFields":
self._alias = alias
return self
[docs]
class TimingWindowEndAtFields(GraphQLField):
"""Timing window end at a specified date and time."""
at_utc: "TimingWindowEndAtGraphQLField" = TimingWindowEndAtGraphQLField("atUtc")
"Window end date and time, in UTC."
[docs]
def fields(
self, *subfields: TimingWindowEndAtGraphQLField
) -> "TimingWindowEndAtFields":
"""Subfields should come from the TimingWindowEndAtFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "TimingWindowEndAtFields":
self._alias = alias
return self
[docs]
class TimingWindowRepeatFields(GraphQLField):
"""Timing window repetition"""
[docs]
@classmethod
def period(cls) -> "TimeSpanFields":
"""Repeat period, counting from the start of the window."""
return TimeSpanFields("period")
times: "TimingWindowRepeatGraphQLField" = TimingWindowRepeatGraphQLField("times")
"Repetition times. If absent, will repeat forever."
[docs]
def fields(
self, *subfields: Union[TimingWindowRepeatGraphQLField, "TimeSpanFields"]
) -> "TimingWindowRepeatFields":
"""Subfields should come from the TimingWindowRepeatFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "TimingWindowRepeatFields":
self._alias = alias
return self
[docs]
class UnlinkUserResultFields(GraphQLField):
result: "UnlinkUserResultGraphQLField" = UnlinkUserResultGraphQLField("result")
"Returns true if the user was unlinked, false if no such link existed."
[docs]
def fields(
self, *subfields: UnlinkUserResultGraphQLField
) -> "UnlinkUserResultFields":
"""Subfields should come from the UnlinkUserResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "UnlinkUserResultFields":
self._alias = alias
return self
[docs]
class UnnormalizedSedFields(GraphQLField):
"""Un-normalized spectral energy distribution. Exactly one of the definitions will be non-null."""
stellar_library: "UnnormalizedSedGraphQLField" = UnnormalizedSedGraphQLField(
"stellarLibrary"
)
cool_star: "UnnormalizedSedGraphQLField" = UnnormalizedSedGraphQLField("coolStar")
galaxy: "UnnormalizedSedGraphQLField" = UnnormalizedSedGraphQLField("galaxy")
planet: "UnnormalizedSedGraphQLField" = UnnormalizedSedGraphQLField("planet")
quasar: "UnnormalizedSedGraphQLField" = UnnormalizedSedGraphQLField("quasar")
hii_region: "UnnormalizedSedGraphQLField" = UnnormalizedSedGraphQLField("hiiRegion")
planetary_nebula: "UnnormalizedSedGraphQLField" = UnnormalizedSedGraphQLField(
"planetaryNebula"
)
power_law: "UnnormalizedSedGraphQLField" = UnnormalizedSedGraphQLField("powerLaw")
black_body_temp_k: "UnnormalizedSedGraphQLField" = UnnormalizedSedGraphQLField(
"blackBodyTempK"
)
[docs]
@classmethod
def flux_densities(cls) -> "FluxDensityEntryFields":
return FluxDensityEntryFields("fluxDensities")
flux_densities_attachment: "UnnormalizedSedGraphQLField" = (
UnnormalizedSedGraphQLField("fluxDensitiesAttachment")
)
[docs]
def fields(
self, *subfields: Union[UnnormalizedSedGraphQLField, "FluxDensityEntryFields"]
) -> "UnnormalizedSedFields":
"""Subfields should come from the UnnormalizedSedFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "UnnormalizedSedFields":
self._alias = alias
return self
[docs]
class UpdateAsterismsResultFields(GraphQLField):
"""The result of updating the selected observations, up to `LIMIT` or the maximum
of (1000). If `hasMore` is true, additional observations were modified and not
included here."""
[docs]
@classmethod
def observations(cls) -> "ObservationFields":
"""The edited observations, up to the specified LIMIT or the default maximum of 1000."""
return ObservationFields("observations")
has_more: "UpdateAsterismsResultGraphQLField" = UpdateAsterismsResultGraphQLField(
"hasMore"
)
"`true` when there were additional edits that were not returned."
[docs]
def fields(
self, *subfields: Union[UpdateAsterismsResultGraphQLField, "ObservationFields"]
) -> "UpdateAsterismsResultFields":
"""Subfields should come from the UpdateAsterismsResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "UpdateAsterismsResultFields":
self._alias = alias
return self
[docs]
class UpdateAttachmentsResultFields(GraphQLField):
"""The result of updating the selected attachments, up to `LIMIT` or the maximum of (1000). If `hasMore` is true, additional attachments were modified and not included here."""
[docs]
@classmethod
def attachments(cls) -> "AttachmentFields":
"""The edited attachments, up to the specified LIMIT or the default maximum of 1000."""
return AttachmentFields("attachments")
has_more: "UpdateAttachmentsResultGraphQLField" = (
UpdateAttachmentsResultGraphQLField("hasMore")
)
"`true` when there were additional edits that were not returned."
[docs]
def fields(
self, *subfields: Union[UpdateAttachmentsResultGraphQLField, "AttachmentFields"]
) -> "UpdateAttachmentsResultFields":
"""Subfields should come from the UpdateAttachmentsResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "UpdateAttachmentsResultFields":
self._alias = alias
return self
[docs]
class UpdateCallsForProposalsResultFields(GraphQLField):
"""The result of updating the selected calls for proposals, up to `LIMIT` or the
maximum of 1000. If `hasMore` is true, additional calls were modified and not
included here."""
[docs]
@classmethod
def calls_for_proposals(cls) -> "CallForProposalsFields":
"""The edited observations, up to the specified LIMIT or the default maximum of
1000."""
return CallForProposalsFields("callsForProposals")
has_more: "UpdateCallsForProposalsResultGraphQLField" = (
UpdateCallsForProposalsResultGraphQLField("hasMore")
)
"`true` when there were additional edits that were not returned."
[docs]
def fields(
self,
*subfields: Union[
UpdateCallsForProposalsResultGraphQLField, "CallForProposalsFields"
],
) -> "UpdateCallsForProposalsResultFields":
"""Subfields should come from the UpdateCallsForProposalsResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "UpdateCallsForProposalsResultFields":
self._alias = alias
return self
[docs]
class UpdateConfigurationRequestsResultFields(GraphQLField):
"""The result of updating the selected observations, up to `LIMIT` or the maximum of (1000). If `hasMore` is true, additional observations were modified and not included here."""
[docs]
@classmethod
def requests(cls) -> "ConfigurationRequestFields":
"""The edited observations, up to the specified LIMIT or the default maximum of 1000."""
return ConfigurationRequestFields("requests")
has_more: "UpdateConfigurationRequestsResultGraphQLField" = (
UpdateConfigurationRequestsResultGraphQLField("hasMore")
)
"`true` when there were additional edits that were not returned."
[docs]
def fields(
self,
*subfields: Union[
UpdateConfigurationRequestsResultGraphQLField, "ConfigurationRequestFields"
],
) -> "UpdateConfigurationRequestsResultFields":
"""Subfields should come from the UpdateConfigurationRequestsResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "UpdateConfigurationRequestsResultFields":
self._alias = alias
return self
[docs]
class UpdateDatasetsResultFields(GraphQLField):
"""The result of updating the selected datasets, up to `LIMIT` or the maximum of (1000). If `hasMore` is true, additional datasets were modified and not included here."""
[docs]
@classmethod
def datasets(cls) -> "DatasetFields":
"""The edited datasets, up to the specified LIMIT or the default maximum of 1000."""
return DatasetFields("datasets")
has_more: "UpdateDatasetsResultGraphQLField" = UpdateDatasetsResultGraphQLField(
"hasMore"
)
"`true` when there were additional edits that were not returned."
[docs]
def fields(
self, *subfields: Union[UpdateDatasetsResultGraphQLField, "DatasetFields"]
) -> "UpdateDatasetsResultFields":
"""Subfields should come from the UpdateDatasetsResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "UpdateDatasetsResultFields":
self._alias = alias
return self
[docs]
class UpdateGroupsResultFields(GraphQLField):
[docs]
@classmethod
def groups(cls) -> "GroupFields":
"""The edited groups, up to the specified LIMIT or the default maximum of 1000."""
return GroupFields("groups")
has_more: "UpdateGroupsResultGraphQLField" = UpdateGroupsResultGraphQLField(
"hasMore"
)
"`true` when there were additional edits that were not returned."
[docs]
def fields(
self, *subfields: Union[UpdateGroupsResultGraphQLField, "GroupFields"]
) -> "UpdateGroupsResultFields":
"""Subfields should come from the UpdateGroupsResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "UpdateGroupsResultFields":
self._alias = alias
return self
[docs]
class UpdateObservationsResultFields(GraphQLField):
"""The result of updating the selected observations, up to `LIMIT` or the maximum of (1000). If `hasMore` is true, additional observations were modified and not included here."""
[docs]
@classmethod
def observations(cls) -> "ObservationFields":
"""The edited observations, up to the specified LIMIT or the default maximum of 1000."""
return ObservationFields("observations")
has_more: "UpdateObservationsResultGraphQLField" = (
UpdateObservationsResultGraphQLField("hasMore")
)
"`true` when there were additional edits that were not returned."
[docs]
def fields(
self,
*subfields: Union[UpdateObservationsResultGraphQLField, "ObservationFields"],
) -> "UpdateObservationsResultFields":
"""Subfields should come from the UpdateObservationsResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "UpdateObservationsResultFields":
self._alias = alias
return self
[docs]
class UpdateProgramNotesResultFields(GraphQLField):
"""The result of updating the selected notes, up to `LIMIT` or the maximum of
(1000). If `hasMore` is true, additional notes were modified and not included
here."""
[docs]
@classmethod
def program_notes(cls) -> "ProgramNoteFields":
"""The edited notes, up to the specified LIMIT or the default maximum of 1000."""
return ProgramNoteFields("programNotes")
has_more: "UpdateProgramNotesResultGraphQLField" = (
UpdateProgramNotesResultGraphQLField("hasMore")
)
"`true` when there were additional edits that were not returned."
[docs]
def fields(
self,
*subfields: Union[UpdateProgramNotesResultGraphQLField, "ProgramNoteFields"],
) -> "UpdateProgramNotesResultFields":
"""Subfields should come from the UpdateProgramNotesResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "UpdateProgramNotesResultFields":
self._alias = alias
return self
[docs]
class UpdateProgramUsersResultFields(GraphQLField):
"""The result of calling 'updateProgramUsers', up to 'LIMIT' or the maximum of
1000. If 'hasMore' is true, additional program users were modified but not
included in the result."""
[docs]
@classmethod
def program_users(cls) -> "ProgramUserFields":
"""The first program users that were updated (up to the LIMIT specified in the
mutation)."""
return ProgramUserFields("programUsers")
has_more: "UpdateProgramUsersResultGraphQLField" = (
UpdateProgramUsersResultGraphQLField("hasMore")
)
"Whether there were additional updated program users that were not returned."
[docs]
def fields(
self,
*subfields: Union[UpdateProgramUsersResultGraphQLField, "ProgramUserFields"],
) -> "UpdateProgramUsersResultFields":
"""Subfields should come from the UpdateProgramUsersResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "UpdateProgramUsersResultFields":
self._alias = alias
return self
[docs]
class UpdateProgramsResultFields(GraphQLField):
"""The result of updating the selected programs, up to `LIMIT` or the maximum of (1000). If `hasMore` is true, additional programs were modified and not included here."""
[docs]
@classmethod
def programs(cls) -> "ProgramFields":
"""The edited programs, up to the specified LIMIT or the default maximum of 1000."""
return ProgramFields("programs")
has_more: "UpdateProgramsResultGraphQLField" = UpdateProgramsResultGraphQLField(
"hasMore"
)
"`true` when there were additional edits that were not returned."
[docs]
def fields(
self, *subfields: Union[UpdateProgramsResultGraphQLField, "ProgramFields"]
) -> "UpdateProgramsResultFields":
"""Subfields should come from the UpdateProgramsResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "UpdateProgramsResultFields":
self._alias = alias
return self
[docs]
class UpdateProposalResultFields(GraphQLField):
"""The result of updating a proposal"""
[docs]
@classmethod
def proposal(cls) -> "ProposalFields":
"""The updated proposal."""
return ProposalFields("proposal")
[docs]
def fields(
self, *subfields: Union[UpdateProposalResultGraphQLField, "ProposalFields"]
) -> "UpdateProposalResultFields":
"""Subfields should come from the UpdateProposalResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "UpdateProposalResultFields":
self._alias = alias
return self
[docs]
class UpdateTargetsResultFields(GraphQLField):
"""The result of updating the selected targets, up to `LIMIT` or the maximum of (1000). If `hasMore` is true, additional targets were modified and not included here."""
[docs]
@classmethod
def targets(cls) -> "TargetFields":
"""The edited targets, up to the specified LIMIT or the default maximum of 1000."""
return TargetFields("targets")
has_more: "UpdateTargetsResultGraphQLField" = UpdateTargetsResultGraphQLField(
"hasMore"
)
"`true` when there were additional edits that were not returned."
[docs]
def fields(
self, *subfields: Union[UpdateTargetsResultGraphQLField, "TargetFields"]
) -> "UpdateTargetsResultFields":
"""Subfields should come from the UpdateTargetsResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "UpdateTargetsResultFields":
self._alias = alias
return self
[docs]
class UserFields(GraphQLField):
id: "UserGraphQLField" = UserGraphQLField("id")
type_: "UserGraphQLField" = UserGraphQLField("type")
service_name: "UserGraphQLField" = UserGraphQLField("serviceName")
orcid_id: "UserGraphQLField" = UserGraphQLField("orcidId")
[docs]
@classmethod
def profile(cls) -> "UserProfileFields":
return UserProfileFields("profile")
[docs]
def fields(
self, *subfields: Union[UserGraphQLField, "UserProfileFields"]
) -> "UserFields":
"""Subfields should come from the UserFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "UserFields":
self._alias = alias
return self
[docs]
class UserInvitationFields(GraphQLField):
"""Invitation"""
id: "UserInvitationGraphQLField" = UserInvitationGraphQLField("id")
"Id"
status: "UserInvitationGraphQLField" = UserInvitationGraphQLField("status")
"Invitation status."
[docs]
@classmethod
def issuer(cls) -> "UserFields":
"""User who issued the invitation."""
return UserFields("issuer")
recipient_email: "UserInvitationGraphQLField" = UserInvitationGraphQLField(
"recipientEmail"
)
"Recipient email address."
[docs]
@classmethod
def program_user(cls) -> "ProgramUserFields":
"""The ProgramUser associated with the invitation."""
return ProgramUserFields("programUser")
[docs]
@classmethod
def email(cls) -> "EmailFields":
"""The email sent for the invitation."""
return EmailFields("email")
[docs]
def fields(
self,
*subfields: Union[
UserInvitationGraphQLField, "EmailFields", "ProgramUserFields", "UserFields"
],
) -> "UserInvitationFields":
"""Subfields should come from the UserInvitationFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "UserInvitationFields":
self._alias = alias
return self
[docs]
class UserProfileFields(GraphQLField):
given_name: "UserProfileGraphQLField" = UserProfileGraphQLField("givenName")
family_name: "UserProfileGraphQLField" = UserProfileGraphQLField("familyName")
credit_name: "UserProfileGraphQLField" = UserProfileGraphQLField("creditName")
email: "UserProfileGraphQLField" = UserProfileGraphQLField("email")
[docs]
def fields(self, *subfields: UserProfileGraphQLField) -> "UserProfileFields":
"""Subfields should come from the UserProfileFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "UserProfileFields":
self._alias = alias
return self
[docs]
class VisitFields(GraphQLField):
"""A visit is recorded whenever any part of an observation is attempted. There
is a specific static configuration for each instrument, only one of which is
defined. The same static configuration holds for the entire visit."""
id: "VisitGraphQLField" = VisitGraphQLField("id")
"Visit id."
instrument: "VisitGraphQLField" = VisitGraphQLField("instrument")
"Instrument in use for this visit. This serves as a discriminator between the\nvarious specific static instrument configuration types (e.g.,\n`gmosNorth: GmosNorthStatic`.)"
[docs]
@classmethod
def observation(cls) -> "ObservationFields":
"""Observation associated with this visit."""
return ObservationFields("observation")
created: "VisitGraphQLField" = VisitGraphQLField("created")
"Created by Observe at time."
site: "VisitGraphQLField" = VisitGraphQLField("site")
"Site of the visit."
[docs]
@classmethod
def interval(cls) -> "TimestampIntervalFields":
"""Time interval during which this visit executed."""
return TimestampIntervalFields("interval")
[docs]
@classmethod
def atom_records(
cls, *, offset: Optional[Any] = None, limit: Optional[Any] = None
) -> "AtomRecordSelectResultFields":
"""Executed (or at least partially executed) atom records for this visit."""
arguments: dict[str, dict[str, Any]] = {
"OFFSET": {"type": "PosInt", "value": offset},
"LIMIT": {"type": "NonNegInt", "value": limit},
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return AtomRecordSelectResultFields("atomRecords", arguments=cleared_arguments)
[docs]
@classmethod
def datasets(
cls, *, offset: Optional[Any] = None, limit: Optional[Any] = None
) -> "DatasetSelectResultFields":
"""Datasets associated with this visit."""
arguments: dict[str, dict[str, Any]] = {
"OFFSET": {"type": "DatasetId", "value": offset},
"LIMIT": {"type": "NonNegInt", "value": limit},
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return DatasetSelectResultFields("datasets", arguments=cleared_arguments)
[docs]
@classmethod
def events(
cls, *, offset: Optional[Any] = None, limit: Optional[Any] = None
) -> "ExecutionEventSelectResultFields":
"""Execution events associated with this visit."""
arguments: dict[str, dict[str, Any]] = {
"OFFSET": {"type": "ExecutionEventId", "value": offset},
"LIMIT": {"type": "NonNegInt", "value": limit},
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return ExecutionEventSelectResultFields("events", arguments=cleared_arguments)
[docs]
@classmethod
def time_charge_invoice(cls) -> "TimeChargeInvoiceFields":
"""Time accounting details for this visit."""
return TimeChargeInvoiceFields("timeChargeInvoice")
idempotency_key: "VisitGraphQLField" = VisitGraphQLField("idempotencyKey")
"Idempotency key, if any. The IdempotencyKey may be provided by clients when\nthe visit is created and is used to enable problem-free retry in the case of\nfailure."
[docs]
@classmethod
def flamingos_2(cls) -> "Flamingos2StaticFields":
"""Flamingos 2 static instrument configuration, for Flamingos 2 visits. See the
`instrument` discriminator. This will be null unless the instrument is
`FLAMINGOS2`."""
return Flamingos2StaticFields("flamingos2")
[docs]
@classmethod
def gmos_north(cls) -> "GmosNorthStaticFields":
"""GmosNorth static instrument configuration, for GMOS North visits. See the
`instrument` discriminator. This will be null unless the instrument is
`GMOS_NORTH`."""
return GmosNorthStaticFields("gmosNorth")
[docs]
@classmethod
def gmos_south(cls) -> "GmosSouthStaticFields":
"""GmosSouth static instrument configuration, for GMOS South visits. See the
`instrument` discriminator. This will be null unless the instrument is
`GMOS_SOUTH`."""
return GmosSouthStaticFields("gmosSouth")
[docs]
@classmethod
def igrins_2(cls) -> "Igrins2StaticFields":
"""IGRINS-2 static instrument configuration, for IGRINS-2 visits. See the
`instrument` discriminator. This will be null unless the instrument is
`IGRINS2`."""
return Igrins2StaticFields("igrins2")
[docs]
def fields(
self,
*subfields: Union[
VisitGraphQLField,
"AtomRecordSelectResultFields",
"DatasetSelectResultFields",
"ExecutionEventSelectResultFields",
"Flamingos2StaticFields",
"GmosNorthStaticFields",
"GmosSouthStaticFields",
"Igrins2StaticFields",
"ObservationFields",
"TimeChargeInvoiceFields",
"TimestampIntervalFields",
],
) -> "VisitFields":
"""Subfields should come from the VisitFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "VisitFields":
self._alias = alias
return self
[docs]
class VisitSelectResultFields(GraphQLField):
"""Matching visit results, limited to a maximum of 1000 entries."""
[docs]
@classmethod
def matches(cls) -> "VisitFields":
"""Matching visits up to the return size limit of 1000."""
return VisitFields("matches")
has_more: "VisitSelectResultGraphQLField" = VisitSelectResultGraphQLField("hasMore")
"`true` when there were additional matches that were not returned."
[docs]
def fields(
self, *subfields: Union[VisitSelectResultGraphQLField, "VisitFields"]
) -> "VisitSelectResultFields":
"""Subfields should come from the VisitSelectResultFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "VisitSelectResultFields":
self._alias = alias
return self
[docs]
class VisitorFields(GraphQLField):
mode: "VisitorGraphQLField" = VisitorGraphQLField("mode")
[docs]
@classmethod
def central_wavelength(cls) -> "WavelengthFields":
return WavelengthFields("centralWavelength")
[docs]
@classmethod
def guide_star_min_sep(cls) -> "AngleFields":
return AngleFields("guideStarMinSep")
[docs]
def fields(
self, *subfields: Union[VisitorGraphQLField, "AngleFields", "WavelengthFields"]
) -> "VisitorFields":
"""Subfields should come from the VisitorFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "VisitorFields":
self._alias = alias
return self
[docs]
class WavelengthFields(GraphQLField):
picometers: "WavelengthGraphQLField" = WavelengthGraphQLField("picometers")
"Wavelength in pm"
angstroms: "WavelengthGraphQLField" = WavelengthGraphQLField("angstroms")
"Wavelength in Å"
nanometers: "WavelengthGraphQLField" = WavelengthGraphQLField("nanometers")
"Wavelength in nm"
micrometers: "WavelengthGraphQLField" = WavelengthGraphQLField("micrometers")
"Wavelength in µm"
[docs]
def fields(self, *subfields: WavelengthGraphQLField) -> "WavelengthFields":
"""Subfields should come from the WavelengthFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "WavelengthFields":
self._alias = alias
return self
[docs]
class WavelengthDitherFields(GraphQLField):
"""A WavelengthDither is expressed in the same units as Wavelength but
constrained to positive values. It expresses an "offset" to a given
Wavelength."""
picometers: "WavelengthDitherGraphQLField" = WavelengthDitherGraphQLField(
"picometers"
)
"Wavelength dither in pm"
angstroms: "WavelengthDitherGraphQLField" = WavelengthDitherGraphQLField(
"angstroms"
)
"Wavelength dither in Å"
nanometers: "WavelengthDitherGraphQLField" = WavelengthDitherGraphQLField(
"nanometers"
)
"Wavelength dither in nm"
micrometers: "WavelengthDitherGraphQLField" = WavelengthDitherGraphQLField(
"micrometers"
)
"Wavelength dither in µm"
[docs]
def fields(
self, *subfields: WavelengthDitherGraphQLField
) -> "WavelengthDitherFields":
"""Subfields should come from the WavelengthDitherFields class"""
self._subfields.extend(subfields)
return self
[docs]
def alias(self, alias: str) -> "WavelengthDitherFields":
self._alias = alias
return self