tableauserverclient 0.25__py3-none-any.whl → 0.27.post0.dev1__py3-none-any.whl

tableauserverclient/models/workbook_item.py

@@ -20,7 +20,7 @@ from .view_item import ViewItem
 
 
 class WorkbookItem(object):
-    def __init__(self, project_id: str, name: Optional[str] = None, show_tabs: bool = False) -> None:
+    def __init__(self, project_id: Optional[str] = None, name: Optional[str] = None, show_tabs: bool = False) -> None:
         self._connections = None
         self._content_url = None
         self._webpage_url = None
@@ -38,7 +38,8 @@ class WorkbookItem(object):
         self.name = name
         self._description = None
         self.owner_id: Optional[str] = None
-        self.project_id = project_id
+        # workaround for Personal Space workbooks without a project
+        self.project_id: Optional[str] = project_id or uuid.uuid4().__str__()
         self.show_tabs = show_tabs
         self.hidden_views: Optional[List[str]] = None
         self.tags: Set[str] = set()
@@ -52,11 +53,14 @@ class WorkbookItem(object):
 
         return None
 
-    def __repr__(self):
+    def __str__(self):
         return "<WorkbookItem {0} '{1}' contentUrl='{2}' project={3}>".format(
             self._id, self.name, self.content_url, self.project_id
         )
 
+    def __repr__(self):
+        return self.__str__() + "  { " + ", ".join(" % s: % s" % item for item in vars(self).items()) + "}"
+
     @property
     def connections(self) -> List[ConnectionItem]:
         if self._connections is None:
@@ -293,49 +297,16 @@ class WorkbookItem(object):
         parsed_response = fromstring(resp)
         all_workbook_xml = parsed_response.findall(".//t:workbook", namespaces=ns)
         for workbook_xml in all_workbook_xml:
-            (
-                id,
-                name,
-                content_url,
-                webpage_url,
-                created_at,
-                description,
-                updated_at,
-                size,
-                show_tabs,
-                project_id,
-                project_name,
-                owner_id,
-                tags,
-                views,
-                data_acceleration_config,
-            ) = cls._parse_element(workbook_xml, ns)
-
-            # workaround for Personal Space workbooks which won't have a project
-            if not project_id:
-                project_id = uuid.uuid4()
-
-            workbook_item = cls(project_id)
-            workbook_item._set_values(
-                id,
-                name,
-                content_url,
-                webpage_url,
-                created_at,
-                description,
-                updated_at,
-                size,
-                show_tabs,
-                None,
-                project_name,
-                owner_id,
-                tags,
-                views,
-                data_acceleration_config,
-            )
+            workbook_item = cls.from_xml(workbook_xml, ns)
             all_workbook_items.append(workbook_item)
         return all_workbook_items
 
+    @classmethod
+    def from_xml(cls, workbook_xml, ns):
+        workbook_item = cls()
+        workbook_item._set_values(*cls._parse_element(workbook_xml, ns))
+        return workbook_item
+
     @staticmethod
     def _parse_element(workbook_xml, ns):
         id = workbook_xml.get("id", None)

tableauserverclient/server/__init__.py

@@ -10,9 +10,7 @@ from .request_options import (
 
 from .filter import Filter
 from .sort import Sort
-from ..models import *
 from .endpoint import *
 from .server import Server
 from .pager import Pager
-from .exceptions import NotSignedInError
-from ..helpers import *
+from .endpoint.exceptions import NotSignedInError

tableauserverclient/server/endpoint/__init__.py

@@ -5,11 +5,7 @@ from .data_alert_endpoint import DataAlerts
 from .databases_endpoint import Databases
 from .datasources_endpoint import Datasources
 from .endpoint import Endpoint, QuerysetEndpoint
-from .exceptions import (
-    ServerResponseError,
-    MissingRequiredFieldError,
-    ServerInfoEndpointNotFoundError,
-)
+from .exceptions import ServerResponseError, MissingRequiredFieldError
 from .favorites_endpoint import Favorites
 from .fileuploads_endpoint import Fileuploads
 from .flow_runs_endpoint import FlowRuns

tableauserverclient/server/endpoint/auth_endpoint.py

@@ -1,4 +1,6 @@
 import logging
+from typing import TYPE_CHECKING
+import warnings
 
 from defusedxml.ElementTree import fromstring
 
@@ -6,7 +8,11 @@ from .endpoint import Endpoint, api
 from .exceptions import ServerResponseError
 from ..request_factory import RequestFactory
 
-logger = logging.getLogger("tableau.endpoint.auth")
+from tableauserverclient.helpers.logging import logger
+
+if TYPE_CHECKING:
+    from tableauserverclient.models.site_item import SiteItem
+    from tableauserverclient.models.tableau_auth import Credentials
 
 
 class Auth(Endpoint):
@@ -21,11 +27,21 @@ class Auth(Endpoint):
             self._callback()
 
     @property
-    def baseurl(self):
+    def baseurl(self) -> str:
         return "{0}/auth".format(self.parent_srv.baseurl)
 
     @api(version="2.0")
-    def sign_in(self, auth_req):
+    def sign_in(self, auth_req: "Credentials") -> contextmgr:
+        """
+        Sign in to a Tableau Server or Tableau Online using a credentials object.
+
+        The credentials object can either be a TableauAuth object, a
+        PersonalAccessTokenAuth object, or a JWTAuth object. This method now
+        accepts them all. The object should be populated with the site_id and
+        optionally a user_id to impersonate.
+
+        Creates a context manager that will sign out of the server upon exit.
+        """
         url = "{0}/{1}".format(self.baseurl, "signin")
         signin_req = RequestFactory.Auth.signin_req(auth_req)
         server_response = self.parent_srv.session.post(
@@ -50,13 +66,18 @@ class Auth(Endpoint):
         logger.info("Signed into {0} as user with id {1}".format(self.parent_srv.server_address, user_id))
         return Auth.contextmgr(self.sign_out)
 
+    # We use the same request that username/password login uses for all auth types.
+    # The distinct methods are mostly useful for explicitly showing api version support for each auth type
     @api(version="3.6")
-    def sign_in_with_personal_access_token(self, auth_req):
-        # We use the same request that username/password login uses.
+    def sign_in_with_personal_access_token(self, auth_req: "Credentials") -> contextmgr:
+        return self.sign_in(auth_req)
+
+    @api(version="3.17")
+    def sign_in_with_json_web_token(self, auth_req: "Credentials") -> contextmgr:
         return self.sign_in(auth_req)
 
     @api(version="2.0")
-    def sign_out(self):
+    def sign_out(self) -> None:
         url = "{0}/{1}".format(self.baseurl, "signout")
         # If there are no auth tokens you're already signed out. No-op
         if not self.parent_srv.is_signed_in():
@@ -66,7 +87,7 @@ class Auth(Endpoint):
         logger.info("Signed out")
 
     @api(version="2.6")
-    def switch_site(self, site_item):
+    def switch_site(self, site_item: "SiteItem") -> contextmgr:
         url = "{0}/{1}".format(self.baseurl, "switchSite")
         switch_req = RequestFactory.Auth.switch_req(site_item.content_url)
         try:
@@ -87,7 +108,7 @@ class Auth(Endpoint):
         return Auth.contextmgr(self.sign_out)
 
     @api(version="3.10")
-    def revoke_all_server_admin_tokens(self):
+    def revoke_all_server_admin_tokens(self) -> None:
         url = "{0}/{1}".format(self.baseurl, "revokeAllServerAdminTokens")
         self.post_request(url, "")
         logger.info("Revoked all tokens for all server admins")

tableauserverclient/server/endpoint/custom_views_endpoint.py

@@ -6,7 +6,7 @@ from .exceptions import MissingRequiredFieldError
 from tableauserverclient.models import CustomViewItem, PaginationItem
 from tableauserverclient.server import RequestFactory, RequestOptions, ImageRequestOptions
 
-logger = logging.getLogger("tableau.endpoint.custom_views")
+from tableauserverclient.helpers.logging import logger
 
 """
 Get a list of custom views on a site

tableauserverclient/server/endpoint/data_acceleration_report_endpoint.py

@@ -5,7 +5,7 @@ from .endpoint import api, Endpoint
 from .permissions_endpoint import _PermissionsEndpoint
 from tableauserverclient.models import DataAccelerationReportItem
 
-logger = logging.getLogger("tableau.endpoint.data_acceleration_report")
+from tableauserverclient.helpers.logging import logger
 
 
 class DataAccelerationReport(Endpoint):

tableauserverclient/server/endpoint/data_alert_endpoint.py

@@ -5,7 +5,7 @@ from .exceptions import MissingRequiredFieldError
 from tableauserverclient.server import RequestFactory
 from tableauserverclient.models import DataAlertItem, PaginationItem, UserItem
 
-logger = logging.getLogger("tableau.endpoint.dataAlerts")
+from tableauserverclient.helpers.logging import logger
 
 from typing import List, Optional, TYPE_CHECKING, Tuple, Union
 

tableauserverclient/server/endpoint/databases_endpoint.py

@@ -8,7 +8,7 @@ from .permissions_endpoint import _PermissionsEndpoint
 from tableauserverclient.server import RequestFactory
 from tableauserverclient.models import DatabaseItem, TableItem, PaginationItem, Resource
 
-logger = logging.getLogger("tableau.endpoint.databases")
+from tableauserverclient.helpers.logging import logger
 
 
 class Databases(Endpoint):

tableauserverclient/server/endpoint/datasources_endpoint.py

@@ -1,7 +1,6 @@
 import cgi
 import copy
 import json
-import logging
 import io
 import os
 
@@ -20,13 +19,14 @@ from .exceptions import InternalServerError, MissingRequiredFieldError
 from .permissions_endpoint import _PermissionsEndpoint
 from .resource_tagger import _ResourceTagger
 
-from tableauserverclient.server import RequestFactory, RequestOptions
+from tableauserverclient.config import ALLOWED_FILE_EXTENSIONS, FILESIZE_LIMIT_MB, BYTES_PER_MB, CHUNK_SIZE_MB
 from tableauserverclient.filesys_helpers import (
-    to_filename,
     make_download_path,
     get_file_type,
     get_file_object_size,
+    to_filename,
 )
+from tableauserverclient.helpers.logging import logger
 from tableauserverclient.models import (
     ConnectionCredentials,
     ConnectionItem,
@@ -35,6 +35,7 @@ from tableauserverclient.models import (
     RevisionItem,
     PaginationItem,
 )
+from tableauserverclient.server import RequestFactory, RequestOptions
 
 io_types = (io.BytesIO, io.BufferedReader)
 io_types_r = (io.BytesIO, io.BufferedReader)
@@ -44,13 +45,6 @@ FilePath = Union[str, os.PathLike]
 FileObject = Union[io.BufferedReader, io.BytesIO]
 PathOrFile = Union[FilePath, FileObject]
 
-# The maximum size of a file that can be published in a single request is 64MB
-FILESIZE_LIMIT = 1024 * 1024 * 64  # 64MB
-
-ALLOWED_FILE_EXTENSIONS = ["tds", "tdsx", "tde", "hyper", "parquet"]
-
-logger = logging.getLogger("tableau.endpoint.datasources")
-
 FilePath = Union[str, os.PathLike]
 FileObjectR = Union[io.BufferedReader, io.BytesIO]
 FileObjectW = Union[io.BufferedWriter, io.BytesIO]
@@ -162,12 +156,20 @@ class Datasources(QuerysetEndpoint):
 
     # Update datasource connections
     @api(version="2.3")
-    def update_connection(self, datasource_item: DatasourceItem, connection_item: ConnectionItem) -> ConnectionItem:
+    def update_connection(
+        self, datasource_item: DatasourceItem, connection_item: ConnectionItem
+    ) -> Optional[ConnectionItem]:
         url = "{0}/{1}/connections/{2}".format(self.baseurl, datasource_item.id, connection_item.id)
 
         update_req = RequestFactory.Connection.update_req(connection_item)
         server_response = self.put_request(url, update_req)
-        connection = ConnectionItem.from_response(server_response.content, self.parent_srv.namespace)[0]
+        connections = ConnectionItem.from_response(server_response.content, self.parent_srv.namespace)
+        if not connections:
+            return None
+
+        if len(connections) > 1:
+            logger.debug("Multiple connections returned ({0})".format(len(connections)))
+        connection = list(filter(lambda x: x.id == connection_item.id, connections))[0]
 
         logger.info(
             "Updated datasource item (ID: {0} & connection item {1}".format(datasource_item.id, connection_item.id)
@@ -220,7 +222,7 @@ class Datasources(QuerysetEndpoint):
             filename = os.path.basename(file)
             file_extension = os.path.splitext(filename)[1][1:]
             file_size = os.path.getsize(file)
-
+            logger.debug("Publishing file `{}`, size `{}`".format(filename, file_size))
             # If name is not defined, grab the name from the file to publish
             if not datasource_item.name:
                 datasource_item.name = os.path.splitext(filename)[0]
@@ -261,8 +263,12 @@ class Datasources(QuerysetEndpoint):
             url += "&{0}=true".format("asJob")
 
         # Determine if chunking is required (64MB is the limit for single upload method)
-        if file_size >= FILESIZE_LIMIT:
-            logger.info("Publishing {0} to server with chunking method (datasource over 64MB)".format(filename))
+        if file_size >= FILESIZE_LIMIT_MB * BYTES_PER_MB:
+            logger.info(
+                "Publishing {} to server with chunking method (datasource over {}MB, chunk size {}MB)".format(
+                    filename, FILESIZE_LIMIT_MB, CHUNK_SIZE_MB
+                )
+            )
             upload_session_id = self.parent_srv.fileuploads.upload(file)
             url = "{0}&uploadSessionId={1}".format(url, upload_session_id)
             xml_request, content_type = RequestFactory.Datasource.publish_req_chunked(

tableauserverclient/server/endpoint/default_permissions_endpoint.py

@@ -10,7 +10,7 @@ if TYPE_CHECKING:
     from ..server import Server
     from ..request_options import RequestOptions
 
-logger = logging.getLogger(__name__)
+from tableauserverclient.helpers.logging import logger
 
 # these are the only two items that can hold default permissions for another type
 BaseItem = Union[DatabaseItem, ProjectItem]

tableauserverclient/server/endpoint/dqw_endpoint.py

@@ -5,7 +5,7 @@ from .exceptions import MissingRequiredFieldError
 from tableauserverclient.server import RequestFactory
 from tableauserverclient.models import DQWItem
 
-logger = logging.getLogger(__name__)
+from tableauserverclient.helpers.logging import logger
 
 
 class _DataQualityWarningEndpoint(Endpoint):

tableauserverclient/server/endpoint/endpoint.py

@@ -1,24 +1,31 @@
+from threading import Thread
+from time import sleep
+from tableauserverclient import datetime_helpers as datetime
+
 import requests
-import logging
 from packaging.version import Version
 from functools import wraps
 from xml.etree.ElementTree import ParseError
-from typing import Any, Callable, Dict, Optional, TYPE_CHECKING
+from typing import Any, Callable, Dict, Optional, TYPE_CHECKING, Union
 
 from .exceptions import (
     ServerResponseError,
     InternalServerError,
     NonXMLResponseError,
-    EndpointUnavailableError,
+    NotSignedInError,
 )
+from ..exceptions import EndpointUnavailableError
+
 from tableauserverclient.server.query import QuerySet
 from tableauserverclient import helpers, get_versions
 
+from tableauserverclient.helpers.logging import logger
+from tableauserverclient.config import DELAY_SLEEP_SECONDS
+
 if TYPE_CHECKING:
     from ..server import Server
     from requests import Response
 
-logger = logging.getLogger("tableau.endpoint")
 
 Success_codes = [200, 201, 202, 204]
 
@@ -34,6 +41,8 @@ class Endpoint(object):
     def __init__(self, parent_srv: "Server"):
         self.parent_srv = parent_srv
 
+    async_response = None
+
     @staticmethod
     def set_parameters(http_options, auth_token, content, content_type, parameters) -> Dict[str, Any]:
         parameters = parameters or {}
@@ -53,6 +62,8 @@ class Endpoint(object):
 
     @staticmethod
     def set_user_agent(parameters):
+        if "headers" not in parameters:
+            parameters["headers"] = {}
         if USER_AGENT_HEADER not in parameters["headers"]:
             if USER_AGENT_HEADER in parameters:
                 parameters["headers"][USER_AGENT_HEADER] = parameters[USER_AGENT_HEADER]
@@ -65,6 +76,59 @@ class Endpoint(object):
         # return explicitly for testing only
         return parameters
 
+    def _blocking_request(self, method, url, parameters={}) -> Optional["Response"]:
+        self.async_response = None
+        response = None
+        logger.debug("[{}] Begin blocking request to {}".format(datetime.timestamp(), url))
+        try:
+            response = method(url, **parameters)
+            self.async_response = response
+            logger.debug("[{}] Call finished".format(datetime.timestamp()))
+        except Exception as e:
+            logger.debug("Error making request to server: {}".format(e))
+            self.async_response = e
+        finally:
+            if response and not self.async_response:
+                logger.debug("Request response not saved")
+                return None
+        logger.debug("[{}] Request complete".format(datetime.timestamp()))
+        return self.async_response
+
+    def send_request_while_show_progress_threaded(
+        self, method, url, parameters={}, request_timeout=0
+    ) -> Optional["Response"]:
+        try:
+            request_thread = Thread(target=self._blocking_request, args=(method, url, parameters))
+            request_thread.async_response = -1  # type:ignore # this is an invented attribute for thread comms
+            request_thread.start()
+        except Exception as e:
+            logger.debug("Error starting server request on separate thread: {}".format(e))
+            return None
+        seconds = 0
+        minutes = 0
+        sleep(1)
+        if self.async_response != -1:
+            # a quick return for any immediate responses
+            return self.async_response
+        while self.async_response == -1 and (request_timeout == 0 or seconds < request_timeout):
+            self.log_wait_time_then_sleep(minutes, seconds, url)
+            seconds = seconds + DELAY_SLEEP_SECONDS
+            if seconds >= 60:
+                seconds = 0
+                minutes = minutes + 1
+        return self.async_response
+
+    def log_wait_time_then_sleep(self, minutes, seconds, url):
+        logger.debug("{} Waiting....".format(datetime.timestamp()))
+        if seconds >= 60:  # detailed log message ~every minute
+            if minutes % 5 == 0:
+                logger.info(
+                    "[{}] Waiting ({} minutes so far) for request to {}".format(datetime.timestamp(), minutes, url)
+                )
+            else:
+                logger.debug("[{}] Waiting for request to {}".format(datetime.timestamp(), url))
+        sleep(DELAY_SLEEP_SECONDS)
+
     def _make_request(
         self,
         method: Callable[..., "Response"],
@@ -80,36 +144,59 @@ class Endpoint(object):
 
         logger.debug("request method {}, url: {}".format(method.__name__, url))
         if content:
-            redacted = helpers.strings.redact_xml(content[:1000])
+            redacted = helpers.strings.redact_xml(content[:200])
+            # this needs to be under a trace or something, it's a LOT
             # logger.debug("request content: {}".format(redacted))
 
-        server_response = method(url, **parameters)
+        # a request can, for stuff like publishing, spin for ages waiting for a response.
+        # we need some user-facing activity so they know it's not dead.
+        request_timeout = self.parent_srv.http_options.get("timeout") or 0
+        server_response: Optional["Response"] = self.send_request_while_show_progress_threaded(
+            method, url, parameters, request_timeout
+        )
+        logger.debug("[{}] Async request returned: received {}".format(datetime.timestamp(), server_response))
+        # is this blocking retry really necessary? I guess if it was just the threading messing it up?
+        if server_response is None:
+            logger.debug(server_response)
+            logger.debug("[{}] Async request failed: retrying".format(datetime.timestamp()))
+            server_response = self._blocking_request(method, url, parameters)
+        if server_response is None:
+            logger.debug("[{}] Request failed".format(datetime.timestamp()))
+            raise RuntimeError
         self._check_status(server_response, url)
 
         loggable_response = self.log_response_safely(server_response)
-        # logger.debug("Server response from {0}:\n\t{1}".format(url, loggable_response))
+        logger.debug("Server response from {0}".format(url))
+        # logger.debug("\n\t{1}".format(loggable_response))
 
         if content_type == "application/xml":
             self.parent_srv._namespace.detect(server_response.content)
 
         return server_response
 
-    def _check_status(self, server_response, url: Optional[str] = None):
+    def _check_status(self, server_response: "Response", url: Optional[str] = None):
+        logger.debug("Response status: {}".format(server_response))
+        if not hasattr(server_response, "status_code"):
+            raise EnvironmentError("Response is not a http response?")
         if server_response.status_code >= 500:
             raise InternalServerError(server_response, url)
         elif server_response.status_code not in Success_codes:
             try:
+                if server_response.status_code == 401:
+                    # TODO: catch this in server.py and attempt to sign in again, in case it's a session expiry
+                    raise NotSignedInError(server_response.content, url)
+
                 raise ServerResponseError.from_response(server_response.content, self.parent_srv.namespace, url)
             except ParseError:
                 # This will happen if we get a non-success HTTP code that doesn't return an xml error object
-                # e.g metadata endpoints, 503 pages, totally different servers
+                # e.g. metadata endpoints, 503 pages, totally different servers
                 # we convert this to a better exception and pass through the raw response body
                 raise NonXMLResponseError(server_response.content)
             except Exception:
                 # anything else re-raise here
                 raise
 
-    def log_response_safely(self, server_response: requests.Response) -> str:
+    def log_response_safely(self, server_response: "Response") -> str:
         # Checking the content type header prevents eager evaluation of streaming requests.
         content_type = server_response.headers.get("Content-Type")
 
@@ -117,7 +204,7 @@ class Endpoint(object):
         # content-type is an octet-stream accomplishes the same goal without eagerly loading content.
         # This check is to determine if the response is a text response (xml or otherwise)
         # so that we do not attempt to log bytes and other binary data.
-        loggable_response = "Content type {}".format(content_type)
+        loggable_response = "Content type `{}`".format(content_type)
         if content_type == "application/octet-stream":
             loggable_response = "A stream of type {} [Truncated File Contents]".format(content_type)
         elif server_response.encoding and len(server_response.content) > 0:

tableauserverclient/server/endpoint/exceptions.py

@@ -47,11 +47,7 @@ class MissingRequiredFieldError(TableauError):
     pass
 
 
-class ServerInfoEndpointNotFoundError(TableauError):
-    pass
-
-
-class EndpointUnavailableError(TableauError):
+class NotSignedInError(TableauError):
     pass