Merge branch 'development' into bcantoni/pytest-parallel

Author: jacalata

pyproject.toml

@@ -15,7 +15,7 @@ dependencies = [
     'defusedxml>=0.7.1',  # latest as at 7/31/23
     'packaging>=23.1',   # latest as at 7/31/23
     'requests>=2.32',  # latest as at 7/31/23
-    'urllib3>=2.2.2,<3',
+    'urllib3>=2.6.0,<3',
     'typing_extensions>=4.0',
 ]
 requires-python = ">=3.9"
@@ -32,7 +32,7 @@ classifiers = [
 repository = "https://github.com/tableau/server-client-python"
 
 [project.optional-dependencies]
-test = ["black==24.8", "build", "mypy==1.4", "pytest>=7.0", "pytest-cov", "pytest-subtests",
+test = ["black==24.10", "build", "mypy==1.4", "pytest>=7.0", "pytest-cov", "pytest-subtests",
     "pytest-xdist", "requests-mock>=1.0,<2.0", "types-requests>=2.32.4.20250913"]
 [tool.black]
 line-length = 120

tableauserverclient/models/schedule_item.py

@@ -1,6 +1,6 @@
 import xml.etree.ElementTree as ET
 from datetime import datetime
-from typing import Optional, Union
+from typing import Optional, Union, TYPE_CHECKING
 
 from defusedxml.ElementTree import fromstring
 
@@ -16,6 +16,10 @@
     property_is_enum,
 )
 
+if TYPE_CHECKING:
+    from requests import Response
+
+
 Interval = Union[HourlyInterval, DailyInterval, WeeklyInterval, MonthlyInterval]
 
 
@@ -407,3 +411,8 @@ def _read_warnings(parsed_response, ns):
         for warning_xml in all_warning_xml:
             warnings.append(warning_xml.get("message", None))
         return warnings
+
+
+def parse_batch_schedule_state(response: "Response", ns) -> list[str]:
+    xml = fromstring(response.content)
+    return [text for tag in xml.findall(".//t:scheduleLuid", namespaces=ns) if (text := tag.text)]

tableauserverclient/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 @@ def get_extract_refresh_tasks(
         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)

tableauserverclient/server/endpoint/views_endpoint.py

@@ -371,6 +371,29 @@ def update(self, view_item: ViewItem) -> ViewItem:
         # Returning view item to stay consistent with datasource/view update functions
         return view_item
 
+    @api(version="3.27")
+    def delete(self, view: ViewItem | str) -> None:
+        """
+        Deletes a view in a workbook. If you delete the only view in a workbook,
+        the workbook is deleted. Can be used to remove hidden views when
+        republishing or migrating to a different environment.
+
+        REST API: https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref_workbooks_and_views.htm#delete_view
+
+        Parameters
+        ----------
+        view: ViewItem | str
+            The ViewItem or the luid for the view to be deleted.
+
+        Returns
+        -------
+        None
+        """
+        id_ = getattr(view, "id", view)
+        self.delete_request(f"{self.baseurl}/{id_}")
+        logger.info(f"View({id_}) deleted.")
+        return None
+
     @api(version="1.0")
     def add_tags(self, item: Union[ViewItem, str], tags: Union[Iterable[str], str]) -> set[str]:
         """

tableauserverclient/server/request_factory.py

@@ -643,6 +643,16 @@ def add_datasource_req(self, id_: Optional[str], task_type: str = TaskItem.Type.
     def add_flow_req(self, id_: Optional[str], task_type: str = TaskItem.Type.RunFlow) -> bytes:
         return self._add_to_req(id_, "flow", task_type)
 
+    @_tsrequest_wrapped
+    def batch_update_state(self, xml: ET.Element, schedules: Iterable[ScheduleItem | str]) -> None:
+        luids = ET.SubElement(xml, "scheduleLuids")
+        for schedule in schedules:
+            luid = getattr(schedule, "id", schedule)
+            if not isinstance(luid, str):
+                continue
+            luid_tag = ET.SubElement(luids, "scheduleLuid")
+            luid_tag.text = luid
+
 
 class SiteRequest:
     def update_req(self, site_item: "SiteItem", parent_srv: Optional["Server"] = None):

test/assets/schedule_batch_update_state.xml

@@ -0,0 +1,7 @@
+<tsResponse xmlns="http://tableau.com/api" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://tableau.com/api http://tableau.com/api/ts-api-2.3.xsd">
+  <scheduleLuids>
+    <scheduleLuid>593d2ebf-0d18-4deb-9d21-b113a4902583</scheduleLuid>
+    <scheduleLuid>cecbb71e-def0-4030-8068-5ae50f51db1c</scheduleLuid>
+    <scheduleLuid>f39a6e7d-405e-4c07-8c18-95845f9da80e</scheduleLuid>
+  </scheduleLuids>
+</tsResponse>

test/http/test_http_requests.py

@@ -1,3 +1,4 @@
+import pytest
 import tableauserverclient as TSC
 import unittest
 import requests
@@ -27,91 +28,103 @@ def __init__(self, status_code):
     return MockResponse(200)
 
 
-class ServerTests(unittest.TestCase):
-    def test_init_server_model_empty_throws(self):
-        with self.assertRaises(TypeError):
-            server = TSC.Server()
-
-    def test_init_server_model_no_protocol_defaults_htt(self):
-        server = TSC.Server("fake-url")
-
-    def test_init_server_model_valid_server_name_works(self):
-        server = TSC.Server("http://fake-url")
-
-    def test_init_server_model_valid_https_server_name_works(self):
-        # by default, it will just set the version to 2.3
-        server = TSC.Server("https://fake-url")
-
-    def test_init_server_model_bad_server_name_not_version_check(self):
-        server = TSC.Server("fake-url", use_server_version=False)
-
-    @mock.patch("requests.sessions.Session.get", side_effect=mocked_requests_get)
-    def test_init_server_model_bad_server_name_do_version_check(self, mock_get):
-        server = TSC.Server("fake-url", use_server_version=True)
-
-    def test_init_server_model_bad_server_name_not_version_check_random_options(self):
-        # with self.assertRaises(MissingSchema):
-        server = TSC.Server("fake-url", use_server_version=False, http_options={"foo": 1})
-
-    def test_init_server_model_bad_server_name_not_version_check_real_options(self):
-        # with self.assertRaises(ValueError):
-        server = TSC.Server("fake-url", use_server_version=False, http_options={"verify": False})
-
-    def test_http_options_skip_ssl_works(self):
-        http_options = {"verify": False}
-        server = TSC.Server("http://fake-url")
-        server.add_http_options(http_options)
-
-    def test_http_options_multiple_options_works(self):
-        http_options = {"verify": False, "birdname": "Parrot"}
-        server = TSC.Server("http://fake-url")
-        server.add_http_options(http_options)
-
-    # ValueError: dictionary update sequence element #0 has length 1; 2 is required
-    def test_http_options_multiple_dicts_fails(self):
-        http_options_1 = {"verify": False}
-        http_options_2 = {"birdname": "Parrot"}
-        server = TSC.Server("http://fake-url")
-        with self.assertRaises(ValueError):
-            server.add_http_options([http_options_1, http_options_2])
-
-    # TypeError: cannot convert dictionary update sequence element #0 to a sequence
-    def test_http_options_not_sequence_fails(self):
-        server = TSC.Server("http://fake-url")
-        with self.assertRaises(ValueError):
-            server.add_http_options({1, 2, 3})
-
-    def test_validate_connection_http(self):
-        url = "http://cookies.com"
-        server = TSC.Server(url)
-        server.validate_connection_settings()
-        self.assertEqual(url, server.server_address)
-
-    def test_validate_connection_https(self):
-        url = "https://cookies.com"
-        server = TSC.Server(url)
-        server.validate_connection_settings()
-        self.assertEqual(url, server.server_address)
-
-    def test_validate_connection_no_protocol(self):
-        url = "cookies.com"
-        fixed_url = "http://cookies.com"
-        server = TSC.Server(url)
-        server.validate_connection_settings()
-        self.assertEqual(fixed_url, server.server_address)
-
-
-class SessionTests(unittest.TestCase):
-    test_header = {"x-test": "true"}
-
-    @staticmethod
-    def session_factory():
-        session = requests.session()
-        session.headers.update(SessionTests.test_header)
-        return session
-
-    def test_session_factory_adds_headers(self):
-        test_request_bin = "http://capture-this-with-mock.com"
-        with requests_mock.mock() as m:
-            m.get(url="http://capture-this-with-mock.com/api/2.4/serverInfo", request_headers=SessionTests.test_header)
-            server = TSC.Server(test_request_bin, use_server_version=True, session_factory=SessionTests.session_factory)
+def test_init_server_model_empty_throws():
+    with pytest.raises(TypeError):
+        server = TSC.Server()
+
+
+def test_init_server_model_no_protocol_defaults_htt():
+    server = TSC.Server("fake-url")
+
+
+def test_init_server_model_valid_server_name_works():
+    server = TSC.Server("http://fake-url")
+
+
+def test_init_server_model_valid_https_server_name_works():
+    # by default, it will just set the version to 2.3
+    server = TSC.Server("https://fake-url")
+
+
+def test_init_server_model_bad_server_name_not_version_check():
+    server = TSC.Server("fake-url", use_server_version=False)
+
+
+@mock.patch("requests.sessions.Session.get", side_effect=mocked_requests_get)
+def test_init_server_model_bad_server_name_do_version_check(mock_get):
+    server = TSC.Server("fake-url", use_server_version=True)
+
+
+def test_init_server_model_bad_server_name_not_version_check_random_options():
+    server = TSC.Server("fake-url", use_server_version=False, http_options={"foo": 1})
+
+
+def test_init_server_model_bad_server_name_not_version_check_real_options():
+    server = TSC.Server("fake-url", use_server_version=False, http_options={"verify": False})
+
+
+def test_http_options_skip_ssl_works():
+    http_options = {"verify": False}
+    server = TSC.Server("http://fake-url")
+    server.add_http_options(http_options)
+
+
+def test_http_options_multiple_options_works():
+    http_options = {"verify": False, "birdname": "Parrot"}
+    server = TSC.Server("http://fake-url")
+    server.add_http_options(http_options)
+
+
+# ValueError: dictionary update sequence element #0 has length 1; 2 is required
+def test_http_options_multiple_dicts_fails():
+    http_options_1 = {"verify": False}
+    http_options_2 = {"birdname": "Parrot"}
+    server = TSC.Server("http://fake-url")
+    with pytest.raises(ValueError):
+        server.add_http_options([http_options_1, http_options_2])
+
+
+# TypeError: cannot convert dictionary update sequence element #0 to a sequence
+def test_http_options_not_sequence_fails():
+    server = TSC.Server("http://fake-url")
+    with pytest.raises(ValueError):
+        server.add_http_options({1, 2, 3})
+
+
+def test_validate_connection_http():
+    url = "http://cookies.com"
+    server = TSC.Server(url)
+    server.validate_connection_settings()
+    assert url == server.server_address
+
+
+def test_validate_connection_https():
+    url = "https://cookies.com"
+    server = TSC.Server(url)
+    server.validate_connection_settings()
+    assert url == server.server_address
+
+
+def test_validate_connection_no_protocol():
+    url = "cookies.com"
+    fixed_url = "http://cookies.com"
+    server = TSC.Server(url)
+    server.validate_connection_settings()
+    assert fixed_url == server.server_address
+
+
+test_header = {"x-test": "true"}
+
+
+@pytest.fixture
+def session_factory() -> requests.Session:
+    session = requests.session()
+    session.headers.update(test_header)
+    return session
+
+
+def test_session_factory_adds_headers(session_factory):
+    test_request_bin = "http://capture-this-with-mock.com"
+    with requests_mock.mock() as m:
+        m.get(url="http://capture-this-with-mock.com/api/2.4/serverInfo", request_headers=test_header)
+        server = TSC.Server(test_request_bin, use_server_version=True, session_factory=lambda: session_factory)

test/request_factory/test_datasource_requests.py

@@ -1,15 +1,13 @@
-import unittest
 import tableauserverclient as TSC
 import tableauserverclient.server.request_factory as TSC_RF
 from tableauserverclient import DatasourceItem
 
 
-class DatasourceRequestTests(unittest.TestCase):
-    def test_generate_xml(self):
-        datasource_item: TSC.DatasourceItem = TSC.DatasourceItem("name")
-        datasource_item.name = "a ds"
-        datasource_item.description = "described"
-        datasource_item.use_remote_query_agent = False
-        datasource_item.ask_data_enablement = DatasourceItem.AskDataEnablement.Enabled
-        datasource_item.project_id = "testval"
-        TSC_RF.RequestFactory.Datasource._generate_xml(datasource_item)
+def test_generate_xml():
+    datasource_item: TSC.DatasourceItem = TSC.DatasourceItem("name")
+    datasource_item.name = "a ds"
+    datasource_item.description = "described"
+    datasource_item.use_remote_query_agent = False
+    datasource_item.ask_data_enablement = DatasourceItem.AskDataEnablement.Enabled
+    datasource_item.project_id = "testval"
+    TSC_RF.RequestFactory.Datasource._generate_xml(datasource_item)