codepbi 0.1.7__py3-none-any.whl

codepbi/__init__.py

@@ -0,0 +1,17 @@
+from .model import (
+    Field,
+    Filter,
+    Page,
+    Position,
+    Report,
+    Visual,
+    column_width,
+    drillthrough_binding,
+    field_ref,
+    visual_interaction,
+)
+
+__all__ = [
+    "Field", "Filter", "Page", "Position", "Report", "Visual",
+    "column_width", "drillthrough_binding", "field_ref", "visual_interaction",
+]

codepbi/ids.py

@@ -0,0 +1,11 @@
+import secrets
+import uuid
+
+
+def hex_id(length: int = 20) -> str:
+    """Matches the folder-name id style PBI Desktop generates for pages/visuals (e.g. '953e48bb4f7e4f9a82ce')."""
+    return secrets.token_hex(length // 2)
+
+
+def guid() -> str:
+    return str(uuid.uuid4())

codepbi/model.py

@@ -0,0 +1,408 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from .ids import hex_id
+
+# Single-role visuals: visualType -> the one query role every projected field goes under.
+# slicer was wrongly "Field" in earlier versions -- confirmed "Values" (like everything else
+# here) via a real Desktop-saved slicer. See docs/codepbi-lessons-learned.md in the project
+# that found this.
+SINGLE_ROLE_KEY = {
+    "slicer": "Values",
+    "tableEx": "Values",
+    "card": "Values",
+    "multiRowCard": "Values",
+}
+
+
+def field_ref(entity: str, property_: str, is_measure: bool = False) -> dict:
+    """The {"Column": {...}} / {"Measure": {...}} expression wrapper every field reference
+    uses -- shared by projections, filters, and drillthrough page bindings."""
+    wrapper = "Measure" if is_measure else "Column"
+    return {
+        wrapper: {
+            "Expression": {"SourceRef": {"Entity": entity}},
+            "Property": property_,
+        }
+    }
+
+
+def drillthrough_binding(fields: list[Field], name: str = "drillthrough") -> dict:
+    """pageBinding for a page with page_type="Drillthrough". One BindingParameter per field
+    that should trigger/filter the drillthrough page. Structure confirmed against the
+    published page/2.1.0 JSON Schema (pageBinding/BindingParameter definitions), not inferred
+    from an example.
+
+    Usage: page.page_type = "Drillthrough"; page.page_binding = drillthrough_binding([field])
+    """
+    return {
+        "name": name,
+        "type": "Drillthrough",
+        "parameters": [
+            {"name": f.query_ref, "fieldExpr": field_ref(f.entity, f.property, f.is_measure)}
+            for f in fields
+        ],
+    }
+
+
+INTERACTION_TYPES = {"Default", "DataFilter", "HighlightFilter", "NoFilter"}
+
+
+def visual_interaction(source: Visual, target: Visual, interaction_type: str) -> dict:
+    """A page.visual_interactions entry overriding how selecting a data point on `source`
+    affects `target`. interaction_type is one of INTERACTION_TYPES. Structure confirmed
+    against the published page/2.1.0 JSON Schema (VisualInteraction definition).
+
+    Usage: page.visual_interactions.append(visual_interaction(chart_a, chart_b, "NoFilter"))
+    """
+    if interaction_type not in INTERACTION_TYPES:
+        raise ValueError(f"interaction_type must be one of {sorted(INTERACTION_TYPES)}")
+    return {"source": source.name, "target": target.name, "type": interaction_type}
+
+
+def _literal(value: str) -> dict:
+    return {"expr": {"Literal": {"Value": value}}}
+
+
+def column_width(query_ref: str, pixels: float) -> dict:
+    """An `objects.columnWidth` entry for a table/matrix column, keyed by the column's
+    queryRef (e.g. "Organizations.Organization Name" -- the same string Field.query_ref
+    produces). Confirmed from a real Desktop-saved manual column resize: table/matrix
+    columns are NOT sized from container width alone -- Desktop persists an explicit
+    per-column pixel width once you drag one, and that's the only mechanical lever
+    available (there's no formula from container width + data, since actual column
+    width depends on live data this generator never sees).
+
+    Usage: matrix.objects["columnWidth"] = [column_width("Orders.Region", 200)]
+    """
+    return {
+        "properties": {"value": {"expr": {"Literal": {"Value": f"{pixels}D"}}}},
+        "selector": {"metadata": query_ref},
+    }
+
+
+@dataclass
+class Field:
+    """A column or measure reference projected onto a visual, e.g.
+    Field("Projects", "Project Title") for a column, or
+    Field("Orders", "Total Sales", is_measure=True) for a measure."""
+
+    entity: str
+    property: str
+    native_name: str | None = None
+    is_measure: bool = False
+
+    @property
+    def query_ref(self) -> str:
+        return f"{self.entity}.{self.property}"
+
+    @property
+    def native_query_ref(self) -> str:
+        return self.native_name or self.property
+
+
+@dataclass
+class Position:
+    x: float
+    y: float
+    width: float
+    height: float
+    z: float = 0
+    tab_order: float | None = None
+
+    def __post_init__(self) -> None:
+        if self.tab_order is None:
+            self.tab_order = self.z
+
+
+@dataclass
+class Filter:
+    """A filter pane entry on a visual. Use `categorical` to just expose a field as filterable,
+    or `equals` to pre-apply a fixed condition (matches what PBI Desktop itself emits)."""
+
+    entity: str
+    property: str
+    kind: str  # "Categorical" or "Advanced"
+    value: str | None = None
+    name: str = field(default_factory=hex_id)
+
+    @staticmethod
+    def categorical(entity: str, property: str) -> Filter:
+        return Filter(entity, property, kind="Categorical")
+
+    @staticmethod
+    def equals(entity: str, property: str, value: str) -> Filter:
+        return Filter(entity, property, kind="Advanced", value=value)
+
+
+@dataclass
+class Visual:
+    """roles maps a visual-type-specific query role name (e.g. "Category", "Y", "Series" for a
+    chart; "Values" for a table/card; "Field" for a slicer) to the fields projected onto it.
+    Role names are NOT uniform across visual types.
+
+    objects / visual_container_objects are passed straight through to the visual's own JSON
+    (per-visual-type formatting and title/background/border respectively)."""
+
+    visual_type: str
+    roles: dict[str, list[Field]]
+    position: Position
+    filters: list[Filter] = field(default_factory=list)
+    name: str = field(default_factory=hex_id)
+    drill_filter_other_visuals: bool = True
+    objects: dict = field(default_factory=dict)
+    visual_container_objects: dict = field(default_factory=dict)
+    # If set, this container IS a group (visual_type/roles are ignored) -- confirmed via the
+    # visualContainer schema: {"displayName": str, "groupMode": "ScaleMode" | "ScrollMode"}.
+    visual_group: dict | None = None
+    # Name of the group Visual this one belongs to, if any.
+    parent_group_name: str | None = None
+
+
+@dataclass
+class Page:
+    display_name: str
+    name: str = field(default_factory=hex_id)
+    height: float = 720
+    width: float = 1280
+    display_option: str = "FitToPage"
+    visuals: list[Visual] = field(default_factory=list)
+    # "Drillthrough" or "Tooltip"; pairs with page_binding. None = a normal page.
+    page_type: str | None = None
+    page_binding: dict | None = None
+    # Overrides for how selecting a data point on one visual affects another -- see
+    # visual_interaction(). Default (no entry) leaves Desktop's own inferred behavior.
+    visual_interactions: list[dict] = field(default_factory=list)
+    # Page-level formatting passthrough, e.g. {"background": [{"properties": {...}}]} --
+    # confirmed property names (pageInformation, pageSize, background, displayArea, outspace,
+    # outspacePane, filterCard, pageRefresh, personalizeVisual) via the published page schema.
+    objects: dict = field(default_factory=dict)
+    # Page-level filters, applied on top of visual-level filters and under report-level ones.
+    # Same FilterContainer shape as Visual.filters (confirmed via filterConfiguration schema).
+    filters: list[Filter] = field(default_factory=list)
+
+    def add_visual(
+        self,
+        visual_type: str,
+        roles: dict[str, list[Field]],
+        position: Position,
+        filters: list[Filter] | None = None,
+        objects: dict | None = None,
+        visual_container_objects: dict | None = None,
+    ) -> Visual:
+        visual = Visual(
+            visual_type, roles, position, filters or [],
+            objects=objects or {}, visual_container_objects=visual_container_objects or {},
+        )
+        self.visuals.append(visual)
+        return visual
+
+    def add_group(self, display_name: str, position: Position, group_mode: str = "ScaleMode") -> Visual:
+        """A grouping container -- add visuals normally, then set their `.parent_group_name`
+        to this group's `.name` to make them members."""
+        group = Visual(
+            visual_type="", roles={}, position=position,
+            visual_group={"displayName": display_name, "groupMode": group_mode},
+        )
+        self.visuals.append(group)
+        return group
+
+    def add_text_box(
+        self, text: str, position: Position, font_size: str | None = None, bold: bool = False,
+    ) -> Visual:
+        """A static text box -- confirmed shape from a real Desktop-saved textbox. No query
+        roles; content lives entirely in objects.general.paragraphs. Note the text `value` is
+        a plain string here, NOT the usual Literal/expr wrapper every other property uses.
+        There is no vertical-alignment property for this visual (checked, and confirmed absent
+        in a real example) -- center it relative to other visuals by sizing its box tightly
+        around the text and aligning box centers, not by looking for an alignment property."""
+        text_style = {}
+        if font_size:
+            text_style["fontSize"] = font_size
+        if bold:
+            text_style["fontWeight"] = "bold"
+        text_run = {"value": text}
+        if text_style:
+            text_run["textStyle"] = text_style
+        objects = {"general": [{"properties": {"paragraphs": [{"textRuns": [text_run]}]}}]}
+        return self.add_visual("textbox", {}, position, objects=objects)
+
+    def add_image(
+        self, resource_name: str, position: Position,
+        display_name: str | None = None, scaling: str = "Normal",
+    ) -> Visual:
+        """A static image, referencing a resource already registered via
+        Report.add_image_resource(resource_name, local_file_path). Confirmed shape from a real
+        Desktop-saved image visual (logo). No query roles."""
+        objects = {
+            "image": [{
+                "properties": {
+                    "sourceType": _literal("'image'"),
+                    "sourceFile": {
+                        "image": {
+                            "name": _literal(f"'{display_name or resource_name}'"),
+                            "url": {
+                                "expr": {
+                                    "ResourcePackageItem": {
+                                        "PackageName": "RegisteredResources",
+                                        "PackageType": 1,
+                                        "ItemName": resource_name,
+                                    }
+                                }
+                            },
+                            "scaling": _literal(f"'{scaling}'"),
+                        }
+                    },
+                }
+            }]
+        }
+        return self.add_visual("image", {}, position, objects=objects)
+
+    def _add_single_role(self, visual_type: str, fields: list[Field], position: Position,
+                          filters: list[Filter] | None = None) -> Visual:
+        return self.add_visual(visual_type, {SINGLE_ROLE_KEY[visual_type]: fields}, position, filters)
+
+    def add_table(self, fields: list[Field], position: Position, filters: list[Filter] | None = None) -> Visual:
+        return self._add_single_role("tableEx", fields, position, filters)
+
+    def add_slicer(self, field_: Field, position: Position) -> Visual:
+        return self._add_single_role("slicer", [field_], position)
+
+    def add_card(self, field_: Field, position: Position) -> Visual:
+        return self._add_single_role("card", [field_], position)
+
+    def add_multi_row_card(self, fields: list[Field], position: Position) -> Visual:
+        return self._add_single_role("multiRowCard", fields, position)
+
+    def add_matrix(
+        self, rows: list[Field], values: list[Field], position: Position,
+        columns: list[Field] | None = None,
+    ) -> Visual:
+        roles = {"Rows": rows, "Values": values}
+        if columns:
+            roles["Columns"] = columns
+        return self.add_visual("pivotTable", roles, position)
+
+    def add_bar_chart(
+        self, category: Field, values: list[Field], position: Position,
+        series: Field | None = None, clustered: bool = True,
+    ) -> Visual:
+        roles = {"Category": [category], "Y": values}
+        if series:
+            roles["Series"] = [series]
+        visual_type = "clusteredBarChart" if clustered else "barChart"
+        return self.add_visual(visual_type, roles, position)
+
+    def add_column_chart(
+        self, category: Field, values: list[Field], position: Position,
+        series: Field | None = None, clustered: bool = True,
+    ) -> Visual:
+        roles = {"Category": [category], "Y": values}
+        if series:
+            roles["Series"] = [series]
+        visual_type = "clusteredColumnChart" if clustered else "columnChart"
+        return self.add_visual(visual_type, roles, position)
+
+    def add_line_chart(
+        self, category: Field, values: list[Field], position: Position,
+        series: Field | None = None,
+    ) -> Visual:
+        roles = {"Category": [category], "Y": values}
+        if series:
+            roles["Series"] = [series]
+        return self.add_visual("lineChart", roles, position)
+
+    def add_combo_chart(
+        self, category: Field, column_values: list[Field], line_values: list[Field],
+        position: Position,
+    ) -> Visual:
+        roles = {"Category": [category], "Y": column_values, "Y2": line_values}
+        return self.add_visual("lineClusteredColumnComboChart", roles, position)
+
+    def add_pie_chart(
+        self, category: Field, values: list[Field], position: Position, donut: bool = False,
+    ) -> Visual:
+        roles = {"Category": [category], "Y": values}
+        return self.add_visual("donutChart" if donut else "pieChart", roles, position)
+
+    def add_scatter_chart(
+        self, x: Field, y: Field, position: Position,
+        category: Field | None = None, size: Field | None = None,
+    ) -> Visual:
+        # Desktop's UI labels this well "Details", but (like every other chart here) the
+        # underlying role key is "Category" -- see docs/codepbi-lessons-learned.md.
+        roles = {"X": [x], "Y": [y]}
+        if category:
+            roles["Category"] = [category]
+        if size:
+            roles["Size"] = [size]
+        return self.add_visual("scatterChart", roles, position)
+
+    def add_gauge(
+        self, value: Field, position: Position,
+        min_value: Field | None = None, max_value: Field | None = None, target_value: Field | None = None,
+    ) -> Visual:
+        roles = {"Y": [value]}
+        if min_value:
+            roles["MinValue"] = [min_value]
+        if max_value:
+            roles["MaxValue"] = [max_value]
+        if target_value:
+            roles["TargetValue"] = [target_value]
+        return self.add_visual("gauge", roles, position)
+
+    def add_treemap(
+        self, group: Field, values: list[Field], position: Position, details: Field | None = None,
+    ) -> Visual:
+        roles = {"Group": [group], "Values": values}
+        if details:
+            roles["Details"] = [details]
+        return self.add_visual("treemap", roles, position)
+
+    def add_filled_map(
+        self, location: Field, position: Position,
+        values: list[Field] | None = None, legend: Field | None = None,
+    ) -> Visual:
+        roles = {"Category": [location]}
+        if values:
+            roles["Values"] = values
+        if legend:
+            roles["Legend"] = [legend]
+        return self.add_visual("filledMap", roles, position)
+
+
+@dataclass
+class Report:
+    name: str
+    semantic_model_path: str
+    pages: list[Page] = field(default_factory=list)
+    active_page_name: str | None = None
+    # A custom color theme -- Microsoft's public Report Theme JSON format
+    # (https://learn.microsoft.com/power-bi/create-reports/desktop-report-themes), e.g.
+    # {"name": "Brand", "dataColors": ["#005493", "#008fb4", ...]}. None = Desktop's default
+    # theme (still valid -- themeCollection is required but can be empty, see
+    # docs/codepbi-lessons-learned.md in the consuming project).
+    theme: dict | None = None
+    # Report-level filters, applied on top of page- and visual-level filters. Same
+    # FilterContainer shape as Visual/Page filters -- confirmed via the filterConfiguration
+    # schema (report.json's top-level "filterConfig" property).
+    filters: list[Filter] = field(default_factory=list)
+    # (resource_name, local_file_path) pairs bundled into the report's RegisteredResources
+    # package (type "Image") -- reference one from a page via Page.add_image(resource_name, ...).
+    images: list[tuple[str, str]] = field(default_factory=list)
+
+    def add_image_resource(self, name: str, file_path: str) -> None:
+        self.images.append((name, file_path))
+
+    def add_page(self, display_name: str, **kwargs) -> Page:
+        page = Page(display_name=display_name, **kwargs)
+        self.pages.append(page)
+        if self.active_page_name is None:
+            self.active_page_name = page.name
+        return page
+
+    def save(self, parent_dir: str) -> str:
+        from .writer import write_report
+
+        return write_report(self, parent_dir)

codepbi/semantic/__init__.py

@@ -0,0 +1,48 @@
+"""Sync a Power BI TMDL semantic model from a dbt project.
+
+Treats dbt's schema YAML (`meta.entity` / `meta.grain` / `meta.display_name` / ...)
+as the source of truth for columns, and a dbt-semantic-layer-style
+`semantic_models/*.yml` (entities + measures) as the source of truth for joins
+and DAX measures. Applies both to TMDL via the Tabular Object Model (TOM), so
+Power BI Desktop keeps working normally against the result.
+
+Typical flow:
+
+    from codepbi.semantic import TmdlProjectConfig, check_drift, sync_descriptions, \\
+        sync_measures, sync_relationships
+
+    config = TmdlProjectConfig(
+        dbt_project_dir="path/to/dbt_project",
+        semantic_model_definition_dir="path/to/Model.SemanticModel/definition",
+        tom_lib_dir="path/to/analysis-services-dlls",
+    )
+
+    sync_measures.sync(config)
+    sync_descriptions.sync(config)       # also runs validate_tmdl at the end
+    sync_relationships.sync(config)
+    check_drift.check(config)
+"""
+
+from . import (
+    check_drift,
+    check_schema_vs_sql,
+    schema_loader,
+    sync_descriptions,
+    sync_measures,
+    sync_relationships,
+    tom_utils,
+    validate_tmdl,
+)
+from .config import TmdlProjectConfig
+
+__all__ = [
+    "TmdlProjectConfig",
+    "check_drift",
+    "check_schema_vs_sql",
+    "schema_loader",
+    "sync_descriptions",
+    "sync_measures",
+    "sync_relationships",
+    "tom_utils",
+    "validate_tmdl",
+]

codepbi/semantic/check_drift.py

@@ -0,0 +1,48 @@
+# CI drift detection: compares dbt columns (schema YAML) against TMDL sourceColumns.
+# Returns 1 if TMDL references columns that don't exist in dbt.
+
+from . import tom_utils
+from .config import TmdlProjectConfig
+from .schema_loader import load_schema
+
+
+def check(config: TmdlProjectConfig) -> int:
+    dbt_models = {
+        pbi_table: {col["source"] for col in spec["columns"]}
+        for pbi_table, spec in load_schema(config).items()
+    }
+
+    errors = []
+    warnings = []
+
+    for table_name, table in sorted(tom_utils.read_tables(config).items()):
+        if table_name not in dbt_models:
+            continue
+
+        dbt_cols = dbt_models[table_name]
+        tmdl_sources = {col["source"] for col in table["columns"].values() if col["source"]}
+
+        # TMDL references columns not in dbt (breaking -- column was removed/renamed)
+        orphaned = tmdl_sources - dbt_cols
+        for col in sorted(orphaned):
+            errors.append(f'  {table_name}: TMDL sourceColumn "{col}" not found in schema YAML')
+
+        # dbt has columns not in TMDL (informational -- new column not yet exposed in PBI)
+        missing = dbt_cols - tmdl_sources
+        for col in sorted(missing):
+            warnings.append(f'  {table_name}: dbt column "{col}" not in TMDL')
+
+    if warnings:
+        print(f"INFO: {len(warnings)} dbt columns not yet in TMDL:")
+        for w in warnings:
+            print(w)
+        print()
+
+    if errors:
+        print(f"ERROR: {len(errors)} TMDL columns reference missing dbt columns:")
+        for e in errors:
+            print(e)
+        return 1
+
+    print(f"OK: all TMDL sourceColumns exist in schema YAML ({len(dbt_models)} tables checked)")
+    return 0

codepbi/semantic/check_schema_vs_sql.py

@@ -0,0 +1,61 @@
+# Drift detection check_drift can't do: it only compares schema YAML against
+# TMDL, so if schema YAML itself is wrong (a column moved/renamed in a model's
+# SQL without schema YAML being updated to match), TMDL happily syncs to the
+# same wrong name and both "agree" on a column that doesn't exist -- the bug
+# only surfaces later when Power BI queries it live. This checks schema YAML's
+# declared columns against what each model's own compiled SQL actually SELECTs.
+# Requires `dbt compile` (or `dbt run`) to have already produced target/compiled/....
+
+from .config import TmdlProjectConfig
+from .dbt_sql import load_model_data, sql_exprs
+from .schema_loader import load_schema
+
+
+def check(config: TmdlProjectConfig) -> int:
+    if config.dbt_manifest_path is None or config.dbt_compiled_dir is None:
+        raise SystemExit(
+            "check_schema_vs_sql requires config.dbt_manifest_path and "
+            "config.dbt_compiled_dir to be set."
+        )
+    schema = load_schema(config)
+    model_data = load_model_data(config.dbt_manifest_path, config.dbt_compiled_dir)
+    errors = []
+    checked = 0
+
+    for table_name, spec in sorted(schema.items()):
+        dbt_model = spec["model"]
+        if not dbt_model:
+            continue
+
+        if not model_data.get(dbt_model, {}).get("compiled_exists"):
+            errors.append(f'{table_name}: no compiled SQL found for model "{dbt_model}" '
+                          f'(did `dbt compile` run?)')
+            continue
+
+        try:
+            exprs = sql_exprs(model_data[dbt_model]["sql"])
+        except Exception as e:
+            errors.append(f'{table_name}: failed to parse compiled SQL for model "{dbt_model}": {e}')
+            continue
+
+        if set(exprs) == {"*"}:
+            errors.append(f'{table_name}: model "{dbt_model}" appears to end in a bare '
+                          f'SELECT * -- cannot verify its columns')
+            continue
+
+        exprs_lower = {k.lower() for k in exprs}
+        for col in spec["columns"]:
+            checked += 1
+            source_col = col["source"]
+            if source_col.lower() not in exprs_lower:
+                errors.append(f'{table_name}.{col["display"]}: schema YAML source column '
+                              f'"{source_col}" not found in "{dbt_model}"\'s compiled SELECT list')
+
+    if errors:
+        print(f"ERROR: {len(errors)} schema YAML column(s) not found in their model's compiled SQL:")
+        for e in errors:
+            print(f"  {e}")
+        return 1
+
+    print(f"OK: all schema YAML columns exist in their model's compiled SQL ({checked} columns checked)")
+    return 0

codepbi/semantic/config.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class TmdlProjectConfig:
+    """Points the semantic-sync tooling at a specific dbt project + TMDL semantic model.
+
+    dbt_project_dir: the dbt project root (contains dbt_project.yml, models/, seeds/).
+    semantic_model_definition_dir: the `<Model>.SemanticModel/definition` folder PBI Desktop
+        reads/writes (contains model.tmdl, tables/, relationships.tmdl).
+    tom_lib_dir: folder containing the Microsoft.AnalysisServices .NET DLLs (from the
+        `Microsoft.AnalysisServices.NetCore.retail.amd64` NuGet package) that pythonnet
+        loads to talk to TOM. Not redistributed here — obtain separately.
+    models_glob: glob (relative to dbt_project_dir) for schema YAML files to read.
+        Excludes anything under semantic_models_subdir and any `sources.yml` automatically.
+    semantic_models_subdir: relative path to the folder of per-table semantic model YAML
+        files (entities + measures, dbt-semantic-layer style) that are the join and
+        DAX-measure authority.
+    skip_tables: TMDL table names to ignore entirely (e.g. a reference/glossary table with
+        no backing dbt model).
+    extra_column_meta: additional `meta.*` keys to pass through verbatim on each column dict
+        (key -> default value used when a column doesn't declare it), for callers that track
+        extra per-column metadata (e.g. data-governance fields) beyond what TMDL sync needs.
+        Unused by anything in this package; purely a passthrough so callers don't have to
+        re-parse schema YAML themselves just to read one more field.
+    extra_table_meta: same idea as extra_column_meta, but for per-table `meta.*` keys.
+    dbt_manifest_path: path to target/manifest.json, only needed for check_schema_vs_sql.
+    dbt_compiled_dir: folder compiled SQL is actually written under -- dbt's real layout is
+        target/compiled/<dbt_project_name>/<model-paths>/..., which isn't generically
+        derivable, so this must be the fully resolved path. Only needed for
+        check_schema_vs_sql.
+    """
+
+    dbt_project_dir: Path
+    semantic_model_definition_dir: Path
+    tom_lib_dir: Path
+    models_glob: str = "models/**/*.yml"
+    semantic_models_subdir: str = "models/semantic_models"
+    skip_tables: set[str] = field(default_factory=set)
+    extra_column_meta: dict[str, str] = field(default_factory=dict)
+    extra_table_meta: dict[str, str] = field(default_factory=dict)
+    dbt_manifest_path: Path | None = None
+    dbt_compiled_dir: Path | None = None
+
+    def __post_init__(self) -> None:
+        self.dbt_project_dir = Path(self.dbt_project_dir)
+        self.semantic_model_definition_dir = Path(self.semantic_model_definition_dir)
+        self.tom_lib_dir = Path(self.tom_lib_dir)
+        if self.dbt_manifest_path is not None:
+            self.dbt_manifest_path = Path(self.dbt_manifest_path)
+        if self.dbt_compiled_dir is not None:
+            self.dbt_compiled_dir = Path(self.dbt_compiled_dir)
+
+    @property
+    def tables_dir(self) -> Path:
+        return self.semantic_model_definition_dir / "tables"
+
+    @property
+    def semantic_models_dir(self) -> Path:
+        return self.dbt_project_dir / self.semantic_models_subdir