fluidattacks_gitlab_sdk 1.0.0__py3-none-any.whl

fluidattacks_gitlab_sdk/_http_client/_core.py

@@ -0,0 +1,152 @@
+from __future__ import (
+    annotations,
+)
+
+import logging
+from collections.abc import Callable
+from dataclasses import (
+    dataclass,
+    field,
+)
+
+from fa_purity import (
+    Cmd,
+    Coproduct,
+    FrozenList,
+    Result,
+    ResultE,
+    UnitType,
+)
+from fa_purity.json import (
+    JsonObj,
+)
+from pure_requests.retry import (
+    MaxRetriesReached,
+)
+from requests.exceptions import (
+    ChunkedEncodingError as RawChunkedEncodingError,
+)
+from requests.exceptions import (
+    ConnectionError as RawConnectionError,
+)
+from requests.exceptions import (
+    HTTPError as RawHTTPError,
+)
+from requests.exceptions import (
+    JSONDecodeError as RawJSONDecodeError,
+)
+from requests.exceptions import (
+    RequestException as RawRequestException,
+)
+
+LOG = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class Credentials:
+    api_key: str
+
+    def __repr__(self) -> str:
+        return "Credentials([masked])"
+
+    def __str__(self) -> str:
+        return "Credentials([masked])"
+
+
+@dataclass(frozen=True)
+class _Private:
+    pass
+
+
+@dataclass(frozen=True)
+class HTTPError:
+    raw: RawHTTPError
+
+
+@dataclass(frozen=True)
+class JSONDecodeError:
+    raw: RawJSONDecodeError
+
+
+@dataclass(frozen=True)
+class ChunkedEncodingError:
+    _private: _Private = field(repr=False, hash=False, compare=False)
+    raw: RawChunkedEncodingError
+
+
+@dataclass(frozen=True)
+class RequestsConnectionError:
+    _private: _Private = field(repr=False, hash=False, compare=False)
+    raw: RawConnectionError
+
+
+@dataclass(frozen=True)
+class RequestException:
+    raw: RawRequestException
+
+    def to_chunk_error(self) -> ResultE[ChunkedEncodingError]:
+        if isinstance(self.raw, RawChunkedEncodingError):
+            return Result.success(ChunkedEncodingError(_Private(), self.raw))
+        return Result.failure(ValueError("Not a ChunkedEncodingError"))
+
+    def to_connection_error(self) -> ResultE[RequestsConnectionError]:
+        if isinstance(self.raw, RawConnectionError):
+            return Result.success(RequestsConnectionError(_Private(), self.raw))
+        return Result.failure(ValueError("Not a RequestsConnectionError"))
+
+
+@dataclass(frozen=True)
+class UnhandledErrors:
+    error: Coproduct[JSONDecodeError, Coproduct[HTTPError, RequestException]]
+
+
+@dataclass(frozen=True)
+class HandledErrors:
+    error: Coproduct[
+        HTTPError,
+        Coproduct[ChunkedEncodingError, RequestsConnectionError],
+    ]
+
+
+@dataclass(frozen=True)
+class RelativeEndpoint:
+    paths: FrozenList[str]
+
+    @staticmethod
+    def new(*args: str) -> RelativeEndpoint:
+        return RelativeEndpoint(tuple(args))
+
+
+@dataclass(frozen=True)
+class HttpJsonClient:
+    get: Callable[
+        [RelativeEndpoint, JsonObj],
+        Cmd[
+            Result[
+                Coproduct[JsonObj, FrozenList[JsonObj]],
+                Coproduct[UnhandledErrors, MaxRetriesReached],
+            ]
+        ],
+    ]
+    post: Callable[
+        [RelativeEndpoint],
+        Cmd[Result[UnitType, Coproduct[UnhandledErrors, MaxRetriesReached]]],
+    ]
+
+
+@dataclass(frozen=True)
+class Page:
+    @dataclass(frozen=True)
+    class _Private:
+        pass
+
+    private: Page._Private = field(repr=False, hash=False, compare=False)
+    page_num: int
+    per_page: int
+
+    @staticmethod
+    def new_page(page_num: int, per_page: int) -> ResultE[Page]:
+        if page_num > 0 and per_page in range(1, 101):
+            pag = Page(Page._Private(), page_num, per_page)
+            return Result.success(pag)
+        return Result.failure(ValueError("Invalid page"))

fluidattacks_gitlab_sdk/_logger.py

@@ -0,0 +1,36 @@
+from fa_purity import (
+    Cmd,
+)
+from fluidattacks_utils_logger import (
+    set_main_log,
+)
+from fluidattacks_utils_logger.env import (
+    current_app_env,
+    notifier_key,
+    observes_debug,
+)
+from fluidattacks_utils_logger.handlers import (
+    LoggingConf,
+)
+
+
+def set_logger(root_name: str, version: str) -> Cmd[None]:
+    n_key = notifier_key()
+    app_env = current_app_env()
+    debug = observes_debug()
+    conf = n_key.bind(
+        lambda key: app_env.map(
+            lambda env: LoggingConf(
+                "sdk",
+                version,
+                "./observes/sdk/fluidattacks_gitlab_sdk",
+                False,
+                key,
+                env,
+                "observes",
+            ),
+        ),
+    )
+    return debug.bind(
+        lambda d: conf.bind(lambda c: set_main_log(root_name, c, d, False)),
+    )

fluidattacks_gitlab_sdk/ids.py

@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from fa_purity import Coproduct
+from fluidattacks_etl_utils.natural import Natural
+
+
+@dataclass(frozen=True)
+class ProjectId:
+    """Represents a global project id."""
+
+    project_id: Natural
+
+
+@dataclass(frozen=True)
+class ProjectPath:
+    """Represents a project path."""
+
+    path: str
+
+
+@dataclass(frozen=True)
+class GroupId:
+    """Represents a global group id."""
+
+    group_id: Natural
+
+
+@dataclass(frozen=True)
+class UserId:
+    """Represents an user id."""
+
+    user_id: Natural
+
+
+@dataclass(frozen=True)
+class MilestoneGlobalId:
+    """Represents an milestone global id."""
+
+    global_id: Natural
+
+
+@dataclass(frozen=True)
+class MilestoneInternalId:
+    """Represents an milestone internal id."""
+
+    internal: Natural
+
+
+@dataclass(frozen=True)
+class MilestoneFullInternalId:
+    parent: Coproduct[ProjectId, GroupId]
+    internal: MilestoneInternalId
+
+
+@dataclass(frozen=True)
+class MilestoneFullId:
+    global_id: MilestoneGlobalId
+    internal_id: MilestoneFullInternalId
+
+
+@dataclass(frozen=True)
+class MrGlobalId:
+    """Represents an MR global id."""
+
+    global_id: Natural
+
+
+@dataclass(frozen=True)
+class MrInternalId:
+    """Represents an MR internal id."""
+
+    internal: Natural
+
+
+@dataclass(frozen=True)
+class MrFullInternalId:
+    project: ProjectId
+    internal: MrInternalId
+
+
+@dataclass(frozen=True)
+class MrFullId:
+    global_id: MrGlobalId
+    internal_id: MrFullInternalId
+
+
+@dataclass(frozen=True)
+class MemberId:
+    member_id: Natural
+
+
+@dataclass(frozen=True)
+class EpicGlobalId:
+    global_id: Natural
+
+
+@dataclass(frozen=True)
+class EpicInternalId:
+    internal_id: Natural
+
+
+@dataclass(frozen=True)
+class EpicFullInternalId:
+    group: GroupId
+    internal_id: EpicInternalId
+
+
+@dataclass(frozen=True)
+class EpicFullId:
+    global_id: EpicGlobalId
+    internal_id: EpicFullInternalId
+
+
+@dataclass(frozen=True)
+class IssueGlobalId:
+    global_id: Natural
+
+
+@dataclass(frozen=True)
+class IssueInternalId:
+    internal_id: Natural
+
+
+@dataclass(frozen=True)
+class IssueFullInternalId:
+    project: ProjectId
+    internal_id: IssueInternalId
+
+
+@dataclass(frozen=True)
+class IssueFullId:
+    global_id: IssueGlobalId
+    internal_id: IssueFullInternalId

fluidattacks_gitlab_sdk/issues/__init__.py

@@ -0,0 +1,7 @@
+from ._client import IssueClientFactory
+from .core import IssueClient
+
+__all__ = [
+    "IssueClient",
+    "IssueClientFactory",
+]

fluidattacks_gitlab_sdk/issues/_client/__init__.py

@@ -0,0 +1,28 @@
+from __future__ import (
+    annotations,
+)
+
+from dataclasses import dataclass
+
+from fa_purity import Cmd
+
+from fluidattacks_gitlab_sdk._gql_client import GraphQlGitlabClient
+from fluidattacks_gitlab_sdk._http_client import ClientFactory, Credentials, HttpJsonClient
+from fluidattacks_gitlab_sdk.issues.core import IssueClient
+
+from ._get_issue import get_issue
+from ._most_recent import most_recent_issue
+
+
+def _from_client(client: HttpJsonClient, new_gql_client: Cmd[GraphQlGitlabClient]) -> IssueClient:
+    return IssueClient(
+        lambda p, i: new_gql_client.bind(lambda c: get_issue(client, c, p, i)),
+        lambda p: new_gql_client.bind(lambda c: most_recent_issue(client, c, p)),
+    )
+
+
+@dataclass(frozen=True)
+class IssueClientFactory:
+    @staticmethod
+    def new(creds: Credentials) -> IssueClient:
+        return _from_client(ClientFactory.new(creds), GraphQlGitlabClient.new(creds.api_key))

fluidattacks_gitlab_sdk/issues/_client/_decode.py

@@ -0,0 +1,165 @@
+import inspect
+
+from fa_purity import Maybe, ResultE
+from fa_purity.json import JsonObj, JsonPrimitiveUnfolder, JsonUnfolder, JsonValue, Unfolder
+from fluidattacks_etl_utils import smash
+from fluidattacks_etl_utils.bug import Bug
+from fluidattacks_etl_utils.decode import DecodeUtils
+
+from fluidattacks_gitlab_sdk import _handlers
+from fluidattacks_gitlab_sdk._decoders import (
+    decode_date,
+    decode_epic_full_id,
+    decode_issue_full_id,
+    decode_milestone_full_id,
+)
+from fluidattacks_gitlab_sdk.ids import (
+    IssueFullId,
+)
+from fluidattacks_gitlab_sdk.issues.core import (
+    Issue,
+    IssueCounts,
+    IssueDates,
+    IssueDef,
+    IssueOtherProperties,
+    IssueReferences,
+    IssueType,
+)
+from fluidattacks_gitlab_sdk.users.core import UserObj
+from fluidattacks_gitlab_sdk.users.decode import decode_user_obj
+
+
+def decode_type(raw: JsonValue) -> ResultE[IssueType]:
+    return Unfolder.to_primitive(raw).bind(
+        lambda p: JsonPrimitiveUnfolder.to_str(p).bind(
+            lambda r: _handlers.handle_value_error(lambda: IssueType(r)),
+        ),
+    )
+
+
+def _decode_stats(raw: JsonObj) -> ResultE[IssueCounts]:
+    return smash.smash_result_3(
+        JsonUnfolder.require(raw, "upvotes", DecodeUtils.to_int),
+        JsonUnfolder.require(raw, "downvotes", DecodeUtils.to_int),
+        JsonUnfolder.require(raw, "merge_requests_count", DecodeUtils.to_int),
+    ).map(lambda t: IssueCounts(*t))
+
+
+def _decode_properties(raw: JsonObj) -> ResultE[IssueOtherProperties]:
+    return smash.smash_result_5(
+        JsonUnfolder.require(raw, "confidential", DecodeUtils.to_bool),
+        JsonUnfolder.require(
+            raw,
+            "discussion_locked",
+            lambda v: DecodeUtils.to_maybe(v, DecodeUtils.to_bool),
+        ),
+        JsonUnfolder.require(raw, "labels", lambda v: Unfolder.to_list_of(v, DecodeUtils.to_str)),
+        JsonUnfolder.optional(
+            raw,
+            "health_status",
+            lambda v: DecodeUtils.to_maybe(v, DecodeUtils.to_str),
+        ).map(lambda m: m.bind(lambda x: x)),
+        JsonUnfolder.optional(
+            raw,
+            "weight",
+            lambda v: DecodeUtils.to_maybe(v, DecodeUtils.to_int),
+        ).map(lambda m: m.bind(lambda x: x)),
+    ).map(lambda t: IssueOtherProperties(*t))
+
+
+def _decode_refs(updated_by: Maybe[UserObj], raw: JsonObj) -> ResultE[IssueReferences]:
+    return smash.smash_result_5(
+        JsonUnfolder.require(raw, "author", lambda v: Unfolder.to_json(v).bind(decode_user_obj)),
+        JsonUnfolder.require(
+            raw,
+            "milestone",
+            lambda v: DecodeUtils.to_maybe(
+                v,
+                lambda v: Unfolder.to_json(v).bind(decode_milestone_full_id),
+            ),
+        ),
+        JsonUnfolder.optional(
+            raw,
+            "epic",
+            lambda v: DecodeUtils.to_maybe(
+                v,
+                lambda v: Unfolder.to_json(v).bind(decode_epic_full_id),
+            ),
+        ).map(lambda m: m.bind(lambda x: x)),
+        JsonUnfolder.require(
+            raw,
+            "closed_by",
+            lambda v: DecodeUtils.to_maybe(v, lambda v: Unfolder.to_json(v).bind(decode_user_obj)),
+        ),
+        JsonUnfolder.require(
+            raw,
+            "assignees",
+            lambda v: Unfolder.to_list_of(v, lambda v: Unfolder.to_json(v).bind(decode_user_obj)),
+        ),
+    ).map(lambda t: IssueReferences(*t, updated_by))
+
+
+def _decode_def(raw: JsonObj) -> ResultE[IssueDef]:
+    return smash.smash_result_4(
+        JsonUnfolder.require(raw, "title", DecodeUtils.to_str),
+        JsonUnfolder.require(raw, "state", DecodeUtils.to_str),
+        JsonUnfolder.require(raw, "issue_type", decode_type),
+        JsonUnfolder.require(
+            raw,
+            "description",
+            lambda v: DecodeUtils.to_maybe(v, DecodeUtils.to_str),
+        ),
+    ).map(lambda t: IssueDef(*t))
+
+
+def _decode_dates(raw: JsonObj) -> ResultE[IssueDates]:
+    return smash.smash_result_4(
+        JsonUnfolder.require(raw, "created_at", DecodeUtils.to_date_time),
+        JsonUnfolder.require(
+            raw,
+            "updated_at",
+            lambda v: DecodeUtils.to_maybe(v, DecodeUtils.to_date_time),
+        ),
+        JsonUnfolder.require(
+            raw,
+            "closed_at",
+            lambda v: DecodeUtils.to_maybe(v, DecodeUtils.to_date_time),
+        ),
+        JsonUnfolder.optional(
+            raw,
+            "due_date",
+            lambda v: DecodeUtils.to_maybe(v, lambda i: DecodeUtils.to_str(i).bind(decode_date)),
+        ).map(lambda m: m.bind(lambda x: x)),
+    ).map(lambda t: IssueDates(*t))
+
+
+def decode_issue(updated_by: Maybe[UserObj], raw: JsonObj) -> ResultE[Issue]:
+    return (
+        smash.smash_result_5(
+            _decode_def(raw),
+            _decode_refs(updated_by, raw),
+            _decode_properties(raw),
+            _decode_dates(raw),
+            _decode_stats(raw),
+        )
+        .map(lambda t: Issue(*t))
+        .alt(
+            lambda e: Bug.new(
+                "decode_issue",
+                inspect.currentframe(),
+                e,
+                (JsonUnfolder.dumps(raw),),
+            ),
+        )
+    )
+
+
+def decode_issue_and_id(
+    updated_by: Maybe[UserObj],
+    raw: JsonObj,
+) -> ResultE[tuple[IssueFullId, Issue]]:
+    _id = decode_issue_full_id(raw)
+    return smash.smash_result_2(
+        _id,
+        decode_issue(updated_by, raw),
+    )

fluidattacks_gitlab_sdk/issues/_client/_get_issue.py

@@ -0,0 +1,79 @@
+import inspect
+import logging
+
+from fa_purity import (
+    Cmd,
+    CmdTransform,
+    Coproduct,
+    FrozenDict,
+    Maybe,
+    Result,
+    cast_exception,
+)
+from fluidattacks_etl_utils.bug import Bug
+from fluidattacks_etl_utils.decode import int_to_str
+from fluidattacks_etl_utils.smash import merge_coproduct, right_map
+
+from fluidattacks_gitlab_sdk._decoders import assert_single
+from fluidattacks_gitlab_sdk._gql_client import GraphQlGitlabClient
+from fluidattacks_gitlab_sdk._handlers import NotFound, handle_not_found
+from fluidattacks_gitlab_sdk._http_client import HttpJsonClient, RelativeEndpoint
+from fluidattacks_gitlab_sdk.ids import IssueFullId, IssueInternalId, ProjectId
+from fluidattacks_gitlab_sdk.issues._client._updated_by import get_updated_by
+from fluidattacks_gitlab_sdk.issues.core import Issue, ProjectIdObj
+from fluidattacks_gitlab_sdk.users.core import UserObj
+
+from ._decode import decode_issue_and_id
+
+LOG = logging.getLogger(__name__)
+
+
+def _get_issue(
+    client: HttpJsonClient,
+    project: ProjectId,
+    updated_by: Maybe[UserObj],
+    issue_id: IssueInternalId,
+) -> Cmd[Result[tuple[IssueFullId, Issue], Coproduct[NotFound, Exception]]]:
+    endpoint = RelativeEndpoint.new(
+        "projects",
+        int_to_str(project.project_id.value),
+        "issues",
+        int_to_str(issue_id.internal_id.value),
+    )
+    msg = Cmd.wrap_impure(lambda: LOG.info("[API] get_issue(%s, %s)", project, issue_id))
+    return msg + client.get(
+        endpoint,
+        FrozenDict({}),
+    ).map(
+        lambda r: r.alt(
+            lambda e: e.map(handle_not_found, lambda e: Coproduct.inr(cast_exception(e))),
+        )
+        .bind(lambda i: assert_single(i).alt(Coproduct.inr))
+        .bind(lambda i: decode_issue_and_id(updated_by, i).alt(Coproduct.inr))
+        .alt(
+            lambda c: right_map(
+                c,
+                lambda e: cast_exception(
+                    Bug.new(
+                        "_get_issue",
+                        inspect.currentframe(),
+                        e,
+                        (),
+                    ),
+                ),
+            ),
+        ),
+    )
+
+
+def get_issue(
+    client: HttpJsonClient,
+    gql_client: GraphQlGitlabClient,
+    project: ProjectIdObj,
+    issue_id: IssueInternalId,
+) -> Cmd[Result[tuple[IssueFullId, Issue], Coproduct[NotFound, Exception]]]:
+    updated_by = get_updated_by(gql_client, project.project_path, issue_id)
+    return CmdTransform.chain_cmd_result(
+        updated_by,
+        lambda u: _get_issue(client, project.project_id, u, issue_id),
+    ).map(lambda r: r.alt(merge_coproduct))