pbip-compiler 0.2.0__tar.gz

pbip_compiler-0.2.0/.github/workflows/release.yml

@@ -0,0 +1,40 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
+
+      - name: Build
+        run: uv build
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

pbip_compiler-0.2.0/.gitignore

@@ -0,0 +1,14 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+.claude
+prototypes/
+*.pbix
+.DS_Store

pbip_compiler-0.2.0/.python-version

@@ -0,0 +1 @@
+3.11

pbip_compiler-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Maxim Bacar
+
+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.

pbip_compiler-0.2.0/PKG-INFO

@@ -0,0 +1,201 @@
+Metadata-Version: 2.4
+Name: pbip-compiler
+Version: 0.2.0
+Summary: Compile a Power BI Project (.pbip) folder into a .pbix file — pure Python, no Power BI Desktop or Windows required.
+Project-URL: Homepage, https://github.com/MaximBacar/pbip-compiler
+Project-URL: Repository, https://github.com/MaximBacar/pbip-compiler
+Project-URL: Issues, https://github.com/MaximBacar/pbip-compiler/issues
+Author-email: Maxim Bacar <maximbacar@hotmail.ca>
+License: MIT License
+        
+        Copyright (c) 2026 Maxim Bacar
+        
+        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.
+License-File: LICENSE
+Keywords: pbip,pbix,powerbi,report,tmdl,vertipaq
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.11
+Requires-Dist: msal>=1.37.0
+Requires-Dist: pbix-mcp>=0.9.2
+Requires-Dist: pydantic>=2
+Description-Content-Type: text/markdown
+
+# pbip-compiler
+
+Compile a **Power BI Project (`.pbip`)** folder into a single **`.pbix`** file —
+in pure Python. No Power BI Desktop, no external CLI tools, no Windows required.
+
+It parses the project's semantic model (TMDL / `model.bim`) and PBIR report,
+builds a real VertiPaq `DataModel` (via [`pbix-mcp`](https://pypi.org/project/pbix-mcp/)),
+preserves each table's Power Query (M) so the report stays refreshable, and
+assembles the final `.pbix` ZIP.
+
+## Features
+
+- 📦 `.pbip` → `.pbix` entirely in Python
+- 🧮 Builds a real VertiPaq DataModel (tables, columns, measures, relationships)
+- 🔁 Preserves partition M expressions → **Refresh** in Power BI loads the data
+- 🌐 Handles **live-connection** reports (bound to a published semantic model)
+- 🪶 Falls back to a thin / report-only `.pbix` when there is no local model
+
+## Installation
+
+```bash
+# with uv (recommended)
+uv add pbip-compiler
+
+# or with pip
+pip install pbip-compiler
+```
+
+Requires Python ≥ 3.11.
+
+## Quick start (CLI)
+
+```bash
+pbip-compiler --pbip ./MyProject --output ./MyReport.pbix
+```
+
+## Using `pbip_compiler` as a module
+
+### 1. Compile a `.pbip` folder to a `.pbix` file
+
+```python
+from pbip_compiler import PbipCompiler
+
+compiler = PbipCompiler("./MyProject")        # path to the .pbip folder
+output = compiler.compile("./MyReport.pbix")  # returns the resolved Path
+
+print(f"Compiled → {output}")
+```
+
+### 2. Compile to bytes (no file written)
+
+Useful when serving the result over HTTP, uploading it, or writing it yourself.
+
+```python
+from pbip_compiler import PbipCompiler
+
+compiler = PbipCompiler("./MyProject")
+pbix_bytes: bytes = compiler.compile_to_bytes()
+
+# e.g. write it yourself, stream it, upload it...
+with open("MyReport.pbix", "wb") as f:
+    f.write(pbix_bytes)
+```
+
+### 3. Handle errors
+
+```python
+from pathlib import Path
+from pbip_compiler import PbipCompiler
+
+try:
+    result: Path = PbipCompiler("./MyProject").compile("./out.pbix")
+    print(f"✅ Success → {result}")
+except FileNotFoundError as exc:
+    # e.g. no *.Report folder inside the project
+    print(f"❌ Project layout problem: {exc}")
+except Exception as exc:
+    print(f"❌ Compilation failed: {exc}")
+```
+
+### 4. Build a `.pbix` from a semantic model defined in code
+
+You don't have to start from a `.pbip` folder. You can describe a model with the
+data classes and build the DataModel directly.
+
+```python
+from pbip_compiler import Column, Measure, Relationship, SemanticModel, Table
+from pbip_compiler.datamodel import PbixMcpDataModelBuilder
+
+model = SemanticModel(
+    tables=[
+        Table(
+            name="Sales",
+            columns=[
+                Column(name="OrderId",   data_type="Int64"),
+                Column(name="ProductId", data_type="Int64"),
+                Column(name="Amount",    data_type="Decimal"),
+            ],
+            measures=[
+                Measure(name="Total Sales", expression="SUM(Sales[Amount])"),
+            ],
+            # Power Query (M) source — preserved so Refresh loads the data
+            m_expression='let Source = Csv.Document(File.Contents("sales.csv")) in Source',
+        ),
+        Table(
+            name="Product",
+            columns=[
+                Column(name="ProductId", data_type="Int64"),
+                Column(name="Name",      data_type="String"),
+            ],
+        ),
+    ],
+    relationships=[
+        Relationship(
+            from_table="Sales",   from_column="ProductId",
+            to_table="Product",   to_column="ProductId",
+        ),
+    ],
+)
+
+datamodel_bytes: bytes = PbixMcpDataModelBuilder().build(model)
+```
+
+## Public API
+
+| Object | Description |
+| --- | --- |
+| `PbipCompiler(pbip_path)` | Orchestrates a `.pbip` → `.pbix` compilation. |
+| `PbipCompiler.compile(output)` | Compile and write the `.pbix`; returns the `Path`. |
+| `PbipCompiler.compile_to_bytes()` | Compile and return the `.pbix` as `bytes`. |
+| `SemanticModel` | A model: `tables` + `relationships`. |
+| `Table` | `name`, `columns`, `measures`, `is_hidden`, `m_expression`. |
+| `Column` | `name`, `data_type`, `source_column`. |
+| `Measure` | `name`, `expression` (DAX). |
+| `Relationship` | `from_table`/`from_column` → `to_table`/`to_column`. |
+
+## How it works
+
+```
+.pbip folder
+   ├── *.Report/         → PBIR report  ─┐
+   └── *.SemanticModel/  → TMDL / .bim  ─┤
+                                         ▼
+        SemanticModelLoader  +  ReportLayoutLoader
+                                         ▼
+        PbixMcpDataModelBuilder  (VertiPaq DataModel, M preserved)
+                                         ▼
+        PbixAssembler  →  MyReport.pbix
+```
+
+- **Live connection** — if the report binds to a published semantic model, no
+  local DataModel is built; the report + a Connections part are embedded.
+- **No / empty semantic model** — a thin (report-only) `.pbix` is produced.
+
+## License
+
+[MIT](LICENSE) © 2026 Maxim Bacar

pbip_compiler-0.2.0/README.md

@@ -0,0 +1,157 @@
+# pbip-compiler
+
+Compile a **Power BI Project (`.pbip`)** folder into a single **`.pbix`** file —
+in pure Python. No Power BI Desktop, no external CLI tools, no Windows required.
+
+It parses the project's semantic model (TMDL / `model.bim`) and PBIR report,
+builds a real VertiPaq `DataModel` (via [`pbix-mcp`](https://pypi.org/project/pbix-mcp/)),
+preserves each table's Power Query (M) so the report stays refreshable, and
+assembles the final `.pbix` ZIP.
+
+## Features
+
+- 📦 `.pbip` → `.pbix` entirely in Python
+- 🧮 Builds a real VertiPaq DataModel (tables, columns, measures, relationships)
+- 🔁 Preserves partition M expressions → **Refresh** in Power BI loads the data
+- 🌐 Handles **live-connection** reports (bound to a published semantic model)
+- 🪶 Falls back to a thin / report-only `.pbix` when there is no local model
+
+## Installation
+
+```bash
+# with uv (recommended)
+uv add pbip-compiler
+
+# or with pip
+pip install pbip-compiler
+```
+
+Requires Python ≥ 3.11.
+
+## Quick start (CLI)
+
+```bash
+pbip-compiler --pbip ./MyProject --output ./MyReport.pbix
+```
+
+## Using `pbip_compiler` as a module
+
+### 1. Compile a `.pbip` folder to a `.pbix` file
+
+```python
+from pbip_compiler import PbipCompiler
+
+compiler = PbipCompiler("./MyProject")        # path to the .pbip folder
+output = compiler.compile("./MyReport.pbix")  # returns the resolved Path
+
+print(f"Compiled → {output}")
+```
+
+### 2. Compile to bytes (no file written)
+
+Useful when serving the result over HTTP, uploading it, or writing it yourself.
+
+```python
+from pbip_compiler import PbipCompiler
+
+compiler = PbipCompiler("./MyProject")
+pbix_bytes: bytes = compiler.compile_to_bytes()
+
+# e.g. write it yourself, stream it, upload it...
+with open("MyReport.pbix", "wb") as f:
+    f.write(pbix_bytes)
+```
+
+### 3. Handle errors
+
+```python
+from pathlib import Path
+from pbip_compiler import PbipCompiler
+
+try:
+    result: Path = PbipCompiler("./MyProject").compile("./out.pbix")
+    print(f"✅ Success → {result}")
+except FileNotFoundError as exc:
+    # e.g. no *.Report folder inside the project
+    print(f"❌ Project layout problem: {exc}")
+except Exception as exc:
+    print(f"❌ Compilation failed: {exc}")
+```
+
+### 4. Build a `.pbix` from a semantic model defined in code
+
+You don't have to start from a `.pbip` folder. You can describe a model with the
+data classes and build the DataModel directly.
+
+```python
+from pbip_compiler import Column, Measure, Relationship, SemanticModel, Table
+from pbip_compiler.datamodel import PbixMcpDataModelBuilder
+
+model = SemanticModel(
+    tables=[
+        Table(
+            name="Sales",
+            columns=[
+                Column(name="OrderId",   data_type="Int64"),
+                Column(name="ProductId", data_type="Int64"),
+                Column(name="Amount",    data_type="Decimal"),
+            ],
+            measures=[
+                Measure(name="Total Sales", expression="SUM(Sales[Amount])"),
+            ],
+            # Power Query (M) source — preserved so Refresh loads the data
+            m_expression='let Source = Csv.Document(File.Contents("sales.csv")) in Source',
+        ),
+        Table(
+            name="Product",
+            columns=[
+                Column(name="ProductId", data_type="Int64"),
+                Column(name="Name",      data_type="String"),
+            ],
+        ),
+    ],
+    relationships=[
+        Relationship(
+            from_table="Sales",   from_column="ProductId",
+            to_table="Product",   to_column="ProductId",
+        ),
+    ],
+)
+
+datamodel_bytes: bytes = PbixMcpDataModelBuilder().build(model)
+```
+
+## Public API
+
+| Object | Description |
+| --- | --- |
+| `PbipCompiler(pbip_path)` | Orchestrates a `.pbip` → `.pbix` compilation. |
+| `PbipCompiler.compile(output)` | Compile and write the `.pbix`; returns the `Path`. |
+| `PbipCompiler.compile_to_bytes()` | Compile and return the `.pbix` as `bytes`. |
+| `SemanticModel` | A model: `tables` + `relationships`. |
+| `Table` | `name`, `columns`, `measures`, `is_hidden`, `m_expression`. |
+| `Column` | `name`, `data_type`, `source_column`. |
+| `Measure` | `name`, `expression` (DAX). |
+| `Relationship` | `from_table`/`from_column` → `to_table`/`to_column`. |
+
+## How it works
+
+```
+.pbip folder
+   ├── *.Report/         → PBIR report  ─┐
+   └── *.SemanticModel/  → TMDL / .bim  ─┤
+                                         ▼
+        SemanticModelLoader  +  ReportLayoutLoader
+                                         ▼
+        PbixMcpDataModelBuilder  (VertiPaq DataModel, M preserved)
+                                         ▼
+        PbixAssembler  →  MyReport.pbix
+```
+
+- **Live connection** — if the report binds to a published semantic model, no
+  local DataModel is built; the report + a Connections part are embedded.
+- **No / empty semantic model** — a thin (report-only) `.pbix` is produced.
+
+## License
+
+[MIT](LICENSE) © 2026 Maxim Bacar

pbip_compiler-0.2.0/pbip_compiler/__init__.py

@@ -0,0 +1,38 @@
+"""pbip_compiler — compile a Power BI Project (.pbip) folder into a full .pbix file.
+
+Pure Python — no CLI tools, no Power BI Desktop, no Windows required.
+
+Public API
+──────────
+    from pbip_compiler import compile_pbip
+    compile_pbip("./MyProject", "./MyReport.pbix")
+
+Package layout
+──────────────
+    discovery        – locate the .Report / .SemanticModel folders
+    semantic_model/  – parse TMSL (model.bim) and TMDL into a normalised model
+    datamodel/       – build the VertiPaq DataModel via pbix-mcp (+ data fetch)
+    report/          – compile the PBIR report into a legacy Report/Layout
+    pbix/            – assemble the final .pbix ZIP
+    compiler         – orchestrates the above (compile_pbip)
+"""
+
+from __future__ import annotations
+
+from .compiler import PbipCompiler
+from .models import (
+    Column,
+    Measure,
+    Relationship,
+    SemanticModel,
+    Table,
+)
+
+__all__ = [
+    "PbipCompiler",
+    "SemanticModel",
+    "Table",
+    "Column",
+    "Measure",
+    "Relationship",
+]

pbip_compiler-0.2.0/pbip_compiler/cli.py

@@ -0,0 +1,33 @@
+"""Command-line entry point — compile a .pbip folder into a .pbix file."""
+
+from __future__ import annotations
+
+import sys
+from argparse import ArgumentParser, RawDescriptionHelpFormatter
+from pathlib import Path
+
+from . import PbipCompiler
+
+
+def main() -> None:
+    parser: ArgumentParser = ArgumentParser(
+        description     = "Compile a .pbip folder into a .pbix file (pure Python).",
+        formatter_class = RawDescriptionHelpFormatter,
+    )
+    parser.add_argument("--pbip",   required=True, help="Path to the .pbip project folder")
+    parser.add_argument("--output", required=True, help="Destination .pbix path")
+    args = parser.parse_args()
+
+    compiler: PbipCompiler = PbipCompiler(args.pbip)
+
+    try:
+        result: Path = compiler.compile(args.output)
+        print(f"\n✅  Success → {result}")
+
+    except Exception as exc:
+        print(f"\n❌  Error: {exc}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

pbip_compiler-0.2.0/pbip_compiler/compiler.py

@@ -0,0 +1,88 @@
+"""Public entry point — orchestrate the .pbip → .pbix compilation."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional, Union
+
+from .datamodel import PbixMcpDataModelBuilder
+from .discovery import (
+    find_report_folder,
+    find_semantic_model_folder,
+    read_live_connection,
+)
+from .pbix import PbixAssembler
+from .report import ReportLayoutLoader
+from .semantic_model import SemanticModelLoader
+
+
+class PbipCompiler:
+    """Compile a .pbip project folder into a .pbix file."""
+
+    def __init__(self, pbip_path : Union[Path, str]) -> None:
+        self._model_loader      = SemanticModelLoader()
+        self._layout_loader     = ReportLayoutLoader()
+        self._datamodel_builder = PbixMcpDataModelBuilder()
+        self._assembler         = PbixAssembler()
+
+        self.pbip_path : Path   = Path(pbip_path).resolve()
+
+    def compile(self, output: Union[Path, str]) -> Path:
+        """Compile the project and write the .pbix to ``output``."""
+        output : Path = Path(output).resolve()
+        self._compile(output)
+        return output
+
+    def compile_to_bytes(self) -> bytes:
+        """Compile the project and return the .pbix as bytes (no file written)."""
+        return self._compile(None)
+
+    def _compile(self, output: Optional[Path]) -> bytes:
+
+        print(f"[pbip→pbix]")
+        print(f"  source : {self.pbip_path}")
+
+
+        report_folder = find_report_folder(self.pbip_path)
+        print(f"  report : {report_folder.relative_to(self.pbip_path)}/")
+
+        # Live connection (report bound to a published semantic model): no local
+        # model — embed the PBIR report + a Connections part and we're done.
+        connection_string = read_live_connection(report_folder)
+        if connection_string:
+            print(f"  model  : live connection (remote semantic model)")
+            return self._assembler.assemble_live_connection(
+                output, report_folder, connection_string,
+            )
+
+        semantic_folder = find_semantic_model_folder(self.pbip_path)
+        print(f"  model  : {semantic_folder.relative_to(self.pbip_path) if semantic_folder else '(none)'}/")
+
+        # report layout
+        layout = self._layout_loader.load(report_folder)
+        print(f"  pages  : {len(layout.get('sections', []))}")
+
+        # base pbix
+        base_pbix = self._build_base_pbix(semantic_folder)
+
+        # Assemble
+        return self._assembler.assemble(output, layout, base_pbix, report_folder=report_folder)
+
+    def _build_base_pbix(self, semantic_folder: Optional[Path]) -> Optional[bytes]:
+        if not semantic_folder:
+            print("  data   : no SemanticModel folder — thin report")
+            return None
+
+        model = self._model_loader.load(semantic_folder)
+        if not model or not model.tables:
+            print("  data   : semantic model empty — thin report")
+            return None
+
+        n_t = len(model.tables)
+        n_m = sum(len(t.measures) for t in model.tables)
+        n_r = len(model.relationships)
+        print(f"  data   : building DataModel "
+              f"({n_t} tables, {n_m} measures, {n_r} relationships)")
+
+        return self._datamodel_builder.build(model)
+

pbip_compiler-0.2.0/pbip_compiler/datamodel/__init__.py

@@ -0,0 +1,10 @@
+"""DataModel building via pbix-mcp, with original-M preservation."""
+
+from __future__ import annotations
+
+from .builder import DataModelBuilder, PbixMcpDataModelBuilder
+
+__all__ = [
+    "DataModelBuilder",
+    "PbixMcpDataModelBuilder",
+]

pbip_compiler-0.2.0/pbip_compiler/datamodel/builder.py

@@ -0,0 +1,67 @@
+from    pbix_mcp.builder    import PBIXBuilder
+from    ..models            import Column, SemanticModel, Table
+from    .mpatch             import patch_partition_m
+from    abc                 import ABC, abstractmethod
+
+import  warnings
+
+class DataModelBuilder(ABC):
+    @abstractmethod
+    def build(self, model: SemanticModel) -> bytes:
+        ...
+
+class PbixMcpDataModelBuilder(DataModelBuilder):
+
+    def _sentinel_row(columns: list[Column]) -> dict:
+        """Return one placeholder row with zero/empty values per column type."""
+        row: dict = {}
+        for c in columns:
+            if c.data_type == "String":
+                row[c.name] = " "
+            elif c.data_type == "Boolean":
+                row[c.name] = False
+            else:
+                row[c.name] = 0
+        return row
+
+
+    def build(self, model: SemanticModel) -> bytes:
+        
+        builder : PBIXBuilder = PBIXBuilder()
+
+        for table in model.tables:
+            self._add_table(builder, table)
+            for measure in table.measures:
+                builder.add_measure(table.name, measure.name, measure.expression)
+
+        for relationship in model.relationships:
+            builder.add_relationship(
+                relationship.from_table, relationship.from_column, relationship.to_table, relationship.to_column,
+            )
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            pbix_bytes : bytes = builder.build()
+
+        # Overwrite pbix-mcp's placeholder partition query with the real M, so
+        # Refresh loads the data. Tables without an M keep the placeholder.
+        m_by_table = {t.name: t.m_expression for t in model.tables if t.m_expression}
+        for table in model.tables:
+            if table.m_expression:
+                print(f"    [data] {table.name}: M preserved → refreshable "
+                      f"(Refresh in Power BI loads the data)")
+            else:
+                print(f"    [warn] {table.name}: no partition M → empty table")
+
+        return patch_partition_m(pbix_bytes, m_by_table)
+
+    def _add_table(self, builder: PBIXBuilder, t: Table) -> None:
+        # No source_db: pbix-mcp writes a placeholder #table query, which build()
+        # overwrites with the table's real M. One sentinel row keeps VertiPaq's
+        # column store valid (rows=[] corrupts it).
+        builder.add_table(
+            name    = t.name,
+            columns = [c.model_dump(include={"name", "data_type"}) for c in t.columns],
+            rows    = [PbixMcpDataModelBuilder._sentinel_row(t.columns)],
+            hidden  = t.is_hidden,
+        )