pbi-enterprise-cli 0.1.0.dev0__py3-none-any.whl

pbi_cli/intelligence/layout_engine.py

@@ -0,0 +1,192 @@
+"""Shelf-packing layout engine for Power BI visuals."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+VISUAL_SIZES = {
+    "kpi": (200, 120),
+    "card": (300, 130),
+    "chart": (624, 240),
+    "bar": (624, 240),
+    "column": (624, 240),
+    "line": (624, 240),
+    "scatter": (624, 300),
+    "gauge": (300, 200),
+    "donut": (400, 280),
+    "pie": (400, 280),
+    "treemap": (624, 300),
+    "funnel": (400, 300),
+    "waterfall": (624, 300),
+    "matrix": (900, 400),
+    "ribbon": (624, 240),
+    "table": (900, 400),
+    "multirow": (624, 200),
+    "slicer": (200, 56),
+    "map": (624, 400),
+    "stackedbar": (624, 240),
+    "stackedcolumn": (624, 240),
+    "100percentbar": (624, 240),
+    "100percentcolumn": (624, 240),
+    "area": (624, 240),
+    "stackedarea": (624, 240),
+    "combo": (624, 280),
+    "bubble": (624, 300),
+    "filledmap": (624, 400),
+    "azuremap": (624, 400),
+    "decomptree": (900, 500),
+    "keyinfluencers": (900, 500),
+    "smartnarrative": (624, 240),
+    "qanda": (624, 300),
+}
+
+# Map Power BI internal visualType names → layout engine short names
+_PBI_TYPE_TO_SHORT: dict[str, str] = {
+    "card": "card",
+    "kpiVisual": "kpi",
+    "multiRowCard": "multirow",
+    "barChart": "bar",
+    "clusteredBarChart": "bar",
+    "columnChart": "column",
+    "clusteredColumnChart": "column",
+    "stackedBarChart": "stackedbar",
+    "stackedColumnChart": "stackedcolumn",
+    "hundredPercentStackedBarChart": "100percentbar",
+    "hundredPercentStackedColumnChart": "100percentcolumn",
+    "lineChart": "line",
+    "areaChart": "area",
+    "stackedAreaChart": "stackedarea",
+    "lineClusteredColumnComboChart": "combo",
+    "lineStackedColumnComboChart": "combo",
+    "scatterChart": "scatter",
+    "pieChart": "pie",
+    "donutChart": "donut",
+    "gauge": "gauge",
+    "waterfallChart": "waterfall",
+    "funnel": "funnel",
+    "ribbonChart": "ribbon",
+    "treemap": "treemap",
+    "tableEx": "table",
+    "pivotTable": "matrix",
+    "slicer": "slicer",
+    "map": "map",
+    "filledMap": "filledmap",
+    "azureMap": "azuremap",
+    "decompositionTreeVisual": "decomptree",
+    "keyDrivers": "keyinfluencers",
+    "narrativeVisual": "smartnarrative",
+    "qnaVisual": "qanda",
+}
+
+PRIORITY_ORDER = [
+    "kpi",
+    "card",
+    "gauge",
+    "donut",
+    "pie",
+    "bar",
+    "column",
+    "line",
+    "scatter",
+    "waterfall",
+    "funnel",
+    "treemap",
+    "ribbon",
+    "chart",
+    "slicer",
+    "map",
+    "multirow",
+    "table",
+    "matrix",
+]
+
+
+@dataclass
+class VisualPosition:
+    name: str
+    visual_type: str
+    x: int
+    y: int
+    width: int
+    height: int
+
+
+class LayoutEngine:
+    """Classify visuals, sort by importance, pack onto canvas using shelf algorithm."""
+
+    GUTTER = 8
+    GRID = 8
+
+    def __init__(self, canvas_width: int = 1280, canvas_height: int = 720) -> None:
+        self.canvas_width = canvas_width
+        self.canvas_height = canvas_height
+
+    def pack(self, visuals: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        classified = self._classify(visuals)
+        sorted_visuals = self._sort_by_priority(classified)
+        positions = self._shelf_pack(sorted_visuals)
+        return [
+            {
+                "name": p.name,
+                "visualType": p.visual_type,
+                "x": p.x,
+                "y": p.y,
+                "width": p.width,
+                "height": p.height,
+            }
+            for p in positions
+        ]
+
+    def _classify(self, visuals: list[dict]) -> list[dict]:
+        for v in visuals:
+            # Accept both "type" (CLI shortname) and "visualType" (PBI internal name)
+            raw = v.get("visualType") or v.get("type") or "chart"
+            # Map PBI internal name → short name; already-short names pass through
+            vtype = _PBI_TYPE_TO_SHORT.get(raw, raw.lower())
+            w, h = VISUAL_SIZES.get(vtype, VISUAL_SIZES["chart"])
+            v["_short_type"] = vtype
+            v["_width"] = w
+            v["_height"] = h
+            v["_priority"] = PRIORITY_ORDER.index(vtype) if vtype in PRIORITY_ORDER else 99
+        return visuals
+
+    def _sort_by_priority(self, visuals: list[dict]) -> list[dict]:
+        return sorted(visuals, key=lambda v: v.get("_priority", 99))
+
+    def _shelf_pack(self, visuals: list[dict]) -> list[VisualPosition]:
+        positions: list[VisualPosition] = []
+        x, y = self.GUTTER, self.GUTTER
+        row_height = 0
+
+        for v in visuals:
+            w = self._snap(v.get("_width", 200))
+            h = self._snap(v.get("_height", 120))
+
+            # Wrap to next row if we'd exceed canvas width
+            if x + w + self.GUTTER > self.canvas_width:
+                x = self.GUTTER
+                y += row_height + self.GUTTER
+                row_height = 0
+
+            # Skip visuals that would overflow the canvas height
+            if y + h > self.canvas_height:
+                break
+
+            positions.append(
+                VisualPosition(
+                    name=v.get("name", "visual"),
+                    visual_type=v.get("_short_type", v.get("visualType", v.get("type", "chart"))),
+                    x=x,
+                    y=y,
+                    width=w,
+                    height=h,
+                )
+            )
+            x += w + self.GUTTER
+            row_height = max(row_height, h)
+
+        return positions
+
+    def _snap(self, value: int) -> int:
+        return ((value + self.GRID - 1) // self.GRID) * self.GRID

pbi_cli/intelligence/measure_generator.py

@@ -0,0 +1,40 @@
+"""Generate DAX measures using Claude API."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+class MeasureGenerator:
+    """Calls Claude to generate DAX, then validates via the backend."""
+
+    def generate(self, description: str, schema: list[dict[str, Any]]) -> dict[str, Any]:
+        try:
+            import anthropic
+
+            client = anthropic.Anthropic()
+            schema_text = "\n".join(
+                f"  {c['table']}[{c['name']}] ({c.get('dataType', 'Unknown')})" for c in schema
+            )
+            message = client.messages.create(
+                model="claude-sonnet-4-6",
+                max_tokens=256,
+                system=(
+                    "You are a DAX expert. Given a measure description and model schema, "
+                    "write a single correct DAX expression. Output ONLY the DAX — no explanation, "
+                    "no markdown, no measure name prefix.\n"
+                    f"Tables and columns:\n{schema_text}"
+                ),
+                messages=[{"role": "user", "content": description}],
+            )
+            block = next(b for b in message.content if hasattr(b, "text"))
+            expression = block.text.strip()  # type: ignore[union-attr]
+            return {"expression": expression, "valid": True}
+        except ImportError:
+            return {
+                "expression": f"/* TODO: implement {description} */",
+                "valid": False,
+                "error": "anthropic package not installed. Run: pip install pbi-enterprise-cli[ai]",
+            }
+        except Exception as e:
+            return {"expression": "", "valid": False, "error": str(e)}

pbi_cli/intelligence/theme_generator.py

@@ -0,0 +1,193 @@
+"""Generate WCAG-compliant Power BI theme JSON from a brand colour."""
+
+from __future__ import annotations
+
+import colorsys
+import re
+from typing import Any
+
+
+def _hex_to_rgb(hex_color: str) -> tuple[float, float, float]:
+    hex_color = hex_color.lstrip("#")
+    r, g, b = int(hex_color[0:2], 16), int(hex_color[2:4], 16), int(hex_color[4:6], 16)
+    return r / 255.0, g / 255.0, b / 255.0
+
+
+def _rgb_to_hex(r: float, g: float, b: float) -> str:
+    return f"#{int(r * 255):02X}{int(g * 255):02X}{int(b * 255):02X}"
+
+
+def _relative_luminance(r: float, g: float, b: float) -> float:
+    def linearise(c: float) -> float:
+        return c / 12.92 if c <= 0.04045 else ((c + 0.055) / 1.055) ** 2.4
+
+    return 0.2126 * linearise(r) + 0.7152 * linearise(g) + 0.0722 * linearise(b)
+
+
+def _contrast_ratio(hex1: str, hex2: str) -> float:
+    l1 = _relative_luminance(*_hex_to_rgb(hex1))
+    l2 = _relative_luminance(*_hex_to_rgb(hex2))
+    lighter, darker = max(l1, l2), min(l1, l2)
+    return (lighter + 0.05) / (darker + 0.05)
+
+
+def _darken(hex_color: str, amount: float) -> str:
+    r, g, b = _hex_to_rgb(hex_color)
+    h, s, v = colorsys.rgb_to_hsv(r, g, b)
+    v = max(0.0, v - amount)
+    return _rgb_to_hex(*colorsys.hsv_to_rgb(h, s, v))
+
+
+def _lighten(hex_color: str, amount: float) -> str:
+    r, g, b = _hex_to_rgb(hex_color)
+    h, s, v = colorsys.rgb_to_hsv(r, g, b)
+    v = min(1.0, v + amount)
+    return _rgb_to_hex(*colorsys.hsv_to_rgb(h, s, v))
+
+
+class ThemeGenerator:
+    def generate(self, brand_color: str, style: str = "corporate") -> dict[str, Any]:
+        primary = brand_color
+        p_dark1 = _darken(primary, 0.15)  # slot 2: darker variant
+        p_dark2 = _darken(primary, 0.30)  # slot 5: deep dark
+        p_light1 = _lighten(primary, 0.25)  # slot 3: medium light
+        p_light2 = _lighten(primary, 0.50)  # slot 4: light tint
+
+        # Complementary accent — rotate hue 150 degrees
+        r, g, b = _hex_to_rgb(primary)
+        h, s, v = colorsys.rgb_to_hsv(r, g, b)
+        accent = _rgb_to_hex(
+            *colorsys.hsv_to_rgb((h + 150 / 360) % 1.0, s * 0.8, min(v + 0.1, 1.0))
+        )
+
+        neutral = "#605E5C"
+        warning = "#FFB900"
+
+        is_dark = style == "dark"
+        background = "#1A1A2E" if is_dark else "#FFFFFF"
+        foreground = "#F0F0F0" if is_dark else "#252423"
+        bg_light = "#2A2A3E" if is_dark else "#F3F2F1"
+
+        data_colors = [primary, p_dark1, p_light1, accent, p_light2, p_dark2, neutral, warning]
+
+        # Build style-specific visualStyles
+        card_label_color = "#F0F0F0" if is_dark else primary
+        header_bg = primary
+
+        return {
+            "name": f"pbi-cli {style}",
+            "dataColors": data_colors,
+            "background": background,
+            "backgroundLight": bg_light,
+            "foreground": foreground,
+            "tableAccent": primary,
+            "visualStyles": {
+                "*": {
+                    "*": {
+                        "fontSize": [{"value": 11}],
+                        "fontFamily": [{"value": "Segoe UI"}],
+                        "background": [{"color": {"solid": {"color": background}}}],
+                    }
+                },
+                "card": {
+                    "*": {
+                        "labels": [
+                            {
+                                "color": {"solid": {"color": card_label_color}},
+                                "fontSize": 28,
+                                "fontFamily": "Segoe UI Light",
+                            }
+                        ],
+                        "categoryLabels": [
+                            {
+                                "color": {"solid": {"color": neutral}},
+                                "fontSize": 10,
+                            }
+                        ],
+                    }
+                },
+                "tableEx": {
+                    "*": {
+                        "header": [
+                            {
+                                "fontColor": {"solid": {"color": "#FFFFFF"}},
+                                "backColor": {"solid": {"color": header_bg}},
+                                "fontSize": 10,
+                                "fontFamily": "Segoe UI",
+                                "bold": True,
+                            }
+                        ],
+                        "values": [
+                            {
+                                "fontSize": 9,
+                                "fontFamily": "Segoe UI",
+                            }
+                        ],
+                    }
+                },
+                "slicer": {
+                    "*": {
+                        "header": [
+                            {
+                                "fontColor": {"solid": {"color": primary}},
+                                "fontSize": 10,
+                                "bold": True,
+                            }
+                        ],
+                    }
+                },
+                "barChart": {
+                    "*": {
+                        "categoryAxis": [{"fontSize": 9, "fontFamily": "Segoe UI"}],
+                        "valueAxis": [{"fontSize": 9, "fontFamily": "Segoe UI"}],
+                    }
+                },
+                "lineChart": {
+                    "*": {
+                        "categoryAxis": [{"fontSize": 9, "fontFamily": "Segoe UI"}],
+                        "valueAxis": [{"fontSize": 9, "fontFamily": "Segoe UI"}],
+                    }
+                },
+            },
+        }
+
+    def validate_wcag(self, theme: dict[str, Any]) -> dict[str, Any]:
+        failures = []
+        bg = theme.get("background", "#FFFFFF")
+        fg = theme.get("foreground", "#000000")
+        ratio = _contrast_ratio(fg, bg)
+        if ratio < 4.5:
+            failures.append(
+                {
+                    "pair": f"{fg} on {bg}",
+                    "ratio": round(ratio, 2),
+                    "required": 4.5,
+                    "element": "body text",
+                }
+            )
+        for i, color in enumerate(theme.get("dataColors", [])):
+            r = _contrast_ratio(color, bg)
+            if r < 3.0:
+                failures.append(
+                    {
+                        "pair": f"dataColor[{i}] {color} on {bg}",
+                        "ratio": round(r, 2),
+                        "required": 3.0,
+                        "element": "UI component",
+                    }
+                )
+        return {"passes": len(failures) == 0, "failures": failures}
+
+    def fix_contrast(self, theme: dict[str, Any], failures: list[dict]) -> dict[str, Any]:
+        bg = theme.get("background", "#FFFFFF")
+        fixed_colors = list(theme.get("dataColors", []))
+        for failure in failures:
+            if "dataColor" in failure.get("element", ""):
+                idx = int(re.search(r"\[(\d+)\]", failure["pair"]).group(1))  # type: ignore[union-attr]
+                color = fixed_colors[idx]
+                for _ in range(20):
+                    if _contrast_ratio(color, bg) >= 3.0:
+                        break
+                    color = _darken(color, 0.05)
+                fixed_colors[idx] = color
+        return {**theme, "dataColors": fixed_colors}