pbip-compiler 0.2.0__py3-none-any.whl

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/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/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/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/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,
+        )

pbip_compiler/datamodel/mpatch.py

@@ -0,0 +1,39 @@
+from    pbix_mcp.formats.datamodel_roundtrip    import compress_datamodel, decompress_datamodel
+from    pbix_mcp.formats                        import abf_rebuild
+from    zipfile                                 import ZipFile, ZipInfo, ZIP_STORED, ZIP_DEFLATED
+from    io                                      import BytesIO
+from    sqlite3                                 import Connection
+
+def patch_partition_m(pbix_bytes: bytes, m_by_table: dict[str, str]) -> bytes:
+
+    if not m_by_table:
+        return pbix_bytes
+
+    with ZipFile(BytesIO(pbix_bytes)) as zf:
+        datamodel : bytes= zf.read("DataModel")
+
+    abf : bytes = decompress_datamodel(datamodel)
+
+    def modifier(conn: Connection) -> None:
+        for table_name, m_expr in m_by_table.items():
+            conn.execute(
+                "UPDATE [Partition] SET QueryDefinition = ? "
+                "WHERE Name = ? AND QueryDefinition IS NOT NULL",
+                (m_expr, table_name),
+            )
+
+    new_abf         : bytes = abf_rebuild.rebuild_abf_with_modified_sqlite(abf, modifier)
+    new_datamodel   : bytes = compress_datamodel(new_abf)
+
+    buf : BytesIO = BytesIO()
+    with ZipFile(BytesIO(pbix_bytes)) as zf_in:
+        with ZipFile(buf, "w", ZIP_DEFLATED) as zf_out:
+            for name in zf_in.namelist():
+                info : ZipInfo = ZipInfo(filename=name)
+                if name == "DataModel":
+                    info.compress_type = ZIP_STORED
+                    zf_out.writestr(info, new_datamodel)
+                else:
+                    info.compress_type = ZIP_DEFLATED
+                    zf_out.writestr(info, zf_in.read(name))
+    return buf.getvalue()

pbip_compiler/discovery.py

@@ -0,0 +1,50 @@
+import json
+from pathlib import Path
+from typing import Optional
+
+
+def find_report_folder(pbip_root: Path) -> Path:
+    """Return the *.Report folder (or any folder that looks like a report)."""
+    for d in pbip_root.glob("*.Report"):
+        if d.is_dir():
+            return d
+    for d in pbip_root.iterdir():
+        if d.is_dir() and (
+            (d / "definition.pbir").exists()
+            or (d / "report.json").exists()
+            or (d / "definition").is_dir()
+        ):
+            return d
+    raise FileNotFoundError(
+        f"No *.Report folder found inside {pbip_root}.\n"
+        "Expected:  MyProject/MyProject.Report/  (with report.json or definition/)"
+    )
+
+
+def find_semantic_model_folder(pbip_root: Path) -> Optional[Path]:
+    """Return the *.SemanticModel folder, or None for a report-only project."""
+    for d in pbip_root.glob("*.SemanticModel"):
+        if d.is_dir():
+            return d
+    return None
+
+
+def read_live_connection(report_folder: Path) -> Optional[str]:
+    """Return the live-connection string if the report binds to a remote model.
+
+    A "connect to a published semantic model" report has, in its
+    definition.pbir, datasetReference.byConnection.connectionString. Returns
+    that string, or None for a local-model (byPath) / model-less report.
+    """
+    pbir = report_folder / "definition.pbir"
+    if not pbir.exists():
+        return None
+    try:
+        with open(pbir, encoding="utf-8-sig") as f:
+            data = json.load(f)
+    except (json.JSONDecodeError, OSError):
+        return None
+    by_conn = data.get("datasetReference", {}).get("byConnection")
+    if isinstance(by_conn, dict):
+        return by_conn.get("connectionString")
+    return None

pbip_compiler/models.py

@@ -0,0 +1,37 @@
+from pydantic import BaseModel, Field
+
+
+class Column(BaseModel):
+    """A storage (non-calculated) column of a table."""
+    name: str
+    data_type: str = "String"          # pbix-mcp data_type string
+    source_column: str = ""            # source field name (defaults to name)
+
+    def model_post_init(self, __context) -> None:
+        if not self.source_column:
+            object.__setattr__(self, "source_column", self.name)
+
+
+class Measure(BaseModel):
+    name: str
+    expression: str = ""
+
+
+class Relationship(BaseModel):
+    from_table: str
+    from_column: str
+    to_table: str
+    to_column: str
+
+
+class Table(BaseModel):
+    name: str
+    columns: list[Column] = Field(default_factory=list)
+    measures: list[Measure] = Field(default_factory=list)
+    is_hidden: bool = False
+    m_expression: str = ""             # partition Power Query (M) source
+
+
+class SemanticModel(BaseModel):
+    tables: list[Table] = Field(default_factory=list)
+    relationships: list[Relationship] = Field(default_factory=list)

pbip_compiler/pbix/__init__.py

@@ -0,0 +1,7 @@
+"""PBIX ZIP assembly — patch layout into a pbix-mcp build, or build thin."""
+
+from __future__ import annotations
+
+from .assembler import PbixAssembler
+
+__all__ = ["PbixAssembler"]

pbip_compiler/pbix/assembler.py

@@ -0,0 +1,229 @@
+from    pbip_compiler.report.resources  import StaticResourceCollector
+from    .constants          import LIVE_CONTENT_TYPES, LIVE_METADATA, LIVE_SETTINGS, LIVE_VERSION, THIN_CONTENT_TYPES, THIN_DIAGRAM, THIN_METADATA, THIN_SETTINGS, THIN_VERSION
+
+from    pathlib             import Path
+from    typing              import Optional
+from    io                  import BytesIO
+
+import  json
+import  zipfile
+
+class PbixAssembler:
+    """Write the final .pbix file from a layout and an optional base PBIX."""
+
+    def __init__(self) -> None:
+        self._resources = StaticResourceCollector()
+
+    def assemble(
+        self,
+        output_path: Optional[Path],
+        layout: dict,
+        base_pbix: Optional[bytes],
+        report_folder: Optional[Path] = None,  # for copying theme/static resources
+    ) -> bytes:
+        """Build the .pbix bytes. Writes them to ``output_path`` when given,
+        otherwise just returns them (in-memory compilation)."""
+        name = output_path.name if output_path is not None else "(in-memory)"
+        print(f"\n[build] Assembling {name} …")
+
+        if base_pbix is not None:
+            raw = self._patch_layout_into_pbix(base_pbix, layout, report_folder)
+        else:
+            raw = self._build_thin_pbix(layout)
+
+        if output_path is not None:
+            output_path.write_bytes(raw)
+            print(f"\n[done] {output_path}  ({len(raw) / 1024:,.1f} KB)")
+        else:
+            print(f"\n[done] in-memory  ({len(raw) / 1024:,.1f} KB)")
+        return raw
+
+    def _patch_layout_into_pbix(
+        self,
+        base_pbix: bytes,
+        layout: dict,
+        report_folder: Optional[Path],
+    ) -> bytes:
+        """Replace Report/Layout in a pbix-mcp-generated PBIX with our own layout,
+        and embed any StaticResources (themes) referenced by resourcePackages.
+
+        Without the theme files the report engine raises "report load failed"
+        even though the DataModel loads fine — the layout references them by path.
+        """
+        layout_bytes = json.dumps(
+            layout, ensure_ascii=False, separators=(",", ":")
+        ).encode("utf-16-le")
+
+        extra_files: dict[str, bytes] = {}
+        if report_folder is not None:
+            extra_files = self._resources.collect(report_folder, layout)
+
+        buf = BytesIO()
+        with zipfile.ZipFile(BytesIO(base_pbix)) as zf_in:
+            with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as zf_out:
+                for name in zf_in.namelist():
+                    if name == "Report/Layout":
+                        info = zipfile.ZipInfo(filename=name)
+                        info.compress_type = zipfile.ZIP_DEFLATED
+                        zf_out.writestr(info, layout_bytes)
+                        print(f"  ✓  {name:<55} {len(layout_bytes):>10,} bytes  (from PBIP)")
+                    elif name == "DataModel":
+                        raw = zf_in.read(name)
+                        info = zipfile.ZipInfo(filename=name)
+                        info.compress_type = zipfile.ZIP_STORED
+                        zf_out.writestr(info, raw)
+                        print(f"  ✓  {name:<55} {len(raw):>10,} bytes  (from pbix-mcp)")
+                    else:
+                        raw = zf_in.read(name)
+                        info = zipfile.ZipInfo(filename=name)
+                        info.compress_type = zipfile.ZIP_DEFLATED
+                        zf_out.writestr(info, raw)
+                        print(f"  ✓  {name:<55} {len(raw):>10,} bytes")
+
+                for zip_key, data in extra_files.items():
+                    info = zipfile.ZipInfo(filename=zip_key)
+                    info.compress_type = zipfile.ZIP_DEFLATED
+                    zf_out.writestr(info, data)
+
+        return buf.getvalue()
+
+    def _build_thin_pbix(self, layout: dict) -> bytes:
+        """Build a minimal PBIX with no DataModel (thin/report-only).
+
+        Opens in Power BI Desktop as an empty report that can connect to
+        an external semantic model (Live Connection or DirectQuery).
+        """
+        layout_bytes = json.dumps(
+            layout, ensure_ascii=False, separators=(",", ":")
+        ).encode("utf-16-le")
+
+        buf = BytesIO()
+        with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as zf:
+            def add(name: str, data: bytes, compress: bool = True) -> None:
+                info = zipfile.ZipInfo(filename=name)
+                info.compress_type = zipfile.ZIP_DEFLATED if compress else zipfile.ZIP_STORED
+                zf.writestr(info, data)
+                print(f"  ✓  {name:<55} {len(data):>10,} bytes")
+
+            add("Version",             THIN_VERSION,        compress=False)
+            add("[Content_Types].xml", THIN_CONTENT_TYPES)
+            add("DiagramLayout",       THIN_DIAGRAM)
+            add("Settings",            THIN_SETTINGS)
+            add("Metadata",            THIN_METADATA)
+            add("Report/Layout",       layout_bytes)
+            print("  –  DataModel                                              (omitted — thin report)")
+        return buf.getvalue()
+
+    # ── Live connection (connect to a published semantic model) ──────────────
+    def assemble_live_connection(
+        self,
+        output_path: Optional[Path],
+        report_folder: Path,
+        connection_string: str,
+    ) -> bytes:
+        """Build a live-connection .pbix: no DataModel, a Connections part, and
+        the PBIR report (definition/ + StaticResources/) embedded verbatim under
+        Report/. The report binds to the remote model named in connection_string.
+
+        Writes to ``output_path`` when given, otherwise just returns the bytes.
+        """
+        name = output_path.name if output_path is not None else "(in-memory)"
+        print(f"\n[build] Assembling {name} (live connection) …")
+
+        buf = BytesIO()
+        with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as zf:
+            def add(name: str, data: bytes, compress: bool = True) -> None:
+                info = zipfile.ZipInfo(filename=name)
+                info.compress_type = zipfile.ZIP_DEFLATED if compress else zipfile.ZIP_STORED
+                zf.writestr(info, data)
+                print(f"  ✓  {name:<60} {len(data):>10,} bytes")
+
+            add("Version",             LIVE_VERSION, compress=False)
+            add("[Content_Types].xml", LIVE_CONTENT_TYPES)
+            add("Settings",            LIVE_SETTINGS)
+            add("Metadata",            LIVE_METADATA)
+            add("Connections",         self._build_connections(connection_string))
+
+            # Embed the PBIR report verbatim: definition/ + StaticResources/.
+            # (definition.pbir, .platform, .pbi … stay out — not PBIX parts.)
+            for sub in ("definition", "StaticResources"):
+                base = report_folder / sub
+                if not base.is_dir():
+                    continue
+                for f in sorted(base.rglob("*")):
+                    if f.is_file():
+                        rel = f.relative_to(report_folder).as_posix()
+                        add(f"Report/{rel}", f.read_bytes())
+
+            print("  –  DataModel                                              (omitted — live connection)")
+
+        raw = buf.getvalue()
+        if output_path is not None:
+            output_path.write_bytes(raw)
+            print(f"\n[done] {output_path}  ({len(raw) / 1024:,.1f} KB)")
+        else:
+            print(f"\n[done] in-memory  ({len(raw) / 1024:,.1f} KB)")
+        return raw
+
+    @staticmethod
+    def _build_connections(connection_string: str) -> bytes:
+        """Turn a PBIP byConnection string into the PBIX Connections part (UTF-8).
+
+        The PBIP connectionString carries the standard AS/Power BI keys plus
+        extra semanticmodelid/modelid params; the PBIX Connections part keeps the
+        four standard keys and lifts modelid → PbiServiceModelId, initial catalog
+        → PbiModelDatabaseName.
+        """
+        pairs = PbixAssembler._parse_conn_string(connection_string)
+
+        def unquote(s: str) -> str:
+            return s[1:-1] if len(s) >= 2 and s[0] == '"' and s[-1] == '"' else s
+
+        ds   = pairs.get("data source", "")
+        ic   = pairs.get("initial catalog", "")
+        ip   = unquote(pairs.get("identity provider", ""))
+        isec = pairs.get("integrated security", "ClaimsToken")
+
+        clean = (f'Data Source={ds};Initial Catalog={ic};'
+                 f'Identity Provider="{ip}";Integrated Security={isec}')
+
+        conn: dict = {
+            "Name": "EntityDataSource",
+            "ConnectionString": clean,
+            "ConnectionType": "pbiServiceLive",
+        }
+        if "modelid" in pairs:
+            try:
+                conn["PbiServiceModelId"] = int(pairs["modelid"])
+            except ValueError:
+                pass
+        conn["PbiModelVirtualServerName"] = "sobe_wowvirtualserver"
+        conn["PbiModelDatabaseName"] = ic
+
+        doc = {"Version": 2, "Connections": [conn]}
+        return json.dumps(doc, separators=(",", ":")).encode("utf-8")
+
+    @staticmethod
+    def _parse_conn_string(cs: str) -> dict:
+        """Parse a `key=value;…` connection string into a lowercased-key dict,
+        respecting double-quoted values (which may contain commas)."""
+        parts: list[str] = []
+        buf, in_quotes = "", False
+        for ch in cs:
+            if ch == '"':
+                in_quotes = not in_quotes
+                buf += ch
+            elif ch == ";" and not in_quotes:
+                parts.append(buf)
+                buf = ""
+            else:
+                buf += ch
+        if buf.strip():
+            parts.append(buf)
+
+        pairs: dict = {}
+        for p in parts:
+            if "=" in p:
+                k, v = p.split("=", 1)
+                pairs[k.strip().lower()] = v.strip()
+        return pairs