#DDQ2024-12 Find a View by URL

pip install tableauserverclient

Enter the name of the Tableau view to search for: Sales Dashboard

Searching for views...

Found the following view(s):

1)
- View Name: Sales Dashboard
- View ID: e8f2a1b4-1234-5678-9abc-def012345678
- Workbook Name: Annual Sales Reports
- Project Name: Corporate Reports
- View URL: https://your-tableau-server/views/AnnualSalesReports/SalesDashboard

2)
- View Name: Regional Sales Dashboard
- View ID: f9a3b2c5-2345-6789-0bcd-ef1234567890
- Workbook Name: Regional Reports
- Project Name: Sales Team
- View URL: https://your-tableau-server/views/RegionalReports/RegionalSalesDashboard

Process completed successfully.

# /// script
# requires-python = ">=3.10"
# dependencies = [
#   "tableauserverclient>=0.34",
#   "python-dotenv",
# ]
# ///

import argparse
from collections.abc import Sequence
from dataclasses import dataclass
import os
import re
import sys
from typing import overload
from urllib.parse import urlparse

from dotenv import load_dotenv
import tableauserverclient as TSC

load_dotenv()


@dataclass
class SearchDetails:
    server: str
    site_url: str | None = None
    content_url: str | None = None
    auth: TSC.TableauAuth | TSC.PersonalAccessTokenAuth


@overload
def get_auth(
    username: str, password: str, token_name: None, token_secret: None, site_url: str
) -> TSC.TableauAuth: ...


@overload
def get_auth(
    username: None, password: None, token_name: str, token_secret: str, site_url: str
) -> TSC.PersonalAccessTokenAuth: ...


def get_auth(username, password, token_name, token_secret, site_url):
    """
    From the provided credentials, return the object that will be used to
    authenticate to Tableau Server or Tableau Cloud. Preference is given to
    the provided credentials, but if they are not provided, the function will
    attempt to read the credentials from the environment variables.

    Parameters
    ----------
    username: str | None
        The username to use for authentication. Required if using username and
        password authentication. Can be read from the TABLEAU_USERNAME
        environment variable.

    password: str | None
        The password to use for authentication. Required if using username and
        password authentication. Can be read from the TABLEAU_PASSWORD
        environment variable.

    token_name: str | None
        The name of the personal access token to use for authentication. Required
        if using personal access token authentication. Can be read from the
        TABLEAU_TOKEN_NAME environment variable.

    token_secret: str | None
        The secret of the personal access token to use for authentication. Required
        if using personal access token authentication. Can be read from the
        TABLEAU_TOKEN_SECRET environment variable.

    site_url: str
        The URL of the site to authenticate to. Required. Can be read from the
        TABLEAU_SITE_URL environment variable.

    Returns
    -------
    TSC.TableauAuth | TSC.PersonalAccessTokenAuth
        The object to use for authentication.
    """
    if username and password:
        return TSC.TableauAuth(username, password, site_url)
    elif token_name and token_secret:
        return TSC.PersonalAccessTokenAuth(token_name, token_secret, site_url)
    else:
        if (username := os.getenv("TABLEAU_USERNAME")) and (
            password := os.getenv("TABLEAU_PASSWORD")
        ):
            return TSC.TableauAuth(username, password, site_url)
        elif (token_name := os.getenv("TABLEAU_TOKEN_NAME")) and (
            token_secret := os.getenv("TABLEAU_TOKEN_SECRET")
        ):
            return TSC.PersonalAccessTokenAuth(token_name, token_secret, site_url)
        raise ValueError(
            "Either username and password or token name and token secret must be provided."
        )


def parse_url(url: str) -> SearchDetails:
    """
    Parse the user provided URL to extract the server URL, site URL,
    and the view object path to search for.

    Parameters
    ----------
    url: str
        The URL to parse. The URL should be in the format of
        'https://<server>/#/<site>/views/<workbook>/<view>'.

    Returns
    -------
    SearchDetails
        A dataclass containing the server URL, site URL, and the view object
        path to search for.
    """
    # The URL may have a "query" string that needs to be removed before
    # parsing. URL standard expects the query string to be before the fragment.
    # Tableau Server URLs use the fragment to handle navigation to a site, and
    # then to a specific object within that site.
    parsed_url = urlparse(url.split("?")[0])
    server = f"{parsed_url.scheme}://{parsed_url.netloc}"
    # Create a regular expression pattern with named capture groups to extract
    # relevant parts of the URL.
    pattern = re.compile(
        r"""
    ^\/?                          # Start of string and optional leading slash
    (site\/(?P<site>\w+))?        # Optional site URL. If not present, then the "default" site
    ((?P<view>views)\/            # Fixed string "views" followed by a slash
    (?P<view_path>[\w-]+\/[\w-]+) # View path is Workbook/View
    )
    $ # End of string
    """,
        flags=re.VERBOSE,
    )

    if (match := pattern.fullmatch(parsed_url.fragment)):
        # The default site URL is represented by an empty string.
        site = match.groupdict().get("site", "")
        # Content URL has the format "workbook/sheets/view".
        view_path = match.groupdict().get("view_path", "")
        workbook, view = view_path.split("/")
        content_url = f"{workbook}/sheets/{view}"

    else:
        raise ValueError(
            "URL must be in the format 'https://<server>/#/<site>/views/<workbook>/<view>'."
        )

    return SearchDetails(server, site, content_url, None)


def get_args(args: Sequence[str] | None = None) -> SearchDetails:
    """
    Parse command line arguments.
    """
    # If no arguments are provided, use sys.argv[1:] to read arguments from
    # the command line. A str is also technically a sequence, so we need to
    # check for that.
    if isinstance(args, str):
        raise ValueError("args must be a sequence of strings or None.")
    args = args or sys.argv[1:]

    parser = argparse.ArgumentParser(description="Locate a view by name.")
    parser.add_argument(
        "-u", "--url", dest="url", help="URL of the View to locate.", required=True
    )
    parser.add_argument(
        "--username",
        required=False,
        help="Username to authenticate with. Required if using username and password authentication, or can be read from the TABLEAU_USERNAME environment variable.",
    )
    parser.add_argument(
        "--password",
        required=False,
        help="Password to authenticate with. Required if using username and password authentication, or can be read from the TABLEAU_PASSWORD environment variable.",
    )
    parser.add_argument(
        "--token-name",
        required=False,
        help="Name of the personal access token to authenticate with. Required if using personal access token authentication, or can be read from the TABLEAU_TOKEN_NAME environment variable.",
    )
    parser.add_argument(
        "--token-secret",
        required=False,
        help="Secret of the personal access token to authenticate with. Required if using personal access token authentication, or can be read from the TABLEAU_TOKEN_SECRET environment variable.",
    )

    args = parser.parse_args(args)

    details = parse_url(args.url)
    auth = get_auth(
        args.username,
        args.password,
        args.token_name,
        args.token_secret,
        details.site_url,
    )
    details.auth = auth

    return details


def main() -> int:
    """
    Main function for the script. Return value will be used as the exit code.
    0 is considered a successful exit, any other value is considered an error.
    """

    # Parse out command line arguments
    search_details = get_args()
    # Set "use_server_version" to True to use the server's version instead of
    # the default version. This ensures that the client doesn't complain about
    # version mismatches.
    server = TSC.Server(search_details.server, use_server_version=True)

    # Sign in using a context manager to ensure that the sign out is called
    # when the block is exited.
    with server.auth.sign_in(search_details.auth):
        # Get the QuerySet of views that match the filter options.
        views = server.views.filter(content_url=search_details.content_url)
        # Check how many results are returned. Raise an error if no views are found.
        # URL is unique, so only one view at most should be returned.
        if len(views) == 0:
            raise RuntimeError(f"No views found with name {search_details.name}.")

        # If only one view is found, print out the name and ID of the view.
        view = views[0]
        print(f"View found: {view.name} ({view.id})")

    return 0


if __name__ == "__main__":
    sys.exit(main())