nominal-api 0.734.0__py3-none-any.whl → 0.736.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
nominal_api/_impl.py CHANGED
@@ -8026,6 +8026,90 @@ ingest_api_AuthenticationVisitor.__qualname__ = "AuthenticationVisitor"
8026
8026
  ingest_api_AuthenticationVisitor.__module__ = "nominal_api.ingest_api"
8027
8027
 
8028
8028
 
8029
+ class ingest_api_AvroStreamOpts(ConjureBeanType):
8030
+ """Options for ingesting Avro data with the following schema. This is a "stream-like" file format to support
8031
+ use cases where a columnar/tabular format does not make sense. This closely matches Nominal's streaming
8032
+ API, making it useful for use cases where network connection drops during streaming and a backup file needs
8033
+ to be created.
8034
+
8035
+ If this schema is not used, will result in a failed ingestion.
8036
+ {
8037
+ "type": "record",
8038
+ "name": "AvroStream",
8039
+ "namespace": "io.nominal.ingest",
8040
+ "fields": [
8041
+ {
8042
+ "name": "channel",
8043
+ "type": "string",
8044
+ "doc": "Channel/series name (e.g., 'vehicle_id', 'col_1', 'temperature')",
8045
+ },
8046
+ {
8047
+ "name": "timestamps",
8048
+ "type": {"type": "array", "items": "long"},
8049
+ "doc": "Array of Unix timestamps in nanoseconds",
8050
+ },
8051
+ {
8052
+ "name": "values",
8053
+ "type": {"type": "array", "items": ["double", "string"]},
8054
+ "doc": "Array of values. Can either be doubles or strings",
8055
+ },
8056
+ {
8057
+ "name": "tags",
8058
+ "type": {"type": "map", "values": "string"},
8059
+ "default": {},
8060
+ "doc": "Key-value metadata tags",
8061
+ },
8062
+ ],
8063
+ }
8064
+ """
8065
+
8066
+ @builtins.classmethod
8067
+ def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
8068
+ return {
8069
+ 'source': ConjureFieldDefinition('source', ingest_api_IngestSource),
8070
+ 'target': ConjureFieldDefinition('target', ingest_api_DatasetIngestTarget),
8071
+ 'time_unit': ConjureFieldDefinition('timeUnit', api_TimeUnit),
8072
+ 'channel_prefix': ConjureFieldDefinition('channelPrefix', ingest_api_ChannelPrefix),
8073
+ 'additional_file_tags': ConjureFieldDefinition('additionalFileTags', OptionalTypeWrapper[Dict[api_TagName, api_TagValue]])
8074
+ }
8075
+
8076
+ __slots__: List[str] = ['_source', '_target', '_time_unit', '_channel_prefix', '_additional_file_tags']
8077
+
8078
+ def __init__(self, source: "ingest_api_IngestSource", target: "ingest_api_DatasetIngestTarget", time_unit: "api_TimeUnit", additional_file_tags: Optional[Dict[str, str]] = None, channel_prefix: Optional[str] = None) -> None:
8079
+ self._source = source
8080
+ self._target = target
8081
+ self._time_unit = time_unit
8082
+ self._channel_prefix = channel_prefix
8083
+ self._additional_file_tags = additional_file_tags
8084
+
8085
+ @builtins.property
8086
+ def source(self) -> "ingest_api_IngestSource":
8087
+ return self._source
8088
+
8089
+ @builtins.property
8090
+ def target(self) -> "ingest_api_DatasetIngestTarget":
8091
+ return self._target
8092
+
8093
+ @builtins.property
8094
+ def time_unit(self) -> "api_TimeUnit":
8095
+ return self._time_unit
8096
+
8097
+ @builtins.property
8098
+ def channel_prefix(self) -> Optional[str]:
8099
+ return self._channel_prefix
8100
+
8101
+ @builtins.property
8102
+ def additional_file_tags(self) -> Optional[Dict[str, str]]:
8103
+ """Specifies a tag set to apply to all data in the file.
8104
+ """
8105
+ return self._additional_file_tags
8106
+
8107
+
8108
+ ingest_api_AvroStreamOpts.__name__ = "AvroStreamOpts"
8109
+ ingest_api_AvroStreamOpts.__qualname__ = "AvroStreamOpts"
8110
+ ingest_api_AvroStreamOpts.__module__ = "nominal_api.ingest_api"
8111
+
8112
+
8029
8113
  class ingest_api_ChannelConfig(ConjureBeanType):
8030
8114
 
8031
8115
  @builtins.classmethod
@@ -8478,6 +8562,8 @@ class ingest_api_CsvOpts(ConjureBeanType):
8478
8562
 
8479
8563
  @builtins.property
8480
8564
  def additional_file_tags(self) -> Optional[Dict[str, str]]:
8565
+ """Specifies a tag set to apply to all data in the file.
8566
+ """
8481
8567
  return self._additional_file_tags
8482
8568
 
8483
8569
 
@@ -9745,6 +9831,7 @@ class ingest_api_IngestOptions(ConjureUnionType):
9745
9831
  _parquet: Optional["ingest_api_ParquetOpts"] = None
9746
9832
  _video: Optional["ingest_api_VideoOpts"] = None
9747
9833
  _containerized: Optional["ingest_api_ContainerizedOpts"] = None
9834
+ _avro_stream: Optional["ingest_api_AvroStreamOpts"] = None
9748
9835
 
9749
9836
  @builtins.classmethod
9750
9837
  def _options(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -9755,7 +9842,8 @@ class ingest_api_IngestOptions(ConjureUnionType):
9755
9842
  'csv': ConjureFieldDefinition('csv', ingest_api_CsvOpts),
9756
9843
  'parquet': ConjureFieldDefinition('parquet', ingest_api_ParquetOpts),
9757
9844
  'video': ConjureFieldDefinition('video', ingest_api_VideoOpts),
9758
- 'containerized': ConjureFieldDefinition('containerized', ingest_api_ContainerizedOpts)
9845
+ 'containerized': ConjureFieldDefinition('containerized', ingest_api_ContainerizedOpts),
9846
+ 'avro_stream': ConjureFieldDefinition('avroStream', ingest_api_AvroStreamOpts)
9759
9847
  }
9760
9848
 
9761
9849
  def __init__(
@@ -9767,10 +9855,11 @@ class ingest_api_IngestOptions(ConjureUnionType):
9767
9855
  parquet: Optional["ingest_api_ParquetOpts"] = None,
9768
9856
  video: Optional["ingest_api_VideoOpts"] = None,
9769
9857
  containerized: Optional["ingest_api_ContainerizedOpts"] = None,
9858
+ avro_stream: Optional["ingest_api_AvroStreamOpts"] = None,
9770
9859
  type_of_union: Optional[str] = None
9771
9860
  ) -> None:
9772
9861
  if type_of_union is None:
9773
- if (dataflash is not None) + (mcap_protobuf_timeseries is not None) + (journal_json is not None) + (csv is not None) + (parquet is not None) + (video is not None) + (containerized is not None) != 1:
9862
+ if (dataflash is not None) + (mcap_protobuf_timeseries is not None) + (journal_json is not None) + (csv is not None) + (parquet is not None) + (video is not None) + (containerized is not None) + (avro_stream is not None) != 1:
9774
9863
  raise ValueError('a union must contain a single member')
9775
9864
 
9776
9865
  if dataflash is not None:
@@ -9794,6 +9883,9 @@ class ingest_api_IngestOptions(ConjureUnionType):
9794
9883
  if containerized is not None:
9795
9884
  self._containerized = containerized
9796
9885
  self._type = 'containerized'
9886
+ if avro_stream is not None:
9887
+ self._avro_stream = avro_stream
9888
+ self._type = 'avroStream'
9797
9889
 
9798
9890
  elif type_of_union == 'dataflash':
9799
9891
  if dataflash is None:
@@ -9830,6 +9922,11 @@ class ingest_api_IngestOptions(ConjureUnionType):
9830
9922
  raise ValueError('a union value must not be None')
9831
9923
  self._containerized = containerized
9832
9924
  self._type = 'containerized'
9925
+ elif type_of_union == 'avroStream':
9926
+ if avro_stream is None:
9927
+ raise ValueError('a union value must not be None')
9928
+ self._avro_stream = avro_stream
9929
+ self._type = 'avroStream'
9833
9930
 
9834
9931
  @builtins.property
9835
9932
  def dataflash(self) -> Optional["ingest_api_DataflashOpts"]:
@@ -9859,6 +9956,10 @@ class ingest_api_IngestOptions(ConjureUnionType):
9859
9956
  def containerized(self) -> Optional["ingest_api_ContainerizedOpts"]:
9860
9957
  return self._containerized
9861
9958
 
9959
+ @builtins.property
9960
+ def avro_stream(self) -> Optional["ingest_api_AvroStreamOpts"]:
9961
+ return self._avro_stream
9962
+
9862
9963
  def accept(self, visitor) -> Any:
9863
9964
  if not isinstance(visitor, ingest_api_IngestOptionsVisitor):
9864
9965
  raise ValueError('{} is not an instance of ingest_api_IngestOptionsVisitor'.format(visitor.__class__.__name__))
@@ -9876,6 +9977,8 @@ class ingest_api_IngestOptions(ConjureUnionType):
9876
9977
  return visitor._video(self.video)
9877
9978
  if self._type == 'containerized' and self.containerized is not None:
9878
9979
  return visitor._containerized(self.containerized)
9980
+ if self._type == 'avroStream' and self.avro_stream is not None:
9981
+ return visitor._avro_stream(self.avro_stream)
9879
9982
 
9880
9983
 
9881
9984
  ingest_api_IngestOptions.__name__ = "IngestOptions"
@@ -9913,6 +10016,10 @@ class ingest_api_IngestOptionsVisitor:
9913
10016
  def _containerized(self, containerized: "ingest_api_ContainerizedOpts") -> Any:
9914
10017
  pass
9915
10018
 
10019
+ @abstractmethod
10020
+ def _avro_stream(self, avro_stream: "ingest_api_AvroStreamOpts") -> Any:
10021
+ pass
10022
+
9916
10023
 
9917
10024
  ingest_api_IngestOptionsVisitor.__name__ = "IngestOptionsVisitor"
9918
10025
  ingest_api_IngestOptionsVisitor.__qualname__ = "IngestOptionsVisitor"
@@ -10188,6 +10295,39 @@ gets migrated to this one.
10188
10295
  _decoder = ConjureDecoder()
10189
10296
  return _decoder.decode(_response.json(), ingest_api_IngestResponse, self._return_none_for_unknown_union_types)
10190
10297
 
10298
+ def rerun_ingest(self, auth_header: str, request: "ingest_api_RerunIngestRequest") -> "ingest_api_IngestResponse":
10299
+ """Triggers an ingest job using an existing ingest job RID.
10300
+ Returns the same response format as the /ingest endpoint.
10301
+ """
10302
+ _conjure_encoder = ConjureEncoder()
10303
+
10304
+ _headers: Dict[str, Any] = {
10305
+ 'Accept': 'application/json',
10306
+ 'Content-Type': 'application/json',
10307
+ 'Authorization': auth_header,
10308
+ }
10309
+
10310
+ _params: Dict[str, Any] = {
10311
+ }
10312
+
10313
+ _path_params: Dict[str, str] = {
10314
+ }
10315
+
10316
+ _json: Any = _conjure_encoder.default(request)
10317
+
10318
+ _path = '/ingest/v1/re-ingest'
10319
+ _path = _path.format(**_path_params)
10320
+
10321
+ _response: Response = self._request(
10322
+ 'POST',
10323
+ self._uri + _path,
10324
+ params=_params,
10325
+ headers=_headers,
10326
+ json=_json)
10327
+
10328
+ _decoder = ConjureDecoder()
10329
+ return _decoder.decode(_response.json(), ingest_api_IngestResponse, self._return_none_for_unknown_union_types)
10330
+
10191
10331
  def deprecated_trigger_ingest(self, auth_header: str, trigger_ingest: "ingest_api_DeprecatedTriggerIngest") -> "ingest_api_TriggeredIngest":
10192
10332
  _conjure_encoder = ConjureEncoder()
10193
10333
 
@@ -11649,6 +11789,8 @@ and archives such as .tar, .tar.gz, and .zip (must set the isArchive flag).
11649
11789
 
11650
11790
  @builtins.property
11651
11791
  def additional_file_tags(self) -> Optional[Dict[str, str]]:
11792
+ """Specifies a tag set to apply to all data in the file.
11793
+ """
11652
11794
  return self._additional_file_tags
11653
11795
 
11654
11796
  @builtins.property
@@ -11974,6 +12116,29 @@ ingest_api_RelativeTimestamp.__qualname__ = "RelativeTimestamp"
11974
12116
  ingest_api_RelativeTimestamp.__module__ = "nominal_api.ingest_api"
11975
12117
 
11976
12118
 
12119
+ class ingest_api_RerunIngestRequest(ConjureBeanType):
12120
+
12121
+ @builtins.classmethod
12122
+ def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
12123
+ return {
12124
+ 'ingest_job_rid': ConjureFieldDefinition('ingestJobRid', ingest_api_IngestJobRid)
12125
+ }
12126
+
12127
+ __slots__: List[str] = ['_ingest_job_rid']
12128
+
12129
+ def __init__(self, ingest_job_rid: str) -> None:
12130
+ self._ingest_job_rid = ingest_job_rid
12131
+
12132
+ @builtins.property
12133
+ def ingest_job_rid(self) -> str:
12134
+ return self._ingest_job_rid
12135
+
12136
+
12137
+ ingest_api_RerunIngestRequest.__name__ = "RerunIngestRequest"
12138
+ ingest_api_RerunIngestRequest.__qualname__ = "RerunIngestRequest"
12139
+ ingest_api_RerunIngestRequest.__module__ = "nominal_api.ingest_api"
12140
+
12141
+
11977
12142
  class ingest_api_S3IngestSource(ConjureBeanType):
11978
12143
 
11979
12144
  @builtins.classmethod
@@ -13407,455 +13572,1899 @@ ingest_workflow_api_FetchExtractorJobLogsRequest.__qualname__ = "FetchExtractorJ
13407
13572
  ingest_workflow_api_FetchExtractorJobLogsRequest.__module__ = "nominal_api.ingest_workflow_api"
13408
13573
 
13409
13574
 
13410
- class ingest_workflow_api_FetchExtractorJobLogsResponse(ConjureBeanType):
13575
+ class ingest_workflow_api_FetchExtractorJobLogsResponse(ConjureBeanType):
13576
+
13577
+ @builtins.classmethod
13578
+ def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
13579
+ return {
13580
+ }
13581
+
13582
+ __slots__: List[str] = []
13583
+
13584
+
13585
+
13586
+ ingest_workflow_api_FetchExtractorJobLogsResponse.__name__ = "FetchExtractorJobLogsResponse"
13587
+ ingest_workflow_api_FetchExtractorJobLogsResponse.__qualname__ = "FetchExtractorJobLogsResponse"
13588
+ ingest_workflow_api_FetchExtractorJobLogsResponse.__module__ = "nominal_api.ingest_workflow_api"
13589
+
13590
+
13591
+ class ingest_workflow_api_GetExtractorJobStateRequest(ConjureBeanType):
13592
+
13593
+ @builtins.classmethod
13594
+ def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
13595
+ return {
13596
+ 'workspace_rid': ConjureFieldDefinition('workspaceRid', api_rids_WorkspaceRid),
13597
+ 'ingest_job_uuid': ConjureFieldDefinition('ingestJobUuid', str)
13598
+ }
13599
+
13600
+ __slots__: List[str] = ['_workspace_rid', '_ingest_job_uuid']
13601
+
13602
+ def __init__(self, ingest_job_uuid: str, workspace_rid: str) -> None:
13603
+ self._workspace_rid = workspace_rid
13604
+ self._ingest_job_uuid = ingest_job_uuid
13605
+
13606
+ @builtins.property
13607
+ def workspace_rid(self) -> str:
13608
+ return self._workspace_rid
13609
+
13610
+ @builtins.property
13611
+ def ingest_job_uuid(self) -> str:
13612
+ return self._ingest_job_uuid
13613
+
13614
+
13615
+ ingest_workflow_api_GetExtractorJobStateRequest.__name__ = "GetExtractorJobStateRequest"
13616
+ ingest_workflow_api_GetExtractorJobStateRequest.__qualname__ = "GetExtractorJobStateRequest"
13617
+ ingest_workflow_api_GetExtractorJobStateRequest.__module__ = "nominal_api.ingest_workflow_api"
13618
+
13619
+
13620
+ class ingest_workflow_api_GetExtractorJobStateResponse(ConjureBeanType):
13621
+
13622
+ @builtins.classmethod
13623
+ def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
13624
+ return {
13625
+ 'state': ConjureFieldDefinition('state', ingest_workflow_api_ExtractorJobState),
13626
+ 'message': ConjureFieldDefinition('message', OptionalTypeWrapper[str])
13627
+ }
13628
+
13629
+ __slots__: List[str] = ['_state', '_message']
13630
+
13631
+ def __init__(self, state: "ingest_workflow_api_ExtractorJobState", message: Optional[str] = None) -> None:
13632
+ self._state = state
13633
+ self._message = message
13634
+
13635
+ @builtins.property
13636
+ def state(self) -> "ingest_workflow_api_ExtractorJobState":
13637
+ return self._state
13638
+
13639
+ @builtins.property
13640
+ def message(self) -> Optional[str]:
13641
+ return self._message
13642
+
13643
+
13644
+ ingest_workflow_api_GetExtractorJobStateResponse.__name__ = "GetExtractorJobStateResponse"
13645
+ ingest_workflow_api_GetExtractorJobStateResponse.__qualname__ = "GetExtractorJobStateResponse"
13646
+ ingest_workflow_api_GetExtractorJobStateResponse.__module__ = "nominal_api.ingest_workflow_api"
13647
+
13648
+
13649
+ class ingest_workflow_api_IngestDataflashRequest(ConjureBeanType):
13650
+
13651
+ @builtins.classmethod
13652
+ def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
13653
+ return {
13654
+ 'locator': ConjureFieldDefinition('locator', ingest_workflow_api_ObjectLocator)
13655
+ }
13656
+
13657
+ __slots__: List[str] = ['_locator']
13658
+
13659
+ def __init__(self, locator: "ingest_workflow_api_ObjectLocator") -> None:
13660
+ self._locator = locator
13661
+
13662
+ @builtins.property
13663
+ def locator(self) -> "ingest_workflow_api_ObjectLocator":
13664
+ return self._locator
13665
+
13666
+
13667
+ ingest_workflow_api_IngestDataflashRequest.__name__ = "IngestDataflashRequest"
13668
+ ingest_workflow_api_IngestDataflashRequest.__qualname__ = "IngestDataflashRequest"
13669
+ ingest_workflow_api_IngestDataflashRequest.__module__ = "nominal_api.ingest_workflow_api"
13670
+
13671
+
13672
+ class ingest_workflow_api_IngestDataflashResponse(ConjureBeanType):
13673
+
13674
+ @builtins.classmethod
13675
+ def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
13676
+ return {
13677
+ 'units': ConjureFieldDefinition('units', Dict[str, str]),
13678
+ 'parquet_object_locators': ConjureFieldDefinition('parquetObjectLocators', List[ingest_workflow_api_ObjectLocator]),
13679
+ 'timestamp_series_name': ConjureFieldDefinition('timestampSeriesName', str),
13680
+ 'time_unit': ConjureFieldDefinition('timeUnit', ingest_workflow_api_TimeUnitSeconds)
13681
+ }
13682
+
13683
+ __slots__: List[str] = ['_units', '_parquet_object_locators', '_timestamp_series_name', '_time_unit']
13684
+
13685
+ def __init__(self, parquet_object_locators: List["ingest_workflow_api_ObjectLocator"], time_unit: "ingest_workflow_api_TimeUnitSeconds", timestamp_series_name: str, units: Dict[str, str]) -> None:
13686
+ self._units = units
13687
+ self._parquet_object_locators = parquet_object_locators
13688
+ self._timestamp_series_name = timestamp_series_name
13689
+ self._time_unit = time_unit
13690
+
13691
+ @builtins.property
13692
+ def units(self) -> Dict[str, str]:
13693
+ return self._units
13694
+
13695
+ @builtins.property
13696
+ def parquet_object_locators(self) -> List["ingest_workflow_api_ObjectLocator"]:
13697
+ """Azure or S3-style blob locators of parquet files. Currently
13698
+ only a single file is supported, the list type is used for future compatibility.
13699
+ """
13700
+ return self._parquet_object_locators
13701
+
13702
+ @builtins.property
13703
+ def timestamp_series_name(self) -> str:
13704
+ """The name of the column in the generated parquet file that contains the timestamp.
13705
+ """
13706
+ return self._timestamp_series_name
13707
+
13708
+ @builtins.property
13709
+ def time_unit(self) -> "ingest_workflow_api_TimeUnitSeconds":
13710
+ """The unit of time for the timestamp column. Can only be seconds.
13711
+ """
13712
+ return self._time_unit
13713
+
13714
+
13715
+ ingest_workflow_api_IngestDataflashResponse.__name__ = "IngestDataflashResponse"
13716
+ ingest_workflow_api_IngestDataflashResponse.__qualname__ = "IngestDataflashResponse"
13717
+ ingest_workflow_api_IngestDataflashResponse.__module__ = "nominal_api.ingest_workflow_api"
13718
+
13719
+
13720
+ class ingest_workflow_api_IngestMcapProtobufRequest(ConjureBeanType):
13721
+
13722
+ @builtins.classmethod
13723
+ def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
13724
+ return {
13725
+ 'locator': ConjureFieldDefinition('locator', ingest_workflow_api_ObjectLocator),
13726
+ 'channels': ConjureFieldDefinition('channels', ingest_workflow_api_McapProtoChannels)
13727
+ }
13728
+
13729
+ __slots__: List[str] = ['_locator', '_channels']
13730
+
13731
+ def __init__(self, channels: "ingest_workflow_api_McapProtoChannels", locator: "ingest_workflow_api_ObjectLocator") -> None:
13732
+ self._locator = locator
13733
+ self._channels = channels
13734
+
13735
+ @builtins.property
13736
+ def locator(self) -> "ingest_workflow_api_ObjectLocator":
13737
+ return self._locator
13738
+
13739
+ @builtins.property
13740
+ def channels(self) -> "ingest_workflow_api_McapProtoChannels":
13741
+ return self._channels
13742
+
13743
+
13744
+ ingest_workflow_api_IngestMcapProtobufRequest.__name__ = "IngestMcapProtobufRequest"
13745
+ ingest_workflow_api_IngestMcapProtobufRequest.__qualname__ = "IngestMcapProtobufRequest"
13746
+ ingest_workflow_api_IngestMcapProtobufRequest.__module__ = "nominal_api.ingest_workflow_api"
13747
+
13748
+
13749
+ class ingest_workflow_api_IngestMcapProtobufResponse(ConjureBeanType):
13750
+
13751
+ @builtins.classmethod
13752
+ def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
13753
+ return {
13754
+ 'timestamp_column_name': ConjureFieldDefinition('timestampColumnName', str),
13755
+ 'parquet_object_locators': ConjureFieldDefinition('parquetObjectLocators', List[ingest_workflow_api_ObjectLocator])
13756
+ }
13757
+
13758
+ __slots__: List[str] = ['_timestamp_column_name', '_parquet_object_locators']
13759
+
13760
+ def __init__(self, parquet_object_locators: List["ingest_workflow_api_ObjectLocator"], timestamp_column_name: str) -> None:
13761
+ self._timestamp_column_name = timestamp_column_name
13762
+ self._parquet_object_locators = parquet_object_locators
13763
+
13764
+ @builtins.property
13765
+ def timestamp_column_name(self) -> str:
13766
+ return self._timestamp_column_name
13767
+
13768
+ @builtins.property
13769
+ def parquet_object_locators(self) -> List["ingest_workflow_api_ObjectLocator"]:
13770
+ """Azure or S3-style blob locators of parquet files. Currently
13771
+ only a single file is supported, the list type is used for future compatibility.
13772
+ """
13773
+ return self._parquet_object_locators
13774
+
13775
+
13776
+ ingest_workflow_api_IngestMcapProtobufResponse.__name__ = "IngestMcapProtobufResponse"
13777
+ ingest_workflow_api_IngestMcapProtobufResponse.__qualname__ = "IngestMcapProtobufResponse"
13778
+ ingest_workflow_api_IngestMcapProtobufResponse.__module__ = "nominal_api.ingest_workflow_api"
13779
+
13780
+
13781
+ class ingest_workflow_api_McapProtoChannels(ConjureUnionType):
13782
+ _all: Optional["ingest_workflow_api_Empty"] = None
13783
+ _include_topics: Optional[List[str]] = None
13784
+ _exclude_topics: Optional[List[str]] = None
13785
+
13786
+ @builtins.classmethod
13787
+ def _options(cls) -> Dict[str, ConjureFieldDefinition]:
13788
+ return {
13789
+ 'all': ConjureFieldDefinition('all', ingest_workflow_api_Empty),
13790
+ 'include_topics': ConjureFieldDefinition('includeTopics', List[ingest_workflow_api_McapTopicName]),
13791
+ 'exclude_topics': ConjureFieldDefinition('excludeTopics', List[ingest_workflow_api_McapTopicName])
13792
+ }
13793
+
13794
+ def __init__(
13795
+ self,
13796
+ all: Optional["ingest_workflow_api_Empty"] = None,
13797
+ include_topics: Optional[List[str]] = None,
13798
+ exclude_topics: Optional[List[str]] = None,
13799
+ type_of_union: Optional[str] = None
13800
+ ) -> None:
13801
+ if type_of_union is None:
13802
+ if (all is not None) + (include_topics is not None) + (exclude_topics is not None) != 1:
13803
+ raise ValueError('a union must contain a single member')
13804
+
13805
+ if all is not None:
13806
+ self._all = all
13807
+ self._type = 'all'
13808
+ if include_topics is not None:
13809
+ self._include_topics = include_topics
13810
+ self._type = 'includeTopics'
13811
+ if exclude_topics is not None:
13812
+ self._exclude_topics = exclude_topics
13813
+ self._type = 'excludeTopics'
13814
+
13815
+ elif type_of_union == 'all':
13816
+ if all is None:
13817
+ raise ValueError('a union value must not be None')
13818
+ self._all = all
13819
+ self._type = 'all'
13820
+ elif type_of_union == 'includeTopics':
13821
+ if include_topics is None:
13822
+ raise ValueError('a union value must not be None')
13823
+ self._include_topics = include_topics
13824
+ self._type = 'includeTopics'
13825
+ elif type_of_union == 'excludeTopics':
13826
+ if exclude_topics is None:
13827
+ raise ValueError('a union value must not be None')
13828
+ self._exclude_topics = exclude_topics
13829
+ self._type = 'excludeTopics'
13830
+
13831
+ @builtins.property
13832
+ def all(self) -> Optional["ingest_workflow_api_Empty"]:
13833
+ return self._all
13834
+
13835
+ @builtins.property
13836
+ def include_topics(self) -> Optional[List[str]]:
13837
+ return self._include_topics
13838
+
13839
+ @builtins.property
13840
+ def exclude_topics(self) -> Optional[List[str]]:
13841
+ return self._exclude_topics
13842
+
13843
+ def accept(self, visitor) -> Any:
13844
+ if not isinstance(visitor, ingest_workflow_api_McapProtoChannelsVisitor):
13845
+ raise ValueError('{} is not an instance of ingest_workflow_api_McapProtoChannelsVisitor'.format(visitor.__class__.__name__))
13846
+ if self._type == 'all' and self.all is not None:
13847
+ return visitor._all(self.all)
13848
+ if self._type == 'includeTopics' and self.include_topics is not None:
13849
+ return visitor._include_topics(self.include_topics)
13850
+ if self._type == 'excludeTopics' and self.exclude_topics is not None:
13851
+ return visitor._exclude_topics(self.exclude_topics)
13852
+
13853
+
13854
+ ingest_workflow_api_McapProtoChannels.__name__ = "McapProtoChannels"
13855
+ ingest_workflow_api_McapProtoChannels.__qualname__ = "McapProtoChannels"
13856
+ ingest_workflow_api_McapProtoChannels.__module__ = "nominal_api.ingest_workflow_api"
13857
+
13858
+
13859
+ class ingest_workflow_api_McapProtoChannelsVisitor:
13860
+
13861
+ @abstractmethod
13862
+ def _all(self, all: "ingest_workflow_api_Empty") -> Any:
13863
+ pass
13864
+
13865
+ @abstractmethod
13866
+ def _include_topics(self, include_topics: List[str]) -> Any:
13867
+ pass
13868
+
13869
+ @abstractmethod
13870
+ def _exclude_topics(self, exclude_topics: List[str]) -> Any:
13871
+ pass
13872
+
13873
+
13874
+ ingest_workflow_api_McapProtoChannelsVisitor.__name__ = "McapProtoChannelsVisitor"
13875
+ ingest_workflow_api_McapProtoChannelsVisitor.__qualname__ = "McapProtoChannelsVisitor"
13876
+ ingest_workflow_api_McapProtoChannelsVisitor.__module__ = "nominal_api.ingest_workflow_api"
13877
+
13878
+
13879
+ class ingest_workflow_api_MultipartUploadDetails(ConjureBeanType):
13880
+
13881
+ @builtins.classmethod
13882
+ def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
13883
+ return {
13884
+ 'upload_id': ConjureFieldDefinition('uploadId', str),
13885
+ 's3_handle': ConjureFieldDefinition('s3Handle', scout_catalog_S3Handle)
13886
+ }
13887
+
13888
+ __slots__: List[str] = ['_upload_id', '_s3_handle']
13889
+
13890
+ def __init__(self, s3_handle: "scout_catalog_S3Handle", upload_id: str) -> None:
13891
+ self._upload_id = upload_id
13892
+ self._s3_handle = s3_handle
13893
+
13894
+ @builtins.property
13895
+ def upload_id(self) -> str:
13896
+ return self._upload_id
13897
+
13898
+ @builtins.property
13899
+ def s3_handle(self) -> "scout_catalog_S3Handle":
13900
+ return self._s3_handle
13901
+
13902
+
13903
+ ingest_workflow_api_MultipartUploadDetails.__name__ = "MultipartUploadDetails"
13904
+ ingest_workflow_api_MultipartUploadDetails.__qualname__ = "MultipartUploadDetails"
13905
+ ingest_workflow_api_MultipartUploadDetails.__module__ = "nominal_api.ingest_workflow_api"
13906
+
13907
+
13908
+ class ingest_workflow_api_ObjectLocator(ConjureBeanType):
13909
+ """Locator for files in an object store.
13910
+ Clients are expected to have auth and origin/region configured independently.
13911
+ """
13912
+
13913
+ @builtins.classmethod
13914
+ def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
13915
+ return {
13916
+ 'bucket': ConjureFieldDefinition('bucket', str),
13917
+ 'object_name': ConjureFieldDefinition('objectName', str)
13918
+ }
13919
+
13920
+ __slots__: List[str] = ['_bucket', '_object_name']
13921
+
13922
+ def __init__(self, bucket: str, object_name: str) -> None:
13923
+ self._bucket = bucket
13924
+ self._object_name = object_name
13925
+
13926
+ @builtins.property
13927
+ def bucket(self) -> str:
13928
+ return self._bucket
13929
+
13930
+ @builtins.property
13931
+ def object_name(self) -> str:
13932
+ return self._object_name
13933
+
13934
+
13935
+ ingest_workflow_api_ObjectLocator.__name__ = "ObjectLocator"
13936
+ ingest_workflow_api_ObjectLocator.__qualname__ = "ObjectLocator"
13937
+ ingest_workflow_api_ObjectLocator.__module__ = "nominal_api.ingest_workflow_api"
13938
+
13939
+
13940
+ class ingest_workflow_api_PresignedFileInput(ConjureBeanType):
13941
+
13942
+ @builtins.classmethod
13943
+ def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
13944
+ return {
13945
+ 'url': ConjureFieldDefinition('url', ingest_workflow_api_PresignedUrl),
13946
+ 'input': ConjureFieldDefinition('input', ingest_workflow_api_ValidatedFileInput)
13947
+ }
13948
+
13949
+ __slots__: List[str] = ['_url', '_input']
13950
+
13951
+ def __init__(self, input: "ingest_workflow_api_ValidatedFileInput", url: str) -> None:
13952
+ self._url = url
13953
+ self._input = input
13954
+
13955
+ @builtins.property
13956
+ def url(self) -> str:
13957
+ return self._url
13958
+
13959
+ @builtins.property
13960
+ def input(self) -> "ingest_workflow_api_ValidatedFileInput":
13961
+ return self._input
13962
+
13963
+
13964
+ ingest_workflow_api_PresignedFileInput.__name__ = "PresignedFileInput"
13965
+ ingest_workflow_api_PresignedFileInput.__qualname__ = "PresignedFileInput"
13966
+ ingest_workflow_api_PresignedFileInput.__module__ = "nominal_api.ingest_workflow_api"
13967
+
13968
+
13969
+ class ingest_workflow_api_TimeUnitSeconds(ConjureEnumType):
13970
+
13971
+ SECONDS = 'SECONDS'
13972
+ '''SECONDS'''
13973
+ UNKNOWN = 'UNKNOWN'
13974
+ '''UNKNOWN'''
13975
+
13976
+ def __reduce_ex__(self, proto):
13977
+ return self.__class__, (self.name,)
13978
+
13979
+
13980
+ ingest_workflow_api_TimeUnitSeconds.__name__ = "TimeUnitSeconds"
13981
+ ingest_workflow_api_TimeUnitSeconds.__qualname__ = "TimeUnitSeconds"
13982
+ ingest_workflow_api_TimeUnitSeconds.__module__ = "nominal_api.ingest_workflow_api"
13983
+
13984
+
13985
+ class ingest_workflow_api_ValidatedFileInput(ConjureBeanType):
13986
+
13987
+ @builtins.classmethod
13988
+ def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
13989
+ return {
13990
+ 'handle': ConjureFieldDefinition('handle', scout_catalog_S3Handle),
13991
+ 'file_name': ConjureFieldDefinition('fileName', str),
13992
+ 'env_var': ConjureFieldDefinition('envVar', str)
13993
+ }
13994
+
13995
+ __slots__: List[str] = ['_handle', '_file_name', '_env_var']
13996
+
13997
+ def __init__(self, env_var: str, file_name: str, handle: "scout_catalog_S3Handle") -> None:
13998
+ self._handle = handle
13999
+ self._file_name = file_name
14000
+ self._env_var = env_var
14001
+
14002
+ @builtins.property
14003
+ def handle(self) -> "scout_catalog_S3Handle":
14004
+ """Path to the input file in S3.
14005
+ """
14006
+ return self._handle
14007
+
14008
+ @builtins.property
14009
+ def file_name(self) -> str:
14010
+ """Name of the file that will be placed on disk.
14011
+ """
14012
+ return self._file_name
14013
+
14014
+ @builtins.property
14015
+ def env_var(self) -> str:
14016
+ """Environment variable that will store the path to the file.
14017
+ """
14018
+ return self._env_var
14019
+
14020
+
14021
+ ingest_workflow_api_ValidatedFileInput.__name__ = "ValidatedFileInput"
14022
+ ingest_workflow_api_ValidatedFileInput.__qualname__ = "ValidatedFileInput"
14023
+ ingest_workflow_api_ValidatedFileInput.__module__ = "nominal_api.ingest_workflow_api"
14024
+
14025
+
14026
+ class modules_ApplyModuleRequest(ConjureBeanType):
14027
+
14028
+ @builtins.classmethod
14029
+ def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
14030
+ return {
14031
+ 'module_rid': ConjureFieldDefinition('moduleRid', modules_api_ModuleRid),
14032
+ 'asset_rid': ConjureFieldDefinition('assetRid', scout_rids_api_AssetRid)
14033
+ }
14034
+
14035
+ __slots__: List[str] = ['_module_rid', '_asset_rid']
14036
+
14037
+ def __init__(self, asset_rid: str, module_rid: str) -> None:
14038
+ self._module_rid = module_rid
14039
+ self._asset_rid = asset_rid
14040
+
14041
+ @builtins.property
14042
+ def module_rid(self) -> str:
14043
+ return self._module_rid
14044
+
14045
+ @builtins.property
14046
+ def asset_rid(self) -> str:
14047
+ return self._asset_rid
14048
+
14049
+
14050
+ modules_ApplyModuleRequest.__name__ = "ApplyModuleRequest"
14051
+ modules_ApplyModuleRequest.__qualname__ = "ApplyModuleRequest"
14052
+ modules_ApplyModuleRequest.__module__ = "nominal_api.modules"
14053
+
14054
+
14055
+ class modules_ApplyModuleResponse(ConjureBeanType):
14056
+
14057
+ @builtins.classmethod
14058
+ def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
14059
+ return {
14060
+ 'result': ConjureFieldDefinition('result', modules_ModuleApplication)
14061
+ }
14062
+
14063
+ __slots__: List[str] = ['_result']
14064
+
14065
+ def __init__(self, result: "modules_ModuleApplication") -> None:
14066
+ self._result = result
14067
+
14068
+ @builtins.property
14069
+ def result(self) -> "modules_ModuleApplication":
14070
+ return self._result
14071
+
14072
+
14073
+ modules_ApplyModuleResponse.__name__ = "ApplyModuleResponse"
14074
+ modules_ApplyModuleResponse.__qualname__ = "ApplyModuleResponse"
14075
+ modules_ApplyModuleResponse.__module__ = "nominal_api.modules"
14076
+
14077
+
14078
+ class modules_BatchArchiveModulesRequest(ConjureBeanType):
14079
+
14080
+ @builtins.classmethod
14081
+ def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
14082
+ return {
14083
+ 'requests': ConjureFieldDefinition('requests', List[modules_api_ModuleRid])
14084
+ }
14085
+
14086
+ __slots__: List[str] = ['_requests']
14087
+
14088
+ def __init__(self, requests: List[str]) -> None:
14089
+ self._requests = requests
14090
+
14091
+ @builtins.property
14092
+ def requests(self) -> List[str]:
14093
+ return self._requests
14094
+
14095
+
14096
+ modules_BatchArchiveModulesRequest.__name__ = "BatchArchiveModulesRequest"
14097
+ modules_BatchArchiveModulesRequest.__qualname__ = "BatchArchiveModulesRequest"
14098
+ modules_BatchArchiveModulesRequest.__module__ = "nominal_api.modules"
14099
+
14100
+
14101
+ class modules_BatchArchiveModulesResponse(ConjureBeanType):
14102
+
14103
+ @builtins.classmethod
14104
+ def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
14105
+ return {
14106
+ 'archived_module_rids': ConjureFieldDefinition('archivedModuleRids', List[modules_api_ModuleRid])
14107
+ }
14108
+
14109
+ __slots__: List[str] = ['_archived_module_rids']
14110
+
14111
+ def __init__(self, archived_module_rids: List[str]) -> None:
14112
+ self._archived_module_rids = archived_module_rids
14113
+
14114
+ @builtins.property
14115
+ def archived_module_rids(self) -> List[str]:
14116
+ return self._archived_module_rids
14117
+
14118
+
14119
+ modules_BatchArchiveModulesResponse.__name__ = "BatchArchiveModulesResponse"
14120
+ modules_BatchArchiveModulesResponse.__qualname__ = "BatchArchiveModulesResponse"
14121
+ modules_BatchArchiveModulesResponse.__module__ = "nominal_api.modules"
14122
+
14123
+
14124
+ class modules_BatchGetModulesRequest(ConjureBeanType):
14125
+
14126
+ @builtins.classmethod
14127
+ def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
14128
+ return {
14129
+ 'requests': ConjureFieldDefinition('requests', List[modules_GetModuleRequest])
14130
+ }
14131
+
14132
+ __slots__: List[str] = ['_requests']
14133
+
14134
+ def __init__(self, requests: List["modules_GetModuleRequest"]) -> None:
14135
+ self._requests = requests
14136
+
14137
+ @builtins.property
14138
+ def requests(self) -> List["modules_GetModuleRequest"]:
14139
+ return self._requests
14140
+
14141
+
14142
+ modules_BatchGetModulesRequest.__name__ = "BatchGetModulesRequest"
14143
+ modules_BatchGetModulesRequest.__qualname__ = "BatchGetModulesRequest"
14144
+ modules_BatchGetModulesRequest.__module__ = "nominal_api.modules"
14145
+
14146
+
14147
+ class modules_BatchUnarchiveModulesRequest(ConjureBeanType):
14148
+
14149
+ @builtins.classmethod
14150
+ def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
14151
+ return {
14152
+ 'requests': ConjureFieldDefinition('requests', List[modules_api_ModuleRid])
14153
+ }
14154
+
14155
+ __slots__: List[str] = ['_requests']
14156
+
14157
+ def __init__(self, requests: List[str]) -> None:
14158
+ self._requests = requests
14159
+
14160
+ @builtins.property
14161
+ def requests(self) -> List[str]:
14162
+ return self._requests
14163
+
14164
+
14165
+ modules_BatchUnarchiveModulesRequest.__name__ = "BatchUnarchiveModulesRequest"
14166
+ modules_BatchUnarchiveModulesRequest.__qualname__ = "BatchUnarchiveModulesRequest"
14167
+ modules_BatchUnarchiveModulesRequest.__module__ = "nominal_api.modules"
14168
+
14169
+
14170
+ class modules_BatchUnarchiveModulesResponse(ConjureBeanType):
14171
+
14172
+ @builtins.classmethod
14173
+ def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
14174
+ return {
14175
+ 'unarchived_module_rids': ConjureFieldDefinition('unarchivedModuleRids', List[modules_api_ModuleRid])
14176
+ }
14177
+
14178
+ __slots__: List[str] = ['_unarchived_module_rids']
14179
+
14180
+ def __init__(self, unarchived_module_rids: List[str]) -> None:
14181
+ self._unarchived_module_rids = unarchived_module_rids
14182
+
14183
+ @builtins.property
14184
+ def unarchived_module_rids(self) -> List[str]:
14185
+ return self._unarchived_module_rids
14186
+
14187
+
14188
+ modules_BatchUnarchiveModulesResponse.__name__ = "BatchUnarchiveModulesResponse"
14189
+ modules_BatchUnarchiveModulesResponse.__qualname__ = "BatchUnarchiveModulesResponse"
14190
+ modules_BatchUnarchiveModulesResponse.__module__ = "nominal_api.modules"
14191
+
14192
+
14193
+ class modules_CreateOrUpdateModuleRequest(ConjureBeanType):
14194
+
14195
+ @builtins.classmethod
14196
+ def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
14197
+ return {
14198
+ 'name': ConjureFieldDefinition('name', str),
14199
+ 'description': ConjureFieldDefinition('description', str),
14200
+ 'definition': ConjureFieldDefinition('definition', modules_ModuleVersionDefinition)
14201
+ }
14202
+
14203
+ __slots__: List[str] = ['_name', '_description', '_definition']
14204
+
14205
+ def __init__(self, definition: "modules_ModuleVersionDefinition", description: str, name: str) -> None:
14206
+ self._name = name
14207
+ self._description = description
14208
+ self._definition = definition
14209
+
14210
+ @builtins.property
14211
+ def name(self) -> str:
14212
+ """The name of the module. This should be unique to the module in the current workspace.
14213
+ """
14214
+ return self._name
14215
+
14216
+ @builtins.property
14217
+ def description(self) -> str:
14218
+ return self._description
14219
+
14220
+ @builtins.property
14221
+ def definition(self) -> "modules_ModuleVersionDefinition":
14222
+ return self._definition
14223
+
14224
+
14225
+ modules_CreateOrUpdateModuleRequest.__name__ = "CreateOrUpdateModuleRequest"
14226
+ modules_CreateOrUpdateModuleRequest.__qualname__ = "CreateOrUpdateModuleRequest"
14227
+ modules_CreateOrUpdateModuleRequest.__module__ = "nominal_api.modules"
14228
+
14229
+
14230
+ class modules_Function(ConjureBeanType):
14231
+
14232
+ @builtins.classmethod
14233
+ def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
14234
+ return {
14235
+ 'name': ConjureFieldDefinition('name', str),
14236
+ 'description': ConjureFieldDefinition('description', str),
14237
+ 'parameters': ConjureFieldDefinition('parameters', List[modules_FunctionParameter]),
14238
+ 'function_node': ConjureFieldDefinition('functionNode', modules_FunctionNode),
14239
+ 'is_exported': ConjureFieldDefinition('isExported', bool)
14240
+ }
14241
+
14242
+ __slots__: List[str] = ['_name', '_description', '_parameters', '_function_node', '_is_exported']
14243
+
14244
+ def __init__(self, description: str, function_node: "modules_FunctionNode", is_exported: bool, name: str, parameters: List["modules_FunctionParameter"]) -> None:
14245
+ self._name = name
14246
+ self._description = description
14247
+ self._parameters = parameters
14248
+ self._function_node = function_node
14249
+ self._is_exported = is_exported
14250
+
14251
+ @builtins.property
14252
+ def name(self) -> str:
14253
+ """The name of the function. This should be unique to the function in the current module.
14254
+ """
14255
+ return self._name
14256
+
14257
+ @builtins.property
14258
+ def description(self) -> str:
14259
+ return self._description
14260
+
14261
+ @builtins.property
14262
+ def parameters(self) -> List["modules_FunctionParameter"]:
14263
+ return self._parameters
14264
+
14265
+ @builtins.property
14266
+ def function_node(self) -> "modules_FunctionNode":
14267
+ return self._function_node
14268
+
14269
+ @builtins.property
14270
+ def is_exported(self) -> bool:
14271
+ return self._is_exported
14272
+
14273
+
14274
+ modules_Function.__name__ = "Function"
14275
+ modules_Function.__qualname__ = "Function"
14276
+ modules_Function.__module__ = "nominal_api.modules"
14277
+
14278
+
14279
+ class modules_FunctionNode(ConjureUnionType):
14280
+ _enum: Optional["scout_compute_api_EnumSeries"] = None
14281
+ _numeric: Optional["scout_compute_api_NumericSeries"] = None
14282
+ _ranges: Optional["scout_compute_api_RangeSeries"] = None
14283
+
14284
+ @builtins.classmethod
14285
+ def _options(cls) -> Dict[str, ConjureFieldDefinition]:
14286
+ return {
14287
+ 'enum': ConjureFieldDefinition('enum', scout_compute_api_EnumSeries),
14288
+ 'numeric': ConjureFieldDefinition('numeric', scout_compute_api_NumericSeries),
14289
+ 'ranges': ConjureFieldDefinition('ranges', scout_compute_api_RangeSeries)
14290
+ }
14291
+
14292
+ def __init__(
14293
+ self,
14294
+ enum: Optional["scout_compute_api_EnumSeries"] = None,
14295
+ numeric: Optional["scout_compute_api_NumericSeries"] = None,
14296
+ ranges: Optional["scout_compute_api_RangeSeries"] = None,
14297
+ type_of_union: Optional[str] = None
14298
+ ) -> None:
14299
+ if type_of_union is None:
14300
+ if (enum is not None) + (numeric is not None) + (ranges is not None) != 1:
14301
+ raise ValueError('a union must contain a single member')
14302
+
14303
+ if enum is not None:
14304
+ self._enum = enum
14305
+ self._type = 'enum'
14306
+ if numeric is not None:
14307
+ self._numeric = numeric
14308
+ self._type = 'numeric'
14309
+ if ranges is not None:
14310
+ self._ranges = ranges
14311
+ self._type = 'ranges'
14312
+
14313
+ elif type_of_union == 'enum':
14314
+ if enum is None:
14315
+ raise ValueError('a union value must not be None')
14316
+ self._enum = enum
14317
+ self._type = 'enum'
14318
+ elif type_of_union == 'numeric':
14319
+ if numeric is None:
14320
+ raise ValueError('a union value must not be None')
14321
+ self._numeric = numeric
14322
+ self._type = 'numeric'
14323
+ elif type_of_union == 'ranges':
14324
+ if ranges is None:
14325
+ raise ValueError('a union value must not be None')
14326
+ self._ranges = ranges
14327
+ self._type = 'ranges'
14328
+
14329
+ @builtins.property
14330
+ def enum(self) -> Optional["scout_compute_api_EnumSeries"]:
14331
+ return self._enum
14332
+
14333
+ @builtins.property
14334
+ def numeric(self) -> Optional["scout_compute_api_NumericSeries"]:
14335
+ return self._numeric
14336
+
14337
+ @builtins.property
14338
+ def ranges(self) -> Optional["scout_compute_api_RangeSeries"]:
14339
+ return self._ranges
14340
+
14341
+ def accept(self, visitor) -> Any:
14342
+ if not isinstance(visitor, modules_FunctionNodeVisitor):
14343
+ raise ValueError('{} is not an instance of modules_FunctionNodeVisitor'.format(visitor.__class__.__name__))
14344
+ if self._type == 'enum' and self.enum is not None:
14345
+ return visitor._enum(self.enum)
14346
+ if self._type == 'numeric' and self.numeric is not None:
14347
+ return visitor._numeric(self.numeric)
14348
+ if self._type == 'ranges' and self.ranges is not None:
14349
+ return visitor._ranges(self.ranges)
14350
+
14351
+
14352
+ modules_FunctionNode.__name__ = "FunctionNode"
14353
+ modules_FunctionNode.__qualname__ = "FunctionNode"
14354
+ modules_FunctionNode.__module__ = "nominal_api.modules"
14355
+
14356
+
14357
+ class modules_FunctionNodeVisitor:
14358
+
14359
+ @abstractmethod
14360
+ def _enum(self, enum: "scout_compute_api_EnumSeries") -> Any:
14361
+ pass
14362
+
14363
+ @abstractmethod
14364
+ def _numeric(self, numeric: "scout_compute_api_NumericSeries") -> Any:
14365
+ pass
14366
+
14367
+ @abstractmethod
14368
+ def _ranges(self, ranges: "scout_compute_api_RangeSeries") -> Any:
14369
+ pass
14370
+
14371
+
14372
+ modules_FunctionNodeVisitor.__name__ = "FunctionNodeVisitor"
14373
+ modules_FunctionNodeVisitor.__qualname__ = "FunctionNodeVisitor"
14374
+ modules_FunctionNodeVisitor.__module__ = "nominal_api.modules"
14375
+
14376
+
14377
+ class modules_FunctionParameter(ConjureBeanType):
14378
+
14379
+ @builtins.classmethod
14380
+ def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
14381
+ return {
14382
+ 'name': ConjureFieldDefinition('name', str),
14383
+ 'type': ConjureFieldDefinition('type', modules_ValueType),
14384
+ 'default_value': ConjureFieldDefinition('defaultValue', OptionalTypeWrapper[scout_compute_api_VariableName])
14385
+ }
14386
+
14387
+ __slots__: List[str] = ['_name', '_type', '_default_value']
14388
+
14389
+ def __init__(self, name: str, type: "modules_ValueType", default_value: Optional[str] = None) -> None:
14390
+ self._name = name
14391
+ self._type = type
14392
+ self._default_value = default_value
14393
+
14394
+ @builtins.property
14395
+ def name(self) -> str:
14396
+ return self._name
14397
+
14398
+ @builtins.property
14399
+ def type(self) -> "modules_ValueType":
14400
+ return self._type
14401
+
14402
+ @builtins.property
14403
+ def default_value(self) -> Optional[str]:
14404
+ """This must reference a variable in its parent module's `defaultVariables`.
14405
+ """
14406
+ return self._default_value
14407
+
14408
+
14409
+ modules_FunctionParameter.__name__ = "FunctionParameter"
14410
+ modules_FunctionParameter.__qualname__ = "FunctionParameter"
14411
+ modules_FunctionParameter.__module__ = "nominal_api.modules"
14412
+
14413
+
14414
+ class modules_GetModuleRequest(ConjureBeanType):
14415
+
14416
+ @builtins.classmethod
14417
+ def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
14418
+ return {
14419
+ 'module_rid': ConjureFieldDefinition('moduleRid', modules_api_ModuleRid)
14420
+ }
14421
+
14422
+ __slots__: List[str] = ['_module_rid']
14423
+
14424
+ def __init__(self, module_rid: str) -> None:
14425
+ self._module_rid = module_rid
14426
+
14427
+ @builtins.property
14428
+ def module_rid(self) -> str:
14429
+ return self._module_rid
14430
+
14431
+
14432
+ modules_GetModuleRequest.__name__ = "GetModuleRequest"
14433
+ modules_GetModuleRequest.__qualname__ = "GetModuleRequest"
14434
+ modules_GetModuleRequest.__module__ = "nominal_api.modules"
14435
+
14436
+
14437
+ class modules_Module(ConjureBeanType):
14438
+
14439
+ @builtins.classmethod
14440
+ def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
14441
+ return {
14442
+ 'metadata': ConjureFieldDefinition('metadata', modules_ModuleMetadata),
14443
+ 'definition': ConjureFieldDefinition('definition', modules_ModuleVersionDefinition)
14444
+ }
14445
+
14446
+ __slots__: List[str] = ['_metadata', '_definition']
14447
+
14448
+ def __init__(self, definition: "modules_ModuleVersionDefinition", metadata: "modules_ModuleMetadata") -> None:
14449
+ self._metadata = metadata
14450
+ self._definition = definition
14451
+
14452
+ @builtins.property
14453
+ def metadata(self) -> "modules_ModuleMetadata":
14454
+ return self._metadata
14455
+
14456
+ @builtins.property
14457
+ def definition(self) -> "modules_ModuleVersionDefinition":
14458
+ return self._definition
14459
+
14460
+
14461
+ modules_Module.__name__ = "Module"
14462
+ modules_Module.__qualname__ = "Module"
14463
+ modules_Module.__module__ = "nominal_api.modules"
14464
+
14465
+
14466
+ class modules_ModuleApplication(ConjureBeanType):
14467
+
14468
+ @builtins.classmethod
14469
+ def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
14470
+ return {
14471
+ 'module': ConjureFieldDefinition('module', modules_ModuleRef),
14472
+ 'asset_rid': ConjureFieldDefinition('assetRid', scout_rids_api_AssetRid),
14473
+ 'applied_at': ConjureFieldDefinition('appliedAt', str),
14474
+ 'applied_by': ConjureFieldDefinition('appliedBy', scout_rids_api_UserRid)
14475
+ }
14476
+
14477
+ __slots__: List[str] = ['_module', '_asset_rid', '_applied_at', '_applied_by']
14478
+
14479
+ def __init__(self, applied_at: str, applied_by: str, asset_rid: str, module: "modules_ModuleRef") -> None:
14480
+ self._module = module
14481
+ self._asset_rid = asset_rid
14482
+ self._applied_at = applied_at
14483
+ self._applied_by = applied_by
14484
+
14485
+ @builtins.property
14486
+ def module(self) -> "modules_ModuleRef":
14487
+ return self._module
14488
+
14489
+ @builtins.property
14490
+ def asset_rid(self) -> str:
14491
+ return self._asset_rid
14492
+
14493
+ @builtins.property
14494
+ def applied_at(self) -> str:
14495
+ return self._applied_at
14496
+
14497
+ @builtins.property
14498
+ def applied_by(self) -> str:
14499
+ return self._applied_by
14500
+
14501
+
14502
+ modules_ModuleApplication.__name__ = "ModuleApplication"
14503
+ modules_ModuleApplication.__qualname__ = "ModuleApplication"
14504
+ modules_ModuleApplication.__module__ = "nominal_api.modules"
14505
+
14506
+
14507
+ class modules_ModuleMetadata(ConjureBeanType):
14508
+
14509
+ @builtins.classmethod
14510
+ def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
14511
+ return {
14512
+ 'rid': ConjureFieldDefinition('rid', modules_api_ModuleRid),
14513
+ 'name': ConjureFieldDefinition('name', str),
14514
+ 'description': ConjureFieldDefinition('description', str),
14515
+ 'created_by': ConjureFieldDefinition('createdBy', scout_rids_api_UserRid),
14516
+ 'created_at': ConjureFieldDefinition('createdAt', str),
14517
+ 'archived_at': ConjureFieldDefinition('archivedAt', OptionalTypeWrapper[str])
14518
+ }
14519
+
14520
+ __slots__: List[str] = ['_rid', '_name', '_description', '_created_by', '_created_at', '_archived_at']
14521
+
14522
+ def __init__(self, created_at: str, created_by: str, description: str, name: str, rid: str, archived_at: Optional[str] = None) -> None:
14523
+ self._rid = rid
14524
+ self._name = name
14525
+ self._description = description
14526
+ self._created_by = created_by
14527
+ self._created_at = created_at
14528
+ self._archived_at = archived_at
14529
+
14530
+ @builtins.property
14531
+ def rid(self) -> str:
14532
+ return self._rid
14533
+
14534
+ @builtins.property
14535
+ def name(self) -> str:
14536
+ """The name of the module. This is unique to the module in the current workspace.
14537
+ """
14538
+ return self._name
14539
+
14540
+ @builtins.property
14541
+ def description(self) -> str:
14542
+ return self._description
14543
+
14544
+ @builtins.property
14545
+ def created_by(self) -> str:
14546
+ return self._created_by
14547
+
14548
+ @builtins.property
14549
+ def created_at(self) -> str:
14550
+ return self._created_at
14551
+
14552
+ @builtins.property
14553
+ def archived_at(self) -> Optional[str]:
14554
+ """The time at which the module was archived. Unset if the module is not archived.
14555
+ """
14556
+ return self._archived_at
14557
+
14558
+
14559
+ modules_ModuleMetadata.__name__ = "ModuleMetadata"
14560
+ modules_ModuleMetadata.__qualname__ = "ModuleMetadata"
14561
+ modules_ModuleMetadata.__module__ = "nominal_api.modules"
14562
+
14563
+
14564
+ class modules_ModuleParameter(ConjureBeanType):
14565
+
14566
+ @builtins.classmethod
14567
+ def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
14568
+ return {
14569
+ 'name': ConjureFieldDefinition('name', str),
14570
+ 'type': ConjureFieldDefinition('type', modules_ValueType)
14571
+ }
14572
+
14573
+ __slots__: List[str] = ['_name', '_type']
14574
+
14575
+ def __init__(self, name: str, type: "modules_ValueType") -> None:
14576
+ self._name = name
14577
+ self._type = type
14578
+
14579
+ @builtins.property
14580
+ def name(self) -> str:
14581
+ return self._name
14582
+
14583
+ @builtins.property
14584
+ def type(self) -> "modules_ValueType":
14585
+ return self._type
14586
+
14587
+
14588
+ modules_ModuleParameter.__name__ = "ModuleParameter"
14589
+ modules_ModuleParameter.__qualname__ = "ModuleParameter"
14590
+ modules_ModuleParameter.__module__ = "nominal_api.modules"
14591
+
14592
+
14593
+ class modules_ModuleRef(ConjureBeanType):
14594
+
14595
+ @builtins.classmethod
14596
+ def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
14597
+ return {
14598
+ 'rid': ConjureFieldDefinition('rid', modules_api_ModuleRid)
14599
+ }
14600
+
14601
+ __slots__: List[str] = ['_rid']
14602
+
14603
+ def __init__(self, rid: str) -> None:
14604
+ self._rid = rid
14605
+
14606
+ @builtins.property
14607
+ def rid(self) -> str:
14608
+ return self._rid
14609
+
14610
+
14611
+ modules_ModuleRef.__name__ = "ModuleRef"
14612
+ modules_ModuleRef.__qualname__ = "ModuleRef"
14613
+ modules_ModuleRef.__module__ = "nominal_api.modules"
14614
+
14615
+
14616
+ class modules_ModuleSummary(ConjureBeanType):
14617
+
14618
+ @builtins.classmethod
14619
+ def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
14620
+ return {
14621
+ 'metadata': ConjureFieldDefinition('metadata', modules_ModuleMetadata),
14622
+ 'latest': ConjureFieldDefinition('latest', modules_ModuleVersionMetadata)
14623
+ }
14624
+
14625
+ __slots__: List[str] = ['_metadata', '_latest']
14626
+
14627
+ def __init__(self, latest: "modules_ModuleVersionMetadata", metadata: "modules_ModuleMetadata") -> None:
14628
+ self._metadata = metadata
14629
+ self._latest = latest
14630
+
14631
+ @builtins.property
14632
+ def metadata(self) -> "modules_ModuleMetadata":
14633
+ return self._metadata
14634
+
14635
+ @builtins.property
14636
+ def latest(self) -> "modules_ModuleVersionMetadata":
14637
+ return self._latest
14638
+
14639
+
14640
+ modules_ModuleSummary.__name__ = "ModuleSummary"
14641
+ modules_ModuleSummary.__qualname__ = "ModuleSummary"
14642
+ modules_ModuleSummary.__module__ = "nominal_api.modules"
14643
+
14644
+
14645
+ class modules_ModuleVersionDefinition(ConjureBeanType):
14646
+
14647
+ @builtins.classmethod
14648
+ def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
14649
+ return {
14650
+ 'parameters': ConjureFieldDefinition('parameters', List[modules_ModuleParameter]),
14651
+ 'default_variables': ConjureFieldDefinition('defaultVariables', List[modules_TypedModuleVariable]),
14652
+ 'functions': ConjureFieldDefinition('functions', List[modules_Function])
14653
+ }
14654
+
14655
+ __slots__: List[str] = ['_parameters', '_default_variables', '_functions']
14656
+
14657
+ def __init__(self, default_variables: List["modules_TypedModuleVariable"], functions: List["modules_Function"], parameters: List["modules_ModuleParameter"]) -> None:
14658
+ self._parameters = parameters
14659
+ self._default_variables = default_variables
14660
+ self._functions = functions
14661
+
14662
+ @builtins.property
14663
+ def parameters(self) -> List["modules_ModuleParameter"]:
14664
+ """Specifies the parameters the module accepts when applying it. Limited to 100.
14665
+ """
14666
+ return self._parameters
14667
+
14668
+ @builtins.property
14669
+ def default_variables(self) -> List["modules_TypedModuleVariable"]:
14670
+ """Specifies the variables that are present within the module to be used by other variables or functions.
14671
+ Limited to 100.
14672
+ """
14673
+ return self._default_variables
14674
+
14675
+ @builtins.property
14676
+ def functions(self) -> List["modules_Function"]:
14677
+ """The list of functions that resolve to derived series that appear in channel search after applying to an
14678
+ asset. Limited to 100.
14679
+ """
14680
+ return self._functions
14681
+
14682
+
14683
+ modules_ModuleVersionDefinition.__name__ = "ModuleVersionDefinition"
14684
+ modules_ModuleVersionDefinition.__qualname__ = "ModuleVersionDefinition"
14685
+ modules_ModuleVersionDefinition.__module__ = "nominal_api.modules"
14686
+
14687
+
14688
+ class modules_ModuleVersionMetadata(ConjureBeanType):
14689
+
14690
+ @builtins.classmethod
14691
+ def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
14692
+ return {
14693
+ 'created_by': ConjureFieldDefinition('createdBy', scout_rids_api_UserRid),
14694
+ 'created_at': ConjureFieldDefinition('createdAt', str)
14695
+ }
14696
+
14697
+ __slots__: List[str] = ['_created_by', '_created_at']
14698
+
14699
+ def __init__(self, created_at: str, created_by: str) -> None:
14700
+ self._created_by = created_by
14701
+ self._created_at = created_at
14702
+
14703
+ @builtins.property
14704
+ def created_by(self) -> str:
14705
+ return self._created_by
14706
+
14707
+ @builtins.property
14708
+ def created_at(self) -> str:
14709
+ return self._created_at
14710
+
14711
+
14712
+ modules_ModuleVersionMetadata.__name__ = "ModuleVersionMetadata"
14713
+ modules_ModuleVersionMetadata.__qualname__ = "ModuleVersionMetadata"
14714
+ modules_ModuleVersionMetadata.__module__ = "nominal_api.modules"
14715
+
14716
+
14717
+ class modules_ModulesService(Service):
14718
+ """Modules define collections of compute logic that can be shared and used across different contexts by applying them
14719
+ to assets. The Modules Service provides the api for managing these collections and using them.
14720
+ """
14721
+
14722
+ def create_module(self, auth_header: str, request: "modules_CreateOrUpdateModuleRequest") -> "modules_Module":
14723
+ """Create a new module.
14724
+ """
14725
+ _conjure_encoder = ConjureEncoder()
14726
+
14727
+ _headers: Dict[str, Any] = {
14728
+ 'Accept': 'application/json',
14729
+ 'Content-Type': 'application/json',
14730
+ 'Authorization': auth_header,
14731
+ }
14732
+
14733
+ _params: Dict[str, Any] = {
14734
+ }
14735
+
14736
+ _path_params: Dict[str, str] = {
14737
+ }
14738
+
14739
+ _json: Any = _conjure_encoder.default(request)
14740
+
14741
+ _path = '/scout/v2/modules'
14742
+ _path = _path.format(**_path_params)
14743
+
14744
+ _response: Response = self._request(
14745
+ 'POST',
14746
+ self._uri + _path,
14747
+ params=_params,
14748
+ headers=_headers,
14749
+ json=_json)
14750
+
14751
+ _decoder = ConjureDecoder()
14752
+ return _decoder.decode(_response.json(), modules_Module, self._return_none_for_unknown_union_types)
14753
+
14754
+ def update_module(self, auth_header: str, module_rid: str, request: "modules_CreateOrUpdateModuleRequest") -> "modules_Module":
14755
+ """Update an existing module.
14756
+ """
14757
+ _conjure_encoder = ConjureEncoder()
14758
+
14759
+ _headers: Dict[str, Any] = {
14760
+ 'Accept': 'application/json',
14761
+ 'Content-Type': 'application/json',
14762
+ 'Authorization': auth_header,
14763
+ }
14764
+
14765
+ _params: Dict[str, Any] = {
14766
+ }
14767
+
14768
+ _path_params: Dict[str, str] = {
14769
+ 'moduleRid': quote(str(_conjure_encoder.default(module_rid)), safe=''),
14770
+ }
14771
+
14772
+ _json: Any = _conjure_encoder.default(request)
14773
+
14774
+ _path = '/scout/v2/modules/{moduleRid}'
14775
+ _path = _path.format(**_path_params)
14776
+
14777
+ _response: Response = self._request(
14778
+ 'PUT',
14779
+ self._uri + _path,
14780
+ params=_params,
14781
+ headers=_headers,
14782
+ json=_json)
14783
+
14784
+ _decoder = ConjureDecoder()
14785
+ return _decoder.decode(_response.json(), modules_Module, self._return_none_for_unknown_union_types)
14786
+
14787
+ def batch_get_modules(self, auth_header: str, request: "modules_BatchGetModulesRequest") -> List["modules_Module"]:
14788
+ """Get a list of modules by their RIDs and version specifiers if provided.
14789
+ """
14790
+ _conjure_encoder = ConjureEncoder()
14791
+
14792
+ _headers: Dict[str, Any] = {
14793
+ 'Accept': 'application/json',
14794
+ 'Content-Type': 'application/json',
14795
+ 'Authorization': auth_header,
14796
+ }
14797
+
14798
+ _params: Dict[str, Any] = {
14799
+ }
14800
+
14801
+ _path_params: Dict[str, str] = {
14802
+ }
14803
+
14804
+ _json: Any = _conjure_encoder.default(request)
14805
+
14806
+ _path = '/scout/v2/modules/batch-get'
14807
+ _path = _path.format(**_path_params)
14808
+
14809
+ _response: Response = self._request(
14810
+ 'POST',
14811
+ self._uri + _path,
14812
+ params=_params,
14813
+ headers=_headers,
14814
+ json=_json)
14815
+
14816
+ _decoder = ConjureDecoder()
14817
+ return _decoder.decode(_response.json(), List[modules_Module], self._return_none_for_unknown_union_types)
14818
+
14819
+ def search_modules(self, auth_header: str, request: "modules_SearchModulesRequest") -> "modules_SearchModulesResponse":
14820
+ """Search for modules.
14821
+ """
14822
+ _conjure_encoder = ConjureEncoder()
14823
+
14824
+ _headers: Dict[str, Any] = {
14825
+ 'Accept': 'application/json',
14826
+ 'Content-Type': 'application/json',
14827
+ 'Authorization': auth_header,
14828
+ }
14829
+
14830
+ _params: Dict[str, Any] = {
14831
+ }
14832
+
14833
+ _path_params: Dict[str, str] = {
14834
+ }
14835
+
14836
+ _json: Any = _conjure_encoder.default(request)
14837
+
14838
+ _path = '/scout/v2/modules/search'
14839
+ _path = _path.format(**_path_params)
14840
+
14841
+ _response: Response = self._request(
14842
+ 'POST',
14843
+ self._uri + _path,
14844
+ params=_params,
14845
+ headers=_headers,
14846
+ json=_json)
14847
+
14848
+ _decoder = ConjureDecoder()
14849
+ return _decoder.decode(_response.json(), modules_SearchModulesResponse, self._return_none_for_unknown_union_types)
14850
+
14851
+ def batch_archive_modules(self, auth_header: str, request: "modules_BatchArchiveModulesRequest") -> "modules_BatchArchiveModulesResponse":
14852
+ """Archive a set of modules.
14853
+ """
14854
+ _conjure_encoder = ConjureEncoder()
14855
+
14856
+ _headers: Dict[str, Any] = {
14857
+ 'Accept': 'application/json',
14858
+ 'Content-Type': 'application/json',
14859
+ 'Authorization': auth_header,
14860
+ }
14861
+
14862
+ _params: Dict[str, Any] = {
14863
+ }
14864
+
14865
+ _path_params: Dict[str, str] = {
14866
+ }
14867
+
14868
+ _json: Any = _conjure_encoder.default(request)
14869
+
14870
+ _path = '/scout/v2/modules/archive'
14871
+ _path = _path.format(**_path_params)
14872
+
14873
+ _response: Response = self._request(
14874
+ 'POST',
14875
+ self._uri + _path,
14876
+ params=_params,
14877
+ headers=_headers,
14878
+ json=_json)
14879
+
14880
+ _decoder = ConjureDecoder()
14881
+ return _decoder.decode(_response.json(), modules_BatchArchiveModulesResponse, self._return_none_for_unknown_union_types)
14882
+
14883
+ def batch_unarchive_modules(self, auth_header: str, request: "modules_BatchUnarchiveModulesRequest") -> "modules_BatchUnarchiveModulesResponse":
14884
+ """Unarchive a set of modules.
14885
+ """
14886
+ _conjure_encoder = ConjureEncoder()
13411
14887
 
13412
- @builtins.classmethod
13413
- def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
13414
- return {
14888
+ _headers: Dict[str, Any] = {
14889
+ 'Accept': 'application/json',
14890
+ 'Content-Type': 'application/json',
14891
+ 'Authorization': auth_header,
13415
14892
  }
13416
14893
 
13417
- __slots__: List[str] = []
14894
+ _params: Dict[str, Any] = {
14895
+ }
13418
14896
 
14897
+ _path_params: Dict[str, str] = {
14898
+ }
13419
14899
 
14900
+ _json: Any = _conjure_encoder.default(request)
13420
14901
 
13421
- ingest_workflow_api_FetchExtractorJobLogsResponse.__name__ = "FetchExtractorJobLogsResponse"
13422
- ingest_workflow_api_FetchExtractorJobLogsResponse.__qualname__ = "FetchExtractorJobLogsResponse"
13423
- ingest_workflow_api_FetchExtractorJobLogsResponse.__module__ = "nominal_api.ingest_workflow_api"
14902
+ _path = '/scout/v2/modules/unarchive'
14903
+ _path = _path.format(**_path_params)
13424
14904
 
14905
+ _response: Response = self._request(
14906
+ 'POST',
14907
+ self._uri + _path,
14908
+ params=_params,
14909
+ headers=_headers,
14910
+ json=_json)
13425
14911
 
13426
- class ingest_workflow_api_GetExtractorJobStateRequest(ConjureBeanType):
14912
+ _decoder = ConjureDecoder()
14913
+ return _decoder.decode(_response.json(), modules_BatchUnarchiveModulesResponse, self._return_none_for_unknown_union_types)
13427
14914
 
13428
- @builtins.classmethod
13429
- def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
13430
- return {
13431
- 'workspace_rid': ConjureFieldDefinition('workspaceRid', api_rids_WorkspaceRid),
13432
- 'ingest_job_uuid': ConjureFieldDefinition('ingestJobUuid', str)
14915
+ def apply_module(self, auth_header: str, request: "modules_ApplyModuleRequest") -> "modules_ApplyModuleResponse":
14916
+ """Apply a module to an asset.
14917
+ """
14918
+ _conjure_encoder = ConjureEncoder()
14919
+
14920
+ _headers: Dict[str, Any] = {
14921
+ 'Accept': 'application/json',
14922
+ 'Content-Type': 'application/json',
14923
+ 'Authorization': auth_header,
13433
14924
  }
13434
14925
 
13435
- __slots__: List[str] = ['_workspace_rid', '_ingest_job_uuid']
14926
+ _params: Dict[str, Any] = {
14927
+ }
13436
14928
 
13437
- def __init__(self, ingest_job_uuid: str, workspace_rid: str) -> None:
13438
- self._workspace_rid = workspace_rid
13439
- self._ingest_job_uuid = ingest_job_uuid
14929
+ _path_params: Dict[str, str] = {
14930
+ }
13440
14931
 
13441
- @builtins.property
13442
- def workspace_rid(self) -> str:
13443
- return self._workspace_rid
14932
+ _json: Any = _conjure_encoder.default(request)
13444
14933
 
13445
- @builtins.property
13446
- def ingest_job_uuid(self) -> str:
13447
- return self._ingest_job_uuid
14934
+ _path = '/scout/v2/modules/apply'
14935
+ _path = _path.format(**_path_params)
13448
14936
 
14937
+ _response: Response = self._request(
14938
+ 'POST',
14939
+ self._uri + _path,
14940
+ params=_params,
14941
+ headers=_headers,
14942
+ json=_json)
13449
14943
 
13450
- ingest_workflow_api_GetExtractorJobStateRequest.__name__ = "GetExtractorJobStateRequest"
13451
- ingest_workflow_api_GetExtractorJobStateRequest.__qualname__ = "GetExtractorJobStateRequest"
13452
- ingest_workflow_api_GetExtractorJobStateRequest.__module__ = "nominal_api.ingest_workflow_api"
14944
+ _decoder = ConjureDecoder()
14945
+ return _decoder.decode(_response.json(), modules_ApplyModuleResponse, self._return_none_for_unknown_union_types)
13453
14946
 
14947
+ def unapply_module(self, auth_header: str, request: "modules_UnapplyModuleRequest") -> "modules_UnapplyModuleResponse":
14948
+ """Unapply a module from an asset.
14949
+ """
14950
+ _conjure_encoder = ConjureEncoder()
13454
14951
 
13455
- class ingest_workflow_api_GetExtractorJobStateResponse(ConjureBeanType):
14952
+ _headers: Dict[str, Any] = {
14953
+ 'Accept': 'application/json',
14954
+ 'Content-Type': 'application/json',
14955
+ 'Authorization': auth_header,
14956
+ }
13456
14957
 
13457
- @builtins.classmethod
13458
- def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
13459
- return {
13460
- 'state': ConjureFieldDefinition('state', ingest_workflow_api_ExtractorJobState),
13461
- 'message': ConjureFieldDefinition('message', OptionalTypeWrapper[str])
14958
+ _params: Dict[str, Any] = {
13462
14959
  }
13463
14960
 
13464
- __slots__: List[str] = ['_state', '_message']
14961
+ _path_params: Dict[str, str] = {
14962
+ }
13465
14963
 
13466
- def __init__(self, state: "ingest_workflow_api_ExtractorJobState", message: Optional[str] = None) -> None:
13467
- self._state = state
13468
- self._message = message
14964
+ _json: Any = _conjure_encoder.default(request)
13469
14965
 
13470
- @builtins.property
13471
- def state(self) -> "ingest_workflow_api_ExtractorJobState":
13472
- return self._state
14966
+ _path = '/scout/v2/modules/unapply'
14967
+ _path = _path.format(**_path_params)
13473
14968
 
13474
- @builtins.property
13475
- def message(self) -> Optional[str]:
13476
- return self._message
14969
+ _response: Response = self._request(
14970
+ 'POST',
14971
+ self._uri + _path,
14972
+ params=_params,
14973
+ headers=_headers,
14974
+ json=_json)
13477
14975
 
14976
+ _decoder = ConjureDecoder()
14977
+ return _decoder.decode(_response.json(), modules_UnapplyModuleResponse, self._return_none_for_unknown_union_types)
13478
14978
 
13479
- ingest_workflow_api_GetExtractorJobStateResponse.__name__ = "GetExtractorJobStateResponse"
13480
- ingest_workflow_api_GetExtractorJobStateResponse.__qualname__ = "GetExtractorJobStateResponse"
13481
- ingest_workflow_api_GetExtractorJobStateResponse.__module__ = "nominal_api.ingest_workflow_api"
14979
+ def search_module_applications(self, auth_header: str, request: "modules_SearchModuleApplicationsRequest") -> "modules_SearchModuleApplicationsResponse":
14980
+ """Search for module applications.
14981
+ """
14982
+ _conjure_encoder = ConjureEncoder()
13482
14983
 
14984
+ _headers: Dict[str, Any] = {
14985
+ 'Accept': 'application/json',
14986
+ 'Content-Type': 'application/json',
14987
+ 'Authorization': auth_header,
14988
+ }
13483
14989
 
13484
- class ingest_workflow_api_IngestDataflashRequest(ConjureBeanType):
14990
+ _params: Dict[str, Any] = {
14991
+ }
13485
14992
 
13486
- @builtins.classmethod
13487
- def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
13488
- return {
13489
- 'locator': ConjureFieldDefinition('locator', ingest_workflow_api_ObjectLocator)
14993
+ _path_params: Dict[str, str] = {
13490
14994
  }
13491
14995
 
13492
- __slots__: List[str] = ['_locator']
14996
+ _json: Any = _conjure_encoder.default(request)
13493
14997
 
13494
- def __init__(self, locator: "ingest_workflow_api_ObjectLocator") -> None:
13495
- self._locator = locator
14998
+ _path = '/scout/v2/modules/applications/search'
14999
+ _path = _path.format(**_path_params)
13496
15000
 
13497
- @builtins.property
13498
- def locator(self) -> "ingest_workflow_api_ObjectLocator":
13499
- return self._locator
15001
+ _response: Response = self._request(
15002
+ 'POST',
15003
+ self._uri + _path,
15004
+ params=_params,
15005
+ headers=_headers,
15006
+ json=_json)
13500
15007
 
15008
+ _decoder = ConjureDecoder()
15009
+ return _decoder.decode(_response.json(), modules_SearchModuleApplicationsResponse, self._return_none_for_unknown_union_types)
13501
15010
 
13502
- ingest_workflow_api_IngestDataflashRequest.__name__ = "IngestDataflashRequest"
13503
- ingest_workflow_api_IngestDataflashRequest.__qualname__ = "IngestDataflashRequest"
13504
- ingest_workflow_api_IngestDataflashRequest.__module__ = "nominal_api.ingest_workflow_api"
13505
15011
 
15012
+ modules_ModulesService.__name__ = "ModulesService"
15013
+ modules_ModulesService.__qualname__ = "ModulesService"
15014
+ modules_ModulesService.__module__ = "nominal_api.modules"
13506
15015
 
13507
- class ingest_workflow_api_IngestDataflashResponse(ConjureBeanType):
15016
+
15017
+ class modules_SearchModuleApplicationsRequest(ConjureBeanType):
13508
15018
 
13509
15019
  @builtins.classmethod
13510
15020
  def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
13511
15021
  return {
13512
- 'units': ConjureFieldDefinition('units', Dict[str, str]),
13513
- 'parquet_object_locators': ConjureFieldDefinition('parquetObjectLocators', List[ingest_workflow_api_ObjectLocator]),
13514
- 'timestamp_series_name': ConjureFieldDefinition('timestampSeriesName', str),
13515
- 'time_unit': ConjureFieldDefinition('timeUnit', ingest_workflow_api_TimeUnitSeconds)
15022
+ 'search_text': ConjureFieldDefinition('searchText', str),
15023
+ 'asset_rids': ConjureFieldDefinition('assetRids', OptionalTypeWrapper[List[scout_rids_api_AssetRid]]),
15024
+ 'module_rids': ConjureFieldDefinition('moduleRids', OptionalTypeWrapper[List[modules_api_ModuleRid]]),
15025
+ 'page_size': ConjureFieldDefinition('pageSize', int),
15026
+ 'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
13516
15027
  }
13517
15028
 
13518
- __slots__: List[str] = ['_units', '_parquet_object_locators', '_timestamp_series_name', '_time_unit']
13519
-
13520
- def __init__(self, parquet_object_locators: List["ingest_workflow_api_ObjectLocator"], time_unit: "ingest_workflow_api_TimeUnitSeconds", timestamp_series_name: str, units: Dict[str, str]) -> None:
13521
- self._units = units
13522
- self._parquet_object_locators = parquet_object_locators
13523
- self._timestamp_series_name = timestamp_series_name
13524
- self._time_unit = time_unit
15029
+ __slots__: List[str] = ['_search_text', '_asset_rids', '_module_rids', '_page_size', '_next_page_token']
13525
15030
 
13526
- @builtins.property
13527
- def units(self) -> Dict[str, str]:
13528
- return self._units
15031
+ def __init__(self, page_size: int, search_text: str, asset_rids: Optional[List[str]] = None, module_rids: Optional[List[str]] = None, next_page_token: Optional[str] = None) -> None:
15032
+ self._search_text = search_text
15033
+ self._asset_rids = asset_rids
15034
+ self._module_rids = module_rids
15035
+ self._page_size = page_size
15036
+ self._next_page_token = next_page_token
13529
15037
 
13530
15038
  @builtins.property
13531
- def parquet_object_locators(self) -> List["ingest_workflow_api_ObjectLocator"]:
13532
- """Azure or S3-style blob locators of parquet files. Currently
13533
- only a single file is supported, the list type is used for future compatibility.
13534
- """
13535
- return self._parquet_object_locators
15039
+ def search_text(self) -> str:
15040
+ return self._search_text
13536
15041
 
13537
15042
  @builtins.property
13538
- def timestamp_series_name(self) -> str:
13539
- """The name of the column in the generated parquet file that contains the timestamp.
13540
- """
13541
- return self._timestamp_series_name
15043
+ def asset_rids(self) -> Optional[List[str]]:
15044
+ return self._asset_rids
13542
15045
 
13543
15046
  @builtins.property
13544
- def time_unit(self) -> "ingest_workflow_api_TimeUnitSeconds":
13545
- """The unit of time for the timestamp column. Can only be seconds.
13546
- """
13547
- return self._time_unit
13548
-
13549
-
13550
- ingest_workflow_api_IngestDataflashResponse.__name__ = "IngestDataflashResponse"
13551
- ingest_workflow_api_IngestDataflashResponse.__qualname__ = "IngestDataflashResponse"
13552
- ingest_workflow_api_IngestDataflashResponse.__module__ = "nominal_api.ingest_workflow_api"
13553
-
13554
-
13555
- class ingest_workflow_api_IngestMcapProtobufRequest(ConjureBeanType):
13556
-
13557
- @builtins.classmethod
13558
- def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
13559
- return {
13560
- 'locator': ConjureFieldDefinition('locator', ingest_workflow_api_ObjectLocator),
13561
- 'channels': ConjureFieldDefinition('channels', ingest_workflow_api_McapProtoChannels)
13562
- }
13563
-
13564
- __slots__: List[str] = ['_locator', '_channels']
13565
-
13566
- def __init__(self, channels: "ingest_workflow_api_McapProtoChannels", locator: "ingest_workflow_api_ObjectLocator") -> None:
13567
- self._locator = locator
13568
- self._channels = channels
15047
+ def module_rids(self) -> Optional[List[str]]:
15048
+ return self._module_rids
13569
15049
 
13570
15050
  @builtins.property
13571
- def locator(self) -> "ingest_workflow_api_ObjectLocator":
13572
- return self._locator
15051
+ def page_size(self) -> int:
15052
+ return self._page_size
13573
15053
 
13574
15054
  @builtins.property
13575
- def channels(self) -> "ingest_workflow_api_McapProtoChannels":
13576
- return self._channels
15055
+ def next_page_token(self) -> Optional[str]:
15056
+ return self._next_page_token
13577
15057
 
13578
15058
 
13579
- ingest_workflow_api_IngestMcapProtobufRequest.__name__ = "IngestMcapProtobufRequest"
13580
- ingest_workflow_api_IngestMcapProtobufRequest.__qualname__ = "IngestMcapProtobufRequest"
13581
- ingest_workflow_api_IngestMcapProtobufRequest.__module__ = "nominal_api.ingest_workflow_api"
15059
+ modules_SearchModuleApplicationsRequest.__name__ = "SearchModuleApplicationsRequest"
15060
+ modules_SearchModuleApplicationsRequest.__qualname__ = "SearchModuleApplicationsRequest"
15061
+ modules_SearchModuleApplicationsRequest.__module__ = "nominal_api.modules"
13582
15062
 
13583
15063
 
13584
- class ingest_workflow_api_IngestMcapProtobufResponse(ConjureBeanType):
15064
+ class modules_SearchModuleApplicationsResponse(ConjureBeanType):
13585
15065
 
13586
15066
  @builtins.classmethod
13587
15067
  def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
13588
15068
  return {
13589
- 'timestamp_column_name': ConjureFieldDefinition('timestampColumnName', str),
13590
- 'parquet_object_locators': ConjureFieldDefinition('parquetObjectLocators', List[ingest_workflow_api_ObjectLocator])
15069
+ 'results': ConjureFieldDefinition('results', List[modules_ModuleApplication]),
15070
+ 'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
13591
15071
  }
13592
15072
 
13593
- __slots__: List[str] = ['_timestamp_column_name', '_parquet_object_locators']
15073
+ __slots__: List[str] = ['_results', '_next_page_token']
13594
15074
 
13595
- def __init__(self, parquet_object_locators: List["ingest_workflow_api_ObjectLocator"], timestamp_column_name: str) -> None:
13596
- self._timestamp_column_name = timestamp_column_name
13597
- self._parquet_object_locators = parquet_object_locators
15075
+ def __init__(self, results: List["modules_ModuleApplication"], next_page_token: Optional[str] = None) -> None:
15076
+ self._results = results
15077
+ self._next_page_token = next_page_token
13598
15078
 
13599
15079
  @builtins.property
13600
- def timestamp_column_name(self) -> str:
13601
- return self._timestamp_column_name
15080
+ def results(self) -> List["modules_ModuleApplication"]:
15081
+ return self._results
13602
15082
 
13603
15083
  @builtins.property
13604
- def parquet_object_locators(self) -> List["ingest_workflow_api_ObjectLocator"]:
13605
- """Azure or S3-style blob locators of parquet files. Currently
13606
- only a single file is supported, the list type is used for future compatibility.
13607
- """
13608
- return self._parquet_object_locators
15084
+ def next_page_token(self) -> Optional[str]:
15085
+ return self._next_page_token
13609
15086
 
13610
15087
 
13611
- ingest_workflow_api_IngestMcapProtobufResponse.__name__ = "IngestMcapProtobufResponse"
13612
- ingest_workflow_api_IngestMcapProtobufResponse.__qualname__ = "IngestMcapProtobufResponse"
13613
- ingest_workflow_api_IngestMcapProtobufResponse.__module__ = "nominal_api.ingest_workflow_api"
15088
+ modules_SearchModuleApplicationsResponse.__name__ = "SearchModuleApplicationsResponse"
15089
+ modules_SearchModuleApplicationsResponse.__qualname__ = "SearchModuleApplicationsResponse"
15090
+ modules_SearchModuleApplicationsResponse.__module__ = "nominal_api.modules"
13614
15091
 
13615
15092
 
13616
- class ingest_workflow_api_McapProtoChannels(ConjureUnionType):
13617
- _all: Optional["ingest_workflow_api_Empty"] = None
13618
- _include_topics: Optional[List[str]] = None
13619
- _exclude_topics: Optional[List[str]] = None
15093
+ class modules_SearchModulesQuery(ConjureUnionType):
15094
+ _search_text: Optional[str] = None
15095
+ _created_by: Optional[str] = None
15096
+ _last_updated_by: Optional[str] = None
15097
+ _and_: Optional[List["modules_SearchModulesQuery"]] = None
15098
+ _or_: Optional[List["modules_SearchModulesQuery"]] = None
15099
+ _not_: Optional["modules_SearchModulesQuery"] = None
13620
15100
 
13621
15101
  @builtins.classmethod
13622
15102
  def _options(cls) -> Dict[str, ConjureFieldDefinition]:
13623
15103
  return {
13624
- 'all': ConjureFieldDefinition('all', ingest_workflow_api_Empty),
13625
- 'include_topics': ConjureFieldDefinition('includeTopics', List[ingest_workflow_api_McapTopicName]),
13626
- 'exclude_topics': ConjureFieldDefinition('excludeTopics', List[ingest_workflow_api_McapTopicName])
15104
+ 'search_text': ConjureFieldDefinition('searchText', str),
15105
+ 'created_by': ConjureFieldDefinition('createdBy', scout_rids_api_UserRid),
15106
+ 'last_updated_by': ConjureFieldDefinition('lastUpdatedBy', scout_rids_api_UserRid),
15107
+ 'and_': ConjureFieldDefinition('and', List[modules_SearchModulesQuery]),
15108
+ 'or_': ConjureFieldDefinition('or', List[modules_SearchModulesQuery]),
15109
+ 'not_': ConjureFieldDefinition('not', modules_SearchModulesQuery)
13627
15110
  }
13628
15111
 
13629
15112
  def __init__(
13630
15113
  self,
13631
- all: Optional["ingest_workflow_api_Empty"] = None,
13632
- include_topics: Optional[List[str]] = None,
13633
- exclude_topics: Optional[List[str]] = None,
15114
+ search_text: Optional[str] = None,
15115
+ created_by: Optional[str] = None,
15116
+ last_updated_by: Optional[str] = None,
15117
+ and_: Optional[List["modules_SearchModulesQuery"]] = None,
15118
+ or_: Optional[List["modules_SearchModulesQuery"]] = None,
15119
+ not_: Optional["modules_SearchModulesQuery"] = None,
13634
15120
  type_of_union: Optional[str] = None
13635
15121
  ) -> None:
13636
15122
  if type_of_union is None:
13637
- if (all is not None) + (include_topics is not None) + (exclude_topics is not None) != 1:
15123
+ if (search_text is not None) + (created_by is not None) + (last_updated_by is not None) + (and_ is not None) + (or_ is not None) + (not_ is not None) != 1:
13638
15124
  raise ValueError('a union must contain a single member')
13639
15125
 
13640
- if all is not None:
13641
- self._all = all
13642
- self._type = 'all'
13643
- if include_topics is not None:
13644
- self._include_topics = include_topics
13645
- self._type = 'includeTopics'
13646
- if exclude_topics is not None:
13647
- self._exclude_topics = exclude_topics
13648
- self._type = 'excludeTopics'
15126
+ if search_text is not None:
15127
+ self._search_text = search_text
15128
+ self._type = 'searchText'
15129
+ if created_by is not None:
15130
+ self._created_by = created_by
15131
+ self._type = 'createdBy'
15132
+ if last_updated_by is not None:
15133
+ self._last_updated_by = last_updated_by
15134
+ self._type = 'lastUpdatedBy'
15135
+ if and_ is not None:
15136
+ self._and_ = and_
15137
+ self._type = 'and'
15138
+ if or_ is not None:
15139
+ self._or_ = or_
15140
+ self._type = 'or'
15141
+ if not_ is not None:
15142
+ self._not_ = not_
15143
+ self._type = 'not'
13649
15144
 
13650
- elif type_of_union == 'all':
13651
- if all is None:
15145
+ elif type_of_union == 'searchText':
15146
+ if search_text is None:
13652
15147
  raise ValueError('a union value must not be None')
13653
- self._all = all
13654
- self._type = 'all'
13655
- elif type_of_union == 'includeTopics':
13656
- if include_topics is None:
15148
+ self._search_text = search_text
15149
+ self._type = 'searchText'
15150
+ elif type_of_union == 'createdBy':
15151
+ if created_by is None:
13657
15152
  raise ValueError('a union value must not be None')
13658
- self._include_topics = include_topics
13659
- self._type = 'includeTopics'
13660
- elif type_of_union == 'excludeTopics':
13661
- if exclude_topics is None:
15153
+ self._created_by = created_by
15154
+ self._type = 'createdBy'
15155
+ elif type_of_union == 'lastUpdatedBy':
15156
+ if last_updated_by is None:
13662
15157
  raise ValueError('a union value must not be None')
13663
- self._exclude_topics = exclude_topics
13664
- self._type = 'excludeTopics'
15158
+ self._last_updated_by = last_updated_by
15159
+ self._type = 'lastUpdatedBy'
15160
+ elif type_of_union == 'and':
15161
+ if and_ is None:
15162
+ raise ValueError('a union value must not be None')
15163
+ self._and_ = and_
15164
+ self._type = 'and'
15165
+ elif type_of_union == 'or':
15166
+ if or_ is None:
15167
+ raise ValueError('a union value must not be None')
15168
+ self._or_ = or_
15169
+ self._type = 'or'
15170
+ elif type_of_union == 'not':
15171
+ if not_ is None:
15172
+ raise ValueError('a union value must not be None')
15173
+ self._not_ = not_
15174
+ self._type = 'not'
13665
15175
 
13666
15176
  @builtins.property
13667
- def all(self) -> Optional["ingest_workflow_api_Empty"]:
13668
- return self._all
15177
+ def search_text(self) -> Optional[str]:
15178
+ return self._search_text
13669
15179
 
13670
15180
  @builtins.property
13671
- def include_topics(self) -> Optional[List[str]]:
13672
- return self._include_topics
15181
+ def created_by(self) -> Optional[str]:
15182
+ return self._created_by
13673
15183
 
13674
15184
  @builtins.property
13675
- def exclude_topics(self) -> Optional[List[str]]:
13676
- return self._exclude_topics
15185
+ def last_updated_by(self) -> Optional[str]:
15186
+ return self._last_updated_by
15187
+
15188
+ @builtins.property
15189
+ def and_(self) -> Optional[List["modules_SearchModulesQuery"]]:
15190
+ return self._and_
15191
+
15192
+ @builtins.property
15193
+ def or_(self) -> Optional[List["modules_SearchModulesQuery"]]:
15194
+ return self._or_
15195
+
15196
+ @builtins.property
15197
+ def not_(self) -> Optional["modules_SearchModulesQuery"]:
15198
+ return self._not_
13677
15199
 
13678
15200
  def accept(self, visitor) -> Any:
13679
- if not isinstance(visitor, ingest_workflow_api_McapProtoChannelsVisitor):
13680
- raise ValueError('{} is not an instance of ingest_workflow_api_McapProtoChannelsVisitor'.format(visitor.__class__.__name__))
13681
- if self._type == 'all' and self.all is not None:
13682
- return visitor._all(self.all)
13683
- if self._type == 'includeTopics' and self.include_topics is not None:
13684
- return visitor._include_topics(self.include_topics)
13685
- if self._type == 'excludeTopics' and self.exclude_topics is not None:
13686
- return visitor._exclude_topics(self.exclude_topics)
15201
+ if not isinstance(visitor, modules_SearchModulesQueryVisitor):
15202
+ raise ValueError('{} is not an instance of modules_SearchModulesQueryVisitor'.format(visitor.__class__.__name__))
15203
+ if self._type == 'searchText' and self.search_text is not None:
15204
+ return visitor._search_text(self.search_text)
15205
+ if self._type == 'createdBy' and self.created_by is not None:
15206
+ return visitor._created_by(self.created_by)
15207
+ if self._type == 'lastUpdatedBy' and self.last_updated_by is not None:
15208
+ return visitor._last_updated_by(self.last_updated_by)
15209
+ if self._type == 'and' and self.and_ is not None:
15210
+ return visitor._and(self.and_)
15211
+ if self._type == 'or' and self.or_ is not None:
15212
+ return visitor._or(self.or_)
15213
+ if self._type == 'not' and self.not_ is not None:
15214
+ return visitor._not(self.not_)
13687
15215
 
13688
15216
 
13689
- ingest_workflow_api_McapProtoChannels.__name__ = "McapProtoChannels"
13690
- ingest_workflow_api_McapProtoChannels.__qualname__ = "McapProtoChannels"
13691
- ingest_workflow_api_McapProtoChannels.__module__ = "nominal_api.ingest_workflow_api"
15217
+ modules_SearchModulesQuery.__name__ = "SearchModulesQuery"
15218
+ modules_SearchModulesQuery.__qualname__ = "SearchModulesQuery"
15219
+ modules_SearchModulesQuery.__module__ = "nominal_api.modules"
13692
15220
 
13693
15221
 
13694
- class ingest_workflow_api_McapProtoChannelsVisitor:
15222
+ class modules_SearchModulesQueryVisitor:
13695
15223
 
13696
15224
  @abstractmethod
13697
- def _all(self, all: "ingest_workflow_api_Empty") -> Any:
15225
+ def _search_text(self, search_text: str) -> Any:
13698
15226
  pass
13699
15227
 
13700
15228
  @abstractmethod
13701
- def _include_topics(self, include_topics: List[str]) -> Any:
15229
+ def _created_by(self, created_by: str) -> Any:
13702
15230
  pass
13703
15231
 
13704
15232
  @abstractmethod
13705
- def _exclude_topics(self, exclude_topics: List[str]) -> Any:
15233
+ def _last_updated_by(self, last_updated_by: str) -> Any:
13706
15234
  pass
13707
15235
 
15236
+ @abstractmethod
15237
+ def _and(self, and_: List["modules_SearchModulesQuery"]) -> Any:
15238
+ pass
13708
15239
 
13709
- ingest_workflow_api_McapProtoChannelsVisitor.__name__ = "McapProtoChannelsVisitor"
13710
- ingest_workflow_api_McapProtoChannelsVisitor.__qualname__ = "McapProtoChannelsVisitor"
13711
- ingest_workflow_api_McapProtoChannelsVisitor.__module__ = "nominal_api.ingest_workflow_api"
15240
+ @abstractmethod
15241
+ def _or(self, or_: List["modules_SearchModulesQuery"]) -> Any:
15242
+ pass
13712
15243
 
15244
+ @abstractmethod
15245
+ def _not(self, not_: "modules_SearchModulesQuery") -> Any:
15246
+ pass
13713
15247
 
13714
- class ingest_workflow_api_MultipartUploadDetails(ConjureBeanType):
15248
+
15249
+ modules_SearchModulesQueryVisitor.__name__ = "SearchModulesQueryVisitor"
15250
+ modules_SearchModulesQueryVisitor.__qualname__ = "SearchModulesQueryVisitor"
15251
+ modules_SearchModulesQueryVisitor.__module__ = "nominal_api.modules"
15252
+
15253
+
15254
+ class modules_SearchModulesRequest(ConjureBeanType):
13715
15255
 
13716
15256
  @builtins.classmethod
13717
15257
  def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
13718
15258
  return {
13719
- 'upload_id': ConjureFieldDefinition('uploadId', str),
13720
- 's3_handle': ConjureFieldDefinition('s3Handle', scout_catalog_S3Handle)
15259
+ 'query': ConjureFieldDefinition('query', modules_SearchModulesQuery),
15260
+ 'page_size': ConjureFieldDefinition('pageSize', int),
15261
+ 'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
13721
15262
  }
13722
15263
 
13723
- __slots__: List[str] = ['_upload_id', '_s3_handle']
15264
+ __slots__: List[str] = ['_query', '_page_size', '_next_page_token']
13724
15265
 
13725
- def __init__(self, s3_handle: "scout_catalog_S3Handle", upload_id: str) -> None:
13726
- self._upload_id = upload_id
13727
- self._s3_handle = s3_handle
15266
+ def __init__(self, page_size: int, query: "modules_SearchModulesQuery", next_page_token: Optional[str] = None) -> None:
15267
+ self._query = query
15268
+ self._page_size = page_size
15269
+ self._next_page_token = next_page_token
13728
15270
 
13729
15271
  @builtins.property
13730
- def upload_id(self) -> str:
13731
- return self._upload_id
15272
+ def query(self) -> "modules_SearchModulesQuery":
15273
+ return self._query
13732
15274
 
13733
15275
  @builtins.property
13734
- def s3_handle(self) -> "scout_catalog_S3Handle":
13735
- return self._s3_handle
15276
+ def page_size(self) -> int:
15277
+ return self._page_size
13736
15278
 
15279
+ @builtins.property
15280
+ def next_page_token(self) -> Optional[str]:
15281
+ return self._next_page_token
13737
15282
 
13738
- ingest_workflow_api_MultipartUploadDetails.__name__ = "MultipartUploadDetails"
13739
- ingest_workflow_api_MultipartUploadDetails.__qualname__ = "MultipartUploadDetails"
13740
- ingest_workflow_api_MultipartUploadDetails.__module__ = "nominal_api.ingest_workflow_api"
13741
15283
 
15284
+ modules_SearchModulesRequest.__name__ = "SearchModulesRequest"
15285
+ modules_SearchModulesRequest.__qualname__ = "SearchModulesRequest"
15286
+ modules_SearchModulesRequest.__module__ = "nominal_api.modules"
13742
15287
 
13743
- class ingest_workflow_api_ObjectLocator(ConjureBeanType):
13744
- """Locator for files in an object store.
13745
- Clients are expected to have auth and origin/region configured independently.
13746
- """
15288
+
15289
+ class modules_SearchModulesResponse(ConjureBeanType):
13747
15290
 
13748
15291
  @builtins.classmethod
13749
15292
  def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
13750
15293
  return {
13751
- 'bucket': ConjureFieldDefinition('bucket', str),
13752
- 'object_name': ConjureFieldDefinition('objectName', str)
15294
+ 'results': ConjureFieldDefinition('results', List[modules_ModuleSummary]),
15295
+ 'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
13753
15296
  }
13754
15297
 
13755
- __slots__: List[str] = ['_bucket', '_object_name']
15298
+ __slots__: List[str] = ['_results', '_next_page_token']
13756
15299
 
13757
- def __init__(self, bucket: str, object_name: str) -> None:
13758
- self._bucket = bucket
13759
- self._object_name = object_name
15300
+ def __init__(self, results: List["modules_ModuleSummary"], next_page_token: Optional[str] = None) -> None:
15301
+ self._results = results
15302
+ self._next_page_token = next_page_token
13760
15303
 
13761
15304
  @builtins.property
13762
- def bucket(self) -> str:
13763
- return self._bucket
15305
+ def results(self) -> List["modules_ModuleSummary"]:
15306
+ return self._results
13764
15307
 
13765
15308
  @builtins.property
13766
- def object_name(self) -> str:
13767
- return self._object_name
15309
+ def next_page_token(self) -> Optional[str]:
15310
+ return self._next_page_token
13768
15311
 
13769
15312
 
13770
- ingest_workflow_api_ObjectLocator.__name__ = "ObjectLocator"
13771
- ingest_workflow_api_ObjectLocator.__qualname__ = "ObjectLocator"
13772
- ingest_workflow_api_ObjectLocator.__module__ = "nominal_api.ingest_workflow_api"
15313
+ modules_SearchModulesResponse.__name__ = "SearchModulesResponse"
15314
+ modules_SearchModulesResponse.__qualname__ = "SearchModulesResponse"
15315
+ modules_SearchModulesResponse.__module__ = "nominal_api.modules"
13773
15316
 
13774
15317
 
13775
- class ingest_workflow_api_PresignedFileInput(ConjureBeanType):
15318
+ class modules_SemanticVersion(ConjureBeanType):
13776
15319
 
13777
15320
  @builtins.classmethod
13778
15321
  def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
13779
15322
  return {
13780
- 'url': ConjureFieldDefinition('url', ingest_workflow_api_PresignedUrl),
13781
- 'input': ConjureFieldDefinition('input', ingest_workflow_api_ValidatedFileInput)
15323
+ 'major': ConjureFieldDefinition('major', int),
15324
+ 'minor': ConjureFieldDefinition('minor', int),
15325
+ 'patch': ConjureFieldDefinition('patch', int)
13782
15326
  }
13783
15327
 
13784
- __slots__: List[str] = ['_url', '_input']
15328
+ __slots__: List[str] = ['_major', '_minor', '_patch']
13785
15329
 
13786
- def __init__(self, input: "ingest_workflow_api_ValidatedFileInput", url: str) -> None:
13787
- self._url = url
13788
- self._input = input
15330
+ def __init__(self, major: int, minor: int, patch: int) -> None:
15331
+ self._major = major
15332
+ self._minor = minor
15333
+ self._patch = patch
13789
15334
 
13790
15335
  @builtins.property
13791
- def url(self) -> str:
13792
- return self._url
15336
+ def major(self) -> int:
15337
+ return self._major
13793
15338
 
13794
15339
  @builtins.property
13795
- def input(self) -> "ingest_workflow_api_ValidatedFileInput":
13796
- return self._input
15340
+ def minor(self) -> int:
15341
+ return self._minor
13797
15342
 
15343
+ @builtins.property
15344
+ def patch(self) -> int:
15345
+ return self._patch
13798
15346
 
13799
- ingest_workflow_api_PresignedFileInput.__name__ = "PresignedFileInput"
13800
- ingest_workflow_api_PresignedFileInput.__qualname__ = "PresignedFileInput"
13801
- ingest_workflow_api_PresignedFileInput.__module__ = "nominal_api.ingest_workflow_api"
13802
15347
 
15348
+ modules_SemanticVersion.__name__ = "SemanticVersion"
15349
+ modules_SemanticVersion.__qualname__ = "SemanticVersion"
15350
+ modules_SemanticVersion.__module__ = "nominal_api.modules"
13803
15351
 
13804
- class ingest_workflow_api_TimeUnitSeconds(ConjureEnumType):
13805
15352
 
13806
- SECONDS = 'SECONDS'
13807
- '''SECONDS'''
13808
- UNKNOWN = 'UNKNOWN'
13809
- '''UNKNOWN'''
15353
+ class modules_TypedModuleVariable(ConjureBeanType):
13810
15354
 
13811
- def __reduce_ex__(self, proto):
13812
- return self.__class__, (self.name,)
15355
+ @builtins.classmethod
15356
+ def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
15357
+ return {
15358
+ 'name': ConjureFieldDefinition('name', str),
15359
+ 'type': ConjureFieldDefinition('type', modules_ValueType),
15360
+ 'value': ConjureFieldDefinition('value', scout_compute_api_VariableValue)
15361
+ }
13813
15362
 
15363
+ __slots__: List[str] = ['_name', '_type', '_value']
13814
15364
 
13815
- ingest_workflow_api_TimeUnitSeconds.__name__ = "TimeUnitSeconds"
13816
- ingest_workflow_api_TimeUnitSeconds.__qualname__ = "TimeUnitSeconds"
13817
- ingest_workflow_api_TimeUnitSeconds.__module__ = "nominal_api.ingest_workflow_api"
15365
+ def __init__(self, name: str, type: "modules_ValueType", value: "scout_compute_api_VariableValue") -> None:
15366
+ self._name = name
15367
+ self._type = type
15368
+ self._value = value
13818
15369
 
15370
+ @builtins.property
15371
+ def name(self) -> str:
15372
+ return self._name
15373
+
15374
+ @builtins.property
15375
+ def type(self) -> "modules_ValueType":
15376
+ return self._type
15377
+
15378
+ @builtins.property
15379
+ def value(self) -> "scout_compute_api_VariableValue":
15380
+ return self._value
15381
+
15382
+
15383
+ modules_TypedModuleVariable.__name__ = "TypedModuleVariable"
15384
+ modules_TypedModuleVariable.__qualname__ = "TypedModuleVariable"
15385
+ modules_TypedModuleVariable.__module__ = "nominal_api.modules"
13819
15386
 
13820
- class ingest_workflow_api_ValidatedFileInput(ConjureBeanType):
15387
+
15388
+ class modules_UnapplyModuleRequest(ConjureBeanType):
13821
15389
 
13822
15390
  @builtins.classmethod
13823
15391
  def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
13824
15392
  return {
13825
- 'handle': ConjureFieldDefinition('handle', scout_catalog_S3Handle),
13826
- 'file_name': ConjureFieldDefinition('fileName', str),
13827
- 'env_var': ConjureFieldDefinition('envVar', str)
15393
+ 'module_rid': ConjureFieldDefinition('moduleRid', modules_api_ModuleRid),
15394
+ 'asset_rid': ConjureFieldDefinition('assetRid', scout_rids_api_AssetRid)
13828
15395
  }
13829
15396
 
13830
- __slots__: List[str] = ['_handle', '_file_name', '_env_var']
15397
+ __slots__: List[str] = ['_module_rid', '_asset_rid']
13831
15398
 
13832
- def __init__(self, env_var: str, file_name: str, handle: "scout_catalog_S3Handle") -> None:
13833
- self._handle = handle
13834
- self._file_name = file_name
13835
- self._env_var = env_var
15399
+ def __init__(self, asset_rid: str, module_rid: str) -> None:
15400
+ self._module_rid = module_rid
15401
+ self._asset_rid = asset_rid
13836
15402
 
13837
15403
  @builtins.property
13838
- def handle(self) -> "scout_catalog_S3Handle":
13839
- """Path to the input file in S3.
13840
- """
13841
- return self._handle
15404
+ def module_rid(self) -> str:
15405
+ return self._module_rid
13842
15406
 
13843
15407
  @builtins.property
13844
- def file_name(self) -> str:
13845
- """Name of the file that will be placed on disk.
13846
- """
13847
- return self._file_name
15408
+ def asset_rid(self) -> str:
15409
+ return self._asset_rid
15410
+
15411
+
15412
+ modules_UnapplyModuleRequest.__name__ = "UnapplyModuleRequest"
15413
+ modules_UnapplyModuleRequest.__qualname__ = "UnapplyModuleRequest"
15414
+ modules_UnapplyModuleRequest.__module__ = "nominal_api.modules"
15415
+
15416
+
15417
+ class modules_UnapplyModuleResponse(ConjureBeanType):
15418
+
15419
+ @builtins.classmethod
15420
+ def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
15421
+ return {
15422
+ 'success': ConjureFieldDefinition('success', bool)
15423
+ }
15424
+
15425
+ __slots__: List[str] = ['_success']
15426
+
15427
+ def __init__(self, success: bool) -> None:
15428
+ self._success = success
13848
15429
 
13849
15430
  @builtins.property
13850
- def env_var(self) -> str:
13851
- """Environment variable that will store the path to the file.
13852
- """
13853
- return self._env_var
15431
+ def success(self) -> bool:
15432
+ return self._success
13854
15433
 
13855
15434
 
13856
- ingest_workflow_api_ValidatedFileInput.__name__ = "ValidatedFileInput"
13857
- ingest_workflow_api_ValidatedFileInput.__qualname__ = "ValidatedFileInput"
13858
- ingest_workflow_api_ValidatedFileInput.__module__ = "nominal_api.ingest_workflow_api"
15435
+ modules_UnapplyModuleResponse.__name__ = "UnapplyModuleResponse"
15436
+ modules_UnapplyModuleResponse.__qualname__ = "UnapplyModuleResponse"
15437
+ modules_UnapplyModuleResponse.__module__ = "nominal_api.modules"
15438
+
15439
+
15440
+ class modules_ValueType(ConjureEnumType):
15441
+
15442
+ NUMERIC_SERIES = 'NUMERIC_SERIES'
15443
+ '''NUMERIC_SERIES'''
15444
+ ENUM_SERIES = 'ENUM_SERIES'
15445
+ '''ENUM_SERIES'''
15446
+ RANGES_SERIES = 'RANGES_SERIES'
15447
+ '''RANGES_SERIES'''
15448
+ STRING_CONSTANT = 'STRING_CONSTANT'
15449
+ '''STRING_CONSTANT'''
15450
+ DURATION_CONSTANT = 'DURATION_CONSTANT'
15451
+ '''DURATION_CONSTANT'''
15452
+ TIMESTAMP_CONSTANT = 'TIMESTAMP_CONSTANT'
15453
+ '''TIMESTAMP_CONSTANT'''
15454
+ INTEGER_CONSTANT = 'INTEGER_CONSTANT'
15455
+ '''INTEGER_CONSTANT'''
15456
+ ASSET_RID = 'ASSET_RID'
15457
+ '''ASSET_RID'''
15458
+ UNKNOWN = 'UNKNOWN'
15459
+ '''UNKNOWN'''
15460
+
15461
+ def __reduce_ex__(self, proto):
15462
+ return self.__class__, (self.name,)
15463
+
15464
+
15465
+ modules_ValueType.__name__ = "ValueType"
15466
+ modules_ValueType.__qualname__ = "ValueType"
15467
+ modules_ValueType.__module__ = "nominal_api.modules"
13859
15468
 
13860
15469
 
13861
15470
  class persistent_compute_api_AppendResult(ConjureBeanType):
@@ -83851,6 +85460,8 @@ scout_rids_api_FunctionLineageRid = str
83851
85460
 
83852
85461
  timeseries_logicalseries_api_DatabaseName = str
83853
85462
 
85463
+ modules_api_ModuleRid = str
85464
+
83854
85465
  timeseries_logicalseries_api_SchemaName = str
83855
85466
 
83856
85467
  scout_datasource_connection_api_BucketName = str