fluidattacks_gitlab_sdk 1.0.0__py3-none-any.whl

fluidattacks_gitlab_sdk/issues/_client/_most_recent.py

@@ -0,0 +1,119 @@
+import inspect
+import logging
+
+from fa_purity import (
+    Cmd,
+    Maybe,
+    NewFrozenList,
+    Result,
+    ResultE,
+    cast_exception,
+)
+from fa_purity.json import JsonObj, JsonUnfolder, Primitive, UnfoldedFactory
+from fluidattacks_etl_utils.bug import Bug
+from fluidattacks_etl_utils.decode import int_to_str
+
+from fluidattacks_gitlab_sdk._decoders import (
+    assert_multiple,
+    decode_issue_internal_id,
+    decode_maybe_single,
+)
+from fluidattacks_gitlab_sdk._gql_client import GraphQlGitlabClient
+from fluidattacks_gitlab_sdk._http_client import HttpJsonClient, RelativeEndpoint
+from fluidattacks_gitlab_sdk.ids import IssueFullId, ProjectPath
+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 _most_recent_issue(
+    gql_client: GraphQlGitlabClient,
+    raw: JsonObj,
+    project: ProjectPath,
+) -> Cmd[ResultE[tuple[IssueFullId, Issue]]]:
+    """
+    Completes the raw issue obj by getting the updated by field.
+
+    This function should be called always after getting the raw issue.
+    It can fail when:
+    - decode fails
+    - raw issue id not exist and/or is fake
+    """
+    _updated_by: Cmd[ResultE[Maybe[UserObj]]] = (
+        decode_issue_internal_id(raw)
+        .to_coproduct()
+        .map(
+            lambda i: get_updated_by(gql_client, project, i.internal_id).map(
+                lambda r: r.alt(
+                    lambda c: c.map(
+                        lambda e: Bug.new(
+                            "most_recent_issue: race condition",
+                            inspect.currentframe(),
+                            e,
+                            (str(project), JsonUnfolder.dumps(raw)),
+                        ),  # this should be not possible, the issue was retrieved before
+                        lambda e: e,
+                    ),
+                ),
+            ),
+            lambda e: Cmd.wrap_value(Result.failure(e)),
+        )
+    )
+    return _updated_by.map(
+        lambda r: r.bind(
+            lambda u: decode_issue_and_id(u, raw),
+        ),
+    )
+
+
+def most_recent_issue(
+    client: HttpJsonClient,
+    gql_client: GraphQlGitlabClient,
+    project: ProjectIdObj,
+) -> Cmd[ResultE[Maybe[tuple[IssueFullId, Issue]]]]:
+    endpoint = RelativeEndpoint.new(
+        "projects",
+        int_to_str(project.project_id.project_id.value),
+        "issues",
+    )
+    params: dict[str, Primitive] = {
+        "order_by": "created_at",
+        "sort": "desc",
+        "per_page": 1,
+    }
+    empty: Maybe[tuple[IssueFullId, Issue]] = Maybe.empty()
+    msg: Cmd[None] = Cmd.wrap_impure(lambda: LOG.info("[API] most_recent_issue(%s)", project))
+    get_maybe_single = client.get(
+        endpoint,
+        UnfoldedFactory.from_dict(params),
+    ).map(
+        lambda r: r.alt(
+            lambda e: cast_exception(
+                Bug.new(
+                    "most_recent_issue",
+                    inspect.currentframe(),
+                    e,
+                    (),
+                ),
+            ),
+        )
+        .bind(assert_multiple)
+        .map(NewFrozenList)
+        .map(decode_maybe_single),
+    )
+    get_issue: Cmd[ResultE[Maybe[tuple[IssueFullId, Issue]]]] = get_maybe_single.bind(
+        lambda r: r.to_coproduct().map(
+            lambda m: m.to_coproduct().map(
+                lambda raw: _most_recent_issue(gql_client, raw, project.project_path).map(
+                    lambda r: r.map(Maybe.some),
+                ),
+                lambda _: Cmd.wrap_value(Result.success(empty)),
+            ),
+            lambda e: Cmd.wrap_value(Result.failure(e)),
+        ),
+    )
+    return msg + get_issue

fluidattacks_gitlab_sdk/issues/_client/_updated_by.py

@@ -0,0 +1,157 @@
+import inspect
+import logging
+from collections.abc import Callable
+from typing import TypeVar
+
+from fa_purity import (
+    Cmd,
+    Coproduct,
+    FrozenList,
+    FrozenTools,
+    Maybe,
+    Result,
+    ResultE,
+)
+from fa_purity.json import JsonObj, JsonUnfolder, JsonValue, Unfolder
+from fluidattacks_etl_utils.bug import Bug
+from fluidattacks_etl_utils.decode import DecodeUtils, int_to_str, str_to_int
+from fluidattacks_etl_utils.natural import Natural
+from fluidattacks_etl_utils.smash import right_map
+
+from fluidattacks_gitlab_sdk._gql_client import GraphQlGitlabClient
+from fluidattacks_gitlab_sdk._handlers import NotFound
+from fluidattacks_gitlab_sdk.ids import IssueInternalId, ProjectPath, UserId
+from fluidattacks_gitlab_sdk.users.core import User, UserName, UserObj
+
+LOG = logging.getLogger(__name__)
+_T = TypeVar("_T")
+
+
+def _nested_key(raw: JsonObj, first_key: str, next_keys: FrozenList[str]) -> ResultE[JsonValue]:
+    if next_keys:
+        return JsonUnfolder.require(
+            raw,
+            first_key,
+            lambda v: Unfolder.to_json(v).bind(
+                lambda v: _nested_key(v, next_keys[0], next_keys[1:]),
+            ),
+        )
+    return JsonUnfolder.require(raw, first_key, lambda v: Result.success(v))
+
+
+def _decode_gid(raw: str) -> ResultE[UserId]:
+    return str_to_int(raw.removeprefix("gid://gitlab/User/")).bind(Natural.from_int).map(UserId)
+
+
+def decode_user_obj(raw: JsonObj) -> ResultE[UserObj]:
+    return (
+        JsonUnfolder.require(raw, "id", DecodeUtils.to_str)
+        .bind(_decode_gid)
+        .bind(
+            lambda user_id: JsonUnfolder.require(raw, "username", DecodeUtils.to_str)
+            .map(User)
+            .bind(
+                lambda user: JsonUnfolder.require(raw, "name", DecodeUtils.to_str)
+                .map(UserName)
+                .map(
+                    lambda name: UserObj(user_id, user, name),
+                ),
+            ),
+        )
+    )
+
+
+def decode_updated_by(raw: JsonObj) -> ResultE[Maybe[UserObj]]:
+    return JsonUnfolder.require(
+        raw,
+        "updatedBy",
+        lambda v: DecodeUtils.to_maybe(v, lambda v: Unfolder.to_json(v).bind(decode_user_obj)),
+    )
+
+
+def _set_not_found_if_empty(
+    value: JsonValue,
+    transform: Callable[[JsonValue], ResultE[_T]],
+) -> Result[_T, Coproduct[NotFound, Exception]]:
+    return (
+        DecodeUtils.to_maybe(value, transform)
+        .alt(Coproduct[NotFound, Exception].inr)
+        .bind(
+            lambda m: m.to_coproduct().map(
+                lambda m: Result.success(m),
+                lambda _: Result.failure(Coproduct.inl(NotFound(ValueError("Issue not found")))),
+            ),
+        )
+    )
+
+
+def _decode(raw: JsonObj) -> Result[Maybe[UserObj], Coproduct[NotFound, Exception]]:
+    return (
+        _nested_key(raw, "project", ("issue",))
+        .alt(Coproduct[NotFound, Exception].inr)
+        .bind(
+            lambda v: _set_not_found_if_empty(
+                v,
+                lambda v: Unfolder.to_json(v).bind(decode_updated_by),
+            ),
+        )
+        .alt(
+            lambda c: c.map(
+                Coproduct.inl,
+                lambda e: Coproduct.inr(
+                    Bug.new(
+                        "decode_updated_by",
+                        inspect.currentframe(),
+                        e,
+                        (JsonUnfolder.dumps(raw),),
+                    ),
+                ),
+            ),
+        )
+    )
+
+
+def get_updated_by(
+    client: GraphQlGitlabClient,
+    project: ProjectPath,
+    issue_id: IssueInternalId,
+) -> Cmd[Result[Maybe[UserObj], Coproduct[NotFound, Exception]]]:
+    """
+    Get the updatedBy field of an issue.
+
+    To avoid failure ensure:
+    - The issue exist
+    - The credentials are correct
+    """
+    query = """
+    query getIssueUpdatedBy($project: ID!, $issue_iid: String!){
+        project(fullPath: $project) {
+            issue(iid: $issue_iid) {
+                updatedBy {
+                    id
+                    name
+                    username
+                }
+            }
+        }
+    }
+    """
+    values: dict[str, str] = {
+        "project": project.path,
+        "issue_iid": int_to_str(issue_id.internal_id.value),
+    }
+    return client.get(query, FrozenTools.freeze(values)).map(
+        lambda r: r.alt(Coproduct[NotFound, Exception].inr)
+        .bind(_decode)
+        .alt(
+            lambda c: right_map(
+                c,
+                lambda e: Bug.new(
+                    "get_updated_by",
+                    inspect.currentframe(),
+                    e,
+                    (str(project), str(issue_id)),
+                ),
+            ),
+        ),
+    )

fluidattacks_gitlab_sdk/issues/core.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from datetime import date
+from enum import (
+    Enum,
+)
+
+from fa_purity import Cmd, Coproduct, FrozenList, Maybe, Result, ResultE
+from fa_purity.date_time import DatetimeUTC
+
+from fluidattacks_gitlab_sdk._handlers import NotFound
+from fluidattacks_gitlab_sdk.ids import (
+    EpicFullId,
+    IssueFullId,
+    IssueInternalId,
+    MilestoneFullId,
+    ProjectId,
+    ProjectPath,
+)
+from fluidattacks_gitlab_sdk.users.core import UserObj
+
+
+class IssueType(Enum):
+    ISSUE = "issue"
+    INCIDENT = "incident"
+    TASK = "task"
+    TEST_CASE = "test_case"
+    REQUIREMENT = "requirement"
+
+
+@dataclass(frozen=True)
+class IssueCounts:
+    up_votes: int
+    down_votes: int
+    merge_requests_count: int
+
+
+@dataclass(frozen=True)
+class IssueDates:
+    created_at: DatetimeUTC
+    updated_at: Maybe[DatetimeUTC]
+    closed_at: Maybe[DatetimeUTC]
+    due_date: Maybe[date]
+
+
+@dataclass(frozen=True)
+class IssueOtherProperties:
+    confidential: bool
+    discussion_locked: Maybe[bool]
+    labels: FrozenList[str]
+    health_status: Maybe[str]
+    weight: Maybe[int]
+
+
+@dataclass(frozen=True)
+class IssueReferences:
+    author: UserObj
+    milestone: Maybe[MilestoneFullId]
+    epic: Maybe[EpicFullId]
+    closed_by: Maybe[UserObj]
+    assignees: FrozenList[UserObj]
+    updated_by: Maybe[UserObj]
+
+
+@dataclass(frozen=True)
+class IssueDef:
+    title: str
+    state: str
+    issue_type: IssueType
+    description: Maybe[str]
+
+
+@dataclass(frozen=True)
+class Issue:
+    definition: IssueDef
+    references: IssueReferences
+    properties: IssueOtherProperties
+    dates: IssueDates
+    stats: IssueCounts
+
+
+@dataclass(frozen=True)
+class ProjectIdObj:
+    project_id: ProjectId
+    project_path: ProjectPath
+
+
+@dataclass(frozen=True)
+class IssueClient:
+    get_issue: Callable[
+        [ProjectIdObj, IssueInternalId],
+        Cmd[Result[tuple[IssueFullId, Issue], Coproduct[NotFound, Exception]]],
+    ]
+    most_recent_issue: Callable[
+        [ProjectIdObj],
+        Cmd[ResultE[Maybe[tuple[IssueFullId, Issue]]]],
+    ]

fluidattacks_gitlab_sdk/members/__init__.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass
+
+from fluidattacks_gitlab_sdk._http_client import ClientFactory, Credentials, HttpJsonClient
+from fluidattacks_gitlab_sdk.members.core import Member, MemberClient
+
+from . import _client
+
+
+def _from_client(client: HttpJsonClient) -> MemberClient:
+    return MemberClient(
+        lambda p: _client.get_members(client, p),
+    )
+
+
+@dataclass(frozen=True)
+class MembersClientFactory:
+    @staticmethod
+    def new(creds: Credentials) -> MemberClient:
+        return _from_client(ClientFactory.new(creds))
+
+
+__all__ = [
+    "Member",
+    "MemberClient",
+]

fluidattacks_gitlab_sdk/members/_client.py

@@ -0,0 +1,49 @@
+import inspect
+
+from fa_purity import (
+    Cmd,
+    FrozenList,
+    ResultE,
+    cast_exception,
+)
+from fa_purity.json import Primitive, UnfoldedFactory
+from fluidattacks_etl_utils.bug import Bug
+from fluidattacks_etl_utils.decode import int_to_str
+
+from fluidattacks_gitlab_sdk._decoders import assert_multiple
+from fluidattacks_gitlab_sdk._http_client import HttpJsonClient, RelativeEndpoint
+from fluidattacks_gitlab_sdk.ids import MemberId, ProjectId
+
+from ._decode import decode_members
+from .core import Member
+
+
+def get_members(
+    client: HttpJsonClient,
+    project: ProjectId,
+) -> Cmd[ResultE[FrozenList[tuple[MemberId, Member]]]]:
+    endpoint = RelativeEndpoint.new(
+        "projects",
+        int_to_str(project.project_id.value),
+        "members",
+    )
+
+    params: dict[str, Primitive] = {
+        "page": 1,
+        "per_page": 100,
+    }
+
+    return client.get(
+        endpoint,
+        UnfoldedFactory.from_dict(params),
+    ).map(
+        lambda result: (
+            result.alt(
+                lambda e: cast_exception(
+                    Bug.new("_get_members", inspect.currentframe(), e, ()),
+                ),
+            )
+            .bind(assert_multiple)
+            .bind(lambda members: decode_members(members, project))
+        ),
+    )

fluidattacks_gitlab_sdk/members/_decode.py

@@ -0,0 +1,40 @@
+import logging
+
+from fa_purity import FrozenList, PureIterFactory, Result, ResultE, 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.ids import MemberId, ProjectId
+from fluidattacks_gitlab_sdk.members.core import Member
+
+LOG = logging.getLogger(__name__)
+
+
+def decode_member(raw: JsonObj, id_project: ProjectId) -> ResultE[Member]:
+    return smash.smash_result_2(
+        JsonUnfolder.require(raw, "username", DecodeUtils.to_str),
+        JsonUnfolder.require(raw, "name", DecodeUtils.to_str),
+    ).map(lambda m: Member(m[0], m[1], id_project))
+
+
+def decode_member_and_id(raw: JsonObj, id_project: ProjectId) -> ResultE[tuple[MemberId, Member]]:
+    return smash.smash_result_2(
+        JsonUnfolder.require(raw, "id", DecodeUtils.to_int).bind(Natural.from_int).map(MemberId),
+        decode_member(raw, id_project),
+    )
+
+
+def decode_members(
+    members: FrozenList[JsonObj],
+    id_project: ProjectId,
+) -> ResultE[FrozenList[tuple[MemberId, Member]]]:
+    if not members:
+        return Result.failure(ValueError("Expected a list of members"))
+
+    return ResultTransform.all_ok(
+        PureIterFactory.from_list(members)
+        .map(lambda c: decode_member_and_id(c, id_project))
+        .to_list(),
+    )

fluidattacks_gitlab_sdk/members/core.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+
+from fa_purity import Cmd, FrozenList, ResultE
+
+from fluidattacks_gitlab_sdk.ids import MemberId, ProjectId
+
+
+@dataclass(frozen=True)
+class Member:
+    member_user_name: str
+    member_name: str
+    id_project: ProjectId
+
+
+@dataclass(frozen=True)
+class MemberClient:
+    get_members: Callable[
+        [ProjectId],
+        Cmd[ResultE[FrozenList[tuple[MemberId, Member]]]],
+    ]

fluidattacks_gitlab_sdk/merge_requests/__init__.py

@@ -0,0 +1,9 @@
+"""Main documentation at https://docs.gitlab.com/ee/api/merge_requests.html ."""
+
+from ._client import MrClientFactory
+from .core import MrsClient
+
+__all__ = [
+    "MrClientFactory",
+    "MrsClient",
+]