python-gitlab 5.5.0__py3-none-any.whl → 6.0.0__py3-none-any.whl

gitlab/client.py

@@ -4,18 +4,7 @@ from __future__ import annotations
 
 import os
 import re
-from typing import (
-    Any,
-    BinaryIO,
-    cast,
-    Dict,
-    List,
-    Optional,
-    Tuple,
-    Type,
-    TYPE_CHECKING,
-    Union,
-)
+from typing import Any, BinaryIO, cast, TYPE_CHECKING
 from urllib import parse
 
 import requests
@@ -83,26 +72,26 @@ class Gitlab:
 
     def __init__(
         self,
-        url: Optional[str] = None,
-        private_token: Optional[str] = None,
-        oauth_token: Optional[str] = None,
-        job_token: Optional[str] = None,
-        ssl_verify: Union[bool, str] = True,
-        http_username: Optional[str] = None,
-        http_password: Optional[str] = None,
-        timeout: Optional[float] = None,
+        url: str | None = None,
+        private_token: str | None = None,
+        oauth_token: str | None = None,
+        job_token: str | None = None,
+        ssl_verify: bool | str = True,
+        http_username: str | None = None,
+        http_password: str | None = None,
+        timeout: float | None = None,
         api_version: str = "4",
-        per_page: Optional[int] = None,
-        pagination: Optional[str] = None,
-        order_by: Optional[str] = None,
+        per_page: int | None = None,
+        pagination: str | None = None,
+        order_by: str | None = None,
         user_agent: str = gitlab.const.USER_AGENT,
         retry_transient_errors: bool = False,
         keep_base_url: bool = False,
         **kwargs: Any,
     ) -> None:
         self._api_version = str(api_version)
-        self._server_version: Optional[str] = None
-        self._server_revision: Optional[str] = None
+        self._server_version: str | None = None
+        self._server_revision: str | None = None
         self._base_url = utils.get_base_url(url)
         self._url = f"{self._base_url}/api/v{api_version}"
         #: Timeout to use for requests to gitlab server
@@ -123,7 +112,7 @@ class Gitlab:
         self._set_auth_info()
 
         #: Create a session object for requests
-        _backend: Type[_backends.DefaultBackend] = kwargs.pop(
+        _backend: type[_backends.DefaultBackend] = kwargs.pop(
             "backend", _backends.DefaultBackend
         )
         self._backend = _backend(**kwargs)
@@ -141,7 +130,7 @@ class Gitlab:
         from gitlab.v4 import objects
 
         self._objects = objects
-        self.user: Optional[objects.CurrentUser] = None
+        self.user: objects.CurrentUser | None = None
 
         self.broadcastmessages = objects.BroadcastMessageManager(self)
         """See :class:`~gitlab.v4.objects.BroadcastMessageManager`"""
@@ -177,6 +166,8 @@ class Gitlab:
         """See :class:`~gitlab.v4.objects.LicenseManager`"""
         self.namespaces = objects.NamespaceManager(self)
         """See :class:`~gitlab.v4.objects.NamespaceManager`"""
+        self.member_roles = objects.MemberRoleManager(self)
+        """See :class:`~gitlab.v4.objects.MergeRequestManager`"""
         self.mergerequests = objects.MergeRequestManager(self)
         """See :class:`~gitlab.v4.objects.MergeRequestManager`"""
         self.notificationsettings = objects.NotificationSettingsManager(self)
@@ -224,18 +215,18 @@ class Gitlab:
         self.statistics = objects.ApplicationStatisticsManager(self)
         """See :class:`~gitlab.v4.objects.ApplicationStatisticsManager`"""
 
-    def __enter__(self) -> "Gitlab":
+    def __enter__(self) -> Gitlab:
         return self
 
     def __exit__(self, *args: Any) -> None:
         self.session.close()
 
-    def __getstate__(self) -> Dict[str, Any]:
+    def __getstate__(self) -> dict[str, Any]:
         state = self.__dict__.copy()
         state.pop("_objects")
         return state
 
-    def __setstate__(self, state: Dict[str, Any]) -> None:
+    def __setstate__(self, state: dict[str, Any]) -> None:
         self.__dict__.update(state)
         # We only support v4 API at this time
         if self._api_version not in ("4",):
@@ -266,10 +257,10 @@ class Gitlab:
     @classmethod
     def from_config(
         cls,
-        gitlab_id: Optional[str] = None,
-        config_files: Optional[List[str]] = None,
+        gitlab_id: str | None = None,
+        config_files: list[str] | None = None,
         **kwargs: Any,
-    ) -> "Gitlab":
+    ) -> Gitlab:
         """Create a Gitlab connection from configuration files.
 
         Args:
@@ -310,10 +301,10 @@ class Gitlab:
     @classmethod
     def merge_config(
         cls,
-        options: Dict[str, Any],
-        gitlab_id: Optional[str] = None,
-        config_files: Optional[List[str]] = None,
-    ) -> "Gitlab":
+        options: dict[str, Any],
+        gitlab_id: str | None = None,
+        config_files: list[str] | None = None,
+    ) -> Gitlab:
         """Create a Gitlab connection by merging configuration with
         the following precedence:
 
@@ -364,8 +355,8 @@ class Gitlab:
 
     @staticmethod
     def _merge_auth(
-        options: Dict[str, Any], config: gitlab.config.GitlabConfigParser
-    ) -> Tuple[Optional[str], Optional[str], Optional[str]]:
+        options: dict[str, Any], config: gitlab.config.GitlabConfigParser
+    ) -> tuple[str | None, str | None, str | None]:
         """
         Return a tuple where at most one of 3 token types ever has a value.
         Since multiple types of tokens may be present in the environment,
@@ -402,7 +393,7 @@ class Gitlab:
         if hasattr(self.user, "web_url") and hasattr(self.user, "username"):
             self._check_url(self.user.web_url, path=self.user.username)
 
-    def version(self) -> Tuple[str, str]:
+    def version(self) -> tuple[str, str]:
         """Returns the version and revision of the gitlab server.
 
         Note that self.version and self.revision will be set on the gitlab
@@ -429,7 +420,7 @@ class Gitlab:
 
     @gitlab.exceptions.on_http_error(gitlab.exceptions.GitlabMarkdownError)
     def markdown(
-        self, text: str, gfm: bool = False, project: Optional[str] = None, **kwargs: Any
+        self, text: str, gfm: bool = False, project: str | None = None, **kwargs: Any
     ) -> str:
         """Render an arbitrary Markdown document.
 
@@ -456,7 +447,7 @@ class Gitlab:
         return data["html"]
 
     @gitlab.exceptions.on_http_error(gitlab.exceptions.GitlabLicenseError)
-    def get_license(self, **kwargs: Any) -> Dict[str, Union[str, Dict[str, str]]]:
+    def get_license(self, **kwargs: Any) -> dict[str, str | dict[str, str]]:
         """Retrieve information about the current license.
 
         Args:
@@ -475,7 +466,7 @@ class Gitlab:
         return {}
 
     @gitlab.exceptions.on_http_error(gitlab.exceptions.GitlabLicenseError)
-    def set_license(self, license: str, **kwargs: Any) -> Dict[str, Any]:
+    def set_license(self, license: str, **kwargs: Any) -> dict[str, Any]:
         """Add a new license.
 
         Args:
@@ -516,7 +507,7 @@ class Gitlab:
                 "authentication should be defined"
             )
 
-        self._auth: Optional[requests.auth.AuthBase] = None
+        self._auth: requests.auth.AuthBase | None = None
         if self.private_token:
             self._auth = _backends.PrivateTokenAuth(self.private_token)
 
@@ -564,7 +555,7 @@ class Gitlab:
         logger.handlers.clear()
         logger.addHandler(handler)
 
-    def _get_session_opts(self) -> Dict[str, Any]:
+    def _get_session_opts(self) -> dict[str, Any]:
         return {
             "headers": self.headers.copy(),
             "auth": self._auth,
@@ -585,7 +576,7 @@ class Gitlab:
             return path
         return f"{self._url}{path}"
 
-    def _check_url(self, url: Optional[str], *, path: str = "api") -> Optional[str]:
+    def _check_url(self, url: str | None, *, path: str = "api") -> str | None:
         """
         Checks if ``url`` starts with a different base URL from the user-provided base
         URL and warns the user before returning it. If ``keep_base_url`` is set to
@@ -645,16 +636,16 @@ class Gitlab:
         self,
         verb: str,
         path: str,
-        query_data: Optional[Dict[str, Any]] = None,
-        post_data: Optional[Union[Dict[str, Any], bytes, BinaryIO]] = None,
+        query_data: dict[str, Any] | None = None,
+        post_data: dict[str, Any] | bytes | BinaryIO | None = None,
         raw: bool = False,
         streamed: bool = False,
-        files: Optional[Dict[str, Any]] = None,
-        timeout: Optional[float] = None,
+        files: dict[str, Any] | None = None,
+        timeout: float | None = None,
         obey_rate_limit: bool = True,
-        retry_transient_errors: Optional[bool] = None,
+        retry_transient_errors: bool | None = None,
         max_retries: int = 10,
-        extra_headers: Optional[Dict[str, Any]] = None,
+        extra_headers: dict[str, Any] | None = None,
         **kwargs: Any,
     ) -> requests.Response:
         """Make an HTTP request to the Gitlab server.
@@ -785,11 +776,11 @@ class Gitlab:
     def http_get(
         self,
         path: str,
-        query_data: Optional[Dict[str, Any]] = None,
+        query_data: dict[str, Any] | None = None,
         streamed: bool = False,
         raw: bool = False,
         **kwargs: Any,
-    ) -> Union[Dict[str, Any], requests.Response]:
+    ) -> dict[str, Any] | requests.Response:
         """Make a GET request to the Gitlab server.
 
         Args:
@@ -829,8 +820,8 @@ class Gitlab:
             return result
 
     def http_head(
-        self, path: str, query_data: Optional[Dict[str, Any]] = None, **kwargs: Any
-    ) -> "requests.structures.CaseInsensitiveDict[Any]":
+        self, path: str, query_data: dict[str, Any] | None = None, **kwargs: Any
+    ) -> requests.structures.CaseInsensitiveDict[Any]:
         """Make a HEAD request to the Gitlab server.
 
         Args:
@@ -852,12 +843,12 @@ class Gitlab:
     def http_list(
         self,
         path: str,
-        query_data: Optional[Dict[str, Any]] = None,
+        query_data: dict[str, Any] | None = None,
         *,
-        iterator: Optional[bool] = None,
-        message_details: Optional[utils.WarnMessageData] = None,
+        iterator: bool | None = None,
+        message_details: utils.WarnMessageData | None = None,
         **kwargs: Any,
-    ) -> Union["GitlabList", List[Dict[str, Any]]]:
+    ) -> GitlabList | list[dict[str, Any]]:
         """Make a GET request to the Gitlab server for list-oriented queries.
 
         Args:
@@ -892,18 +883,16 @@ class Gitlab:
 
         page = kwargs.get("page")
 
-        if iterator and page is not None:
-            arg_used_message = f"iterator={iterator}"
-            utils.warn(
-                message=(
-                    f"`{arg_used_message}` and `page={page}` were both specified. "
-                    f"`{arg_used_message}` will be ignored and a `list` will be "
-                    f"returned."
-                ),
-                category=UserWarning,
-            )
+        if iterator:
+            if page is not None:
+                utils.warn(
+                    message=(
+                        f"`{iterator=}` and `{page=}` were both specified. "
+                        f"`{page=}` will be ignored."
+                    ),
+                    category=UserWarning,
+                )
 
-        if iterator and page is None:
             # Generator requested
             return GitlabList(self, url, query_data, **kwargs)
 
@@ -958,22 +947,18 @@ class Gitlab:
                 f"`get_all=False` to the `list()` call."
             )
             show_caller = True
-        utils.warn(
-            message=message,
-            category=UserWarning,
-            show_caller=show_caller,
-        )
+        utils.warn(message=message, category=UserWarning, show_caller=show_caller)
         return items
 
     def http_post(
         self,
         path: str,
-        query_data: Optional[Dict[str, Any]] = None,
-        post_data: Optional[Dict[str, Any]] = None,
+        query_data: dict[str, Any] | None = None,
+        post_data: dict[str, Any] | None = None,
         raw: bool = False,
-        files: Optional[Dict[str, Any]] = None,
+        files: dict[str, Any] | None = None,
         **kwargs: Any,
-    ) -> Union[Dict[str, Any], requests.Response]:
+    ) -> dict[str, Any] | requests.Response:
         """Make a POST request to the Gitlab server.
 
         Args:
@@ -1023,12 +1008,12 @@ class Gitlab:
     def http_put(
         self,
         path: str,
-        query_data: Optional[Dict[str, Any]] = None,
-        post_data: Optional[Union[Dict[str, Any], bytes, BinaryIO]] = None,
+        query_data: dict[str, Any] | None = None,
+        post_data: dict[str, Any] | bytes | BinaryIO | None = None,
         raw: bool = False,
-        files: Optional[Dict[str, Any]] = None,
+        files: dict[str, Any] | None = None,
         **kwargs: Any,
-    ) -> Union[Dict[str, Any], requests.Response]:
+    ) -> dict[str, Any] | requests.Response:
         """Make a PUT request to the Gitlab server.
 
         Args:
@@ -1076,11 +1061,11 @@ class Gitlab:
         self,
         path: str,
         *,
-        query_data: Optional[Dict[str, Any]] = None,
-        post_data: Optional[Union[Dict[str, Any], bytes]] = None,
+        query_data: dict[str, Any] | None = None,
+        post_data: dict[str, Any] | bytes | None = None,
         raw: bool = False,
         **kwargs: Any,
-    ) -> Union[Dict[str, Any], requests.Response]:
+    ) -> dict[str, Any] | requests.Response:
         """Make a PATCH request to the Gitlab server.
 
         Args:
@@ -1103,12 +1088,7 @@ class Gitlab:
         post_data = post_data or {}
 
         result = self.http_request(
-            "patch",
-            path,
-            query_data=query_data,
-            post_data=post_data,
-            raw=raw,
-            **kwargs,
+            "patch", path, query_data=query_data, post_data=post_data, raw=raw, **kwargs
         )
         if result.status_code in gitlab.const.NO_JSON_RESPONSE_CODES:
             return result
@@ -1141,7 +1121,7 @@ class Gitlab:
     @gitlab.exceptions.on_http_error(gitlab.exceptions.GitlabSearchError)
     def search(
         self, scope: str, search: str, **kwargs: Any
-    ) -> Union["GitlabList", List[Dict[str, Any]]]:
+    ) -> GitlabList | list[dict[str, Any]]:
         """Search GitLab resources matching the provided string.'
 
         Args:
@@ -1171,7 +1151,7 @@ class GitlabList:
         self,
         gl: Gitlab,
         url: str,
-        query_data: Dict[str, Any],
+        query_data: dict[str, Any],
         get_next: bool = True,
         **kwargs: Any,
     ) -> None:
@@ -1187,7 +1167,7 @@ class GitlabList:
         self._kwargs.pop("query_parameters", None)
 
     def _query(
-        self, url: str, query_data: Optional[Dict[str, Any]] = None, **kwargs: Any
+        self, url: str, query_data: dict[str, Any] | None = None, **kwargs: Any
     ) -> None:
         query_data = query_data or {}
         result = self._gl.http_request("get", url, query_data=query_data, **kwargs)
@@ -1197,15 +1177,15 @@ class GitlabList:
             next_url = None
 
         self._next_url = self._gl._check_url(next_url)
-        self._current_page: Optional[str] = result.headers.get("X-Page")
-        self._prev_page: Optional[str] = result.headers.get("X-Prev-Page")
-        self._next_page: Optional[str] = result.headers.get("X-Next-Page")
-        self._per_page: Optional[str] = result.headers.get("X-Per-Page")
-        self._total_pages: Optional[str] = result.headers.get("X-Total-Pages")
-        self._total: Optional[str] = result.headers.get("X-Total")
+        self._current_page: str | None = result.headers.get("X-Page")
+        self._prev_page: str | None = result.headers.get("X-Prev-Page")
+        self._next_page: str | None = result.headers.get("X-Next-Page")
+        self._per_page: str | None = result.headers.get("X-Per-Page")
+        self._total_pages: str | None = result.headers.get("X-Total-Pages")
+        self._total: str | None = result.headers.get("X-Total")
 
         try:
-            self._data: List[Dict[str, Any]] = result.json()
+            self._data: list[dict[str, Any]] = result.json()
         except Exception as e:
             raise gitlab.exceptions.GitlabParsingError(
                 error_message="Failed to parse the server message"
@@ -1221,7 +1201,7 @@ class GitlabList:
         return int(self._current_page)
 
     @property
-    def prev_page(self) -> Optional[int]:
+    def prev_page(self) -> int | None:
         """The previous page number.
 
         If None, the current page is the first.
@@ -1229,7 +1209,7 @@ class GitlabList:
         return int(self._prev_page) if self._prev_page else None
 
     @property
-    def next_page(self) -> Optional[int]:
+    def next_page(self) -> int | None:
         """The next page number.
 
         If None, the current page is the last.
@@ -1237,7 +1217,7 @@ class GitlabList:
         return int(self._next_page) if self._next_page else None
 
     @property
-    def per_page(self) -> Optional[int]:
+    def per_page(self) -> int | None:
         """The number of items per page."""
         return int(self._per_page) if self._per_page is not None else None
 
@@ -1245,20 +1225,20 @@ class GitlabList:
     # the headers 'x-total-pages' and 'x-total'. In those cases we return None.
     # https://docs.gitlab.com/ee/user/gitlab_com/index.html#pagination-response-headers
     @property
-    def total_pages(self) -> Optional[int]:
+    def total_pages(self) -> int | None:
         """The total number of pages."""
         if self._total_pages is not None:
             return int(self._total_pages)
         return None
 
     @property
-    def total(self) -> Optional[int]:
+    def total(self) -> int | None:
         """The total number of items."""
         if self._total is not None:
             return int(self._total)
         return None
 
-    def __iter__(self) -> "GitlabList":
+    def __iter__(self) -> GitlabList:
         return self
 
     def __len__(self) -> int:
@@ -1266,10 +1246,10 @@ class GitlabList:
             return 0
         return int(self._total)
 
-    def __next__(self) -> Dict[str, Any]:
+    def __next__(self) -> dict[str, Any]:
         return self.next()
 
-    def next(self) -> Dict[str, Any]:
+    def next(self) -> dict[str, Any]:
         try:
             item = self._data[self._current]
             self._current += 1
@@ -1287,11 +1267,11 @@ class GitlabList:
 class _BaseGraphQL:
     def __init__(
         self,
-        url: Optional[str] = None,
+        url: str | None = None,
         *,
-        token: Optional[str] = None,
-        ssl_verify: Union[bool, str] = True,
-        timeout: Optional[float] = None,
+        token: str | None = None,
+        ssl_verify: bool | str = True,
+        timeout: float | None = None,
         user_agent: str = gitlab.const.USER_AGENT,
         fetch_schema_from_transport: bool = False,
         max_retries: int = 10,
@@ -1316,7 +1296,7 @@ class _BaseGraphQL:
         self._client_opts = self._get_client_opts()
         self._fetch_schema_from_transport = fetch_schema_from_transport
 
-    def _get_client_opts(self) -> Dict[str, Any]:
+    def _get_client_opts(self) -> dict[str, Any]:
         headers = {"User-Agent": self._user_agent}
 
         if self._token:
@@ -1332,12 +1312,12 @@ class _BaseGraphQL:
 class GraphQL(_BaseGraphQL):
     def __init__(
         self,
-        url: Optional[str] = None,
+        url: str | None = None,
         *,
-        token: Optional[str] = None,
-        ssl_verify: Union[bool, str] = True,
-        client: Optional[httpx.Client] = None,
-        timeout: Optional[float] = None,
+        token: str | None = None,
+        ssl_verify: bool | str = True,
+        client: httpx.Client | None = None,
+        timeout: float | None = None,
         user_agent: str = gitlab.const.USER_AGENT,
         fetch_schema_from_transport: bool = False,
         max_retries: int = 10,
@@ -1364,15 +1344,13 @@ class GraphQL(_BaseGraphQL):
         )
         self._gql = gql.gql
 
-    def __enter__(self) -> "GraphQL":
+    def __enter__(self) -> GraphQL:
         return self
 
     def __exit__(self, *args: Any) -> None:
         self._http_client.close()
 
-    def execute(
-        self, request: Union[str, graphql.Source], *args: Any, **kwargs: Any
-    ) -> Any:
+    def execute(self, request: str | graphql.Source, *args: Any, **kwargs: Any) -> Any:
         parsed_document = self._gql(request)
         retry = utils.Retry(
             max_retries=self._max_retries,
@@ -1391,13 +1369,11 @@ class GraphQL(_BaseGraphQL):
 
                 if e.code == 401:
                     raise gitlab.exceptions.GitlabAuthenticationError(
-                        response_code=e.code,
-                        error_message=str(e),
+                        response_code=e.code, error_message=str(e)
                     )
 
                 raise gitlab.exceptions.GitlabHttpError(
-                    response_code=e.code,
-                    error_message=str(e),
+                    response_code=e.code, error_message=str(e)
                 )
 
             return result
@@ -1406,12 +1382,12 @@ class GraphQL(_BaseGraphQL):
 class AsyncGraphQL(_BaseGraphQL):
     def __init__(
         self,
-        url: Optional[str] = None,
+        url: str | None = None,
         *,
-        token: Optional[str] = None,
-        ssl_verify: Union[bool, str] = True,
-        client: Optional[httpx.AsyncClient] = None,
-        timeout: Optional[float] = None,
+        token: str | None = None,
+        ssl_verify: bool | str = True,
+        client: httpx.AsyncClient | None = None,
+        timeout: float | None = None,
         user_agent: str = gitlab.const.USER_AGENT,
         fetch_schema_from_transport: bool = False,
         max_retries: int = 10,
@@ -1438,14 +1414,14 @@ class AsyncGraphQL(_BaseGraphQL):
         )
         self._gql = gql.gql
 
-    async def __aenter__(self) -> "AsyncGraphQL":
+    async def __aenter__(self) -> AsyncGraphQL:
         return self
 
     async def __aexit__(self, *args: Any) -> None:
         await self._http_client.aclose()
 
     async def execute(
-        self, request: Union[str, graphql.Source], *args: Any, **kwargs: Any
+        self, request: str | graphql.Source, *args: Any, **kwargs: Any
     ) -> Any:
         parsed_document = self._gql(request)
         retry = utils.Retry(
@@ -1467,13 +1443,11 @@ class AsyncGraphQL(_BaseGraphQL):
 
                 if e.code == 401:
                     raise gitlab.exceptions.GitlabAuthenticationError(
-                        response_code=e.code,
-                        error_message=str(e),
+                        response_code=e.code, error_message=str(e)
                     )
 
                 raise gitlab.exceptions.GitlabHttpError(
-                    response_code=e.code,
-                    error_message=str(e),
+                    response_code=e.code, error_message=str(e)
                 )
 
             return result

gitlab/config.py

@@ -1,14 +1,15 @@
+from __future__ import annotations
+
 import configparser
 import os
 import shlex
 import subprocess
 from os.path import expanduser, expandvars
 from pathlib import Path
-from typing import List, Optional, Union
 
 from gitlab.const import USER_AGENT
 
-_DEFAULT_FILES: List[str] = [
+_DEFAULT_FILES: list[str] = [
     "/etc/python-gitlab.cfg",
     str(Path.home() / ".python-gitlab.cfg"),
 ]
@@ -20,14 +21,12 @@ HELPER_ATTRIBUTES = ["job_token", "http_password", "private_token", "oauth_token
 _CONFIG_PARSER_ERRORS = (configparser.NoOptionError, configparser.NoSectionError)
 
 
-def _resolve_file(filepath: Union[Path, str]) -> str:
+def _resolve_file(filepath: Path | str) -> str:
     resolved = Path(filepath).resolve(strict=True)
     return str(resolved)
 
 
-def _get_config_files(
-    config_files: Optional[List[str]] = None,
-) -> Union[str, List[str]]:
+def _get_config_files(config_files: list[str] | None = None) -> str | list[str]:
     """
     Return resolved path(s) to config files if they exist, with precedence:
     1. Files passed in config_files
@@ -90,23 +89,23 @@ class GitlabConfigHelperError(ConfigError):
 
 class GitlabConfigParser:
     def __init__(
-        self, gitlab_id: Optional[str] = None, config_files: Optional[List[str]] = None
+        self, gitlab_id: str | None = None, config_files: list[str] | None = None
     ) -> None:
         self.gitlab_id = gitlab_id
-        self.http_username: Optional[str] = None
-        self.http_password: Optional[str] = None
-        self.job_token: Optional[str] = None
-        self.oauth_token: Optional[str] = None
-        self.private_token: Optional[str] = None
+        self.http_username: str | None = None
+        self.http_password: str | None = None
+        self.job_token: str | None = None
+        self.oauth_token: str | None = None
+        self.private_token: str | None = None
 
         self.api_version: str = "4"
-        self.order_by: Optional[str] = None
-        self.pagination: Optional[str] = None
-        self.per_page: Optional[int] = None
+        self.order_by: str | None = None
+        self.pagination: str | None = None
+        self.per_page: int | None = None
         self.retry_transient_errors: bool = False
-        self.ssl_verify: Union[bool, str] = True
+        self.ssl_verify: bool | str = True
         self.timeout: int = 60
-        self.url: Optional[str] = None
+        self.url: str | None = None
         self.user_agent: str = USER_AGENT
         self.keep_base_url: bool = False