dax-quax 0.1.0__tar.gz

dax_quax-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,46 @@
+name: ci
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    # Ubuntu on purpose. CONVENTIONS §10 promises the suite runs with no Power BI Desktop,
+    # no .NET and no network; running it anywhere else would let that promise rot quietly.
+    runs-on: ubuntu-latest
+    strategy:
+      # Both results, always. With fail-fast one version's failure cancels the other and
+      # hides whether the problem is the code or that one interpreter.
+      fail-fast: false
+      matrix:
+        # Every version pyproject.toml's requires-python claims. ">=3.12" is a promise to
+        # anyone installing this, and a promise no job exercises is a guess. Widening
+        # requires-python means adding the version here in the same commit.
+        python: ["3.12", "3.13", "3.14"]
+    name: test (py${{ matrix.python }})
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
+        with:
+          python-version: ${{ matrix.python }}
+      - run: pip install -e ".[dev,file,report,serve,mcp]"
+      # One version is enough for lint: ruff reads the target-version from pyproject.
+      - run: ruff check .
+        if: matrix.python == '3.12'
+      - run: pytest -q
+
+  imports-without-extras:
+    # Installed bare, so a dependency somebody added to the core requirements without
+    # declaring it in pyproject.toml shows up here and nowhere else. The check itself also
+    # blocks the known optional packages, which is why it runs as an ordinary test on a
+    # developer machine where every extra is present -- see tools/check_imports.py.
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+      - run: pip install -e .
+      - run: python tools/check_imports.py

dax_quax-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,49 @@
+name: release
+
+on:
+  push:
+    tags: ["v*"]
+
+jobs:
+  build:
+    # Only the public copy publishes. The private repo carries this file so the two trees
+    # stay identical, and a tag pushed there must not race the real release to PyPI.
+    if: github.repository == 'S-CurveLabs/dax-quax'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+      # A tag that disagrees with pyproject.toml would publish a version nobody asked for,
+      # and PyPI never lets a version number be reused.
+      - name: tag matches version
+        run: |
+          version=$(python -c "import tomllib; print(tomllib.load(open('pyproject.toml','rb'))['project']['version'])")
+          test "v$version" = "$GITHUB_REF_NAME" || { echo "tag $GITHUB_REF_NAME != v$version"; exit 1; }
+      - run: pip install -e ".[dev,file,report,serve,mcp]"
+      - run: pytest -q
+      - run: pip install build twine
+      - run: python -m build
+      - run: twine check --strict dist/*
+      - uses: actions/upload-artifact@v7
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    # Trusted publishing: PyPI trusts this workflow and environment by name, so no API
+    # token is stored anywhere.
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/project/dax-quax/
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v8
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1

dax_quax-0.1.0/.gitignore

@@ -0,0 +1,53 @@
+# python
+__pycache__/
+*.py[cod]
+.venv/
+venv/
+*.egg-info/
+dist/
+build/
+.pytest_cache/
+.ruff_cache/
+
+# vendored .NET assemblies — fetched, not committed
+spikes/**/libs/
+src/dax_quax/_libs/
+*.nupkg
+*.runtimeconfig.json
+
+# local model artefacts
+*.pbix
+*.pbip
+*.abf
+*.vpax
+cache.abf
+
+# ...but fixtures are exempt. The synthetic .pbip project has to be committed, and
+# the patterns above would otherwise swallow it. Last matching rule wins, so this
+# has to sit after them.
+!tests/fixtures/**
+
+# local scratch renders
+.scratch/
+
+# a real .pbip corpus, borrowed rather than vendored (tools/fetch_demo.py).
+# It carries no licence, and CONVENTIONS §10 keeps CI offline.
+tests/fixtures/demo/
+
+# A fixture recorded from the borrowed corpus loaded into Power BI Desktop. Derived from
+# unlicensed content, so it is reproduced rather than committed:
+#   python tools/fetch_demo.py && open Report01.pbip && python tools/record_fixture.py demo01
+tests/fixtures/demo01/
+
+# Real .pbix samples, borrowed for the pbixray contract (tools/fetch_pbix.py).
+tests/fixtures/pbix/
+
+# Generated review / audit reports, from agents or otherwise. Each one is a snapshot of
+# one pass over the tree: it goes stale the moment a finding is fixed, and a stale one
+# gets quoted back as current fact. Keep what survived triage in CONVENTIONS or a test.
+*_report.md
+*_REPORT.md
+*review*.md
+*REVIEW*.md
+*redteam*.md
+*audit*.md

dax_quax-0.1.0/LICENSE

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

dax_quax-0.1.0/PKG-INFO

@@ -0,0 +1,183 @@
+Metadata-Version: 2.5
+Name: dax-quax
+Version: 0.1.0
+Summary: What does every object in this tabular model cost, what depends on it, and can it be deleted?
+Project-URL: Homepage, https://github.com/S-CurveLabs/dax-quax
+Project-URL: Source, https://github.com/S-CurveLabs/dax-quax
+Project-URL: Issues, https://github.com/S-CurveLabs/dax-quax/issues
+Author: S-Curve Labs
+License-Expression: MIT
+License-File: LICENSE
+Keywords: dax,mcp,pbip,power-bi,tabular,tmdl,vertipaq
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.12
+Requires-Dist: networkx>=3.0
+Requires-Dist: pandas>=2.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Provides-Extra: file
+Requires-Dist: pbixray>=0.3; extra == 'file'
+Provides-Extra: live
+Requires-Dist: pythonnet>=3.0; extra == 'live'
+Provides-Extra: mcp
+Requires-Dist: mcp>=2.2; extra == 'mcp'
+Provides-Extra: report
+Requires-Dist: jinja2>=3.1; extra == 'report'
+Provides-Extra: serve
+Requires-Dist: fastapi>=0.110; extra == 'serve'
+Requires-Dist: uvicorn>=0.29; extra == 'serve'
+Description-Content-Type: text/markdown
+
+# dax-quax
+
+**For every object in a Power BI model: what does it cost, what depends on it, and can it be deleted?**
+
+Not a DAX Studio clone. It answers one question, and it is careful about the answer, because
+telling you to delete a column that something still uses is the only way a tool like this can
+really hurt you.
+
+```
+Contoso  (pbip)
+  87 objects, 214.3 MB measured
+  REMOVE    6      41.2 MB   (19.2% of measured)
+  REVIEW    3       8.1 MB
+  UNKNOWN   0
+  KEEP     78
+
+top 3 by size:
+  REMOVE     28.4 MB  Sales[Order Number]
+             Remove it from the Power Query load.
+             Contoso.SemanticModel/definition/tables/Sales.tmdl:3
+
+scope: 3 reports scanned
+```
+
+## Install
+
+```bash
+pip install "dax-quax[file,report]"
+```
+
+Reading a `.pbip` project folder or a `.pbix` file needs nothing else — no Power BI Desktop,
+no .NET, and it works on Linux and macOS. To scan a *running* Power BI Desktop you also need
+the Microsoft client assemblies, which cannot ship in the wheel:
+
+```bash
+pip install "dax-quax[live]"
+dax-quax install-runtime
+```
+
+That fetches ADOMD.NET from nuget.org into a per-user folder. Windows only, because the
+engine it talks to is.
+
+If you skip it, the first live connection offers to do it for you when there is a terminal
+to ask at. Set `DAXQUAX_AUTO_INSTALL_RUNTIME=1` to answer yes in advance, or `=0` to be left
+alone — unattended runs are never prompted, because a question nobody can answer is a hang.
+
+They are not in the wheel on purpose. The assemblies are Microsoft's: the EULA does have a
+distributable-code clause, but it is scoped to a REDIST list the NuGet package does not
+contain, and one of its conditions is requiring end users to accept terms protecting
+Microsoft, which `pip install` does not do.
+
+| Extra | For |
+|---|---|
+| `file` | `.pbix`, `.abf`, PowerPivot `.xlsx` — metadata **and** sizes with nothing installed |
+| `report` | the HTML report |
+| `serve` | `serve`, the browsable version |
+| `live` | a running Power BI Desktop (plus `dax-quax install-runtime`) |
+| `mcp` | the MCP server |
+
+## Use it
+
+```bash
+dax-quax scan --pbip  path/to/Model.SemanticModel --report-folder path/to/Name.Report
+dax-quax scan --pbix  path/to/file.pbix
+dax-quax scan                                  # a running Power BI Desktop
+dax-quax scan --workspace path/to/folder       # every model, against every report over it
+
+dax-quax report --pbip DIR --out report.html   # one self-contained file, no network
+dax-quax serve  --pbip DIR                     # the same, plus lineage and a rescan
+dax-quax bench  "EVALUATE ..." --cold          # storage-engine vs formula-engine timings
+dax-quax mcp    --pbip DIR                     # answer questions about the model, read-only
+```
+
+As a library:
+
+```python
+from dax_quax import open_pbip
+
+model = open_pbip("path/to/Model.SemanticModel")
+model.findings()          # ranked cost x usage
+model.lineage()           # what breaks if this goes
+model.where("[Margin]")   # the file and line that define it
+```
+
+## What makes a verdict trustworthy
+
+A verdict is only as good as what was scanned, so **the scope travels with it** instead of
+living in a header you might not have read.
+
+- `REMOVE` means *nothing in what was scanned referenced it*. It is a question to put to a
+  person, not an instruction.
+- **If no report was scanned, nothing is ever `REMOVE`.** Every unreferenced object is
+  `UNKNOWN`, because a report you left out is usage that was not counted.
+- In a workspace scan, **one report that cannot be matched to its model degrades every
+  verdict in the whole directory.**
+- Anything the scan could not see is listed on the report, next to the verdicts.
+
+A false `REMOVE` is the expensive failure. `UNKNOWN` is free. The tool is built to prefer the
+second, and several places say so out loud rather than quietly rounding a gap to zero — a size
+it could not measure stays `None` and never becomes `0 B`.
+
+## For agents
+
+`dax-quax mcp` exposes the model over MCP, read-only, so you can ask an assistant what is safe
+to delete and why. The surface is fenced three ways: every tool is a function of a snapshot
+that holds no connection, an allowlist controls what is reachable, and each tool is advertised
+with the protocol's own `readOnlyHint`. Every payload carrying a verdict also carries the scope
+caveat — an agent gets one payload and no headline, so the caveat is attached centrally rather
+than left to each tool to remember.
+
+```jsonc
+{"dax-quax": {"command": "dax-quax", "args": ["mcp", "--pbip", "C:/path/Model.SemanticModel"]}}
+```
+
+## Limits worth knowing before you trust it
+
+- Consumers outside the artefacts you scan — Excel, paginated reports, anything on the XMLA
+  endpoint — are invisible. A workspace scan narrows this; it cannot close it.
+- Perspectives and translations are not walked. Neither can cause a false `REMOVE`.
+- `.pbix` sizes come from [pbixray](https://github.com/Hugoberry/pbixray), which reports no
+  encoding, no row count and no hierarchy size — those stay absent rather than becoming zero.
+- DAX references are *extracted*, not parsed. Dynamic references built with string
+  manipulation cannot be seen by anything that does not run the query.
+- Version 0.1. Six of the seven declared interfaces to Microsoft's formats and APIs turned out
+  to be wrong the first time they met a real engine; they are fixed and pinned by tests now,
+  but that is the nature of the terrain.
+
+## Development
+
+```bash
+python -m venv .venv && .venv/Scripts/activate   # source .venv/bin/activate elsewhere
+pip install -e ".[dev,file,report,serve,mcp]"
+pytest -q                      # no Power BI, no .NET, no network
+python tools/check_imports.py  # nothing may need an extra to import
+```
+
+Run `pytest` from inside the environment you installed into. The extras carry the test
+dependencies, so a `pytest` picked up from somewhere else fails during collection on an
+import — `No module named 'networkx'` — rather than on anything you changed.
+
+Tests that need something real are deselected by default — `-m live` for a running instance,
+`-m pbix` after `python tools/fetch_pbix.py`, `-m demo` after `python tools/fetch_demo.py`.
+
+## License
+
+MIT.

dax_quax-0.1.0/README.md

@@ -0,0 +1,146 @@
+# dax-quax
+
+**For every object in a Power BI model: what does it cost, what depends on it, and can it be deleted?**
+
+Not a DAX Studio clone. It answers one question, and it is careful about the answer, because
+telling you to delete a column that something still uses is the only way a tool like this can
+really hurt you.
+
+```
+Contoso  (pbip)
+  87 objects, 214.3 MB measured
+  REMOVE    6      41.2 MB   (19.2% of measured)
+  REVIEW    3       8.1 MB
+  UNKNOWN   0
+  KEEP     78
+
+top 3 by size:
+  REMOVE     28.4 MB  Sales[Order Number]
+             Remove it from the Power Query load.
+             Contoso.SemanticModel/definition/tables/Sales.tmdl:3
+
+scope: 3 reports scanned
+```
+
+## Install
+
+```bash
+pip install "dax-quax[file,report]"
+```
+
+Reading a `.pbip` project folder or a `.pbix` file needs nothing else — no Power BI Desktop,
+no .NET, and it works on Linux and macOS. To scan a *running* Power BI Desktop you also need
+the Microsoft client assemblies, which cannot ship in the wheel:
+
+```bash
+pip install "dax-quax[live]"
+dax-quax install-runtime
+```
+
+That fetches ADOMD.NET from nuget.org into a per-user folder. Windows only, because the
+engine it talks to is.
+
+If you skip it, the first live connection offers to do it for you when there is a terminal
+to ask at. Set `DAXQUAX_AUTO_INSTALL_RUNTIME=1` to answer yes in advance, or `=0` to be left
+alone — unattended runs are never prompted, because a question nobody can answer is a hang.
+
+They are not in the wheel on purpose. The assemblies are Microsoft's: the EULA does have a
+distributable-code clause, but it is scoped to a REDIST list the NuGet package does not
+contain, and one of its conditions is requiring end users to accept terms protecting
+Microsoft, which `pip install` does not do.
+
+| Extra | For |
+|---|---|
+| `file` | `.pbix`, `.abf`, PowerPivot `.xlsx` — metadata **and** sizes with nothing installed |
+| `report` | the HTML report |
+| `serve` | `serve`, the browsable version |
+| `live` | a running Power BI Desktop (plus `dax-quax install-runtime`) |
+| `mcp` | the MCP server |
+
+## Use it
+
+```bash
+dax-quax scan --pbip  path/to/Model.SemanticModel --report-folder path/to/Name.Report
+dax-quax scan --pbix  path/to/file.pbix
+dax-quax scan                                  # a running Power BI Desktop
+dax-quax scan --workspace path/to/folder       # every model, against every report over it
+
+dax-quax report --pbip DIR --out report.html   # one self-contained file, no network
+dax-quax serve  --pbip DIR                     # the same, plus lineage and a rescan
+dax-quax bench  "EVALUATE ..." --cold          # storage-engine vs formula-engine timings
+dax-quax mcp    --pbip DIR                     # answer questions about the model, read-only
+```
+
+As a library:
+
+```python
+from dax_quax import open_pbip
+
+model = open_pbip("path/to/Model.SemanticModel")
+model.findings()          # ranked cost x usage
+model.lineage()           # what breaks if this goes
+model.where("[Margin]")   # the file and line that define it
+```
+
+## What makes a verdict trustworthy
+
+A verdict is only as good as what was scanned, so **the scope travels with it** instead of
+living in a header you might not have read.
+
+- `REMOVE` means *nothing in what was scanned referenced it*. It is a question to put to a
+  person, not an instruction.
+- **If no report was scanned, nothing is ever `REMOVE`.** Every unreferenced object is
+  `UNKNOWN`, because a report you left out is usage that was not counted.
+- In a workspace scan, **one report that cannot be matched to its model degrades every
+  verdict in the whole directory.**
+- Anything the scan could not see is listed on the report, next to the verdicts.
+
+A false `REMOVE` is the expensive failure. `UNKNOWN` is free. The tool is built to prefer the
+second, and several places say so out loud rather than quietly rounding a gap to zero — a size
+it could not measure stays `None` and never becomes `0 B`.
+
+## For agents
+
+`dax-quax mcp` exposes the model over MCP, read-only, so you can ask an assistant what is safe
+to delete and why. The surface is fenced three ways: every tool is a function of a snapshot
+that holds no connection, an allowlist controls what is reachable, and each tool is advertised
+with the protocol's own `readOnlyHint`. Every payload carrying a verdict also carries the scope
+caveat — an agent gets one payload and no headline, so the caveat is attached centrally rather
+than left to each tool to remember.
+
+```jsonc
+{"dax-quax": {"command": "dax-quax", "args": ["mcp", "--pbip", "C:/path/Model.SemanticModel"]}}
+```
+
+## Limits worth knowing before you trust it
+
+- Consumers outside the artefacts you scan — Excel, paginated reports, anything on the XMLA
+  endpoint — are invisible. A workspace scan narrows this; it cannot close it.
+- Perspectives and translations are not walked. Neither can cause a false `REMOVE`.
+- `.pbix` sizes come from [pbixray](https://github.com/Hugoberry/pbixray), which reports no
+  encoding, no row count and no hierarchy size — those stay absent rather than becoming zero.
+- DAX references are *extracted*, not parsed. Dynamic references built with string
+  manipulation cannot be seen by anything that does not run the query.
+- Version 0.1. Six of the seven declared interfaces to Microsoft's formats and APIs turned out
+  to be wrong the first time they met a real engine; they are fixed and pinned by tests now,
+  but that is the nature of the terrain.
+
+## Development
+
+```bash
+python -m venv .venv && .venv/Scripts/activate   # source .venv/bin/activate elsewhere
+pip install -e ".[dev,file,report,serve,mcp]"
+pytest -q                      # no Power BI, no .NET, no network
+python tools/check_imports.py  # nothing may need an extra to import
+```
+
+Run `pytest` from inside the environment you installed into. The extras carry the test
+dependencies, so a `pytest` picked up from somewhere else fails during collection on an
+import — `No module named 'networkx'` — rather than on anything you changed.
+
+Tests that need something real are deselected by default — `-m live` for a running instance,
+`-m pbix` after `python tools/fetch_pbix.py`, `-m demo` after `python tools/fetch_demo.py`.
+
+## License
+
+MIT.

dax_quax-0.1.0/pyproject.toml

@@ -0,0 +1,89 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "dax-quax"
+version = "0.1.0"
+description = "What does every object in this tabular model cost, what depends on it, and can it be deleted?"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.12"
+authors = [{ name = "S-Curve Labs" }]
+keywords = ["power-bi", "tabular", "vertipaq", "dax", "tmdl", "pbip", "mcp"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Database",
+    "Topic :: Software Development :: Quality Assurance",
+]
+dependencies = ["pandas>=2.0", "networkx>=3.0"]
+
+[project.urls]
+Homepage = "https://github.com/S-CurveLabs/dax-quax"
+Source = "https://github.com/S-CurveLabs/dax-quax"
+Issues = "https://github.com/S-CurveLabs/dax-quax/issues"
+
+[project.optional-dependencies]
+live = ["pythonnet>=3.0"]
+file = ["pbixray>=0.3"]
+report = ["jinja2>=3.1"]
+serve = ["fastapi>=0.110", "uvicorn>=0.29"]
+mcp = ["mcp>=2.2"]
+dev = ["pytest>=8.0", "ruff>=0.6"]
+
+[project.scripts]
+dax-quax = "dax_quax.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/dax_quax"]
+# Never ship the vendored .NET assemblies. They are Microsoft's, whether we may
+# redistribute them is unsettled, and they are 5 MB that only a live connection uses --
+# `dax-quax install-runtime` fetches them per user instead. Hatchling already honours
+# .gitignore, where _libs/ also sits; this says it outright so the exclusion survives
+# anyone changing how files are selected.
+exclude = ["_libs/**"]
+
+[tool.hatch.build.targets.sdist]
+# The borrowed corpora are fetched per-developer, never shipped. None of them carries a
+# licence: the .pbix samples come from tools/fetch_pbix.py, the demo project from
+# tools/fetch_demo.py, and demo01 is recorded from that project loaded into Desktop.
+# .gitignore keeps them out of the repo, but hatchling's sdist does not honour the
+# re-ignore lines that follow `!tests/fixtures/**`, so it collected them off the local
+# disk instead -- a 28 MB sdist against a 148 KB wheel. Naming them here is what stops an
+# upload from redistributing 26 MB of somebody else's content.
+exclude = [
+    "/tests/fixtures/demo/**",
+    "/tests/fixtures/demo01/**",
+    "/tests/fixtures/pbix/**",
+    "/.claude/**",
+    # Private-repo only; tools/export_public.py leaves them out of the public tree too.
+    "/CONVENTIONS.md",
+    "/CODE_REVIEW.md",
+    "/spikes/**",
+    "/tools/export_public.py",
+]
+
+[tool.ruff]
+line-length = 100
+# spikes/ are frozen reproduction scripts for a finding, not maintained source.
+extend-exclude = ["spikes"]
+target-version = "py312"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+# so `pytest` works without an editable install, which CI should not need
+pythonpath = ["src"]
+markers = [
+    "live: requires a running Power BI Desktop instance (deselected by default)",
+    "pbix: requires a real .pbix via DAXQUAX_TEST_PBIX (deselected by default)",
+    "demo: requires the borrowed .pbip corpus; run tools/fetch_demo.py first",
+]
+addopts = "-m 'not live and not pbix and not demo'"

dax_quax-0.1.0/src/dax_quax/__init__.py

@@ -0,0 +1,86 @@
+"""dax-quax — what does every object in this tabular model cost, and can it be deleted?
+
+Public surface. Everything else is internal and may move.
+"""
+
+from __future__ import annotations
+
+from dax_quax.analysis.usage import (
+    Finding,
+    ScanScope,
+    Thresholds,
+    Verdict,
+    assess,
+)
+from dax_quax.errors import (
+    ConnectionDiscoveryError,
+    ContractViolation,
+    DaxQuaxError,
+    MissingCapability,
+)
+from dax_quax.model import Column, ColumnMetrics, Measure, Model, ObjectRef, Relationship, Table
+
+__version__ = "0.1.0"
+
+
+def connect(port: int | None = None, database: str | None = None) -> Model:
+    """Load a Model from a running local Power BI Desktop instance.
+
+    Windows only, and imported lazily so the rest of the package stays cross-platform.
+    """
+    from dax_quax.sources.live import connect as _connect
+
+    return _connect(port=port, database=database)
+
+
+def open_workspace(path: str):
+    """Scan a directory of .pbip artefacts: every model, against every report over it."""
+    from dax_quax.sources.workspace import discover_workspace
+
+    return discover_workspace(path)
+
+
+def open_pbip(path: str, *, attach_reports: bool = True) -> Model:
+    """Load a Model from a .pbip project folder, with its sibling reports attached.
+
+    Cross-platform: no .NET, no Power BI Desktop, nothing but text on disk.
+    """
+    from dax_quax.sources.pbip import open_pbip as _open
+
+    return _open(path, attach_reports=attach_reports)
+
+
+def open_file(path: str) -> Model:
+    """Load a Model from a .pbix, .abf or PowerPivot .xlsx.
+
+    The only source that carries metadata **and** storage metrics with no Power BI Desktop
+    and no local cache. Needs the ``file`` extra.
+    """
+    from dax_quax.sources.file import load_file
+
+    return load_file(path)
+
+
+__all__ = [
+    "Column",
+    "Finding",
+    "ScanScope",
+    "Thresholds",
+    "Verdict",
+    "ColumnMetrics",
+    "ConnectionDiscoveryError",
+    "ContractViolation",
+    "DaxQuaxError",
+    "Measure",
+    "MissingCapability",
+    "Model",
+    "ObjectRef",
+    "Relationship",
+    "Table",
+    "__version__",
+    "assess",
+    "connect",
+    "open_file",
+    "open_pbip",
+    "open_workspace",
+]

dax_quax-0.1.0/src/dax_quax/analysis/__init__.py

@@ -0,0 +1 @@
+"""Analyses. Pure functions of a Model."""