fluidattacks_gitlab_sdk 1.0.0__py3-none-any.whl

fluidattacks_gitlab_sdk/__init__.py

@@ -0,0 +1,22 @@
+import logging
+
+from fa_purity import (
+    Unsafe,
+)
+
+from fluidattacks_gitlab_sdk._http_client import Credentials
+
+from ._handlers import NotFound
+from ._logger import (
+    set_logger,
+)
+
+__version__ = "1.0.0"
+
+Unsafe.compute(set_logger(__name__, __version__))
+LOG = logging.getLogger(__name__)
+
+__all__ = [
+    "Credentials",
+    "NotFound",
+]

fluidattacks_gitlab_sdk/_decoders.py

@@ -0,0 +1,170 @@
+from collections.abc import Callable
+from datetime import date
+from typing import TypeVar
+
+from fa_purity import (
+    Bool,
+    Coproduct,
+    CoproductFactory,
+    FrozenList,
+    Maybe,
+    NewFrozenList,
+    Result,
+    ResultE,
+    ResultSmash,
+    ResultTransform,
+)
+from fa_purity.json import JsonObj, JsonUnfolder
+from fluidattacks_etl_utils import smash
+from fluidattacks_etl_utils.decode import DecodeUtils
+from fluidattacks_etl_utils.natural import Natural
+
+from fluidattacks_gitlab_sdk._handlers import handle_value_error
+from fluidattacks_gitlab_sdk.ids import (
+    EpicFullId,
+    EpicFullInternalId,
+    EpicGlobalId,
+    EpicInternalId,
+    GroupId,
+    IssueFullId,
+    IssueFullInternalId,
+    IssueGlobalId,
+    IssueInternalId,
+    MilestoneFullId,
+    MilestoneFullInternalId,
+    MilestoneGlobalId,
+    MilestoneInternalId,
+    MrFullId,
+    MrFullInternalId,
+    MrGlobalId,
+    MrInternalId,
+    ProjectId,
+)
+
+_T = TypeVar("_T")
+
+
+def decode_maybe_single(items: NewFrozenList[_T]) -> Maybe[_T]:
+    return Bool.from_primitive(len(items.items) <= 1).map(
+        lambda _: ResultTransform.get_index(items, 0).map(Maybe.some).value_or(Maybe.empty()),
+        lambda _: Maybe.empty(),
+    )
+
+
+def _decode_internal_id(
+    raw: JsonObj,
+    iid_transform: Callable[[Natural], _T],
+) -> ResultE[tuple[ProjectId, _T]]:
+    _project = (
+        JsonUnfolder.require(raw, "project_id", DecodeUtils.to_int)
+        .bind(Natural.from_int)
+        .map(ProjectId)
+    )
+    return smash.smash_result_2(
+        _project,
+        JsonUnfolder.require(raw, "iid", DecodeUtils.to_int)
+        .bind(Natural.from_int)
+        .map(iid_transform),
+    )
+
+
+def _decode_id(
+    raw: JsonObj,
+) -> ResultE[Natural]:
+    return JsonUnfolder.require(raw, "id", DecodeUtils.to_int).bind(Natural.from_int)
+
+
+def decode_milestone_internal_id(raw: JsonObj) -> ResultE[MilestoneFullInternalId]:
+    _decode_project = (
+        JsonUnfolder.require(raw, "project_id", DecodeUtils.to_int)
+        .bind(Natural.from_int)
+        .map(ProjectId)
+    )
+    _decode_group = (
+        JsonUnfolder.require(raw, "group_id", DecodeUtils.to_int)
+        .bind(Natural.from_int)
+        .map(GroupId)
+    )
+    _decode_iid = (
+        JsonUnfolder.require(raw, "iid", DecodeUtils.to_int)
+        .bind(Natural.from_int)
+        .map(MilestoneInternalId)
+    )
+    _union: CoproductFactory[ProjectId, GroupId] = CoproductFactory()
+    _project_or_group = _decode_project.map(_union.inl).lash(
+        lambda _: _decode_group.map(_union.inr),
+    )
+    return ResultSmash.smash_result_2(
+        _project_or_group,
+        _decode_iid,
+    ).map(lambda t: MilestoneFullInternalId(*t))
+
+
+def decode_milestone_full_id(raw: JsonObj) -> ResultE[MilestoneFullId]:
+    return smash.smash_result_2(
+        _decode_id(raw).map(MilestoneGlobalId),
+        decode_milestone_internal_id(raw),
+    ).map(lambda t: MilestoneFullId(*t))
+
+
+def decode_epic_internal_id(raw: JsonObj) -> ResultE[EpicFullInternalId]:
+    _decode_group = (
+        JsonUnfolder.require(raw, "group_id", DecodeUtils.to_int)
+        .bind(Natural.from_int)
+        .map(GroupId)
+    )
+    _decode_iid = (
+        JsonUnfolder.require(raw, "iid", DecodeUtils.to_int)
+        .bind(Natural.from_int)
+        .map(EpicInternalId)
+    )
+    return ResultSmash.smash_result_2(
+        _decode_group,
+        _decode_iid,
+    ).map(lambda t: EpicFullInternalId(*t))
+
+
+def decode_epic_full_id(raw: JsonObj) -> ResultE[EpicFullId]:
+    return smash.smash_result_2(
+        _decode_id(raw).map(EpicGlobalId),
+        decode_epic_internal_id(raw),
+    ).map(lambda t: EpicFullId(*t))
+
+
+def decode_mr_internal_id(raw: JsonObj) -> ResultE[MrFullInternalId]:
+    return _decode_internal_id(raw, MrInternalId).map(lambda t: MrFullInternalId(*t))
+
+
+def decode_mr_full_id(raw: JsonObj) -> ResultE[MrFullId]:
+    return smash.smash_result_2(_decode_id(raw).map(MrGlobalId), decode_mr_internal_id(raw)).map(
+        lambda t: MrFullId(*t),
+    )
+
+
+def decode_issue_internal_id(raw: JsonObj) -> ResultE[IssueFullInternalId]:
+    return _decode_internal_id(raw, IssueInternalId).map(lambda t: IssueFullInternalId(*t))
+
+
+def decode_issue_full_id(raw: JsonObj) -> ResultE[IssueFullId]:
+    return smash.smash_result_2(
+        _decode_id(raw).map(IssueGlobalId),
+        decode_issue_internal_id(raw),
+    ).map(lambda t: IssueFullId(*t))
+
+
+def decode_date(raw: str) -> ResultE[date]:
+    return handle_value_error(lambda: date.fromisoformat(raw))
+
+
+def assert_single(item: Coproduct[JsonObj, FrozenList[JsonObj]]) -> ResultE[JsonObj]:
+    return item.map(
+        Result.success,
+        lambda _: Result.failure(ValueError("Expected a json not a list")),
+    )
+
+
+def assert_multiple(item: Coproduct[JsonObj, FrozenList[JsonObj]]) -> ResultE[FrozenList[JsonObj]]:
+    return item.map(
+        lambda _: Result.failure(ValueError("Expected a json list not a single json")),
+        Result.success,
+    )

fluidattacks_gitlab_sdk/_gql_client/__init__.py

@@ -0,0 +1,8 @@
+from ._client import GraphQlGitlabClient
+from ._error import ApiError, ApiResult
+
+__all__ = [
+    "ApiError",
+    "ApiResult",
+    "GraphQlGitlabClient",
+]

fluidattacks_gitlab_sdk/_gql_client/_client.py

@@ -0,0 +1,101 @@
+from __future__ import (
+    annotations,
+)
+
+import inspect
+from dataclasses import (
+    dataclass,
+)
+
+from fa_purity import (
+    Cmd,
+    FrozenDict,
+    Result,
+    ResultE,
+)
+from fa_purity.json import (
+    JsonObj,
+    JsonValueFactory,
+    Unfolder,
+)
+from fluidattacks_etl_utils.bug import (
+    Bug,
+)
+from fluidattacks_etl_utils.retry import (
+    cmd_if_fail,
+    retry_cmd,
+    sleep_cmd,
+)
+from fluidattacks_etl_utils.typing import (
+    Dict,
+    TypeVar,
+)
+from gql import (
+    Client,
+    gql,
+)
+from gql.transport.requests import (
+    RequestsHTTPTransport,
+)
+
+from . import _handlers
+from ._error import (
+    ApiError,
+)
+
+API_ENDPOINT = "https://gitlab.com/api/graphql"
+_T = TypeVar("_T")
+
+
+def error_handler(cmd: Cmd[_T]) -> Cmd[ResultE[_T]]:
+    return _handlers.too_many_requests_handler(
+        _handlers.server_error_handler(_handlers.connection_error_handler(cmd)),
+    ).map(lambda a: a.bind(lambda b: b.bind(lambda c: c)))
+
+
+@dataclass(frozen=True)
+class _GraphQlAsmClient:
+    client: Client
+
+
+@dataclass(frozen=True)
+class GraphQlGitlabClient:
+    _inner: _GraphQlAsmClient
+
+    @staticmethod
+    def new(token: str) -> Cmd[GraphQlGitlabClient]:
+        def _new() -> GraphQlGitlabClient:
+            headers: Dict[str, str] = {"Authorization": f"Bearer {token}"}
+            transport = RequestsHTTPTransport(API_ENDPOINT, headers)
+            client = Client(transport=transport, fetch_schema_from_transport=False)
+            return GraphQlGitlabClient(_GraphQlAsmClient(client))
+
+        return Cmd.wrap_impure(_new)
+
+    def _get(self, query: str, values: FrozenDict[str, str]) -> Cmd[JsonObj]:
+        def _action() -> JsonObj:
+            return Bug.assume_success(
+                "gql_decode_get_response",
+                inspect.currentframe(),
+                (query, str(values)),
+                JsonValueFactory.from_any(
+                    self._inner.client.execute(gql(query), dict(values)),  # type: ignore[misc]
+                ).bind(Unfolder.to_json),
+            )
+
+        return Cmd.wrap_impure(_action)
+
+    def get(self, query: str, values: FrozenDict[str, str]) -> Cmd[Result[JsonObj, ApiError]]:
+        result = retry_cmd(
+            error_handler(self._get(query, values)),
+            lambda i, r: cmd_if_fail(r, sleep_cmd(i**2)),
+            10,
+        ).map(
+            lambda r: Bug.assume_success(
+                "gql_get_response",
+                inspect.currentframe(),
+                (query, str(values)),
+                r,
+            ),
+        )
+        return _handlers.api_error_handler(result)

fluidattacks_gitlab_sdk/_gql_client/_error.py

@@ -0,0 +1,24 @@
+from dataclasses import (
+    dataclass,
+)
+
+from fa_purity import (
+    FrozenList,
+    Result,
+)
+from fa_purity.json import (
+    JsonValue,
+)
+from fluidattacks_etl_utils.typing import (
+    TypeVar,
+)
+
+_T = TypeVar("_T")
+
+
+@dataclass
+class ApiError(Exception):
+    errors: FrozenList[JsonValue]
+
+
+ApiResult = Result[_T, ApiError]  # type: ignore[misc]

fluidattacks_gitlab_sdk/_gql_client/_handlers.py

@@ -0,0 +1,87 @@
+import inspect
+
+from fa_purity import (
+    Cmd,
+    CmdUnwrapper,
+    Result,
+    ResultE,
+    ResultFactory,
+)
+from fa_purity.json import (
+    JsonValueFactory,
+    Unfolder,
+)
+from fluidattacks_etl_utils.bug import (
+    Bug,
+)
+from fluidattacks_etl_utils.typing import (
+    Callable,
+    TypeVar,
+)
+from gql.transport.exceptions import (
+    TransportQueryError,
+    TransportServerError,
+)
+from requests.exceptions import (
+    ConnectionError as RequestsConnectionError,
+)
+
+from ._error import (
+    ApiError,
+)
+
+_T = TypeVar("_T")
+
+
+def http_status_handler(is_handled: Callable[[int], bool], cmd: Cmd[_T]) -> Cmd[ResultE[_T]]:
+    factory: ResultFactory[_T, Exception] = ResultFactory()
+
+    def _action(unwrapper: CmdUnwrapper) -> ResultE[_T]:
+        try:
+            return factory.success(unwrapper.act(cmd))
+        except TransportServerError as err:
+            if err.code is not None and is_handled(err.code):
+                return factory.failure(err)
+            raise
+
+    return Cmd.new_cmd(_action)
+
+
+def api_error_handler(cmd: Cmd[_T]) -> Cmd[Result[_T, ApiError]]:
+    factory: ResultFactory[_T, ApiError] = ResultFactory()
+
+    def _action(unwrapper: CmdUnwrapper) -> Result[_T, ApiError]:
+        try:
+            return factory.success(unwrapper.act(cmd))
+        except TransportQueryError as err:  # type: ignore[misc]
+            _errors = JsonValueFactory.from_any(err.errors).bind(  # type: ignore[misc]
+                lambda x: Unfolder.to_list(x),
+            )
+            errors = Bug.assume_success(
+                "decode_errors",
+                inspect.currentframe(),
+                (str(_errors),),
+                _errors,
+            )
+            return factory.failure(ApiError(errors))
+
+    return Cmd.new_cmd(_action)
+
+
+def too_many_requests_handler(cmd: Cmd[_T]) -> Cmd[ResultE[_T]]:
+    too_many_requests_num = 429
+    return http_status_handler(lambda c: c == too_many_requests_num, cmd)
+
+
+def server_error_handler(cmd: Cmd[_T]) -> Cmd[ResultE[_T]]:
+    return http_status_handler(lambda c: c in range(500, 600), cmd)
+
+
+def connection_error_handler(cmd: Cmd[_T]) -> Cmd[ResultE[_T]]:
+    def _action(unwrapper: CmdUnwrapper) -> ResultE[_T]:
+        try:
+            return Result.success(unwrapper.act(cmd))
+        except RequestsConnectionError as err:
+            return Result.failure(Exception(err))
+
+    return Cmd.new_cmd(_action)

fluidattacks_gitlab_sdk/_handlers.py

@@ -0,0 +1,40 @@
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import TypeVar
+
+from fa_purity import Coproduct, Result, ResultE, cast_exception
+
+from fluidattacks_gitlab_sdk._http_client import HTTPError, UnhandledErrors
+
+_T = TypeVar("_T")
+
+
+@dataclass
+class NotFound(Exception):
+    parent: Exception | None
+
+
+def handle_value_error(value: Callable[[], _T]) -> ResultE[_T]:
+    try:
+        return Result.success(value())
+    except ValueError as error:
+        return Result.failure(error)
+
+
+def _handle_not_found(error: HTTPError) -> Coproduct[NotFound, Exception]:
+    not_found_code = 404
+    err_code: int = error.raw.response.status_code  # type: ignore[misc]
+
+    if err_code == not_found_code:
+        return Coproduct.inl(NotFound(error.raw))
+    return Coproduct.inr(error.raw)
+
+
+def handle_not_found(error: UnhandledErrors) -> Coproduct[NotFound, Exception]:
+    return error.error.map(
+        lambda e: Coproduct.inr(cast_exception(e.raw)),
+        lambda c: c.map(
+            _handle_not_found,
+            lambda e: Coproduct.inr(cast_exception(e.raw)),
+        ),
+    )

fluidattacks_gitlab_sdk/_http_client/__init__.py

@@ -0,0 +1,28 @@
+from dataclasses import dataclass
+
+from fluidattacks_gitlab_sdk._http_client._client_1 import Client1
+from fluidattacks_gitlab_sdk._http_client._core import (
+    Credentials,
+    HTTPError,
+    HttpJsonClient,
+    Page,
+    RelativeEndpoint,
+    UnhandledErrors,
+)
+
+
+@dataclass(frozen=True)
+class ClientFactory:
+    @staticmethod
+    def new(creds: Credentials) -> HttpJsonClient:
+        return Client1.new(creds).client
+
+
+__all__ = [
+    "Credentials",
+    "HTTPError",
+    "HttpJsonClient",
+    "Page",
+    "RelativeEndpoint",
+    "UnhandledErrors",
+]

fluidattacks_gitlab_sdk/_http_client/_client_1.py

@@ -0,0 +1,206 @@
+from __future__ import (
+    annotations,
+)
+
+import logging
+from dataclasses import (
+    dataclass,
+)
+from typing import (
+    TypeVar,
+)
+
+from fa_purity import (
+    Cmd,
+    Coproduct,
+    FrozenDict,
+    FrozenList,
+    Result,
+    UnitType,
+    unit,
+)
+from fa_purity.json import (
+    JsonObj,
+    JsonPrimitiveFactory,
+    JsonUnfolder,
+    JsonValue,
+)
+from fluidattacks_etl_utils.smash import bind_chain
+from pure_requests import (
+    response,
+)
+from pure_requests import (
+    retry as _retry,
+)
+from pure_requests.basic import (
+    Data,
+    Endpoint,
+    HttpClientFactory,
+    Params,
+)
+from pure_requests.retry import (
+    HandledError,
+    MaxRetriesReached,
+)
+
+from ._core import (
+    Credentials,
+    HandledErrors,
+    HTTPError,
+    HttpJsonClient,
+    JSONDecodeError,
+    RelativeEndpoint,
+    RequestException,
+    UnhandledErrors,
+)
+
+LOG = logging.getLogger(__name__)
+
+
+_S = TypeVar("_S")
+_F = TypeVar("_F")
+
+
+def _retry_cmd(retry: int, item: Result[_S, _F]) -> Cmd[Result[_S, _F]]:
+    log = Cmd.wrap_impure(lambda: LOG.info("retry #%2s waiting...", retry))
+    return _retry.cmd_if_fail(item, log + _retry.sleep_cmd(retry**2))
+
+
+def _http_error_handler(
+    error: HTTPError,
+) -> HandledError[HandledErrors, UnhandledErrors]:
+    err_code: int = error.raw.response.status_code  # type: ignore[misc]
+    handled = (
+        409,
+        429,
+    )
+    if err_code in range(500, 600) or err_code in handled:
+        return HandledError.handled(HandledErrors(Coproduct.inl(error)))
+    return HandledError.unhandled(UnhandledErrors(Coproduct.inr(Coproduct.inl(error))))
+
+
+def _handled_request_exception(
+    error: RequestException,
+) -> HandledError[HandledErrors, UnhandledErrors]:
+    return (
+        error.to_chunk_error()
+        .map(lambda e: HandledError.handled(HandledErrors(Coproduct.inr(Coproduct.inl(e)))))
+        .lash(
+            lambda _: error.to_connection_error().map(
+                lambda e: HandledError.handled(HandledErrors(Coproduct.inr(Coproduct.inr(e)))),
+            ),
+        )
+        .value_or(HandledError.unhandled(UnhandledErrors(Coproduct.inr(Coproduct.inr(error)))))
+    )
+
+
+def _handled_errors(
+    error: Coproduct[JSONDecodeError, Coproduct[HTTPError, RequestException]],
+) -> HandledError[HandledErrors, UnhandledErrors]:
+    """Classify errors."""
+    return error.map(
+        lambda _: HandledError.unhandled(UnhandledErrors(error)),
+        lambda c: c.map(
+            _http_error_handler,
+            _handled_request_exception,
+        ),
+    )
+
+
+def _adjust_unhandled(
+    error: UnhandledErrors | MaxRetriesReached,
+) -> Coproduct[UnhandledErrors, MaxRetriesReached]:
+    return Coproduct.inr(error) if isinstance(error, MaxRetriesReached) else Coproduct.inl(error)
+
+
+@dataclass(frozen=True)
+class Client1:
+    _creds: Credentials
+    _max_retries: int
+
+    def _full_endpoint(self, endpoint: RelativeEndpoint) -> Endpoint:
+        return Endpoint("/".join(("https://gitlab.com/api/v4", *endpoint.paths)))
+
+    @staticmethod
+    def new(creds: Credentials) -> Client1:
+        return Client1(
+            creds,
+            150,
+        )
+
+    @property
+    def _headers(self) -> JsonObj:
+        return FrozenDict(
+            {
+                "Private-Token": JsonValue.from_primitive(
+                    JsonPrimitiveFactory.from_raw(self._creds.api_key),
+                ),
+            },
+        )
+
+    def get(
+        self,
+        endpoint: RelativeEndpoint,
+        params: JsonObj,
+    ) -> Cmd[
+        Result[
+            Coproduct[JsonObj, FrozenList[JsonObj]],
+            Coproduct[UnhandledErrors, MaxRetriesReached],
+        ]
+    ]:
+        _full = self._full_endpoint(endpoint)
+        log = Cmd.wrap_impure(
+            lambda: LOG.debug(
+                "[API] get: %s\nparams = %s",
+                _full,
+                JsonUnfolder.dumps(params),
+            ),
+        )
+        client = HttpClientFactory.new_client(None, self._headers, False)
+        handled = log + client.get(_full, Params(params)).map(
+            lambda r: r.alt(RequestException),
+        ).map(
+            lambda r: bind_chain(r, lambda i: response.handle_status(i).alt(HTTPError)),
+        ).map(
+            lambda r: bind_chain(r, lambda i: response.json_decode(i).alt(JSONDecodeError)).alt(
+                _handled_errors,
+            ),
+        )
+        return _retry.retry_cmd(
+            handled,
+            _retry_cmd,
+            self._max_retries,
+        ).map(lambda r: r.alt(_adjust_unhandled))
+
+    def post(
+        self,
+        endpoint: RelativeEndpoint,
+    ) -> Cmd[Result[UnitType, Coproduct[UnhandledErrors, MaxRetriesReached]]]:
+        _full = self._full_endpoint(endpoint)
+        log = Cmd.wrap_impure(lambda: LOG.info("API call (post): %s", _full))
+        client = HttpClientFactory.new_client(None, self._headers, False)
+        handled = log + client.post(
+            self._full_endpoint(endpoint),
+            Params(FrozenDict({})),
+            Data(FrozenDict({})),
+        ).map(lambda r: r.alt(RequestException)).map(
+            lambda r: bind_chain(r, lambda i: response.handle_status(i).alt(HTTPError)).alt(
+                lambda e: _handled_errors(Coproduct.inr(e)),
+            ),
+        )
+        return _retry.retry_cmd(
+            handled,
+            _retry_cmd,
+            self._max_retries,
+        ).map(
+            lambda r: r.map(
+                lambda _: unit,
+            ).alt(_adjust_unhandled),
+        )
+
+    @property
+    def client(self) -> HttpJsonClient:
+        return HttpJsonClient(
+            self.get,
+            self.post,
+        )