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

gitlab/types.py

@@ -1,18 +1,17 @@
+from __future__ import annotations
+
 import dataclasses
-from typing import Any, Dict, List, Optional, Tuple, TYPE_CHECKING
+from typing import Any, TYPE_CHECKING
 
 
 @dataclasses.dataclass(frozen=True)
 class RequiredOptional:
-    required: Tuple[str, ...] = ()
-    optional: Tuple[str, ...] = ()
-    exclusive: Tuple[str, ...] = ()
+    required: tuple[str, ...] = ()
+    optional: tuple[str, ...] = ()
+    exclusive: tuple[str, ...] = ()
 
     def validate_attrs(
-        self,
-        *,
-        data: Dict[str, Any],
-        excludes: Optional[List[str]] = None,
+        self, *, data: dict[str, Any], excludes: list[str] | None = None
     ) -> None:
         if excludes is None:
             excludes = []
@@ -46,7 +45,7 @@ class GitlabAttribute:
     def set_from_cli(self, cli_value: Any) -> None:
         self._value = cli_value
 
-    def get_for_api(self, *, key: str) -> Tuple[str, Any]:
+    def get_for_api(self, *, key: str) -> tuple[str, Any]:
         return (key, self._value)
 
 
@@ -59,7 +58,7 @@ class _ListArrayAttribute(GitlabAttribute):
         else:
             self._value = [item.strip() for item in cli_value.split(",")]
 
-    def get_for_api(self, *, key: str) -> Tuple[str, str]:
+    def get_for_api(self, *, key: str) -> tuple[str, str]:
         # Do not comma-split single value passed as string
         if isinstance(self._value, str):
             return (key, self._value)
@@ -73,7 +72,7 @@ class ArrayAttribute(_ListArrayAttribute):
     """To support `array` types as documented in
     https://docs.gitlab.com/ee/api/#array"""
 
-    def get_for_api(self, *, key: str) -> Tuple[str, Any]:
+    def get_for_api(self, *, key: str) -> tuple[str, Any]:
         if isinstance(self._value, str):
             return (f"{key}[]", self._value)
 
@@ -89,17 +88,17 @@ class CommaSeparatedListAttribute(_ListArrayAttribute):
 
 
 class LowercaseStringAttribute(GitlabAttribute):
-    def get_for_api(self, *, key: str) -> Tuple[str, str]:
+    def get_for_api(self, *, key: str) -> tuple[str, str]:
         return (key, str(self._value).lower())
 
 
 class FileAttribute(GitlabAttribute):
     @staticmethod
-    def get_file_name(attr_name: Optional[str] = None) -> Optional[str]:
+    def get_file_name(attr_name: str | None = None) -> str | None:
         return attr_name
 
 
 class ImageAttribute(FileAttribute):
     @staticmethod
-    def get_file_name(attr_name: Optional[str] = None) -> str:
+    def get_file_name(attr_name: str | None = None) -> str:
         return f"{attr_name}.png" if attr_name else "image.png"

gitlab/utils.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import dataclasses
 import email.message
 import logging
@@ -6,18 +8,8 @@ import time
 import traceback
 import urllib.parse
 import warnings
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    Iterator,
-    Literal,
-    MutableMapping,
-    Optional,
-    Tuple,
-    Type,
-    Union,
-)
+from collections.abc import Iterator, MutableMapping
+from typing import Any, Callable, Literal
 
 import requests
 
@@ -29,7 +21,7 @@ class _StdoutStream:
         print(chunk)
 
 
-def get_base_url(url: Optional[str] = None) -> str:
+def get_base_url(url: str | None = None) -> str:
     """Return the base URL with the trailing slash stripped.
     If the URL is a Falsy value, return the default URL.
     Returns:
@@ -41,7 +33,7 @@ def get_base_url(url: Optional[str] = None) -> str:
     return url.rstrip("/")
 
 
-def get_content_type(content_type: Optional[str]) -> str:
+def get_content_type(content_type: str | None) -> str:
     message = email.message.Message()
     if content_type is not None:
         message["content-type"] = content_type
@@ -54,11 +46,11 @@ class MaskingFormatter(logging.Formatter):
 
     def __init__(
         self,
-        fmt: Optional[str] = logging.BASIC_FORMAT,
-        datefmt: Optional[str] = None,
+        fmt: str | None = logging.BASIC_FORMAT,
+        datefmt: str | None = None,
         style: Literal["%", "{", "$"] = "%",
         validate: bool = True,
-        masked: Optional[str] = None,
+        masked: str | None = None,
     ) -> None:
         super().__init__(fmt, datefmt, style, validate)
         self.masked = masked
@@ -77,11 +69,11 @@ class MaskingFormatter(logging.Formatter):
 def response_content(
     response: requests.Response,
     streamed: bool,
-    action: Optional[Callable[[bytes], Any]],
+    action: Callable[[bytes], Any] | None,
     chunk_size: int,
     *,
     iterator: bool,
-) -> Optional[Union[bytes, Iterator[Any]]]:
+) -> bytes | Iterator[Any] | None:
     if iterator:
         return response.iter_content(chunk_size=chunk_size)
 
@@ -101,17 +93,15 @@ class Retry:
     def __init__(
         self,
         max_retries: int,
-        obey_rate_limit: Optional[bool] = True,
-        retry_transient_errors: Optional[bool] = False,
+        obey_rate_limit: bool | None = True,
+        retry_transient_errors: bool | None = False,
     ) -> None:
         self.cur_retries = 0
         self.max_retries = max_retries
         self.obey_rate_limit = obey_rate_limit
         self.retry_transient_errors = retry_transient_errors
 
-    def _retryable_status_code(
-        self, status_code: Optional[int], reason: str = ""
-    ) -> bool:
+    def _retryable_status_code(self, status_code: int | None, reason: str = "") -> bool:
         if status_code == 429 and self.obey_rate_limit:
             return True
 
@@ -126,8 +116,8 @@ class Retry:
 
     def handle_retry_on_status(
         self,
-        status_code: Optional[int],
-        headers: Optional[MutableMapping[str, str]] = None,
+        status_code: int | None,
+        headers: MutableMapping[str, str] | None = None,
         reason: str = "",
     ) -> bool:
         if not self._retryable_status_code(status_code, reason):
@@ -163,12 +153,12 @@ class Retry:
 
 
 def _transform_types(
-    data: Dict[str, Any],
-    custom_types: Dict[str, Any],
+    data: dict[str, Any],
+    custom_types: dict[str, Any],
     *,
     transform_data: bool,
-    transform_files: Optional[bool] = True,
-) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+    transform_files: bool | None = True,
+) -> tuple[dict[str, Any], dict[str, Any]]:
     """Copy the data dict with attributes that have custom types and transform them
     before being sent to the server.
 
@@ -198,6 +188,12 @@ def _transform_types(
 
         # if the type is FileAttribute we need to pass the data as file
         if isinstance(gitlab_attribute, types.FileAttribute) and transform_files:
+            # The GitLab API accepts mixed types
+            # (e.g. a file for avatar image or empty string for removing the avatar)
+            # So if string is empty, keep it in data dict
+            if isinstance(data[attr_name], str) and data[attr_name] == "":
+                continue
+
             key = gitlab_attribute.get_file_name(attr_name)
             files[attr_name] = (key, data.pop(attr_name))
             continue
@@ -214,11 +210,7 @@ def _transform_types(
     return data, files
 
 
-def copy_dict(
-    *,
-    src: Dict[str, Any],
-    dest: Dict[str, Any],
-) -> None:
+def copy_dict(*, src: dict[str, Any], dest: dict[str, Any]) -> None:
     for k, v in src.items():
         if isinstance(v, dict):
             # NOTE(jlvillal): This provides some support for the `hash` type
@@ -247,7 +239,7 @@ class EncodedId(str):
         https://docs.gitlab.com/ee/api/index.html#path-parameters
     """
 
-    def __new__(cls, value: Union[str, int, "EncodedId"]) -> "EncodedId":
+    def __new__(cls, value: str | int | EncodedId) -> EncodedId:
         if isinstance(value, EncodedId):
             return value
 
@@ -258,15 +250,15 @@ class EncodedId(str):
         return super().__new__(cls, value)
 
 
-def remove_none_from_dict(data: Dict[str, Any]) -> Dict[str, Any]:
+def remove_none_from_dict(data: dict[str, Any]) -> dict[str, Any]:
     return {k: v for k, v in data.items() if v is not None}
 
 
 def warn(
     message: str,
     *,
-    category: Optional[Type[Warning]] = None,
-    source: Optional[Any] = None,
+    category: type[Warning] | None = None,
+    source: Any | None = None,
     show_caller: bool = True,
 ) -> None:
     """This `warnings.warn` wrapper function attempts to show the location causing the
@@ -290,10 +282,7 @@ def warn(
     if show_caller:
         message += warning_from
     warnings.warn(
-        message=message,
-        category=category,
-        stacklevel=stacklevel,
-        source=source,
+        message=message, category=category, stacklevel=stacklevel, source=source
     )
 
 

gitlab/v4/cli.py

@@ -1,8 +1,10 @@
+from __future__ import annotations
+
 import argparse
 import json
 import operator
 import sys
-from typing import Any, Dict, List, Optional, Type, TYPE_CHECKING, Union
+from typing import Any, TYPE_CHECKING
 
 import gitlab
 import gitlab.base
@@ -17,9 +19,9 @@ class GitlabCLI:
         gl: gitlab.Gitlab,
         gitlab_resource: str,
         resource_action: str,
-        args: Dict[str, str],
+        args: dict[str, str],
     ) -> None:
-        self.cls: Type[gitlab.base.RESTObject] = cli.gitlab_resource_to_cls(
+        self.cls: type[gitlab.base.RESTObject] = cli.gitlab_resource_to_cls(
             gitlab_resource, namespace=gitlab.v4.objects
         )
         self.cls_name = self.cls.__name__
@@ -27,26 +29,17 @@ class GitlabCLI:
         self.resource_action = resource_action.lower()
         self.gl = gl
         self.args = args
-        self.parent_args: Dict[str, Any] = {}
-        self.mgr_cls: Union[
-            Type[gitlab.mixins.CreateMixin],
-            Type[gitlab.mixins.DeleteMixin],
-            Type[gitlab.mixins.GetMixin],
-            Type[gitlab.mixins.GetWithoutIdMixin],
-            Type[gitlab.mixins.ListMixin],
-            Type[gitlab.mixins.UpdateMixin],
-        ] = getattr(gitlab.v4.objects, f"{self.cls.__name__}Manager")
+        self.parent_args: dict[str, Any] = {}
+        self.mgr_cls: Any = getattr(gitlab.v4.objects, f"{self.cls.__name__}Manager")
         # We could do something smart, like splitting the manager name to find
         # parents, build the chain of managers to get to the final object.
         # Instead we do something ugly and efficient: interpolate variables in
         # the class _path attribute, and replace the value with the result.
-        if TYPE_CHECKING:
-            assert self.mgr_cls._path is not None
 
         self._process_from_parent_attrs()
 
         self.mgr_cls._path = self.mgr_cls._path.format(**self.parent_args)
-        self.mgr = self.mgr_cls(gl)
+        self.mgr: Any = self.mgr_cls(gl)
         self.mgr._from_parent_attrs = self.parent_args
         if self.mgr_cls._types:
             for attr_name, type_cls in self.mgr_cls._types.items():
@@ -82,7 +75,9 @@ class GitlabCLI:
         return self.do_custom()
 
     def do_custom(self) -> Any:
-        class_instance: Union[gitlab.base.RESTManager, gitlab.base.RESTObject]
+        class_instance: (
+            gitlab.base.RESTManager[gitlab.base.RESTObject] | gitlab.base.RESTObject
+        )
         in_obj = cli.custom_actions[self.cls_name][self.resource_action].in_object
 
         # Get the object (lazy), then act
@@ -132,13 +127,13 @@ class GitlabCLI:
             assert isinstance(self.mgr, gitlab.mixins.CreateMixin)
         try:
             result = self.mgr.create(self.args)
+            if TYPE_CHECKING:
+                assert isinstance(result, gitlab.base.RESTObject)
         except Exception as e:  # pragma: no cover, cli.die is unit-tested
             cli.die("Impossible to create object", e)
         return result
 
-    def do_list(
-        self,
-    ) -> Union[gitlab.base.RESTObjectList, List[gitlab.base.RESTObject]]:
+    def do_list(self) -> list[gitlab.base.RESTObject]:
         if TYPE_CHECKING:
             assert isinstance(self.mgr, gitlab.mixins.ListMixin)
         message_details = gitlab.utils.WarnMessageData(
@@ -150,15 +145,19 @@ class GitlabCLI:
         )
 
         try:
-            result = self.mgr.list(**self.args, message_details=message_details)
+            result = self.mgr.list(
+                **self.args, message_details=message_details, iterator=False
+            )
         except Exception as e:  # pragma: no cover, cli.die is unit-tested
             cli.die("Impossible to list objects", e)
         return result
 
-    def do_get(self) -> Optional[gitlab.base.RESTObject]:
+    def do_get(self) -> gitlab.base.RESTObject | None:
         if isinstance(self.mgr, gitlab.mixins.GetWithoutIdMixin):
             try:
                 result = self.mgr.get(id=None, **self.args)
+                if TYPE_CHECKING:
+                    assert isinstance(result, gitlab.base.RESTObject) or result is None
             except Exception as e:  # pragma: no cover, cli.die is unit-tested
                 cli.die("Impossible to get object", e)
             return result
@@ -170,6 +169,8 @@ class GitlabCLI:
         id = self.args.pop(self.cls._id_attr)
         try:
             result = self.mgr.get(id, lazy=False, **self.args)
+            if TYPE_CHECKING:
+                assert isinstance(result, gitlab.base.RESTObject) or result is None
         except Exception as e:  # pragma: no cover, cli.die is unit-tested
             cli.die("Impossible to get object", e)
         return result
@@ -184,7 +185,7 @@ class GitlabCLI:
         except Exception as e:  # pragma: no cover, cli.die is unit-tested
             cli.die("Impossible to destroy object", e)
 
-    def do_update(self) -> Dict[str, Any]:
+    def do_update(self) -> dict[str, Any]:
         if TYPE_CHECKING:
             assert isinstance(self.mgr, gitlab.mixins.UpdateMixin)
         if issubclass(self.mgr_cls, gitlab.mixins.GetWithoutIdMixin):
@@ -209,13 +210,12 @@ else:
 
 
 def _populate_sub_parser_by_class(
-    cls: Type[gitlab.base.RESTObject],
-    sub_parser: _SubparserType,
+    cls: type[gitlab.base.RESTObject], sub_parser: _SubparserType
 ) -> None:
     mgr_cls_name = f"{cls.__name__}Manager"
     mgr_cls = getattr(gitlab.v4.objects, mgr_cls_name)
 
-    action_parsers: Dict[str, argparse.ArgumentParser] = {}
+    action_parsers: dict[str, argparse.ArgumentParser] = {}
     for action_name, help_text in [
         ("list", "List the GitLab resources"),
         ("get", "Get a GitLab resource"),
@@ -227,9 +227,7 @@ def _populate_sub_parser_by_class(
             continue
 
         sub_parser_action = sub_parser.add_parser(
-            action_name,
-            conflict_handler="resolve",
-            help=help_text,
+            action_name, conflict_handler="resolve", help=help_text
         )
         action_parsers[action_name] = sub_parser_action
         sub_parser_action.add_argument("--sudo", required=False)
@@ -401,16 +399,20 @@ def extend_parser(parser: argparse.ArgumentParser) -> argparse.ArgumentParser:
         if not isinstance(cls, type):
             continue
         if issubclass(cls, gitlab.base.RESTManager):
-            if cls._obj_cls is not None:
-                classes.add(cls._obj_cls)
+            classes.add(cls._obj_cls)
 
     for cls in sorted(classes, key=operator.attrgetter("__name__")):
+        if cls is gitlab.base.RESTObject:
+            # Skip managers where _obj_cls is a plain RESTObject class
+            # Those managers do not actually manage any objects and
+            # can only be used to calls specific API paths.
+            continue
+
         arg_name = cli.cls_to_gitlab_resource(cls)
         mgr_cls_name = f"{cls.__name__}Manager"
         mgr_cls = getattr(gitlab.v4.objects, mgr_cls_name)
         object_group = subparsers.add_parser(
-            arg_name,
-            help=f"API endpoint: {mgr_cls._path}",
+            arg_name, help=f"API endpoint: {mgr_cls._path}"
         )
 
         object_subparsers = object_group.add_subparsers(
@@ -425,8 +427,8 @@ def extend_parser(parser: argparse.ArgumentParser) -> argparse.ArgumentParser:
 
 
 def get_dict(
-    obj: Union[str, Dict[str, Any], gitlab.base.RESTObject], fields: List[str]
-) -> Union[str, Dict[str, Any]]:
+    obj: str | dict[str, Any] | gitlab.base.RESTObject, fields: list[str]
+) -> str | dict[str, Any]:
     if not isinstance(obj, gitlab.base.RESTObject):
         return obj
 
@@ -437,13 +439,13 @@ def get_dict(
 
 class JSONPrinter:
     @staticmethod
-    def display(d: Union[str, Dict[str, Any]], **_kwargs: Any) -> None:
+    def display(d: str | dict[str, Any], **_kwargs: Any) -> None:
         print(json.dumps(d))
 
     @staticmethod
     def display_list(
-        data: List[Union[str, Dict[str, Any], gitlab.base.RESTObject]],
-        fields: List[str],
+        data: list[str | dict[str, Any] | gitlab.base.RESTObject],
+        fields: list[str],
         **_kwargs: Any,
     ) -> None:
         print(json.dumps([get_dict(obj, fields) for obj in data]))
@@ -451,7 +453,7 @@ class JSONPrinter:
 
 class YAMLPrinter:
     @staticmethod
-    def display(d: Union[str, Dict[str, Any]], **_kwargs: Any) -> None:
+    def display(d: str | dict[str, Any], **_kwargs: Any) -> None:
         try:
             import yaml  # noqa
 
@@ -465,8 +467,8 @@ class YAMLPrinter:
 
     @staticmethod
     def display_list(
-        data: List[Union[str, Dict[str, Any], gitlab.base.RESTObject]],
-        fields: List[str],
+        data: list[str | dict[str, Any] | gitlab.base.RESTObject],
+        fields: list[str],
         **_kwargs: Any,
     ) -> None:
         try:
@@ -486,14 +488,14 @@ class YAMLPrinter:
 
 
 class LegacyPrinter:
-    def display(self, _d: Union[str, Dict[str, Any]], **kwargs: Any) -> None:
+    def display(self, _d: str | dict[str, Any], **kwargs: Any) -> None:
         verbose = kwargs.get("verbose", False)
         padding = kwargs.get("padding", 0)
-        obj: Optional[Union[Dict[str, Any], gitlab.base.RESTObject]] = kwargs.get("obj")
+        obj: dict[str, Any] | gitlab.base.RESTObject | None = kwargs.get("obj")
         if TYPE_CHECKING:
             assert obj is not None
 
-        def display_dict(d: Dict[str, Any], padding: int) -> None:
+        def display_dict(d: dict[str, Any], padding: int) -> None:
             for k in sorted(d.keys()):
                 v = d[k]
                 if isinstance(v, dict):
@@ -547,10 +549,7 @@ class LegacyPrinter:
         )
 
     def display_list(
-        self,
-        data: List[Union[str, gitlab.base.RESTObject]],
-        fields: List[str],
-        **kwargs: Any,
+        self, data: list[str | gitlab.base.RESTObject], fields: list[str], **kwargs: Any
     ) -> None:
         verbose = kwargs.get("verbose", False)
         for obj in data:
@@ -561,9 +560,7 @@ class LegacyPrinter:
             print("")
 
 
-PRINTERS: Dict[
-    str, Union[Type[JSONPrinter], Type[LegacyPrinter], Type[YAMLPrinter]]
-] = {
+PRINTERS: dict[str, type[JSONPrinter] | type[LegacyPrinter] | type[YAMLPrinter]] = {
     "json": JSONPrinter,
     "legacy": LegacyPrinter,
     "yaml": YAMLPrinter,
@@ -574,10 +571,10 @@ def run(
     gl: gitlab.Gitlab,
     gitlab_resource: str,
     resource_action: str,
-    args: Dict[str, Any],
+    args: dict[str, Any],
     verbose: bool,
     output: str,
-    fields: List[str],
+    fields: list[str],
 ) -> None:
     g_cli = GitlabCLI(
         gl=gl,
@@ -587,7 +584,7 @@ def run(
     )
     data = g_cli.run()
 
-    printer: Union[JSONPrinter, LegacyPrinter, YAMLPrinter] = PRINTERS[output]()
+    printer: JSONPrinter | LegacyPrinter | YAMLPrinter = PRINTERS[output]()
 
     if isinstance(data, dict):
         printer.display(data, verbose=True, obj=data)

gitlab/v4/objects/__init__.py

@@ -39,6 +39,7 @@ from .jobs import *
 from .keys import *
 from .labels import *
 from .ldap import *
+from .member_roles import *
 from .members import *
 from .merge_request_approvals import *
 from .merge_requests import *

gitlab/v4/objects/access_requests.py

@@ -1,4 +1,4 @@
-from gitlab.base import RESTManager, RESTObject
+from gitlab.base import RESTObject
 from gitlab.mixins import (
     AccessRequestMixin,
     CreateMixin,
@@ -19,7 +19,11 @@ class GroupAccessRequest(AccessRequestMixin, ObjectDeleteMixin, RESTObject):
     pass
 
 
-class GroupAccessRequestManager(ListMixin, CreateMixin, DeleteMixin, RESTManager):
+class GroupAccessRequestManager(
+    ListMixin[GroupAccessRequest],
+    CreateMixin[GroupAccessRequest],
+    DeleteMixin[GroupAccessRequest],
+):
     _path = "/groups/{group_id}/access_requests"
     _obj_cls = GroupAccessRequest
     _from_parent_attrs = {"group_id": "id"}
@@ -29,7 +33,11 @@ class ProjectAccessRequest(AccessRequestMixin, ObjectDeleteMixin, RESTObject):
     pass
 
 
-class ProjectAccessRequestManager(ListMixin, CreateMixin, DeleteMixin, RESTManager):
+class ProjectAccessRequestManager(
+    ListMixin[ProjectAccessRequest],
+    CreateMixin[ProjectAccessRequest],
+    DeleteMixin[ProjectAccessRequest],
+):
     _path = "/projects/{project_id}/access_requests"
     _obj_cls = ProjectAccessRequest
     _from_parent_attrs = {"project_id": "id"}

gitlab/v4/objects/appearance.py

@@ -1,21 +1,22 @@
-from typing import Any, cast, Dict, Optional, Union
+from __future__ import annotations
+
+from typing import Any
 
 from gitlab import exceptions as exc
-from gitlab.base import RESTManager, RESTObject
+from gitlab.base import RESTObject
 from gitlab.mixins import GetWithoutIdMixin, SaveMixin, UpdateMixin
 from gitlab.types import RequiredOptional
 
-__all__ = [
-    "ApplicationAppearance",
-    "ApplicationAppearanceManager",
-]
+__all__ = ["ApplicationAppearance", "ApplicationAppearanceManager"]
 
 
 class ApplicationAppearance(SaveMixin, RESTObject):
     _id_attr = None
 
 
-class ApplicationAppearanceManager(GetWithoutIdMixin, UpdateMixin, RESTManager):
+class ApplicationAppearanceManager(
+    GetWithoutIdMixin[ApplicationAppearance], UpdateMixin[ApplicationAppearance]
+):
     _path = "/application/appearance"
     _obj_cls = ApplicationAppearance
     _update_attrs = RequiredOptional(
@@ -31,16 +32,16 @@ class ApplicationAppearanceManager(GetWithoutIdMixin, UpdateMixin, RESTManager):
             "message_background_color",
             "message_font_color",
             "email_header_and_footer_enabled",
-        ),
+        )
     )
 
     @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:
@@ -58,6 +59,3 @@ class ApplicationAppearanceManager(GetWithoutIdMixin, UpdateMixin, RESTManager):
         new_data = new_data or {}
         data = new_data.copy()
         return super().update(id, data, **kwargs)
-
-    def get(self, **kwargs: Any) -> ApplicationAppearance:
-        return cast(ApplicationAppearance, super().get(**kwargs))

gitlab/v4/objects/applications.py

@@ -1,11 +1,8 @@
-from gitlab.base import RESTManager, RESTObject
+from gitlab.base import RESTObject
 from gitlab.mixins import CreateMixin, DeleteMixin, ListMixin, ObjectDeleteMixin
 from gitlab.types import RequiredOptional
 
-__all__ = [
-    "Application",
-    "ApplicationManager",
-]
+__all__ = ["Application", "ApplicationManager"]
 
 
 class Application(ObjectDeleteMixin, RESTObject):
@@ -13,7 +10,9 @@ class Application(ObjectDeleteMixin, RESTObject):
     _repr_attr = "name"
 
 
-class ApplicationManager(ListMixin, CreateMixin, DeleteMixin, RESTManager):
+class ApplicationManager(
+    ListMixin[Application], CreateMixin[Application], DeleteMixin[Application]
+):
     _path = "/applications"
     _obj_cls = Application
     _create_attrs = RequiredOptional(