codepbi 0.1.7__tar.gz

codepbi-0.1.7/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ryan Thomas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

codepbi-0.1.7/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: codepbi
+Version: 0.1.7
+Summary: Code-first Power BI — define pages/visuals in Python and emit a working PBIP/PBIR report; sync a TMDL semantic model from a dbt project.
+Author: Ryan Thomas
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/ryantthomas/codepbi
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: semantic
+Requires-Dist: pyyaml; extra == "semantic"
+Requires-Dist: sqlglot; extra == "semantic"
+Requires-Dist: pythonnet; extra == "semantic"
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+# codepbi
+
+Code-first Power BI. Define pages and visuals in Python, get a working PBIP/PBIR
+report that opens and edits normally in Power BI Desktop.
+
+```python
+from codepbi import Field, Filter, Position, Report
+
+report = Report(name="Sales Overview", semantic_model_path="../Sales.SemanticModel")
+page = report.add_page("Overview")
+page.add_slicer(Field("Orders", "Region"), Position(x=0, y=0, width=200, height=400))
+page.add_table(
+    fields=[Field("Orders", "Region"), Field("Orders", "Order Amount")],
+    position=Position(x=220, y=0, width=800, height=400),
+    filters=[Filter.equals("Orders", "Status", "Active")],
+)
+report.save("output_dir")
+```
+
+## `codepbi.semantic`
+
+A separate module for the other half of the workflow: syncing a Power BI TMDL
+semantic model *from* a dbt project, via the Tabular Object Model (TOM). Treats
+dbt's schema YAML 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.
+
+```python
+from codepbi.semantic import TmdlProjectConfig, 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 validates the resulting model
+sync_relationships.sync(config)
+```
+
+Requires the `semantic` extra (`pip install codepbi[semantic]`) plus the
+`Microsoft.AnalysisServices.NetCore.retail.amd64` NuGet package's DLLs, obtained
+separately and pointed at via `tom_lib_dir` (not redistributed here).
+
+## Install
+
+```bash
+pip install -e .           # report/visual builder only
+pip install -e ".[semantic]"  # + the dbt-to-TMDL sync module
+```
+
+## License
+
+MIT

codepbi-0.1.7/README.md

@@ -0,0 +1,55 @@
+# codepbi
+
+Code-first Power BI. Define pages and visuals in Python, get a working PBIP/PBIR
+report that opens and edits normally in Power BI Desktop.
+
+```python
+from codepbi import Field, Filter, Position, Report
+
+report = Report(name="Sales Overview", semantic_model_path="../Sales.SemanticModel")
+page = report.add_page("Overview")
+page.add_slicer(Field("Orders", "Region"), Position(x=0, y=0, width=200, height=400))
+page.add_table(
+    fields=[Field("Orders", "Region"), Field("Orders", "Order Amount")],
+    position=Position(x=220, y=0, width=800, height=400),
+    filters=[Filter.equals("Orders", "Status", "Active")],
+)
+report.save("output_dir")
+```
+
+## `codepbi.semantic`
+
+A separate module for the other half of the workflow: syncing a Power BI TMDL
+semantic model *from* a dbt project, via the Tabular Object Model (TOM). Treats
+dbt's schema YAML 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.
+
+```python
+from codepbi.semantic import TmdlProjectConfig, 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 validates the resulting model
+sync_relationships.sync(config)
+```
+
+Requires the `semantic` extra (`pip install codepbi[semantic]`) plus the
+`Microsoft.AnalysisServices.NetCore.retail.amd64` NuGet package's DLLs, obtained
+separately and pointed at via `tom_lib_dir` (not redistributed here).
+
+## Install
+
+```bash
+pip install -e .           # report/visual builder only
+pip install -e ".[semantic]"  # + the dbt-to-TMDL sync module
+```
+
+## License
+
+MIT

codepbi-0.1.7/pyproject.toml

@@ -0,0 +1,25 @@
+[project]
+name = "codepbi"
+version = "0.1.7"
+description = "Code-first Power BI — define pages/visuals in Python and emit a working PBIP/PBIR report; sync a TMDL semantic model from a dbt project."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [{ name = "Ryan Thomas" }]
+dependencies = []
+
+[project.optional-dependencies]
+# Only needed for codepbi.semantic (dbt -> TMDL sync). Requires the
+# Microsoft.AnalysisServices .NET DLLs separately -- see codepbi/semantic/tom_utils.py.
+semantic = ["pyyaml", "sqlglot", "pythonnet"]
+dev = ["pytest"]
+
+[project.urls]
+Homepage = "https://github.com/ryantthomas/codepbi"
+
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]

codepbi-0.1.7/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

codepbi-0.1.7/src/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-0.1.7/src/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-0.1.7/src/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-0.1.7/src/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",
+]