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

gitlab/mixins.py

@@ -1,19 +1,9 @@
+from __future__ import annotations
+
 import enum
+from collections.abc import Iterator
 from types import ModuleType
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    Iterator,
-    List,
-    Literal,
-    Optional,
-    overload,
-    Tuple,
-    Type,
-    TYPE_CHECKING,
-    Union,
-)
+from typing import Any, Callable, Literal, overload, TYPE_CHECKING
 
 import requests
 
@@ -48,18 +38,16 @@ __all__ = [
 
 if TYPE_CHECKING:
     # When running mypy we use these as the base classes
-    _RestManagerBase = base.RESTManager
     _RestObjectBase = base.RESTObject
 else:
-    _RestManagerBase = object
     _RestObjectBase = object
 
 
-class HeadMixin(_RestManagerBase):
+class HeadMixin(base.RESTManager[base.TObjCls]):
     @exc.on_http_error(exc.GitlabHeadError)
     def head(
-        self, id: Optional[Union[str, int]] = None, **kwargs: Any
-    ) -> "requests.structures.CaseInsensitiveDict[Any]":
+        self, id: str | int | None = None, **kwargs: Any
+    ) -> requests.structures.CaseInsensitiveDict[Any]:
         """Retrieve headers from an endpoint.
 
         Args:
@@ -73,9 +61,6 @@ class HeadMixin(_RestManagerBase):
             GitlabAuthenticationError: If authentication is not correct
             GitlabHeadError: If the server cannot perform the request
         """
-        if TYPE_CHECKING:
-            assert self.path is not None
-
         path = self.path
         if id is not None:
             path = f"{path}/{utils.EncodedId(id)}"
@@ -83,20 +68,11 @@ class HeadMixin(_RestManagerBase):
         return self.gitlab.http_head(path, **kwargs)
 
 
-class GetMixin(HeadMixin, _RestManagerBase):
-    _computed_path: Optional[str]
-    _from_parent_attrs: Dict[str, Any]
-    _obj_cls: Optional[Type[base.RESTObject]]
-    _optional_get_attrs: Tuple[str, ...] = ()
-    _parent: Optional[base.RESTObject]
-    _parent_attrs: Dict[str, Any]
-    _path: Optional[str]
-    gitlab: gitlab.Gitlab
+class GetMixin(HeadMixin[base.TObjCls]):
+    _optional_get_attrs: tuple[str, ...] = ()
 
     @exc.on_http_error(exc.GitlabGetError)
-    def get(
-        self, id: Union[str, int], lazy: bool = False, **kwargs: Any
-    ) -> base.RESTObject:
+    def get(self, id: str | int, lazy: bool = False, **kwargs: Any) -> base.TObjCls:
         """Retrieve a single object.
 
         Args:
@@ -116,8 +92,6 @@ class GetMixin(HeadMixin, _RestManagerBase):
         if isinstance(id, str):
             id = utils.EncodedId(id)
         path = f"{self.path}/{id}"
-        if TYPE_CHECKING:
-            assert self._obj_cls is not None
         if lazy is True:
             if TYPE_CHECKING:
                 assert self._obj_cls._id_attr is not None
@@ -128,18 +102,11 @@ class GetMixin(HeadMixin, _RestManagerBase):
         return self._obj_cls(self, server_data, lazy=lazy)
 
 
-class GetWithoutIdMixin(HeadMixin, _RestManagerBase):
-    _computed_path: Optional[str]
-    _from_parent_attrs: Dict[str, Any]
-    _obj_cls: Optional[Type[base.RESTObject]]
-    _optional_get_attrs: Tuple[str, ...] = ()
-    _parent: Optional[base.RESTObject]
-    _parent_attrs: Dict[str, Any]
-    _path: Optional[str]
-    gitlab: gitlab.Gitlab
+class GetWithoutIdMixin(HeadMixin[base.TObjCls]):
+    _optional_get_attrs: tuple[str, ...] = ()
 
     @exc.on_http_error(exc.GitlabGetError)
-    def get(self, **kwargs: Any) -> base.RESTObject:
+    def get(self, **kwargs: Any) -> base.TObjCls:
         """Retrieve a single object.
 
         Args:
@@ -152,22 +119,19 @@ class GetWithoutIdMixin(HeadMixin, _RestManagerBase):
             GitlabAuthenticationError: If authentication is not correct
             GitlabGetError: If the server cannot perform the request
         """
-        if TYPE_CHECKING:
-            assert self.path is not None
         server_data = self.gitlab.http_get(self.path, **kwargs)
         if TYPE_CHECKING:
             assert not isinstance(server_data, requests.Response)
-            assert self._obj_cls is not None
         return self._obj_cls(self, server_data)
 
 
 class RefreshMixin(_RestObjectBase):
-    _id_attr: Optional[str]
-    _attrs: Dict[str, Any]
+    _id_attr: str | None
+    _attrs: dict[str, Any]
     _module: ModuleType
-    _parent_attrs: Dict[str, Any]
-    _updated_attrs: Dict[str, Any]
-    manager: base.RESTManager
+    _parent_attrs: dict[str, Any]
+    _updated_attrs: dict[str, Any]
+    manager: base.RESTManager[Any]
 
     @exc.on_http_error(exc.GitlabGetError)
     def refresh(self, **kwargs: Any) -> None:
@@ -194,22 +158,32 @@ class RefreshMixin(_RestObjectBase):
         self._update_attrs(server_data)
 
 
-class ListMixin(HeadMixin, _RestManagerBase):
-    _computed_path: Optional[str]
-    _from_parent_attrs: Dict[str, Any]
-    _list_filters: Tuple[str, ...] = ()
-    _obj_cls: Optional[Type[base.RESTObject]]
-    _parent: Optional[base.RESTObject]
-    _parent_attrs: Dict[str, Any]
-    _path: Optional[str]
-    gitlab: gitlab.Gitlab
+class ListMixin(HeadMixin[base.TObjCls]):
+    _list_filters: tuple[str, ...] = ()
+
+    @overload
+    def list(
+        self, *, iterator: Literal[False] = False, **kwargs: Any
+    ) -> list[base.TObjCls]: ...
+
+    @overload
+    def list(
+        self, *, iterator: Literal[True] = True, **kwargs: Any
+    ) -> base.RESTObjectList[base.TObjCls]: ...
+
+    @overload
+    def list(
+        self, *, iterator: bool = False, **kwargs: Any
+    ) -> base.RESTObjectList[base.TObjCls] | list[base.TObjCls]: ...
 
     @exc.on_http_error(exc.GitlabListError)
-    def list(self, **kwargs: Any) -> Union[base.RESTObjectList, List[base.RESTObject]]:
+    def list(
+        self, *, iterator: bool = False, **kwargs: Any
+    ) -> base.RESTObjectList[base.TObjCls] | list[base.TObjCls]:
         """Retrieve a list of objects.
 
         Args:
-            all: If True, return all the items, without pagination
+            get_all: If True, return all the items, without pagination
             per_page: Number of items to retrieve per request
             page: ID of the page to return (starts with page 1)
             iterator: If set to True and no pagination option is
@@ -244,37 +218,18 @@ class ListMixin(HeadMixin, _RestManagerBase):
         # Allow to overwrite the path, handy for custom listings
         path = data.pop("path", self.path)
 
-        if TYPE_CHECKING:
-            assert self._obj_cls is not None
-        obj = self.gitlab.http_list(path, **data)
+        obj = self.gitlab.http_list(path, iterator=iterator, **data)
         if isinstance(obj, list):
             return [self._obj_cls(self, item, created_from_list=True) for item in obj]
         return base.RESTObjectList(self, self._obj_cls, obj)
 
 
-class RetrieveMixin(ListMixin, GetMixin):
-    _computed_path: Optional[str]
-    _from_parent_attrs: Dict[str, Any]
-    _obj_cls: Optional[Type[base.RESTObject]]
-    _parent: Optional[base.RESTObject]
-    _parent_attrs: Dict[str, Any]
-    _path: Optional[str]
-    gitlab: gitlab.Gitlab
-
+class RetrieveMixin(ListMixin[base.TObjCls], GetMixin[base.TObjCls]): ...
 
-class CreateMixin(_RestManagerBase):
-    _computed_path: Optional[str]
-    _from_parent_attrs: Dict[str, Any]
-    _obj_cls: Optional[Type[base.RESTObject]]
-    _parent: Optional[base.RESTObject]
-    _parent_attrs: Dict[str, Any]
-    _path: Optional[str]
-    gitlab: gitlab.Gitlab
 
+class CreateMixin(base.RESTManager[base.TObjCls]):
     @exc.on_http_error(exc.GitlabCreateError)
-    def create(
-        self, data: Optional[Dict[str, Any]] = None, **kwargs: Any
-    ) -> base.RESTObject:
+    def create(self, data: dict[str, Any] | None = None, **kwargs: Any) -> base.TObjCls:
         """Create a new object.
 
         Args:
@@ -303,7 +258,6 @@ class CreateMixin(_RestManagerBase):
         server_data = self.gitlab.http_post(path, post_data=data, files=files, **kwargs)
         if TYPE_CHECKING:
             assert not isinstance(server_data, requests.Response)
-            assert self._obj_cls is not None
         return self._obj_cls(self, server_data)
 
 
@@ -314,19 +268,11 @@ class UpdateMethod(enum.IntEnum):
     PATCH = 3
 
 
-class UpdateMixin(_RestManagerBase):
-    _computed_path: Optional[str]
-    _from_parent_attrs: Dict[str, Any]
-    _obj_cls: Optional[Type[base.RESTObject]]
-    _parent: Optional[base.RESTObject]
-    _parent_attrs: Dict[str, Any]
-    _path: Optional[str]
+class UpdateMixin(base.RESTManager[base.TObjCls]):
+    # Update mixins attrs for easier implementation
     _update_method: UpdateMethod = UpdateMethod.PUT
-    gitlab: gitlab.Gitlab
 
-    def _get_update_method(
-        self,
-    ) -> Callable[..., Union[Dict[str, Any], requests.Response]]:
+    def _get_update_method(self) -> Callable[..., dict[str, Any] | requests.Response]:
         """Return the HTTP method to use.
 
         Returns:
@@ -344,10 +290,10 @@ class UpdateMixin(_RestManagerBase):
     @exc.on_http_error(exc.GitlabUpdateError)
     def update(
         self,
-        id: Optional[Union[str, int]] = None,
-        new_data: Optional[Dict[str, Any]] = None,
+        id: str | int | None = None,
+        new_data: dict[str, Any] | None = None,
         **kwargs: Any,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Update an object on the server.
 
         Args:
@@ -384,17 +330,9 @@ class UpdateMixin(_RestManagerBase):
         return result
 
 
-class SetMixin(_RestManagerBase):
-    _computed_path: Optional[str]
-    _from_parent_attrs: Dict[str, Any]
-    _obj_cls: Optional[Type[base.RESTObject]]
-    _parent: Optional[base.RESTObject]
-    _parent_attrs: Dict[str, Any]
-    _path: Optional[str]
-    gitlab: gitlab.Gitlab
-
+class SetMixin(base.RESTManager[base.TObjCls]):
     @exc.on_http_error(exc.GitlabSetError)
-    def set(self, key: str, value: str, **kwargs: Any) -> base.RESTObject:
+    def set(self, key: str, value: str, **kwargs: Any) -> base.TObjCls:
         """Create or update the object.
 
         Args:
@@ -414,21 +352,12 @@ class SetMixin(_RestManagerBase):
         server_data = self.gitlab.http_put(path, post_data=data, **kwargs)
         if TYPE_CHECKING:
             assert not isinstance(server_data, requests.Response)
-            assert self._obj_cls is not None
         return self._obj_cls(self, server_data)
 
 
-class DeleteMixin(_RestManagerBase):
-    _computed_path: Optional[str]
-    _from_parent_attrs: Dict[str, Any]
-    _obj_cls: Optional[Type[base.RESTObject]]
-    _parent: Optional[base.RESTObject]
-    _parent_attrs: Dict[str, Any]
-    _path: Optional[str]
-    gitlab: gitlab.Gitlab
-
+class DeleteMixin(base.RESTManager[base.TObjCls]):
     @exc.on_http_error(exc.GitlabDeleteError)
-    def delete(self, id: Optional[Union[str, int]] = None, **kwargs: Any) -> None:
+    def delete(self, id: str | int | None = None, **kwargs: Any) -> None:
         """Delete an object on the server.
 
         Args:
@@ -444,42 +373,37 @@ class DeleteMixin(_RestManagerBase):
         else:
             path = f"{self.path}/{utils.EncodedId(id)}"
 
-        if TYPE_CHECKING:
-            assert path is not None
         self.gitlab.http_delete(path, **kwargs)
 
 
-class CRUDMixin(GetMixin, ListMixin, CreateMixin, UpdateMixin, DeleteMixin):
-    _computed_path: Optional[str]
-    _from_parent_attrs: Dict[str, Any]
-    _obj_cls: Optional[Type[base.RESTObject]]
-    _parent: Optional[base.RESTObject]
-    _parent_attrs: Dict[str, Any]
-    _path: Optional[str]
-    gitlab: gitlab.Gitlab
+class CRUDMixin(
+    GetMixin[base.TObjCls],
+    ListMixin[base.TObjCls],
+    CreateMixin[base.TObjCls],
+    UpdateMixin[base.TObjCls],
+    DeleteMixin[base.TObjCls],
+): ...
 
 
-class NoUpdateMixin(GetMixin, ListMixin, CreateMixin, DeleteMixin):
-    _computed_path: Optional[str]
-    _from_parent_attrs: Dict[str, Any]
-    _obj_cls: Optional[Type[base.RESTObject]]
-    _parent: Optional[base.RESTObject]
-    _parent_attrs: Dict[str, Any]
-    _path: Optional[str]
-    gitlab: gitlab.Gitlab
+class NoUpdateMixin(
+    GetMixin[base.TObjCls],
+    ListMixin[base.TObjCls],
+    CreateMixin[base.TObjCls],
+    DeleteMixin[base.TObjCls],
+): ...
 
 
 class SaveMixin(_RestObjectBase):
     """Mixin for RESTObject's that can be updated."""
 
-    _id_attr: Optional[str]
-    _attrs: Dict[str, Any]
+    _id_attr: str | None
+    _attrs: dict[str, Any]
     _module: ModuleType
-    _parent_attrs: Dict[str, Any]
-    _updated_attrs: Dict[str, Any]
-    manager: base.RESTManager
+    _parent_attrs: dict[str, Any]
+    _updated_attrs: dict[str, Any]
+    manager: base.RESTManager[Any]
 
-    def _get_updated_data(self) -> Dict[str, Any]:
+    def _get_updated_data(self) -> dict[str, Any]:
         updated_data = {}
         for attr in self.manager._update_attrs.required:
             # Get everything required, no matter if it's been updated
@@ -489,7 +413,7 @@ class SaveMixin(_RestObjectBase):
 
         return updated_data
 
-    def save(self, **kwargs: Any) -> Optional[Dict[str, Any]]:
+    def save(self, **kwargs: Any) -> dict[str, Any] | None:
         """Save the changes made to the object to the server.
 
         The object is updated to match what the server returns.
@@ -521,12 +445,12 @@ class SaveMixin(_RestObjectBase):
 class ObjectDeleteMixin(_RestObjectBase):
     """Mixin for RESTObject's that can be deleted."""
 
-    _id_attr: Optional[str]
-    _attrs: Dict[str, Any]
+    _id_attr: str | None
+    _attrs: dict[str, Any]
     _module: ModuleType
-    _parent_attrs: Dict[str, Any]
-    _updated_attrs: Dict[str, Any]
-    manager: base.RESTManager
+    _parent_attrs: dict[str, Any]
+    _updated_attrs: dict[str, Any]
+    manager: base.RESTManager[Any]
 
     def delete(self, **kwargs: Any) -> None:
         """Delete the object from the server.
@@ -545,16 +469,16 @@ class ObjectDeleteMixin(_RestObjectBase):
 
 
 class UserAgentDetailMixin(_RestObjectBase):
-    _id_attr: Optional[str]
-    _attrs: Dict[str, Any]
+    _id_attr: str | None
+    _attrs: dict[str, Any]
     _module: ModuleType
-    _parent_attrs: Dict[str, Any]
-    _updated_attrs: Dict[str, Any]
-    manager: base.RESTManager
+    _parent_attrs: dict[str, Any]
+    _updated_attrs: dict[str, Any]
+    manager: base.RESTManager[Any]
 
     @cli.register_custom_action(cls_names=("Snippet", "ProjectSnippet", "ProjectIssue"))
     @exc.on_http_error(exc.GitlabGetError)
-    def user_agent_detail(self, **kwargs: Any) -> Dict[str, Any]:
+    def user_agent_detail(self, **kwargs: Any) -> dict[str, Any]:
         """Get the user agent detail.
 
         Args:
@@ -572,12 +496,12 @@ class UserAgentDetailMixin(_RestObjectBase):
 
 
 class AccessRequestMixin(_RestObjectBase):
-    _id_attr: Optional[str]
-    _attrs: Dict[str, Any]
+    _id_attr: str | None
+    _attrs: dict[str, Any]
     _module: ModuleType
-    _parent_attrs: Dict[str, Any]
-    _updated_attrs: Dict[str, Any]
-    manager: base.RESTManager
+    _parent_attrs: dict[str, Any]
+    _updated_attrs: dict[str, Any]
+    manager: base.RESTManager[Any]
 
     @cli.register_custom_action(
         cls_names=("ProjectAccessRequest", "GroupAccessRequest"),
@@ -607,12 +531,12 @@ class AccessRequestMixin(_RestObjectBase):
 
 
 class DownloadMixin(_RestObjectBase):
-    _id_attr: Optional[str]
-    _attrs: Dict[str, Any]
+    _id_attr: str | None
+    _attrs: dict[str, Any]
     _module: ModuleType
-    _parent_attrs: Dict[str, Any]
-    _updated_attrs: Dict[str, Any]
-    manager: base.RESTManager
+    _parent_attrs: dict[str, Any]
+    _updated_attrs: dict[str, Any]
+    manager: base.RESTManager[Any]
 
     @overload
     def download(
@@ -640,7 +564,7 @@ class DownloadMixin(_RestObjectBase):
     def download(
         self,
         streamed: Literal[True] = True,
-        action: Optional[Callable[[bytes], Any]] = None,
+        action: Callable[[bytes], Any] | None = None,
         chunk_size: int = 1024,
         *,
         iterator: Literal[False] = False,
@@ -652,12 +576,12 @@ class DownloadMixin(_RestObjectBase):
     def download(
         self,
         streamed: bool = False,
-        action: Optional[Callable[[bytes], Any]] = None,
+        action: Callable[[bytes], Any] | None = None,
         chunk_size: int = 1024,
         *,
         iterator: bool = False,
         **kwargs: Any,
-    ) -> Optional[Union[bytes, Iterator[Any]]]:
+    ) -> bytes | Iterator[Any] | None:
         """Download the archive of a resource export.
 
         Args:
@@ -689,15 +613,7 @@ class DownloadMixin(_RestObjectBase):
         )
 
 
-class RotateMixin(_RestManagerBase):
-    _computed_path: Optional[str]
-    _from_parent_attrs: Dict[str, Any]
-    _obj_cls: Optional[Type[base.RESTObject]]
-    _parent: Optional[base.RESTObject]
-    _parent_attrs: Dict[str, Any]
-    _path: Optional[str]
-    gitlab: gitlab.Gitlab
-
+class RotateMixin(base.RESTManager[base.TObjCls]):
     @cli.register_custom_action(
         cls_names=(
             "PersonalAccessTokenManager",
@@ -708,8 +624,8 @@ class RotateMixin(_RestManagerBase):
     )
     @exc.on_http_error(exc.GitlabRotateError)
     def rotate(
-        self, id: Union[str, int], expires_at: Optional[str] = None, **kwargs: Any
-    ) -> Dict[str, Any]:
+        self, id: str | int, expires_at: str | None = None, **kwargs: Any
+    ) -> dict[str, Any]:
         """Rotate an access token.
 
         Args:
@@ -721,7 +637,7 @@ class RotateMixin(_RestManagerBase):
             GitlabRotateError: If the server cannot perform the request
         """
         path = f"{self.path}/{utils.EncodedId(id)}/rotate"
-        data: Dict[str, Any] = {}
+        data: dict[str, Any] = {}
         if expires_at is not None:
             data = {"expires_at": expires_at}
 
@@ -732,22 +648,23 @@ class RotateMixin(_RestManagerBase):
 
 
 class ObjectRotateMixin(_RestObjectBase):
-    _id_attr: Optional[str]
-    _attrs: Dict[str, Any]
+    _id_attr: str | None
+    _attrs: dict[str, Any]
     _module: ModuleType
-    _parent_attrs: Dict[str, Any]
-    _updated_attrs: Dict[str, Any]
-    manager: base.RESTManager
+    _parent_attrs: dict[str, Any]
+    _updated_attrs: dict[str, Any]
+    manager: base.RESTManager[Any]
 
     @cli.register_custom_action(
         cls_names=("PersonalAccessToken", "GroupAccessToken", "ProjectAccessToken"),
         optional=("expires_at",),
     )
     @exc.on_http_error(exc.GitlabRotateError)
-    def rotate(self, **kwargs: Any) -> Dict[str, Any]:
+    def rotate(self, *, self_rotate: bool = False, **kwargs: Any) -> dict[str, Any]:
         """Rotate the current access token object.
 
         Args:
+            self_rotate: If True, the current access token object will be rotated.
             **kwargs: Extra options to send to the server (e.g. sudo)
 
         Raises:
@@ -757,18 +674,19 @@ class ObjectRotateMixin(_RestObjectBase):
         if TYPE_CHECKING:
             assert isinstance(self.manager, RotateMixin)
             assert self.encoded_id is not None
-        server_data = self.manager.rotate(self.encoded_id, **kwargs)
+        token_id = "self" if self_rotate else self.encoded_id
+        server_data = self.manager.rotate(token_id, **kwargs)
         self._update_attrs(server_data)
         return server_data
 
 
 class SubscribableMixin(_RestObjectBase):
-    _id_attr: Optional[str]
-    _attrs: Dict[str, Any]
+    _id_attr: str | None
+    _attrs: dict[str, Any]
     _module: ModuleType
-    _parent_attrs: Dict[str, Any]
-    _updated_attrs: Dict[str, Any]
-    manager: base.RESTManager
+    _parent_attrs: dict[str, Any]
+    _updated_attrs: dict[str, Any]
+    manager: base.RESTManager[Any]
 
     @cli.register_custom_action(
         cls_names=("ProjectIssue", "ProjectMergeRequest", "ProjectLabel", "GroupLabel")
@@ -812,12 +730,12 @@ class SubscribableMixin(_RestObjectBase):
 
 
 class TodoMixin(_RestObjectBase):
-    _id_attr: Optional[str]
-    _attrs: Dict[str, Any]
+    _id_attr: str | None
+    _attrs: dict[str, Any]
     _module: ModuleType
-    _parent_attrs: Dict[str, Any]
-    _updated_attrs: Dict[str, Any]
-    manager: base.RESTManager
+    _parent_attrs: dict[str, Any]
+    _updated_attrs: dict[str, Any]
+    manager: base.RESTManager[Any]
 
     @cli.register_custom_action(cls_names=("ProjectIssue", "ProjectMergeRequest"))
     @exc.on_http_error(exc.GitlabTodoError)
@@ -836,16 +754,16 @@ class TodoMixin(_RestObjectBase):
 
 
 class TimeTrackingMixin(_RestObjectBase):
-    _id_attr: Optional[str]
-    _attrs: Dict[str, Any]
+    _id_attr: str | None
+    _attrs: dict[str, Any]
     _module: ModuleType
-    _parent_attrs: Dict[str, Any]
-    _updated_attrs: Dict[str, Any]
-    manager: base.RESTManager
+    _parent_attrs: dict[str, Any]
+    _updated_attrs: dict[str, Any]
+    manager: base.RESTManager[Any]
 
     @cli.register_custom_action(cls_names=("ProjectIssue", "ProjectMergeRequest"))
     @exc.on_http_error(exc.GitlabTimeTrackingError)
-    def time_stats(self, **kwargs: Any) -> Dict[str, Any]:
+    def time_stats(self, **kwargs: Any) -> dict[str, Any]:
         """Get time stats for the object.
 
         Args:
@@ -873,7 +791,7 @@ class TimeTrackingMixin(_RestObjectBase):
         cls_names=("ProjectIssue", "ProjectMergeRequest"), required=("duration",)
     )
     @exc.on_http_error(exc.GitlabTimeTrackingError)
-    def time_estimate(self, duration: str, **kwargs: Any) -> Dict[str, Any]:
+    def time_estimate(self, duration: str, **kwargs: Any) -> dict[str, Any]:
         """Set an estimated time of work for the object.
 
         Args:
@@ -893,7 +811,7 @@ class TimeTrackingMixin(_RestObjectBase):
 
     @cli.register_custom_action(cls_names=("ProjectIssue", "ProjectMergeRequest"))
     @exc.on_http_error(exc.GitlabTimeTrackingError)
-    def reset_time_estimate(self, **kwargs: Any) -> Dict[str, Any]:
+    def reset_time_estimate(self, **kwargs: Any) -> dict[str, Any]:
         """Resets estimated time for the object to 0 seconds.
 
         Args:
@@ -913,7 +831,7 @@ class TimeTrackingMixin(_RestObjectBase):
         cls_names=("ProjectIssue", "ProjectMergeRequest"), required=("duration",)
     )
     @exc.on_http_error(exc.GitlabTimeTrackingError)
-    def add_spent_time(self, duration: str, **kwargs: Any) -> Dict[str, Any]:
+    def add_spent_time(self, duration: str, **kwargs: Any) -> dict[str, Any]:
         """Add time spent working on the object.
 
         Args:
@@ -933,7 +851,7 @@ class TimeTrackingMixin(_RestObjectBase):
 
     @cli.register_custom_action(cls_names=("ProjectIssue", "ProjectMergeRequest"))
     @exc.on_http_error(exc.GitlabTimeTrackingError)
-    def reset_spent_time(self, **kwargs: Any) -> Dict[str, Any]:
+    def reset_spent_time(self, **kwargs: Any) -> dict[str, Any]:
         """Resets the time spent working on the object.
 
         Args:
@@ -951,22 +869,22 @@ class TimeTrackingMixin(_RestObjectBase):
 
 
 class ParticipantsMixin(_RestObjectBase):
-    _id_attr: Optional[str]
-    _attrs: Dict[str, Any]
+    _id_attr: str | None
+    _attrs: dict[str, Any]
     _module: ModuleType
-    _parent_attrs: Dict[str, Any]
-    _updated_attrs: Dict[str, Any]
-    manager: base.RESTManager
+    _parent_attrs: dict[str, Any]
+    _updated_attrs: dict[str, Any]
+    manager: base.RESTManager[Any]
 
     @cli.register_custom_action(cls_names=("ProjectMergeRequest", "ProjectIssue"))
     @exc.on_http_error(exc.GitlabListError)
     def participants(
         self, **kwargs: Any
-    ) -> Union[gitlab.client.GitlabList, List[Dict[str, Any]]]:
+    ) -> gitlab.client.GitlabList | list[dict[str, Any]]:
         """List the participants.
 
         Args:
-            all: If True, return all the items, without pagination
+            get_all: If True, return all the items, without pagination
             per_page: Number of items to retrieve per request
             page: ID of the page to return (starts with page 1)
             **kwargs: Extra options to send to the server (e.g. sudo)
@@ -986,13 +904,13 @@ class ParticipantsMixin(_RestObjectBase):
         return result
 
 
-class BadgeRenderMixin(_RestManagerBase):
+class BadgeRenderMixin(base.RESTManager[base.TObjCls]):
     @cli.register_custom_action(
         cls_names=("GroupBadgeManager", "ProjectBadgeManager"),
         required=("link_url", "image_url"),
     )
     @exc.on_http_error(exc.GitlabRenderError)
-    def render(self, link_url: str, image_url: str, **kwargs: Any) -> Dict[str, Any]:
+    def render(self, link_url: str, image_url: str, **kwargs: Any) -> dict[str, Any]:
         """Preview link_url and image_url after interpolation.
 
         Args:
@@ -1016,17 +934,15 @@ class BadgeRenderMixin(_RestManagerBase):
 
 
 class PromoteMixin(_RestObjectBase):
-    _id_attr: Optional[str]
-    _attrs: Dict[str, Any]
+    _id_attr: str | None
+    _attrs: dict[str, Any]
     _module: ModuleType
-    _parent_attrs: Dict[str, Any]
-    _updated_attrs: Dict[str, Any]
+    _parent_attrs: dict[str, Any]
+    _updated_attrs: dict[str, Any]
     _update_method: UpdateMethod = UpdateMethod.PUT
-    manager: base.RESTManager
+    manager: base.RESTManager[Any]
 
-    def _get_update_method(
-        self,
-    ) -> Callable[..., Union[Dict[str, Any], requests.Response]]:
+    def _get_update_method(self) -> Callable[..., dict[str, Any] | requests.Response]:
         """Return the HTTP method to use.
 
         Returns:
@@ -1039,7 +955,7 @@ class PromoteMixin(_RestObjectBase):
         return http_method
 
     @exc.on_http_error(exc.GitlabPromoteError)
-    def promote(self, **kwargs: Any) -> Dict[str, Any]:
+    def promote(self, **kwargs: Any) -> dict[str, Any]:
         """Promote the item.
 
         Args:
@@ -1063,13 +979,13 @@ class PromoteMixin(_RestObjectBase):
 
 
 class UploadMixin(_RestObjectBase):
-    _id_attr: Optional[str]
-    _attrs: Dict[str, Any]
+    _id_attr: str | None
+    _attrs: dict[str, Any]
     _module: ModuleType
-    _parent_attrs: Dict[str, Any]
-    _updated_attrs: Dict[str, Any]
+    _parent_attrs: dict[str, Any]
+    _updated_attrs: dict[str, Any]
     _upload_path: str
-    manager: base.RESTManager
+    manager: base.RESTManager[Any]
 
     def _get_upload_path(self) -> str:
         """Formats _upload_path with object attributes.
@@ -1089,10 +1005,10 @@ class UploadMixin(_RestObjectBase):
     def upload(
         self,
         filename: str,
-        filedata: Optional[bytes] = None,
-        filepath: Optional[str] = None,
+        filedata: bytes | None = None,
+        filepath: str | None = None,
         **kwargs: Any,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Upload the specified file.
 
         .. note::