pypbip 0.1.0__tar.gz

pypbip-0.1.0/LICENSE

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

pypbip-0.1.0/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: pypbip
+Version: 0.1.0
+Summary: Python library for handling Power BI semantic model, report, and diagram artifacts
+Author: Pedro
+License-Expression: MIT
+Project-URL: Homepage, https://pypi.org/project/pypbip/
+Keywords: powerbi,semantic-model,tabular,report
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# pypbip
+
+`pypbip` is a Python library for handling Power BI project artifacts in code, including semantic model (`model.bim`), report metadata, and diagram layout structures.
+
+## Features
+
+- Work with semantic model objects such as tables, columns, measures, and DAX expressions.
+- Parse and write report sections and visual container metadata.
+- Handle diagram layouts and nodes programmatically.
+
+## Installation
+
+```bash
+pip install pypbip
+```
+
+## Quick Start
+
+```python
+from pypbip import ModelBim, Report, DiagramLayout
+
+# load a model.bim structure
+model = ModelBim.from_file("path/to/model.bim")
+
+# load report metadata
+report = Report.from_file("path/to/report.json")
+
+# load diagram layout metadata
+layout = DiagramLayout.from_file("path/to/diagramLayout.json")
+```
+
+## Compatibility
+
+- Python 3.9+
+
+## License
+
+MIT

pypbip-0.1.0/README.md

@@ -0,0 +1,38 @@
+# pypbip
+
+`pypbip` is a Python library for handling Power BI project artifacts in code, including semantic model (`model.bim`), report metadata, and diagram layout structures.
+
+## Features
+
+- Work with semantic model objects such as tables, columns, measures, and DAX expressions.
+- Parse and write report sections and visual container metadata.
+- Handle diagram layouts and nodes programmatically.
+
+## Installation
+
+```bash
+pip install pypbip
+```
+
+## Quick Start
+
+```python
+from pypbip import ModelBim, Report, DiagramLayout
+
+# load a model.bim structure
+model = ModelBim.from_file("path/to/model.bim")
+
+# load report metadata
+report = Report.from_file("path/to/report.json")
+
+# load diagram layout metadata
+layout = DiagramLayout.from_file("path/to/diagramLayout.json")
+```
+
+## Compatibility
+
+- Python 3.9+
+
+## License
+
+MIT

pypbip-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=69", "wheel", "build"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pypbip"
+version = "0.1.0"
+description = "Python library for handling Power BI semantic model, report, and diagram artifacts"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+authors = [
+  { name = "Pedro" }
+]
+keywords = ["powerbi", "semantic-model", "tabular", "report"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Software Development :: Libraries"
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://pypi.org/project/pypbip/"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+include-package-data = false
+
+[tool.setuptools.packages.find]
+where = ["src"]

pypbip-0.1.0/setup.cfg

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

pypbip-0.1.0/src/pypbip/__init__.py

@@ -0,0 +1,21 @@
+from .model_bim import ModelBim, SemanticModel, Table, DaxExpression, Column, Measure
+from .report import Report, Section, VisualContainer, ResourcePackage
+from .diagram import DiagramLayout, Diagram, DiagramNode
+
+__all__ = [
+    "ModelBim",
+    "SemanticModel",
+    "Table",
+    "DaxExpression",
+    "Column",
+    "Measure",
+    "Report",
+    "Section",
+    "VisualContainer",
+    "ResourcePackage",
+    "DiagramLayout",
+    "Diagram",
+    "DiagramNode",
+]
+
+

pypbip-0.1.0/src/pypbip/diagram/__init__.py

@@ -0,0 +1,9 @@
+from .diagram_layout import DiagramLayout
+from .diagram import Diagram
+from .diagram_node import DiagramNode
+
+__all__ = [
+    "DiagramLayout",
+    "Diagram",
+    "DiagramNode",
+]

pypbip-0.1.0/src/pypbip/diagram/diagram.py

@@ -0,0 +1,68 @@
+from typing import Dict, List
+
+from .diagram_node import DiagramNode
+from ..json_util import dump_json
+
+
+class Diagram:
+    def __init__(
+        self,
+        name: str,
+        ordinal: int,
+        nodes: List[DiagramNode],
+        scroll_position: Dict[str, float],
+        zoom_value: float,
+        pin_key_fields_to_top: bool,
+        show_extra_header_info: bool,
+        hide_key_fields_when_collapsed: bool,
+        tables_locked: bool,
+    ):
+        self.name = name
+        self.ordinal = ordinal
+        self.nodes = nodes
+        self.scroll_position = scroll_position
+        self.zoom_value = zoom_value
+        self.pin_key_fields_to_top = pin_key_fields_to_top
+        self.show_extra_header_info = show_extra_header_info
+        self.hide_key_fields_when_collapsed = hide_key_fields_when_collapsed
+        self.tables_locked = tables_locked
+        self.node_list = [n.name for n in self.nodes]
+        self.summary = {
+            "nodes": self.node_list,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Diagram":
+        return cls(
+            name=data.get("name"),
+            ordinal=data.get("ordinal"),
+            nodes=[DiagramNode.from_dict(n) for n in data.get("nodes")],
+            scroll_position=data.get("scrollPosition"),
+            zoom_value=data.get("zoomValue"),
+            pin_key_fields_to_top=data.get("pinKeyFieldsToTop"),
+            show_extra_header_info=data.get("showExtraHeaderInfo"),
+            hide_key_fields_when_collapsed=data.get("hideKeyFieldsWhenCollapsed"),
+            tables_locked=data.get("tablesLocked"),
+        )
+
+    def to_dict(self) -> dict:
+        return {
+            "ordinal": self.ordinal,
+            "scrollPosition": self.scroll_position,
+            "nodes": [n.to_dict() for n in self.nodes],
+            "name": self.name,
+            "zoomValue": self.zoom_value,
+            "pinKeyFieldsToTop": self.pin_key_fields_to_top,
+            "showExtraHeaderInfo": self.show_extra_header_info,
+            "hideKeyFieldsWhenCollapsed": self.hide_key_fields_when_collapsed,
+            "tablesLocked": self.tables_locked,
+        }
+
+    def to_json(self, indent: int = 2) -> str:
+        return dump_json(self.to_dict(), indent=indent)
+
+
+if __name__ == "__main__":
+    diagram_dict = {"name": "ExampleDiagram", "ordinal": 0, "nodes": []}
+    diagram = Diagram.from_dict(diagram_dict)
+    print(diagram.to_json())

pypbip-0.1.0/src/pypbip/diagram/diagram_layout.py

@@ -0,0 +1,115 @@
+import contextlib
+from ..json_util import read_json_file
+from typing import List, Dict
+from .diagram import Diagram
+from .diagram_node import DiagramNode
+from ..report import Section
+from ..model_bim import ModelBim, Table
+
+
+class DiagramLayout:
+    def __init__(
+        self,
+        version: str,
+        diagrams: List[Diagram],
+        selectedDiagram: str,
+        defaultDiagram: str,
+    ):
+        self.version = version
+        self.diagrams = diagrams
+        self.selectedDiagram = selectedDiagram
+        self.defaultDiagram = defaultDiagram
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "DiagramLayout":
+        return cls(
+            version=data.get("version"),
+            diagrams=[Diagram.from_dict(d) for d in data.get("diagrams", [])],
+            selectedDiagram=data.get("selectedDiagram"),
+            defaultDiagram=data.get("defaultDiagram"),
+        )
+
+    def to_dict(self) -> dict:
+        return {
+            "version": self.version,
+            "diagrams": [d.to_dict() for d in self.diagrams],
+            "selectedDiagram": self.selectedDiagram,
+            "defaultDiagram": self.defaultDiagram,
+        }
+
+    @classmethod
+    def from_file(cls, file_path: str) -> "DiagramLayout":
+        data = read_json_file(file_path)
+        return cls.from_dict(data)
+
+    def create_nodes(self, tables: List[str], mapping: Dict[str, Table]) -> List[DiagramNode]:
+        nodes = []
+        width = 300
+        height = 300
+        for idx, table in enumerate(tables):
+            with contextlib.suppress(Exception):
+                node_dict = {
+                    "location": {
+                        "x": 0 + idx * (width + 30),
+                        "y": 50 + 0 * height,
+                    },
+                    "nodeIndex": table,
+                    "nodeLineageTag": mapping[table].lineageTag,
+                    "size": {
+                        "height": height,
+                        "width": width
+                    },
+                    "zIndex": 0
+                }
+                node = DiagramNode.from_dict(node_dict)
+                nodes.append(node)
+        return nodes
+
+    def create_diagram(self, nodes: List[DiagramNode], name: str) -> Diagram:
+        diagram_dict = {
+            "ordinal": 99,
+            "scrollPosition": {
+                "x": 0,
+                "y": 0
+            },
+            "nodes": [node.to_dict() for node in nodes],
+            "name": f"@ {name}",
+            "zoomValue": 100,
+            "pinKeyFieldsToTop": True,
+            "showExtraHeaderInfo": False,
+            "hideKeyFieldsWhenCollapsed": False,
+            "tablesLocked": False
+        }
+        return Diagram.from_dict(diagram_dict)
+
+    def delete_existing_diagrams_with_section_names(self, section_names):
+        self.diagrams = [
+            diagram
+            for diagram in self.diagrams
+            if not diagram.name.startswith("@")
+        ]
+
+    def add_sections_diagrams(self, sections: List[Section], dataset: ModelBim):
+        section_names = []
+        sections_diagrams = []
+        for section in sections:
+            tables_from_fields = []
+            used_measures = [f.split(".")[-1] for f in section.used_fields if f.split(".")[-1] in dataset.model.measures.keys()]
+            for measure in used_measures:
+                field_used_tables = dataset.model.measures[measure].used_tables
+                tables_from_fields.extend(field_used_tables)
+            used_tables = section.used_tables + tables_from_fields
+            used_tables = list(set(used_tables))
+            nodes = self.create_nodes(used_tables, dataset.model.tables)
+            diagram = self.create_diagram(nodes, section.displayName)
+            sections_diagrams.append(diagram)
+            section_names.append(section.displayName)
+
+        self.delete_existing_diagrams_with_section_names(section_names)
+        self.diagrams.extend(sections_diagrams)
+
+
+if __name__ == "__main__":
+    diagramLayout_path = "BaseDataSet.Dataset/diagramLayout.json"
+    dl = DiagramLayout.from_file(diagramLayout_path)
+    print(dl.to_dict())

pypbip-0.1.0/src/pypbip/diagram/diagram_node.py

@@ -0,0 +1,51 @@
+from typing import Optional, Dict
+
+
+class DiagramNode:
+    def __init__(
+        self,
+        name: str,
+        location: Dict[str, float],
+        node_lineage_tag: str,
+        size: Dict[str, float],
+        z_index: int,
+        expanded_height: Optional[float] = None,
+    ):
+        self.name = name
+        self.location = location
+        self.node_lineage_tag = node_lineage_tag
+        self.size = size
+        self.z_index = z_index
+        self.expanded_height = expanded_height
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "DiagramNode":
+        return cls(
+            name=data.get("nodeIndex"),
+            location=data.get("location"),
+            node_lineage_tag=data.get("nodeLineageTag"),
+            size=data.get("size"),
+            z_index=data.get("zIndex"),
+            expanded_height=data.get("expandedHeight"),
+        )
+
+    def to_dict(self) -> dict:
+        base_dict = {
+            "location": self.location,
+            "nodeIndex": self.name,
+            "nodeLineageTag": self.node_lineage_tag,
+            "size": self.size,
+            "zIndex": self.z_index,
+        }
+        if self.expanded_height is not None:
+            base_dict["expandedHeight"] = self.expanded_height
+
+        for k in list(base_dict.keys()):
+            if base_dict[k] in (None, "", {}):
+                del base_dict[k]
+        return base_dict
+
+
+if __name__ == "__main__":
+    node = DiagramNode.from_dict({"nodeIndex": "ExampleNode", "location": {"x": 0, "y": 0}, "nodeLineageTag": "example-tag", "size": {"height": 100, "width": 200}, "zIndex": 0})
+    print(node.to_json())

pypbip-0.1.0/src/pypbip/json_util.py

@@ -0,0 +1,24 @@
+import json
+
+
+def write_json_file(filepath, content):
+    with open(filepath, "w", encoding="utf-8", newline="\n") as output_file:
+        json.dump(content, output_file, indent=2, ensure_ascii=False)
+
+
+def read_json_file(file_path) -> dict:
+    with open(file_path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def dump_json(obj, indent=2) -> str:
+    return json.dumps(obj, indent=indent, ensure_ascii=False)
+
+
+def dump_json_inline(obj) -> str:
+    return json.dumps(obj)
+
+
+def parse_json(s: str):
+    return json.loads(s)
+

pypbip-0.1.0/src/pypbip/model_bim/__init__.py

@@ -0,0 +1,17 @@
+from .model_bim import ModelBim
+from .semantic_model import SemanticModel
+from .table import Table
+from .dax_expression import DaxExpression
+from .column import Column
+from .measures import Measure
+
+__all__ = [
+    "ModelBim",
+    "SemanticModel",
+    "Table",
+    "DaxExpression",
+    "Column",
+    "Measure",
+]
+
+

pypbip-0.1.0/src/pypbip/model_bim/column.py

@@ -0,0 +1,104 @@
+from ..json_util import read_json_file, dump_json
+from .dax_expression import DaxExpression
+
+
+class Column:
+    def __init__(
+            self,
+            sortByColumn,
+            expression,
+            isDataTypeInferred,
+            extendedProperties,
+            dataType,
+            description,
+            summarizeBy,
+            type,
+            isHidden,
+            name,
+            formatString,
+            changedProperties,
+            isNameInferred,
+            relatedColumnDetails,
+            sourceColumn,
+            lineageTag,
+            displayFolder,
+            annotations,
+        ):
+        self.sortByColumn = sortByColumn
+        self.expression = DaxExpression(expression)
+        self.isDataTypeInferred = isDataTypeInferred
+        self.extendedProperties = extendedProperties
+        self.dataType = dataType
+        self.description = description
+        self.summarizeBy = summarizeBy
+        self.type = type
+        self.isHidden = isHidden
+        self.name = name
+        self.formatString = formatString
+        self.changedProperties = changedProperties
+        self.isNameInferred = isNameInferred
+        self.relatedColumnDetails = relatedColumnDetails
+        self.sourceColumn = sourceColumn
+        self.lineageTag = lineageTag
+        self.displayFolder = displayFolder
+        self.annotations = annotations
+
+    @classmethod
+    def from_file(cls, file_path: str) -> "Column":
+        data: dict = read_json_file(file_path)
+        return Column.from_dict(data)
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Column":
+        return cls(
+            sortByColumn=data.get("sortByColumn"),
+            expression=data.get("expression"),
+            isDataTypeInferred=data.get("isDataTypeInferred"),
+            extendedProperties=data.get("extendedProperties"),
+            dataType=data.get("dataType"),
+            description=data.get("description"),
+            summarizeBy=data.get("summarizeBy"),
+            type=data.get("type"),
+            isHidden=data.get("isHidden"),
+            name=data.get("name"),
+            formatString=data.get("formatString"),
+            changedProperties=data.get("changedProperties"),
+            isNameInferred=data.get("isNameInferred"),
+            relatedColumnDetails=data.get("relatedColumnDetails"),
+            sourceColumn=data.get("sourceColumn"),
+            lineageTag=data.get("lineageTag"),
+            displayFolder=data.get("displayFolder"),
+            annotations=data.get("annotations"),
+        )
+
+    def to_dict(self) -> dict:
+        base_dict = {
+            "name": self.name,
+            "annotations": self.annotations,
+            "changedProperties": self.changedProperties,
+            "dataType": self.dataType,
+            "description": self.description,
+            "displayFolder": self.displayFolder,
+            "expression": self.expression.to_dict(),
+            "extendedProperties": self.extendedProperties,
+            "formatString": self.formatString,
+            "isDataTypeInferred": self.isDataTypeInferred,
+            "isHidden": self.isHidden,
+            "isNameInferred": self.isNameInferred,
+            "lineageTag": self.lineageTag,
+            "relatedColumnDetails": self.relatedColumnDetails,
+            "sortByColumn": self.sortByColumn,
+            "sourceColumn": self.sourceColumn,
+            "summarizeBy": self.summarizeBy,
+            "type": self.type,
+        }
+        for k in list(base_dict.keys()):
+            if base_dict[k] in (None, "", []):
+                del base_dict[k]
+        return base_dict
+
+    def to_json(self, indent: int = 2) -> str:
+        return dump_json(self.to_dict(), indent=indent)
+
+    def clean_expression(self):
+        self.expression.clean_expression()