acryl-datahub 1.0.0rc18__py3-none-any.whl → 1.3.0.1rc9__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/ingestion/source/metabase.py

@@ -13,7 +13,10 @@ from pydantic import Field, root_validator, validator
 from requests.models import HTTPError
 
 import datahub.emitter.mce_builder as builder
-from datahub.configuration.source_common import DatasetLineageProviderConfigBase
+from datahub.configuration.source_common import (
+    DatasetLineageProviderConfigBase,
+    LowerCaseDatasetUrnConfigMixin,
+)
 from datahub.ingestion.api.common import PipelineContext
 from datahub.ingestion.api.decorators import (
     SourceCapability,
@@ -49,6 +52,7 @@ from datahub.metadata.schema_classes import (
     ChartQueryTypeClass,
     ChartTypeClass,
     DashboardInfoClass,
+    EdgeClass,
     OwnerClass,
     OwnershipClass,
     OwnershipTypeClass,
@@ -61,7 +65,11 @@ logger = logging.getLogger(__name__)
 DATASOURCE_URN_RECURSION_LIMIT = 5
 
 
-class MetabaseConfig(DatasetLineageProviderConfigBase, StatefulIngestionConfigBase):
+class MetabaseConfig(
+    DatasetLineageProviderConfigBase,
+    StatefulIngestionConfigBase,
+    LowerCaseDatasetUrnConfigMixin,
+):
     # See the Metabase /api/session endpoint for details
     # https://www.metabase.com/docs/latest/api-documentation.html#post-apisession
     connect_uri: str = Field(default="localhost:3000", description="Metabase host URL.")
@@ -331,19 +339,25 @@ class MetabaseSource(StatefulIngestionSourceBase):
             lastModified=AuditStamp(time=modified_ts, actor=modified_actor),
         )
 
-        chart_urns = []
+        # Convert chart URNs to chart edges (instead of deprecated charts field)
+        chart_edges = []
         cards_data = dashboard_details.get("dashcards", {})
         for card_info in cards_data:
             card_id = card_info.get("card").get("id", "")
             if not card_id:
                 continue  # most likely a virtual card without an id (text or heading), not relevant.
             chart_urn = builder.make_chart_urn(self.platform, str(card_id))
-            chart_urns.append(chart_urn)
+            chart_edges.append(
+                EdgeClass(
+                    destinationUrn=chart_urn,
+                    lastModified=last_modified.lastModified,
+                )
+            )
 
         dashboard_info_class = DashboardInfoClass(
             description=description,
             title=title,
-            charts=chart_urns,
+            chartEdges=chart_edges,
             lastModified=last_modified,
             dashboardUrl=f"{self.config.display_uri}/dashboard/{dashboard_id}",
             customProperties={},
@@ -481,13 +495,25 @@ class MetabaseSource(StatefulIngestionSourceBase):
         datasource_urn = self.get_datasource_urn(card_details)
         custom_properties = self.construct_card_custom_properties(card_details)
 
+        input_edges = (
+            [
+                EdgeClass(
+                    destinationUrn=urn,
+                    lastModified=last_modified.lastModified,
+                )
+                for urn in datasource_urn
+            ]
+            if datasource_urn
+            else None
+        )
+
         chart_info = ChartInfoClass(
             type=chart_type,
             description=description,
             title=title,
             lastModified=last_modified,
             chartUrl=f"{self.config.display_uri}/card/{card_id}",
-            inputs=datasource_urn,
+            inputEdges=input_edges,
             customProperties=custom_properties,
         )
         chart_snapshot.aspects.append(chart_info)

datahub/ingestion/source/metadata/business_glossary.py

@@ -5,11 +5,11 @@ import time
 from dataclasses import dataclass, field
 from typing import Any, Dict, Iterable, List, Optional, TypeVar, Union
 
-from pydantic import validator
+import pydantic
 from pydantic.fields import Field
 
 import datahub.metadata.schema_classes as models
-from datahub.configuration.common import ConfigModel
+from datahub.configuration.common import ConfigModel, LaxStr
 from datahub.configuration.config_loader import load_config_file
 from datahub.emitter.mce_builder import (
     datahub_guid,
@@ -66,7 +66,7 @@ class GlossaryTermConfig(ConfigModel):
     contains: Optional[List[str]] = None
     values: Optional[List[str]] = None
     related_terms: Optional[List[str]] = None
-    custom_properties: Optional[Dict[str, str]] = None
+    custom_properties: Optional[Dict[str, LaxStr]] = None
     knowledge_links: Optional[List[KnowledgeCard]] = None
     domain: Optional[str] = None
 
@@ -82,7 +82,7 @@ class GlossaryNodeConfig(ConfigModel):
     terms: Optional[List["GlossaryTermConfig"]] = None
     nodes: Optional[List["GlossaryNodeConfig"]] = None
     knowledge_links: Optional[List[KnowledgeCard]] = None
-    custom_properties: Optional[Dict[str, str]] = None
+    custom_properties: Optional[Dict[str, LaxStr]] = None
 
     # Private fields.
     _urn: str
@@ -108,12 +108,12 @@ class BusinessGlossarySourceConfig(ConfigModel):
 
 
 class BusinessGlossaryConfig(DefaultConfig):
-    version: str
+    version: LaxStr
     terms: Optional[List["GlossaryTermConfig"]] = None
     nodes: Optional[List["GlossaryNodeConfig"]] = None
 
-    @validator("version")
-    def version_must_be_1(cls, v):
+    @pydantic.field_validator("version", mode="after")
+    def version_must_be_1(cls, v: str) -> str:
         if v != "1":
             raise ValueError("Only version 1 is supported")
         return v