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

tableauserverclient/server/endpoint/favorites_endpoint.py

@@ -1,16 +1,20 @@
-import logging
-
 from .endpoint import Endpoint, api
-from tableauserverclient.server import RequestFactory
-from tableauserverclient.models import FavoriteItem
-
-from typing import Optional, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from ...models import DatasourceItem, FlowItem, ProjectItem, UserItem, ViewItem, WorkbookItem
-    from ..request_options import RequestOptions
-
-logger = logging.getLogger("tableau.endpoint.favorites")
+from requests import Response
+from tableauserverclient.helpers.logging import logger
+from tableauserverclient.models import (
+    DatasourceItem,
+    FavoriteItem,
+    FlowItem,
+    MetricItem,
+    ProjectItem,
+    Resource,
+    TableauItem,
+    UserItem,
+    ViewItem,
+    WorkbookItem,
+)
+from tableauserverclient.server import RequestFactory, RequestOptions
+from typing import Optional
 
 
 class Favorites(Endpoint):
@@ -20,74 +24,112 @@ class Favorites(Endpoint):
 
     # Gets all favorites
     @api(version="2.5")
-    def get(self, user_item: "UserItem", req_options: Optional["RequestOptions"] = None) -> None:
+    def get(self, user_item: UserItem, req_options: Optional[RequestOptions] = None) -> None:
         logger.info("Querying all favorites for user {0}".format(user_item.name))
         url = "{0}/{1}".format(self.baseurl, user_item.id)
         server_response = self.get_request(url, req_options)
-
         user_item._favorites = FavoriteItem.from_response(server_response.content, self.parent_srv.namespace)
 
+    # ---------add to favorites
+
+    @api(version="3.15")
+    def add_favorite(self, user_item: UserItem, content_type: str, item: TableauItem) -> "Response":
+        url = "{0}/{1}".format(self.baseurl, user_item.id)
+        add_req = RequestFactory.Favorite.add_request(item.id, content_type, item.name)
+        server_response = self.put_request(url, add_req)
+        logger.info("Favorited {0} for user (ID: {1})".format(item.name, user_item.id))
+        return server_response
+
     @api(version="2.0")
-    def add_favorite_workbook(self, user_item: "UserItem", workbook_item: "WorkbookItem") -> None:
+    def add_favorite_workbook(self, user_item: UserItem, workbook_item: WorkbookItem) -> None:
         url = "{0}/{1}".format(self.baseurl, user_item.id)
         add_req = RequestFactory.Favorite.add_workbook_req(workbook_item.id, workbook_item.name)
         server_response = self.put_request(url, add_req)
         logger.info("Favorited {0} for user (ID: {1})".format(workbook_item.name, user_item.id))
 
     @api(version="2.0")
-    def add_favorite_view(self, user_item: "UserItem", view_item: "ViewItem") -> None:
+    def add_favorite_view(self, user_item: UserItem, view_item: ViewItem) -> None:
         url = "{0}/{1}".format(self.baseurl, user_item.id)
         add_req = RequestFactory.Favorite.add_view_req(view_item.id, view_item.name)
         server_response = self.put_request(url, add_req)
         logger.info("Favorited {0} for user (ID: {1})".format(view_item.name, user_item.id))
 
     @api(version="2.3")
-    def add_favorite_datasource(self, user_item: "UserItem", datasource_item: "DatasourceItem") -> None:
+    def add_favorite_datasource(self, user_item: UserItem, datasource_item: DatasourceItem) -> None:
         url = "{0}/{1}".format(self.baseurl, user_item.id)
         add_req = RequestFactory.Favorite.add_datasource_req(datasource_item.id, datasource_item.name)
         server_response = self.put_request(url, add_req)
         logger.info("Favorited {0} for user (ID: {1})".format(datasource_item.name, user_item.id))
 
     @api(version="3.1")
-    def add_favorite_project(self, user_item: "UserItem", project_item: "ProjectItem") -> None:
+    def add_favorite_project(self, user_item: UserItem, project_item: ProjectItem) -> None:
         url = "{0}/{1}".format(self.baseurl, user_item.id)
         add_req = RequestFactory.Favorite.add_project_req(project_item.id, project_item.name)
         server_response = self.put_request(url, add_req)
         logger.info("Favorited {0} for user (ID: {1})".format(project_item.name, user_item.id))
 
     @api(version="3.3")
-    def add_favorite_flow(self, user_item: "UserItem", flow_item: "FlowItem") -> None:
+    def add_favorite_flow(self, user_item: UserItem, flow_item: FlowItem) -> None:
         url = "{0}/{1}".format(self.baseurl, user_item.id)
         add_req = RequestFactory.Favorite.add_flow_req(flow_item.id, flow_item.name)
         server_response = self.put_request(url, add_req)
         logger.info("Favorited {0} for user (ID: {1})".format(flow_item.name, user_item.id))
 
+    @api(version="3.3")
+    def add_favorite_metric(self, user_item: UserItem, metric_item: MetricItem) -> None:
+        url = "{0}/{1}".format(self.baseurl, user_item.id)
+        add_req = RequestFactory.Favorite.add_request(metric_item.id, Resource.Metric, metric_item.name)
+        server_response = self.put_request(url, add_req)
+        logger.info("Favorited metric {0} for user (ID: {1})".format(metric_item.name, user_item.id))
+
+    # ------- delete from favorites
+    # Response:
+    """
+    <tsResponse>
+      <favorites>
+        <favorite label="favorite-label">
+      </favorites>
+    </tsResponse>
+    """
+
+    @api(version="3.15")
+    def delete_favorite(self, user_item: UserItem, content_type: Resource, item: TableauItem) -> None:
+        url = "{0}/{1}/{2}/{3}".format(self.baseurl, user_item.id, content_type, item.id)
+        logger.info("Removing favorite {0}({1}) for user (ID: {2})".format(content_type, item.id, user_item.id))
+        self.delete_request(url)
+
     @api(version="2.0")
-    def delete_favorite_workbook(self, user_item: "UserItem", workbook_item: "WorkbookItem") -> None:
+    def delete_favorite_workbook(self, user_item: UserItem, workbook_item: WorkbookItem) -> None:
         url = "{0}/{1}/workbooks/{2}".format(self.baseurl, user_item.id, workbook_item.id)
-        logger.info("Removing favorite {0} for user (ID: {1})".format(workbook_item.id, user_item.id))
+        logger.info("Removing favorite workbook {0} for user (ID: {1})".format(workbook_item.id, user_item.id))
         self.delete_request(url)
 
     @api(version="2.0")
-    def delete_favorite_view(self, user_item: "UserItem", view_item: "ViewItem") -> None:
+    def delete_favorite_view(self, user_item: UserItem, view_item: ViewItem) -> None:
         url = "{0}/{1}/views/{2}".format(self.baseurl, user_item.id, view_item.id)
-        logger.info("Removing favorite {0} for user (ID: {1})".format(view_item.id, user_item.id))
+        logger.info("Removing favorite view {0} for user (ID: {1})".format(view_item.id, user_item.id))
         self.delete_request(url)
 
     @api(version="2.3")
-    def delete_favorite_datasource(self, user_item: "UserItem", datasource_item: "DatasourceItem") -> None:
+    def delete_favorite_datasource(self, user_item: UserItem, datasource_item: DatasourceItem) -> None:
         url = "{0}/{1}/datasources/{2}".format(self.baseurl, user_item.id, datasource_item.id)
         logger.info("Removing favorite {0} for user (ID: {1})".format(datasource_item.id, user_item.id))
         self.delete_request(url)
 
     @api(version="3.1")
-    def delete_favorite_project(self, user_item: "UserItem", project_item: "ProjectItem") -> None:
+    def delete_favorite_project(self, user_item: UserItem, project_item: ProjectItem) -> None:
         url = "{0}/{1}/projects/{2}".format(self.baseurl, user_item.id, project_item.id)
-        logger.info("Removing favorite {0} for user (ID: {1})".format(project_item.id, user_item.id))
+        logger.info("Removing favorite project {0} for user (ID: {1})".format(project_item.id, user_item.id))
         self.delete_request(url)
 
     @api(version="3.3")
-    def delete_favorite_flow(self, user_item: "UserItem", flow_item: "FlowItem") -> None:
-        url = "{0}/{1}/projects/{2}".format(self.baseurl, user_item.id, flow_item.id)
-        logger.info("Removing favorite {0} for user (ID: {1})".format(flow_item.id, user_item.id))
+    def delete_favorite_flow(self, user_item: UserItem, flow_item: FlowItem) -> None:
+        url = "{0}/{1}/flows/{2}".format(self.baseurl, user_item.id, flow_item.id)
+        logger.info("Removing favorite flow {0} for user (ID: {1})".format(flow_item.id, user_item.id))
+        self.delete_request(url)
+
+    @api(version="3.15")
+    def delete_favorite_metric(self, user_item: UserItem, metric_item: MetricItem) -> None:
+        url = "{0}/{1}/metrics/{2}".format(self.baseurl, user_item.id, metric_item.id)
+        logger.info("Removing favorite metric {0} for user (ID: {1})".format(metric_item.id, user_item.id))
         self.delete_request(url)

tableauserverclient/server/endpoint/fileuploads_endpoint.py

@@ -1,13 +1,10 @@
-import logging
-
 from .endpoint import Endpoint, api
-from tableauserverclient.server import RequestFactory
-from tableauserverclient.models import FileuploadItem
+from tableauserverclient import datetime_helpers as datetime
+from tableauserverclient.helpers.logging import logger
 
-# For when a datasource is over 64MB, break it into 5MB(standard chunk size) chunks
-CHUNK_SIZE = 1024 * 1024 * 5  # 5MB
-
-logger = logging.getLogger("tableau.endpoint.fileuploads")
+from tableauserverclient.config import BYTES_PER_MB, CHUNK_SIZE_MB
+from tableauserverclient.models import FileuploadItem
+from tableauserverclient.server import RequestFactory
 
 
 class Fileuploads(Endpoint):
@@ -44,7 +41,7 @@ class Fileuploads(Endpoint):
 
         try:
             while True:
-                chunked_content = file_content.read(CHUNK_SIZE)
+                chunked_content = file_content.read(CHUNK_SIZE_MB * BYTES_PER_MB)
                 if not chunked_content:
                     break
                 yield chunked_content
@@ -55,8 +52,12 @@ class Fileuploads(Endpoint):
     def upload(self, file):
         upload_id = self.initiate()
         for chunk in self._read_chunks(file):
+            logger.debug("{} processing chunk...".format(datetime.timestamp()))
             request, content_type = RequestFactory.Fileupload.chunk_req(chunk)
+            logger.debug("{} created chunk request".format(datetime.timestamp()))
             fileupload_item = self.append(upload_id, request, content_type)
-            logger.info("\tPublished {0}MB".format(fileupload_item.file_size))
+            logger.info(
+                "\t{0} Published {1}MB".format(datetime.timestamp(), (fileupload_item.file_size / BYTES_PER_MB))
+            )
         logger.info("File upload finished (ID: {0})".format(upload_id))
         return upload_id

tableauserverclient/server/endpoint/flow_runs_endpoint.py

@@ -6,7 +6,7 @@ from .exceptions import FlowRunFailedException, FlowRunCancelledException
 from tableauserverclient.models import FlowRunItem, PaginationItem
 from tableauserverclient.exponential_backoff import ExponentialBackoffTimer
 
-logger = logging.getLogger("tableau.endpoint.flowruns")
+from tableauserverclient.helpers.logging import logger
 
 if TYPE_CHECKING:
     from ..server import Server

tableauserverclient/server/endpoint/flows_endpoint.py

@@ -32,13 +32,13 @@ FILESIZE_LIMIT = 1024 * 1024 * 64  # 64MB
 
 ALLOWED_FILE_EXTENSIONS = ["tfl", "tflx"]
 
-logger = logging.getLogger("tableau.endpoint.flows")
+from tableauserverclient.helpers.logging import logger
 
 if TYPE_CHECKING:
-    from .. import DQWItem
-    from ..request_options import RequestOptions
-    from ...models.permissions_item import PermissionsRule
-    from .schedules_endpoint import AddResponse
+    from tableauserverclient.models import DQWItem
+    from tableauserverclient.models.permissions_item import PermissionsRule
+    from tableauserverclient.server.request_options import RequestOptions
+    from tableauserverclient.server.endpoint.schedules_endpoint import AddResponse
 
 
 FilePath = Union[str, os.PathLike]

tableauserverclient/server/endpoint/groups_endpoint.py

@@ -6,7 +6,7 @@ from tableauserverclient.server import RequestFactory
 from tableauserverclient.models import GroupItem, UserItem, PaginationItem, JobItem
 from ..pager import Pager
 
-logger = logging.getLogger("tableau.endpoint.groups")
+from tableauserverclient.helpers.logging import logger
 
 from typing import List, Optional, TYPE_CHECKING, Tuple, Union
 
@@ -82,14 +82,17 @@ class Groups(QuerysetEndpoint):
             )
             group_item.minimum_site_role = default_site_role
 
+        url = "{0}/{1}".format(self.baseurl, group_item.id)
+
         if not group_item.id:
             error = "Group item missing ID."
             raise MissingRequiredFieldError(error)
         if as_job and (group_item.domain_name is None or group_item.domain_name == "local"):
             error = "Local groups cannot be updated asynchronously."
             raise ValueError(error)
+        elif as_job:
+            url = "?".join([url, "asJob=True"])
 
-        url = "{0}/{1}".format(self.baseurl, group_item.id)
         update_req = RequestFactory.Group.update_req(group_item, None)
         server_response = self.put_request(url, update_req)
         logger.info("Updated group item (ID: {0})".format(group_item.id))

tableauserverclient/server/endpoint/jobs_endpoint.py

@@ -6,7 +6,7 @@ from tableauserverclient.models import JobItem, BackgroundJobItem, PaginationIte
 from ..request_options import RequestOptionsBase
 from tableauserverclient.exponential_backoff import ExponentialBackoffTimer
 
-logger = logging.getLogger("tableau.endpoint.jobs")
+from tableauserverclient.helpers.logging import logger
 
 from typing import List, Optional, Tuple, Union
 

tableauserverclient/server/endpoint/metadata_endpoint.py

@@ -4,7 +4,7 @@ import logging
 from .endpoint import Endpoint, api
 from .exceptions import GraphQLError, InvalidGraphQLQuery
 
-logger = logging.getLogger("tableau.endpoint.metadata")
+from tableauserverclient.helpers.logging import logger
 
 
 def is_valid_paged_query(parsed_query):

tableauserverclient/server/endpoint/metrics_endpoint.py

@@ -15,7 +15,7 @@ if TYPE_CHECKING:
     from ...server import Server
 
 
-logger = logging.getLogger("tableau.endpoint.metrics")
+from tableauserverclient.helpers.logging import logger
 
 
 class Metrics(QuerysetEndpoint):

tableauserverclient/server/endpoint/permissions_endpoint.py

@@ -8,7 +8,7 @@ from .exceptions import MissingRequiredFieldError
 
 from typing import Callable, TYPE_CHECKING, List, Optional, Union
 
-logger = logging.getLogger(__name__)
+from tableauserverclient.helpers.logging import logger
 
 if TYPE_CHECKING:
     from ..server import Server

tableauserverclient/server/endpoint/projects_endpoint.py

@@ -13,7 +13,7 @@ if TYPE_CHECKING:
     from ..server import Server
     from ..request_options import RequestOptions
 
-logger = logging.getLogger("tableau.endpoint.projects")
+from tableauserverclient.helpers.logging import logger
 
 
 class Projects(QuerysetEndpoint):
@@ -63,6 +63,8 @@ class Projects(QuerysetEndpoint):
     def create(self, project_item: ProjectItem, samples: bool = False) -> ProjectItem:
         params = {"params": {RequestOptions.Field.PublishSamples: samples}}
         url = self.baseurl
+        if project_item._samples:
+            url = "{0}?publishSamples={1}".format(self.baseurl, project_item._samples)
         create_req = RequestFactory.Project.create_req(project_item)
         server_response = self.post_request(url, create_req, XML_CONTENT_TYPE, params)
         new_project = ProjectItem.from_response(server_response.content, self.parent_srv.namespace)[0]

tableauserverclient/server/endpoint/resource_tagger.py

@@ -1,13 +1,13 @@
 import copy
-import logging
 import urllib.parse
 
 from .endpoint import Endpoint
-from .exceptions import EndpointUnavailableError, ServerResponseError
+from .exceptions import ServerResponseError
+from ..exceptions import EndpointUnavailableError
 from tableauserverclient.server import RequestFactory
 from tableauserverclient.models import TagItem
 
-logger = logging.getLogger("tableau.endpoint.resource_tagger")
+from tableauserverclient.helpers.logging import logger
 
 
 class _ResourceTagger(Endpoint):

tableauserverclient/server/endpoint/schedules_endpoint.py

@@ -9,7 +9,8 @@ from .exceptions import MissingRequiredFieldError
 from tableauserverclient.server import RequestFactory
 from tableauserverclient.models import PaginationItem, ScheduleItem, TaskItem
 
-logger = logging.getLogger("tableau.endpoint.schedules")
+from tableauserverclient.helpers.logging import logger
+
 AddResponse = namedtuple("AddResponse", ("result", "error", "warnings", "task_created"))
 OK = AddResponse(result=True, error=None, warnings=None, task_created=None)
 

tableauserverclient/server/endpoint/server_info_endpoint.py

@@ -1,15 +1,13 @@
 import logging
 
 from .endpoint import Endpoint, api
-from .exceptions import (
-    ServerResponseError,
+from .exceptions import ServerResponseError
+from ..exceptions import (
     ServerInfoEndpointNotFoundError,
     EndpointUnavailableError,
 )
 from tableauserverclient.models import ServerInfoItem
 
-logger = logging.getLogger("tableau.endpoint.server_info")
-
 
 class ServerInfo(Endpoint):
     def __init__(self, server):

tableauserverclient/server/endpoint/sites_endpoint.py

@@ -6,7 +6,7 @@ from .exceptions import MissingRequiredFieldError
 from tableauserverclient.server import RequestFactory
 from tableauserverclient.models import SiteItem, PaginationItem
 
-logger = logging.getLogger("tableau.endpoint.sites")
+from tableauserverclient.helpers.logging import logger
 
 from typing import TYPE_CHECKING, List, Optional, Tuple
 

tableauserverclient/server/endpoint/subscriptions_endpoint.py

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

tableauserverclient/server/endpoint/tables_endpoint.py

@@ -8,7 +8,7 @@ from tableauserverclient.server import RequestFactory
 from tableauserverclient.models import TableItem, ColumnItem, PaginationItem
 from ..pager import Pager
 
-logger = logging.getLogger("tableau.endpoint.tables")
+from tableauserverclient.helpers.logging import logger
 
 
 class Tables(Endpoint):

tableauserverclient/server/endpoint/tasks_endpoint.py

@@ -5,7 +5,7 @@ from .exceptions import MissingRequiredFieldError
 from tableauserverclient.models import TaskItem, PaginationItem
 from tableauserverclient.server import RequestFactory
 
-logger = logging.getLogger("tableau.endpoint.tasks")
+from tableauserverclient.helpers.logging import logger
 
 
 class Tasks(Endpoint):
@@ -51,6 +51,17 @@ class Tasks(Endpoint):
         server_response = self.get_request(url)
         return TaskItem.from_response(server_response.content, self.parent_srv.namespace)[0]
 
+    @api(version="3.19")
+    def create(self, extract_item: TaskItem) -> TaskItem:
+        if not extract_item:
+            error = "No extract refresh provided"
+            raise ValueError(error)
+        logger.info("Creating an extract refresh ({})".format(extract_item))
+        url = "{0}/{1}".format(self.baseurl, self.__normalize_task_type(TaskItem.Type.ExtractRefresh))
+        create_req = RequestFactory.Task.create_extract_req(extract_item)
+        server_response = self.post_request(url, create_req)
+        return server_response.content
+
     @api(version="2.6")
     def run(self, task_item):
         if not task_item.id:

tableauserverclient/server/endpoint/users_endpoint.py

@@ -8,7 +8,7 @@ from tableauserverclient.server import RequestFactory, RequestOptions
 from tableauserverclient.models import UserItem, WorkbookItem, PaginationItem, GroupItem
 from ..pager import Pager
 
-logger = logging.getLogger("tableau.endpoint.users")
+from tableauserverclient.helpers.logging import logger
 
 
 class Users(QuerysetEndpoint):

tableauserverclient/server/endpoint/views_endpoint.py

@@ -7,7 +7,7 @@ from .permissions_endpoint import _PermissionsEndpoint
 from .resource_tagger import _ResourceTagger
 from tableauserverclient.models import ViewItem, PaginationItem
 
-logger = logging.getLogger("tableau.endpoint.views")
+from tableauserverclient.helpers.logging import logger
 
 from typing import Iterator, List, Optional, Tuple, TYPE_CHECKING
 

tableauserverclient/server/endpoint/webhooks_endpoint.py

@@ -4,7 +4,7 @@ from .endpoint import Endpoint, api
 from tableauserverclient.server import RequestFactory
 from tableauserverclient.models import WebhookItem, PaginationItem
 
-logger = logging.getLogger("tableau.endpoint.webhooks")
+from tableauserverclient.helpers.logging import logger
 
 from typing import List, Optional, TYPE_CHECKING, Tuple
 

tableauserverclient/server/endpoint/workbooks_endpoint.py

@@ -44,7 +44,8 @@ FILESIZE_LIMIT = 1024 * 1024 * 64  # 64MB
 
 ALLOWED_FILE_EXTENSIONS = ["twb", "twbx"]
 
-logger = logging.getLogger("tableau.endpoint.workbooks")
+from tableauserverclient.helpers.logging import logger
+
 FilePath = Union[str, os.PathLike]
 FileObject = Union[io.BufferedReader, io.BytesIO]
 FileObjectR = Union[io.BufferedReader, io.BytesIO]
@@ -309,6 +310,7 @@ class Workbooks(QuerysetEndpoint):
         as_job: bool = False,
         hidden_views: Optional[Sequence[str]] = None,
         skip_connection_check: bool = False,
+        parameters=None,
     ):
         if connection_credentials is not None:
             import warnings
@@ -412,7 +414,7 @@ class Workbooks(QuerysetEndpoint):
 
         # Send the publishing request to server
         try:
-            server_response = self.post_request(url, xml_request, content_type)
+            server_response = self.post_request(url, xml_request, content_type, parameters)
         except InternalServerError as err:
             if err.code == 504 and not as_job:
                 err.content = "Timeout error while publishing. Please use asynchronous publishing to avoid timeouts."

tableauserverclient/server/exceptions.py

@@ -1,2 +1,9 @@
-class NotSignedInError(Exception):
+# These errors can be thrown without even talking to Tableau Server
+
+
+class ServerInfoEndpointNotFoundError(Exception):
+    pass
+
+
+class EndpointUnavailableError(Exception):
     pass

tableauserverclient/server/filter.py

@@ -11,7 +11,11 @@ class Filter(object):
     def __str__(self):
         value_string = str(self._value)
         if isinstance(self._value, list):
-            value_string = value_string.replace(" ", "").replace("'", "")
+            # this should turn the string representation of the list
+            # from ['<string1>', '<string2>', ...]
+            # to [<string1>,<string2>]
+            # so effectively, remove any spaces between "," and "'" and then remove all "'"
+            value_string = value_string.replace(", '", ",'").replace("'", "")
         return "{0}:{1}:{2}".format(self.field, self.operator, value_string)
 
     @property