gooddata-dbt 1.60.1.dev1__tar.gz → 1.60.1.dev2__tar.gz

{gooddata_dbt-1.60.1.dev1 → gooddata_dbt-1.60.1.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gooddata-dbt
-Version: 1.60.1.dev1
+Version: 1.60.1.dev2
 Summary: dbt plugin for GoodData
 Author-email: GoodData <support@gooddata.com>
 License-Expression: MIT
@@ -19,7 +19,7 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Requires-Dist: attrs<=24.2.0,>=21.4.0
 Requires-Dist: cattrs<=24.1.1,>=22.1.0
-Requires-Dist: gooddata-sdk~=1.60.1.dev1
+Requires-Dist: gooddata-sdk~=1.60.1.dev2
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: requests~=2.32.0
 Requires-Dist: tabulate~=0.8.10

{gooddata_dbt-1.60.1.dev1 → gooddata_dbt-1.60.1.dev2}/pyproject.toml

@@ -1,7 +1,7 @@
 # (C) 2025 GoodData Corporation
 [project]
 name = "gooddata-dbt"
-version = "1.60.1.dev1"
+version = "1.60.1.dev2"
 description = "dbt plugin for GoodData"
 readme = "README.md"
 license = "MIT"
@@ -10,7 +10,7 @@ authors = [
 ]
 requires-python = ">=3.10"
 dependencies = [
-    "gooddata-sdk~=1.60.1.dev1",
+    "gooddata-sdk~=1.60.1.dev2",
     "pyyaml>=6.0",
     "attrs>=21.4.0,<=24.2.0",
     "cattrs>=22.1.0,<=24.1.1",
@@ -47,6 +47,15 @@ allowed-unresolved-imports = ["deep_translator", "github"]
 [tool.hatch.build.targets.wheel]
 packages = ["src/gooddata_dbt"]
 
+[tool.coverage.run]
+source = ["gooddata_dbt"]
+
+[tool.coverage.paths]
+source = [
+    "src/gooddata_dbt",
+    "**/site-packages/gooddata_dbt",
+]
+
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"

{gooddata_dbt-1.60.1.dev1 → gooddata_dbt-1.60.1.dev2}/src/gooddata_dbt/dbt/base.py

@@ -21,6 +21,7 @@ class GoodDataLabelType(Enum):
     HYPERLINK = "HYPERLINK"
     GEO_LATITUDE = "GEO_LATITUDE"
     GEO_LONGITUDE = "GEO_LONGITUDE"
+    GEO_AREA = "GEO_AREA"
 
 
 class GoodDataSortDirection(Enum):

{gooddata_dbt-1.60.1.dev1 → gooddata_dbt-1.60.1.dev2}/src/gooddata_dbt/dbt/metrics.py

@@ -1,7 +1,6 @@
 # (C) 2023 GoodData Corporation
 import json
 import re
-from typing import Optional
 
 import attrs
 from gooddata_sdk import CatalogDeclarativeMetric, CatalogDeclarativeModel
@@ -26,8 +25,8 @@ DBT_TO_GD_FILTER_OPERATORS = {
 
 @attrs.define(auto_attribs=True, kw_only=True)
 class DbtModelMetaGoodDataMetricProps(Base):
-    model_id: Optional[str] = None
-    format: Optional[str] = None
+    model_id: str | None = None
+    format: str | None = None
 
 
 @attrs.define(auto_attribs=True, kw_only=True)
@@ -49,11 +48,11 @@ class DbtModelMetric(DbtModelBase):
     model: str
     calculation_method: str
     expression: str
-    filters: Optional[list[DbtModelMetricFilter]] = None
+    filters: list[DbtModelMetricFilter] | None = None
 
 
 class DbtModelMetrics:
-    def __init__(self, model_ids: Optional[list[str]], ldm: CatalogDeclarativeModel) -> None:
+    def __init__(self, model_ids: list[str] | None, ldm: CatalogDeclarativeModel) -> None:
         self.model_ids = model_ids
         self.ldm = ldm
         with open(DBT_PATH_TO_MANIFEST) as fp:
@@ -104,7 +103,7 @@ class DbtModelMetrics:
         else:
             raise Exception(f"Unsupported entity type {table_name=} {expression_entity=}")
 
-    def make_entity_id(self, table_name: str, token: str) -> Optional[str]:
+    def make_entity_id(self, table_name: str, token: str) -> str | None:
         entity_type = self.get_entity_type(table_name, token)
         if not entity_type:
             return None
@@ -125,7 +124,7 @@ class DbtModelMetrics:
             result_tokens.append(entity_id or token)
         return " ".join(result_tokens)
 
-    def make_gooddata_filter(self, table_name: str, dbt_filters: Optional[list[DbtModelMetricFilter]] = None) -> str:
+    def make_gooddata_filter(self, table_name: str, dbt_filters: list[DbtModelMetricFilter] | None = None) -> str:
         # TODO - Quite naive implementation
         #    e.g. missing polishing of values (e.g. SQL vs MAQL enclosers)
         gd_maql_filters = []

{gooddata_dbt-1.60.1.dev1 → gooddata_dbt-1.60.1.dev2}/src/gooddata_dbt/dbt/profiles.py

@@ -2,7 +2,7 @@
 import argparse
 import os
 import re
-from typing import Optional, Union
+from typing import Union
 from urllib.parse import quote_plus
 
 import attrs
@@ -97,7 +97,7 @@ class DbtOutputSnowflake(Base):
     database: str
     warehouse: str
     schema: str
-    query_tag: Optional[str] = None
+    query_tag: str | None = None
 
     def to_gooddata(self, data_source_id: str, schema_name: str) -> CatalogDataSourceSnowflake:
         return CatalogDataSourceSnowflake(
@@ -222,7 +222,7 @@ class DbtProfiles:
             # else do nothing, real value seems to be stored in dbt profile
 
     @staticmethod
-    def to_data_class(output: str, output_def: dict) -> Optional[DbtOutput]:
+    def to_data_class(output: str, output_def: dict) -> DbtOutput | None:
         db_type = output_def["type"]
         if db_type == "postgres":
             return DbtOutputPostgreSQL.from_dict({"name": output, **output_def})

{gooddata_dbt-1.60.1.dev1 → gooddata_dbt-1.60.1.dev2}/src/gooddata_dbt/dbt/tables.py

@@ -3,7 +3,7 @@ import copy
 import json
 import re
 from pathlib import Path
-from typing import Optional, Union
+from typing import Union
 
 import attrs
 from gooddata_sdk import CatalogDeclarativeColumn, CatalogDeclarativeTable, CatalogDeclarativeTables
@@ -27,22 +27,23 @@ from gooddata_dbt.dbt.cloud import DbtConnection
 
 @attrs.define(auto_attribs=True, kw_only=True)
 class DbtModelMetaGoodDataTableProps(Base):
-    model_id: Optional[str] = None
+    model_id: str | None = None
 
 
 @attrs.define(auto_attribs=True, kw_only=True)
 class DbtModelMetaGoodDataColumnProps(Base):
-    id: Optional[str] = None
-    ldm_type: Optional[GoodDataLdmType] = None
-    referenced_table: Optional[str] = None
-    label_type: Optional[GoodDataLabelType] = None
-    attribute_column: Optional[str] = None
-    sort_column: Optional[str] = None
-    sort_direction: Optional[GoodDataSortDirection] = None
-    default_view: Optional[bool] = None
+    id: str | None = None
+    ldm_type: GoodDataLdmType | None = None
+    referenced_table: str | None = None
+    label_type: GoodDataLabelType | None = None
+    attribute_column: str | None = None
+    sort_column: str | None = None
+    sort_direction: GoodDataSortDirection | None = None
+    default_view: bool | None = None
+    geo_area_config: dict[str, dict[str, str]] | None = None
 
     @property
-    def gooddata_ref_table_ldm_id(self) -> Optional[str]:
+    def gooddata_ref_table_ldm_id(self) -> str | None:
         if self.referenced_table:
             return self.referenced_table.lower()
         return None
@@ -73,7 +74,7 @@ class DbtModelBase(Base):
     tags: list[str]
     # If 2+ references point to the same table, the table plays multiple roles,
     # it must be generated as multiple datasets
-    role_name: Optional[str] = None
+    role_name: str | None = None
 
     # TODO - duplicate of backend logic.
     # Solution: use result of generateLdm as a master template, and override based on dbt metadata only if necessary
@@ -120,7 +121,7 @@ class DbtModelBase(Base):
 
 @attrs.define(auto_attribs=True, kw_only=True)
 class DbtModelColumn(DbtModelBase):
-    data_type: Optional[str]
+    data_type: str | None
     meta: DbtModelMetaGoodDataColumn = attrs.field(factory=DbtModelMetaGoodDataColumn)
 
     # Enable to override LDM ID for LDM entities derived from columns (attributes, ...)
@@ -130,21 +131,21 @@ class DbtModelColumn(DbtModelBase):
         return self.meta.gooddata.id or self.gooddata_ldm_id
 
     @property
-    def ldm_type(self) -> Optional[str]:
+    def ldm_type(self) -> str | None:
         if self.meta.gooddata.ldm_type is None:
             return None
         else:
             return self.meta.gooddata.ldm_type.value
 
     @property
-    def label_type(self) -> Optional[str]:
+    def label_type(self) -> str | None:
         if self.meta.gooddata.label_type is None:
             return None
         else:
             return self.meta.gooddata.label_type.value
 
     @property
-    def sort_direction(self) -> Optional[str]:
+    def sort_direction(self) -> str | None:
         if self.meta.gooddata.sort_direction is None:
             return None
         else:
@@ -387,22 +388,23 @@ class DbtModelTables:
         return facts
 
     @staticmethod
-    def make_labels(table: DbtModelTable, attribute_column: DbtModelColumn) -> tuple[list[dict], Optional[dict]]:
+    def make_labels(table: DbtModelTable, attribute_column: DbtModelColumn) -> tuple[list[dict], dict | None]:
         labels = []
         default_view = None
         for column in table.columns.values():
             if column.gooddata_is_label(attribute_column.name):
-                labels.append(
-                    {
-                        "id": column.ldm_id,
-                        "title": column.gooddata_ldm_title,
-                        "description": column.gooddata_ldm_description,
-                        "source_column": column.name,
-                        "source_column_data_type": column.data_type,
-                        "value_type": column.label_type,
-                        "tags": [table.gooddata_ldm_title] + column.tags,
-                    }
-                )
+                label_dict: dict = {
+                    "id": column.ldm_id,
+                    "title": column.gooddata_ldm_title,
+                    "description": column.gooddata_ldm_description,
+                    "source_column": column.name,
+                    "source_column_data_type": column.data_type,
+                    "value_type": column.label_type,
+                    "tags": [table.gooddata_ldm_title] + column.tags,
+                }
+                if column.meta.gooddata.geo_area_config is not None:
+                    label_dict["geo_area_config"] = column.meta.gooddata.geo_area_config
+                labels.append(label_dict)
                 if column.meta.gooddata.default_view:
                     default_view = {
                         "id": column.ldm_id,
@@ -507,7 +509,7 @@ class DbtModelTables:
                 result.append(table)
         return result
 
-    def make_declarative_datasets(self, data_source_id: str, model_ids: Optional[list[str]]) -> dict:
+    def make_declarative_datasets(self, data_source_id: str, model_ids: list[str] | None) -> dict:
         result: dict[str, list] = {"datasets": [], "date_instances": []}
         model_tables = [t for t in self.tables if not model_ids or t.meta.gooddata.model_id in model_ids]
         role_playing_tables = self.find_role_playing_tables(model_tables)
@@ -517,7 +519,7 @@ class DbtModelTables:
             result = self.make_dataset(data_source_id, table, role_playing_tables, result)
         return result
 
-    def get_entity_type(self, table_name: str, column_name: str) -> Optional[str]:
+    def get_entity_type(self, table_name: str, column_name: str) -> str | None:
         comp_table_name = table_name
         if self.upper_case:
             comp_table_name = table_name.upper()

{gooddata_dbt-1.60.1.dev1 → gooddata_dbt-1.60.1.dev2}/src/gooddata_dbt/dbt_plugin.py

@@ -5,7 +5,6 @@ from argparse import Namespace
 from asyncio import Semaphore
 from pathlib import Path
 from time import time
-from typing import Optional
 
 import tabulate
 import yaml
@@ -36,7 +35,7 @@ def generate_and_put_ldm(
     data_source_id: str,
     workspace_id: str,
     dbt_tables: DbtModelTables,
-    model_ids: Optional[list[str]],
+    model_ids: list[str] | None,
 ) -> None:
     scan_request = CatalogScanModelRequest(scan_tables=True, scan_views=True)
     logger.info(f"Scan data source {data_source_id=}")
@@ -68,7 +67,7 @@ def deploy_ldm(
     args: Namespace,
     all_model_ids: list[str],
     sdk_wrapper: GoodDataSdkWrapper,
-    model_ids: Optional[list[str]],
+    model_ids: list[str] | None,
     workspace_id: str,
 ) -> None:
     logger.info("Generate and put LDM")
@@ -186,7 +185,7 @@ async def test_visualizations(
     logger: logging.Logger,
     sdk_wrapper: GoodDataSdkWrapper,
     workspace_id: str,
-    skip_tests: Optional[list[str]],
+    skip_tests: list[str] | None,
     test_visualizations_parallelism: int = 1,
 ) -> None:
     start = time()
@@ -334,7 +333,7 @@ def process_organization(
     logger: logging.Logger,
     sdk_wrapper: GoodDataSdkWrapper,
     gd_config: GoodDataConfig,
-    organization: Optional[GoodDataConfigOrganization] = None,
+    organization: GoodDataConfigOrganization | None = None,
 ) -> None:
     if args.method == "upload_notification":
         dbt_profiles = DbtProfiles(args)

{gooddata_dbt-1.60.1.dev1 → gooddata_dbt-1.60.1.dev2}/src/gooddata_dbt/gooddata/config.py

@@ -1,5 +1,4 @@
 # (C) 2023 GoodData Corporation
-from typing import Optional
 
 import attr
 import attrs
@@ -37,8 +36,8 @@ class GoodDataConfigProduct(Base):
     name: str
     environment_setup_id: str
     model_ids: list[str] = attr.field(factory=list)
-    localization: Optional[GoodDataConfigLocalization] = None
-    skip_tests: Optional[list[str]] = None
+    localization: GoodDataConfigLocalization | None = None
+    skip_tests: list[str] | None = None
 
 
 @attrs.define(auto_attribs=True, kw_only=True)
@@ -49,7 +48,7 @@ class GoodDataConfigOrganization(Base):
 
 @attrs.define(auto_attribs=True, kw_only=True)
 class GoodDataGlobalConfig(Base):
-    test_visualizations_parallelism: Optional[int] = 1
+    test_visualizations_parallelism: int | None = 1
 
 
 @attrs.define(auto_attribs=True, kw_only=True)

{gooddata_dbt-1.60.1.dev1 → gooddata_dbt-1.60.1.dev2}/src/gooddata_dbt/sdk_wrapper.py

@@ -1,7 +1,6 @@
 # (C) 2023 GoodData Corporation
 import argparse
 from logging import Logger
-from typing import Optional
 
 from gooddata_sdk import GoodDataSdk
 
@@ -11,7 +10,7 @@ from gooddata_dbt.gooddata.api_wrapper import GoodDataApiWrapper
 class GoodDataSdkWrapper:
     # Timeout=600 because supporting waiting for GoodData services to start
     def __init__(
-        self, args: argparse.Namespace, logger: Logger, profile: Optional[str] = None, timeout: int = 600
+        self, args: argparse.Namespace, logger: Logger, profile: str | None = None, timeout: int = 600
     ) -> None:
         self.args = args
         self.logger = logger
@@ -22,7 +21,7 @@ class GoodDataSdkWrapper:
         if not self.args.dry_run:
             self.wait_for_gooddata_is_up(self.timeout)
 
-    def get_host_from_sdk(self) -> Optional[str]:
+    def get_host_from_sdk(self) -> str | None:
         # TODO - make _hostname public in gooddata_sdk
         return self.sdk.client._hostname
 
@@ -54,7 +53,7 @@ class GoodDataSdkWrapper:
         self.sdk.support.wait_till_available(timeout=timeout)
         self.logger.info(f"Host {host} is up")
 
-    def pre_cache_visualizations(self, workspaces: Optional[list] = None) -> None:
+    def pre_cache_visualizations(self, workspaces: list | None = None) -> None:
         if not workspaces:
             workspaces = [w.id for w in self.sdk.catalog_workspace.list_workspaces()]
         for workspace_id in workspaces:

{gooddata_dbt-1.60.1.dev1 → gooddata_dbt-1.60.1.dev2}/tests/resources/dbt_target/manifest.json

@@ -1860,6 +1860,25 @@
           "data_type": null,
           "quote": null,
           "tags": []
+        },
+        "country": {
+          "name": "country",
+          "description": "",
+          "meta": {
+            "gooddata": {
+              "ldm_type": "label",
+              "label_type": "GEO_AREA",
+              "attribute_column": "code",
+              "geo_area_config": {
+                "collection": {
+                  "id": "countries"
+                }
+              }
+            }
+          },
+          "data_type": null,
+          "quote": null,
+          "tags": []
         }
       },
       "meta": {

{gooddata_dbt-1.60.1.dev1 → gooddata_dbt-1.60.1.dev2}/tests/resources/gooddata_layouts/pdm/airports.yaml

@@ -21,6 +21,9 @@ columns:
   - dataType: STRING
     isPrimaryKey: false
     name: name
+  - dataType: STRING
+    isPrimaryKey: false
+    name: country
   - dataType: STRING
     isPrimaryKey: false
     name: state

{gooddata_dbt-1.60.1.dev1 → gooddata_dbt-1.60.1.dev2}/tests/test_tables.py

@@ -49,3 +49,35 @@ def test_make_ldm():
     assert ldm.ldm is not None
     assert len(ldm.ldm.datasets) == 4
     assert len(ldm.ldm.date_instances) == 4
+
+
+FAA_MODEL_ID = "faa"
+
+
+def test_make_ldm_geo_area():
+    """Test that GEO_AREA label type is parsed and included in the LDM."""
+    tables = DbtModelTables.from_local(upper_case=False, all_model_ids=[FAA_MODEL_ID], manifest_path=_MANIFEST_PATH)
+    scan_pdm = CatalogDeclarativeTables.load_from_disk(_PDM_PATH)
+    tables.set_data_types(scan_pdm)
+    data_source_id = "postgres"
+
+    declarative_datasets = tables.make_declarative_datasets(data_source_id, [FAA_MODEL_ID])
+    ldm = CatalogDeclarativeModel.from_dict({"ldm": declarative_datasets}, camel_case=False)
+
+    assert ldm.ldm is not None
+    # airports is referenced twice (origin/destination), find either one
+    airports = [ds for ds in ldm.ldm.datasets if ds.id == "airports_origin"]
+    assert len(airports) == 1
+    airports_ds = airports[0]
+    # Find the code attribute (which has geo labels)
+    code_attrs = [a for a in airports_ds.attributes if a.id == "code_origin"]
+    assert len(code_attrs) == 1
+    labels = code_attrs[0].labels
+    label_types = {label.id: label.value_type for label in labels}
+    assert label_types["latitude_origin"] == "GEO_LATITUDE"
+    assert label_types["longitude_origin"] == "GEO_LONGITUDE"
+    assert label_types["country_origin"] == "GEO_AREA"
+    # Verify geo_area_config is propagated
+    country_label = next(lbl for lbl in labels if lbl.id == "country_origin")
+    assert country_label.geo_area_config is not None
+    assert country_label.geo_area_config.collection.id == "countries"

{gooddata_dbt-1.60.1.dev1 → gooddata_dbt-1.60.1.dev2}/tox.ini

@@ -11,4 +11,4 @@ dependency_groups =
 setenv =
     COVERAGE_CORE=sysmon
 commands =
-    pytest -v --cov=src/gooddata_dbt --cov-report=xml tests {posargs} --json-report --json-report-file=.json-report-{envname}.json
+    pytest -v --cov --cov-report=xml tests {posargs} --json-report --json-report-file=.json-report-{envname}.json