acryl-datahub 1.3.1__py3-none-any.whl → 1.3.1.1rc1__py3-none-any.whl

datahub/ingestion/transformer/add_dataset_properties.py

@@ -50,7 +50,7 @@ class AddDatasetProperties(DatasetPropertiesTransformer):
 
     @classmethod
     def create(cls, config_dict: dict, ctx: PipelineContext) -> "AddDatasetProperties":
-        config = AddDatasetPropertiesConfig.parse_obj(config_dict)
+        config = AddDatasetPropertiesConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     @staticmethod
@@ -144,5 +144,5 @@ class SimpleAddDatasetProperties(AddDatasetProperties):
     def create(
         cls, config_dict: dict, ctx: PipelineContext
     ) -> "SimpleAddDatasetProperties":
-        config = SimpleAddDatasetPropertiesConfig.parse_obj(config_dict)
+        config = SimpleAddDatasetPropertiesConfig.model_validate(config_dict)
         return cls(config, ctx)

datahub/ingestion/transformer/add_dataset_schema_tags.py

@@ -38,7 +38,7 @@ class AddDatasetSchemaTags(DatasetSchemaMetadataTransformer):
 
     @classmethod
     def create(cls, config_dict: dict, ctx: PipelineContext) -> "AddDatasetSchemaTags":
-        config = AddDatasetSchemaTagsConfig.parse_obj(config_dict)
+        config = AddDatasetSchemaTagsConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     def extend_field(
@@ -142,5 +142,5 @@ class PatternAddDatasetSchemaTags(AddDatasetSchemaTags):
     def create(
         cls, config_dict: dict, ctx: PipelineContext
     ) -> "PatternAddDatasetSchemaTags":
-        config = PatternDatasetTagsConfig.parse_obj(config_dict)
+        config = PatternDatasetTagsConfig.model_validate(config_dict)
         return cls(config, ctx)

datahub/ingestion/transformer/add_dataset_schema_terms.py

@@ -39,7 +39,7 @@ class AddDatasetSchemaTerms(DatasetSchemaMetadataTransformer):
 
     @classmethod
     def create(cls, config_dict: dict, ctx: PipelineContext) -> "AddDatasetSchemaTerms":
-        config = AddDatasetSchemaTermsConfig.parse_obj(config_dict)
+        config = AddDatasetSchemaTermsConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     def extend_field(
@@ -162,5 +162,5 @@ class PatternAddDatasetSchemaTerms(AddDatasetSchemaTerms):
     def create(
         cls, config_dict: dict, ctx: PipelineContext
     ) -> "PatternAddDatasetSchemaTerms":
-        config = PatternDatasetTermsConfig.parse_obj(config_dict)
+        config = PatternDatasetTermsConfig.model_validate(config_dict)
         return cls(config, ctx)

datahub/ingestion/transformer/add_dataset_tags.py

@@ -41,7 +41,7 @@ class AddDatasetTags(DatasetTagsTransformer):
 
     @classmethod
     def create(cls, config_dict: dict, ctx: PipelineContext) -> "AddDatasetTags":
-        config = AddDatasetTagsConfig.parse_obj(config_dict)
+        config = AddDatasetTagsConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     def transform_aspect(
@@ -104,7 +104,7 @@ class SimpleAddDatasetTags(AddDatasetTags):
 
     @classmethod
     def create(cls, config_dict: dict, ctx: PipelineContext) -> "SimpleAddDatasetTags":
-        config = SimpleDatasetTagConfig.parse_obj(config_dict)
+        config = SimpleDatasetTagConfig.model_validate(config_dict)
         return cls(config, ctx)
 
 
@@ -128,5 +128,5 @@ class PatternAddDatasetTags(AddDatasetTags):
 
     @classmethod
     def create(cls, config_dict: dict, ctx: PipelineContext) -> "PatternAddDatasetTags":
-        config = PatternDatasetTagsConfig.parse_obj(config_dict)
+        config = PatternDatasetTagsConfig.model_validate(config_dict)
         return cls(config, ctx)

datahub/ingestion/transformer/add_dataset_terms.py

@@ -39,7 +39,7 @@ class AddDatasetTerms(DatasetTermsTransformer):
 
     @classmethod
     def create(cls, config_dict: dict, ctx: PipelineContext) -> "AddDatasetTerms":
-        config = AddDatasetTermsConfig.parse_obj(config_dict)
+        config = AddDatasetTermsConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     @staticmethod
@@ -120,7 +120,7 @@ class SimpleAddDatasetTerms(AddDatasetTerms):
 
     @classmethod
     def create(cls, config_dict: dict, ctx: PipelineContext) -> "SimpleAddDatasetTerms":
-        config = SimpleDatasetTermsConfig.parse_obj(config_dict)
+        config = SimpleDatasetTermsConfig.model_validate(config_dict)
         return cls(config, ctx)
 
 
@@ -147,5 +147,5 @@ class PatternAddDatasetTerms(AddDatasetTerms):
     def create(
         cls, config_dict: dict, ctx: PipelineContext
     ) -> "PatternAddDatasetTerms":
-        config = PatternDatasetTermsConfig.parse_obj(config_dict)
+        config = PatternDatasetTermsConfig.model_validate(config_dict)
         return cls(config, ctx)

datahub/ingestion/transformer/dataset_domain.py

@@ -67,7 +67,7 @@ class AddDatasetDomain(DatasetDomainTransformer):
 
     @classmethod
     def create(cls, config_dict: dict, ctx: PipelineContext) -> "AddDatasetDomain":
-        config = AddDatasetDomainSemanticsConfig.parse_obj(config_dict)
+        config = AddDatasetDomainSemanticsConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     @staticmethod
@@ -208,7 +208,7 @@ class SimpleAddDatasetDomain(AddDatasetDomain):
     def create(
         cls, config_dict: dict, ctx: PipelineContext
     ) -> "SimpleAddDatasetDomain":
-        config = SimpleDatasetDomainSemanticsConfig.parse_obj(config_dict)
+        config = SimpleDatasetDomainSemanticsConfig.model_validate(config_dict)
         return cls(config, ctx)
 
 
@@ -238,5 +238,5 @@ class PatternAddDatasetDomain(AddDatasetDomain):
     def create(
         cls, config_dict: dict, ctx: PipelineContext
     ) -> "PatternAddDatasetDomain":
-        config = PatternDatasetDomainSemanticsConfig.parse_obj(config_dict)
+        config = PatternDatasetDomainSemanticsConfig.model_validate(config_dict)
         return cls(config, ctx)

datahub/ingestion/transformer/dataset_domain_based_on_tags.py

@@ -27,7 +27,7 @@ class DatasetTagDomainMapper(DatasetDomainTransformer):
     def create(
         cls, config_dict: dict, ctx: PipelineContext
     ) -> "DatasetTagDomainMapper":
-        config = DatasetTagDomainMapperConfig.parse_obj(config_dict)
+        config = DatasetTagDomainMapperConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     def transform_aspect(

datahub/ingestion/transformer/extract_dataset_tags.py

@@ -29,7 +29,7 @@ class ExtractDatasetTags(DatasetTagsTransformer):
 
     @classmethod
     def create(cls, config_dict: dict, ctx: PipelineContext) -> "ExtractDatasetTags":
-        config = ExtractDatasetTagsConfig.parse_obj(config_dict)
+        config = ExtractDatasetTagsConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     def _get_tags_to_add(self, entity_urn: str) -> List[TagAssociationClass]:

datahub/ingestion/transformer/extract_ownership_from_tags.py

@@ -62,7 +62,7 @@ class ExtractOwnersFromTagsTransformer(DatasetTagsTransformer):
     def create(
         cls, config_dict: dict, ctx: PipelineContext
     ) -> "ExtractOwnersFromTagsTransformer":
-        config = ExtractOwnersFromTagsConfig.parse_obj(config_dict)
+        config = ExtractOwnersFromTagsConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     def get_owner_urn(self, owner_str: str) -> str:

datahub/ingestion/transformer/mark_dataset_status.py

@@ -24,7 +24,7 @@ class MarkDatasetStatus(DatasetStatusTransformer):
 
     @classmethod
     def create(cls, config_dict: dict, ctx: PipelineContext) -> "MarkDatasetStatus":
-        config = MarkDatasetStatusConfig.parse_obj(config_dict)
+        config = MarkDatasetStatusConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     def transform_aspect(

datahub/ingestion/transformer/pattern_cleanup_dataset_usage_user.py

@@ -38,7 +38,7 @@ class PatternCleanupDatasetUsageUser(DatasetUsageStatisticsTransformer):
     def create(
         cls, config_dict: dict, ctx: PipelineContext
     ) -> "PatternCleanupDatasetUsageUser":
-        config = PatternCleanupDatasetUsageUserConfig.parse_obj(config_dict)
+        config = PatternCleanupDatasetUsageUserConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     def transform_aspect(

datahub/ingestion/transformer/pattern_cleanup_ownership.py

@@ -37,7 +37,7 @@ class PatternCleanUpOwnership(OwnershipTransformer):
     def create(
         cls, config_dict: dict, ctx: PipelineContext
     ) -> "PatternCleanUpOwnership":
-        config = PatternCleanUpOwnershipConfig.parse_obj(config_dict)
+        config = PatternCleanUpOwnershipConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     def _get_current_owner_urns(self, entity_urn: str) -> Set[str]:

datahub/ingestion/transformer/remove_dataset_ownership.py

@@ -21,7 +21,7 @@ class SimpleRemoveDatasetOwnership(OwnershipTransformer):
     def create(
         cls, config_dict: dict, ctx: PipelineContext
     ) -> "SimpleRemoveDatasetOwnership":
-        config = ClearDatasetOwnershipConfig.parse_obj(config_dict)
+        config = ClearDatasetOwnershipConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     def transform_aspect(

datahub/ingestion/transformer/replace_external_url.py

@@ -47,7 +47,7 @@ class ReplaceExternalUrlDataset(DatasetPropertiesTransformer, ReplaceUrl):
     def create(
         cls, config_dict: dict, ctx: PipelineContext
     ) -> "ReplaceExternalUrlDataset":
-        config = ReplaceExternalUrlConfig.parse_obj(config_dict)
+        config = ReplaceExternalUrlConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     def transform_aspect(
@@ -97,7 +97,7 @@ class ReplaceExternalUrlContainer(ContainerPropertiesTransformer, ReplaceUrl):
     def create(
         cls, config_dict: dict, ctx: PipelineContext
     ) -> "ReplaceExternalUrlContainer":
-        config = ReplaceExternalUrlConfig.parse_obj(config_dict)
+        config = ReplaceExternalUrlConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     def transform_aspect(

datahub/ingestion/transformer/set_browse_path.py

@@ -42,7 +42,7 @@ class SetBrowsePathTransformer(BaseTransformer, SingleAspectTransformer):
     def create(
         cls, config_dict: dict, ctx: PipelineContext
     ) -> "SetBrowsePathTransformer":
-        config = SetBrowsePathTransformerConfig.parse_obj(config_dict)
+        config = SetBrowsePathTransformerConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     @staticmethod

datahub/ingestion/transformer/tags_to_terms.py

@@ -32,7 +32,7 @@ class TagsToTermMapper(TagsToTermTransformer):
 
     @classmethod
     def create(cls, config_dict: dict, ctx: PipelineContext) -> "TagsToTermMapper":
-        config = TagsToTermMapperConfig.parse_obj(config_dict)
+        config = TagsToTermMapperConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     @staticmethod

datahub/lite/duckdb_lite.py

@@ -42,7 +42,7 @@ logger = logging.getLogger(__name__)
 class DuckDBLite(DataHubLiteLocal[DuckDBLiteConfig]):
     @classmethod
     def create(cls, config_dict: dict) -> "DuckDBLite":
-        config: DuckDBLiteConfig = DuckDBLiteConfig.parse_obj(config_dict)
+        config: DuckDBLiteConfig = DuckDBLiteConfig.model_validate(config_dict)
         return DuckDBLite(config)
 
     def __init__(self, config: DuckDBLiteConfig) -> None:

datahub/lite/lite_util.py

@@ -92,7 +92,7 @@ class DataHubLiteWrapper(DataHubLiteLocal):
 
 
 def get_datahub_lite(config_dict: dict, read_only: bool = False) -> "DataHubLiteLocal":
-    lite_local_config = LiteLocalConfig.parse_obj(config_dict)
+    lite_local_config = LiteLocalConfig.model_validate(config_dict)
 
     lite_type = lite_local_config.type
     try:
@@ -102,7 +102,7 @@ def get_datahub_lite(config_dict: dict, read_only: bool = False) -> "DataHubLite
             f"Failed to find a registered lite implementation for {lite_type}. Valid values are {[k for k in lite_registry.mapping]}"
         ) from e
 
-    lite_specific_config = lite_class.get_config_class().parse_obj(
+    lite_specific_config = lite_class.get_config_class().model_validate(
         lite_local_config.config
     )
     lite = lite_class(lite_specific_config)

datahub/sdk/search_filters.py

@@ -16,6 +16,7 @@ from typing import (
 )
 
 import pydantic
+from pydantic import field_validator
 
 from datahub.configuration.common import ConfigModel
 from datahub.configuration.pydantic_migration_helpers import (
@@ -102,7 +103,8 @@ class _EntitySubtypeFilter(_BaseFilter):
         description="The entity subtype to filter on. Can be 'Table', 'View', 'Source', etc. depending on the native platform's concepts.",
     )
 
-    @pydantic.validator("entity_subtype", pre=True)
+    @field_validator("entity_subtype", mode="before")
+    @classmethod
     def validate_entity_subtype(cls, v: str) -> List[str]:
         return [v] if not isinstance(v, list) else v
 
@@ -141,10 +143,13 @@ class _PlatformFilter(_BaseFilter):
     platform: List[str]
     # TODO: Add validator to convert string -> list of strings
 
-    @pydantic.validator("platform", each_item=True)
-    def validate_platform(cls, v: str) -> str:
+    @field_validator("platform", mode="before")
+    @classmethod
+    def validate_platform(cls, v):
         # Subtle - we use the constructor instead of the from_string method
         # because coercion is acceptable here.
+        if isinstance(v, list):
+            return [str(DataPlatformUrn(item)) for item in v]
         return str(DataPlatformUrn(v))
 
     def _build_rule(self) -> SearchFilterRule:
@@ -161,8 +166,11 @@ class _PlatformFilter(_BaseFilter):
 class _DomainFilter(_BaseFilter):
     domain: List[str]
 
-    @pydantic.validator("domain", each_item=True)
-    def validate_domain(cls, v: str) -> str:
+    @field_validator("domain", mode="before")
+    @classmethod
+    def validate_domain(cls, v):
+        if isinstance(v, list):
+            return [str(DomainUrn.from_string(item)) for item in v]
         return str(DomainUrn.from_string(v))
 
     def _build_rule(self) -> SearchFilterRule:
@@ -183,8 +191,11 @@ class _ContainerFilter(_BaseFilter):
         description="If true, only entities that are direct descendants of the container will be returned.",
     )
 
-    @pydantic.validator("container", each_item=True)
-    def validate_container(cls, v: str) -> str:
+    @field_validator("container", mode="before")
+    @classmethod
+    def validate_container(cls, v):
+        if isinstance(v, list):
+            return [str(ContainerUrn.from_string(item)) for item in v]
         return str(ContainerUrn.from_string(v))
 
     @classmethod
@@ -249,17 +260,25 @@ class _OwnerFilter(_BaseFilter):
         description="The owner to filter on. Should be user or group URNs.",
     )
 
-    @pydantic.validator("owner", each_item=True)
-    def validate_owner(cls, v: str) -> str:
-        if not v.startswith("urn:li:"):
-            raise ValueError(f"Owner must be a valid User or Group URN, got: {v}")
-        _type = guess_entity_type(v)
-        if _type == CorpUserUrn.ENTITY_TYPE:
-            return str(CorpUserUrn.from_string(v))
-        elif _type == CorpGroupUrn.ENTITY_TYPE:
-            return str(CorpGroupUrn.from_string(v))
-        else:
-            raise ValueError(f"Owner must be a valid User or Group URN, got: {v}")
+    @field_validator("owner", mode="before")
+    @classmethod
+    def validate_owner(cls, v):
+        validated = []
+        for owner in v:
+            if not owner.startswith("urn:li:"):
+                raise ValueError(
+                    f"Owner must be a valid User or Group URN, got: {owner}"
+                )
+            _type = guess_entity_type(owner)
+            if _type == CorpUserUrn.ENTITY_TYPE:
+                validated.append(str(CorpUserUrn.from_string(owner)))
+            elif _type == CorpGroupUrn.ENTITY_TYPE:
+                validated.append(str(CorpGroupUrn.from_string(owner)))
+            else:
+                raise ValueError(
+                    f"Owner must be a valid User or Group URN, got: {owner}"
+                )
+        return validated
 
     def _build_rule(self) -> SearchFilterRule:
         return SearchFilterRule(
@@ -279,17 +298,21 @@ class _GlossaryTermFilter(_BaseFilter):
         description="The glossary term to filter on. Should be glossary term URNs.",
     )
 
-    @pydantic.validator("glossary_term", each_item=True)
-    def validate_glossary_term(cls, v: str) -> str:
-        if not v.startswith("urn:li:"):
-            raise ValueError(f"Glossary term must be a valid URN, got: {v}")
-        # Validate that it's a glossary term URN
-        _type = guess_entity_type(v)
-        if _type != "glossaryTerm":
-            raise ValueError(
-                f"Glossary term must be a valid glossary term URN, got: {v}"
-            )
-        return v
+    @field_validator("glossary_term", mode="before")
+    @classmethod
+    def validate_glossary_term(cls, v):
+        validated = []
+        for term in v:
+            if not term.startswith("urn:li:"):
+                raise ValueError(f"Glossary term must be a valid URN, got: {term}")
+            # Validate that it's a glossary term URN
+            _type = guess_entity_type(term)
+            if _type != "glossaryTerm":
+                raise ValueError(
+                    f"Glossary term must be a valid glossary term URN, got: {term}"
+                )
+            validated.append(term)
+        return validated
 
     def _build_rule(self) -> SearchFilterRule:
         return SearchFilterRule(
@@ -309,15 +332,19 @@ class _TagFilter(_BaseFilter):
         description="The tag to filter on. Should be tag URNs.",
     )
 
-    @pydantic.validator("tag", each_item=True)
-    def validate_tag(cls, v: str) -> str:
-        if not v.startswith("urn:li:"):
-            raise ValueError(f"Tag must be a valid URN, got: {v}")
-        # Validate that it's a tag URN
-        _type = guess_entity_type(v)
-        if _type != "tag":
-            raise ValueError(f"Tag must be a valid tag URN, got: {v}")
-        return v
+    @field_validator("tag", mode="before")
+    @classmethod
+    def validate_tag(cls, v):
+        validated = []
+        for tag in v:
+            if not tag.startswith("urn:li:"):
+                raise ValueError(f"Tag must be a valid URN, got: {tag}")
+            # Validate that it's a tag URN
+            _type = guess_entity_type(tag)
+            if _type != "tag":
+                raise ValueError(f"Tag must be a valid tag URN, got: {tag}")
+            validated.append(tag)
+        return validated
 
     def _build_rule(self) -> SearchFilterRule:
         return SearchFilterRule(
@@ -426,7 +453,8 @@ class _Not(_BaseFilter):
 
     not_: "Filter" = pydantic.Field(alias="not")
 
-    @pydantic.validator("not_", pre=False)
+    @field_validator("not_", mode="after")
+    @classmethod
     def validate_not(cls, v: "Filter") -> "Filter":
         inner_filter = v.compile()
         if len(inner_filter) != 1:
@@ -571,7 +599,7 @@ def load_filters(obj: Any) -> Filter:
     if PYDANTIC_VERSION_2:
         return pydantic.TypeAdapter(Filter).validate_python(obj)  # type: ignore
     else:
-        return pydantic.parse_obj_as(Filter, obj)  # type: ignore
+        return pydantic.TypeAdapter(Filter).validate_python(obj)  # type: ignore
 
 
 # We need FilterDsl for two reasons:

datahub/secret/datahub_secret_store.py

@@ -1,7 +1,7 @@
 import logging
 from typing import Any, Dict, List, Optional, Union
 
-from pydantic import BaseModel, validator
+from pydantic import BaseModel, field_validator
 
 from datahub.ingestion.graph.client import DataHubGraph
 from datahub.ingestion.graph.config import DatahubClientConfig
@@ -18,8 +18,11 @@ class DataHubSecretStoreConfig(BaseModel):
     class Config:
         arbitrary_types_allowed = True
 
-    @validator("graph_client")
-    def check_graph_connection(cls, v: DataHubGraph) -> DataHubGraph:
+    @field_validator("graph_client", mode="after")
+    @classmethod
+    def check_graph_connection(
+        cls, v: Optional[DataHubGraph]
+    ) -> Optional[DataHubGraph]:
         if v is not None:
             v.test_connection()
         return v
@@ -63,7 +66,7 @@ class DataHubSecretStore(SecretStore):
 
     @classmethod
     def create(cls, config: Any) -> "DataHubSecretStore":
-        config = DataHubSecretStoreConfig.parse_obj(config)
+        config = DataHubSecretStoreConfig.model_validate(config)
         return cls(config)
 
     def close(self) -> None:

datahub/secret/file_secret_store.py

@@ -45,5 +45,5 @@ class FileSecretStore(SecretStore):
 
     @classmethod
     def create(cls, config: Any) -> "FileSecretStore":
-        config = FileSecretStoreConfig.parse_obj(config)
+        config = FileSecretStoreConfig.model_validate(config)
         return cls(config)

datahub/sql_parsing/sqlglot_lineage.py

@@ -28,6 +28,7 @@ import sqlglot.optimizer.optimizer
 import sqlglot.optimizer.qualify
 import sqlglot.optimizer.qualify_columns
 import sqlglot.optimizer.unnest_subqueries
+from pydantic import field_validator
 
 from datahub.cli.env_utils import get_boolean_env_variable
 from datahub.ingestion.graph.client import DataHubGraph
@@ -141,7 +142,8 @@ class DownstreamColumnRef(_ParserBaseModel):
     column_type: Optional[SchemaFieldDataTypeClass] = None
     native_column_type: Optional[str] = None
 
-    @pydantic.validator("column_type", pre=True)
+    @field_validator("column_type", mode="before")
+    @classmethod
     def _load_column_type(
         cls, v: Optional[Union[dict, SchemaFieldDataTypeClass]]
     ) -> Optional[SchemaFieldDataTypeClass]:
@@ -215,7 +217,8 @@ class SqlParsingDebugInfo(_ParserBaseModel):
     def error(self) -> Optional[Exception]:
         return self.table_error or self.column_error
 
-    @pydantic.validator("table_error", "column_error")
+    @field_validator("table_error", "column_error", mode="before")
+    @classmethod
     def remove_variables_from_error(cls, v: Optional[Exception]) -> Optional[Exception]:
         if v and v.__traceback__:
             # Remove local variables from the traceback to avoid memory leaks.

datahub/testing/check_sql_parser_result.py

@@ -60,8 +60,8 @@ def assert_sql_result_with_resolver(
     expected = SqlParsingResult.parse_raw(expected_file.read_text())
 
     full_diff = deepdiff.DeepDiff(
-        expected.dict(),
-        res.dict(),
+        expected.model_dump(),
+        res.model_dump(),
         exclude_regex_paths=[
             r"root.column_lineage\[\d+\].logic",
         ],

datahub/utilities/ingest_utils.py

@@ -48,7 +48,7 @@ def deploy_source_vars(
 
     deploy_options_raw = pipeline_config.pop("deployment", None)
     if deploy_options_raw is not None:
-        deploy_options = DeployOptions.parse_obj(deploy_options_raw)
+        deploy_options = DeployOptions.model_validate(deploy_options_raw)
 
         if name:
             logger.info(f"Overriding deployment name {deploy_options.name} with {name}")