fluidattacks_gitlab_sdk 1.0.0__py3-none-any.whl

fluidattacks_gitlab_sdk/merge_requests/_client.py

@@ -0,0 +1,265 @@
+from __future__ import (
+    annotations,
+)
+
+import inspect
+from dataclasses import (
+    dataclass,
+)
+from datetime import datetime
+
+from fa_purity import (
+    Cmd,
+    FrozenDict,
+    FrozenList,
+    Maybe,
+    NewFrozenList,
+    Result,
+    ResultE,
+    Stream,
+    cast_exception,
+)
+from fa_purity._core.utils import raise_exception
+from fa_purity.date_time import DatetimeUTC
+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_etl_utils.paginate import (
+    cursor_pagination,
+)
+
+from fluidattacks_gitlab_sdk._decoders import assert_multiple, assert_single, decode_maybe_single
+from fluidattacks_gitlab_sdk._http_client import (
+    ClientFactory,
+    Credentials,
+    HttpJsonClient,
+    RelativeEndpoint,
+)
+from fluidattacks_gitlab_sdk.ids import MrFullId, MrInternalId, ProjectId
+
+from ._decode import decode_batch_mrs, decode_mr_and_id
+from .core import MergeRequest, MrsClient, PerPage
+
+
+def get_mr(
+    client: HttpJsonClient,
+    project: ProjectId,
+    mr_id: MrInternalId,
+) -> Cmd[ResultE[tuple[MrFullId, MergeRequest]]]:
+    endpoint = RelativeEndpoint.new(
+        "projects",
+        int_to_str(project.project_id.value),
+        "merge_requests",
+        int_to_str(mr_id.internal.value),
+    )
+    return client.get(
+        endpoint,
+        FrozenDict({}),
+    ).map(
+        lambda r: r.alt(
+            lambda e: cast_exception(
+                Bug.new(
+                    "_get_mr",
+                    inspect.currentframe(),
+                    e,
+                    (),
+                ),
+            ),
+        )
+        .bind(assert_single)
+        .bind(decode_mr_and_id),
+    )
+
+
+def most_recent_mr_until(
+    client: HttpJsonClient,
+    project: ProjectId,
+    date_created_before: DatetimeUTC,
+) -> Cmd[ResultE[Maybe[tuple[MrFullId, MergeRequest]]]]:
+    endpoint = RelativeEndpoint.new(
+        "projects",
+        int_to_str(project.project_id.value),
+        "merge_requests",
+    )
+    params: dict[str, Primitive] = {
+        "created_before": date_created_before.date_time.isoformat(),
+        "order_by": "created_at",
+        "sort": "desc",
+        "per_page": 1,
+    }
+    empty: Maybe[tuple[MrFullId, MergeRequest]] = Maybe.empty()
+    return client.get(
+        endpoint,
+        UnfoldedFactory.from_dict(params),
+    ).map(
+        lambda r: r.alt(
+            lambda e: cast_exception(
+                Bug.new(
+                    "most_recent_mr",
+                    inspect.currentframe(),
+                    e,
+                    (),
+                ),
+            ),
+        )
+        .bind(assert_multiple)
+        .map(NewFrozenList)
+        .map(decode_maybe_single)
+        .bind(
+            lambda m: m.to_coproduct().map(
+                lambda r: decode_mr_and_id(r).map(Maybe.some),
+                lambda _: Result.success(empty),
+            ),
+        ),
+    )
+
+
+def most_recent_mr(
+    client: HttpJsonClient,
+    project: ProjectId,
+) -> Cmd[ResultE[Maybe[tuple[MrFullId, MergeRequest]]]]:
+    endpoint = RelativeEndpoint.new(
+        "projects",
+        int_to_str(project.project_id.value),
+        "merge_requests",
+    )
+    params: dict[str, Primitive] = {
+        "order_by": "created_at",
+        "sort": "desc",
+        "per_page": 1,
+    }
+    empty: Maybe[tuple[MrFullId, MergeRequest]] = Maybe.empty()
+    return client.get(
+        endpoint,
+        UnfoldedFactory.from_dict(params),
+    ).map(
+        lambda r: r.alt(
+            lambda e: cast_exception(
+                Bug.new(
+                    "most_recent_mr",
+                    inspect.currentframe(),
+                    e,
+                    (),
+                ),
+            ),
+        )
+        .bind(assert_multiple)
+        .map(NewFrozenList)
+        .map(decode_maybe_single)
+        .bind(
+            lambda m: m.to_coproduct().map(
+                lambda r: decode_mr_and_id(r).map(Maybe.some),
+                lambda _: Result.success(empty),
+            ),
+        ),
+    )
+
+
+def validate_next_page(
+    page: int,
+    items: FrozenList[tuple[MrFullId, MergeRequest]],
+) -> ResultE[tuple[FrozenList[tuple[MrFullId, MergeRequest]], Maybe[int]]]:
+    return Result.success((items, Maybe.some(page + 1) if len(items) > 0 else Maybe.empty()))
+
+
+def get_updated_mrs(  # noqa: PLR0913
+    client: HttpJsonClient,
+    project: ProjectId,
+    date_update_after: datetime,
+    date_updated_before: datetime,
+    page: Maybe[int],
+    per_page: PerPage,
+) -> Cmd[ResultE[tuple[FrozenList[tuple[MrFullId, MergeRequest]], Maybe[int]]]]:
+    endpoint = RelativeEndpoint.new(
+        "projects",
+        int_to_str(project.project_id.value),
+        "merge_requests",
+    )
+    current_page: int = page.value_or(1)
+    params: dict[str, Primitive] = {
+        "updated_after": date_update_after.isoformat(),
+        "updated_before": date_updated_before.isoformat(),
+        "labels": "Any",
+        "order_by": "updated_at",
+        "sort": "desc",
+        "page": int_to_str(current_page),
+        "per_page": per_page,
+    }
+    return client.get(
+        endpoint,
+        UnfoldedFactory.from_dict(params),
+    ).map(
+        lambda r: r.alt(
+            lambda e: cast_exception(
+                Bug.new(
+                    "mr_updates",
+                    inspect.currentframe(),
+                    e,
+                    (),
+                ),
+            ),
+        )
+        .bind(assert_multiple)
+        .bind(decode_batch_mrs)
+        .bind(lambda items: validate_next_page(current_page, items)),
+    )
+
+
+def get_page(  # noqa: PLR0913
+    client: HttpJsonClient,
+    project: ProjectId,
+    date_update_after: datetime,
+    date_updated_before: datetime,
+    page: Maybe[int],
+    per_page: PerPage,
+) -> Cmd[tuple[FrozenList[tuple[MrFullId, MergeRequest]], Maybe[int]]]:
+    return get_updated_mrs(
+        client,
+        project,
+        date_update_after,
+        date_updated_before,
+        page,
+        per_page,
+    ).map(lambda r: r.alt(raise_exception).to_union())
+
+
+def get_all_updated_mrs(
+    client: HttpJsonClient,
+    project: ProjectId,
+    date_update_after: datetime,
+    date_updated_before: datetime,
+    per_page: PerPage,
+) -> Cmd[Stream[FrozenList[tuple[MrFullId, MergeRequest]]]]:
+    stream = cursor_pagination(
+        lambda maybe_page: get_page(
+            client,
+            project,
+            date_update_after,
+            date_updated_before,
+            maybe_page,
+            per_page,
+        ),
+    )
+    return Cmd.wrap_value(stream)
+
+
+def _from_client(client: HttpJsonClient) -> MrsClient:
+    return MrsClient(
+        lambda p, i: get_mr(client, p, i),
+        lambda p: most_recent_mr(client, p),
+        lambda p, d: most_recent_mr_until(client, p, d),
+        lambda p, a, b, v: get_all_updated_mrs(
+            client,
+            p,
+            a,
+            b,
+            v,
+        ),
+    )
+
+
+@dataclass(frozen=True)
+class MrClientFactory:
+    @staticmethod
+    def new(creds: Credentials) -> MrsClient:
+        return _from_client(ClientFactory.new(creds))

fluidattacks_gitlab_sdk/merge_requests/_decode.py

@@ -0,0 +1,234 @@
+import inspect
+
+from fa_purity import Maybe, PureIterFactory, Result, ResultE, ResultTransform
+from fa_purity._core.frozen import FrozenList
+from fa_purity.json import JsonObj, JsonUnfolder, Unfolder
+from fluidattacks_etl_utils import smash
+from fluidattacks_etl_utils.bug import Bug
+from fluidattacks_etl_utils.decode import DecodeUtils
+from fluidattacks_etl_utils.natural import Natural
+
+from fluidattacks_gitlab_sdk._decoders import (
+    decode_milestone_full_id,
+    decode_mr_full_id,
+)
+from fluidattacks_gitlab_sdk.ids import (
+    MrFullId,
+    ProjectId,
+    UserId,
+)
+from fluidattacks_gitlab_sdk.merge_requests.core import (
+    MergeRequest,
+    MergeRequestDates,
+    MergeRequestFullState,
+    MergeRequestOrigins,
+    MergeRequestPeople,
+    MergeRequestProperties,
+    MergeRequestSha,
+    MergeRequestState,
+    TaskCompletion,
+)
+from fluidattacks_gitlab_sdk.users.decode import decode_user_obj
+
+
+def decode_sha(raw: JsonObj) -> ResultE[MergeRequestSha]:
+    return smash.smash_result_3(
+        JsonUnfolder.require(raw, "sha", DecodeUtils.to_opt_str),
+        JsonUnfolder.optional(raw, "merge_commit_sha", DecodeUtils.to_opt_str).map(
+            lambda m: m.bind(lambda x: x),
+        ),
+        JsonUnfolder.optional(raw, "squash_commit_sha", DecodeUtils.to_opt_str).map(
+            lambda m: m.bind(lambda x: x),
+        ),
+    ).map(lambda t: MergeRequestSha(*t))
+
+
+def decode_dates(raw: JsonObj) -> ResultE[MergeRequestDates]:
+    return smash.smash_result_5(
+        JsonUnfolder.require(raw, "created_at", DecodeUtils.to_date_time),
+        JsonUnfolder.optional(raw, "prepared_at", DecodeUtils.to_opt_date_time).map(
+            lambda m: m.bind(lambda x: x),
+        ),
+        JsonUnfolder.optional(raw, "updated_at", DecodeUtils.to_opt_date_time).map(
+            lambda m: m.bind(lambda x: x),
+        ),
+        JsonUnfolder.optional(raw, "merged_at", DecodeUtils.to_opt_date_time).map(
+            lambda m: m.bind(lambda x: x),
+        ),
+        JsonUnfolder.optional(raw, "closed_at", DecodeUtils.to_opt_date_time).map(
+            lambda m: m.bind(lambda x: x),
+        ),
+    ).map(lambda t: MergeRequestDates(*t))
+
+
+def decode_user_id(raw: JsonObj) -> ResultE[UserId]:
+    return JsonUnfolder.require(raw, "id", DecodeUtils.to_int).bind(Natural.from_int).map(UserId)
+
+
+def decode_people(raw: JsonObj) -> ResultE[MergeRequestPeople]:
+    return smash.smash_result_5(
+        JsonUnfolder.require(
+            raw,
+            "author",
+            lambda v: Unfolder.to_json(v).bind(decode_user_obj),
+        ),
+        JsonUnfolder.optional(
+            raw,
+            "merge_user",
+            lambda v: Unfolder.to_optional(
+                v,
+                lambda v: Unfolder.to_json(v).bind(decode_user_obj),
+            ),
+        ).map(lambda m: m.bind(lambda x: Maybe.from_optional(x))),
+        JsonUnfolder.optional(
+            raw,
+            "closed_by",
+            lambda v: Unfolder.to_optional(
+                v,
+                lambda v: Unfolder.to_json(v).bind(decode_user_obj),
+            ),
+        ).map(lambda m: m.bind(lambda x: Maybe.from_optional(x))),
+        JsonUnfolder.require(
+            raw,
+            "assignees",
+            lambda v: Unfolder.to_list_of(
+                v,
+                lambda v: Unfolder.to_json(v).bind(decode_user_obj),
+            ),
+        ),
+        JsonUnfolder.require(
+            raw,
+            "reviewers",
+            lambda v: Unfolder.to_list_of(
+                v,
+                lambda v: Unfolder.to_json(v).bind(decode_user_obj),
+            ),
+        ),
+    ).map(lambda t: MergeRequestPeople(*t))
+
+
+def decode_state(raw: JsonObj) -> ResultE[MergeRequestFullState]:
+    return smash.smash_result_5(
+        JsonUnfolder.require(raw, "state", DecodeUtils.to_str).bind(
+            MergeRequestState.from_raw,
+        ),
+        JsonUnfolder.require(raw, "detailed_merge_status", DecodeUtils.to_str),
+        JsonUnfolder.require(raw, "has_conflicts", DecodeUtils.to_bool),
+        JsonUnfolder.require(raw, "user_notes_count", DecodeUtils.to_int),
+        JsonUnfolder.optional(raw, "merge_error", DecodeUtils.to_opt_str).map(
+            lambda m: m.bind(lambda x: x),
+        ),
+    ).map(lambda t: MergeRequestFullState(*t))
+
+
+def decode_properties(raw: JsonObj) -> ResultE[MergeRequestProperties]:
+    group_1 = smash.smash_result_5(
+        JsonUnfolder.require(raw, "title", DecodeUtils.to_str),
+        JsonUnfolder.optional(raw, "description", DecodeUtils.to_opt_str).map(
+            lambda m: m.bind(lambda x: x),
+        ),
+        JsonUnfolder.require(raw, "draft", DecodeUtils.to_bool),
+        JsonUnfolder.require(raw, "squash", DecodeUtils.to_bool),
+        JsonUnfolder.require(raw, "imported", DecodeUtils.to_bool),
+    )
+    group_2 = smash.smash_result_5(
+        JsonUnfolder.require(raw, "imported_from", DecodeUtils.to_str),
+        JsonUnfolder.optional(raw, "first_contribution", DecodeUtils.to_bool).map(
+            lambda m: m.value_or(False),
+        ),
+        JsonUnfolder.require(
+            raw,
+            "labels",
+            lambda v: Unfolder.to_list_of(v, DecodeUtils.to_str),
+        ),
+        JsonUnfolder.optional(raw, "merge_after", DecodeUtils.to_opt_date_time).map(
+            lambda m: m.bind(lambda x: x),
+        ),
+        JsonUnfolder.require(raw, "web_url", DecodeUtils.to_str),
+    )
+    return smash.smash_result_2(group_1, group_2).map(
+        lambda g: MergeRequestProperties(*g[0], *g[1]),
+    )
+
+
+def decode_origins(raw: JsonObj) -> ResultE[MergeRequestOrigins]:
+    return smash.smash_result_4(
+        JsonUnfolder.require(raw, "source_project_id", DecodeUtils.to_int)
+        .bind(Natural.from_int)
+        .map(
+            ProjectId,
+        ),
+        JsonUnfolder.require(raw, "source_branch", DecodeUtils.to_str),
+        JsonUnfolder.require(raw, "target_project_id", DecodeUtils.to_int)
+        .bind(Natural.from_int)
+        .map(
+            ProjectId,
+        ),
+        JsonUnfolder.require(raw, "target_branch", DecodeUtils.to_str),
+    ).map(lambda t: MergeRequestOrigins(*t))
+
+
+def decode_completion(raw: JsonObj) -> ResultE[TaskCompletion]:
+    return JsonUnfolder.require(
+        raw,
+        "task_completion_status",
+        lambda v: Unfolder.to_json(v).bind(
+            lambda raw: smash.smash_result_2(
+                JsonUnfolder.require(raw, "count", DecodeUtils.to_int),
+                JsonUnfolder.require(raw, "completed_count", DecodeUtils.to_int),
+            ).map(lambda t: TaskCompletion(*t)),
+        ),
+    )
+
+
+def decode_mr(raw: JsonObj) -> ResultE[MergeRequest]:
+    group_1 = smash.smash_result_5(
+        decode_sha(raw),
+        decode_dates(raw),
+        decode_people(raw),
+        decode_state(raw),
+        decode_properties(raw),
+    )
+    group_2 = smash.smash_result_3(
+        decode_origins(raw),
+        JsonUnfolder.require(
+            raw,
+            "milestone",
+            lambda v: DecodeUtils.to_maybe(
+                v,
+                lambda v: Unfolder.to_json(v).bind(decode_milestone_full_id),
+            ),
+        ),
+        decode_completion(raw),
+    )
+    return (
+        smash.smash_result_2(group_1, group_2)
+        .map(
+            lambda g: MergeRequest(*g[0], *g[1]),
+        )
+        .alt(
+            lambda e: Bug.new(
+                "decode_mr",
+                inspect.currentframe(),
+                e,
+                (JsonUnfolder.dumps(raw),),
+            ),
+        )
+    )
+
+
+def decode_mr_and_id(raw: JsonObj) -> ResultE[tuple[MrFullId, MergeRequest]]:
+    return smash.smash_result_2(
+        decode_mr_full_id(raw),
+        decode_mr(raw),
+    )
+
+
+def decode_batch_mrs(
+    mrs: FrozenList[JsonObj],
+) -> ResultE[FrozenList[tuple[MrFullId, MergeRequest]]]:
+    if not mrs:
+        return Result.success(FrozenList[tuple[MrFullId, MergeRequest]]([]), Exception)
+    return ResultTransform.all_ok(
+        PureIterFactory.from_list(mrs).map(lambda v: decode_mr_and_id(v)).to_list(),
+    )

fluidattacks_gitlab_sdk/merge_requests/core.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from datetime import datetime
+from enum import Enum
+from typing import NewType
+
+from fa_purity import (
+    Cmd,
+    FrozenList,
+    Maybe,
+    Result,
+    ResultE,
+    Stream,
+    cast_exception,
+)
+from fa_purity.date_time import DatetimeUTC
+
+from fluidattacks_gitlab_sdk.ids import (
+    MilestoneFullId,
+    MrFullId,
+    MrInternalId,
+    ProjectId,
+)
+from fluidattacks_gitlab_sdk.users.core import UserObj
+
+PerPage = NewType("PerPage", int)
+
+
+class MergeRequestState(Enum):
+    # locked: transitional state while a merge is happening
+    OPENED = "opened"
+    CLOSED = "closed"
+    LOCKED = "locked"
+    MERGED = "merged"
+
+    @staticmethod
+    def from_raw(raw: str) -> ResultE[MergeRequestState]:
+        try:
+            return Result.success(MergeRequestState(raw))
+        except ValueError as err:
+            return Result.failure(cast_exception(err))
+
+
+@dataclass(frozen=True)
+class MergeRequestSha:
+    sha: Maybe[str]
+    merge_commit_sha: Maybe[str]
+    squash_commit_sha: Maybe[str]
+
+
+@dataclass(frozen=True)
+class MergeRequestDates:
+    created_at: DatetimeUTC
+    prepared_at: Maybe[DatetimeUTC]
+    updated_at: Maybe[DatetimeUTC]
+    merged_at: Maybe[DatetimeUTC]
+    closed_at: Maybe[DatetimeUTC]
+
+
+@dataclass(frozen=True)
+class MergeRequestPeople:
+    author: UserObj
+    merge_user: Maybe[UserObj]
+    closed_by: Maybe[UserObj]
+    assignees: FrozenList[UserObj]
+    reviewers: FrozenList[UserObj]
+
+
+@dataclass(frozen=True)
+class MergeRequestFullState:
+    state: MergeRequestState
+    detailed_merge_status: str
+    has_conflicts: bool
+    user_notes_count: int
+    merge_error: Maybe[str]
+
+
+@dataclass(frozen=True)
+class MergeRequestProperties:
+    title: str
+    description: Maybe[str]
+    draft: bool
+    squash: bool
+    imported: bool
+    imported_from: str
+    first_contribution: bool
+    labels: FrozenList[str]
+    merge_after: Maybe[DatetimeUTC]
+    web_url: str
+
+
+@dataclass(frozen=True)
+class MergeRequestOrigins:
+    source_project_id: ProjectId
+    source_branch: str
+    target_project_id: ProjectId
+    target_branch: str
+
+
+@dataclass(frozen=True)
+class TaskCompletion:
+    count: int
+    completed_count: int
+
+
+@dataclass(frozen=True)
+class MergeRequest:
+    shas: MergeRequestSha
+    dates: MergeRequestDates
+    people: MergeRequestPeople
+    full_state: MergeRequestFullState
+    properties: MergeRequestProperties
+    origins: MergeRequestOrigins
+    milestone: Maybe[MilestoneFullId]
+    task_completion: TaskCompletion
+
+
+@dataclass(frozen=True)
+class MrsClient:
+    get_mr: Callable[
+        [ProjectId, MrInternalId],
+        Cmd[ResultE[tuple[MrFullId, MergeRequest]]],
+    ]
+    most_recent_mr: Callable[
+        [ProjectId],
+        Cmd[ResultE[Maybe[tuple[MrFullId, MergeRequest]]]],
+    ]
+    most_recent_mr_until: Callable[
+        [ProjectId, DatetimeUTC],
+        Cmd[ResultE[Maybe[tuple[MrFullId, MergeRequest]]]],
+    ]
+    get_mr_updated: Callable[
+        [ProjectId, datetime, datetime, PerPage],
+        Cmd[Stream[FrozenList[tuple[MrFullId, MergeRequest]]]],
+    ]

fluidattacks_gitlab_sdk/milestones/__init__.py

@@ -0,0 +1,4 @@
+from ._client import MilestoneFactory
+from .core import MilestoneClient
+
+__all__ = ["MilestoneClient", "MilestoneFactory"]