tableauserverclient 0.33__py3-none-any.whl → 0.34__py3-none-any.whl

tableauserverclient/models/virtual_connection_item.py

@@ -1,6 +1,7 @@
 import datetime as dt
 import json
-from typing import Callable, Dict, Iterable, List, Optional
+from typing import Callable, Optional
+from collections.abc import Iterable
 from xml.etree.ElementTree import Element
 
 from defusedxml.ElementTree import fromstring
@@ -23,7 +24,7 @@ class VirtualConnectionItem:
         self._connections: Optional[Callable[[], Iterable[ConnectionItem]]] = None
         self.project_id: Optional[str] = None
         self.owner_id: Optional[str] = None
-        self.content: Optional[Dict[str, dict]] = None
+        self.content: Optional[dict[str, dict]] = None
         self.certification_note: Optional[str] = None
 
     def __str__(self) -> str:
@@ -40,7 +41,7 @@ class VirtualConnectionItem:
         return self._id
 
     @property
-    def permissions(self) -> List[PermissionsRule]:
+    def permissions(self) -> list[PermissionsRule]:
         if self._permissions is None:
             error = "Workbook item must be populated with permissions first."
             raise UnpopulatedPropertyError(error)
@@ -53,12 +54,12 @@ class VirtualConnectionItem:
         return self._connections()
 
     @classmethod
-    def from_response(cls, response: bytes, ns: Dict[str, str]) -> List["VirtualConnectionItem"]:
+    def from_response(cls, response: bytes, ns: dict[str, str]) -> list["VirtualConnectionItem"]:
         parsed_response = fromstring(response)
         return [cls.from_xml(xml, ns) for xml in parsed_response.findall(".//t:virtualConnection[@name]", ns)]
 
     @classmethod
-    def from_xml(cls, xml: Element, ns: Dict[str, str]) -> "VirtualConnectionItem":
+    def from_xml(cls, xml: Element, ns: dict[str, str]) -> "VirtualConnectionItem":
         v_conn = cls(xml.get("name", ""))
         v_conn._id = xml.get("id", None)
         v_conn.webpage_url = xml.get("webpageUrl", None)

tableauserverclient/models/webhook_item.py

@@ -1,6 +1,6 @@
 import re
 import xml.etree.ElementTree as ET
-from typing import List, Optional, Tuple, Type
+from typing import Optional
 
 from defusedxml.ElementTree import fromstring
 
@@ -13,7 +13,7 @@ def _parse_event(events):
     return NAMESPACE_RE.sub("", event.tag)
 
 
-class WebhookItem(object):
+class WebhookItem:
     def __init__(self):
         self._id: Optional[str] = None
         self.name: Optional[str] = None
@@ -45,10 +45,10 @@ class WebhookItem(object):
 
     @event.setter
     def event(self, value: str) -> None:
-        self._event = "webhook-source-event-{}".format(value)
+        self._event = f"webhook-source-event-{value}"
 
     @classmethod
-    def from_response(cls: Type["WebhookItem"], resp: bytes, ns) -> List["WebhookItem"]:
+    def from_response(cls: type["WebhookItem"], resp: bytes, ns) -> list["WebhookItem"]:
         all_webhooks_items = list()
         parsed_response = fromstring(resp)
         all_webhooks_xml = parsed_response.findall(".//t:webhook", namespaces=ns)
@@ -61,7 +61,7 @@ class WebhookItem(object):
         return all_webhooks_items
 
     @staticmethod
-    def _parse_element(webhook_xml: ET.Element, ns) -> Tuple:
+    def _parse_element(webhook_xml: ET.Element, ns) -> tuple:
         id = webhook_xml.get("id", None)
         name = webhook_xml.get("name", None)
 
@@ -82,4 +82,4 @@ class WebhookItem(object):
         return id, name, url, event, owner_id
 
     def __repr__(self) -> str:
-        return "<Webhook id={} name={} url={} event={}>".format(self.id, self.name, self.url, self.event)
+        return f"<Webhook id={self.id} name={self.name} url={self.url} event={self.event}>"

tableauserverclient/models/workbook_item.py

@@ -2,7 +2,7 @@ import copy
 import datetime
 import uuid
 import xml.etree.ElementTree as ET
-from typing import Callable, Dict, List, Optional, Set
+from typing import Callable, Optional
 
 from defusedxml.ElementTree import fromstring
 
@@ -20,7 +20,85 @@ from .view_item import ViewItem
 from .data_freshness_policy_item import DataFreshnessPolicyItem
 
 
-class WorkbookItem(object):
+class WorkbookItem:
+    """
+    The workbook resources for Tableau are defined in the WorkbookItem class.
+    The class corresponds to the workbook resources you can access using the
+    Tableau REST API. Some workbook methods take an instance of the WorkbookItem
+    class as arguments. The workbook item specifies the project.
+
+    Parameters
+    ----------
+    project_id : Optional[str], optional
+        The project ID for the workbook, by default None.
+
+    name : Optional[str], optional
+        The name of the workbook, by default None.
+
+    show_tabs : bool, optional
+        Determines whether the workbook shows tabs for the view.
+
+    Attributes
+    ----------
+    connections : list[ConnectionItem]
+        The list of data connections (ConnectionItem) for the data sources used
+        by the workbook. You must first call the workbooks.populate_connections
+        method to access this data. See the ConnectionItem class.
+
+    content_url : Optional[str]
+        The name of the workbook as it appears in the URL.
+
+    created_at : Optional[datetime.datetime]
+        The date and time the workbook was created.
+
+    description : Optional[str]
+        User-defined description of the workbook.
+
+    id : Optional[str]
+       The identifier for the workbook. You need this value to query a specific
+       workbook or to delete a workbook with the get_by_id and delete methods.
+
+    owner_id : Optional[str]
+        The identifier for the owner (UserItem) of the workbook.
+
+    preview_image : bytes
+        The thumbnail image for the view. You must first call the
+        workbooks.populate_preview_image method to access this data.
+
+    project_name : Optional[str]
+        The name of the project that contains the workbook.
+
+    size: int
+        The size of the workbook in megabytes.
+
+    hidden_views: Optional[list[str]]
+        List of string names of views that need to be hidden when the workbook
+        is published.
+
+    tags: set[str]
+        The set of tags associated with the workbook.
+
+    updated_at : Optional[datetime.datetime]
+        The date and time the workbook was last updated.
+
+    views : list[ViewItem]
+        The list of views (ViewItem) for the workbook. You must first call the
+        workbooks.populate_views method to access this data. See the ViewItem
+        class.
+
+    web_page_url : Optional[str]
+        The full URL for the workbook.
+
+    Examples
+    --------
+    # creating a new instance of a WorkbookItem
+    >>> import tableauserverclient as TSC
+
+    >>> # Create new workbook_item with project id '3a8b6148-493c-11e6-a621-6f3499394a39'
+
+    >>> new_workbook = TSC.WorkbookItem('3a8b6148-493c-11e6-a621-6f3499394a39')
+    """
+
     def __init__(self, project_id: Optional[str] = None, name: Optional[str] = None, show_tabs: bool = False) -> None:
         self._connections = None
         self._content_url = None
@@ -35,15 +113,15 @@ class WorkbookItem(object):
         self._revisions = None
         self._size = None
         self._updated_at = None
-        self._views: Optional[Callable[[], List[ViewItem]]] = None
+        self._views: Optional[Callable[[], list[ViewItem]]] = None
         self.name = name
         self._description = None
         self.owner_id: Optional[str] = None
         # 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()
+        self.hidden_views: Optional[list[str]] = None
+        self.tags: set[str] = set()
         self.data_acceleration_config = {
             "acceleration_enabled": None,
             "accelerate_now": None,
@@ -56,7 +134,7 @@ class WorkbookItem(object):
         return None
 
     def __str__(self):
-        return "<WorkbookItem {0} '{1}' contentUrl='{2}' project={3}>".format(
+        return "<WorkbookItem {} '{}' contentUrl='{}' project={}>".format(
             self._id, self.name, self.content_url, self.project_id
         )
 
@@ -64,14 +142,14 @@ class WorkbookItem(object):
         return self.__str__() + "  { " + ", ".join(" % s: % s" % item for item in vars(self).items()) + "}"
 
     @property
-    def connections(self) -> List[ConnectionItem]:
+    def connections(self) -> list[ConnectionItem]:
         if self._connections is None:
             error = "Workbook item must be populated with connections first."
             raise UnpopulatedPropertyError(error)
         return self._connections()
 
     @property
-    def permissions(self) -> List[PermissionsRule]:
+    def permissions(self) -> list[PermissionsRule]:
         if self._permissions is None:
             error = "Workbook item must be populated with permissions first."
             raise UnpopulatedPropertyError(error)
@@ -152,7 +230,7 @@ class WorkbookItem(object):
         return self._updated_at
 
     @property
-    def views(self) -> List[ViewItem]:
+    def views(self) -> list[ViewItem]:
         # Views can be set in an initial workbook response OR by a call
         # to Server. Without getting too fancy, I think we can rely on
         # returning a list from the response, until they call
@@ -191,7 +269,7 @@ class WorkbookItem(object):
         self._data_freshness_policy = value
 
     @property
-    def revisions(self) -> List[RevisionItem]:
+    def revisions(self) -> list[RevisionItem]:
         if self._revisions is None:
             error = "Workbook item must be populated with revisions first."
             raise UnpopulatedPropertyError(error)
@@ -203,7 +281,7 @@ class WorkbookItem(object):
     def _set_permissions(self, permissions):
         self._permissions = permissions
 
-    def _set_views(self, views: Callable[[], List[ViewItem]]) -> None:
+    def _set_views(self, views: Callable[[], list[ViewItem]]) -> None:
         self._views = views
 
     def _set_pdf(self, pdf: Callable[[], bytes]) -> None:
@@ -316,7 +394,7 @@ class WorkbookItem(object):
             self.data_freshness_policy = data_freshness_policy
 
     @classmethod
-    def from_response(cls, resp: str, ns: Dict[str, str]) -> List["WorkbookItem"]:
+    def from_response(cls, resp: str, ns: dict[str, str]) -> list["WorkbookItem"]:
         all_workbook_items = list()
         parsed_response = fromstring(resp)
         all_workbook_xml = parsed_response.findall(".//t:workbook", namespaces=ns)

tableauserverclient/namespace.py

@@ -11,7 +11,7 @@ class UnknownNamespaceError(Exception):
     pass
 
 
-class Namespace(object):
+class Namespace:
     def __init__(self):
         self._namespace = {"t": NEW_NAMESPACE}
         self._detected = False

tableauserverclient/server/__init__.py

@@ -11,7 +11,7 @@ from tableauserverclient.server.filter import Filter
 from tableauserverclient.server.sort import Sort
 from tableauserverclient.server.server import Server
 from tableauserverclient.server.pager import Pager
-from tableauserverclient.server.endpoint.exceptions import NotSignedInError
+from tableauserverclient.server.endpoint.exceptions import FailedSignInError, NotSignedInError
 
 from tableauserverclient.server.endpoint import (
     Auth,
@@ -57,6 +57,7 @@ __all__ = [
     "Sort",
     "Server",
     "Pager",
+    "FailedSignInError",
     "NotSignedInError",
     "Auth",
     "CustomViews",

tableauserverclient/server/endpoint/auth_endpoint.py

@@ -16,7 +16,7 @@ if TYPE_CHECKING:
 
 
 class Auth(Endpoint):
-    class contextmgr(object):
+    class contextmgr:
         def __init__(self, callback):
             self._callback = callback
 
@@ -28,7 +28,7 @@ class Auth(Endpoint):
 
     @property
     def baseurl(self) -> str:
-        return "{0}/auth".format(self.parent_srv.baseurl)
+        return f"{self.parent_srv.baseurl}/auth"
 
     @api(version="2.0")
     def sign_in(self, auth_req: "Credentials") -> contextmgr:
@@ -41,8 +41,32 @@ class Auth(Endpoint):
         optionally a user_id to impersonate.
 
         Creates a context manager that will sign out of the server upon exit.
+
+        Parameters
+        ----------
+        auth_req : Credentials
+            The credentials object to use for signing in. Can be a TableauAuth,
+            PersonalAccessTokenAuth, or JWTAuth object.
+
+        Returns
+        -------
+        contextmgr
+            A context manager that will sign out of the server upon exit.
+
+        Examples
+        --------
+        >>> import tableauserverclient as TSC
+
+        >>> # create an auth object
+        >>> tableau_auth = TSC.TableauAuth('USERNAME', 'PASSWORD')
+
+        >>> # create an instance for your server
+        >>> server = TSC.Server('https://SERVER_URL')
+
+        >>> # call the sign-in method with the auth object
+        >>> server.auth.sign_in(tableau_auth)
         """
-        url = "{0}/{1}".format(self.baseurl, "signin")
+        url = f"{self.baseurl}/signin"
         signin_req = RequestFactory.Auth.signin_req(auth_req)
         server_response = self.parent_srv.session.post(
             url, data=signin_req, **self.parent_srv.http_options, allow_redirects=False
@@ -63,22 +87,25 @@ class Auth(Endpoint):
         user_id = parsed_response.find(".//t:user", namespaces=self.parent_srv.namespace).get("id", None)
         auth_token = parsed_response.find("t:credentials", namespaces=self.parent_srv.namespace).get("token", None)
         self.parent_srv._set_auth(site_id, user_id, auth_token)
-        logger.info("Signed into {0} as user with id {1}".format(self.parent_srv.server_address, user_id))
+        logger.info(f"Signed into {self.parent_srv.server_address} as user with id {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: "Credentials") -> contextmgr:
+        """Passthrough to sign_in method"""
         return self.sign_in(auth_req)
 
     @api(version="3.17")
     def sign_in_with_json_web_token(self, auth_req: "Credentials") -> contextmgr:
+        """Passthrough to sign_in method"""
         return self.sign_in(auth_req)
 
     @api(version="2.0")
     def sign_out(self) -> None:
-        url = "{0}/{1}".format(self.baseurl, "signout")
+        """Sign out of current session."""
+        url = f"{self.baseurl}/signout"
         # If there are no auth tokens you're already signed out. No-op
         if not self.parent_srv.is_signed_in():
             return
@@ -88,7 +115,34 @@ class Auth(Endpoint):
 
     @api(version="2.6")
     def switch_site(self, site_item: "SiteItem") -> contextmgr:
-        url = "{0}/{1}".format(self.baseurl, "switchSite")
+        """
+        Switch to a different site on the server. This will sign out of the
+        current site and sign in to the new site. If used as a context manager,
+        will sign out of the new site upon exit.
+
+        Parameters
+        ----------
+        site_item : SiteItem
+            The site to switch to.
+
+        Returns
+        -------
+        contextmgr
+            A context manager that will sign out of the new site upon exit.
+
+        Examples
+        --------
+        >>> import tableauserverclient as TSC
+
+        >>> # Find the site you want to switch to
+        >>> new_site = server.sites.get_by_id("9a8b7c6d-5e4f-3a2b-1c0d-9e8f7a6b5c4d")
+        >>> # switch to the new site
+        >>> with server.auth.switch_site(new_site):
+        >>>     # do something on the new site
+        >>>     pass
+
+        """
+        url = f"{self.baseurl}/switchSite"
         switch_req = RequestFactory.Auth.switch_req(site_item.content_url)
         try:
             server_response = self.post_request(url, switch_req)
@@ -104,11 +158,14 @@ class Auth(Endpoint):
         user_id = parsed_response.find(".//t:user", namespaces=self.parent_srv.namespace).get("id", None)
         auth_token = parsed_response.find("t:credentials", namespaces=self.parent_srv.namespace).get("token", None)
         self.parent_srv._set_auth(site_id, user_id, auth_token)
-        logger.info("Signed into {0} as user with id {1}".format(self.parent_srv.server_address, user_id))
+        logger.info(f"Signed into {self.parent_srv.server_address} as user with id {user_id}")
         return Auth.contextmgr(self.sign_out)
 
     @api(version="3.10")
     def revoke_all_server_admin_tokens(self) -> None:
-        url = "{0}/{1}".format(self.baseurl, "revokeAllServerAdminTokens")
+        """
+        Revokes all personal access tokens for all server admins on the server.
+        """
+        url = f"{self.baseurl}/revokeAllServerAdminTokens"
         self.post_request(url, "")
         logger.info("Revoked all tokens for all server admins")

tableauserverclient/server/endpoint/custom_views_endpoint.py

@@ -1,15 +1,23 @@
 import io
 import logging
 import os
+from contextlib import closing
 from pathlib import Path
-from typing import List, Optional, Tuple, Union
+from typing import Optional, Union
+from collections.abc import Iterator
 
-from tableauserverclient.config import BYTES_PER_MB, FILESIZE_LIMIT_MB
+from tableauserverclient.config import BYTES_PER_MB, config
 from tableauserverclient.filesys_helpers import get_file_object_size
 from tableauserverclient.server.endpoint.endpoint import QuerysetEndpoint, api
 from tableauserverclient.server.endpoint.exceptions import MissingRequiredFieldError
 from tableauserverclient.models import CustomViewItem, PaginationItem
-from tableauserverclient.server import RequestFactory, RequestOptions, ImageRequestOptions
+from tableauserverclient.server import (
+    RequestFactory,
+    RequestOptions,
+    ImageRequestOptions,
+    PDFRequestOptions,
+    CSVRequestOptions,
+)
 
 from tableauserverclient.helpers.logging import logger
 
@@ -33,11 +41,11 @@ io_types_w = (io.BufferedWriter, io.BytesIO)
 
 class CustomViews(QuerysetEndpoint[CustomViewItem]):
     def __init__(self, parent_srv):
-        super(CustomViews, self).__init__(parent_srv)
+        super().__init__(parent_srv)
 
     @property
     def baseurl(self) -> str:
-        return "{0}/sites/{1}/customviews".format(self.parent_srv.baseurl, self.parent_srv.site_id)
+        return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/customviews"
 
     @property
     def expurl(self) -> str:
@@ -55,7 +63,7 @@ class CustomViews(QuerysetEndpoint[CustomViewItem]):
     """
 
     @api(version="3.18")
-    def get(self, req_options: Optional["RequestOptions"] = None) -> Tuple[List[CustomViewItem], PaginationItem]:
+    def get(self, req_options: Optional["RequestOptions"] = None) -> tuple[list[CustomViewItem], PaginationItem]:
         logger.info("Querying all custom views on site")
         url = self.baseurl
         server_response = self.get_request(url, req_options)
@@ -68,8 +76,8 @@ class CustomViews(QuerysetEndpoint[CustomViewItem]):
         if not view_id:
             error = "Custom view item missing ID."
             raise MissingRequiredFieldError(error)
-        logger.info("Querying custom view (ID: {0})".format(view_id))
-        url = "{0}/{1}".format(self.baseurl, view_id)
+        logger.info(f"Querying custom view (ID: {view_id})")
+        url = f"{self.baseurl}/{view_id}"
         server_response = self.get_request(url)
         return CustomViewItem.from_response(server_response.content, self.parent_srv.namespace)
 
@@ -83,17 +91,53 @@ class CustomViews(QuerysetEndpoint[CustomViewItem]):
             return self._get_view_image(view_item, req_options)
 
         view_item._set_image(image_fetcher)
-        logger.info("Populated image for custom view (ID: {0})".format(view_item.id))
+        logger.info(f"Populated image for custom view (ID: {view_item.id})")
 
     def _get_view_image(self, view_item: CustomViewItem, req_options: Optional["ImageRequestOptions"]) -> bytes:
-        url = "{0}/{1}/image".format(self.baseurl, view_item.id)
+        url = f"{self.baseurl}/{view_item.id}/image"
         server_response = self.get_request(url, req_options)
         image = server_response.content
         return image
 
-    """
-    Not yet implemented: pdf or csv exports
-    """
+    @api(version="3.23")
+    def populate_pdf(self, custom_view_item: CustomViewItem, req_options: Optional["PDFRequestOptions"] = None) -> None:
+        if not custom_view_item.id:
+            error = "Custom View item missing ID."
+            raise MissingRequiredFieldError(error)
+
+        def pdf_fetcher():
+            return self._get_custom_view_pdf(custom_view_item, req_options)
+
+        custom_view_item._set_pdf(pdf_fetcher)
+        logger.info(f"Populated pdf for custom view (ID: {custom_view_item.id})")
+
+    def _get_custom_view_pdf(
+        self, custom_view_item: CustomViewItem, req_options: Optional["PDFRequestOptions"]
+    ) -> bytes:
+        url = f"{self.baseurl}/{custom_view_item.id}/pdf"
+        server_response = self.get_request(url, req_options)
+        pdf = server_response.content
+        return pdf
+
+    @api(version="3.23")
+    def populate_csv(self, custom_view_item: CustomViewItem, req_options: Optional["CSVRequestOptions"] = None) -> None:
+        if not custom_view_item.id:
+            error = "Custom View item missing ID."
+            raise MissingRequiredFieldError(error)
+
+        def csv_fetcher():
+            return self._get_custom_view_csv(custom_view_item, req_options)
+
+        custom_view_item._set_csv(csv_fetcher)
+        logger.info(f"Populated csv for custom view (ID: {custom_view_item.id})")
+
+    def _get_custom_view_csv(
+        self, custom_view_item: CustomViewItem, req_options: Optional["CSVRequestOptions"]
+    ) -> Iterator[bytes]:
+        url = f"{self.baseurl}/{custom_view_item.id}/data"
+
+        with closing(self.get_request(url, request_object=req_options, parameters={"stream": True})) as server_response:
+            yield from server_response.iter_content(1024)
 
     @api(version="3.18")
     def update(self, view_item: CustomViewItem) -> Optional[CustomViewItem]:
@@ -105,10 +149,10 @@ class CustomViews(QuerysetEndpoint[CustomViewItem]):
             return view_item
 
         # Update the custom view owner or name
-        url = "{0}/{1}".format(self.baseurl, view_item.id)
+        url = f"{self.baseurl}/{view_item.id}"
         update_req = RequestFactory.CustomView.update_req(view_item)
         server_response = self.put_request(url, update_req)
-        logger.info("Updated custom view (ID: {0})".format(view_item.id))
+        logger.info(f"Updated custom view (ID: {view_item.id})")
         return CustomViewItem.from_response(server_response.content, self.parent_srv.namespace)
 
     # Delete 1 view by id
@@ -117,9 +161,9 @@ class CustomViews(QuerysetEndpoint[CustomViewItem]):
         if not view_id:
             error = "Custom View ID undefined."
             raise ValueError(error)
-        url = "{0}/{1}".format(self.baseurl, view_id)
+        url = f"{self.baseurl}/{view_id}"
         self.delete_request(url)
-        logger.info("Deleted single custom view (ID: {0})".format(view_id))
+        logger.info(f"Deleted single custom view (ID: {view_id})")
 
     @api(version="3.21")
     def download(self, view_item: CustomViewItem, file: PathOrFileW) -> PathOrFileW:
@@ -144,7 +188,7 @@ class CustomViews(QuerysetEndpoint[CustomViewItem]):
         else:
             raise ValueError("File path or file object required for publishing custom view.")
 
-        if size >= FILESIZE_LIMIT_MB * BYTES_PER_MB:
+        if size >= config.FILESIZE_LIMIT_MB * BYTES_PER_MB:
             upload_session_id = self.parent_srv.fileuploads.upload(file)
             url = f"{url}?uploadSessionId={upload_session_id}"
             xml_request, content_type = RequestFactory.CustomView.publish_req_chunked(view_item)

tableauserverclient/server/endpoint/data_acceleration_report_endpoint.py

@@ -10,14 +10,14 @@ from tableauserverclient.helpers.logging import logger
 
 class DataAccelerationReport(Endpoint):
     def __init__(self, parent_srv):
-        super(DataAccelerationReport, self).__init__(parent_srv)
+        super().__init__(parent_srv)
 
         self._permissions = _PermissionsEndpoint(parent_srv, lambda: self.baseurl)
         self._default_permissions = _DefaultPermissionsEndpoint(parent_srv, lambda: self.baseurl)
 
     @property
     def baseurl(self):
-        return "{0}/sites/{1}/dataAccelerationReport".format(self.parent_srv.baseurl, self.parent_srv.site_id)
+        return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/dataAccelerationReport"
 
     @api(version="3.8")
     def get(self, req_options=None):