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

tableauserverclient/server/endpoint/tables_endpoint.py

@@ -1,17 +1,19 @@
 import logging
+from typing import Iterable, Set, Union
 
-from .dqw_endpoint import _DataQualityWarningEndpoint
-from .endpoint import api, Endpoint
-from .exceptions import MissingRequiredFieldError
-from .permissions_endpoint import _PermissionsEndpoint
+from tableauserverclient.server.endpoint.dqw_endpoint import _DataQualityWarningEndpoint
+from tableauserverclient.server.endpoint.endpoint import api, Endpoint
+from tableauserverclient.server.endpoint.exceptions import MissingRequiredFieldError
+from tableauserverclient.server.endpoint.permissions_endpoint import _PermissionsEndpoint
+from tableauserverclient.server.endpoint.resource_tagger import TaggingMixin
 from tableauserverclient.server import RequestFactory
 from tableauserverclient.models import TableItem, ColumnItem, PaginationItem
-from ..pager import Pager
+from tableauserverclient.server.pager import Pager
 
 from tableauserverclient.helpers.logging import logger
 
 
-class Tables(Endpoint):
+class Tables(Endpoint, TaggingMixin[TableItem]):
     def __init__(self, parent_srv):
         super(Tables, self).__init__(parent_srv)
 
@@ -124,3 +126,14 @@ class Tables(Endpoint):
     @api(version="3.5")
     def delete_dqw(self, item):
         self._data_quality_warnings.clear(item)
+
+    @api(version="3.9")
+    def add_tags(self, item: Union[TableItem, str], tags: Union[Iterable[str], str]) -> Set[str]:
+        return super().add_tags(item, tags)
+
+    @api(version="3.9")
+    def delete_tags(self, item: Union[TableItem, str], tags: Union[Iterable[str], str]) -> None:
+        return super().delete_tags(item, tags)
+
+    def update_tags(self, item: TableItem) -> None:  # type: ignore
+        raise NotImplementedError("Update tags is not implemented for TableItem")

tableauserverclient/server/endpoint/users_endpoint.py

@@ -2,6 +2,8 @@ import copy
 import logging
 from typing import List, Optional, Tuple
 
+from tableauserverclient.server.query import QuerySet
+
 from .endpoint import QuerysetEndpoint, api
 from .exceptions import MissingRequiredFieldError, ServerResponseError
 from tableauserverclient.server import RequestFactory, RequestOptions
@@ -166,3 +168,40 @@ class Users(QuerysetEndpoint[UserItem]):
         group_item = GroupItem.from_response(server_response.content, self.parent_srv.namespace)
         pagination_item = PaginationItem.from_response(server_response.content, self.parent_srv.namespace)
         return group_item, pagination_item
+
+    def filter(self, *invalid, page_size: Optional[int] = None, **kwargs) -> QuerySet[UserItem]:
+        """
+        Queries the Tableau Server for items using the specified filters. Page
+        size can be specified to limit the number of items returned in a single
+        request. If not specified, the default page size is 100. Page size can
+        be an integer between 1 and 1000.
+
+        No positional arguments are allowed. All filters must be specified as
+        keyword arguments. If you use the equality operator, you can specify it
+        through <field_name>=<value>. If you want to use a different operator,
+        you can specify it through <field_name>__<operator>=<value>. Field
+        names can either be in snake_case or camelCase.
+
+        This endpoint supports the following fields and operators:
+
+
+        domain_name=...
+        domain_name__in=...
+        friendly_name=...
+        friendly_name__in=...
+        is_local=...
+        last_login=...
+        last_login__gt=...
+        last_login__gte=...
+        last_login__lt=...
+        last_login__lte=...
+        luid=...
+        luid__in=...
+        name__cieq=...
+        name=...
+        name__in=...
+        site_role=...
+        site_role__in=...
+        """
+
+        return super().filter(*invalid, page_size=page_size, **kwargs)

tableauserverclient/server/endpoint/views_endpoint.py

@@ -1,18 +1,20 @@
 import logging
 from contextlib import closing
 
-from .endpoint import QuerysetEndpoint, api
-from .exceptions import MissingRequiredFieldError
-from .permissions_endpoint import _PermissionsEndpoint
-from .resource_tagger import _ResourceTagger
+from tableauserverclient.server.endpoint.endpoint import QuerysetEndpoint, api
+from tableauserverclient.server.endpoint.exceptions import MissingRequiredFieldError
+from tableauserverclient.server.endpoint.permissions_endpoint import _PermissionsEndpoint
+from tableauserverclient.server.endpoint.resource_tagger import TaggingMixin
+from tableauserverclient.server.query import QuerySet
+
 from tableauserverclient.models import ViewItem, PaginationItem
 
 from tableauserverclient.helpers.logging import logger
 
-from typing import Iterator, List, Optional, Tuple, TYPE_CHECKING
+from typing import Iterable, Iterator, List, Optional, Set, Tuple, TYPE_CHECKING, Union
 
 if TYPE_CHECKING:
-    from ..request_options import (
+    from tableauserverclient.server.request_options import (
         RequestOptions,
         CSVRequestOptions,
         PDFRequestOptions,
@@ -21,10 +23,9 @@ if TYPE_CHECKING:
     )
 
 
-class Views(QuerysetEndpoint[ViewItem]):
+class Views(QuerysetEndpoint[ViewItem], TaggingMixin[ViewItem]):
     def __init__(self, parent_srv):
         super(Views, self).__init__(parent_srv)
-        self._resource_tagger = _ResourceTagger(parent_srv)
         self._permissions = _PermissionsEndpoint(parent_srv, lambda: self.baseurl)
 
     # Used because populate_preview_image functionaliy requires workbook endpoint
@@ -169,7 +170,91 @@ class Views(QuerysetEndpoint[ViewItem]):
             error = "View item missing ID. View must be retrieved from server first."
             raise MissingRequiredFieldError(error)
 
-        self._resource_tagger.update_tags(self.baseurl, view_item)
+        self.update_tags(view_item)
 
         # Returning view item to stay consistent with datasource/view update functions
         return view_item
+
+    @api(version="1.0")
+    def add_tags(self, item: Union[ViewItem, str], tags: Union[Iterable[str], str]) -> Set[str]:
+        return super().add_tags(item, tags)
+
+    @api(version="1.0")
+    def delete_tags(self, item: Union[ViewItem, str], tags: Union[Iterable[str], str]) -> None:
+        return super().delete_tags(item, tags)
+
+    @api(version="1.0")
+    def update_tags(self, item: ViewItem) -> None:
+        return super().update_tags(item)
+
+    def filter(self, *invalid, page_size: Optional[int] = None, **kwargs) -> QuerySet[ViewItem]:
+        """
+        Queries the Tableau Server for items using the specified filters. Page
+        size can be specified to limit the number of items returned in a single
+        request. If not specified, the default page size is 100. Page size can
+        be an integer between 1 and 1000.
+
+        No positional arguments are allowed. All filters must be specified as
+        keyword arguments. If you use the equality operator, you can specify it
+        through <field_name>=<value>. If you want to use a different operator,
+        you can specify it through <field_name>__<operator>=<value>. Field
+        names can either be in snake_case or camelCase.
+
+        This endpoint supports the following fields and operators:
+
+
+        caption=...
+        caption__in=...
+        content_url=...
+        content_url__in=...
+        created_at=...
+        created_at__gt=...
+        created_at__gte=...
+        created_at__lt=...
+        created_at__lte=...
+        favorites_total=...
+        favorites_total__gt=...
+        favorites_total__gte=...
+        favorites_total__lt=...
+        favorites_total__lte=...
+        fields=...
+        fields__in=...
+        hits_total=...
+        hits_total__gt=...
+        hits_total__gte=...
+        hits_total__lt=...
+        hits_total__lte=...
+        name=...
+        name__in=...
+        owner_domain=...
+        owner_domain__in=...
+        owner_email=...
+        owner_email__in=...
+        owner_name=...
+        project_name=...
+        project_name__in=...
+        sheet_number=...
+        sheet_number__gt=...
+        sheet_number__gte=...
+        sheet_number__lt=...
+        sheet_number__lte=...
+        sheet_type=...
+        sheet_type__in=...
+        tags=...
+        tags__in=...
+        title=...
+        title__in=...
+        updated_at=...
+        updated_at__gt=...
+        updated_at__gte=...
+        updated_at__lt=...
+        updated_at__lte=...
+        view_url_name=...
+        view_url_name__in=...
+        workbook_description=...
+        workbook_description__in=...
+        workbook_name=...
+        workbook_name__in=...
+        """
+
+        return super().filter(*invalid, page_size=page_size, **kwargs)

tableauserverclient/server/endpoint/virtual_connections_endpoint.py

@@ -0,0 +1,173 @@
+from functools import partial
+import json
+from pathlib import Path
+from typing import Iterable, List, Optional, Set, TYPE_CHECKING, Tuple, Union
+
+from tableauserverclient.models.connection_item import ConnectionItem
+from tableauserverclient.models.pagination_item import PaginationItem
+from tableauserverclient.models.revision_item import RevisionItem
+from tableauserverclient.models.virtual_connection_item import VirtualConnectionItem
+from tableauserverclient.server.request_factory import RequestFactory
+from tableauserverclient.server.request_options import RequestOptions
+from tableauserverclient.server.endpoint.endpoint import QuerysetEndpoint, api
+from tableauserverclient.server.endpoint.permissions_endpoint import _PermissionsEndpoint
+from tableauserverclient.server.endpoint.resource_tagger import TaggingMixin
+from tableauserverclient.server.pager import Pager
+
+if TYPE_CHECKING:
+    from tableauserverclient.server import Server
+
+
+class VirtualConnections(QuerysetEndpoint[VirtualConnectionItem], TaggingMixin):
+    def __init__(self, parent_srv: "Server") -> None:
+        super().__init__(parent_srv)
+        self._permissions = _PermissionsEndpoint(parent_srv, lambda: self.baseurl)
+
+    @property
+    def baseurl(self) -> str:
+        return f"{self.parent_srv.baseurl}/sites/{self.parent_srv.site_id}/virtualConnections"
+
+    @api(version="3.18")
+    def get(self, req_options: Optional[RequestOptions] = None) -> Tuple[List[VirtualConnectionItem], PaginationItem]:
+        server_response = self.get_request(self.baseurl, req_options)
+        pagination_item = PaginationItem.from_response(server_response.content, self.parent_srv.namespace)
+        virtual_connections = VirtualConnectionItem.from_response(server_response.content, self.parent_srv.namespace)
+        return virtual_connections, pagination_item
+
+    @api(version="3.18")
+    def populate_connections(self, virtual_connection: VirtualConnectionItem) -> VirtualConnectionItem:
+        def _connection_fetcher():
+            return Pager(partial(self._get_virtual_database_connections, virtual_connection))
+
+        virtual_connection._connections = _connection_fetcher
+        return virtual_connection
+
+    def _get_virtual_database_connections(
+        self, virtual_connection: VirtualConnectionItem, req_options: Optional[RequestOptions] = None
+    ) -> Tuple[List[ConnectionItem], PaginationItem]:
+        server_response = self.get_request(f"{self.baseurl}/{virtual_connection.id}/connections", req_options)
+        connections = ConnectionItem.from_response(server_response.content, self.parent_srv.namespace)
+        pagination_item = PaginationItem.from_response(server_response.content, self.parent_srv.namespace)
+
+        return connections, pagination_item
+
+    @api(version="3.18")
+    def update_connection_db_connection(
+        self, virtual_connection: Union[str, VirtualConnectionItem], connection: ConnectionItem
+    ) -> ConnectionItem:
+        vconn_id = getattr(virtual_connection, "id", virtual_connection)
+        url = f"{self.baseurl}/{vconn_id}/connections/{connection.id}/modify"
+        xml_request = RequestFactory.VirtualConnection.update_db_connection(connection)
+        server_response = self.put_request(url, xml_request)
+        return ConnectionItem.from_response(server_response.content, self.parent_srv.namespace)[0]
+
+    @api(version="3.23")
+    def get_by_id(self, virtual_connection: Union[str, VirtualConnectionItem]) -> VirtualConnectionItem:
+        vconn_id = getattr(virtual_connection, "id", virtual_connection)
+        url = f"{self.baseurl}/{vconn_id}"
+        server_response = self.get_request(url)
+        return VirtualConnectionItem.from_response(server_response.content, self.parent_srv.namespace)[0]
+
+    @api(version="3.23")
+    def download(self, virtual_connection: Union[str, VirtualConnectionItem]) -> str:
+        v_conn = self.get_by_id(virtual_connection)
+        return json.dumps(v_conn.content)
+
+    @api(version="3.23")
+    def update(self, virtual_connection: VirtualConnectionItem) -> VirtualConnectionItem:
+        url = f"{self.baseurl}/{virtual_connection.id}"
+        xml_request = RequestFactory.VirtualConnection.update(virtual_connection)
+        server_response = self.put_request(url, xml_request)
+        return VirtualConnectionItem.from_response(server_response.content, self.parent_srv.namespace)[0]
+
+    @api(version="3.23")
+    def get_revisions(
+        self, virtual_connection: VirtualConnectionItem, req_options: Optional[RequestOptions] = None
+    ) -> Tuple[List[RevisionItem], PaginationItem]:
+        server_response = self.get_request(f"{self.baseurl}/{virtual_connection.id}/revisions", req_options)
+        pagination_item = PaginationItem.from_response(server_response.content, self.parent_srv.namespace)
+        revisions = RevisionItem.from_response(server_response.content, self.parent_srv.namespace, virtual_connection)
+        return revisions, pagination_item
+
+    @api(version="3.23")
+    def download_revision(self, virtual_connection: VirtualConnectionItem, revision_number: int) -> str:
+        url = f"{self.baseurl}/{virtual_connection.id}/revisions/{revision_number}"
+        server_response = self.get_request(url)
+        virtual_connection = VirtualConnectionItem.from_response(server_response.content, self.parent_srv.namespace)[0]
+        return json.dumps(virtual_connection.content)
+
+    @api(version="3.23")
+    def delete(self, virtual_connection: Union[VirtualConnectionItem, str]) -> None:
+        vconn_id = getattr(virtual_connection, "id", virtual_connection)
+        self.delete_request(f"{self.baseurl}/{vconn_id}")
+
+    @api(version="3.23")
+    def publish(
+        self,
+        virtual_connection: VirtualConnectionItem,
+        virtual_connection_content: str,
+        mode: str = "CreateNew",
+        publish_as_draft: bool = False,
+    ) -> VirtualConnectionItem:
+        """
+        Publish a virtual connection to the server.
+
+        For the virtual_connection object, name, project_id, and owner_id are
+        required.
+
+        The virtual_connection_content can be a json string or a file path to a
+        json file.
+
+        The mode can be "CreateNew" or "Overwrite". If mode is
+        "Overwrite" and the virtual connection already exists, it will be
+        overwritten.
+
+        If publish_as_draft is True, the virtual connection will be published
+        as a draft, and the id of the draft will be on the response object.
+        """
+        try:
+            json.loads(virtual_connection_content)
+        except json.JSONDecodeError:
+            file = Path(virtual_connection_content)
+            if not file.exists():
+                raise RuntimeError(f"{virtual_connection_content} is not valid json nor an existing file path")
+            content = file.read_text()
+        else:
+            content = virtual_connection_content
+
+        if mode not in ["CreateNew", "Overwrite"]:
+            raise ValueError(f"Invalid mode: {mode}")
+        overwrite = mode == "Overwrite"
+
+        url = f"{self.baseurl}?overwrite={str(overwrite).lower()}&publishAsDraft={str(publish_as_draft).lower()}"
+        xml_request = RequestFactory.VirtualConnection.publish(virtual_connection, content)
+        server_response = self.post_request(url, xml_request)
+        return VirtualConnectionItem.from_response(server_response.content, self.parent_srv.namespace)[0]
+
+    @api(version="3.22")
+    def populate_permissions(self, item: VirtualConnectionItem) -> None:
+        self._permissions.populate(item)
+
+    @api(version="3.22")
+    def add_permissions(self, resource, rules):
+        return self._permissions.update(resource, rules)
+
+    @api(version="3.22")
+    def delete_permission(self, item, capability_item):
+        return self._permissions.delete(item, capability_item)
+
+    @api(version="3.23")
+    def add_tags(
+        self, virtual_connection: Union[VirtualConnectionItem, str], tags: Union[Iterable[str], str]
+    ) -> Set[str]:
+        return super().add_tags(virtual_connection, tags)
+
+    @api(version="3.23")
+    def delete_tags(
+        self, virtual_connection: Union[VirtualConnectionItem, str], tags: Union[Iterable[str], str]
+    ) -> None:
+        return super().delete_tags(virtual_connection, tags)
+
+    @api(version="3.23")
+    def update_tags(self, virtual_connection: VirtualConnectionItem) -> None:
+        raise NotImplementedError("Update tags is not implemented for Virtual Connections")

tableauserverclient/server/endpoint/workbooks_endpoint.py

@@ -7,11 +7,12 @@ from contextlib import closing
 from pathlib import Path
 
 from tableauserverclient.helpers.headers import fix_filename
+from tableauserverclient.server.query import QuerySet
 
-from .endpoint import QuerysetEndpoint, api, parameter_added_in
-from .exceptions import InternalServerError, MissingRequiredFieldError
-from .permissions_endpoint import _PermissionsEndpoint
-from .resource_tagger import _ResourceTagger
+from tableauserverclient.server.endpoint.endpoint import QuerysetEndpoint, api, parameter_added_in
+from tableauserverclient.server.endpoint.exceptions import InternalServerError, MissingRequiredFieldError
+from tableauserverclient.server.endpoint.permissions_endpoint import _PermissionsEndpoint
+from tableauserverclient.server.endpoint.resource_tagger import TaggingMixin
 
 from tableauserverclient.filesys_helpers import (
     to_filename,
@@ -24,9 +25,11 @@ from tableauserverclient.models import WorkbookItem, ConnectionItem, ViewItem, P
 from tableauserverclient.server import RequestFactory
 
 from typing import (
+    Iterable,
     List,
     Optional,
     Sequence,
+    Set,
     Tuple,
     TYPE_CHECKING,
     Union,
@@ -35,8 +38,8 @@ from typing import (
 if TYPE_CHECKING:
     from tableauserverclient.server import Server
     from tableauserverclient.server.request_options import RequestOptions
-    from tableauserverclient.models import DatasourceItem, ConnectionCredentials
-    from .schedules_endpoint import AddResponse
+    from tableauserverclient.models import DatasourceItem
+    from tableauserverclient.server.endpoint.schedules_endpoint import AddResponse
 
 io_types_r = (io.BytesIO, io.BufferedReader)
 io_types_w = (io.BytesIO, io.BufferedWriter)
@@ -56,10 +59,9 @@ PathOrFileR = Union[FilePath, FileObjectR]
 PathOrFileW = Union[FilePath, FileObjectW]
 
 
-class Workbooks(QuerysetEndpoint[WorkbookItem]):
+class Workbooks(QuerysetEndpoint[WorkbookItem], TaggingMixin[WorkbookItem]):
     def __init__(self, parent_srv: "Server") -> None:
         super(Workbooks, self).__init__(parent_srv)
-        self._resource_tagger = _ResourceTagger(parent_srv)
         self._permissions = _PermissionsEndpoint(parent_srv, lambda: self.baseurl)
 
         return None
@@ -147,7 +149,7 @@ class Workbooks(QuerysetEndpoint[WorkbookItem]):
             error = "Workbook item missing ID. Workbook must be retrieved from server first."
             raise MissingRequiredFieldError(error)
 
-        self._resource_tagger.update_tags(self.baseurl, workbook_item)
+        self.update_tags(workbook_item)
 
         # Update the workbook itself
         url = "{0}/{1}".format(self.baseurl, workbook_item.id)
@@ -182,7 +184,7 @@ class Workbooks(QuerysetEndpoint[WorkbookItem]):
         workbook_id: str,
         filepath: Optional[PathOrFileW] = None,
         include_extract: bool = True,
-    ) -> str:
+    ) -> PathOrFileW:
         return self.download_revision(
             workbook_id,
             None,
@@ -498,3 +500,82 @@ class Workbooks(QuerysetEndpoint[WorkbookItem]):
         self, schedule_id: str, item: WorkbookItem
     ) -> List["AddResponse"]:  # actually should return a task
         return self.parent_srv.schedules.add_to_schedule(schedule_id, workbook=item)
+
+    @api(version="1.0")
+    def add_tags(self, item: Union[WorkbookItem, str], tags: Union[Iterable[str], str]) -> Set[str]:
+        return super().add_tags(item, tags)
+
+    @api(version="1.0")
+    def delete_tags(self, item: Union[WorkbookItem, str], tags: Union[Iterable[str], str]) -> None:
+        return super().delete_tags(item, tags)
+
+    @api(version="1.0")
+    def update_tags(self, item: WorkbookItem) -> None:
+        return super().update_tags(item)
+
+    def filter(self, *invalid, page_size: Optional[int] = None, **kwargs) -> QuerySet[WorkbookItem]:
+        """
+        Queries the Tableau Server for items using the specified filters. Page
+        size can be specified to limit the number of items returned in a single
+        request. If not specified, the default page size is 100. Page size can
+        be an integer between 1 and 1000.
+
+        No positional arguments are allowed. All filters must be specified as
+        keyword arguments. If you use the equality operator, you can specify it
+        through <field_name>=<value>. If you want to use a different operator,
+        you can specify it through <field_name>__<operator>=<value>. Field
+        names can either be in snake_case or camelCase.
+
+        This endpoint supports the following fields and operators:
+
+
+        created_at=...
+        created_at__gt=...
+        created_at__gte=...
+        created_at__lt=...
+        created_at__lte=...
+        content_url=...
+        content_url__in=...
+        display_tabs=...
+        favorites_total=...
+        favorites_total__gt=...
+        favorites_total__gte=...
+        favorites_total__lt=...
+        favorites_total__lte=...
+        has_alerts=...
+        has_extracts=...
+        name=...
+        name__in=...
+        owner_domain=...
+        owner_domain__in=...
+        owner_email=...
+        owner_email__in=...
+        owner_name=...
+        owner_name__in=...
+        project_name=...
+        project_name__in=...
+        sheet_count=...
+        sheet_count__gt=...
+        sheet_count__gte=...
+        sheet_count__lt=...
+        sheet_count__lte=...
+        size=...
+        size__gt=...
+        size__gte=...
+        size__lt=...
+        size__lte=...
+        subscriptions_total=...
+        subscriptions_total__gt=...
+        subscriptions_total__gte=...
+        subscriptions_total__lt=...
+        subscriptions_total__lte=...
+        tags=...
+        tags__in=...
+        updated_at=...
+        updated_at__gt=...
+        updated_at__gte=...
+        updated_at__lt=...
+        updated_at__lte=...
+        """
+
+        return super().filter(*invalid, page_size=page_size, **kwargs)

tableauserverclient/server/pager.py

@@ -1,24 +1,23 @@
 import copy
 from functools import partial
-from typing import Generic, Iterable, Iterator, List, Optional, Protocol, Tuple, TypeVar, Union, runtime_checkable
+from typing import Iterable, Iterator, List, Optional, Protocol, Tuple, TypeVar, Union, runtime_checkable
 
 from tableauserverclient.models.pagination_item import PaginationItem
 from tableauserverclient.server.request_options import RequestOptions
 
 
 T = TypeVar("T")
-ReturnType = Tuple[List[T], PaginationItem]
 
 
 @runtime_checkable
-class Endpoint(Protocol):
-    def get(self, req_options: Optional[RequestOptions], **kwargs) -> ReturnType:
+class Endpoint(Protocol[T]):
+    def get(self, req_options: Optional[RequestOptions]) -> Tuple[List[T], PaginationItem]:
         ...
 
 
 @runtime_checkable
-class CallableEndpoint(Protocol):
-    def __call__(self, __req_options: Optional[RequestOptions], **kwargs) -> ReturnType:
+class CallableEndpoint(Protocol[T]):
+    def __call__(self, __req_options: Optional[RequestOptions], **kwargs) -> Tuple[List[T], PaginationItem]:
         ...
 
 
@@ -33,7 +32,7 @@ class Pager(Iterable[T]):
 
     def __init__(
         self,
-        endpoint: Union[CallableEndpoint, Endpoint],
+        endpoint: Union[CallableEndpoint[T], Endpoint[T]],
         request_opts: Optional[RequestOptions] = None,
         **kwargs,
     ) -> None:

tableauserverclient/server/query.py

@@ -1,6 +1,7 @@
 from collections.abc import Sized
 from itertools import count
 from typing import Iterable, Iterator, List, Optional, Protocol, Tuple, TYPE_CHECKING, TypeVar, overload
+from tableauserverclient.config import config
 from tableauserverclient.models.pagination_item import PaginationItem
 from tableauserverclient.server.filter import Filter
 from tableauserverclient.server.request_options import RequestOptions
@@ -35,7 +36,7 @@ see pagination_sample
 class QuerySet(Iterable[T], Sized):
     def __init__(self, model: "QuerysetEndpoint[T]", page_size: Optional[int] = None) -> None:
         self.model = model
-        self.request_options = RequestOptions(pagesize=page_size or 100)
+        self.request_options = RequestOptions(pagesize=page_size or config.PAGE_SIZE)
         self._result_cache: List[T] = []
         self._pagination_item = PaginationItem()