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

datahub/ingestion/transformer/add_dataset_dataproduct.py

@@ -1,7 +1,7 @@
 import logging
 from typing import Callable, Dict, List, Optional, Union
 
-import pydantic
+from pydantic import model_validator
 
 from datahub.configuration.common import ConfigModel, KeyValuePattern
 from datahub.configuration.import_resolver import pydantic_resolve_key
@@ -39,7 +39,7 @@ class AddDatasetDataProduct(DatasetDataproductTransformer):
 
     @classmethod
     def create(cls, config_dict: dict, ctx: PipelineContext) -> "AddDatasetDataProduct":
-        config = AddDatasetDataProductConfig.parse_obj(config_dict)
+        config = AddDatasetDataProductConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     def transform_aspect(
@@ -116,7 +116,7 @@ class SimpleAddDatasetDataProduct(AddDatasetDataProduct):
     def create(
         cls, config_dict: dict, ctx: PipelineContext
     ) -> "SimpleAddDatasetDataProduct":
-        config = SimpleDatasetDataProductConfig.parse_obj(config_dict)
+        config = SimpleDatasetDataProductConfig.model_validate(config_dict)
         return cls(config, ctx)
 
 
@@ -124,7 +124,8 @@ class PatternDatasetDataProductConfig(ConfigModel):
     dataset_to_data_product_urns_pattern: KeyValuePattern = KeyValuePattern.all()
     is_container: bool = False
 
-    @pydantic.root_validator(pre=True)
+    @model_validator(mode="before")
+    @classmethod
     def validate_pattern_value(cls, values: Dict) -> Dict:
         rules = values["dataset_to_data_product_urns_pattern"]["rules"]
         for key, value in rules.items():
@@ -156,5 +157,5 @@ class PatternAddDatasetDataProduct(AddDatasetDataProduct):
     def create(
         cls, config_dict: dict, ctx: PipelineContext
     ) -> "PatternAddDatasetDataProduct":
-        config = PatternDatasetDataProductConfig.parse_obj(config_dict)
+        config = PatternDatasetDataProductConfig.model_validate(config_dict)
         return cls(config, ctx)

datahub/ingestion/transformer/add_dataset_ownership.py

@@ -55,7 +55,7 @@ class AddDatasetOwnership(OwnershipTransformer):
 
     @classmethod
     def create(cls, config_dict: dict, ctx: PipelineContext) -> "AddDatasetOwnership":
-        config = AddDatasetOwnershipConfig.parse_obj(config_dict)
+        config = AddDatasetOwnershipConfig.model_validate(config_dict)
         return cls(config, ctx)
 
     @staticmethod
@@ -209,7 +209,7 @@ class SimpleAddDatasetOwnership(AddDatasetOwnership):
     def create(
         cls, config_dict: dict, ctx: PipelineContext
     ) -> "SimpleAddDatasetOwnership":
-        config = SimpleDatasetOwnershipConfig.parse_obj(config_dict)
+        config = SimpleDatasetOwnershipConfig.model_validate(config_dict)
         return cls(config, ctx)
 
 
@@ -247,5 +247,5 @@ class PatternAddDatasetOwnership(AddDatasetOwnership):
     def create(
         cls, config_dict: dict, ctx: PipelineContext
     ) -> "PatternAddDatasetOwnership":
-        config = PatternDatasetOwnershipConfig.parse_obj(config_dict)
+        config = PatternDatasetOwnershipConfig.model_validate(config_dict)
         return cls(config, ctx)

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/metadata/schema.avsc

@@ -4824,7 +4824,7 @@
               {
                 "Searchable": {
                   "fieldName": "entities",
-                  "fieldType": "URN"
+                  "fieldType": "KEYWORD"
                 },
                 "java": {
                   "class": "com.linkedin.pegasus2avro.common.urn.Urn"
@@ -20303,7 +20303,12 @@
         "doc": "The fully qualified name of the property. e.g. io.acryl.datahub.myProperty"
       },
       {
-        "Searchable": {},
+        "Searchable": {
+          "enableAutocomplete": true,
+          "fieldType": "WORD_GRAM",
+          "searchLabel": "entityName",
+          "searchTier": 1
+        },
         "type": [
           "null",
           "string"

datahub/metadata/schemas/QuerySubjects.avsc

@@ -17,7 +17,7 @@
             {
               "Searchable": {
                 "fieldName": "entities",
-                "fieldType": "URN"
+                "fieldType": "KEYWORD"
               },
               "java": {
                 "class": "com.linkedin.pegasus2avro.common.urn.Urn"

datahub/metadata/schemas/StructuredPropertyDefinition.avsc

@@ -17,7 +17,12 @@
       "doc": "The fully qualified name of the property. e.g. io.acryl.datahub.myProperty"
     },
     {
-      "Searchable": {},
+      "Searchable": {
+        "enableAutocomplete": true,
+        "fieldType": "WORD_GRAM",
+        "searchLabel": "entityName",
+        "searchTier": 1
+      },
       "type": [
         "null",
         "string"

datahub/sdk/__init__.py

@@ -28,6 +28,7 @@ from datahub.sdk.main_client import DataHubClient
 from datahub.sdk.mlmodel import MLModel
 from datahub.sdk.mlmodelgroup import MLModelGroup
 from datahub.sdk.search_filters import Filter, FilterDsl
+from datahub.sdk.tag import Tag
 
 # We want to print out the warning if people do `from datahub.sdk import X`.
 # But we don't want to print out warnings if they're doing a more direct

datahub/sdk/_all_entities.py

@@ -9,6 +9,7 @@ from datahub.sdk.dataset import Dataset
 from datahub.sdk.entity import Entity
 from datahub.sdk.mlmodel import MLModel
 from datahub.sdk.mlmodelgroup import MLModelGroup
+from datahub.sdk.tag import Tag
 
 # Base entity classes that don't have circular dependencies
 # Those that do are imported in the EntityClient where needed
@@ -22,6 +23,7 @@ ENTITY_CLASSES_LIST: List[Type[Entity]] = [
     DataJob,
     Dashboard,
     Chart,
+    Tag,
 ]
 
 # Create the mapping of entity types to classes

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: