nominal-api 0.654.0__tar.gz → 0.656.0__tar.gz

{nominal_api-0.654.0 → nominal_api-0.656.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nominal-api
-Version: 0.654.0
+Version: 0.656.0
 Requires-Python: >=3.8
 Requires-Dist: requests
 Requires-Dist: conjure-python-client<3,>=2.8.0

{nominal_api-0.654.0 → nominal_api-0.656.0}/nominal_api/__init__.py

@@ -75,5 +75,5 @@ __all__ = [
 
 __conjure_generator_version__ = "4.9.0"
 
-__version__ = "0.654.0"
+__version__ = "0.656.0"
 

{nominal_api-0.654.0 → nominal_api-0.656.0}/nominal_api/_impl.py

@@ -7621,16 +7621,16 @@ class ingest_api_ContainerizedOpts(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'sources': ConjureFieldDefinition('sources', Dict[ingest_api_EnvironmentVariable, ingest_api_IngestSource]),
-            'extractor': ConjureFieldDefinition('extractor', ingest_api_ContainerizedExtractorRid),
+            'extractor_rid': ConjureFieldDefinition('extractorRid', ingest_api_ContainerizedExtractorRid),
             'tag': ConjureFieldDefinition('tag', OptionalTypeWrapper[str]),
             'target': ConjureFieldDefinition('target', ingest_api_DatasetIngestTarget)
         }
 
-    __slots__: List[str] = ['_sources', '_extractor', '_tag', '_target']
+    __slots__: List[str] = ['_sources', '_extractor_rid', '_tag', '_target']
 
-    def __init__(self, extractor: str, sources: Dict[str, "ingest_api_IngestSource"], target: "ingest_api_DatasetIngestTarget", tag: Optional[str] = None) -> None:
+    def __init__(self, extractor_rid: str, sources: Dict[str, "ingest_api_IngestSource"], target: "ingest_api_DatasetIngestTarget", tag: Optional[str] = None) -> None:
         self._sources = sources
-        self._extractor = extractor
+        self._extractor_rid = extractor_rid
         self._tag = tag
         self._target = target
 
@@ -7639,8 +7639,8 @@ class ingest_api_ContainerizedOpts(ConjureBeanType):
         return self._sources
 
     @builtins.property
-    def extractor(self) -> str:
-        return self._extractor
+    def extractor_rid(self) -> str:
+        return self._extractor_rid
 
     @builtins.property
     def tag(self) -> Optional[str]:
@@ -8228,16 +8228,18 @@ class ingest_api_FileExtractionInput(ConjureBeanType):
             'environment_variable': ConjureFieldDefinition('environmentVariable', ingest_api_EnvironmentVariable),
             'name': ConjureFieldDefinition('name', str),
             'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
-            'regex': ConjureFieldDefinition('regex', OptionalTypeWrapper[str])
+            'file_filters': ConjureFieldDefinition('fileFilters', List[ingest_api_FileFilter]),
+            'required': ConjureFieldDefinition('required', OptionalTypeWrapper[bool])
         }
 
-    __slots__: List[str] = ['_environment_variable', '_name', '_description', '_regex']
+    __slots__: List[str] = ['_environment_variable', '_name', '_description', '_file_filters', '_required']
 
-    def __init__(self, environment_variable: str, name: str, description: Optional[str] = None, regex: Optional[str] = None) -> None:
+    def __init__(self, environment_variable: str, file_filters: List["ingest_api_FileFilter"], name: str, description: Optional[str] = None, required: Optional[bool] = None) -> None:
         self._environment_variable = environment_variable
         self._name = name
         self._description = description
-        self._regex = regex
+        self._file_filters = file_filters
+        self._required = required
 
     @builtins.property
     def environment_variable(self) -> str:
@@ -8261,11 +8263,18 @@ class ingest_api_FileExtractionInput(ConjureBeanType):
         return self._description
 
     @builtins.property
-    def regex(self) -> Optional[str]:
+    def file_filters(self) -> List["ingest_api_FileFilter"]:
         """
-        Optionally filter files by regex for file selection. Will not be enforced at runtime, so containers need to handle their own validation.
+        Optionally filter files for file selection
         """
-        return self._regex
+        return self._file_filters
+
+    @builtins.property
+    def required(self) -> Optional[bool]:
+        """
+        Whether the input file is required for the extractor to run.
+        """
+        return self._required
 
 
 ingest_api_FileExtractionInput.__name__ = "FileExtractionInput"
@@ -8273,6 +8282,62 @@ ingest_api_FileExtractionInput.__qualname__ = "FileExtractionInput"
 ingest_api_FileExtractionInput.__module__ = "nominal_api.ingest_api"
 
 
+class ingest_api_FileFilter(ConjureUnionType):
+    _suffix: Optional[str] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'suffix': ConjureFieldDefinition('suffix', ingest_api_FileSuffix)
+        }
+
+    def __init__(
+            self,
+            suffix: Optional[str] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (suffix is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if suffix is not None:
+                self._suffix = suffix
+                self._type = 'suffix'
+
+        elif type_of_union == 'suffix':
+            if suffix is None:
+                raise ValueError('a union value must not be None')
+            self._suffix = suffix
+            self._type = 'suffix'
+
+    @builtins.property
+    def suffix(self) -> Optional[str]:
+        return self._suffix
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, ingest_api_FileFilterVisitor):
+            raise ValueError('{} is not an instance of ingest_api_FileFilterVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'suffix' and self.suffix is not None:
+            return visitor._suffix(self.suffix)
+
+
+ingest_api_FileFilter.__name__ = "FileFilter"
+ingest_api_FileFilter.__qualname__ = "FileFilter"
+ingest_api_FileFilter.__module__ = "nominal_api.ingest_api"
+
+
+class ingest_api_FileFilterVisitor:
+
+    @abstractmethod
+    def _suffix(self, suffix: str) -> Any:
+        pass
+
+
+ingest_api_FileFilterVisitor.__name__ = "FileFilterVisitor"
+ingest_api_FileFilterVisitor.__qualname__ = "FileFilterVisitor"
+ingest_api_FileFilterVisitor.__module__ = "nominal_api.ingest_api"
+
+
 class ingest_api_GcsIngestSource(ConjureBeanType):
 
     @builtins.classmethod
@@ -10885,6 +10950,7 @@ class ingest_api_ReingestDatasetsRequest(ConjureBeanType):
         """
         The datasets to reingest data from. Can only include tagless, non-streaming datasets (V1).
 The datasets must be of the same granularity and must only include CSV or Parquet files.
+Will attempt to reingest from datasets in list order.
         """
         return self._source_datasets
 
@@ -12125,20 +12191,20 @@ class ingest_workflow_api_EnsureExtractorJobCreatedRequest(ConjureBeanType):
             'ingest_job_uuid': ConjureFieldDefinition('ingestJobUuid', str),
             'containerized_extractor': ConjureFieldDefinition('containerizedExtractor', ingest_api_ContainerizedExtractor),
             'tag': ConjureFieldDefinition('tag', str),
-            'source_handles': ConjureFieldDefinition('sourceHandles', Dict[str, scout_catalog_S3Handle]),
+            'validated_file_inputs': ConjureFieldDefinition('validatedFileInputs', List[ingest_workflow_api_ValidatedFileInput]),
             'multipart_upload_details': ConjureFieldDefinition('multipartUploadDetails', ingest_workflow_api_MultipartUploadDetails),
             'image_pull_secret_name': ConjureFieldDefinition('imagePullSecretName', OptionalTypeWrapper[str])
         }
 
-    __slots__: List[str] = ['_bearer_token', '_workspace_rid', '_ingest_job_uuid', '_containerized_extractor', '_tag', '_source_handles', '_multipart_upload_details', '_image_pull_secret_name']
+    __slots__: List[str] = ['_bearer_token', '_workspace_rid', '_ingest_job_uuid', '_containerized_extractor', '_tag', '_validated_file_inputs', '_multipart_upload_details', '_image_pull_secret_name']
 
-    def __init__(self, bearer_token: str, containerized_extractor: "ingest_api_ContainerizedExtractor", ingest_job_uuid: str, multipart_upload_details: "ingest_workflow_api_MultipartUploadDetails", source_handles: Dict[str, "scout_catalog_S3Handle"], tag: str, workspace_rid: str, image_pull_secret_name: Optional[str] = None) -> None:
+    def __init__(self, bearer_token: str, containerized_extractor: "ingest_api_ContainerizedExtractor", ingest_job_uuid: str, multipart_upload_details: "ingest_workflow_api_MultipartUploadDetails", tag: str, validated_file_inputs: List["ingest_workflow_api_ValidatedFileInput"], workspace_rid: str, image_pull_secret_name: Optional[str] = None) -> None:
         self._bearer_token = bearer_token
         self._workspace_rid = workspace_rid
         self._ingest_job_uuid = ingest_job_uuid
         self._containerized_extractor = containerized_extractor
         self._tag = tag
-        self._source_handles = source_handles
+        self._validated_file_inputs = validated_file_inputs
         self._multipart_upload_details = multipart_upload_details
         self._image_pull_secret_name = image_pull_secret_name
 
@@ -12163,8 +12229,8 @@ class ingest_workflow_api_EnsureExtractorJobCreatedRequest(ConjureBeanType):
         return self._tag
 
     @builtins.property
-    def source_handles(self) -> Dict[str, "scout_catalog_S3Handle"]:
-        return self._source_handles
+    def validated_file_inputs(self) -> List["ingest_workflow_api_ValidatedFileInput"]:
+        return self._validated_file_inputs
 
     @builtins.property
     def multipart_upload_details(self) -> "ingest_workflow_api_MultipartUploadDetails":
@@ -12721,6 +12787,35 @@ ingest_workflow_api_ObjectLocator.__qualname__ = "ObjectLocator"
 ingest_workflow_api_ObjectLocator.__module__ = "nominal_api.ingest_workflow_api"
 
 
+class ingest_workflow_api_PresignedFileInput(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'url': ConjureFieldDefinition('url', ingest_workflow_api_PresignedUrl),
+            'input': ConjureFieldDefinition('input', ingest_workflow_api_ValidatedFileInput)
+        }
+
+    __slots__: List[str] = ['_url', '_input']
+
+    def __init__(self, input: "ingest_workflow_api_ValidatedFileInput", url: str) -> None:
+        self._url = url
+        self._input = input
+
+    @builtins.property
+    def url(self) -> str:
+        return self._url
+
+    @builtins.property
+    def input(self) -> "ingest_workflow_api_ValidatedFileInput":
+        return self._input
+
+
+ingest_workflow_api_PresignedFileInput.__name__ = "PresignedFileInput"
+ingest_workflow_api_PresignedFileInput.__qualname__ = "PresignedFileInput"
+ingest_workflow_api_PresignedFileInput.__module__ = "nominal_api.ingest_workflow_api"
+
+
 class ingest_workflow_api_TimeUnitSeconds(ConjureEnumType):
 
     SECONDS = 'SECONDS'
@@ -12737,6 +12832,50 @@ ingest_workflow_api_TimeUnitSeconds.__qualname__ = "TimeUnitSeconds"
 ingest_workflow_api_TimeUnitSeconds.__module__ = "nominal_api.ingest_workflow_api"
 
 
+class ingest_workflow_api_ValidatedFileInput(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'handle': ConjureFieldDefinition('handle', scout_catalog_S3Handle),
+            'file_name': ConjureFieldDefinition('fileName', str),
+            'env_var': ConjureFieldDefinition('envVar', str)
+        }
+
+    __slots__: List[str] = ['_handle', '_file_name', '_env_var']
+
+    def __init__(self, env_var: str, file_name: str, handle: "scout_catalog_S3Handle") -> None:
+        self._handle = handle
+        self._file_name = file_name
+        self._env_var = env_var
+
+    @builtins.property
+    def handle(self) -> "scout_catalog_S3Handle":
+        """
+        Path to the input file in S3.
+        """
+        return self._handle
+
+    @builtins.property
+    def file_name(self) -> str:
+        """
+        Name of the file that will be placed on disk.
+        """
+        return self._file_name
+
+    @builtins.property
+    def env_var(self) -> str:
+        """
+        Environment variable that will store the path to the file.
+        """
+        return self._env_var
+
+
+ingest_workflow_api_ValidatedFileInput.__name__ = "ValidatedFileInput"
+ingest_workflow_api_ValidatedFileInput.__qualname__ = "ValidatedFileInput"
+ingest_workflow_api_ValidatedFileInput.__module__ = "nominal_api.ingest_workflow_api"
+
+
 class persistent_compute_api_AppendResult(ConjureBeanType):
     """
     An append result won't cover the full `StreamingComputeNodeRequest#windowWidth` but rather just a smaller 
@@ -22117,6 +22256,89 @@ scout_chartdefinition_api_ChecklistChartDefinitionV1.__qualname__ = "ChecklistCh
 scout_chartdefinition_api_ChecklistChartDefinitionV1.__module__ = "nominal_api.scout_chartdefinition_api"
 
 
+class scout_chartdefinition_api_ColorStyle(ConjureUnionType):
+    _mapped: Optional[Dict[str, str]] = None
+    _single: Optional[str] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'mapped': ConjureFieldDefinition('mapped', Dict[str, scout_api_HexColor]),
+            'single': ConjureFieldDefinition('single', scout_api_HexColor)
+        }
+
+    def __init__(
+            self,
+            mapped: Optional[Dict[str, str]] = None,
+            single: Optional[str] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (mapped is not None) + (single is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if mapped is not None:
+                self._mapped = mapped
+                self._type = 'mapped'
+            if single is not None:
+                self._single = single
+                self._type = 'single'
+
+        elif type_of_union == 'mapped':
+            if mapped is None:
+                raise ValueError('a union value must not be None')
+            self._mapped = mapped
+            self._type = 'mapped'
+        elif type_of_union == 'single':
+            if single is None:
+                raise ValueError('a union value must not be None')
+            self._single = single
+            self._type = 'single'
+
+    @builtins.property
+    def mapped(self) -> Optional[Dict[str, str]]:
+        """
+        Defines specific colors for specific values
+        """
+        return self._mapped
+
+    @builtins.property
+    def single(self) -> Optional[str]:
+        """
+        A single color to apply to the whole plot
+        """
+        return self._single
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_chartdefinition_api_ColorStyleVisitor):
+            raise ValueError('{} is not an instance of scout_chartdefinition_api_ColorStyleVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'mapped' and self.mapped is not None:
+            return visitor._mapped(self.mapped)
+        if self._type == 'single' and self.single is not None:
+            return visitor._single(self.single)
+
+
+scout_chartdefinition_api_ColorStyle.__name__ = "ColorStyle"
+scout_chartdefinition_api_ColorStyle.__qualname__ = "ColorStyle"
+scout_chartdefinition_api_ColorStyle.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_ColorStyleVisitor:
+
+    @abstractmethod
+    def _mapped(self, mapped: Dict[str, str]) -> Any:
+        pass
+
+    @abstractmethod
+    def _single(self, single: str) -> Any:
+        pass
+
+
+scout_chartdefinition_api_ColorStyleVisitor.__name__ = "ColorStyleVisitor"
+scout_chartdefinition_api_ColorStyleVisitor.__qualname__ = "ColorStyleVisitor"
+scout_chartdefinition_api_ColorStyleVisitor.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
 class scout_chartdefinition_api_DefaultFill(ConjureBeanType):
 
     @builtins.classmethod
@@ -23872,6 +24094,140 @@ scout_chartdefinition_api_NumericValueVisualisationV2Visitor.__qualname__ = "Num
 scout_chartdefinition_api_NumericValueVisualisationV2Visitor.__module__ = "nominal_api.scout_chartdefinition_api"
 
 
+class scout_chartdefinition_api_OverlayScope(ConjureEnumType):
+
+    ROW = 'ROW'
+    '''ROW'''
+    PANEL = 'PANEL'
+    '''PANEL'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
+
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
+
+
+scout_chartdefinition_api_OverlayScope.__name__ = "OverlayScope"
+scout_chartdefinition_api_OverlayScope.__qualname__ = "OverlayScope"
+scout_chartdefinition_api_OverlayScope.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_PersistAll(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+        }
+
+    __slots__: List[str] = []
+
+
+
+scout_chartdefinition_api_PersistAll.__name__ = "PersistAll"
+scout_chartdefinition_api_PersistAll.__qualname__ = "PersistAll"
+scout_chartdefinition_api_PersistAll.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_PersistByValue(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'values': ConjureFieldDefinition('values', List[str])
+        }
+
+    __slots__: List[str] = ['_values']
+
+    def __init__(self, values: List[str]) -> None:
+        self._values = values
+
+    @builtins.property
+    def values(self) -> List[str]:
+        return self._values
+
+
+scout_chartdefinition_api_PersistByValue.__name__ = "PersistByValue"
+scout_chartdefinition_api_PersistByValue.__qualname__ = "PersistByValue"
+scout_chartdefinition_api_PersistByValue.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_PersistValueOverlay(ConjureUnionType):
+    _by_value: Optional["scout_chartdefinition_api_PersistByValue"] = None
+    _all: Optional["scout_chartdefinition_api_PersistAll"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'by_value': ConjureFieldDefinition('byValue', scout_chartdefinition_api_PersistByValue),
+            'all': ConjureFieldDefinition('all', scout_chartdefinition_api_PersistAll)
+        }
+
+    def __init__(
+            self,
+            by_value: Optional["scout_chartdefinition_api_PersistByValue"] = None,
+            all: Optional["scout_chartdefinition_api_PersistAll"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (by_value is not None) + (all is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if by_value is not None:
+                self._by_value = by_value
+                self._type = 'byValue'
+            if all is not None:
+                self._all = all
+                self._type = 'all'
+
+        elif type_of_union == 'byValue':
+            if by_value is None:
+                raise ValueError('a union value must not be None')
+            self._by_value = by_value
+            self._type = 'byValue'
+        elif type_of_union == 'all':
+            if all is None:
+                raise ValueError('a union value must not be None')
+            self._all = all
+            self._type = 'all'
+
+    @builtins.property
+    def by_value(self) -> Optional["scout_chartdefinition_api_PersistByValue"]:
+        return self._by_value
+
+    @builtins.property
+    def all(self) -> Optional["scout_chartdefinition_api_PersistAll"]:
+        return self._all
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_chartdefinition_api_PersistValueOverlayVisitor):
+            raise ValueError('{} is not an instance of scout_chartdefinition_api_PersistValueOverlayVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'byValue' and self.by_value is not None:
+            return visitor._by_value(self.by_value)
+        if self._type == 'all' and self.all is not None:
+            return visitor._all(self.all)
+
+
+scout_chartdefinition_api_PersistValueOverlay.__name__ = "PersistValueOverlay"
+scout_chartdefinition_api_PersistValueOverlay.__qualname__ = "PersistValueOverlay"
+scout_chartdefinition_api_PersistValueOverlay.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_PersistValueOverlayVisitor:
+
+    @abstractmethod
+    def _by_value(self, by_value: "scout_chartdefinition_api_PersistByValue") -> Any:
+        pass
+
+    @abstractmethod
+    def _all(self, all: "scout_chartdefinition_api_PersistAll") -> Any:
+        pass
+
+
+scout_chartdefinition_api_PersistValueOverlayVisitor.__name__ = "PersistValueOverlayVisitor"
+scout_chartdefinition_api_PersistValueOverlayVisitor.__qualname__ = "PersistValueOverlayVisitor"
+scout_chartdefinition_api_PersistValueOverlayVisitor.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
 class scout_chartdefinition_api_PlotlyPanelDefinition(ConjureUnionType):
     _v1: Optional["scout_chartdefinition_api_PlotlyPanelDefinitionV1"] = None
 
@@ -23985,6 +24341,24 @@ scout_chartdefinition_api_PlotlyPreset.__qualname__ = "PlotlyPreset"
 scout_chartdefinition_api_PlotlyPreset.__module__ = "nominal_api.scout_chartdefinition_api"
 
 
+class scout_chartdefinition_api_Position(ConjureEnumType):
+
+    TOP = 'TOP'
+    '''TOP'''
+    BOTTOM = 'BOTTOM'
+    '''BOTTOM'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
+
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
+
+
+scout_chartdefinition_api_Position.__name__ = "Position"
+scout_chartdefinition_api_Position.__qualname__ = "Position"
+scout_chartdefinition_api_Position.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
 class scout_chartdefinition_api_RangeCellConfig(ConjureBeanType):
 
     @builtins.classmethod
@@ -24384,6 +24758,99 @@ scout_chartdefinition_api_TimeSeriesChartDefinitionV1.__qualname__ = "TimeSeries
 scout_chartdefinition_api_TimeSeriesChartDefinitionV1.__module__ = "nominal_api.scout_chartdefinition_api"
 
 
+class scout_chartdefinition_api_TimeSeriesEnumPlot(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'color': ConjureFieldDefinition('color', scout_chartdefinition_api_ColorStyle),
+            'position': ConjureFieldDefinition('position', scout_chartdefinition_api_Position),
+            'persist_value_overlays': ConjureFieldDefinition('persistValueOverlays', scout_chartdefinition_api_PersistValueOverlay),
+            'overlay_scope': ConjureFieldDefinition('overlayScope', scout_chartdefinition_api_OverlayScope),
+            'display_inline': ConjureFieldDefinition('displayInline', bool)
+        }
+
+    __slots__: List[str] = ['_color', '_position', '_persist_value_overlays', '_overlay_scope', '_display_inline']
+
+    def __init__(self, color: "scout_chartdefinition_api_ColorStyle", display_inline: bool, overlay_scope: "scout_chartdefinition_api_OverlayScope", persist_value_overlays: "scout_chartdefinition_api_PersistValueOverlay", position: "scout_chartdefinition_api_Position") -> None:
+        self._color = color
+        self._position = position
+        self._persist_value_overlays = persist_value_overlays
+        self._overlay_scope = overlay_scope
+        self._display_inline = display_inline
+
+    @builtins.property
+    def color(self) -> "scout_chartdefinition_api_ColorStyle":
+        """
+        How to color the value ranges
+        """
+        return self._color
+
+    @builtins.property
+    def position(self) -> "scout_chartdefinition_api_Position":
+        """
+        Where to place the plot within the row
+        """
+        return self._position
+
+    @builtins.property
+    def persist_value_overlays(self) -> "scout_chartdefinition_api_PersistValueOverlay":
+        """
+        Render certain values' full-row/full-panel color overlays
+even when not interacting with the plot
+        """
+        return self._persist_value_overlays
+
+    @builtins.property
+    def overlay_scope(self) -> "scout_chartdefinition_api_OverlayScope":
+        """
+        How far to extend the overlay
+        """
+        return self._overlay_scope
+
+    @builtins.property
+    def display_inline(self) -> bool:
+        """
+        Whether to display the value ranges on the same line or stagger them
+such that each value gets a line to itself
+        """
+        return self._display_inline
+
+
+scout_chartdefinition_api_TimeSeriesEnumPlot.__name__ = "TimeSeriesEnumPlot"
+scout_chartdefinition_api_TimeSeriesEnumPlot.__qualname__ = "TimeSeriesEnumPlot"
+scout_chartdefinition_api_TimeSeriesEnumPlot.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_TimeSeriesNumericPlot(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'color': ConjureFieldDefinition('color', scout_api_HexColor),
+            'line_style': ConjureFieldDefinition('lineStyle', scout_chartdefinition_api_LineStyle)
+        }
+
+    __slots__: List[str] = ['_color', '_line_style']
+
+    def __init__(self, color: str, line_style: "scout_chartdefinition_api_LineStyle") -> None:
+        self._color = color
+        self._line_style = line_style
+
+    @builtins.property
+    def color(self) -> str:
+        return self._color
+
+    @builtins.property
+    def line_style(self) -> "scout_chartdefinition_api_LineStyle":
+        return self._line_style
+
+
+scout_chartdefinition_api_TimeSeriesNumericPlot.__name__ = "TimeSeriesNumericPlot"
+scout_chartdefinition_api_TimeSeriesNumericPlot.__qualname__ = "TimeSeriesNumericPlot"
+scout_chartdefinition_api_TimeSeriesNumericPlot.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
 class scout_chartdefinition_api_TimeSeriesPlot(ConjureBeanType):
 
     @builtins.classmethod
@@ -24431,6 +24898,168 @@ scout_chartdefinition_api_TimeSeriesPlot.__qualname__ = "TimeSeriesPlot"
 scout_chartdefinition_api_TimeSeriesPlot.__module__ = "nominal_api.scout_chartdefinition_api"
 
 
+class scout_chartdefinition_api_TimeSeriesPlotConfig(ConjureUnionType):
+    _numeric: Optional["scout_chartdefinition_api_TimeSeriesNumericPlot"] = None
+    _range: Optional["scout_chartdefinition_api_TimeSeriesRangePlot"] = None
+    _enum: Optional["scout_chartdefinition_api_TimeSeriesEnumPlot"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'numeric': ConjureFieldDefinition('numeric', scout_chartdefinition_api_TimeSeriesNumericPlot),
+            'range': ConjureFieldDefinition('range', scout_chartdefinition_api_TimeSeriesRangePlot),
+            'enum': ConjureFieldDefinition('enum', scout_chartdefinition_api_TimeSeriesEnumPlot)
+        }
+
+    def __init__(
+            self,
+            numeric: Optional["scout_chartdefinition_api_TimeSeriesNumericPlot"] = None,
+            range: Optional["scout_chartdefinition_api_TimeSeriesRangePlot"] = None,
+            enum: Optional["scout_chartdefinition_api_TimeSeriesEnumPlot"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (numeric is not None) + (range is not None) + (enum is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if numeric is not None:
+                self._numeric = numeric
+                self._type = 'numeric'
+            if range is not None:
+                self._range = range
+                self._type = 'range'
+            if enum is not None:
+                self._enum = enum
+                self._type = 'enum'
+
+        elif type_of_union == 'numeric':
+            if numeric is None:
+                raise ValueError('a union value must not be None')
+            self._numeric = numeric
+            self._type = 'numeric'
+        elif type_of_union == 'range':
+            if range is None:
+                raise ValueError('a union value must not be None')
+            self._range = range
+            self._type = 'range'
+        elif type_of_union == 'enum':
+            if enum is None:
+                raise ValueError('a union value must not be None')
+            self._enum = enum
+            self._type = 'enum'
+
+    @builtins.property
+    def numeric(self) -> Optional["scout_chartdefinition_api_TimeSeriesNumericPlot"]:
+        return self._numeric
+
+    @builtins.property
+    def range(self) -> Optional["scout_chartdefinition_api_TimeSeriesRangePlot"]:
+        return self._range
+
+    @builtins.property
+    def enum(self) -> Optional["scout_chartdefinition_api_TimeSeriesEnumPlot"]:
+        return self._enum
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_chartdefinition_api_TimeSeriesPlotConfigVisitor):
+            raise ValueError('{} is not an instance of scout_chartdefinition_api_TimeSeriesPlotConfigVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'numeric' and self.numeric is not None:
+            return visitor._numeric(self.numeric)
+        if self._type == 'range' and self.range is not None:
+            return visitor._range(self.range)
+        if self._type == 'enum' and self.enum is not None:
+            return visitor._enum(self.enum)
+
+
+scout_chartdefinition_api_TimeSeriesPlotConfig.__name__ = "TimeSeriesPlotConfig"
+scout_chartdefinition_api_TimeSeriesPlotConfig.__qualname__ = "TimeSeriesPlotConfig"
+scout_chartdefinition_api_TimeSeriesPlotConfig.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_TimeSeriesPlotConfigVisitor:
+
+    @abstractmethod
+    def _numeric(self, numeric: "scout_chartdefinition_api_TimeSeriesNumericPlot") -> Any:
+        pass
+
+    @abstractmethod
+    def _range(self, range: "scout_chartdefinition_api_TimeSeriesRangePlot") -> Any:
+        pass
+
+    @abstractmethod
+    def _enum(self, enum: "scout_chartdefinition_api_TimeSeriesEnumPlot") -> Any:
+        pass
+
+
+scout_chartdefinition_api_TimeSeriesPlotConfigVisitor.__name__ = "TimeSeriesPlotConfigVisitor"
+scout_chartdefinition_api_TimeSeriesPlotConfigVisitor.__qualname__ = "TimeSeriesPlotConfigVisitor"
+scout_chartdefinition_api_TimeSeriesPlotConfigVisitor.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_TimeSeriesPlotV2(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'variable_name': ConjureFieldDefinition('variableName', scout_channelvariables_api_ChannelVariableName),
+            'enabled': ConjureFieldDefinition('enabled', OptionalTypeWrapper[bool]),
+            'y_axis_id': ConjureFieldDefinition('yAxisId', scout_chartdefinition_api_AxisId),
+            'type': ConjureFieldDefinition('type', scout_chartdefinition_api_TimeSeriesPlotConfig)
+        }
+
+    __slots__: List[str] = ['_variable_name', '_enabled', '_y_axis_id', '_type']
+
+    def __init__(self, type: "scout_chartdefinition_api_TimeSeriesPlotConfig", variable_name: str, y_axis_id: str, enabled: Optional[bool] = None) -> None:
+        self._variable_name = variable_name
+        self._enabled = enabled
+        self._y_axis_id = y_axis_id
+        self._type = type
+
+    @builtins.property
+    def variable_name(self) -> str:
+        return self._variable_name
+
+    @builtins.property
+    def enabled(self) -> Optional[bool]:
+        return self._enabled
+
+    @builtins.property
+    def y_axis_id(self) -> str:
+        return self._y_axis_id
+
+    @builtins.property
+    def type(self) -> "scout_chartdefinition_api_TimeSeriesPlotConfig":
+        return self._type
+
+
+scout_chartdefinition_api_TimeSeriesPlotV2.__name__ = "TimeSeriesPlotV2"
+scout_chartdefinition_api_TimeSeriesPlotV2.__qualname__ = "TimeSeriesPlotV2"
+scout_chartdefinition_api_TimeSeriesPlotV2.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_TimeSeriesRangePlot(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'color': ConjureFieldDefinition('color', scout_api_HexColor)
+        }
+
+    __slots__: List[str] = ['_color']
+
+    def __init__(self, color: str) -> None:
+        self._color = color
+
+    @builtins.property
+    def color(self) -> str:
+        return self._color
+
+
+scout_chartdefinition_api_TimeSeriesRangePlot.__name__ = "TimeSeriesRangePlot"
+scout_chartdefinition_api_TimeSeriesRangePlot.__qualname__ = "TimeSeriesRangePlot"
+scout_chartdefinition_api_TimeSeriesRangePlot.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
 class scout_chartdefinition_api_TimeSeriesRow(ConjureBeanType):
 
     @builtins.classmethod
@@ -24438,15 +25067,17 @@ class scout_chartdefinition_api_TimeSeriesRow(ConjureBeanType):
         return {
             'title': ConjureFieldDefinition('title', OptionalTypeWrapper[str]),
             'plots': ConjureFieldDefinition('plots', List[scout_chartdefinition_api_TimeSeriesPlot]),
+            'plots_v2': ConjureFieldDefinition('plotsV2', OptionalTypeWrapper[List[scout_chartdefinition_api_TimeSeriesPlotV2]]),
             'row_flex_size': ConjureFieldDefinition('rowFlexSize', float),
             'enabled': ConjureFieldDefinition('enabled', OptionalTypeWrapper[bool])
         }
 
-    __slots__: List[str] = ['_title', '_plots', '_row_flex_size', '_enabled']
+    __slots__: List[str] = ['_title', '_plots', '_plots_v2', '_row_flex_size', '_enabled']
 
-    def __init__(self, plots: List["scout_chartdefinition_api_TimeSeriesPlot"], row_flex_size: float, enabled: Optional[bool] = None, title: Optional[str] = None) -> None:
+    def __init__(self, plots: List["scout_chartdefinition_api_TimeSeriesPlot"], row_flex_size: float, enabled: Optional[bool] = None, plots_v2: Optional[List["scout_chartdefinition_api_TimeSeriesPlotV2"]] = None, title: Optional[str] = None) -> None:
         self._title = title
         self._plots = plots
+        self._plots_v2 = plots_v2
         self._row_flex_size = row_flex_size
         self._enabled = enabled
 
@@ -24458,6 +25089,10 @@ class scout_chartdefinition_api_TimeSeriesRow(ConjureBeanType):
     def plots(self) -> List["scout_chartdefinition_api_TimeSeriesPlot"]:
         return self._plots
 
+    @builtins.property
+    def plots_v2(self) -> Optional[List["scout_chartdefinition_api_TimeSeriesPlotV2"]]:
+        return self._plots_v2
+
     @builtins.property
     def row_flex_size(self) -> float:
         return self._row_flex_size
@@ -79791,6 +80426,8 @@ scout_rids_api_SnapshotRid = str
 
 scout_units_api_UnitName = str
 
+ingest_api_FileSuffix = str
+
 scout_datasource_connection_api_TableName = str
 
 timeseries_seriescache_api_Resolution = int
@@ -79937,6 +80574,8 @@ scout_video_api_ErrorType = str
 
 scout_comparisonnotebook_api_ComparisonChannelVariableMap = Dict[scout_comparisonnotebook_api_VariableName, scout_comparisonnotebook_api_ChannelVariable]
 
+ingest_workflow_api_PresignedUrl = str
+
 timeseries_logicalseries_api_FieldName = str
 
 scout_channelvariables_api_WorkbookChannelVariableMap = Dict[scout_channelvariables_api_ChannelVariableName, scout_channelvariables_api_ChannelVariable]

{nominal_api-0.654.0 → nominal_api-0.656.0}/nominal_api/ingest_api/__init__.py

@@ -30,6 +30,9 @@ from .._impl import (
     ingest_api_ExistingDatasetIngestDestination as ExistingDatasetIngestDestination,
     ingest_api_ExistingVideoIngestDestination as ExistingVideoIngestDestination,
     ingest_api_FileExtractionInput as FileExtractionInput,
+    ingest_api_FileFilter as FileFilter,
+    ingest_api_FileFilterVisitor as FileFilterVisitor,
+    ingest_api_FileSuffix as FileSuffix,
     ingest_api_GcsIngestSource as GcsIngestSource,
     ingest_api_GetContainerizedExtractorsRequest as GetContainerizedExtractorsRequest,
     ingest_api_GetContainerizedExtractorsResponse as GetContainerizedExtractorsResponse,

{nominal_api-0.654.0 → nominal_api-0.656.0}/nominal_api/ingest_workflow_api/__init__.py

@@ -20,6 +20,9 @@ from .._impl import (
     ingest_workflow_api_McapTopicName as McapTopicName,
     ingest_workflow_api_MultipartUploadDetails as MultipartUploadDetails,
     ingest_workflow_api_ObjectLocator as ObjectLocator,
+    ingest_workflow_api_PresignedFileInput as PresignedFileInput,
+    ingest_workflow_api_PresignedUrl as PresignedUrl,
     ingest_workflow_api_TimeUnitSeconds as TimeUnitSeconds,
+    ingest_workflow_api_ValidatedFileInput as ValidatedFileInput,
 )
 

{nominal_api-0.654.0 → nominal_api-0.656.0}/nominal_api/scout_chartdefinition_api/__init__.py

@@ -21,6 +21,8 @@ from .._impl import (
     scout_chartdefinition_api_ChecklistChartDefinition as ChecklistChartDefinition,
     scout_chartdefinition_api_ChecklistChartDefinitionV1 as ChecklistChartDefinitionV1,
     scout_chartdefinition_api_ChecklistChartDefinitionVisitor as ChecklistChartDefinitionVisitor,
+    scout_chartdefinition_api_ColorStyle as ColorStyle,
+    scout_chartdefinition_api_ColorStyleVisitor as ColorStyleVisitor,
     scout_chartdefinition_api_DataSourceRefName as DataSourceRefName,
     scout_chartdefinition_api_DefaultFill as DefaultFill,
     scout_chartdefinition_api_EnumCellConfig as EnumCellConfig,
@@ -79,10 +81,16 @@ from .._impl import (
     scout_chartdefinition_api_NumericValueVisualisationV2 as NumericValueVisualisationV2,
     scout_chartdefinition_api_NumericValueVisualisationV2Visitor as NumericValueVisualisationV2Visitor,
     scout_chartdefinition_api_NumericValueVisualisationVisitor as NumericValueVisualisationVisitor,
+    scout_chartdefinition_api_OverlayScope as OverlayScope,
+    scout_chartdefinition_api_PersistAll as PersistAll,
+    scout_chartdefinition_api_PersistByValue as PersistByValue,
+    scout_chartdefinition_api_PersistValueOverlay as PersistValueOverlay,
+    scout_chartdefinition_api_PersistValueOverlayVisitor as PersistValueOverlayVisitor,
     scout_chartdefinition_api_PlotlyPanelDefinition as PlotlyPanelDefinition,
     scout_chartdefinition_api_PlotlyPanelDefinitionV1 as PlotlyPanelDefinitionV1,
     scout_chartdefinition_api_PlotlyPanelDefinitionVisitor as PlotlyPanelDefinitionVisitor,
     scout_chartdefinition_api_PlotlyPreset as PlotlyPreset,
+    scout_chartdefinition_api_Position as Position,
     scout_chartdefinition_api_RangeCellConfig as RangeCellConfig,
     scout_chartdefinition_api_RangeRawVisualisation as RangeRawVisualisation,
     scout_chartdefinition_api_RangeValueChannel as RangeValueChannel,
@@ -96,7 +104,13 @@ from .._impl import (
     scout_chartdefinition_api_TimeSeriesChartDefinition as TimeSeriesChartDefinition,
     scout_chartdefinition_api_TimeSeriesChartDefinitionV1 as TimeSeriesChartDefinitionV1,
     scout_chartdefinition_api_TimeSeriesChartDefinitionVisitor as TimeSeriesChartDefinitionVisitor,
+    scout_chartdefinition_api_TimeSeriesEnumPlot as TimeSeriesEnumPlot,
+    scout_chartdefinition_api_TimeSeriesNumericPlot as TimeSeriesNumericPlot,
     scout_chartdefinition_api_TimeSeriesPlot as TimeSeriesPlot,
+    scout_chartdefinition_api_TimeSeriesPlotConfig as TimeSeriesPlotConfig,
+    scout_chartdefinition_api_TimeSeriesPlotConfigVisitor as TimeSeriesPlotConfigVisitor,
+    scout_chartdefinition_api_TimeSeriesPlotV2 as TimeSeriesPlotV2,
+    scout_chartdefinition_api_TimeSeriesRangePlot as TimeSeriesRangePlot,
     scout_chartdefinition_api_TimeSeriesRow as TimeSeriesRow,
     scout_chartdefinition_api_Trace as Trace,
     scout_chartdefinition_api_TraceCompute as TraceCompute,

{nominal_api-0.654.0 → nominal_api-0.656.0}/nominal_api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nominal-api
-Version: 0.654.0
+Version: 0.656.0
 Requires-Python: >=3.8
 Requires-Dist: requests
 Requires-Dist: conjure-python-client<3,>=2.8.0

{nominal_api-0.654.0 → nominal_api-0.656.0}/setup.py

@@ -6,7 +6,7 @@ from setuptools import (
 
 setup(
     name='nominal-api',
-    version='0.654.0',
+    version='0.656.0',
     python_requires='>=3.8',
     package_data={"": ["py.typed"]},
     packages=find_packages(),