GeezerVison is showing github.com — python-gitlab/gitlab/types.py at main · python-gitlab/python-gitlab

Expand file tree

types.py

Copy path

More file actions

Latest commit

History

138 lines (103 loc) · 4.48 KB

types.py

Copy path

File metadata and controls

138 lines (103 loc) · 4.48 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

from __future__ import annotations

import dataclasses

import json

from typing import Any, TYPE_CHECKING

from gitlab import exceptions

@dataclasses.dataclass(frozen=True)

class RequiredOptional:

required: tuple[str, ...] = ()

optional: tuple[str, ...] = ()

exclusive: tuple[str, ...] = ()

def validate_attrs(

self, *, data: dict[str, Any], excludes: list[str] | None = None

) -> None:

if excludes is None:

excludes = []

if self.required:

required = [k for k in self.required if k not in excludes]

missing = [attr for attr in required if attr not in data]

if missing:

raise AttributeError(f"Missing attributes: {', '.join(missing)}")

if self.exclusive:

exclusives = [attr for attr in data if attr in self.exclusive]

if len(exclusives) > 1:

raise AttributeError(

f"Provide only one of these attributes: {', '.join(exclusives)}"

)

if not exclusives:

raise AttributeError(

f"Must provide one of these attributes: "

f"{', '.join(self.exclusive)}"

)

class GitlabAttribute:

# Used in utils._transform_types() to decide if we should call get_for_api()

# on the attribute when transform_data is False (e.g. for POST/PUT/PATCH).

# This allows us to force transformation of data even when sending JSON bodies,

# which is useful for types like CommaSeparatedStringAttribute.

transform_in_body = False

def __init__(self, value: Any = None) -> None:

self._value = value

def get(self) -> Any:

return self._value

def set_from_cli(self, cli_value: Any) -> None:

self._value = cli_value

def get_for_api(self, *, key: str) -> tuple[str, Any]:

return (key, self._value)

class JsonAttribute(GitlabAttribute):

def set_from_cli(self, cli_value: str) -> None:

try:

self._value = json.loads(cli_value)

except (ValueError, TypeError) as e:

raise exceptions.GitlabParsingError(

f"Could not parse JSON data: {e}"

) from e

class _ListArrayAttribute(GitlabAttribute):

"""Helper class to support `list` / `array` types."""

def set_from_cli(self, cli_value: str) -> None:

if not cli_value.strip():

self._value = []

else:

self._value = [item.strip() for item in cli_value.split(",")]

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)

if TYPE_CHECKING:

assert isinstance(self._value, list)

return (key, ",".join([str(x) for x in self._value]))

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]:

if isinstance(self._value, str):

return (f"{key}[]", self._value)

if TYPE_CHECKING:

assert isinstance(self._value, list)

return (f"{key}[]", self._value)

class CommaSeparatedListAttribute(_ListArrayAttribute):

"""

For values which are sent to the server as a Comma Separated Values (CSV) string

in query parameters (GET), but as a list/array in JSON bodies (POST/PUT).

"""

class CommaSeparatedStringAttribute(_ListArrayAttribute):

"""

For values which are sent to the server as a Comma Separated Values (CSV) string.

Unlike CommaSeparatedListAttribute, this type ensures the value is converted

to a string even in JSON bodies (POST/PUT requests).

"""

# Used in utils._transform_types() to ensure the value is converted to a string

# via get_for_api() even when transform_data is False (e.g. for POST/PUT/PATCH).

# This is needed because some APIs require a CSV string instead of a JSON array.

transform_in_body = True

class LowercaseStringAttribute(GitlabAttribute):

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: str | None = None) -> str | None:

return attr_name

class ImageAttribute(FileAttribute):

@staticmethod

def get_file_name(attr_name: str | None = None) -> str:

return f"{attr_name}.png" if attr_name else "image.png"