acryl-datahub 1.2.0.11rc1__py3-none-any.whl → 1.2.0.11rc2__py3-none-any.whl

datahub/ingestion/source/looker/view_upstream.py

@@ -1,18 +1,33 @@
 import logging
 import re
 from abc import ABC, abstractmethod
+from datetime import datetime
 from functools import lru_cache
 from typing import Dict, List, Optional
 
+from looker_sdk.sdk.api40.models import (
+    WriteQuery,
+)
+
 from datahub.emitter.mce_builder import make_dataset_urn_with_platform_instance
 from datahub.ingestion.api.common import PipelineContext
 from datahub.ingestion.source.looker.looker_common import (
     LookerExplore,
     LookerViewId,
     ViewField,
+    ViewFieldDimensionGroupType,
     ViewFieldType,
 )
 from datahub.ingestion.source.looker.looker_config import LookerConnectionDefinition
+from datahub.ingestion.source.looker.looker_constant import (
+    NAME,
+    VIEW_FIELD_INTERVALS_ATTRIBUTE,
+    VIEW_FIELD_TIMEFRAMES_ATTRIBUTE,
+    VIEW_FIELD_TYPE_ATTRIBUTE,
+)
+from datahub.ingestion.source.looker.looker_lib_wrapper import (
+    LookerAPI,
+)
 from datahub.ingestion.source.looker.looker_view_id_cache import LookerViewIdCache
 from datahub.ingestion.source.looker.lookml_concept_context import (
     LookerFieldContext,
@@ -20,7 +35,6 @@ from datahub.ingestion.source.looker.lookml_concept_context import (
 )
 from datahub.ingestion.source.looker.lookml_config import (
     DERIVED_VIEW_SUFFIX,
-    NAME,
     LookMLSourceConfig,
     LookMLSourceReport,
 )
@@ -280,6 +294,447 @@ class AbstractViewUpstream(ABC):
         return upstream_column_refs
 
 
+class LookerQueryAPIBasedViewUpstream(AbstractViewUpstream):
+    """
+    Implements Looker view upstream lineage extraction using the Looker Query API.
+
+    This class leverages the Looker API to generate the fully resolved SQL for a Looker view by constructing a WriteQuery
+    that includes all dimensions, dimension groups and measures. The SQL is then parsed to extract column-level lineage.
+    The Looker client is required for this class, as it is used to execute the WriteQuery and retrieve the SQL.
+
+    Other view upstream implementations use string parsing to extract lineage information from the SQL, which does not cover all the edge cases.
+    Limitations of string based lineage extraction: Ref: https://cloud.google.com/looker/docs/reference/param-field-sql#sql_for_dimensions
+
+    Key Features:
+    - Requires a Looker client (`looker_client`) to execute queries and retrieve SQL for the view.
+    - Requires a `view_to_explore_map` to map view names to their corresponding explore name
+    - Field name translation is handled: Looker API field names are constructed as `<view_name>.<field_name>`, and helper
+      methods are provided to convert between Looker API field names and raw field names.
+    - SQL parsing is cached for efficiency, and the class is designed to gracefully fall back if the Looker Query API fails.
+    - All lineage extraction is based on the SQL returned by the Looker API, ensuring accurate and up-to-date lineage.
+
+    Why view_to_explore_map is required:
+    The Looker Query API expects the explore name (not the view name) as the "view" parameter in the WriteQuery.
+    In Looker, a view can be referenced by multiple explores, but the API needs any one of the
+    explores to access the view's fields
+
+    Example WriteQuery request (see `_execute_query` for details):
+        {
+            "model": "test_model",
+            "view": "users_explore",  # This is the explore name, not the view name
+            "fields": [
+                "users.email", "users.lifetime_purchase_count"
+            ],
+            "limit": "1",
+            "cache": true
+        }
+    The SQL response is then parsed to extract upstream tables and column-level lineage.
+
+    For further details, see the method-level docstrings, especially:
+      - `__get_spr`: SQL parsing and lineage extraction workflow
+      - `_get_sql_write_query`: WriteQuery construction and field enumeration
+      - `_execute_query`: Looker API invocation and SQL retrieval - this only generates the SQL query, does not execute it
+      - Field name translation: `_get_looker_api_field_name` and `_get_field_name_from_looker_api_field_name`
+
+    Note: This class is intended to be robust and raise exceptions if SQL parsing or API calls fail, and will fall back to
+    other implementations - custom regex-based parsing if necessary.
+    """
+
+    def __init__(
+        self,
+        view_context: LookerViewContext,
+        looker_view_id_cache: LookerViewIdCache,
+        config: LookMLSourceConfig,
+        reporter: LookMLSourceReport,
+        ctx: PipelineContext,
+        looker_client: LookerAPI,
+        view_to_explore_map: Dict[str, str],
+    ):
+        super().__init__(view_context, looker_view_id_cache, config, reporter, ctx)
+        self.looker_client = looker_client
+        self.view_to_explore_map = view_to_explore_map
+        # Cache the SQL parsing results
+        # We use maxsize=1 because a new class instance is created for each view, Ref: view_upstream.create_view_upstream
+        self._get_spr = lru_cache(maxsize=1)(self.__get_spr)
+        self._get_upstream_dataset_urn = lru_cache(maxsize=1)(
+            self.__get_upstream_dataset_urn
+        )
+
+        # Initialize the cache
+        # Done to fallback to other implementations if the Looker Query API fails
+        self._get_spr()
+
+    def __get_spr(self) -> SqlParsingResult:
+        """
+        Retrieves the SQL parsing result for the current Looker view by:
+        1. Building a WriteQuery for the view.
+        2. Executing the query via the Looker API to get the SQL.
+        3. Parsing the SQL to extract lineage information.
+
+        Returns:
+            SqlParsingResult if successful, otherwise None.
+        Raises:
+            ValueError: If no SQL is found in the response.
+            ValueError: If no fields are found for the view.
+            ValueError: If explore name is not found for the view.
+            ValueError: If error in parsing SQL for upstream tables.
+            ValueError: If error in parsing SQL for column lineage.
+        """
+        try:
+            # Build the WriteQuery for the current view.
+            sql_query: WriteQuery = self._get_sql_write_query()
+
+            # Execute the query to get the SQL representation from Looker.
+            sql_response = self._execute_query(sql_query)
+
+            # Parse the SQL to extract lineage information.
+            spr = create_lineage_sql_parsed_result(
+                query=sql_response,
+                default_schema=self.view_context.view_connection.default_schema,
+                default_db=self.view_context.view_connection.default_db,
+                platform=self.view_context.view_connection.platform,
+                platform_instance=self.view_context.view_connection.platform_instance,
+                env=self.view_context.view_connection.platform_env or self.config.env,
+                graph=self.ctx.graph,
+            )
+
+            # Check for errors encountered during table extraction.
+            table_error = spr.debug_info.table_error
+            if table_error is not None:
+                self.reporter.report_warning(
+                    title="Table Level Lineage Extraction Failed",
+                    message="Error in parsing derived sql",
+                    context=f"View-name: {self.view_context.name()}",
+                    exc=table_error,
+                )
+                raise ValueError(
+                    f"Error in parsing SQL for upstream tables: {table_error}"
+                )
+
+            column_error = spr.debug_info.column_error
+            if column_error is not None:
+                self.reporter.report_warning(
+                    title="Column Level Lineage Extraction Failed",
+                    message="Error in parsing derived sql",
+                    context=f"View-name: {self.view_context.name()}",
+                    exc=column_error,
+                )
+                raise ValueError(
+                    f"Error in parsing SQL for column lineage: {column_error}"
+                )
+
+            return spr
+        except Exception:
+            # Reraise the exception to allow higher-level handling.
+            raise
+
+    def _get_time_dim_group_field_name(self, dim_group: dict) -> str:
+        """
+        Time dimension groups must be referenced by their individual timeframes suffix.
+        Example:
+            dimension_group: created {
+                type: time
+                timeframes: [date, week, month]
+                sql: ${TABLE}.created_at ;;
+            }
+        Used as: {view_name.date_created}
+
+        created -> created_date, created_week, created_month
+        # Ref: https://cloud.google.com/looker/docs/reference/param-field-dimension-group#dimension_groups_must_be_referenced_by_their_individual_dimensions
+        """
+        dim_group_name = dim_group.get(NAME)
+        timeframes = dim_group.get(VIEW_FIELD_TIMEFRAMES_ATTRIBUTE)
+
+        # If timeframes is not included (rare case), the dimension group will include all possible timeframes.
+        # We will pick to use "raw"
+        suffix = timeframes[0] if timeframes else "raw"
+        return f"{dim_group_name}_{suffix}"
+
+    def _get_duration_dim_group_field_name(self, dim_group: dict) -> str:
+        """
+        Duration dimension groups must be referenced by their plural version of the interval value as prefix
+        Example:
+            dimension_group: since_event {
+                type: duration
+                intervals: [hour, day, week, month, quarter, year]
+                sql_start: ${faa_event_date_raw} ;;
+                sql_end: CURRENT_TIMESTAMP();;
+            }
+        Used as: {view_name.hours_since_event}
+
+        since_event -> hours_since_event, days_since_event, weeks_since_event, months_since_event, quarters_since_event, years_since_event
+        # Ref: https://cloud.google.com/looker/docs/reference/param-field-dimension-group#referencing_intervals_from_another_lookml_field
+        """
+        dim_group_name = dim_group.get(NAME)
+        intervals = dim_group.get(VIEW_FIELD_INTERVALS_ATTRIBUTE)
+
+        # If intervals is not included (rare case), the dimension group will include all possible intervals.
+        # We will pick to use "day" -> "days"
+        prefix = f"{intervals[0]}s" if intervals else "days"
+        return f"{prefix}_{dim_group_name}"
+
+    def _get_sql_write_query(self) -> WriteQuery:
+        """
+        Constructs a WriteQuery object to obtain the SQL representation of the current Looker view.
+
+        We need to list all the fields for the view to get the SQL representation of the view - this fully resolved SQL for view dimensions and measures.
+
+        The method uses the view_to_explore_map to determine the correct explore name to use in the WriteQuery.
+        This is crucial because the Looker Query API expects the explore name (not the view name) as the "view" parameter.
+
+        Ref: https://cloud.google.com/looker/docs/reference/param-field-sql#sql_for_dimensions
+
+        Returns:
+            WriteQuery: The WriteQuery object if fields are found and explore name is available, otherwise None.
+
+        Raises:
+            ValueError: If the explore name is not found in the view_to_explore_map for the current view.
+            ValueError: If no fields are found for the view.
+        """
+
+        # Collect all dimension and measure fields for the view.
+        view_fields: List[str] = []
+        # Add dimension fields in the format: <view_name>.<dimension_name> or <view_name>.<measure_name>
+        for field in self.view_context.dimensions() + self.view_context.measures():
+            field_name = field.get(NAME)
+            assert field_name  # Happy linter
+            view_fields.append(self._get_looker_api_field_name(field_name))
+
+        for dim_group in self.view_context.dimension_groups():
+            dim_group_type: ViewFieldDimensionGroupType = ViewFieldDimensionGroupType(
+                dim_group.get(VIEW_FIELD_TYPE_ATTRIBUTE)
+            )
+
+            if dim_group_type == ViewFieldDimensionGroupType.TIME:
+                view_fields.append(
+                    self._get_looker_api_field_name(
+                        self._get_time_dim_group_field_name(dim_group)
+                    )
+                )
+            elif dim_group_type == ViewFieldDimensionGroupType.DURATION:
+                view_fields.append(
+                    self._get_looker_api_field_name(
+                        self._get_duration_dim_group_field_name(dim_group)
+                    )
+                )
+
+        # Use explore name from view_to_explore_map if available
+        # explore_name is always present in the view_to_explore_map because of the check in view_upstream.create_view_upstream
+        explore_name = self.view_to_explore_map.get(self.view_context.name())
+        assert explore_name  # Happy linter
+
+        if not view_fields:
+            raise ValueError(
+                f"No fields found for view '{self.view_context.name()}'. Cannot proceed with Looker API for view lineage."
+            )
+
+        # Construct and return the WriteQuery object.
+        # The 'limit' is set to "1" as the query is only used to obtain SQL, not to fetch data.
+        return WriteQuery(
+            model=self.looker_view_id_cache.model_name,
+            view=explore_name,
+            fields=view_fields,
+            filters={},
+            limit="1",
+        )
+
+    def _execute_query(self, query: WriteQuery) -> str:
+        """
+        Executes a Looker SQL query using the Looker API and returns the SQL string.
+
+        Ref: https://cloud.google.com/looker/docs/reference/looker-api/latest/methods/Query/run_inline_query
+
+        Example Request:
+            WriteQuery:
+                {
+                    "model": "test_model",
+                    "view": "users",
+                    "fields": [
+                        "users.email", "users.lifetime_purchase_count"
+                    ],
+                    "limit": "1",
+                    "cache": true
+                }
+
+            Response:
+                "
+                SELECT
+                    users."EMAIL"  AS "users.email",
+                    COUNT(DISTINCT ( purchases."PK"  ) ) AS "users.lifetime_purchase_count"
+                FROM "ECOMMERCE"."USERS"  AS users
+                LEFT JOIN "ECOMMERCE"."PURCHASES"  AS purchases ON (users."PK") = (purchases."USER_FK")
+                GROUP BY
+                    1
+                ORDER BY
+                    2 DESC
+                FETCH NEXT 1 ROWS ONLY
+                "
+        Args:
+            query (WriteQuery): The Looker WriteQuery object to execute.
+
+        Returns:
+            str: The SQL string returned by the Looker API, or an empty string if execution fails.
+        """
+
+        # Record the start time for latency measurement.
+        start_time = datetime.now()
+
+        # Execute the query using the Looker client.
+        sql_response = self.looker_client.generate_sql_query(
+            write_query=query, use_cache=self.config.use_api_cache_for_view_lineage
+        )
+
+        # Record the end time after query execution.
+        end_time = datetime.now()
+
+        # Attempt to get the LookerViewId for reporting.
+        looker_view_id: Optional[LookerViewId] = (
+            self.looker_view_id_cache.get_looker_view_id(
+                view_name=self.view_context.name(),
+                base_folder_path=self.view_context.base_folder_path,
+            )
+        )
+
+        # Report the query API latency if the view ID is available.
+        if looker_view_id is not None:
+            self.reporter.report_looker_query_api_latency(
+                looker_view_id.get_urn(self.config),
+                end_time - start_time,
+            )
+
+        # Validate the response structure.
+        if not sql_response:
+            raise ValueError(
+                f"No SQL found in response for view '{self.view_context.name()}'. Response: {sql_response}"
+            )
+
+        # Extract the SQL string from the response.
+        return sql_response
+
+    def __get_upstream_dataset_urn(self) -> List[Urn]:
+        """
+        Extract upstream dataset URNs by parsing the SQL for the current view.
+
+        Returns:
+            List[Urn]: List of upstream dataset URNs, or an empty list if parsing fails.
+        """
+        # Attempt to get the SQL parsing result for the current view.
+        spr: SqlParsingResult = self._get_spr()
+
+        # Remove any 'hive.' prefix from upstream table URNs.
+        upstream_dataset_urns: List[str] = [
+            _drop_hive_dot(urn) for urn in spr.in_tables
+        ]
+
+        # Fix any derived view references present in the URNs.
+        upstream_dataset_urns = fix_derived_view_urn(
+            urns=upstream_dataset_urns,
+            looker_view_id_cache=self.looker_view_id_cache,
+            base_folder_path=self.view_context.base_folder_path,
+            config=self.config,
+        )
+
+        return upstream_dataset_urns
+
+    def _get_looker_api_field_name(self, field_name: str) -> str:
+        """
+        Translate the field name to the looker api field name
+
+        Example:
+            pk -> purchases.pk
+        """
+        return f"{self.view_context.name()}.{field_name}"
+
+    def _get_field_name_from_looker_api_field_name(
+        self, looker_api_field_name: str
+    ) -> str:
+        """
+        Translate the looker api field name to the field name
+
+        Example:
+            purchases.pk -> pk
+        """
+        # Remove the view name at the start and the dot from the looker_api_field_name, but only if it matches the current view name
+        prefix = f"{self.view_context.name()}."
+        if looker_api_field_name.startswith(prefix):
+            return looker_api_field_name[len(prefix) :]
+        else:
+            # Don't throw an error, just return the original field name
+            return looker_api_field_name
+
+    def get_upstream_dataset_urn(self) -> List[Urn]:
+        """Get upstream dataset URNs"""
+        return self._get_upstream_dataset_urn()
+
+    def get_upstream_column_ref(
+        self, field_context: LookerFieldContext
+    ) -> List[ColumnRef]:
+        """Return upstream column references for a given field."""
+        spr: SqlParsingResult = self._get_spr()
+        if not spr.column_lineage:
+            return []
+
+        field_type: Optional[ViewFieldDimensionGroupType] = None
+        field_name = field_context.name()
+        try:
+            # Try if field is a dimension group
+            field_type = ViewFieldDimensionGroupType(
+                field_context.raw_field.get(VIEW_FIELD_TYPE_ATTRIBUTE)
+            )
+
+            if field_type == ViewFieldDimensionGroupType.TIME:
+                field_name = self._get_time_dim_group_field_name(
+                    field_context.raw_field
+                )
+            elif field_type == ViewFieldDimensionGroupType.DURATION:
+                field_name = self._get_duration_dim_group_field_name(
+                    field_context.raw_field
+                )
+
+        except Exception:
+            # Not a dimension group, no modification needed
+            logger.debug(
+                f"view-name={self.view_context.name()}, field-name={field_name}, field-type={field_context.raw_field.get(VIEW_FIELD_TYPE_ATTRIBUTE)}"
+            )
+
+        field_api_name = self._get_looker_api_field_name(field_name).lower()
+
+        upstream_refs: List[ColumnRef] = []
+
+        for lineage in spr.column_lineage:
+            if lineage.downstream.column.lower() == field_api_name:
+                for upstream in lineage.upstreams:
+                    upstream_refs.append(
+                        ColumnRef(table=upstream.table, column=upstream.column)
+                    )
+
+        return _drop_hive_dot_from_upstream(upstream_refs)
+
+    def create_fields(self) -> List[ViewField]:
+        """Create ViewField objects from SQL parsing result."""
+        spr: SqlParsingResult = self._get_spr()
+
+        if not spr.column_lineage:
+            return []
+
+        fields: List[ViewField] = []
+
+        for lineage in spr.column_lineage:
+            fields.append(
+                ViewField(
+                    name=self._get_field_name_from_looker_api_field_name(
+                        lineage.downstream.column
+                    ),
+                    label="",
+                    type=lineage.downstream.native_column_type or "unknown",
+                    description="",
+                    field_type=ViewFieldType.UNKNOWN,
+                    upstream_fields=_drop_hive_dot_from_upstream(lineage.upstreams),
+                )
+            )
+        return fields
+
+
 class SqlBasedDerivedViewUpstream(AbstractViewUpstream, ABC):
     """
     Handle the case where upstream dataset is defined in derived_table.sql
@@ -674,7 +1129,45 @@ def create_view_upstream(
     config: LookMLSourceConfig,
     ctx: PipelineContext,
     reporter: LookMLSourceReport,
+    looker_client: Optional["LookerAPI"] = None,
+    view_to_explore_map: Optional[Dict[str, str]] = None,
 ) -> AbstractViewUpstream:
+    # Looker client is required for LookerQueryAPIBasedViewUpstream also enforced by config.use_api_for_view_lineage
+    # view_to_explore_map is required for Looker query API args
+    # Only process if view exists in view_to_explore_map, because we cannot query views which are not reachable from an explore
+    if (
+        config.use_api_for_view_lineage
+        and looker_client
+        and view_to_explore_map
+        and view_context.name() in view_to_explore_map
+    ):
+        try:
+            return LookerQueryAPIBasedViewUpstream(
+                view_context=view_context,
+                config=config,
+                reporter=reporter,
+                ctx=ctx,
+                looker_view_id_cache=looker_view_id_cache,
+                looker_client=looker_client,
+                view_to_explore_map=view_to_explore_map,
+            )
+        except Exception as e:
+            # Falling back to custom regex-based parsing - best effort approach
+            reporter.report_warning(
+                title="Looker Query API based View Upstream Failed",
+                message="Error in getting upstream lineage for view using Looker Query API",
+                context=f"View-name: {view_context.name()}",
+                exc=e,
+            )
+    else:
+        logger.debug(
+            f"Skipping Looker Query API for view: {view_context.name()} because one or more conditions are not met: "
+            f"use_api_for_view_lineage={config.use_api_for_view_lineage}, "
+            f"looker_client={'set' if looker_client else 'not set'}, "
+            f"view_to_explore_map={'set' if view_to_explore_map else 'not set'}, "
+            f"view_in_view_to_explore_map={view_context.name() in view_to_explore_map if view_to_explore_map else False}"
+        )
+
     if view_context.is_regular_case():
         return RegularViewUpstream(
             view_context=view_context,

datahub/sdk/search_filters.py

@@ -30,7 +30,14 @@ from datahub.ingestion.graph.filters import (
     _get_status_filter,
 )
 from datahub.metadata.schema_classes import EntityTypeName
-from datahub.metadata.urns import ContainerUrn, DataPlatformUrn, DomainUrn
+from datahub.metadata.urns import (
+    ContainerUrn,
+    CorpGroupUrn,
+    CorpUserUrn,
+    DataPlatformUrn,
+    DomainUrn,
+)
+from datahub.utilities.urns.urn import guess_entity_type
 
 _AndSearchFilterRule = TypedDict(
     "_AndSearchFilterRule", {"and": List[SearchFilterRule]}
@@ -235,6 +242,94 @@ class _EnvFilter(_BaseFilter):
         ]
 
 
+class _OwnerFilter(_BaseFilter):
+    """Filter for entities owned by specific users or groups."""
+
+    owner: List[str] = pydantic.Field(
+        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}")
+
+    def _build_rule(self) -> SearchFilterRule:
+        return SearchFilterRule(
+            field="owners",
+            condition="EQUAL",
+            values=self.owner,
+        )
+
+    def compile(self) -> _OrFilters:
+        return [{"and": [self._build_rule()]}]
+
+
+class _GlossaryTermFilter(_BaseFilter):
+    """Filter for entities associated with specific glossary terms."""
+
+    glossary_term: List[str] = pydantic.Field(
+        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
+
+    def _build_rule(self) -> SearchFilterRule:
+        return SearchFilterRule(
+            field="glossaryTerms",
+            condition="EQUAL",
+            values=self.glossary_term,
+        )
+
+    def compile(self) -> _OrFilters:
+        return [{"and": [self._build_rule()]}]
+
+
+class _TagFilter(_BaseFilter):
+    """Filter for entities associated with specific tags."""
+
+    tag: List[str] = pydantic.Field(
+        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
+
+    def _build_rule(self) -> SearchFilterRule:
+        return SearchFilterRule(
+            field="tags",
+            condition="EQUAL",
+            values=self.tag,
+        )
+
+    def compile(self) -> _OrFilters:
+        return [{"and": [self._build_rule()]}]
+
+
 class _CustomCondition(_BaseFilter):
     """Represents a single field condition."""
 
@@ -407,6 +502,9 @@ if TYPE_CHECKING or not PYDANTIC_SUPPORTS_CALLABLE_DISCRIMINATOR:
         _DomainFilter,
         _ContainerFilter,
         _EnvFilter,
+        _OwnerFilter,
+        _GlossaryTermFilter,
+        _TagFilter,
         _CustomCondition,
     ]
 
@@ -448,6 +546,11 @@ else:
                     _ContainerFilter, Tag(_ContainerFilter._field_discriminator())
                 ],
                 Annotated[_EnvFilter, Tag(_EnvFilter._field_discriminator())],
+                Annotated[_OwnerFilter, Tag(_OwnerFilter._field_discriminator())],
+                Annotated[
+                    _GlossaryTermFilter, Tag(_GlossaryTermFilter._field_discriminator())
+                ],
+                Annotated[_TagFilter, Tag(_TagFilter._field_discriminator())],
                 Annotated[
                     _CustomCondition, Tag(_CustomCondition._field_discriminator())
                 ],
@@ -551,6 +654,24 @@ class FilterDsl:
     def env(env: Union[str, Sequence[str]], /) -> _EnvFilter:
         return _EnvFilter(env=[env] if isinstance(env, str) else env)
 
+    @staticmethod
+    def owner(owner: Union[str, Sequence[str]], /) -> _OwnerFilter:
+        return _OwnerFilter(owner=[owner] if isinstance(owner, str) else owner)
+
+    @staticmethod
+    def glossary_term(
+        glossary_term: Union[str, Sequence[str]], /
+    ) -> _GlossaryTermFilter:
+        return _GlossaryTermFilter(
+            glossary_term=[glossary_term]
+            if isinstance(glossary_term, str)
+            else glossary_term
+        )
+
+    @staticmethod
+    def tag(tag: Union[str, Sequence[str]], /) -> _TagFilter:
+        return _TagFilter(tag=[tag] if isinstance(tag, str) else tag)
+
     @staticmethod
     def has_custom_property(key: str, value: str) -> _CustomCondition:
         return _CustomCondition(

datahub/secret/datahub_secret_store.py

@@ -65,3 +65,6 @@ class DataHubSecretStore(SecretStore):
     def create(cls, config: Any) -> "DataHubSecretStore":
         config = DataHubSecretStoreConfig.parse_obj(config)
         return cls(config)
+
+    def close(self) -> None:
+        self.client.graph.close()