from typing import Any, Optional
from .custom_fields import (
AddConditionsEntryResultFields,
AddDatasetEventResultFields,
AddProgramUserResultFields,
AddSequenceEventResultFields,
AddSlewEventResultFields,
AddStepEventResultFields,
AddTimeChargeCorrectionResultFields,
ChangeProgramUserRoleResultFields,
CloneGroupResultFields,
CloneObservationResultFields,
CloneTargetResultFields,
ConfigurationRequestFields,
CreateCallForProposalsResultFields,
CreateGroupResultFields,
CreateObservationResultFields,
CreateProgramNoteResultFields,
CreateProgramResultFields,
CreateProposalResultFields,
CreateTargetResultFields,
CreateUserInvitationResultFields,
DeleteProgramUserResultFields,
DeleteProposalResultFields,
LinkUserResultFields,
ObservationWorkflowFields,
RecordDatasetResultFields,
RecordFlamingos2VisitResultFields,
RecordGmosNorthVisitResultFields,
RecordGmosSouthVisitResultFields,
RecordIgrins2VisitResultFields,
RecordVisitResultFields,
RedeemUserInvitationResultFields,
ReplaceFlamingos2SequenceResultFields,
ReplaceGmosNorthSequenceResultFields,
ReplaceGmosSouthSequenceResultFields,
ReplaceIgrins2SequenceResultFields,
ResetAcquisitionResultFields,
RevokeUserInvitationResultFields,
SetAllocationsResultFields,
SetGuideTargetNameResultFields,
SetProgramReferenceResultFields,
SetProposalStatusResultFields,
UnlinkUserResultFields,
UpdateAsterismsResultFields,
UpdateAttachmentsResultFields,
UpdateCallsForProposalsResultFields,
UpdateConfigurationRequestsResultFields,
UpdateDatasetsResultFields,
UpdateGroupsResultFields,
UpdateObservationsResultFields,
UpdateProgramNotesResultFields,
UpdateProgramsResultFields,
UpdateProgramUsersResultFields,
UpdateProposalResultFields,
UpdateTargetsResultFields,
)
from .input_types import (
AddDatasetEventInput,
AddProgramUserInput,
AddSequenceEventInput,
AddSlewEventInput,
AddStepEventInput,
AddTimeChargeCorrectionInput,
ChangeProgramUserRoleInput,
CloneGroupInput,
CloneObservationInput,
CloneTargetInput,
ConditionsEntryInput,
CreateCallForProposalsInput,
CreateConfigurationRequestInput,
CreateGroupInput,
CreateObservationInput,
CreateProgramInput,
CreateProgramNoteInput,
CreateProposalInput,
CreateTargetInput,
CreateUserInvitationInput,
DeleteProgramUserInput,
DeleteProposalInput,
LinkUserInput,
RecordDatasetInput,
RecordFlamingos2VisitInput,
RecordGmosNorthVisitInput,
RecordGmosSouthVisitInput,
RecordIgrins2VisitInput,
RecordVisitInput,
RedeemUserInvitationInput,
ReplaceFlamingos2SequenceInput,
ReplaceGmosNorthSequenceInput,
ReplaceGmosSouthSequenceInput,
ReplaceIgrins2SequenceInput,
ResetAcquisitionInput,
RevokeUserInvitationInput,
SetAllocationsInput,
SetGuideTargetNameInput,
SetObservationWorkflowStateInput,
SetProgramReferenceInput,
SetProposalStatusInput,
UnlinkUserInput,
UpdateAsterismsInput,
UpdateAttachmentsInput,
UpdateCallsForProposalsInput,
UpdateConfigurationRequestsInput,
UpdateDatasetsInput,
UpdateGroupsInput,
UpdateObservationsInput,
UpdateObservationsTimesInput,
UpdateProgramNotesInput,
UpdateProgramsInput,
UpdateProgramUsersInput,
UpdateProposalInput,
UpdateTargetsInput,
)
[docs]
class Mutation:
[docs]
@classmethod
def add_conditions_entry(
cls, *, input: Optional[ConditionsEntryInput] = None
) -> AddConditionsEntryResultFields:
"""Logs observing conditions to the Chronicle. This operation is permitted only for staff and
service users."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "ConditionsEntryInput", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return AddConditionsEntryResultFields(
field_name="addConditionsEntry", arguments=cleared_arguments
)
[docs]
@classmethod
def add_dataset_event(
cls, input: AddDatasetEventInput
) -> AddDatasetEventResultFields:
"""Adds a new dataset event associated with the given visit. The
generation of a single dataset will produce multiple events as it
transitions through the observe, readout and write stages."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "AddDatasetEventInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return AddDatasetEventResultFields(
field_name="addDatasetEvent", arguments=cleared_arguments
)
[docs]
@classmethod
def add_program_user(cls, input: AddProgramUserInput) -> AddProgramUserResultFields:
"""Creates a 'ProgramUser' without a link to any existing 'User'. No invitation
is sent as a result of this operation, but an invitation may be subsequently
sent and when accepted the 'User' field will become available and the 'User'
will gain appropriate access to the program."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "AddProgramUserInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return AddProgramUserResultFields(
field_name="addProgramUser", arguments=cleared_arguments
)
[docs]
@classmethod
def add_sequence_event(
cls, input: AddSequenceEventInput
) -> AddSequenceEventResultFields:
"""Adds a sequence event associated with the given visit. Multiple events
will be produced during the execution of a sequence as it is started,
paused, continued, etc."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "AddSequenceEventInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return AddSequenceEventResultFields(
field_name="addSequenceEvent", arguments=cleared_arguments
)
[docs]
@classmethod
def add_slew_event(cls, input: AddSlewEventInput) -> AddSlewEventResultFields:
"""Adds a new slew event associated with the given visit."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "AddSlewEventInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return AddSlewEventResultFields(
field_name="addSlewEvent", arguments=cleared_arguments
)
[docs]
@classmethod
def add_step_event(cls, input: AddStepEventInput) -> AddStepEventResultFields:
"""Adds a new step event associated with the given step. Multiple events
will be produced during the execution of a single step as it
transitions through configure and observe stages."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "AddStepEventInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return AddStepEventResultFields(
field_name="addStepEvent", arguments=cleared_arguments
)
[docs]
@classmethod
def add_time_charge_correction(
cls, input: AddTimeChargeCorrectionInput
) -> AddTimeChargeCorrectionResultFields:
"""Adds a new time accounting correction for a particular observation. Note
that time accounting corrections are additive and cannot be adjusted or
deleted except via a future correction. For example, to undo the impact
of an 'Add' operation, a new 'Subtract' operation of the same amount can
be introduced."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "AddTimeChargeCorrectionInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return AddTimeChargeCorrectionResultFields(
field_name="addTimeChargeCorrection", arguments=cleared_arguments
)
[docs]
@classmethod
def change_program_user_role(
cls, input: ChangeProgramUserRoleInput
) -> ChangeProgramUserRoleResultFields:
"""Update the role of a program user."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "ChangeProgramUserRoleInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return ChangeProgramUserRoleResultFields(
field_name="changeProgramUserRole", arguments=cleared_arguments
)
[docs]
@classmethod
def clone_observation(
cls, input: CloneObservationInput
) -> CloneObservationResultFields:
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "CloneObservationInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return CloneObservationResultFields(
field_name="cloneObservation", arguments=cleared_arguments
)
[docs]
@classmethod
def clone_group(cls, input: CloneGroupInput) -> CloneGroupResultFields:
"""Copy this group and its contents, recursively, as a sibling of itself."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "CloneGroupInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return CloneGroupResultFields(
field_name="cloneGroup", arguments=cleared_arguments
)
[docs]
@classmethod
def clone_target(cls, input: CloneTargetInput) -> CloneTargetResultFields:
"""Makes a copy of an existing target, setting it to unobserved and to PRESENT. If `REPLACE_IN` observationIds are specified in the input, the clone will replace the existing target in those observations"""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "CloneTargetInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return CloneTargetResultFields(
field_name="cloneTarget", arguments=cleared_arguments
)
[docs]
@classmethod
def create_call_for_proposals(
cls, input: CreateCallForProposalsInput
) -> CreateCallForProposalsResultFields:
"""Creates a Call for Proposals. Requires staff access."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "CreateCallForProposalsInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return CreateCallForProposalsResultFields(
field_name="createCallForProposals", arguments=cleared_arguments
)
[docs]
@classmethod
def create_group(cls, input: CreateGroupInput) -> CreateGroupResultFields:
"""Creates a new observation according to provided parameters."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "CreateGroupInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return CreateGroupResultFields(
field_name="createGroup", arguments=cleared_arguments
)
[docs]
@classmethod
def create_observation(
cls, input: CreateObservationInput
) -> CreateObservationResultFields:
"""Creates a new observation according to provided parameters"""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "CreateObservationInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return CreateObservationResultFields(
field_name="createObservation", arguments=cleared_arguments
)
[docs]
@classmethod
def create_program(cls, input: CreateProgramInput) -> CreateProgramResultFields:
"""Creates a new program according to provided properties"""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "CreateProgramInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return CreateProgramResultFields(
field_name="createProgram", arguments=cleared_arguments
)
[docs]
@classmethod
def create_program_note(
cls, input: CreateProgramNoteInput
) -> CreateProgramNoteResultFields:
"""Creates a new program note according to provided parameters"""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "CreateProgramNoteInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return CreateProgramNoteResultFields(
field_name="createProgramNote", arguments=cleared_arguments
)
[docs]
@classmethod
def create_proposal(cls, input: CreateProposalInput) -> CreateProposalResultFields:
"""Creates a new proposal according to the provided properties"""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "CreateProposalInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return CreateProposalResultFields(
field_name="createProposal", arguments=cleared_arguments
)
[docs]
@classmethod
def create_target(cls, input: CreateTargetInput) -> CreateTargetResultFields:
"""Creates a new target according to the provided parameters. Only one of sidereal or nonsidereal may be specified."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "CreateTargetInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return CreateTargetResultFields(
field_name="createTarget", arguments=cleared_arguments
)
[docs]
@classmethod
def delete_program_user(
cls, input: DeleteProgramUserInput
) -> DeleteProgramUserResultFields:
"""Deletes a 'ProgramUser'."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "DeleteProgramUserInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return DeleteProgramUserResultFields(
field_name="deleteProgramUser", arguments=cleared_arguments
)
[docs]
@classmethod
def delete_proposal(cls, input: DeleteProposalInput) -> DeleteProposalResultFields:
"""Deletes the given program's proposal, if any."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "DeleteProposalInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return DeleteProposalResultFields(
field_name="deleteProposal", arguments=cleared_arguments
)
[docs]
@classmethod
def link_user(cls, input: LinkUserInput) -> LinkUserResultFields:
"""Ties a specific user to an existing ProgramUser, which must not already be
associated with any user."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "LinkUserInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return LinkUserResultFields(field_name="linkUser", arguments=cleared_arguments)
[docs]
@classmethod
def record_dataset(cls, input: RecordDatasetInput) -> RecordDatasetResultFields:
"""Records a new dataset. This dataset may be subsequently referenced by dataset events."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "RecordDatasetInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return RecordDatasetResultFields(
field_name="recordDataset", arguments=cleared_arguments
)
[docs]
@classmethod
def record_flamingos_2_visit(
cls, input: RecordFlamingos2VisitInput
) -> RecordFlamingos2VisitResultFields:
"""Record a new Flamingos 2 visit"""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "RecordFlamingos2VisitInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return RecordFlamingos2VisitResultFields(
field_name="recordFlamingos2Visit", arguments=cleared_arguments
)
[docs]
@classmethod
def replace_flamingos_2_sequence(
cls, input: ReplaceFlamingos2SequenceInput
) -> ReplaceFlamingos2SequenceResultFields:
"""Replaces the remaining steps in an execution sequence with the provided
sequence. Previously executed (or even partially executed) steps are not
deleted. Any ongoing steps are abandoned."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "ReplaceFlamingos2SequenceInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return ReplaceFlamingos2SequenceResultFields(
field_name="replaceFlamingos2Sequence", arguments=cleared_arguments
)
[docs]
@classmethod
def record_gmos_north_visit(
cls, input: RecordGmosNorthVisitInput
) -> RecordGmosNorthVisitResultFields:
"""Record a new GMOS North visit"""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "RecordGmosNorthVisitInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return RecordGmosNorthVisitResultFields(
field_name="recordGmosNorthVisit", arguments=cleared_arguments
)
[docs]
@classmethod
def replace_gmos_north_sequence(
cls, input: ReplaceGmosNorthSequenceInput
) -> ReplaceGmosNorthSequenceResultFields:
"""Replaces the remaining steps in an execution sequence with the provided
sequence. Previously executed (or even partially executed) steps are not
deleted. Any ongoing steps are abandoned."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "ReplaceGmosNorthSequenceInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return ReplaceGmosNorthSequenceResultFields(
field_name="replaceGmosNorthSequence", arguments=cleared_arguments
)
[docs]
@classmethod
def record_gmos_south_visit(
cls, input: RecordGmosSouthVisitInput
) -> RecordGmosSouthVisitResultFields:
"""Record a new GMOS South visit"""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "RecordGmosSouthVisitInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return RecordGmosSouthVisitResultFields(
field_name="recordGmosSouthVisit", arguments=cleared_arguments
)
[docs]
@classmethod
def record_igrins_2_visit(
cls, input: RecordIgrins2VisitInput
) -> RecordIgrins2VisitResultFields:
"""Record a new IGRINS-2 visit"""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "RecordIgrins2VisitInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return RecordIgrins2VisitResultFields(
field_name="recordIgrins2Visit", arguments=cleared_arguments
)
[docs]
@classmethod
def record_visit(cls, input: RecordVisitInput) -> RecordVisitResultFields:
"""Record a new visit."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "RecordVisitInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return RecordVisitResultFields(
field_name="recordVisit", arguments=cleared_arguments
)
[docs]
@classmethod
def replace_gmos_south_sequence(
cls, input: ReplaceGmosSouthSequenceInput
) -> ReplaceGmosSouthSequenceResultFields:
"""Replaces the remaining steps in an execution sequence with the provided
sequence. Previously executed (or even partially executed) steps are not
deleted. Any ongoing steps are abandoned."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "ReplaceGmosSouthSequenceInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return ReplaceGmosSouthSequenceResultFields(
field_name="replaceGmosSouthSequence", arguments=cleared_arguments
)
[docs]
@classmethod
def replace_igrins_2_sequence(
cls, input: ReplaceIgrins2SequenceInput
) -> ReplaceIgrins2SequenceResultFields:
"""Replaces the remaining steps in an execution sequence with the provided
sequence. Previously executed (or even partially executed) steps are not
deleted. Any ongoing steps are abandoned."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "ReplaceIgrins2SequenceInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return ReplaceIgrins2SequenceResultFields(
field_name="replaceIgrins2Sequence", arguments=cleared_arguments
)
[docs]
@classmethod
def reset_acquisition(
cls, input: ResetAcquisitionInput
) -> ResetAcquisitionResultFields:
"""Resets the acquisition sequence to start from the initial step regardless of
which acquisition steps may have been executed. Requires staff (or better)
access."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "ResetAcquisitionInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return ResetAcquisitionResultFields(
field_name="resetAcquisition", arguments=cleared_arguments
)
[docs]
@classmethod
def set_allocations(cls, input: SetAllocationsInput) -> SetAllocationsResultFields:
"""Set the allocations for a program."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "SetAllocationsInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return SetAllocationsResultFields(
field_name="setAllocations", arguments=cleared_arguments
)
[docs]
@classmethod
def set_guide_target_name(
cls, input: SetGuideTargetNameInput
) -> SetGuideTargetNameResultFields:
"""Set the name of the guide target for an observation."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "SetGuideTargetNameInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return SetGuideTargetNameResultFields(
field_name="setGuideTargetName", arguments=cleared_arguments
)
[docs]
@classmethod
def set_program_reference(
cls, input: SetProgramReferenceInput
) -> SetProgramReferenceResultFields:
"""Set the program reference."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "SetProgramReferenceInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return SetProgramReferenceResultFields(
field_name="setProgramReference", arguments=cleared_arguments
)
[docs]
@classmethod
def set_proposal_status(
cls, input: SetProposalStatusInput
) -> SetProposalStatusResultFields:
"""Set the proposal status."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "SetProposalStatusInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return SetProposalStatusResultFields(
field_name="setProposalStatus", arguments=cleared_arguments
)
[docs]
@classmethod
def unlink_user(cls, input: UnlinkUserInput) -> UnlinkUserResultFields:
"""Unlink a user from a program."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "UnlinkUserInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return UnlinkUserResultFields(
field_name="unlinkUser", arguments=cleared_arguments
)
[docs]
@classmethod
def update_asterisms(
cls, input: UpdateAsterismsInput
) -> UpdateAsterismsResultFields:
"""Update asterisms, adding or deleting targets, in (potentially) multiple
observations at once."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "UpdateAsterismsInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return UpdateAsterismsResultFields(
field_name="updateAsterisms", arguments=cleared_arguments
)
[docs]
@classmethod
def update_attachments(
cls, input: UpdateAttachmentsInput
) -> UpdateAttachmentsResultFields:
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "UpdateAttachmentsInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return UpdateAttachmentsResultFields(
field_name="updateAttachments", arguments=cleared_arguments
)
[docs]
@classmethod
def update_calls_for_proposals(
cls, input: UpdateCallsForProposalsInput
) -> UpdateCallsForProposalsResultFields:
"""Update existing calls for proposals."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "UpdateCallsForProposalsInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return UpdateCallsForProposalsResultFields(
field_name="updateCallsForProposals", arguments=cleared_arguments
)
[docs]
@classmethod
def update_datasets(cls, input: UpdateDatasetsInput) -> UpdateDatasetsResultFields:
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "UpdateDatasetsInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return UpdateDatasetsResultFields(
field_name="updateDatasets", arguments=cleared_arguments
)
[docs]
@classmethod
def update_groups(cls, input: UpdateGroupsInput) -> UpdateGroupsResultFields:
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "UpdateGroupsInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return UpdateGroupsResultFields(
field_name="updateGroups", arguments=cleared_arguments
)
[docs]
@classmethod
def update_observations(
cls, input: UpdateObservationsInput
) -> UpdateObservationsResultFields:
"""Updates existing observations"""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "UpdateObservationsInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return UpdateObservationsResultFields(
field_name="updateObservations", arguments=cleared_arguments
)
[docs]
@classmethod
def update_configuration_requests(
cls, input: UpdateConfigurationRequestsInput
) -> UpdateConfigurationRequestsResultFields:
"""Update existing configuration requests."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "UpdateConfigurationRequestsInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return UpdateConfigurationRequestsResultFields(
field_name="updateConfigurationRequests", arguments=cleared_arguments
)
[docs]
@classmethod
def update_observations_times(
cls, input: UpdateObservationsTimesInput
) -> UpdateObservationsResultFields:
"""Updates existing observations times (execution and duration)"""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "UpdateObservationsTimesInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return UpdateObservationsResultFields(
field_name="updateObservationsTimes", arguments=cleared_arguments
)
[docs]
@classmethod
def update_programs(cls, input: UpdateProgramsInput) -> UpdateProgramsResultFields:
"""Updates existing programs."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "UpdateProgramsInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return UpdateProgramsResultFields(
field_name="updatePrograms", arguments=cleared_arguments
)
[docs]
@classmethod
def update_program_notes(
cls, input: UpdateProgramNotesInput
) -> UpdateProgramNotesResultFields:
"""Updates existing program notes."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "UpdateProgramNotesInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return UpdateProgramNotesResultFields(
field_name="updateProgramNotes", arguments=cleared_arguments
)
[docs]
@classmethod
def update_program_users(
cls, input: UpdateProgramUsersInput
) -> UpdateProgramUsersResultFields:
"""Updates existing program users."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "UpdateProgramUsersInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return UpdateProgramUsersResultFields(
field_name="updateProgramUsers", arguments=cleared_arguments
)
[docs]
@classmethod
def update_proposal(cls, input: UpdateProposalInput) -> UpdateProposalResultFields:
"""Updates an existing proposal."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "UpdateProposalInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return UpdateProposalResultFields(
field_name="updateProposal", arguments=cleared_arguments
)
[docs]
@classmethod
def update_targets(cls, input: UpdateTargetsInput) -> UpdateTargetsResultFields:
"""Updates existing targets"""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "UpdateTargetsInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return UpdateTargetsResultFields(
field_name="updateTargets", arguments=cleared_arguments
)
[docs]
@classmethod
def create_user_invitation(
cls, input: CreateUserInvitationInput
) -> CreateUserInvitationResultFields:
"""Create a user invitation."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "CreateUserInvitationInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return CreateUserInvitationResultFields(
field_name="createUserInvitation", arguments=cleared_arguments
)
[docs]
@classmethod
def redeem_user_invitation(
cls, input: RedeemUserInvitationInput
) -> RedeemUserInvitationResultFields:
"""Redeem a user invitation."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "RedeemUserInvitationInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return RedeemUserInvitationResultFields(
field_name="redeemUserInvitation", arguments=cleared_arguments
)
[docs]
@classmethod
def revoke_user_invitation(
cls, input: RevokeUserInvitationInput
) -> RevokeUserInvitationResultFields:
"""Revoke a user invitation."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "RevokeUserInvitationInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return RevokeUserInvitationResultFields(
field_name="revokeUserInvitation", arguments=cleared_arguments
)
[docs]
@classmethod
def create_configuration_request(
cls, input: CreateConfigurationRequestInput
) -> ConfigurationRequestFields:
"""Create a configuration request."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "CreateConfigurationRequestInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return ConfigurationRequestFields(
field_name="createConfigurationRequest", arguments=cleared_arguments
)
[docs]
@classmethod
def set_observation_workflow_state(
cls, input: SetObservationWorkflowStateInput
) -> ObservationWorkflowFields:
"""Sets the workflow state for the specified observation. The transition must be valid
according to the current workflow. Returns the updated workflow."""
arguments: dict[str, dict[str, Any]] = {
"input": {"type": "SetObservationWorkflowStateInput!", "value": input}
}
cleared_arguments = {
key: value for key, value in arguments.items() if value["value"] is not None
}
return ObservationWorkflowFields(
field_name="setObservationWorkflowState", arguments=cleared_arguments
)