fluidattacks_gitlab_sdk 2.0.1__tar.gz → 2.2.0__tar.gz

{fluidattacks_gitlab_sdk-2.0.1 → fluidattacks_gitlab_sdk-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fluidattacks_gitlab_sdk
-Version: 2.0.1
+Version: 2.2.0
 Summary: gitlab SDK
 Author-email: Product Team <development@fluidattacks.com>
 Requires-Python: >=3.11
@@ -10,4 +10,4 @@ Requires-Dist: fa-purity >=2.5.2, <3.0.0
 Requires-Dist: pure-requests >=3.0.0, <4.0.0
 Requires-Dist: python-dateutil >=2.8.0, <3.0.0
 Requires-Dist: fluidattacks-etl-utils >=2.0.0, <3.0.0
-Requires-Dist: fluidattacks-utils-logger >=2.0.0, <3.0.0
+Requires-Dist: fluidattacks-utils-logger >=3.0.0, <4.0.0

{fluidattacks_gitlab_sdk-2.0.1 → fluidattacks_gitlab_sdk-2.2.0}/fluidattacks_gitlab_sdk/__init__.py

@@ -11,7 +11,7 @@ from ._logger import (
     set_logger,
 )
 
-__version__ = "2.0.1"
+__version__ = "2.2.0"
 
 Unsafe.compute(set_logger(__name__, __version__))
 LOG = logging.getLogger(__name__)

{fluidattacks_gitlab_sdk-2.0.1 → fluidattacks_gitlab_sdk-2.2.0}/fluidattacks_gitlab_sdk/_logger.py

@@ -6,7 +6,6 @@ from fluidattacks_utils_logger import (
 )
 from fluidattacks_utils_logger.env import (
     current_app_env,
-    notifier_key,
     observes_debug,
 )
 from fluidattacks_utils_logger.handlers import (
@@ -15,20 +14,14 @@ from fluidattacks_utils_logger.handlers import (
 
 
 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",
-            ),
+    conf = app_env.map(
+        lambda env: LoggingConf(
+            app_name="observes",
+            app_type="sdk",
+            app_version=version,
+            release_stage=env,
         ),
     )
     return debug.bind(lambda d: conf.bind(lambda c: set_main_log(root_name, c, d)))

{fluidattacks_gitlab_sdk-2.0.1 → fluidattacks_gitlab_sdk-2.2.0}/fluidattacks_gitlab_sdk/ids.py

@@ -133,3 +133,13 @@ class IssueFullInternalId:
 class IssueFullId:
     global_id: IssueGlobalId
     internal_id: IssueFullInternalId
+
+
+@dataclass(frozen=True)
+class JobId:
+    job_id: Natural
+
+
+@dataclass(frozen=True)
+class RunnerId:
+    runner_id: Natural

fluidattacks_gitlab_sdk-2.2.0/fluidattacks_gitlab_sdk/jobs/__init__.py

@@ -0,0 +1,3 @@
+from ._client import JobClientFactory
+
+__all__ = ["JobClientFactory"]

fluidattacks_gitlab_sdk-2.2.0/fluidattacks_gitlab_sdk/jobs/_client.py

@@ -0,0 +1,72 @@
+from __future__ import (
+    annotations,
+)
+
+import inspect
+import logging
+from dataclasses import dataclass
+
+from fa_purity import Cmd, Coproduct, FrozenDict, 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 right_map
+
+from fluidattacks_gitlab_sdk._decoders import assert_single
+from fluidattacks_gitlab_sdk._handlers import NotFound, handle_not_found
+from fluidattacks_gitlab_sdk._http_client import (
+    ClientFactory,
+    Credentials,
+    HttpJsonClient,
+    RelativeEndpoint,
+)
+from fluidattacks_gitlab_sdk.ids import JobId, ProjectId
+
+from ._decode import decode_job_obj
+from .core import JobClient, JobObj
+
+LOG = logging.getLogger(__name__)
+
+
+def get_job(
+    client: HttpJsonClient,
+    project: ProjectId,
+    job_id: JobId,
+) -> Cmd[Result[JobObj, Coproduct[NotFound, Exception]]]:
+    endpoint = RelativeEndpoint.new(
+        "projects",
+        int_to_str(project.project_id.value),
+        "jobs",
+        int_to_str(job_id.job_id.value),
+    )
+    msg = Cmd.wrap_impure(lambda: LOG.info("[API] get_job(%s, %s)", project, job_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 v: assert_single(v).alt(Coproduct.inr))
+        .bind(lambda v: decode_job_obj(v).alt(Coproduct.inr))
+        .alt(
+            lambda c: right_map(
+                c,
+                lambda e: cast_exception(
+                    Bug.new(
+                        "_get_job",
+                        inspect.currentframe(),
+                        e,
+                        (),
+                    ),
+                ),
+            ),
+        ),
+    )
+
+
+def _from_client(client: HttpJsonClient) -> JobClient:
+    return JobClient(lambda p, j: get_job(client, p, j))
+
+
+@dataclass(frozen=True)
+class JobClientFactory:
+    @staticmethod
+    def new(creds: Credentials) -> JobClient:
+        return _from_client(ClientFactory.new(creds))

fluidattacks_gitlab_sdk-2.2.0/fluidattacks_gitlab_sdk/jobs/_decode.py

@@ -0,0 +1,157 @@
+import logging
+from datetime import datetime
+from decimal import Decimal
+
+from dateutil.parser import (
+    isoparse,
+)
+from fa_purity import (
+    FrozenDict,
+    FrozenList,
+    Maybe,
+    Result,
+    ResultE,
+    ResultSmash,
+)
+from fa_purity.json import JsonObj, JsonPrimitiveUnfolder, JsonUnfolder, JsonValue, Unfolder
+from fluidattacks_etl_utils import smash
+from fluidattacks_etl_utils.decode import DecodeUtils
+from fluidattacks_etl_utils.natural import Natural, NaturalOperations
+
+from fluidattacks_gitlab_sdk.ids import JobId, RunnerId, UserId
+
+from .core import Commit, CommitHash, Job, JobConf, JobDates, JobObj, JobResultStatus
+
+LOG = logging.getLogger(__name__)
+
+
+def _decoder_require_list(item: JsonValue) -> ResultE[FrozenList[str]]:
+    return Unfolder.to_list_of(
+        item,
+        lambda v: Unfolder.to_primitive(v).bind(
+            lambda p: JsonPrimitiveUnfolder.to_str(p),
+        ),
+    )
+
+
+def get_float(number: JsonValue) -> ResultE[float]:
+    return Unfolder.to_primitive(number).bind(lambda v: JsonPrimitiveUnfolder.to_float(v))
+
+
+def str_to_datetime(raw: str) -> ResultE[datetime]:
+    try:
+        return Result.success(isoparse(raw))
+    except ValueError as err:
+        return Result.failure(Exception(err))
+
+
+def decode_str(value: JsonValue) -> ResultE[str]:
+    return Unfolder.to_primitive(value).bind(lambda p: JsonPrimitiveUnfolder.to_str(p))
+
+
+def decode_datetime(value: JsonValue) -> ResultE[datetime]:
+    return decode_str(value).bind(str_to_datetime)
+
+
+def decode_job_id(raw: JsonObj) -> ResultE[JobId]:
+    return JsonUnfolder.require(raw, "id", DecodeUtils.to_int).bind(Natural.from_int).map(JobId)
+
+
+def decode_user_id(raw: JsonObj) -> ResultE[Maybe[UserId]]:
+    def decode_maybe_id(raw: JsonObj) -> ResultE[Maybe[UserId]]:
+        return JsonUnfolder.optional(
+            raw,
+            "id",
+            lambda v: Unfolder.to_primitive(v)
+            .bind(JsonPrimitiveUnfolder.to_int)
+            .map(lambda j: UserId(NaturalOperations.absolute(j))),
+        )
+
+    maybe_user_obj = JsonUnfolder.optional(raw, "user", lambda v: Unfolder.to_json(v))
+    return maybe_user_obj.bind(lambda v: decode_maybe_id(v.value_or(FrozenDict({}))))
+
+
+def decode_runner_id(raw: JsonObj) -> ResultE[Maybe[RunnerId]]:
+    def decode_maybe_id(raw: JsonObj) -> ResultE[Maybe[RunnerId]]:
+        return JsonUnfolder.optional(
+            raw,
+            "id",
+            lambda v: Unfolder.to_primitive(v)
+            .bind(JsonPrimitiveUnfolder.to_int)
+            .map(lambda j: RunnerId(NaturalOperations.absolute(j))),
+        )
+
+    maybe_runner_obj = JsonUnfolder.optional(raw, "runner", lambda v: Unfolder.to_json(v))
+    return maybe_runner_obj.bind(lambda v: decode_maybe_id(v.value_or(FrozenDict({}))))
+
+
+def decode_commit_properties(raw: JsonObj) -> ResultE[Commit]:
+    sha_commit = JsonUnfolder.optional(raw, "id", DecodeUtils.to_opt_str).map(
+        lambda v: v.bind(lambda j: j.map(lambda p: CommitHash(p))),
+    )
+    title = JsonUnfolder.optional(raw, "title", DecodeUtils.to_opt_str).map(
+        lambda v: v.bind(lambda j: j),
+    )
+    return ResultSmash.smash_result_2(sha_commit, title).map(lambda v: Commit(*v))
+
+
+def decode_commit(raw: JsonObj) -> ResultE[Commit]:
+    maybe_commit_obj = JsonUnfolder.optional(raw, "commit", lambda v: Unfolder.to_json(v))
+    return maybe_commit_obj.bind(lambda v: decode_commit_properties(v.value_or(FrozenDict({}))))
+
+
+def decode_job_dates(raw: JsonObj) -> ResultE[JobDates]:
+    created_at = JsonUnfolder.require(raw, "created_at", DecodeUtils.to_date_time)
+    started_at = JsonUnfolder.optional(raw, "started_at", DecodeUtils.to_opt_date_time).map(
+        lambda m: m.bind(lambda x: x),
+    )
+    finished_at = JsonUnfolder.optional(raw, "finished_at", DecodeUtils.to_opt_date_time).map(
+        lambda m: m.bind(lambda x: x),
+    )
+    return ResultSmash.smash_result_3(created_at, started_at, finished_at).map(
+        lambda t: JobDates(*t),
+    )
+
+
+def decode_job_conf(raw: JsonObj) -> ResultE[JobConf]:
+    return smash.smash_result_4(
+        JsonUnfolder.require(raw, "allow_failure", DecodeUtils.to_bool),
+        JsonUnfolder.require(raw, "tag_list", _decoder_require_list),
+        JsonUnfolder.require(raw, "ref", DecodeUtils.to_str),
+        JsonUnfolder.require(raw, "stage", DecodeUtils.to_str),
+    ).map(lambda v: JobConf(*v))
+
+
+def decode_job_result(raw: JsonObj) -> ResultE[JobResultStatus]:
+    return smash.smash_result_4(
+        JsonUnfolder.require(raw, "status", DecodeUtils.to_str),
+        JsonUnfolder.optional(raw, "failure_reason", DecodeUtils.to_opt_str).map(
+            lambda v: v.bind(lambda j: j),
+        ),
+        JsonUnfolder.optional(raw, "duration", lambda v: get_float(v).map(Decimal)),
+        JsonUnfolder.optional(raw, "queued_duration", lambda v: get_float(v).map(Decimal)),
+    ).map(lambda v: JobResultStatus(*v))
+
+
+def decode_job(raw: JsonObj) -> ResultE[Job]:
+    first = smash.smash_result_5(
+        JsonUnfolder.require(raw, "name", DecodeUtils.to_str),
+        decode_user_id(raw),
+        decode_runner_id(raw),
+        JsonUnfolder.optional(raw, "coverage", get_float),
+        decode_commit(raw),
+    )
+    second = smash.smash_result_3(
+        decode_job_dates(raw),
+        decode_job_conf(raw),
+        decode_job_result(raw),
+    )
+
+    return smash.smash_result_2(first, second).map(lambda v: Job(*v[0], *v[1]))
+
+
+def decode_job_obj(raw: JsonObj) -> ResultE[JobObj]:
+    id_job = JsonUnfolder.require(raw, "id", DecodeUtils.to_int).map(
+        lambda v: JobId(NaturalOperations.absolute(v)),
+    )
+    return smash.smash_result_2(id_job, decode_job(raw)).map(lambda v: JobObj(*v))

fluidattacks_gitlab_sdk-2.2.0/fluidattacks_gitlab_sdk/jobs/core.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from decimal import Decimal
+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 JobId, ProjectId, RunnerId, UserId
+
+
+@dataclass(frozen=True)
+class CommitHash:
+    hash_str: str
+
+
+@dataclass(frozen=True)
+class Commit:
+    sha_commit: Maybe[CommitHash]
+    title_commit: Maybe[str]
+
+
+@dataclass(frozen=True)
+class JobDates:
+    created_at: DatetimeUTC
+    started_at: Maybe[DatetimeUTC]
+    finished_at: Maybe[DatetimeUTC]
+
+
+@dataclass(frozen=True)
+class JobConf:
+    allow_failure: bool
+    tag_list: FrozenList[str]
+    ref_branch: str
+    stage: str
+
+
+class JobStatus(Enum):
+    CREATED = "created"
+    PENDING = "pending"
+    RUNNING = "running"
+    FAILED = "failed"
+    SUCCESS = "success"
+    CANCELED = "canceled"
+    SKIPPED = "skipped"
+    WAITING_FOR_RESOURCE = "waiting_for_resource"
+    MANUAL = "manual"
+
+    @staticmethod
+    def from_raw(raw: str) -> ResultE[JobStatus]:
+        try:
+            return Result.success(JobStatus(raw))
+        except ValueError as err:
+            return Result.failure(Exception(err))
+
+
+@dataclass(frozen=True)
+class JobResultStatus:
+    status: str
+    failure_reason: Maybe[str]
+    duration: Maybe[Decimal]
+    queued_duration: Maybe[Decimal]
+
+
+@dataclass(frozen=True)
+class Job:
+    name: str
+    user_id: Maybe[UserId]
+    runner_id: Maybe[RunnerId]
+    coverage: Maybe[float]
+    commit: Commit
+    dates: JobDates
+    conf: JobConf
+    result: JobResultStatus
+
+
+@dataclass(frozen=True)
+class JobObj:
+    job_id: JobId
+    obj: Job
+
+
+@dataclass(frozen=True)
+class JobClient:
+    get_job: Callable[[ProjectId, JobId], Cmd[Result[JobObj, Coproduct[NotFound, Exception]]]]
+
+
+__all__ = [
+    "JobId",
+]

{fluidattacks_gitlab_sdk-2.0.1 → fluidattacks_gitlab_sdk-2.2.0}/pyproject.toml

@@ -9,7 +9,7 @@ dependencies = [
     "pure-requests >=3.0.0, <4.0.0",
     "python-dateutil >=2.8.0, <3.0.0",
     "fluidattacks-etl-utils >=2.0.0, <3.0.0",
-    "fluidattacks-utils-logger >=2.0.0, <3.0.0",
+    "fluidattacks-utils-logger >=3.0.0, <4.0.0",
 ]
 description = "gitlab SDK"
 dynamic = ["version"]

{fluidattacks_gitlab_sdk-2.0.1 → fluidattacks_gitlab_sdk-2.2.0}/tests/arch/arch.py

@@ -26,7 +26,7 @@ def _module(path: str) -> FullPathModule | NoReturn:
 
 _dag: Dict[str, tuple[tuple[str, ...] | str, ...]] = {
     "fluidattacks_gitlab_sdk": (
-        ("merge_requests", "members", "issues", "milestones", "mr_approvals"),
+        ("merge_requests", "members", "issues", "milestones", "mr_approvals", "jobs"),
         "users",
         "_handlers",
         ("_http_client", "_gql_client", "_decoders"),
@@ -74,6 +74,7 @@ _dag: Dict[str, tuple[tuple[str, ...] | str, ...]] = {
         "_decode",
         "core",
     ),
+    "fluidattacks_gitlab_sdk.jobs": ("_client", "_decode", "core"),
 }
 
 

fluidattacks_gitlab_sdk-2.2.0/tests/jobs/data.json

@@ -0,0 +1,87 @@
+{
+    "id": 10891419293,
+    "status": "success",
+    "stage": "test",
+    "name": "integrates-back-test",
+    "ref": "developeratfluid",
+    "tag": false,
+    "coverage": null,
+    "allow_failure": false,
+    "created_at": "2025-08-01T23:49:19.0Z",
+    "started_at": "2025-08-01T23:49:22.0Z",
+    "finished_at": "2025-08-02T00:09:05.0Z",
+    "erased_at": null,
+    "duration": 1183.281855,
+    "queued_duration": 3.151458,
+    "user": {
+        "id": 4312487,
+        "username": "slizcanoatfluid",
+        "public_email": "",
+        "name": "Sebastian Lizcano",
+        "state": "active",
+        "locked": false,
+        "avatar_url": "https://secure.gravatar.com/avatar/1c17a07b5fd3f49c7f4a7f8163dd80681e198880aefed63082b409dd9936fcc5?s=80&d=identicon",
+        "web_url": "https://gitlab.com/slizcanoatfluid",
+        "bio": "",
+        "location": "",
+        "linkedin": "",
+        "twitter": "",
+        "discord": "",
+        "website_url": "",
+        "github": "",
+        "job_title": "",
+        "pronouns": "",
+        "organization": "",
+        "bot": false,
+        "work_information": null,
+        "local_time": "1:10 AM"
+    },
+    "commit": {
+        "id":"82717b572300d92cd8dab2d7b9fff6f0090c69f7",
+        "title": "integrates/refac(back) test"
+    },
+    "pipeline": {
+        "id": 1962092437,
+        "iid": 643611,
+        "project_id": 20741933,
+        "sha": "82717b572300d92cd8dab2d7b9fff6f0090c69f8",
+        "ref": "slizcanoatfluid",
+        "status": "failed",
+        "source": "push",
+        "created_at": "2025-08-01T23:04:29.732Z",
+        "updated_at": "2025-08-02T00:24:33.128Z",
+        "web_url": "https://gitlab.com/fluidattacks/universe/-/pipelines/1962092437"
+    },
+    "web_url": "https://gitlab.com/fluidattacks/universe/-/jobs/10891419293",
+    "project": {
+        "ci_job_token_scope_enabled": false
+    },
+    "artifacts": [
+        {
+            "file_type": "trace",
+            "size": 358079,
+            "filename": "job.log",
+            "file_format": null
+        }
+    ],
+    "runner": {
+        "id": 46453645,
+        "description": null,
+        "ip_address": null,
+        "active": true,
+        "paused": false,
+        "is_shared": false,
+        "runner_type": "group_type",
+        "name": null,
+        "online": true,
+        "created_at": "2025-03-13T19:51:43.296Z",
+        "status": "online",
+        "job_execution_status": "active"
+    },
+    "runner_manager": null,
+    "artifacts_expire_at": "2025-08-09T00:08:49.417Z",
+    "archived": false,
+    "tag_list": [
+        "aarch64"
+    ]
+}

fluidattacks_gitlab_sdk-2.2.0/tests/jobs/test_decode_job.py

@@ -0,0 +1,64 @@
+from datetime import UTC, datetime
+from decimal import Decimal
+from pathlib import Path
+
+from fa_purity import Maybe, Unsafe
+from fa_purity.date_time import DatetimeUTC
+from fa_purity.json import JsonValueFactory, Unfolder
+from fluidattacks_etl_utils.natural import NaturalOperations
+
+from fluidattacks_gitlab_sdk.ids import JobId, RunnerId, UserId
+from fluidattacks_gitlab_sdk.jobs._decode import decode_job_obj
+from fluidattacks_gitlab_sdk.jobs.core import (
+    Commit,
+    CommitHash,
+    Job,
+    JobConf,
+    JobDates,
+    JobObj,
+    JobResultStatus,
+)
+
+
+def _assert_utc(date_time: datetime) -> DatetimeUTC:
+    return DatetimeUTC.assert_utc(date_time).alt(Unsafe.raise_exception).to_union()
+
+
+def test_decode() -> None:
+    architectures = ("aarch64",)
+    expected_job = JobObj(
+        JobId(NaturalOperations.absolute(10891419293)),
+        Job(
+            "integrates-back-test",
+            Maybe.some(UserId(NaturalOperations.absolute(4312487))),
+            Maybe.some(RunnerId(NaturalOperations.absolute(46453645))),  # int
+            Maybe.empty(),
+            Commit(
+                Maybe.some(CommitHash("82717b572300d92cd8dab2d7b9fff6f0090c69f7")),
+                Maybe.some("integrates/refac(back) test"),
+            ),
+            JobDates(
+                _assert_utc(datetime(2025, 8, 1, 23, 49, 19, tzinfo=UTC)),
+                Maybe.some(_assert_utc(datetime(2025, 8, 1, 23, 49, 22, tzinfo=UTC))),
+                Maybe.some(_assert_utc(datetime(2025, 8, 2, 0, 9, 5, tzinfo=UTC))),
+            ),
+            JobConf(False, architectures, "developeratfluid", "test"),
+            JobResultStatus(
+                "success",
+                Maybe.empty(),
+                Maybe.some(Decimal(1183.281855)),  # noqa: RUF032
+                Maybe.some(Decimal(3.151458)),  # noqa: RUF032
+            ),
+        ),
+    )
+
+    raw_path = Path(__file__).parent / "data.json"
+    raw_data = (
+        JsonValueFactory.load(raw_path.open(encoding="utf-8"))
+        .bind(Unfolder.to_json)
+        .alt(Unsafe.raise_exception)
+        .to_union()
+    )
+
+    decode_obj = decode_job_obj(raw_data).alt(Unsafe.raise_exception).to_union()
+    assert decode_obj == expected_job

fluidattacks_gitlab_sdk-2.2.0/tests_fx/jobs/client_test.py

@@ -0,0 +1,50 @@
+import pytest
+from fa_purity import Cmd, Coproduct, Result, Unsafe
+from fluidattacks_etl_utils.natural import NaturalOperations
+
+from fluidattacks_gitlab_sdk._handlers import NotFound
+from fluidattacks_gitlab_sdk.ids import JobId
+from fluidattacks_gitlab_sdk.jobs import JobClientFactory
+from fluidattacks_gitlab_sdk.jobs.core import JobObj
+from tests_fx._utils import get_creds_from_env, get_project_from_env
+
+
+def _check_data(result: Result[JobObj, Coproduct[NotFound, Exception]]) -> None:
+    assert result.to_coproduct().map(
+        lambda _: True,
+        lambda c: c.map(
+            lambda _: False,
+            lambda _: False,
+        ),
+    )
+
+
+def _check_not_found(
+    result: Result[JobObj, Coproduct[NotFound, Exception]],
+) -> None:
+    assert result.to_coproduct().map(
+        lambda _: False,
+        lambda c: c.map(
+            lambda _: True,
+            lambda _: False,
+        ),
+    )
+
+
+def test_job() -> None:
+    get_creds = get_creds_from_env().map(lambda r: r.alt(Unsafe.raise_exception).to_union())
+    get_project = get_project_from_env().map(lambda r: r.alt(Unsafe.raise_exception).to_union())
+    action: Cmd[None] = (
+        get_creds.map(JobClientFactory.new)
+        .bind(
+            lambda c: get_project.bind(
+                lambda project: c.get_job(
+                    project,
+                    JobId(NaturalOperations.absolute(12634660510)),
+                ),
+            ),
+        )
+        .map(_check_data)
+    )
+    with pytest.raises(SystemExit):
+        action.compute()