tableau-cli 0.1.1__tar.gz → 0.1.3__tar.gz

{tableau_cli-0.1.1 → tableau_cli-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tableau-cli
-Version: 0.1.1
+Version: 0.1.3
 Summary: CLI for Tableau Server/Cloud, designed for AI agent integration
 Project-URL: Repository, https://github.com/i-richardwang/tableau-cli
 Author: Richard Wang
@@ -132,7 +132,9 @@ tableau-cli datasources download <datasourceId> -o ./data/
 tableau-cli ds download <datasourceId> -o ./data/ --to parquet
 tableau-cli ds download <datasourceId> -o ./data/ --to csv
 
-# Get field metadata (VizQL Data Service + Metadata API enrichment)
+# Get field metadata (VizQL Data Service + Metadata API enrichment).
+# On Tableau >= 2025.3 the result also includes the datasource model:
+# logical tables and their relationships.
 tableau-cli datasources metadata <luid>
 
 # Query datasource data (VizQL Data Service)
@@ -143,16 +145,23 @@ tableau-cli ds query <luid> --query '{"fields": [...]}' --limit 100
 ### Views
 
 ```bash
-# List views
+# List views (includes upstream datasources via Metadata API enrichment)
 tableau-cli views list
 tableau-cli views list --filter "name:has:Dashboard" --format table
 
+# Get view details: upstream datasources, workbook/project/owner info, and web URL
+tableau-cli views get <viewId>
+
 # Get view data as CSV
 tableau-cli views data <viewId>
 
+# Get view data with view filters applied
+tableau-cli views data <viewId> --vf "Region=West" --vf "Category=Technology"
+
 # Download view image
 tableau-cli views image <viewId> -o dashboard.png
 tableau-cli views image <viewId> --width 1200 --height 800 --img-format SVG -o dashboard.svg
+tableau-cli views image <viewId> --vf "Region=West" -o west.png
 ```
 
 ### Convert
@@ -177,14 +186,23 @@ tableau-cli convert extract.hyper --to csv -o ./output/result.csv
 ### Workbooks
 
 ```bash
-# List workbooks
+# List workbooks (includes upstream datasources via Metadata API enrichment)
 tableau-cli workbooks list
 tableau-cli wb list --filter "name:eq:Finance" --format table
 
-# Get workbook details (includes views with usage statistics)
+# Get workbook details (includes views with usage statistics,
+# upstream datasources, and the default view's web URL)
 tableau-cli workbooks get <workbookId>
 ```
 
+### Projects
+
+```bash
+# List projects
+tableau-cli projects list
+tableau-cli projects list --filter "topLevelProject:eq:true" --format table
+```
+
 ### Config
 
 ```bash
@@ -237,10 +255,11 @@ Error types include: `authentication-error`, `feature-disabled`, `tableau-api-er
 | Area | APIs Used |
 |------|-----------|
 | Authentication | REST API v3.24 — PAT sign-in / sign-out |
-| Datasources | REST API (list, download) + VizQL Data Service (metadata, query) + Metadata API (GraphQL enrichment) |
-| Views | REST API (list, data, image) |
-| Workbooks | REST API (list, get with view enrichment) |
-| Search | Content Exploration API |
+| Datasources | REST API (list, download) + VizQL Data Service (metadata, model, query) + Metadata API (GraphQL enrichment) |
+| Views | REST API (list, get, data, image with view filters) + Metadata API (lineage enrichment) |
+| Workbooks | REST API (list, get with view enrichment) + Metadata API (lineage enrichment) |
+| Projects | REST API (list) |
+| Search | Content Exploration API + Metadata API (lineage enrichment) |
 | Convert | Local file conversion: TDSX/HYPER → Parquet/CSV (optional dependencies) |
 
 ## Development

{tableau_cli-0.1.1 → tableau_cli-0.1.3}/README.md

@@ -102,7 +102,9 @@ tableau-cli datasources download <datasourceId> -o ./data/
 tableau-cli ds download <datasourceId> -o ./data/ --to parquet
 tableau-cli ds download <datasourceId> -o ./data/ --to csv
 
-# Get field metadata (VizQL Data Service + Metadata API enrichment)
+# Get field metadata (VizQL Data Service + Metadata API enrichment).
+# On Tableau >= 2025.3 the result also includes the datasource model:
+# logical tables and their relationships.
 tableau-cli datasources metadata <luid>
 
 # Query datasource data (VizQL Data Service)
@@ -113,16 +115,23 @@ tableau-cli ds query <luid> --query '{"fields": [...]}' --limit 100
 ### Views
 
 ```bash
-# List views
+# List views (includes upstream datasources via Metadata API enrichment)
 tableau-cli views list
 tableau-cli views list --filter "name:has:Dashboard" --format table
 
+# Get view details: upstream datasources, workbook/project/owner info, and web URL
+tableau-cli views get <viewId>
+
 # Get view data as CSV
 tableau-cli views data <viewId>
 
+# Get view data with view filters applied
+tableau-cli views data <viewId> --vf "Region=West" --vf "Category=Technology"
+
 # Download view image
 tableau-cli views image <viewId> -o dashboard.png
 tableau-cli views image <viewId> --width 1200 --height 800 --img-format SVG -o dashboard.svg
+tableau-cli views image <viewId> --vf "Region=West" -o west.png
 ```
 
 ### Convert
@@ -147,14 +156,23 @@ tableau-cli convert extract.hyper --to csv -o ./output/result.csv
 ### Workbooks
 
 ```bash
-# List workbooks
+# List workbooks (includes upstream datasources via Metadata API enrichment)
 tableau-cli workbooks list
 tableau-cli wb list --filter "name:eq:Finance" --format table
 
-# Get workbook details (includes views with usage statistics)
+# Get workbook details (includes views with usage statistics,
+# upstream datasources, and the default view's web URL)
 tableau-cli workbooks get <workbookId>
 ```
 
+### Projects
+
+```bash
+# List projects
+tableau-cli projects list
+tableau-cli projects list --filter "topLevelProject:eq:true" --format table
+```
+
 ### Config
 
 ```bash
@@ -207,10 +225,11 @@ Error types include: `authentication-error`, `feature-disabled`, `tableau-api-er
 | Area | APIs Used |
 |------|-----------|
 | Authentication | REST API v3.24 — PAT sign-in / sign-out |
-| Datasources | REST API (list, download) + VizQL Data Service (metadata, query) + Metadata API (GraphQL enrichment) |
-| Views | REST API (list, data, image) |
-| Workbooks | REST API (list, get with view enrichment) |
-| Search | Content Exploration API |
+| Datasources | REST API (list, download) + VizQL Data Service (metadata, model, query) + Metadata API (GraphQL enrichment) |
+| Views | REST API (list, get, data, image with view filters) + Metadata API (lineage enrichment) |
+| Workbooks | REST API (list, get with view enrichment) + Metadata API (lineage enrichment) |
+| Projects | REST API (list) |
+| Search | Content Exploration API + Metadata API (lineage enrichment) |
 | Convert | Local file conversion: TDSX/HYPER → Parquet/CSV (optional dependencies) |
 
 ## Development

{tableau_cli-0.1.1 → tableau_cli-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "tableau-cli"
-version = "0.1.1"
+version = "0.1.3"
 description = "CLI for Tableau Server/Cloud, designed for AI agent integration"
 license = "Apache-2.0"
 requires-python = ">=3.10"

{tableau_cli-0.1.1 → tableau_cli-0.1.3}/skills/SKILL.md

@@ -33,13 +33,14 @@ Before running any `tableau-cli` command, load [references/cli.md](references/cl
 The following requests can be handled directly with CLI commands. Load [references/cli.md](references/cli.md) and execute:
 
 - Search content across types — `search`
-- List/filter datasources, views, or workbooks — `ds list` / `views list` / `wb list`
+- List/filter datasources, views, workbooks, or projects — `ds list` / `views list` / `wb list` / `projects list`
 - Download a datasource file — `ds download` (supports `--to parquet` / `--to csv` for direct conversion)
-- Inspect datasource field metadata — `ds metadata`
+- Inspect datasource field metadata and table relationships — `ds metadata`
 - Query data from a datasource — `ds query`
-- Export view data as CSV — `views data`
-- Export view as image — `views image`
-- View workbook details and its views — `wb get`
+- View details of a single view, incl. its web URL and upstream datasources — `views get`
+- Export view data as CSV — `views data` (supports `--vf "Field=Value"` view filters)
+- Export view as image — `views image` (supports `--vf "Field=Value"` view filters)
+- View workbook details, its views, and its web URL — `wb get`
 - Convert TDSX/HYPER to Parquet/CSV — `convert`
 
 Common combined workflows:
@@ -49,3 +50,5 @@ Common combined workflows:
 **Quick data extraction (no file download)**: `ds metadata` → `ds query` (requires VizQL Data Service; fall back to download + convert if unavailable)
 
 **Export dashboard screenshot**: `views list` → `views image`
+
+**From dashboard to data**: `search` or `views get` → `upstreamDatasources[].luid` → `ds metadata` → `ds query`

{tableau_cli-0.1.1 → tableau_cli-0.1.3}/skills/references/cli.md

@@ -40,6 +40,8 @@ tableau-cli search --format table
 
 View results include `parentWorkbookName` (parent workbook) and `totalViewCount` (total views).
 
+Workbook and view results include `upstreamDatasources[]` (`{luid, name}`) — the published datasources they are built on. Use this to jump from a dashboard to `ds metadata` / `ds query` without a separate lookup.
+
 ---
 
 ## datasources (alias: ds)
@@ -94,10 +96,11 @@ tableau-cli ds metadata <luid> --format table
 
 Returns:
 - `datasourceDescription` — datasource description
+- `datasourceModel` — logical tables and their relationships (join fields and operators); only present on Tableau >= 2025.3
 - `fieldGroups[].fields[]` — field list (name, dataType, role, formula, description, etc.)
 - `parameters[]` — parameter list (name, parameterType, dataType, value, etc.)
 
-Attempts to enrich via GraphQL Metadata API; falls back to base VizQL metadata if unavailable.
+Attempts to enrich via GraphQL Metadata API; falls back to base VizQL metadata if unavailable. Use `datasourceModel` to understand multi-table datasources before constructing `ds query` requests.
 
 ### ds query
 
@@ -137,7 +140,22 @@ tableau-cli views list --filter "name:has:keyword" --format table
 | `--limit` | int | none | Max total results |
 | `--format` | json / table | json | Output format |
 
-Results include `workbookId` to trace back to the parent workbook.
+Results include the parent `workbook` (with name), `project`, `owner`, `upstreamDatasources[]` (published datasources the view is built on), and `totalViewCount`.
+
+### views get
+
+View details for a single view, including its web URL.
+
+```bash
+tableau-cli views get <view-id>
+```
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `view_id` | string (positional) | required | View LUID |
+| `--format` | json / table | json | Output format |
+
+Returns the view with `upstreamDatasources[]`, parent `workbook` / `project` / `owner` info, usage statistics, and `url` — the web URL to open the view in a browser.
 
 ### views data
 
@@ -145,11 +163,13 @@ Export view data as CSV.
 
 ```bash
 tableau-cli views data <view-id>
+tableau-cli views data <view-id> --vf "Region=West" --vf "Category=Technology"
 ```
 
 | Option | Type | Description |
 |--------|------|-------------|
 | `view_id` | string (positional) | View LUID |
+| `--vf` | `Field=Value` (repeatable) | View filter: filter the view by field values before export |
 
 Output: CSV text written directly to stdout (not JSON).
 
@@ -161,6 +181,7 @@ Export view as image.
 tableau-cli views image <view-id> -o output.png
 tableau-cli views image <view-id> --width 1200 --height 800 -o output.png
 tableau-cli views image <view-id> --img-format SVG -o output.svg
+tableau-cli views image <view-id> --vf "Region=West" -o west.png
 ```
 
 | Option | Type | Default | Description |
@@ -169,6 +190,7 @@ tableau-cli views image <view-id> --img-format SVG -o output.svg
 | `--width` | int | none | Image width in pixels |
 | `--height` | int | none | Image height in pixels |
 | `--img-format` | PNG / SVG | PNG | Image format |
+| `--vf` | `Field=Value` (repeatable) | none | View filter: filter the view by field values before rendering |
 | `-o, --output` | path | none | Output file path |
 
 With `-o`: outputs `{"filePath": "<absolute path>"}`. Without `-o`: base64-encoded image to stdout.
@@ -191,6 +213,8 @@ tableau-cli wb list --filter "name:has:keyword" --format table
 | `--limit` | int | none | Max total results |
 | `--format` | json / table | json | Output format |
 
+Results include `upstreamDatasources[]` (`{luid, name}`) — the published datasources each workbook is built on.
+
 ### wb get
 
 View workbook details, including all views with usage statistics.
@@ -205,6 +229,29 @@ tableau-cli wb get <workbook-id> --format table
 | `workbook_id` | string (positional) | required | Workbook LUID |
 | `--format` | json / table | json | Output format |
 
+Returns the workbook with `upstreamDatasources[]` and `url` — the web URL to open the workbook's default view in a browser.
+
+---
+
+## projects
+
+### projects list
+
+```bash
+tableau-cli projects list
+tableau-cli projects list --filter "topLevelProject:eq:true" --format table
+tableau-cli projects list --filter "parentProjectId:eq:<project-id>"
+```
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `--filter` | string | none | Server-side filter (fields: name, parentProjectId, topLevelProject, ownerName, createdAt, updatedAt) |
+| `--page-size` | int | none | Items per page |
+| `--limit` | int | none | Max total results |
+| `--format` | json / table | json | Output format |
+
+Results include name, description, parent project, content permissions, owner, and timestamps.
+
 ---
 
 ## convert
@@ -274,9 +321,14 @@ The `--filter` option uses `field:operator:value` format:
 | Inspect datasource fields | `ds metadata <luid>` |
 | Query data from a datasource | `ds query <luid> --query '{...}'` |
 | Find a dashboard/view | `views list --filter "name:has:..."` |
+| See view details / get view link | `views get <view-id>` |
+| Find the datasource behind a dashboard | `views get <view-id>` → `upstreamDatasources` |
 | Export view data | `views data <view-id>` |
+| Export filtered view data | `views data <view-id> --vf "Field=Value"` |
 | Export view screenshot | `views image <view-id> -o file.png` |
+| Export filtered view screenshot | `views image <view-id> --vf "Field=Value" -o file.png` |
 | Find workbooks | `wb list --filter "name:has:..."` |
-| See views in a workbook | `wb get <workbook-id>` |
+| See views in a workbook / get workbook link | `wb get <workbook-id>` |
+| Browse projects / site structure | `projects list` |
 | Convert local TDSX to Parquet | `convert file.tdsx -o dir/` |
 | Download and convert for analysis | `ds download <id> --to parquet` |

{tableau_cli-0.1.1 → tableau_cli-0.1.3}/skills/references/installation.md

@@ -9,7 +9,13 @@ description: Installation and authentication setup for tableau-cli. Load when th
 pip install "tableau-cli[convert]"
 ```
 
-Without `[convert]`, only core features are available (search, datasources, views, workbooks) — the `convert` command will not work.
+Without `[convert]`, only core features are available (search, datasources, views, workbooks) — the `convert` command and `ds download --to parquet/csv` will not work.
+
+## Upgrade
+
+```bash
+pip install --upgrade "tableau-cli[convert]"
+```
 
 ## Authentication
 

{tableau_cli-0.1.1 → tableau_cli-0.1.3}/src/tableau_cli/api/client.py

@@ -89,6 +89,14 @@ class RestApi:
             self._client.post(url, headers=self._auth_headers())
         self._creds = None
 
+    # ── Server (REST API) ───────────────────────────────────────────
+
+    def get_server_info(self) -> dict[str, Any]:
+        url = f"{self._base_url}/serverinfo"
+        resp = self._client.get(url, headers=self._auth_headers())
+        resp.raise_for_status()
+        return resp.json()["serverInfo"]
+
     # ── Datasources (REST API) ──────────────────────────────────────
 
     def list_datasources(
@@ -167,9 +175,17 @@ class RestApi:
             "views": [_shape_view(v) for v in raw_list],
         }
 
-    def query_view_data(self, *, view_id: str, site_id: str) -> str:
+    def get_view(self, *, view_id: str, site_id: str) -> dict[str, Any]:
+        url = f"{self._base_url}/sites/{site_id}/views/{view_id}"
+        params = {"includeUsageStatistics": "true"}
+        resp = self._client.get(url, params=params, headers=self._auth_headers())
+        resp.raise_for_status()
+        return _shape_view(resp.json()["view"])
+
+    def query_view_data(self, *, view_id: str, site_id: str, view_filters: dict[str, str] | None = None) -> str:
         url = f"{self._base_url}/sites/{site_id}/views/{view_id}/data"
-        resp = self._client.get(url, headers=self._auth_headers())
+        params = _view_filter_params(view_filters)
+        resp = self._client.get(url, params=params, headers=self._auth_headers())
         resp.raise_for_status()
         return resp.text
 
@@ -181,6 +197,7 @@ class RestApi:
         width: int | None = None,
         height: int | None = None,
         format_: str = "PNG",
+        view_filters: dict[str, str] | None = None,
     ) -> bytes:
         url = f"{self._base_url}/sites/{site_id}/views/{view_id}/image"
         params: dict[str, Any] = {"resolution": "high"}
@@ -190,6 +207,7 @@ class RestApi:
             params["vizHeight"] = height
         if format_:
             params["format"] = format_
+        params.update(_view_filter_params(view_filters))
         resp = self._client.get(url, params=params, headers=self._auth_headers())
         if resp.status_code >= 400:
             error_data: dict[str, Any] = {}
@@ -264,6 +282,33 @@ class RestApi:
             "workbooks": [_shape_workbook(w) for w in raw_list],
         }
 
+    # ── Projects (REST API) ─────────────────────────────────────────
+
+    def query_projects(
+        self,
+        *,
+        site_id: str,
+        filter_: str = "",
+        page_size: int | None = None,
+        page_number: int | None = None,
+    ) -> dict[str, Any]:
+        url = f"{self._base_url}/sites/{site_id}/projects"
+        params: dict[str, Any] = {}
+        if filter_:
+            params["filter"] = filter_
+        if page_size is not None:
+            params["pageSize"] = page_size
+        if page_number is not None:
+            params["pageNumber"] = page_number
+        resp = self._client.get(url, params=params, headers=self._auth_headers())
+        resp.raise_for_status()
+        data = resp.json()
+        raw_list = data.get("projects", {}).get("project") or []
+        return {
+            "pagination": _parse_pagination(data["pagination"]),
+            "projects": [_shape_project_detail(p) for p in raw_list],
+        }
+
     # ── Content Exploration (Search) ────────────────────────────────
 
     def search_content(
@@ -305,6 +350,18 @@ class RestApi:
         resp.raise_for_status()
         return resp.json()
 
+    def get_datasource_model(self, *, datasource_luid: str) -> dict[str, Any]:
+        url = f"{self._host}/api/v1/vizql-data-service/get-datasource-model"
+        body = {"datasource": {"datasourceLuid": datasource_luid}}
+        try:
+            resp = self._client.post(url, json=body, headers=self._auth_headers())
+        except httpx.TransportError as exc:
+            raise FeatureDisabledError(VDS_DISABLED_MESSAGE) from exc
+        if resp.status_code == 404:
+            raise FeatureDisabledError(VDS_DISABLED_MESSAGE)
+        resp.raise_for_status()
+        return resp.json()
+
     def query_datasource(self, *, datasource_luid: str, query: dict, options: dict | None = None) -> dict[str, Any]:
         url = f"{self._host}/api/v1/vizql-data-service/query-datasource"
         body: dict[str, Any] = {
@@ -350,6 +407,13 @@ def _parse_pagination(p: dict[str, Any]) -> dict[str, int]:
     }
 
 
+def _view_filter_params(view_filters: dict[str, str] | None) -> dict[str, str]:
+    """Map view filter field names to `vf_`-prefixed query parameters."""
+    if not view_filters:
+        return {}
+    return {(key if key.startswith("vf_") else f"vf_{key}"): value for key, value in view_filters.items()}
+
+
 # ── Response shaping (equivalent to Zod schemas in TS version) ──────────
 
 
@@ -359,6 +423,31 @@ def _shape_project(raw: Any) -> dict[str, str]:
     return {"name": raw.get("name", ""), "id": raw.get("id", "")}
 
 
+def _shape_project_detail(raw: dict[str, Any]) -> dict[str, Any]:
+    """Match TS projectSchema: {id, name, description?, parentProjectId?, contentPermissions?, ...}"""
+    result: dict[str, Any] = {
+        "id": raw.get("id", ""),
+        "name": raw.get("name", ""),
+    }
+    for key in (
+        "description",
+        "parentProjectId",
+        "contentPermissions",
+        "controllingPermissionsProjectId",
+        "createdAt",
+        "updatedAt",
+    ):
+        if key in raw:
+            result[key] = raw[key]
+    # z.coerce.boolean() — convert string "true"/"false" to bool
+    if "topLevelProject" in raw:
+        top_level = raw["topLevelProject"]
+        result["topLevelProject"] = top_level.lower() == "true" if isinstance(top_level, str) else bool(top_level)
+    if isinstance(raw.get("owner"), dict) and raw["owner"].get("id"):
+        result["owner"] = {"id": raw["owner"]["id"]}
+    return result
+
+
 def _shape_tags(raw: Any) -> dict[str, Any]:
     if not isinstance(raw, dict):
         return {}
@@ -382,10 +471,11 @@ def _shape_datasource(raw: dict[str, Any]) -> dict[str, Any]:
 
 
 def _shape_view(raw: dict[str, Any]) -> dict[str, Any]:
-    """Match TS viewSchema: {id, name, createdAt, updatedAt, workbook?, owner?, project?, tags, usage?}"""
+    """Match TS viewSchema: {id, name, contentUrl, createdAt, updatedAt, workbook?, owner?, project?, tags, usage?}"""
     result: dict[str, Any] = {
         "id": raw.get("id", ""),
         "name": raw.get("name", ""),
+        "contentUrl": raw.get("contentUrl", ""),
         "createdAt": raw.get("createdAt", ""),
         "updatedAt": raw.get("updatedAt", ""),
     }

{tableau_cli-0.1.1 → tableau_cli-0.1.3}/src/tableau_cli/cli.py

@@ -78,7 +78,35 @@ def to_error_output(err: Exception) -> dict[str, Any]:
     }
 
 
+def _check_for_update() -> str | None:
+    """Check PyPI for a newer version. Returns a notice string, or None if up to date."""
+    try:
+        from importlib.metadata import version as installed_version
+
+        current = installed_version("tableau-cli")
+        resp = httpx.get("https://pypi.org/pypi/tableau-cli/json", timeout=3)
+        resp.raise_for_status()
+        latest = resp.json()["info"]["version"]
+
+        def version_key(version: str) -> tuple[int, ...]:
+            return tuple(int(part) for part in version.split("."))
+
+        if version_key(latest) > version_key(current):
+            return (
+                f'Update available: {current} → {latest}. Run `pip install --upgrade "tableau-cli[convert]"` to update.'
+            )
+    except Exception:
+        pass
+    return None
+
+
 class TableauCli(click.Group):
+    def format_help(self, ctx: click.Context, formatter: click.HelpFormatter) -> None:
+        super().format_help(ctx, formatter)
+        notice = _check_for_update()
+        if notice:
+            formatter.write(f"\n{notice}\n")
+
     def invoke(self, ctx: click.Context) -> Any:
         try:
             return super().invoke(ctx)
@@ -95,7 +123,7 @@ class TableauCli(click.Group):
 
 
 @click.group(cls=TableauCli)
-@click.version_option("0.1.1")
+@click.version_option("0.1.3")
 def cli():
     """CLI tool for interacting with Tableau Server/Cloud."""
 
@@ -104,6 +132,7 @@ def main() -> None:
     from .commands.config_cmd import config_group
     from .commands.convert_cmd import convert_command
     from .commands.datasources_cmd import datasources_group
+    from .commands.projects_cmd import projects_group
     from .commands.search_cmd import search_command
     from .commands.views_cmd import views_group
     from .commands.workbooks_cmd import workbooks_group
@@ -112,6 +141,7 @@ def main() -> None:
     cli.add_command(convert_command)
     cli.add_command(datasources_group)
     cli.add_command(datasources_group, name="ds")  # alias
+    cli.add_command(projects_group)
     cli.add_command(views_group)
     cli.add_command(workbooks_group)
     cli.add_command(workbooks_group, name="wb")  # alias

{tableau_cli-0.1.1 → tableau_cli-0.1.3}/src/tableau_cli/commands/datasources_cmd.py

@@ -104,17 +104,25 @@ def datasources_metadata(luid, fmt):
             get_graphql_query,
             simplify_read_metadata_result,
         )
+        from ..utils.tableau_version import is_tableau_version_at_least
 
         read_metadata_result = api.read_metadata(datasource_luid=luid)
 
+        # The datasource model (logical tables and their relationships) comes from
+        # a dedicated VizQL Data Service endpoint that requires Tableau >= 2025.3.
+        datasource_model_result = None
+        product_version = api.get_server_info().get("productVersion", {}).get("value", "")
+        if is_tableau_version_at_least(product_version, "2025.3.0"):
+            datasource_model_result = api.get_datasource_model(datasource_luid=luid)
+
         # Try to enrich with Metadata API (GraphQL)
         try:
             graphql_result = api.graphql(get_graphql_query(luid))
         except Exception:
             # Metadata API may not be available
-            return simplify_read_metadata_result(read_metadata_result)
+            return simplify_read_metadata_result(read_metadata_result, datasource_model_result)
 
-        return combine_fields(read_metadata_result, graphql_result)
+        return combine_fields(read_metadata_result, graphql_result, datasource_model_result)
 
     result = with_auth(config, fn)
     output(result, fmt)

tableau_cli-0.1.3/src/tableau_cli/commands/projects_cmd.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import click
+
+from ..auth.with_auth import with_auth
+from ..config.store import resolve_config
+from ..output.format import output
+from ..utils.paginate import paginate
+
+
+@click.group("projects")
+def projects_group():
+    """Manage projects."""
+
+
+@projects_group.command("list")
+@click.option("--filter", "filter_", default=None, help="Filter string (e.g., name:eq:Default)")
+@click.option("--page-size", default=None, type=int, help="Page size for API requests")
+@click.option("--limit", default=None, type=int, help="Max total results")
+@click.option("--format", "fmt", default="json", help="Output format: json | table")
+def projects_list(filter_, page_size, limit, fmt):
+    """List projects on the site."""
+    config = resolve_config()
+
+    def fn(api):
+        def get_data_fn(ps, pn):
+            result = api.query_projects(
+                site_id=api.site_id,
+                filter_=filter_ or "",
+                page_size=ps,
+                page_number=pn,
+            )
+            return {"pagination": result["pagination"], "data": result["projects"]}
+
+        return paginate(page_size=page_size, limit=limit, get_data_fn=get_data_fn)
+
+    result = with_auth(config, fn)
+    output(result, fmt)

{tableau_cli-0.1.1 → tableau_cli-0.1.3}/src/tableau_cli/commands/search_cmd.py

@@ -5,6 +5,7 @@ import click
 from ..auth.with_auth import with_auth
 from ..config.store import resolve_config
 from ..output.format import output
+from ..utils.lineage_utils import enrich_search_results_with_lineage
 from ..utils.search_content_utils import reduce_search_content_response
 
 
@@ -33,7 +34,7 @@ def search_command(terms, type_, limit, order_by, fmt):
             order_by=order_by,
             filter_=",".join(filter_parts) if filter_parts else None,
         )
-        return reduce_search_content_response(response)
+        return enrich_search_results_with_lineage(api, reduce_search_content_response(response))
 
     result = with_auth(config, fn)
     output(result, fmt)

{tableau_cli-0.1.1 → tableau_cli-0.1.3}/src/tableau_cli/commands/views_cmd.py

@@ -2,13 +2,37 @@ from __future__ import annotations
 
 import os
 import sys
+from typing import Any
 
 import click
 
 from ..auth.with_auth import with_auth
 from ..config.store import resolve_config
 from ..output.format import output
+from ..utils.lineage_utils import enrich_views_with_lineage
 from ..utils.paginate import paginate
+from ..utils.web_url import construct_view_web_url
+
+
+def _parse_view_filters(vf: tuple[str, ...]) -> dict[str, str] | None:
+    """Parse repeated --vf 'Field=Value' options into a view filter map."""
+    if not vf:
+        return None
+    view_filters: dict[str, str] = {}
+    for entry in vf:
+        field, sep, value = entry.partition("=")
+        if not sep or not field:
+            raise click.BadParameter(f"Expected 'Field=Value', got '{entry}'.", param_hint="--vf")
+        view_filters[field] = value
+    return view_filters
+
+
+def _flatten_view_usage(views: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """Flatten usage statistics into a top-level totalViewCount (consistent with MCP behavior)."""
+    for view in views:
+        usage = view.pop("usage", None)
+        view["totalViewCount"] = usage.get("totalViewCount", 0) if isinstance(usage, dict) else 0
+    return views
 
 
 @click.group("views")
@@ -35,7 +59,25 @@ def views_list(filter_, page_size, limit, fmt):
             )
             return {"pagination": result["pagination"], "data": result["views"]}
 
-        return paginate(page_size=page_size, limit=limit, get_data_fn=get_data_fn)
+        views = paginate(page_size=page_size, limit=limit, get_data_fn=get_data_fn)
+        return _flatten_view_usage(enrich_views_with_lineage(api, views))
+
+    result = with_auth(config, fn)
+    output(result, fmt)
+
+
+@views_group.command("get")
+@click.argument("view_id")
+@click.option("--format", "fmt", default="json", help="Output format: json | table")
+def views_get(view_id, fmt):
+    """Get view details, including upstream datasources and web URL."""
+    config = resolve_config()
+
+    def fn(api):
+        view = api.get_view(view_id=view_id, site_id=api.site_id)
+        view = enrich_views_with_lineage(api, [view])[0]
+        view["url"] = construct_view_web_url(config.server, config.site_name, view["contentUrl"])
+        return view
 
     result = with_auth(config, fn)
     output(result, fmt)
@@ -43,10 +85,15 @@ def views_list(filter_, page_size, limit, fmt):
 
 @views_group.command("data")
 @click.argument("view_id")
-def views_data(view_id):
+@click.option("--vf", multiple=True, help="View filter as 'Field=Value' (repeatable)")
+def views_data(view_id, vf):
     """Get view data as CSV."""
     config = resolve_config()
-    csv = with_auth(config, lambda api: api.query_view_data(view_id=view_id, site_id=api.site_id))
+    view_filters = _parse_view_filters(vf)
+    csv = with_auth(
+        config,
+        lambda api: api.query_view_data(view_id=view_id, site_id=api.site_id, view_filters=view_filters),
+    )
     sys.stdout.write(csv)
 
 
@@ -55,10 +102,12 @@ def views_data(view_id):
 @click.option("--width", default=None, type=int, help="Image width in pixels")
 @click.option("--height", default=None, type=int, help="Image height in pixels")
 @click.option("--img-format", default="PNG", help="Image format: PNG | SVG")
+@click.option("--vf", multiple=True, help="View filter as 'Field=Value' (repeatable)")
 @click.option("-o", "--output", "output_path", default=None, help="Output file path")
-def views_image(view_id, width, height, img_format, output_path):
+def views_image(view_id, width, height, img_format, vf, output_path):
     """Download view image."""
     config = resolve_config()
+    view_filters = _parse_view_filters(vf)
 
     image_data = with_auth(
         config,
@@ -68,6 +117,7 @@ def views_image(view_id, width, height, img_format, output_path):
             width=width,
             height=height,
             format_=img_format,
+            view_filters=view_filters,
         ),
     )
 

{tableau_cli-0.1.1 → tableau_cli-0.1.3}/src/tableau_cli/commands/workbooks_cmd.py

@@ -5,7 +5,9 @@ import click
 from ..auth.with_auth import with_auth
 from ..config.store import resolve_config
 from ..output.format import output
+from ..utils.lineage_utils import enrich_workbooks_with_lineage
 from ..utils.paginate import paginate
+from ..utils.web_url import get_default_view_web_url
 
 
 @click.group("workbooks")
@@ -32,7 +34,8 @@ def workbooks_list(filter_, page_size, limit, fmt):
             )
             return {"pagination": result["pagination"], "data": result["workbooks"]}
 
-        return paginate(page_size=page_size, limit=limit, get_data_fn=get_data_fn)
+        workbooks = paginate(page_size=page_size, limit=limit, get_data_fn=get_data_fn)
+        return enrich_workbooks_with_lineage(api, workbooks)
 
     result = with_auth(config, fn)
     output(result, fmt)
@@ -53,6 +56,12 @@ def workbooks_get(workbook_id, fmt):
             views = api.query_views_for_workbook(workbook_id=workbook_id, site_id=api.site_id)
             workbook["views"]["view"] = views
 
+        workbook = enrich_workbooks_with_lineage(api, [workbook])[0]
+
+        url = get_default_view_web_url(workbook, config.server, config.site_name)
+        if url:
+            workbook["url"] = url
+
         return workbook
 
     result = with_auth(config, fn)

{tableau_cli-0.1.1 → tableau_cli-0.1.3}/src/tableau_cli/utils/datasource_metadata_utils.py

@@ -137,11 +137,25 @@ def _build_parameters(extra_data: dict[str, Any] | None) -> list[dict[str, Any]]
     return parameters
 
 
+def _datasource_model_entry(datasource_model_result: dict[str, Any] | None) -> dict[str, Any]:
+    """Optional datasourceModel entry, placed after datasourceDescription to match the MCP response shape."""
+    if datasource_model_result is None:
+        return {}
+    return {
+        "datasourceModel": {
+            "logicalTables": datasource_model_result.get("logicalTables", []),
+            "logicalTableRelationships": datasource_model_result.get("logicalTableRelationships", []),
+        }
+    }
+
+
 def simplify_read_metadata_result(
     read_metadata_result: dict[str, Any],
+    datasource_model_result: dict[str, Any] | None = None,
 ) -> dict[str, Any]:
     result: dict[str, Any] = {
         "datasourceDescription": "",
+        **_datasource_model_entry(datasource_model_result),
         "fieldGroups": [],
         "parameters": [],
     }
@@ -172,12 +186,14 @@ def simplify_read_metadata_result(
 def combine_fields(
     read_metadata_result: dict[str, Any],
     list_fields_result: dict[str, Any],
+    datasource_model_result: dict[str, Any] | None = None,
 ) -> dict[str, Any]:
     ds_list = list_fields_result.get("data", {}).get("publishedDatasources", [])
     ds = ds_list[0] if ds_list else None
 
     combined: dict[str, Any] = {
         "datasourceDescription": (ds.get("description") or "") if ds else "",
+        **_datasource_model_entry(datasource_model_result),
         "fieldGroups": [],
         "parameters": [],
     }

tableau_cli-0.1.3/src/tableau_cli/utils/lineage_utils.py

@@ -0,0 +1,216 @@
+from __future__ import annotations
+
+import json
+import sys
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from ..api.client import RestApi
+
+# Lineage enrichment (equivalent to lineageUtils.ts in the TS version).
+#
+# Workbooks, views, and search results are enriched with their upstream published
+# datasources via a single batched Metadata API (GraphQL) query. Enrichment is
+# best-effort: if the Metadata API is unavailable, the original results are
+# returned unchanged and a warning is written to stderr.
+
+
+def _to_graphql_string_array(values: list[str]) -> str:
+    return f"[{', '.join(json.dumps(v) for v in values)}]"
+
+
+def _workbooks_connection_query(workbook_luids: list[str]) -> str:
+    return f"""workbooksConnection(filter: {{ luidWithin: {_to_graphql_string_array(workbook_luids)} }}) {{
+        nodes {{
+          luid
+          upstreamDatasources {{
+            luid
+            name
+          }}
+        }}
+      }}"""
+
+
+def _sheets_connection_query(view_luids: list[str]) -> str:
+    return f"""sheetsConnection(filter: {{ luidWithin: {_to_graphql_string_array(view_luids)} }}) {{
+        nodes {{
+          luid
+          upstreamDatasources {{
+            name
+            ... on PublishedDatasource {{
+              luid
+            }}
+          }}
+          workbook {{
+            luid
+            name
+            projectLuid
+            projectName
+            owner {{
+              luid
+              name
+              username
+            }}
+          }}
+        }}
+      }}"""
+
+
+def get_workbook_lineage_query(workbook_luids: list[str]) -> str:
+    return f"""
+    query workbookLineage {{
+      {_workbooks_connection_query(workbook_luids)}
+    }}"""
+
+
+def get_view_lineage_query(view_luids: list[str]) -> str:
+    return f"""
+    query viewLineage {{
+      {_sheets_connection_query(view_luids)}
+    }}"""
+
+
+def get_search_content_lineage_query(workbook_luids: list[str], view_luids: list[str]) -> str:
+    return f"""
+    query searchContentLineage {{
+      {_workbooks_connection_query(workbook_luids) if workbook_luids else ""}
+      {_sheets_connection_query(view_luids) if view_luids else ""}
+    }}"""
+
+
+def _normalize_lineage_contents(contents: Any) -> list[dict[str, str]]:
+    if not isinstance(contents, list):
+        return []
+    return [
+        {"luid": c["luid"], "name": c.get("name") or c["luid"]}
+        for c in contents
+        if isinstance(c, dict) and c.get("luid")
+    ]
+
+
+def get_workbook_lineage_by_luid(response: dict[str, Any]) -> dict[str, list[dict[str, str]]]:
+    nodes = response.get("data", {}).get("workbooksConnection", {}).get("nodes") or []
+    return {
+        node["luid"]: _normalize_lineage_contents(node.get("upstreamDatasources"))
+        for node in nodes
+        if isinstance(node, dict) and node.get("luid")
+    }
+
+
+def get_view_lineage_by_luid(response: dict[str, Any]) -> dict[str, dict[str, Any]]:
+    nodes = response.get("data", {}).get("sheetsConnection", {}).get("nodes") or []
+    lineage_by_luid: dict[str, dict[str, Any]] = {}
+    for node in nodes:
+        if not isinstance(node, dict) or not node.get("luid"):
+            continue
+        workbook = node.get("workbook") if isinstance(node.get("workbook"), dict) else None
+        owner = workbook.get("owner") if workbook and isinstance(workbook.get("owner"), dict) else None
+        lineage_by_luid[node["luid"]] = {
+            "upstreamDatasources": _normalize_lineage_contents(node.get("upstreamDatasources")),
+            "workbook": (
+                {"luid": workbook["luid"], "name": workbook["name"]} if workbook and workbook.get("name") else None
+            ),
+            "ownerLuid": owner.get("luid") if owner else None,
+            "ownerName": (owner.get("name") or owner.get("username")) if owner else None,
+            "projectLuid": workbook.get("projectLuid") if workbook else None,
+            "projectName": workbook.get("projectName") if workbook else None,
+        }
+    return lineage_by_luid
+
+
+def merge_workbook_lineage(
+    workbooks: list[dict[str, Any]],
+    lineage_by_luid: dict[str, list[dict[str, str]]],
+) -> list[dict[str, Any]]:
+    for workbook in workbooks:
+        upstream_datasources = lineage_by_luid.get(workbook.get("id", ""))
+        if upstream_datasources:
+            workbook["upstreamDatasources"] = upstream_datasources
+    return workbooks
+
+
+def merge_view_lineage(
+    views: list[dict[str, Any]],
+    lineage_by_luid: dict[str, dict[str, Any]],
+) -> list[dict[str, Any]]:
+    for view in views:
+        lineage = lineage_by_luid.get(view.get("id", ""))
+        if not lineage:
+            continue
+        if lineage["upstreamDatasources"]:
+            view["upstreamDatasources"] = lineage["upstreamDatasources"]
+        if lineage["workbook"]:
+            workbook = view.setdefault("workbook", {})
+            workbook.setdefault("id", lineage["workbook"]["luid"])
+            workbook["name"] = lineage["workbook"]["name"]
+        if lineage["ownerLuid"] or lineage["ownerName"]:
+            owner = view.setdefault("owner", {})
+            if lineage["ownerLuid"]:
+                owner.setdefault("id", lineage["ownerLuid"])
+            if lineage["ownerName"]:
+                owner["name"] = lineage["ownerName"]
+        if lineage["projectLuid"] or lineage["projectName"]:
+            project = view.setdefault("project", {})
+            if lineage["projectLuid"]:
+                project.setdefault("id", lineage["projectLuid"])
+            if lineage["projectName"]:
+                project["name"] = lineage["projectName"]
+    return views
+
+
+def _warn_enrichment_failed(subject: str, exc: Exception) -> None:
+    sys.stderr.write(f"Warning: failed to enrich {subject} with lineage metadata: {exc}\n")
+
+
+def enrich_workbooks_with_lineage(api: RestApi, workbooks: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    if not workbooks:
+        return workbooks
+    try:
+        response = api.graphql(get_workbook_lineage_query([w["id"] for w in workbooks]))
+        return merge_workbook_lineage(workbooks, get_workbook_lineage_by_luid(response))
+    except Exception as exc:
+        _warn_enrichment_failed("workbooks", exc)
+        return workbooks
+
+
+def enrich_views_with_lineage(api: RestApi, views: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    if not views:
+        return views
+    try:
+        response = api.graphql(get_view_lineage_query([v["id"] for v in views]))
+        return merge_view_lineage(views, get_view_lineage_by_luid(response))
+    except Exception as exc:
+        _warn_enrichment_failed("views", exc)
+        return views
+
+
+def enrich_search_results_with_lineage(api: RestApi, search_results: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """Attach upstreamDatasources to workbook and view search results."""
+
+    def luids_of_type(content_type: str) -> list[str]:
+        return [r["luid"] for r in search_results if r.get("type") == content_type and isinstance(r.get("luid"), str)]
+
+    workbook_luids = luids_of_type("workbook")
+    view_luids = luids_of_type("view")
+    if not workbook_luids and not view_luids:
+        return search_results
+
+    try:
+        response = api.graphql(get_search_content_lineage_query(workbook_luids, view_luids))
+        workbook_lineage_by_luid = get_workbook_lineage_by_luid(response)
+        view_lineage_by_luid = get_view_lineage_by_luid(response)
+    except Exception as exc:
+        _warn_enrichment_failed("search results", exc)
+        return search_results
+
+    for item in search_results:
+        if item.get("type") == "workbook":
+            upstream_datasources = workbook_lineage_by_luid.get(item.get("luid", ""))
+        elif item.get("type") == "view":
+            lineage = view_lineage_by_luid.get(item.get("luid", ""))
+            upstream_datasources = lineage["upstreamDatasources"] if lineage else None
+        else:
+            continue
+        if upstream_datasources:
+            item["upstreamDatasources"] = upstream_datasources
+    return search_results

tableau_cli-0.1.3/src/tableau_cli/utils/tableau_version.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+
+def is_tableau_version_at_least(product_version: str, min_version: str) -> bool:
+    """Check whether a Tableau product version meets a minimum release version.
+
+    Mirrors the TS isTableauVersionAtLeast helper: builds from the main branch
+    ("main") or unrecognized version formats are assumed to be fresh builds and
+    pass the check.
+    """
+    if product_version == "main":
+        return True
+
+    try:
+        year, major, minor = (int(part) for part in product_version.split("."))
+    except ValueError:
+        return True
+
+    min_year, min_major, min_minor = (int(part) for part in min_version.split("."))
+
+    return (year, major, minor) >= (min_year, min_major, min_minor)

tableau_cli-0.1.3/src/tableau_cli/utils/web_url.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+def construct_view_web_url(server: str, site_name: str, content_url: str) -> str:
+    """Construct the web URL for opening a Tableau view in a browser.
+
+    The API returns contentUrl as 'workbook/sheets/Sheet1' while the web URL
+    uses 'workbook/Sheet1'. The default site omits the /site/{siteName} segment.
+    """
+    url_path = content_url.replace("/sheets/", "/")
+
+    if not site_name or site_name == "Default":
+        return f"{server.rstrip('/')}/#/views/{url_path}"
+    return f"{server.rstrip('/')}/#/site/{site_name}/views/{url_path}"
+
+
+def get_default_view_web_url(workbook: dict[str, Any], server: str, site_name: str) -> str | None:
+    """Web URL for a workbook's default view, falling back to its first view."""
+    views = (workbook.get("views") or {}).get("view") or []
+    if not views:
+        return None
+
+    default_view_id = workbook.get("defaultViewId")
+    target_view = next((v for v in views if v.get("id") == default_view_id), None) if default_view_id else None
+    if target_view is None:
+        target_view = views[0]
+
+    if not target_view.get("contentUrl"):
+        return None
+
+    return construct_view_web_url(server, site_name, target_view["contentUrl"])

tableau_cli-0.1.1/.claude/settings.local.json

@@ -1,18 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(python:*)",
-      "Bash(echo \"EXIT: $?\")",
-      "Bash(tableau-cli datasources:*)",
-      "Bash(tableau-cli convert:*)",
-      "Bash(ruff check:*)",
-      "Bash(git add:*)",
-      "Bash(git commit:*)",
-      "Bash(git push:*)",
-      "Bash(pip index:*)",
-      "Bash(pip install:*)",
-      "Bash(bash -l -c \"history\")",
-      "Bash(twine --version)"
-    ]
-  }
-}

tableau_cli-0.1.1/.claude/skills/tableau-cli

@@ -1 +0,0 @@
-../../.agents/skills/tableau-cli

tableau_cli-0.1.1/skills-lock.json

@@ -1,10 +0,0 @@
-{
-  "version": 1,
-  "skills": {
-    "tableau-cli": {
-      "source": "i-richardwang/tableau-cli",
-      "sourceType": "github",
-      "computedHash": "26defe3fe68adfac902da3328240d33528db5fe9757f88f7e3a8bdc90744c6d9"
-    }
-  }
-}