fluidattacks_batch_client 0.1.0__tar.gz

fluidattacks_batch_client-0.1.0/.envrc

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

fluidattacks_batch_client-0.1.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: fluidattacks_batch_client
+Version: 0.1.0
+Summary: AWS batch python client
+Author-email: Engineering Team <development@fluidattacks.com>
+Requires-Python: >=3.11
+Requires-Dist: click >=8.1.8, <9.0.0
+Requires-Dist: boto3 >=1.42.32, <2.0.0
+Requires-Dist: fa_purity >=2.5.0, <3.0.0

fluidattacks_batch_client-0.1.0/build/default.nix

@@ -0,0 +1,13 @@
+{
+  nixpkgs,
+  builders,
+  scripts,
+  src,
+}:
+{
+  inherit src;
+  root_path = "observes/common/batch-client";
+  module_name = "fluidattacks_batch_client";
+  pypi_token_var = "BATCH_CLIENT_TOKEN";
+  override = b: b;
+}

fluidattacks_batch_client-0.1.0/build/filter.nix

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

fluidattacks_batch_client-0.1.0/flake.lock

@@ -0,0 +1,341 @@
+{
+  "nodes": {
+    "flake-parts": {
+      "inputs": {
+        "nixpkgs-lib": "nixpkgs-lib"
+      },
+      "locked": {
+        "lastModified": 1762810396,
+        "narHash": "sha256-dxFVgQPG+R72dkhXTtqUm7KpxElw3u6E+YlQ2WaDgt8=",
+        "owner": "hercules-ci",
+        "repo": "flake-parts",
+        "rev": "0bdadb1b265fb4143a75bd1ec7d8c915898a9923",
+        "type": "github"
+      },
+      "original": {
+        "owner": "hercules-ci",
+        "repo": "flake-parts",
+        "type": "github"
+      }
+    },
+    "nix_filter": {
+      "locked": {
+        "lastModified": 1757882181,
+        "narHash": "sha256-+cCxYIh2UNalTz364p+QYmWHs0P+6wDhiWR4jDIKQIU=",
+        "owner": "numtide",
+        "repo": "nix-filter",
+        "rev": "59c44d1909c72441144b93cf0f054be7fe764de5",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "nix-filter",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "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-lib": {
+      "locked": {
+        "lastModified": 1761765539,
+        "narHash": "sha256-b0yj6kfvO8ApcSE+QmA6mUfu8IYG6/uU28OFn4PaC8M=",
+        "owner": "nix-community",
+        "repo": "nixpkgs.lib",
+        "rev": "719359f4562934ae99f5443f20aa06c2ffff91fc",
+        "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": 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": 1762812764,
+        "narHash": "sha256-MNqrovkO8AEQeYQK7e3X2GDx2H8vfDIxV4K/VEaIjjo=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "400156fe527ab6b54cf6f70cca2c8385548a29c4",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_flake_2": {
+      "locked": {
+        "lastModified": 1761668286,
+        "narHash": "sha256-YN/cm/hbm7pi7lMZCsNhu6jlBUi4wUirrIlyOMpbjKU=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "1fdb9eb10eff581a40ce2e9511c4ed517eac0c3f",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "observes_flake_builder": {
+      "inputs": {
+        "nix_filter": "nix_filter",
+        "nixpkgs_flake": "nixpkgs_flake",
+        "pyproject-build-systems": "pyproject-build-systems",
+        "pyproject-nix": "pyproject-nix_2",
+        "pythonix_flake": "pythonix_flake",
+        "shell-helpers": "shell-helpers",
+        "uv2nix": "uv2nix_2"
+      },
+      "locked": {
+        "dir": "observes/common/std_flake_2",
+        "lastModified": 1768584843,
+        "narHash": "sha256-V0sEDoOEkxvnG6po+3Ve6OAqFA9H9SuvchW8ohY22Xo=",
+        "ref": "refs/heads/trunk",
+        "rev": "3fa54e41d48bd54a59a76f3b0495998663758538",
+        "shallow": true,
+        "type": "git",
+        "url": "ssh://git@gitlab.com/fluidattacks/universe"
+      },
+      "original": {
+        "dir": "observes/common/std_flake_2",
+        "rev": "3fa54e41d48bd54a59a76f3b0495998663758538",
+        "shallow": true,
+        "type": "git",
+        "url": "ssh://git@gitlab.com/fluidattacks/universe"
+      }
+    },
+    "pyproject-build-systems": {
+      "inputs": {
+        "nixpkgs": "nixpkgs",
+        "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_2"
+      },
+      "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"
+      }
+    },
+    "pythonix_flake": {
+      "inputs": {
+        "nixpkgs_flake": "nixpkgs_flake_2"
+      },
+      "locked": {
+        "dir": "observes/common/pythonix_mirror",
+        "lastModified": 1767370831,
+        "narHash": "sha256-VR86TSrJsNHQq31Ksga+1dvsrkv9u1pKa0MKuKYeIAc=",
+        "ref": "refs/heads/trunk",
+        "rev": "0678f8ff3bfe02cfe23bc819bfa739c53bd6e4b6",
+        "shallow": true,
+        "type": "git",
+        "url": "ssh://git@gitlab.com/fluidattacks/universe"
+      },
+      "original": {
+        "dir": "observes/common/pythonix_mirror",
+        "rev": "0678f8ff3bfe02cfe23bc819bfa739c53bd6e4b6",
+        "shallow": true,
+        "type": "git",
+        "url": "ssh://git@gitlab.com/fluidattacks/universe"
+      }
+    },
+    "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": 1762806066,
+        "narHash": "sha256-Wz99Fl7SpPU1NkTHJ36XOo6DjOEAMXCw3ThRABOS2Hs=",
+        "ref": "refs/heads/trunk",
+        "rev": "d73cfdc7ae9e7f547e22a4481d4c2ccce38b26a8",
+        "shallow": true,
+        "type": "git",
+        "url": "ssh://git@gitlab.com/fluidattacks/universe"
+      },
+      "original": {
+        "dir": "common/utils/shell-helpers",
+        "rev": "d73cfdc7ae9e7f547e22a4481d4c2ccce38b26a8",
+        "shallow": true,
+        "type": "git",
+        "url": "ssh://git@gitlab.com/fluidattacks/universe"
+      }
+    },
+    "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_3",
+        "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_batch_client-0.1.0/flake.nix

@@ -0,0 +1,29 @@
+{
+  description = "Utils for sending aws batch jobs";
+
+  inputs = {
+    observes_flake_builder = {
+      url = "git+ssh://git@gitlab.com/fluidattacks/universe?shallow=1&rev=3fa54e41d48bd54a59a76f3b0495998663758538&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_batch_client-0.1.0/fluidattacks_batch_client/__init__.py

@@ -0,0 +1,9 @@
+from ._logger import (
+    setup_logger,
+)
+from fa_purity import (
+    Unsafe,
+)
+
+__version__ = "0.1.0"
+Unsafe.compute(setup_logger(__name__))

fluidattacks_batch_client-0.1.0/fluidattacks_batch_client/_cli.py

@@ -0,0 +1,171 @@
+import dataclasses
+
+from fluidattacks_batch_client.decode import JobDefDecoder
+from fluidattacks_batch_client.sender import new_sender
+from .api import (
+    new_client,
+)
+from .core import (
+    AllowDuplicates,
+    JobPipeline,
+    JobRequest,
+    JobName,
+)
+import click
+from fa_purity import (
+    Bool,
+    Cmd,
+    FrozenList,
+    NewFrozenList,
+    PureIterFactory,
+    PureIterTransform,
+    ResultE,
+    UnitType,
+    Unsafe,
+    unit,
+)
+from fa_purity.json import (
+    JsonObj,
+    JsonValueFactory,
+    UnfoldedFactory,
+    Unfolder,
+)
+from typing import (
+    IO,
+    Callable,
+    NoReturn,
+    TypeVar,
+)
+import logging
+from . import _utils
+
+LOG = logging.getLogger(__name__)
+
+_T = TypeVar("_T")
+
+
+def _read_file(file_path: str, transform: Callable[[IO[str]], _T]) -> Cmd[_T]:
+    def _action() -> _T:
+        with open(file_path, "r", encoding="utf-8") as file:
+            return transform(file)
+
+    return Cmd.wrap_impure(_action)
+
+
+def _decode_json(file_path: str) -> Cmd[ResultE[JsonObj]]:
+    return _read_file(file_path, UnfoldedFactory.load)
+
+
+def _decode_json_list(file_path: str) -> Cmd[ResultE[FrozenList[JsonObj]]]:
+    return _read_file(
+        file_path,
+        lambda file: JsonValueFactory.load(file).bind(
+            lambda v: Unfolder.to_list_of(v, Unfolder.to_json)
+        ),
+    )
+
+
+@click.command()
+@click.option("--job", required=True, help="json encoded str defining a JobRequest")
+@click.option("--allow-duplicates", is_flag=True)
+@click.option("--args-in-name", is_flag=True)
+@click.option("--dry-run", is_flag=True)
+@click.argument("args", nargs=-1)  # additional args to append into the job command
+def submit_job(
+    job: str,
+    allow_duplicates: bool,
+    args_in_name: bool,
+    dry_run: bool,
+    args: FrozenList[str],
+) -> NoReturn:
+    def _execute(job: JobRequest) -> Cmd[None]:
+        name = Bool.from_primitive(len(args) > 0 and args_in_name).map(
+            lambda _: JobName.normalize(job.name.raw + "-" + "-".join(args)),
+            lambda _: job.name,
+        )
+        overriden_job = dataclasses.replace(job, name=name)
+        if dry_run:
+            return Cmd.wrap_impure(
+                lambda: LOG.info(
+                    "[dry-run] the following batch job will be sent: %s", overriden_job
+                )
+            )
+        return (
+            new_client()
+            .map(new_sender)
+            .bind(
+                lambda s: s.send_single_job(
+                    overriden_job, AllowDuplicates(allow_duplicates)
+                ).map(lambda _: None)
+            )
+        )
+
+    _decoder = _utils.get_environment.map(JobDefDecoder)
+    cmd: Cmd[None] = _decoder.bind(
+        lambda decoder: _decode_json(job)
+        .map(lambda r: r.bind(decoder.decode_job))
+        .map(lambda r: r.alt(Unsafe.raise_exception).to_union())
+        .bind(_execute)
+    )
+    cmd.compute()
+
+
+@click.command()
+@click.option(
+    "--pipeline", required=True, help="json encoded str defining a JobRequest"
+)
+@click.option("--dry-run", is_flag=True)
+def submit_pipeline(
+    pipeline: str,
+    dry_run: bool,
+) -> NoReturn:
+    def _execute(job_pipeline: JobPipeline) -> Cmd[UnitType]:
+        if dry_run:
+            msg = Cmd.wrap_impure(
+                lambda: LOG.info(
+                    "[dry-run] A batch pipeline will be sent",
+                )
+            )
+
+            msgs = NewFrozenList(tuple(enumerate(job_pipeline.jobs, start=1))).map(
+                lambda j: Cmd.wrap_impure(
+                    lambda: LOG.info(
+                        "[dry-run] [pipeline-job-#%s] this job will be sent: %s",
+                        j[0],
+                        j[1],
+                    )
+                )
+            )
+            jobs_msgs = (
+                PureIterFactory.from_list(msgs.items)
+                .transform(PureIterTransform.consume)
+                .map(lambda _: unit)
+            )
+            return msg + jobs_msgs
+        return (
+            new_client()
+            .map(new_sender)
+            .bind(
+                lambda s: s.send_pipeline(
+                    PureIterFactory.from_list(job_pipeline.jobs.items)
+                )
+            )
+        )
+
+    _decoder = _utils.get_environment.map(JobDefDecoder)
+    cmd: Cmd[UnitType] = _decoder.bind(
+        lambda decoder: _decode_json_list(pipeline)
+        .map(lambda r: r.map(NewFrozenList).bind(decoder.decode_pipeline))
+        .map(lambda r: r.alt(Unsafe.raise_exception).to_union())
+        .bind(_execute)
+    )
+    cmd.compute()
+
+
+@click.group()
+def main() -> None:
+    pass
+
+
+main.add_command(submit_job)
+main.add_command(submit_pipeline)

fluidattacks_batch_client-0.1.0/fluidattacks_batch_client/_logger.py

@@ -0,0 +1,17 @@
+from fa_purity import (
+    Cmd,
+)
+import logging
+import sys
+
+
+def setup_logger(name: str) -> Cmd[None]:
+    def _action() -> None:
+        handler = logging.StreamHandler(sys.stderr)
+        formatter = logging.Formatter("[%(levelname)s] %(message)s")
+        handler.setFormatter(formatter)
+        log = logging.getLogger(name)
+        log.addHandler(handler)
+        log.setLevel(logging.INFO)
+
+    return Cmd.wrap_impure(_action)