py-tbparse 0.1.1a0__tar.gz → 0.2.0__tar.gz

{py_tbparse-0.1.1a0 → py_tbparse-0.2.0}/AGENTS.md

@@ -220,7 +220,13 @@ the test fixture picks that directory up automatically via
 `LD_LIBRARY_PATH`. It verifies each download against the checksum
 `apt-get --print-uris` reports for it (SHA256 if offered, MD5Sum as the
 realistic fallback — this environment's apt only emits MD5Sum) before
-extracting; don't remove that step to "simplify" the script. Don't add
+extracting; don't remove that step to "simplify" the script. URIs that
+aren't plain http(s) (e.g. `mirror+file:` apt sources, which `wget` can't
+fetch) are downloaded with `apt-get download` instead, still followed by
+the same checksum check. It also unpacks `xkb-data` and a font, and the
+test fixture sets `XKB_CONFIG_ROOT`/`FONTCONFIG_FILE` from them: on a host
+with neither, Chromium silently drops all keyboard input (so `fill()`
+leaves inputs empty and tests time out) and may crash rendering. Don't add
 `pytest-playwright` — it's a pytest plugin that imports playwright at
 startup, which makes collection fail for anyone who doesn't have it
 installed.

{py_tbparse-0.1.1a0 → py_tbparse-0.2.0}/MANIFEST.in

@@ -4,3 +4,4 @@ include AGENTS.md
 recursive-include tests *.py
 include tests/fixtures/*.twb
 include tests/fixtures/*.twbx
+recursive-include docs *.png

py_tbparse-0.2.0/PKG-INFO

@@ -0,0 +1,150 @@
+Metadata-Version: 2.4
+Name: py-tbparse
+Version: 0.2.0
+Summary: Native Python port of the twbparser R package: parse Tableau .twb/.twbx workbooks into pandas DataFrames.
+Author: DDSNA
+License: MIT
+Project-URL: Homepage, https://github.com/DDSNA/py-tbparse
+Project-URL: Source, https://github.com/DDSNA/py-tbparse
+Project-URL: Issues, https://github.com/DDSNA/py-tbparse/issues
+Keywords: tableau,twb,twbx,workbook,parser,pandas
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+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: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Office/Business
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: lxml>=4.9
+Requires-Dist: pandas>=1.5
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Provides-Extra: browser
+Requires-Dist: playwright>=1.40; extra == "browser"
+Provides-Extra: dev
+Requires-Dist: build>=1.0; extra == "dev"
+Requires-Dist: twine>=5.0; extra == "dev"
+Dynamic: license-file
+
+# py-tbparse
+
+Reads Tableau workbooks (`.twb` and `.twbx`) and gives you what's in them as pandas DataFrames: datasources, fields, calculated fields, joins, relationships, dashboards, custom SQL. It's plain Python. You don't need Tableau or R installed.
+
+It began as a port of PrigasG's R package [twbparser](https://github.com/PrigasG/twbparser). The browser GUI, the command-line tool, workbook diffing and folder scanning are new here.
+
+![py-tbparse GUI, overview of a loaded workbook](https://raw.githubusercontent.com/DDSNA/py-tbparse/main/docs/gui-overview.png)
+
+## Install
+
+```bash
+git clone https://github.com/DDSNA/py-tbparse.git
+cd py-tbparse
+pip install -e .
+```
+
+The project got renamed but the module and commands didn't, so: import `twbparser_py`, run `twbparser` or `twbparser-gui`.
+
+## Using it from Python
+
+```python
+from twbparser_py import TwbParser
+
+p = TwbParser("workbook.twb")    # or a .twbx
+p.get_overview()                 # counts of everything
+p.get_calculated_fields()        # each calculation and its formula
+p.get_relationships()            # how the tables connect
+```
+
+Every getter returns a DataFrame. The rest are `get_datasources`, `get_parameters`, `get_fields`, `get_raw_fields`, `get_joins`, `get_relations`, `get_inferred_relationships`, `get_dashboards`, `get_dashboard_sheets`, `get_custom_sql`, `get_initial_sql` and `get_published_refs`. `get_relationship_graph_dot()` returns the data model as Graphviz text, and `validate()` looks for problems in the relationships. In Jupyter, a bare `p` shows the overview.
+
+Two helpers work across workbooks:
+
+```python
+from twbparser_py import diff_workbooks, scan_folder
+
+diff_workbooks(TwbParser("v1.twb"), TwbParser("v2.twb"), table="datasources")
+scan_folder("./workbooks", table="datasources")   # one table, every workbook in the folder
+```
+
+### `.twbx` files
+
+A `.twbx` is read directly from the zip and nothing gets written to disk. That means `p.twbx_dir` is `None`, and `p.path` is a made-up `<file>.twbx/<name>.twb` that you can't open. If you want the files out, extract them yourself:
+
+```python
+from twbparser_py import extract_twb_from_twbx, twbx_extract_files
+
+extract_twb_from_twbx("workbook.twbx", extract_dir="out/")
+twbx_extract_files("workbook.twbx", exdir="out/")    # everything in the package
+```
+
+## Command line
+
+```bash
+twbparser workbook.twb                        # overview
+twbparser workbook.twb tables                 # list the tables
+twbparser workbook.twb calculated-fields
+twbparser workbook.twb fields --format csv -o fields.csv
+twbparser workbook.twbx dashboard-sheets --dashboard "Sales Overview"
+twbparser workbook.twb validate               # exit code 2 if it finds a problem
+twbparser workbook.twb graph > model.dot      # --include-inferred adds the guessed links
+twbparser diff old.twb new.twb datasources
+twbparser batch ./workbooks datasources
+```
+
+Tables: `overview`, `datasources`, `parameters`, `fields`, `raw-fields`, `calculated-fields`, `joins`, `relations`, `relationships`, `inferred-relationships`, `dashboards`, `dashboard-sheets`, `custom-sql`, `initial-sql`, `published-refs`.
+
+`--format` takes `table` (default), `csv` or `json`. `graph` always prints Graphviz text. `diff` and `batch` accept the same table names except `graph`, `validate` and `tables`.
+
+## GUI
+
+```bash
+twbparser-gui workbook.twb               # opens your browser with it loaded
+twbparser-gui                            # starts empty, paste a path and hit Load
+twbparser-gui --no-browser --port 8765   # server only, for a machine with no display
+```
+
+It uses only the standard library, so there's nothing more to install.
+
+The sidebar lists every table with its row count. Click a column header to sort, type in the filter box to narrow rows (`/` jumps to it), click a row to see a long formula or SQL statement in full. The tiles on the overview open their tables. The graph view lets you copy or download the DOT text. Everything else exports as CSV. It has a dark theme and works in a narrow window.
+
+It's meant to run on your own machine for one person. It refuses requests that come from other websites, but there's no login, so don't put it on a shared network.
+
+## Tests
+
+```bash
+pip install -e ".[test]"
+pytest
+```
+
+The sample workbooks in `tests/fixtures/` come from the R package.
+
+The GUI tests run the page in headless Chromium through Playwright and fail on any JavaScript error. They skip if the browser isn't installed. To run them:
+
+```bash
+pip install -e ".[test,browser]"
+playwright install chromium         # add --with-deps if you have root
+./scripts/setup-browser-libs.sh     # without root, this unpacks the system libraries locally
+pytest tests/test_gui_browser.py
+```
+
+## Compared with the R package
+
+The code follows the R original function by function, and the aim is the same output. Not everything is ported. Missing so far: formatting, tooltips, colors, axes and sorts, dashboard layout and actions, the analytics helpers (calculation complexity, field usage, replication brief) and the Shiny inspector. The GUI covers some of what the inspector did.
+
+Where the R version has a bug, this one doesn't copy it. That currently covers joins and relationships on more than one key, nested joins, the include-parameters option, and calculations with brackets inside brackets.
+
+## Why a Tableau parser
+
+A `.twb` is XML and a `.twbx` is a zip containing one, so reading them from Python isn't hard. Power BI's `.pbix` is a binary format built on a proprietary storage engine, and getting into it from code took reverse-engineering projects like [PBIXRay](https://github.com/Hugoberry/pbixray) and [pbi-tools](https://github.com/pbi-tools/pbi-tools). On the server side it goes the other way: Tableau's own Python tooling ([tableauserverclient](https://pypi.org/project/tableauserverclient/) and `tabcmd`) is more mature and more open than what Microsoft has for the Power BI REST API.
+
+## Credit
+
+Based on [twbparser](https://github.com/PrigasG/twbparser) by George Arthur, MIT licensed.

py_tbparse-0.2.0/README.md

@@ -0,0 +1,114 @@
+# py-tbparse
+
+Reads Tableau workbooks (`.twb` and `.twbx`) and gives you what's in them as pandas DataFrames: datasources, fields, calculated fields, joins, relationships, dashboards, custom SQL. It's plain Python. You don't need Tableau or R installed.
+
+It began as a port of PrigasG's R package [twbparser](https://github.com/PrigasG/twbparser). The browser GUI, the command-line tool, workbook diffing and folder scanning are new here.
+
+![py-tbparse GUI, overview of a loaded workbook](https://raw.githubusercontent.com/DDSNA/py-tbparse/main/docs/gui-overview.png)
+
+## Install
+
+```bash
+git clone https://github.com/DDSNA/py-tbparse.git
+cd py-tbparse
+pip install -e .
+```
+
+The project got renamed but the module and commands didn't, so: import `twbparser_py`, run `twbparser` or `twbparser-gui`.
+
+## Using it from Python
+
+```python
+from twbparser_py import TwbParser
+
+p = TwbParser("workbook.twb")    # or a .twbx
+p.get_overview()                 # counts of everything
+p.get_calculated_fields()        # each calculation and its formula
+p.get_relationships()            # how the tables connect
+```
+
+Every getter returns a DataFrame. The rest are `get_datasources`, `get_parameters`, `get_fields`, `get_raw_fields`, `get_joins`, `get_relations`, `get_inferred_relationships`, `get_dashboards`, `get_dashboard_sheets`, `get_custom_sql`, `get_initial_sql` and `get_published_refs`. `get_relationship_graph_dot()` returns the data model as Graphviz text, and `validate()` looks for problems in the relationships. In Jupyter, a bare `p` shows the overview.
+
+Two helpers work across workbooks:
+
+```python
+from twbparser_py import diff_workbooks, scan_folder
+
+diff_workbooks(TwbParser("v1.twb"), TwbParser("v2.twb"), table="datasources")
+scan_folder("./workbooks", table="datasources")   # one table, every workbook in the folder
+```
+
+### `.twbx` files
+
+A `.twbx` is read directly from the zip and nothing gets written to disk. That means `p.twbx_dir` is `None`, and `p.path` is a made-up `<file>.twbx/<name>.twb` that you can't open. If you want the files out, extract them yourself:
+
+```python
+from twbparser_py import extract_twb_from_twbx, twbx_extract_files
+
+extract_twb_from_twbx("workbook.twbx", extract_dir="out/")
+twbx_extract_files("workbook.twbx", exdir="out/")    # everything in the package
+```
+
+## Command line
+
+```bash
+twbparser workbook.twb                        # overview
+twbparser workbook.twb tables                 # list the tables
+twbparser workbook.twb calculated-fields
+twbparser workbook.twb fields --format csv -o fields.csv
+twbparser workbook.twbx dashboard-sheets --dashboard "Sales Overview"
+twbparser workbook.twb validate               # exit code 2 if it finds a problem
+twbparser workbook.twb graph > model.dot      # --include-inferred adds the guessed links
+twbparser diff old.twb new.twb datasources
+twbparser batch ./workbooks datasources
+```
+
+Tables: `overview`, `datasources`, `parameters`, `fields`, `raw-fields`, `calculated-fields`, `joins`, `relations`, `relationships`, `inferred-relationships`, `dashboards`, `dashboard-sheets`, `custom-sql`, `initial-sql`, `published-refs`.
+
+`--format` takes `table` (default), `csv` or `json`. `graph` always prints Graphviz text. `diff` and `batch` accept the same table names except `graph`, `validate` and `tables`.
+
+## GUI
+
+```bash
+twbparser-gui workbook.twb               # opens your browser with it loaded
+twbparser-gui                            # starts empty, paste a path and hit Load
+twbparser-gui --no-browser --port 8765   # server only, for a machine with no display
+```
+
+It uses only the standard library, so there's nothing more to install.
+
+The sidebar lists every table with its row count. Click a column header to sort, type in the filter box to narrow rows (`/` jumps to it), click a row to see a long formula or SQL statement in full. The tiles on the overview open their tables. The graph view lets you copy or download the DOT text. Everything else exports as CSV. It has a dark theme and works in a narrow window.
+
+It's meant to run on your own machine for one person. It refuses requests that come from other websites, but there's no login, so don't put it on a shared network.
+
+## Tests
+
+```bash
+pip install -e ".[test]"
+pytest
+```
+
+The sample workbooks in `tests/fixtures/` come from the R package.
+
+The GUI tests run the page in headless Chromium through Playwright and fail on any JavaScript error. They skip if the browser isn't installed. To run them:
+
+```bash
+pip install -e ".[test,browser]"
+playwright install chromium         # add --with-deps if you have root
+./scripts/setup-browser-libs.sh     # without root, this unpacks the system libraries locally
+pytest tests/test_gui_browser.py
+```
+
+## Compared with the R package
+
+The code follows the R original function by function, and the aim is the same output. Not everything is ported. Missing so far: formatting, tooltips, colors, axes and sorts, dashboard layout and actions, the analytics helpers (calculation complexity, field usage, replication brief) and the Shiny inspector. The GUI covers some of what the inspector did.
+
+Where the R version has a bug, this one doesn't copy it. That currently covers joins and relationships on more than one key, nested joins, the include-parameters option, and calculations with brackets inside brackets.
+
+## Why a Tableau parser
+
+A `.twb` is XML and a `.twbx` is a zip containing one, so reading them from Python isn't hard. Power BI's `.pbix` is a binary format built on a proprietary storage engine, and getting into it from code took reverse-engineering projects like [PBIXRay](https://github.com/Hugoberry/pbixray) and [pbi-tools](https://github.com/pbi-tools/pbi-tools). On the server side it goes the other way: Tableau's own Python tooling ([tableauserverclient](https://pypi.org/project/tableauserverclient/) and `tabcmd`) is more mature and more open than what Microsoft has for the Power BI REST API.
+
+## Credit
+
+Based on [twbparser](https://github.com/PrigasG/twbparser) by George Arthur, MIT licensed.

py_tbparse-0.2.0/py_tbparse.egg-info/PKG-INFO

@@ -0,0 +1,150 @@
+Metadata-Version: 2.4
+Name: py-tbparse
+Version: 0.2.0
+Summary: Native Python port of the twbparser R package: parse Tableau .twb/.twbx workbooks into pandas DataFrames.
+Author: DDSNA
+License: MIT
+Project-URL: Homepage, https://github.com/DDSNA/py-tbparse
+Project-URL: Source, https://github.com/DDSNA/py-tbparse
+Project-URL: Issues, https://github.com/DDSNA/py-tbparse/issues
+Keywords: tableau,twb,twbx,workbook,parser,pandas
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+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: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Office/Business
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: lxml>=4.9
+Requires-Dist: pandas>=1.5
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Provides-Extra: browser
+Requires-Dist: playwright>=1.40; extra == "browser"
+Provides-Extra: dev
+Requires-Dist: build>=1.0; extra == "dev"
+Requires-Dist: twine>=5.0; extra == "dev"
+Dynamic: license-file
+
+# py-tbparse
+
+Reads Tableau workbooks (`.twb` and `.twbx`) and gives you what's in them as pandas DataFrames: datasources, fields, calculated fields, joins, relationships, dashboards, custom SQL. It's plain Python. You don't need Tableau or R installed.
+
+It began as a port of PrigasG's R package [twbparser](https://github.com/PrigasG/twbparser). The browser GUI, the command-line tool, workbook diffing and folder scanning are new here.
+
+![py-tbparse GUI, overview of a loaded workbook](https://raw.githubusercontent.com/DDSNA/py-tbparse/main/docs/gui-overview.png)
+
+## Install
+
+```bash
+git clone https://github.com/DDSNA/py-tbparse.git
+cd py-tbparse
+pip install -e .
+```
+
+The project got renamed but the module and commands didn't, so: import `twbparser_py`, run `twbparser` or `twbparser-gui`.
+
+## Using it from Python
+
+```python
+from twbparser_py import TwbParser
+
+p = TwbParser("workbook.twb")    # or a .twbx
+p.get_overview()                 # counts of everything
+p.get_calculated_fields()        # each calculation and its formula
+p.get_relationships()            # how the tables connect
+```
+
+Every getter returns a DataFrame. The rest are `get_datasources`, `get_parameters`, `get_fields`, `get_raw_fields`, `get_joins`, `get_relations`, `get_inferred_relationships`, `get_dashboards`, `get_dashboard_sheets`, `get_custom_sql`, `get_initial_sql` and `get_published_refs`. `get_relationship_graph_dot()` returns the data model as Graphviz text, and `validate()` looks for problems in the relationships. In Jupyter, a bare `p` shows the overview.
+
+Two helpers work across workbooks:
+
+```python
+from twbparser_py import diff_workbooks, scan_folder
+
+diff_workbooks(TwbParser("v1.twb"), TwbParser("v2.twb"), table="datasources")
+scan_folder("./workbooks", table="datasources")   # one table, every workbook in the folder
+```
+
+### `.twbx` files
+
+A `.twbx` is read directly from the zip and nothing gets written to disk. That means `p.twbx_dir` is `None`, and `p.path` is a made-up `<file>.twbx/<name>.twb` that you can't open. If you want the files out, extract them yourself:
+
+```python
+from twbparser_py import extract_twb_from_twbx, twbx_extract_files
+
+extract_twb_from_twbx("workbook.twbx", extract_dir="out/")
+twbx_extract_files("workbook.twbx", exdir="out/")    # everything in the package
+```
+
+## Command line
+
+```bash
+twbparser workbook.twb                        # overview
+twbparser workbook.twb tables                 # list the tables
+twbparser workbook.twb calculated-fields
+twbparser workbook.twb fields --format csv -o fields.csv
+twbparser workbook.twbx dashboard-sheets --dashboard "Sales Overview"
+twbparser workbook.twb validate               # exit code 2 if it finds a problem
+twbparser workbook.twb graph > model.dot      # --include-inferred adds the guessed links
+twbparser diff old.twb new.twb datasources
+twbparser batch ./workbooks datasources
+```
+
+Tables: `overview`, `datasources`, `parameters`, `fields`, `raw-fields`, `calculated-fields`, `joins`, `relations`, `relationships`, `inferred-relationships`, `dashboards`, `dashboard-sheets`, `custom-sql`, `initial-sql`, `published-refs`.
+
+`--format` takes `table` (default), `csv` or `json`. `graph` always prints Graphviz text. `diff` and `batch` accept the same table names except `graph`, `validate` and `tables`.
+
+## GUI
+
+```bash
+twbparser-gui workbook.twb               # opens your browser with it loaded
+twbparser-gui                            # starts empty, paste a path and hit Load
+twbparser-gui --no-browser --port 8765   # server only, for a machine with no display
+```
+
+It uses only the standard library, so there's nothing more to install.
+
+The sidebar lists every table with its row count. Click a column header to sort, type in the filter box to narrow rows (`/` jumps to it), click a row to see a long formula or SQL statement in full. The tiles on the overview open their tables. The graph view lets you copy or download the DOT text. Everything else exports as CSV. It has a dark theme and works in a narrow window.
+
+It's meant to run on your own machine for one person. It refuses requests that come from other websites, but there's no login, so don't put it on a shared network.
+
+## Tests
+
+```bash
+pip install -e ".[test]"
+pytest
+```
+
+The sample workbooks in `tests/fixtures/` come from the R package.
+
+The GUI tests run the page in headless Chromium through Playwright and fail on any JavaScript error. They skip if the browser isn't installed. To run them:
+
+```bash
+pip install -e ".[test,browser]"
+playwright install chromium         # add --with-deps if you have root
+./scripts/setup-browser-libs.sh     # without root, this unpacks the system libraries locally
+pytest tests/test_gui_browser.py
+```
+
+## Compared with the R package
+
+The code follows the R original function by function, and the aim is the same output. Not everything is ported. Missing so far: formatting, tooltips, colors, axes and sorts, dashboard layout and actions, the analytics helpers (calculation complexity, field usage, replication brief) and the Shiny inspector. The GUI covers some of what the inspector did.
+
+Where the R version has a bug, this one doesn't copy it. That currently covers joins and relationships on more than one key, nested joins, the include-parameters option, and calculations with brackets inside brackets.
+
+## Why a Tableau parser
+
+A `.twb` is XML and a `.twbx` is a zip containing one, so reading them from Python isn't hard. Power BI's `.pbix` is a binary format built on a proprietary storage engine, and getting into it from code took reverse-engineering projects like [PBIXRay](https://github.com/Hugoberry/pbixray) and [pbi-tools](https://github.com/pbi-tools/pbi-tools). On the server side it goes the other way: Tableau's own Python tooling ([tableauserverclient](https://pypi.org/project/tableauserverclient/) and `tabcmd`) is more mature and more open than what Microsoft has for the Power BI REST API.
+
+## Credit
+
+Based on [twbparser](https://github.com/PrigasG/twbparser) by George Arthur, MIT licensed.

{py_tbparse-0.1.1a0 → py_tbparse-0.2.0}/py_tbparse.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ LICENSE
 MANIFEST.in
 README.md
 pyproject.toml
+docs/gui-overview.png
 py_tbparse.egg-info/PKG-INFO
 py_tbparse.egg-info/SOURCES.txt
 py_tbparse.egg-info/dependency_links.txt
@@ -26,6 +27,7 @@ tests/test_published.py
 tests/test_relationships.py
 tests/test_sql.py
 tests/test_validators.py
+tests/test_version.py
 tests/test_webgui.py
 tests/test_xml.py
 tests/fixtures/test_for_wenjie.twb

{py_tbparse-0.1.1a0 → py_tbparse-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "py-tbparse"
-version = "0.1.1a"
+version = "0.2.0"
 description = "Native Python port of the twbparser R package: parse Tableau .twb/.twbx workbooks into pandas DataFrames."
 readme = "README.md"
 requires-python = ">=3.9"
@@ -30,6 +30,11 @@ dependencies = [
     "pandas>=1.5",
 ]
 
+[project.urls]
+Homepage = "https://github.com/DDSNA/py-tbparse"
+Source = "https://github.com/DDSNA/py-tbparse"
+Issues = "https://github.com/DDSNA/py-tbparse/issues"
+
 [project.optional-dependencies]
 test = ["pytest>=7"]
 browser = ["playwright>=1.40"]

py_tbparse-0.2.0/tests/conftest.py

@@ -0,0 +1,56 @@
+from pathlib import Path
+
+import pytest
+from lxml import etree
+
+FIXTURES = Path(__file__).parent / "fixtures"
+
+
+@pytest.fixture
+def wenjie_xml():
+    return etree.parse(str(FIXTURES / "test_for_wenjie.twb"))
+
+
+@pytest.fixture
+def wenjie_path():
+    return str(FIXTURES / "test_for_wenjie.twb")
+
+
+@pytest.fixture
+def zip_twbx_path():
+    return str(FIXTURES / "test_for_zip.twbx")
+
+
+def xml_from_string(s: str):
+    return etree.fromstring(s.encode("utf-8"))
+
+
+# Real Tableau workbooks give every column in the "Parameters" datasource a
+# @param-domain-type attribute plus a <calculation> holding its value.
+REAL_PARAMS_XML = """
+<workbook>
+  <datasources>
+    <datasource name="Parameters" hasconnection="false" inline="true">
+      <aliases enabled="yes"/>
+      <column caption="Top N" datatype="integer" name="[Parameter 1]"
+              param-domain-type="range" role="measure" type="quantitative" value="10">
+        <calculation class="tableau" formula="10"/>
+        <range granularity="1" max="50" min="1"/>
+      </column>
+      <column caption="Region Pick" datatype="string" name="[Parameter 2]"
+              param-domain-type="list" role="measure" type="nominal" value="&quot;East&quot;">
+        <calculation class="tableau" formula="&quot;East&quot;"/>
+        <members>
+          <member value="&quot;East&quot;"/>
+          <member value="&quot;West&quot;"/>
+        </members>
+      </column>
+    </datasource>
+    <datasource name="Orders">
+      <column name="[Amount]" caption="Amount" datatype="real" role="measure">
+        <calculation class="tableau" formula="SUM([Sales])"/>
+      </column>
+    </datasource>
+  </datasources>
+</workbook>
+"""

{py_tbparse-0.1.1a0 → py_tbparse-0.2.0}/tests/test_batch.py

@@ -37,3 +37,15 @@ def test_scan_folder_datasources_table():
     assert "workbook" in df.columns
     assert "datasource" in df.columns
     assert (df["workbook"] == "test_for_wenjie.twb").sum() == 2
+
+
+def test_scan_folder_directory_with_glob_metacharacters(tmp_path):
+    import shutil
+    import sys
+
+    # `*` can't appear in a Windows path; `[` and `]` still exercise the fix.
+    folder = tmp_path / ("[2024] Q1" if sys.platform == "win32" else "[2024] Q1 *")
+    folder.mkdir()
+    shutil.copy("tests/fixtures/test_for_wenjie.twb", folder)
+    df = scan_folder(str(folder), table="overview")
+    assert list(df["workbook"]) == ["test_for_wenjie.twb"]

{py_tbparse-0.1.1a0 → py_tbparse-0.2.0}/tests/test_calculated_fields.py

@@ -1,3 +1,5 @@
+from conftest import REAL_PARAMS_XML, xml_from_string
+
 from twbparser_py import extract_calculated_fields, extract_raw_fields
 
 
@@ -18,3 +20,16 @@ def test_extract_raw_fields_excludes_calc_and_params(wenjie_xml):
     assert "Calculation_2139209847776120832" not in raw["tableau_internal_name"].apply(
         lambda x: (x or "").strip("[]")
     ).values
+
+
+def test_include_parameters_returns_real_parameter_columns():
+    xml = xml_from_string(REAL_PARAMS_XML)
+
+    default = extract_calculated_fields(xml)
+    assert list(default["datasource"]) == ["Orders"]
+
+    with_params = extract_calculated_fields(xml, include_parameters=True)
+    params = with_params[with_params["datasource"] == "Parameters"]
+    assert sorted(params["tableau_internal_name"]) == ["[Parameter 1]", "[Parameter 2]"]
+    assert set(params["name"]) == {"Top N", "Region Pick"}
+    assert "Orders" in with_params["datasource"].values

py_tbparse-0.2.0/tests/test_clean.py

@@ -0,0 +1,52 @@
+from twbparser_py._clean import bracket_tokens, clean_field, clean_table, strip_brackets
+
+
+def test_bracket_tokens_qualified_name():
+    assert bracket_tokens("[Orders].[Customer ID]") == ["[Orders]", "[Customer ID]"]
+
+
+def test_bracket_tokens_keeps_nested_calc_whole():
+    # The old regex stopped at the first "]" and returned "[LOWER([x]".
+    assert bracket_tokens("[LOWER([x])]") == ["[LOWER([x])]"]
+    assert bracket_tokens("[IFNULL([a],[b])].[T]") == ["[IFNULL([a],[b])]", "[T]"]
+
+
+def test_bracket_tokens_escaped_close_bracket():
+    assert bracket_tokens("[Sales]]Q1].[Orders]") == ["[Sales]]Q1]", "[Orders]"]
+    assert bracket_tokens("[[x]]") == ["[[x]]"]
+
+
+def test_bracket_tokens_empty_and_unclosed():
+    assert bracket_tokens(None) == []
+    assert bracket_tokens("no brackets") == []
+    assert bracket_tokens("[open") == []
+
+
+def test_clean_table_strips_prefix_brackets_and_hex_suffix():
+    assert clean_table("[Extract].[Orders_ABCDEF0123456789ABCDEF0123456789]") == "Orders"
+
+
+def test_clean_table_plain():
+    assert clean_table("[Orders]") == "Orders"
+
+
+def test_clean_table_none():
+    assert clean_table(None) is None
+
+
+def test_clean_field_takes_last_dot_segment():
+    assert clean_field("[Orders].[CustomerID]") == "CustomerID"
+
+
+def test_clean_field_unwraps_derivation_wrapper():
+    assert clean_field("none:Category:nk") == "Category"
+    assert clean_field("clct:Geometry:ok") == "Geometry"
+
+
+def test_clean_field_plain():
+    assert clean_field("CustomerID") == "CustomerID"
+
+
+def test_strip_brackets():
+    assert strip_brackets("[Calculation_123]") == "Calculation_123"
+    assert strip_brackets(None) is None

{py_tbparse-0.1.1a0 → py_tbparse-0.2.0}/tests/test_datasources.py

@@ -61,3 +61,17 @@ def test_athena_region_extracts_when_pattern_matches():
     )
     conns = extract_named_connections(xml_doc)
     assert conns.iloc[0]["region"] == "us-east-1"
+
+
+def test_parameters_fallback_keeps_columns(wenjie_xml, monkeypatch):
+    # A failing parameter extraction must still honour the empty-input
+    # contract: an empty frame with the real columns, not a bare one.
+    from twbparser_py import datasources
+
+    def boom(_xml):
+        raise RuntimeError("malformed")
+
+    monkeypatch.setattr(datasources, "extract_parameters", boom)
+    params = extract_datasource_details(wenjie_xml)["parameters"]
+    assert params.empty
+    assert list(params.columns) == datasources._PARAMETER_COLUMNS