fluidattacks_gitlab_sdk 1.0.0__tar.gz

fluidattacks_gitlab_sdk-1.0.0/.envrc

@@ -0,0 +1,2 @@
+ln -f ../../common/mypy.ini ./mypy.ini
+use_flake ".#python311.devShell"

fluidattacks_gitlab_sdk-1.0.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: fluidattacks_gitlab_sdk
+Version: 1.0.0
+Summary: gitlab SDK
+Author-email: Product Team <development@fluidattacks.com>
+Requires-Python: >=3.11
+Requires-Dist: gql >=3.5.0, <4.0.0
+Requires-Dist: requests-toolbelt >=1.0.0, <2.0.0
+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 >=1.0.0, <2.0.0
+Requires-Dist: fluidattacks-utils-logger >=1.0.0, <2.0.0

fluidattacks_gitlab_sdk-1.0.0/build/default.nix

@@ -0,0 +1,7 @@
+{ nixpkgs, builders, scripts, src, }: {
+  inherit src;
+  root_path = "observes/sdk/gitlab";
+  module_name = "fluidattacks_gitlab_sdk";
+  pypi_token_var = "GITLAB_SDK_TOKEN";
+  override = b: b;
+}

fluidattacks_gitlab_sdk-1.0.0/build/filter.nix

@@ -0,0 +1,12 @@
+path_filter: src:
+path_filter {
+  root = src;
+  include = [
+    "fluidattacks_gitlab_sdk"
+    "tests"
+    "pyproject.toml"
+    "mypy.ini"
+    "ruff.toml"
+    "uv.lock"
+  ];
+}

fluidattacks_gitlab_sdk-1.0.0/flake.lock

@@ -0,0 +1,351 @@
+{
+  "nodes": {
+    "flake-parts": {
+      "inputs": {
+        "nixpkgs-lib": "nixpkgs-lib"
+      },
+      "locked": {
+        "lastModified": 1754487366,
+        "narHash": "sha256-pHYj8gUBapuUzKV/kN/tR3Zvqc7o6gdFB9XKXIp1SQ8=",
+        "owner": "hercules-ci",
+        "repo": "flake-parts",
+        "rev": "af66ad14b28a127c5c0f3bbb298218fc63528a18",
+        "type": "github"
+      },
+      "original": {
+        "owner": "hercules-ci",
+        "repo": "flake-parts",
+        "type": "github"
+      }
+    },
+    "nix_filter": {
+      "locked": {
+        "lastModified": 1731533336,
+        "narHash": "sha256-oRam5PS1vcrr5UPgALW0eo1m/5/pls27Z/pabHNy2Ms=",
+        "owner": "numtide",
+        "repo": "nix-filter",
+        "rev": "f7653272fd234696ae94229839a99b73c9ab7de0",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "nix-filter",
+        "type": "github"
+      }
+    },
+    "nix_filter_2": {
+      "locked": {
+        "lastModified": 1731533336,
+        "narHash": "sha256-oRam5PS1vcrr5UPgALW0eo1m/5/pls27Z/pabHNy2Ms=",
+        "owner": "numtide",
+        "repo": "nix-filter",
+        "rev": "f7653272fd234696ae94229839a99b73c9ab7de0",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "nix-filter",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1736441877,
+        "narHash": "sha256-m3+PhBFkDwqo9lBplG4AyMW8P4/KcioJRS1UG8N7okM=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "ce3899414dab3297cf025bfa356dc2da426feefd",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs-lib": {
+      "locked": {
+        "lastModified": 1753579242,
+        "narHash": "sha256-zvaMGVn14/Zz8hnp4VWT9xVnhc8vuL3TStRqwk22biA=",
+        "owner": "nix-community",
+        "repo": "nixpkgs.lib",
+        "rev": "0f36c44e01a6129be94e3ade315a5883f0228a6e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-community",
+        "repo": "nixpkgs.lib",
+        "type": "github"
+      }
+    },
+    "nixpkgs_2": {
+      "locked": {
+        "lastModified": 1758690382,
+        "narHash": "sha256-NY3kSorgqE5LMm1LqNwGne3ZLMF2/ILgLpFr1fS4X3o=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "e643668fd71b949c53f8626614b21ff71a07379d",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_3": {
+      "locked": {
+        "lastModified": 1758690382,
+        "narHash": "sha256-NY3kSorgqE5LMm1LqNwGne3ZLMF2/ILgLpFr1fS4X3o=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "e643668fd71b949c53f8626614b21ff71a07379d",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_4": {
+      "locked": {
+        "lastModified": 1761373498,
+        "narHash": "sha256-Q/uhWNvd7V7k1H1ZPMy/vkx3F8C13ZcdrKjO7Jv7v0c=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "6a08e6bb4e46ff7fcbb53d409b253f6bad8a28ce",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_flake": {
+      "locked": {
+        "lastModified": 1756313514,
+        "narHash": "sha256-3Xbak0pXR8ziNv1ghHyJ5a5Ti2kt/LWq6hKZVJTvjBs=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "181464235b2daff8725773fef43ffc9d6b02e1c2",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "observes_flake_builder": {
+      "inputs": {
+        "nix_filter": "nix_filter",
+        "nixpkgs_flake": "nixpkgs_flake",
+        "pynix_flake": "pynix_flake",
+        "pyproject-build-systems": "pyproject-build-systems",
+        "pyproject-nix": "pyproject-nix_2",
+        "shell-helpers": "shell-helpers",
+        "uv2nix": "uv2nix_2"
+      },
+      "locked": {
+        "dir": "observes/common/std_flake_2",
+        "lastModified": 1761684858,
+        "narHash": "sha256-gybMRO/MSOPXQjI//u2UKfvs8pD0sACqL2Kjp+xR4rI=",
+        "owner": "fluidattacks",
+        "repo": "universe",
+        "rev": "c5053864bb838edbe226d74a650d901c0270843b",
+        "type": "github"
+      },
+      "original": {
+        "dir": "observes/common/std_flake_2",
+        "owner": "fluidattacks",
+        "repo": "universe",
+        "rev": "c5053864bb838edbe226d74a650d901c0270843b",
+        "type": "github"
+      }
+    },
+    "pynix_flake": {
+      "inputs": {
+        "nix_filter": "nix_filter_2",
+        "nixpkgs": "nixpkgs"
+      },
+      "locked": {
+        "lastModified": 1758642502,
+        "narHash": "sha256-PD/bQMz2dqZSkydHyvRh+jS/0qoV8SdcIVs6sassteQ=",
+        "owner": "dmurciaatfluid",
+        "repo": "python_nix_builder",
+        "rev": "809aafe2e1995e72c15378d099bf251b78f04a20",
+        "type": "gitlab"
+      },
+      "original": {
+        "owner": "dmurciaatfluid",
+        "repo": "python_nix_builder",
+        "type": "gitlab"
+      }
+    },
+    "pyproject-build-systems": {
+      "inputs": {
+        "nixpkgs": "nixpkgs_2",
+        "pyproject-nix": "pyproject-nix",
+        "uv2nix": "uv2nix"
+      },
+      "locked": {
+        "lastModified": 1761781027,
+        "narHash": "sha256-YDvxPAm2WnxrznRqWwHLjryBGG5Ey1ATEJXrON+TWt8=",
+        "owner": "pyproject-nix",
+        "repo": "build-system-pkgs",
+        "rev": "795a980d25301e5133eca37adae37283ec3c8e66",
+        "type": "github"
+      },
+      "original": {
+        "owner": "pyproject-nix",
+        "repo": "build-system-pkgs",
+        "type": "github"
+      }
+    },
+    "pyproject-nix": {
+      "inputs": {
+        "nixpkgs": [
+          "observes_flake_builder",
+          "pyproject-build-systems",
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1758265079,
+        "narHash": "sha256-amLaLNwKSZPShQHzfgmc/9o76dU8xzN0743dWgvYlr8=",
+        "owner": "nix-community",
+        "repo": "pyproject.nix",
+        "rev": "02e9418fd4af638447dca4b17b1280da95527fc9",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-community",
+        "repo": "pyproject.nix",
+        "type": "github"
+      }
+    },
+    "pyproject-nix_2": {
+      "inputs": {
+        "nixpkgs": "nixpkgs_3"
+      },
+      "locked": {
+        "lastModified": 1762427963,
+        "narHash": "sha256-CkPlAbIQ87wmjy5qHibfzk4DmMGBNqFer+lLfXjpP5M=",
+        "owner": "pyproject-nix",
+        "repo": "pyproject.nix",
+        "rev": "4540ea004e04fcd12dd2738d51383d10f956f7b9",
+        "type": "github"
+      },
+      "original": {
+        "owner": "pyproject-nix",
+        "repo": "pyproject.nix",
+        "type": "github"
+      }
+    },
+    "pyproject-nix_3": {
+      "inputs": {
+        "nixpkgs": [
+          "observes_flake_builder",
+          "uv2nix",
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1760402624,
+        "narHash": "sha256-jF6UKLs2uGc2rtved8Vrt58oTWjTQoAssuYs/0578Z4=",
+        "owner": "pyproject-nix",
+        "repo": "pyproject.nix",
+        "rev": "84c4ea102127c77058ea1ed7be7300261fafc7d2",
+        "type": "github"
+      },
+      "original": {
+        "owner": "pyproject-nix",
+        "repo": "pyproject.nix",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "observes_flake_builder": "observes_flake_builder"
+      }
+    },
+    "shell-helpers": {
+      "inputs": {
+        "flake-parts": "flake-parts",
+        "nixpkgs": [
+          "observes_flake_builder",
+          "nixpkgs_flake"
+        ]
+      },
+      "locked": {
+        "dir": "common/utils/shell-helpers",
+        "lastModified": 1752896460,
+        "narHash": "sha256-AsyTatXMx839cGsF6knwTrDZHk3Eue2QD3eSP7bkmpg=",
+        "owner": "fluidattacks",
+        "repo": "universe",
+        "rev": "27749d2c3a2b018eb010a322e5e1352f993c9e86",
+        "type": "github"
+      },
+      "original": {
+        "dir": "common/utils/shell-helpers",
+        "owner": "fluidattacks",
+        "repo": "universe",
+        "rev": "27749d2c3a2b018eb010a322e5e1352f993c9e86",
+        "type": "github"
+      }
+    },
+    "uv2nix": {
+      "inputs": {
+        "nixpkgs": [
+          "observes_flake_builder",
+          "pyproject-build-systems",
+          "nixpkgs"
+        ],
+        "pyproject-nix": [
+          "observes_flake_builder",
+          "pyproject-build-systems",
+          "pyproject-nix"
+        ]
+      },
+      "locked": {
+        "lastModified": 1758933732,
+        "narHash": "sha256-HAmm1GBS1myZCFuog0DC2ZLaynvZtiUI2Crmo+cdQI0=",
+        "owner": "pyproject-nix",
+        "repo": "uv2nix",
+        "rev": "273ce18f913d8559e0d04f820d724308966d7c4d",
+        "type": "github"
+      },
+      "original": {
+        "owner": "pyproject-nix",
+        "repo": "uv2nix",
+        "type": "github"
+      }
+    },
+    "uv2nix_2": {
+      "inputs": {
+        "nixpkgs": "nixpkgs_4",
+        "pyproject-nix": "pyproject-nix_3"
+      },
+      "locked": {
+        "lastModified": 1761872265,
+        "narHash": "sha256-i25GRgp2vUOebY70L3NTAgkd+Pr1hnn5xM3qHxH0ONU=",
+        "owner": "pyproject-nix",
+        "repo": "uv2nix",
+        "rev": "74dfb62871be152ad3673b143b0cc56105a4f3c5",
+        "type": "github"
+      },
+      "original": {
+        "owner": "pyproject-nix",
+        "repo": "uv2nix",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

fluidattacks_gitlab_sdk-1.0.0/flake.nix

@@ -0,0 +1,19 @@
+{
+  description = "Singer target for fluidattacks warehouse";
+
+  inputs = {
+    observes_flake_builder = {
+      url =
+        "github:fluidattacks/universe/c5053864bb838edbe226d74a650d901c0270843b?shallow=1&dir=observes/common/std_flake_2";
+    };
+  };
+
+  outputs = { self, ... }@inputs:
+    let
+      build_args = { system, python_version, nixpkgs, builders, scripts }:
+        import ./build {
+          inherit nixpkgs builders scripts;
+          src = import ./build/filter.nix nixpkgs.nix-filter self;
+        };
+    in { packages = inputs.observes_flake_builder.outputs.build build_args; };
+}

fluidattacks_gitlab_sdk-1.0.0/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-1.0.0/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-1.0.0/fluidattacks_gitlab_sdk/_gql_client/__init__.py

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