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"