tableauserverclient 0.38__py3-none-any.whl → 0.39__py3-none-any.whl

{tableauserverclient/server → server}/endpoint/datasources_endpoint.py

@@ -6,8 +6,8 @@ import os
 
 from contextlib import closing
 from pathlib import Path
-from typing import Literal, Optional, TYPE_CHECKING, Union, overload
-from collections.abc import Iterable, Mapping, Sequence
+from typing import Literal, Optional, TYPE_CHECKING, TypedDict, TypeVar, Union, overload
+from collections.abc import Iterable, Sequence
 
 from tableauserverclient.helpers.headers import fix_filename
 from tableauserverclient.models.dqw_item import DQWItem
@@ -50,13 +50,50 @@ FilePath = Union[str, os.PathLike]
 FileObject = Union[io.BufferedReader, io.BytesIO]
 PathOrFile = Union[FilePath, FileObject]
 
-FilePath = Union[str, os.PathLike]
 FileObjectR = Union[io.BufferedReader, io.BytesIO]
 FileObjectW = Union[io.BufferedWriter, io.BytesIO]
 PathOrFileR = Union[FilePath, FileObjectR]
 PathOrFileW = Union[FilePath, FileObjectW]
 
 
+HyperActionCondition = TypedDict(
+    "HyperActionCondition",
+    {
+        "op": str,
+        "target-col": str,
+        "source-col": str,
+    },
+)
+
+HyperActionRow = TypedDict(
+    "HyperActionRow",
+    {
+        "action": Literal[
+            "update",
+            "upsert",
+            "delete",
+        ],
+        "source-table": str,
+        "target-table": str,
+        "condition": HyperActionCondition,
+    },
+)
+
+HyperActionTable = TypedDict(
+    "HyperActionTable",
+    {
+        "action": Literal[
+            "insert",
+            "replace",
+        ],
+        "source-table": str,
+        "target-table": str,
+    },
+)
+
+HyperAction = Union[HyperActionTable, HyperActionRow]
+
+
 class Datasources(QuerysetEndpoint[DatasourceItem], TaggingMixin[DatasourceItem]):
     def __init__(self, parent_srv: "Server") -> None:
         super().__init__(parent_srv)
@@ -191,16 +228,34 @@ class Datasources(QuerysetEndpoint[DatasourceItem], TaggingMixin[DatasourceItem]
         self.delete_request(url)
         logger.info(f"Deleted single datasource (ID: {datasource_id})")
 
+    T = TypeVar("T", bound=FileObjectW)
+
+    @overload
+    def download(
+        self,
+        datasource_id: str,
+        filepath: T,
+        include_extract: bool = True,
+    ) -> T: ...
+
+    @overload
+    def download(
+        self,
+        datasource_id: str,
+        filepath: Optional[FilePath] = None,
+        include_extract: bool = True,
+    ) -> str: ...
+
     # Download 1 datasource by id
     @api(version="2.0")
     @parameter_added_in(no_extract="2.5")
     @parameter_added_in(include_extract="2.5")
     def download(
         self,
-        datasource_id: str,
-        filepath: Optional[PathOrFileW] = None,
-        include_extract: bool = True,
-    ) -> PathOrFileW:
+        datasource_id,
+        filepath=None,
+        include_extract=True,
+    ):
         """
         Downloads the specified data source from a site. The data source is
         downloaded as a .tdsx file.
@@ -319,8 +374,63 @@ class Datasources(QuerysetEndpoint[DatasourceItem], TaggingMixin[DatasourceItem]
         logger.info(f"Updated datasource item (ID: {datasource_item.id} & connection item {connection_item.id}")
         return connection
 
+    @api(version="3.26")
+    def update_connections(
+        self,
+        datasource_item: DatasourceItem,
+        connection_luids: Iterable[str],
+        authentication_type: str,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        embed_password: Optional[bool] = None,
+    ) -> list[ConnectionItem]:
+        """
+        Bulk updates one or more datasource connections by LUID.
+
+        Parameters
+        ----------
+        datasource_item : DatasourceItem
+            The datasource item containing the connections.
+
+        connection_luids : Iterable of str
+            The connection LUIDs to update.
+
+        authentication_type : str
+            The authentication type to use (e.g., 'auth-keypair').
+
+        username : str, optional
+            The username to set.
+
+        password : str, optional
+            The password or secret to set.
+
+        embed_password : bool, optional
+            Whether to embed the password.
+
+        Returns
+        -------
+        Iterable of str
+            The connection LUIDs that were updated.
+        """
+
+        url = f"{self.baseurl}/{datasource_item.id}/connections"
+
+        request_body = RequestFactory.Datasource.update_connections_req(
+            connection_luids=connection_luids,
+            authentication_type=authentication_type,
+            username=username,
+            password=password,
+            embed_password=embed_password,
+        )
+        server_response = self.put_request(url, request_body)
+        connection_items = ConnectionItem.from_response(server_response.content, self.parent_srv.namespace)
+        updated_ids: list[str] = [conn.id for conn in connection_items]
+
+        logger.info(f"Updated connections for datasource {datasource_item.id}: {', '.join(updated_ids)}")
+        return connection_items
+
     @api(version="2.8")
-    def refresh(self, datasource_item: DatasourceItem, incremental: bool = False) -> JobItem:
+    def refresh(self, datasource_item: Union[DatasourceItem, str], incremental: bool = False) -> JobItem:
         """
         Refreshes the extract of an existing workbook.
 
@@ -328,8 +438,8 @@ class Datasources(QuerysetEndpoint[DatasourceItem], TaggingMixin[DatasourceItem]
 
         Parameters
         ----------
-        workbook_item : WorkbookItem | str
-            The workbook item or workbook ID.
+        workbook_item : DatasourceItem | str
+            The datasource item or datasource ID.
         incremental: bool
             Whether to do a full refresh or incremental refresh of the extract data
 
@@ -424,13 +534,13 @@ class Datasources(QuerysetEndpoint[DatasourceItem], TaggingMixin[DatasourceItem]
     @parameter_added_in(as_job="3.0")
     def publish(
         self,
-        datasource_item: DatasourceItem,
-        file: PathOrFileR,
-        mode: str,
-        connection_credentials: Optional[ConnectionCredentials] = None,
-        connections: Optional[Sequence[ConnectionItem]] = None,
-        as_job: bool = False,
-    ) -> Union[DatasourceItem, JobItem]:
+        datasource_item,
+        file,
+        mode,
+        connection_credentials=None,
+        connections=None,
+        as_job=False,
+    ):
         """
         Publishes a data source to a server, or appends data to an existing
         data source.
@@ -576,7 +686,7 @@ class Datasources(QuerysetEndpoint[DatasourceItem], TaggingMixin[DatasourceItem]
         datasource_or_connection_item: Union[DatasourceItem, ConnectionItem, str],
         *,
         request_id: str,
-        actions: Sequence[Mapping],
+        actions: Sequence[HyperAction],
         payload: Optional[FilePath] = None,
     ) -> JobItem:
         """
@@ -843,15 +953,35 @@ class Datasources(QuerysetEndpoint[DatasourceItem], TaggingMixin[DatasourceItem]
         revisions = RevisionItem.from_response(server_response.content, self.parent_srv.namespace, datasource_item)
         return revisions
 
-    # Download 1 datasource revision by revision number
-    @api(version="2.3")
+    T = TypeVar("T", bound=FileObjectW)
+
+    @overload
     def download_revision(
         self,
         datasource_id: str,
         revision_number: Optional[str],
-        filepath: Optional[PathOrFileW] = None,
+        filepath: T,
         include_extract: bool = True,
-    ) -> PathOrFileW:
+    ) -> T: ...
+
+    @overload
+    def download_revision(
+        self,
+        datasource_id: str,
+        revision_number: Optional[str],
+        filepath: Optional[FilePath] = None,
+        include_extract: bool = True,
+    ) -> str: ...
+
+    # Download 1 datasource revision by revision number
+    @api(version="2.3")
+    def download_revision(
+        self,
+        datasource_id,
+        revision_number,
+        filepath=None,
+        include_extract=True,
+    ):
         """
         Downloads a specific version of a data source prior to the current one
         in .tdsx format. To download the current version of a data source set

server/endpoint/extensions_endpoint.py

@@ -0,0 +1,79 @@
+from tableauserverclient.models.extensions_item import ExtensionsServer, ExtensionsSiteSettings
+from tableauserverclient.server.endpoint.endpoint import Endpoint
+from tableauserverclient.server.endpoint.endpoint import api
+from tableauserverclient.server.request_factory import RequestFactory
+
+
+class Extensions(Endpoint):
+    def __init__(self, parent_srv):
+        super().__init__(parent_srv)
+
+    @property
+    def _server_baseurl(self) -> str:
+        return f"{self.parent_srv.baseurl}/settings/extensions"
+
+    @property
+    def baseurl(self) -> str:
+        return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/settings/extensions"
+
+    @api(version="3.21")
+    def get_server_settings(self) -> ExtensionsServer:
+        """Lists the settings for extensions of a server
+
+        Returns
+        -------
+        ExtensionsServer
+            The server extensions settings
+        """
+        response = self.get_request(self._server_baseurl)
+        return ExtensionsServer.from_response(response.content, self.parent_srv.namespace)
+
+    @api(version="3.21")
+    def update_server_settings(self, extensions_server: ExtensionsServer) -> ExtensionsServer:
+        """Updates the settings for extensions of a server. Overwrites all existing settings. Any
+        sites omitted from the block list will be unblocked.
+
+        Parameters
+        ----------
+        extensions_server : ExtensionsServer
+            The server extensions settings to update
+
+        Returns
+        -------
+        ExtensionsServer
+            The updated server extensions settings
+        """
+        req = RequestFactory.Extensions.update_server_extensions(extensions_server)
+        response = self.put_request(self._server_baseurl, req)
+        return ExtensionsServer.from_response(response.content, self.parent_srv.namespace)
+
+    @api(version="3.21")
+    def get(self) -> ExtensionsSiteSettings:
+        """Lists the extensions settings for the site
+
+        Returns
+        -------
+        ExtensionsSiteSettings
+            The site extensions settings
+        """
+        response = self.get_request(self.baseurl)
+        return ExtensionsSiteSettings.from_response(response.content, self.parent_srv.namespace)
+
+    @api(version="3.21")
+    def update(self, extensions_site_settings: ExtensionsSiteSettings) -> ExtensionsSiteSettings:
+        """Updates the extensions settings for the site. Any extensions omitted
+        from the safe extensions list will be removed.
+
+        Parameters
+        ----------
+        extensions_site_settings : ExtensionsSiteSettings
+            The site extensions settings to update
+
+        Returns
+        -------
+        ExtensionsSiteSettings
+            The updated site extensions settings
+        """
+        req = RequestFactory.Extensions.update_site_extensions(extensions_site_settings)
+        response = self.put_request(self.baseurl, req)
+        return ExtensionsSiteSettings.from_response(response.content, self.parent_srv.namespace)

{tableauserverclient/server → server}/endpoint/flow_task_endpoint.py

@@ -18,7 +18,7 @@ class FlowTasks(Endpoint):
         return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/tasks/flows"
 
     @api(version="3.22")
-    def create(self, flow_item: TaskItem) -> TaskItem:
+    def create(self, flow_item: TaskItem) -> bytes:
         if not flow_item:
             error = "No flow provided"
             raise ValueError(error)

{tableauserverclient/server → server}/endpoint/flows_endpoint.py

@@ -308,7 +308,7 @@ class Flows(QuerysetEndpoint[FlowItem], TaggingMixin[FlowItem]):
         return connection
 
     @api(version="3.3")
-    def refresh(self, flow_item: FlowItem) -> JobItem:
+    def refresh(self, flow_item: Union[FlowItem, str]) -> JobItem:
         """
         Runs the flow to refresh the data.
 
@@ -316,15 +316,16 @@ class Flows(QuerysetEndpoint[FlowItem], TaggingMixin[FlowItem]):
 
         Parameters
         ----------
-        flow_item: FlowItem
-            The flow item to refresh.
+        flow_item: FlowItem | str
+            The FlowItem or str of the flow id to refresh.
 
         Returns
         -------
         JobItem
             The job item that was created to refresh the flow.
         """
-        url = f"{self.baseurl}/{flow_item.id}/run"
+        flow_id = getattr(flow_item, "id", flow_item)
+        url = f"{self.baseurl}/{flow_id}/run"
         empty_req = RequestFactory.Empty.empty_req()
         server_response = self.post_request(url, empty_req)
         new_job = JobItem.from_response(server_response.content, self.parent_srv.namespace)[0]

server/endpoint/oidc_endpoint.py

@@ -0,0 +1,157 @@
+from typing import Protocol, Union, TYPE_CHECKING
+from tableauserverclient.models.oidc_item import SiteOIDCConfiguration
+from tableauserverclient.server.endpoint import Endpoint
+from tableauserverclient.server.request_factory import RequestFactory
+from tableauserverclient.server.endpoint.endpoint import api
+
+if TYPE_CHECKING:
+    from tableauserverclient.models.site_item import SiteAuthConfiguration
+    from tableauserverclient.server.server import Server
+
+
+class IDPAttributes(Protocol):
+    idp_configuration_id: str
+
+
+class IDPProperty(Protocol):
+    @property
+    def idp_configuration_id(self) -> str: ...
+
+
+HasIdpConfigurationID = Union[str, IDPAttributes]
+
+
+class OIDC(Endpoint):
+    def __init__(self, server: "Server") -> None:
+        self.parent_srv = server
+
+    @property
+    def baseurl(self) -> str:
+        return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/site-oidc-configuration"
+
+    @api(version="3.24")
+    def get(self) -> list["SiteAuthConfiguration"]:
+        """
+        Get all OpenID Connect (OIDC) configurations for the currently
+        authenticated Tableau Cloud site. To get all of the configuration
+        details, use the get_by_id method.
+
+        REST API: https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref_identity_pools.htm#AuthnService_ListAuthConfigurations
+
+        Returns
+        -------
+        list[SiteAuthConfiguration]
+        """
+        return self.parent_srv.sites.list_auth_configurations()
+
+    @api(version="3.24")
+    def get_by_id(self, id: Union[str, HasIdpConfigurationID]) -> SiteOIDCConfiguration:
+        """
+        Get details about a specific OpenID Connect (OIDC) configuration on the
+        current Tableau Cloud site. Only retrieves configurations for the
+        currently authenticated site.
+
+        REST API: https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref_openid_connect.htm#get_openid_connect_configuration
+
+        Parameters
+        ----------
+        id : Union[str, HasID]
+            The ID of the OIDC configuration to retrieve. Can be either the
+            ID string or an object with an id attribute.
+
+        Returns
+        -------
+        SiteOIDCConfiguration
+            The OIDC configuration for the specified site.
+        """
+        target = getattr(id, "idp_configuration_id", id)
+        url = f"{self.baseurl}/{target}"
+        response = self.get_request(url)
+        return SiteOIDCConfiguration.from_response(response.content, self.parent_srv.namespace)
+
+    @api(version="3.22")
+    def create(self, config_item: SiteOIDCConfiguration) -> SiteOIDCConfiguration:
+        """
+        Create the OpenID Connect (OIDC) configuration for the currently
+        authenticated Tableau Cloud site. The config_item must have the
+        following attributes set, others are optional:
+
+        idp_configuration_name
+        client_id
+        client_secret
+        authorization_endpoint
+        token_endpoint
+        userinfo_endpoint
+        enabled
+        jwks_uri
+
+        The secret in the returned config will be masked.
+
+        REST API: https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref_openid_connect.htm#create_openid_connect_configuration
+
+        Parameters
+        ----------
+        config : SiteOIDCConfiguration
+            The OIDC configuration to create.
+
+        Returns
+        -------
+        SiteOIDCConfiguration
+            The created OIDC configuration.
+        """
+        url = self.baseurl
+        create_req = RequestFactory.OIDC.create_req(config_item)
+        response = self.put_request(url, create_req)
+        return SiteOIDCConfiguration.from_response(response.content, self.parent_srv.namespace)
+
+    @api(version="3.24")
+    def delete_configuration(self, config: Union[str, HasIdpConfigurationID]) -> None:
+        """
+        Delete the OpenID Connect (OIDC) configuration for the currently
+        authenticated Tableau Cloud site. The config parameter can be either
+        the ID of the configuration or the configuration object itself.
+
+        **Important**: Before removing the OIDC configuration, make sure that
+        users who are set to authenticate with OIDC are set to use a different
+        authentication type. Users who are not set with a different
+        authentication type before removing the OIDC configuration will not be
+        able to sign in to Tableau Cloud.
+
+
+        REST API: https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref_openid_connect.htm#remove_openid_connect_configuration
+
+        Parameters
+        ----------
+        config : Union[str, HasID]
+            The OIDC configuration to delete. Can be either the ID of the
+            configuration or the configuration object itself.
+        """
+
+        target = getattr(config, "idp_configuration_id", config)
+
+        url = f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/disable-site-oidc-configuration?idpConfigurationId={target}"
+        _ = self.put_request(url)
+        return None
+
+    @api(version="3.22")
+    def update(self, config: SiteOIDCConfiguration) -> SiteOIDCConfiguration:
+        """
+        Update the Tableau Cloud site's OpenID Connect (OIDC) configuration. The
+        secret in the returned config will be masked.
+
+        REST API: https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref_openid_connect.htm#update_openid_connect_configuration
+
+        Parameters
+        ----------
+        config : SiteOIDCConfiguration
+            The OIDC configuration to update. Must have the id attribute set.
+
+        Returns
+        -------
+        SiteOIDCConfiguration
+            The updated OIDC configuration.
+        """
+        url = f"{self.baseurl}/{config.idp_configuration_id}"
+        update_req = RequestFactory.OIDC.update_req(config)
+        response = self.put_request(url, update_req)
+        return SiteOIDCConfiguration.from_response(response.content, self.parent_srv.namespace)

{tableauserverclient/server → server}/endpoint/projects_endpoint.py

@@ -89,6 +89,18 @@ class Projects(QuerysetEndpoint[ProjectItem]):
         self.delete_request(url)
         logger.info(f"Deleted single project (ID: {project_id})")
 
+    @api(version="2.0")
+    def get_by_id(self, project_id: str) -> ProjectItem:
+        """
+        Fetch a project by ID. This is a convenience method making up for a gap in the server API.
+        It uses the same endpoint as the update method, but without the ability to update the project.
+        """
+        if not project_id:
+            error = "Project ID undefined."
+            raise ValueError(error)
+        project = ProjectItem(id=project_id)
+        return self.update(project, samples=False)
+
     @api(version="2.0")
     def update(self, project_item: ProjectItem, samples: bool = False) -> ProjectItem:
         """

{tableauserverclient/server → server}/endpoint/schedules_endpoint.py

@@ -1,13 +1,15 @@
+from collections.abc import Iterable
 import copy
 import logging
 import warnings
 from collections import namedtuple
-from typing import TYPE_CHECKING, Callable, Optional, Union
+from typing import TYPE_CHECKING, Any, Callable, Literal, Optional, Union, overload
 
 from .endpoint import Endpoint, api, parameter_added_in
 from .exceptions import MissingRequiredFieldError
 from tableauserverclient.server import RequestFactory
 from tableauserverclient.models import PaginationItem, ScheduleItem, TaskItem, ExtractItem
+from tableauserverclient.models.schedule_item import parse_batch_schedule_state
 
 from tableauserverclient.helpers.logging import logger
 
@@ -279,3 +281,48 @@ class Schedules(Endpoint):
         extract_items = ExtractItem.from_response(server_response.content, self.parent_srv.namespace)
 
         return extract_items, pagination_item
+
+    @overload
+    def batch_update_state(
+        self,
+        schedules: Iterable[ScheduleItem | str],
+        state: Literal["active", "suspended"],
+        update_all: Literal[False] = False,
+    ) -> list[str]: ...
+
+    @overload
+    def batch_update_state(
+        self, schedules: Any, state: Literal["active", "suspended"], update_all: Literal[True]
+    ) -> list[str]: ...
+
+    @api(version="3.27")
+    def batch_update_state(self, schedules, state, update_all=False) -> list[str]:
+        """
+        Batch update the status of one or more scheudles. If update_all is set,
+        all schedules on the Tableau Server are affected.
+
+        Parameters
+        ----------
+        schedules: Iterable[ScheudleItem | str] | Any
+            The schedules to be updated. If update_all=True, this is ignored.
+
+        state: Literal["active", "suspended"]
+            The state of the schedules, whether active or suspended.
+
+        update_all: bool
+            Whether or not to apply the status to all schedules.
+
+        Returns
+        -------
+        List[str]
+            The IDs of the affected schedules.
+        """
+        params = {"state": state}
+        if update_all:
+            params["updateAll"] = "true"
+            payload = RequestFactory.Empty.empty_req()
+        else:
+            payload = RequestFactory.Schedule.batch_update_state(schedules)
+
+        response = self.put_request(self.baseurl, payload, parameters={"params": params})
+        return parse_batch_schedule_state(response, self.parent_srv.namespace)