fluidattacks_batch_client 0.2.1__tar.gz → 1.0.0__tar.gz

{fluidattacks_batch_client-0.2.1 → fluidattacks_batch_client-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fluidattacks_batch_client
-Version: 0.2.1
+Version: 1.0.0
 Summary: AWS batch python client
 Author-email: Engineering Team <development@fluidattacks.com>
 Requires-Python: >=3.11

fluidattacks_batch_client-1.0.0/build/default.nix

@@ -0,0 +1,27 @@
+{
+  nixpkgs,
+  builders,
+  scripts,
+  src,
+}:
+let
+  build_bin =
+    bundle:
+    nixpkgs.writeShellApplication {
+      name = "batch-client";
+      runtimeInputs = [
+        bundle.env.runtime
+        nixpkgs.sops
+      ];
+      text = ''
+        batch-client "''${@}"
+      '';
+    };
+in
+{
+  inherit src;
+  root_path = "observes/common/batch-client";
+  module_name = "fluidattacks_batch_client";
+  pypi_token_var = "BATCH_CLIENT_TOKEN";
+  override = bundle: bundle // { bin = build_bin bundle; };
+}

{fluidattacks_batch_client-0.2.1 → fluidattacks_batch_client-1.0.0}/flake.lock

@@ -138,17 +138,17 @@
       },
       "locked": {
         "dir": "observes/common/std_flake_2",
-        "lastModified": 1768584843,
-        "narHash": "sha256-V0sEDoOEkxvnG6po+3Ve6OAqFA9H9SuvchW8ohY22Xo=",
+        "lastModified": 1773763194,
+        "narHash": "sha256-6mO8J5MTvf52xScV92c8Pa8ZR02HHy+ZIWMkvcVsdMo=",
         "ref": "refs/heads/trunk",
-        "rev": "3fa54e41d48bd54a59a76f3b0495998663758538",
+        "rev": "46ca331f2ad5676a210651331e002ecd7c89ef04",
         "shallow": true,
         "type": "git",
         "url": "ssh://git@gitlab.com/fluidattacks/universe"
       },
       "original": {
         "dir": "observes/common/std_flake_2",
-        "rev": "3fa54e41d48bd54a59a76f3b0495998663758538",
+        "rev": "46ca331f2ad5676a210651331e002ecd7c89ef04",
         "shallow": true,
         "type": "git",
         "url": "ssh://git@gitlab.com/fluidattacks/universe"

{fluidattacks_batch_client-0.2.1 → fluidattacks_batch_client-1.0.0}/flake.nix

@@ -3,7 +3,7 @@
 
   inputs = {
     observes_flake_builder = {
-      url = "git+ssh://git@gitlab.com/fluidattacks/universe?shallow=1&rev=3fa54e41d48bd54a59a76f3b0495998663758538&dir=observes/common/std_flake_2";
+      url = "git+ssh://git@gitlab.com/fluidattacks/universe?shallow=1&rev=46ca331f2ad5676a210651331e002ecd7c89ef04&dir=observes/common/std_flake_2";
     };
   };
 

{fluidattacks_batch_client-0.2.1 → fluidattacks_batch_client-1.0.0}/fluidattacks_batch_client/__init__.py

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

{fluidattacks_batch_client-0.2.1 → fluidattacks_batch_client-1.0.0}/fluidattacks_batch_client/_cli.py

@@ -1,16 +1,13 @@
 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 logging
+from collections.abc import Callable
+from pathlib import Path
+from typing import (
+    IO,
+    NoReturn,
+    TypeVar,
 )
+
 import click
 from fa_purity import (
     Bool,
@@ -30,49 +27,60 @@ from fa_purity.json import (
     UnfoldedFactory,
     Unfolder,
 )
-from typing import (
-    IO,
-    Callable,
-    NoReturn,
-    TypeVar,
-)
-import logging
+
+from fluidattacks_batch_client.decode import JobDefDecoder
+from fluidattacks_batch_client.sender import new_sender
+
 from . import _utils
+from .api import (
+    new_client,
+)
+from .core import (
+    AllowDuplicates,
+    JobName,
+    JobPipeline,
+    JobRequest,
+)
 
 LOG = logging.getLogger(__name__)
 
 _T = TypeVar("_T")
 
 
-def _read_file(file_path: str, transform: Callable[[IO[str]], _T]) -> Cmd[_T]:
+def _read_file(file_path: Path, transform: Callable[[IO[str]], _T]) -> Cmd[_T]:
     def _action() -> _T:
-        with open(file_path, "r", encoding="utf-8") as file:
+        with file_path.open("r", encoding="utf-8") as file:
             return transform(file)
 
     return Cmd.wrap_impure(_action)
 
 
-def _decode_json(file_path: str) -> Cmd[ResultE[JsonObj]]:
+def _decode_json(file_path: Path) -> Cmd[ResultE[JsonObj]]:
     return _read_file(file_path, UnfoldedFactory.load)
 
 
-def _decode_json_list(file_path: str) -> Cmd[ResultE[FrozenList[JsonObj]]]:
+def _decode_json_list(file_path: Path) -> 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)
+            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(
+    "--job",
+    required=True,
+    type=click.Path(exists=True, dir_okay=False, path_type=Path),
+    help="json encoded file 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,
+    job: Path,
     allow_duplicates: bool,
     args_in_name: bool,
     dry_run: bool,
@@ -87,16 +95,17 @@ def submit_job(
         if dry_run:
             return Cmd.wrap_impure(
                 lambda: LOG.info(
-                    "[dry-run] the following batch job will be sent: %s", overriden_job
-                )
+                    "[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 r: r.alt(Unsafe.raise_exception).to_union())
+                lambda s: s.send_single_job(overriden_job, AllowDuplicates(allow_duplicates)).map(
+                    lambda r: r.alt(Unsafe.raise_exception).to_union(),
+                ),
             )
             .map(lambda _: None)
         )
@@ -106,18 +115,21 @@ def submit_job(
         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)
+        .bind(_execute),
     )
     cmd.compute()
 
 
 @click.command()
 @click.option(
-    "--pipeline", required=True, help="json encoded str defining a JobRequest"
+    "--pipeline",
+    required=True,
+    type=click.Path(exists=True, dir_okay=False, path_type=Path),
+    help="file encoding a list of JobRequest i.e. list of jsons",
 )
 @click.option("--dry-run", is_flag=True)
 def submit_pipeline(
-    pipeline: str,
+    pipeline: Path,
     dry_run: bool,
 ) -> NoReturn:
     def _execute(job_pipeline: JobPipeline) -> Cmd[UnitType]:
@@ -125,7 +137,7 @@ def submit_pipeline(
             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(
@@ -134,8 +146,8 @@ def submit_pipeline(
                         "[dry-run] [pipeline-job-#%s] this job will be sent: %s",
                         j[0],
                         j[1],
-                    )
-                )
+                    ),
+                ),
             )
             jobs_msgs = (
                 PureIterFactory.from_list(msgs.items)
@@ -147,9 +159,9 @@ def submit_pipeline(
             new_client()
             .map(new_sender)
             .bind(
-                lambda s: s.send_pipeline(
-                    PureIterFactory.from_list(job_pipeline.jobs.items)
-                ).map(lambda r: r.alt(Unsafe.raise_exception).to_union())
+                lambda s: s.send_pipeline(PureIterFactory.from_list(job_pipeline.jobs.items)).map(
+                    lambda r: r.alt(Unsafe.raise_exception).to_union(),
+                ),
             )
         )
 
@@ -158,7 +170,7 @@ def submit_pipeline(
         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)
+        .bind(_execute),
     )
     cmd.compute()
 

{fluidattacks_batch_client-0.2.1 → fluidattacks_batch_client-1.0.0}/fluidattacks_batch_client/_logger.py

@@ -1,8 +1,9 @@
+import logging
+import sys
+
 from fa_purity import (
     Cmd,
 )
-import logging
-import sys
 
 
 def setup_logger(name: str) -> Cmd[None]:

{fluidattacks_batch_client-0.2.1 → fluidattacks_batch_client-1.0.0}/fluidattacks_batch_client/_utils.py

@@ -2,30 +2,32 @@ from __future__ import (
     annotations,
 )
 
-from collections.abc import (
-    Callable,
-)
+import os
 from dataclasses import (
     dataclass,
 )
+from typing import (
+    TYPE_CHECKING,
+    TypeVar,
+)
+
 from fa_purity import (
     Cmd,
+    Coproduct,
+    CoproductFactory,
     FrozenDict,
     FrozenList,
     Maybe,
     PureIter,
     Result,
     ResultE,
-    Coproduct,
-    CoproductFactory,
     Unsafe,
 )
-from typing import (
-    NoReturn,
-    TypeVar,
-)
-import os
 
+if TYPE_CHECKING:
+    from collections.abc import (
+        Callable,
+    )
 _T = TypeVar("_T")
 
 
@@ -34,9 +36,7 @@ class LibraryBug(Exception):
     traceback: Exception
 
     def __str__(self) -> str:
-        return (
-            "If raised then there is a bug in the `fluidattacks_batch_client` library"
-        )
+        return "If raised then there is a bug in the `fluidattacks_batch_client` library"
 
 
 def str_to_int(raw: str) -> ResultE[int]:
@@ -50,21 +50,21 @@ def int_to_str(item: int) -> str:
     return str(item)
 
 
-def handle_value_error(transform: Callable[[], _T | NoReturn]) -> ResultE[_T]:
+def handle_value_error(transform: Callable[[], _T]) -> ResultE[_T]:
     try:
         return Result.success(transform())
     except ValueError as err:
         return Result.failure(Exception(err))
 
 
-def handle_key_error(transform: Callable[[], _T | NoReturn]) -> ResultE[_T]:
+def handle_key_error(transform: Callable[[], _T]) -> ResultE[_T]:
     try:
         return Result.success(transform())
     except KeyError as err:
         return Result.failure(Exception(err))
 
 
-def handle_index_error(transform: Callable[[], _T | NoReturn]) -> ResultE[_T]:
+def handle_index_error(transform: Callable[[], _T]) -> ResultE[_T]:
     try:
         return Result.success(transform())
     except IndexError as err:
@@ -72,18 +72,15 @@ def handle_index_error(transform: Callable[[], _T | NoReturn]) -> ResultE[_T]:
 
 
 def get_index(items: FrozenList[_T], index: int) -> Maybe[_T]:
-    return Maybe.from_result(
-        handle_index_error(lambda: items[index]).alt(lambda _: None)
-    )
+    return Maybe.from_result(handle_index_error(lambda: items[index]).alt(lambda _: None))
 
 
 def extract_single(items: PureIter[_T]) -> Coproduct[_T, PureIter[_T]]:
     _factory: CoproductFactory[_T, PureIter[_T]] = CoproductFactory()
     single_element = (
-        items.enumerate(1)
-        .find_first(lambda t: t[0] >= 2)
-        .map(lambda _: False)
-        .value_or(True)
+        items.enumerate(1).find_first(lambda t: t[0] >= 2).map(lambda _: False).value_or(True)  # noqa: PLR2004
+        # PLR2004 reason: there is no magic value `2` here
+        # the intention is to find the second element of the iterable
     )
     if single_element:
         return _factory.inl(
@@ -92,11 +89,9 @@ def extract_single(items: PureIter[_T]) -> Coproduct[_T, PureIter[_T]]:
             .to_result()
             .alt(lambda _: LibraryBug(Exception("no first element")))
             .alt(Unsafe.raise_exception)
-            .to_union()[1]
+            .to_union()[1],
         )
     return _factory.inr(items)
 
 
-get_environment = Cmd[FrozenDict[str, str]].wrap_impure(
-    lambda: FrozenDict(dict(os.environ))
-)
+get_environment = Cmd[FrozenDict[str, str]].wrap_impure(lambda: FrozenDict(dict(os.environ)))

{fluidattacks_batch_client-0.2.1 → fluidattacks_batch_client-1.0.0}/fluidattacks_batch_client/api/_client_1/__init__.py

@@ -1,29 +1,29 @@
 from __future__ import annotations
-from typing import TYPE_CHECKING
-from . import (
-    _list_jobs,
-    _send_job,
-    _get_command,
-)
-from fluidattacks_batch_client.api._core import (
-    ApiClient,
-)
+
 import boto3
 from fa_purity import (
     Cmd,
 )
+from mypy_boto3_batch.client import (
+    BatchClient,
+)
 
-if TYPE_CHECKING:
-    from mypy_boto3_batch.client import (
-        BatchClient,
-    )
+from fluidattacks_batch_client.api._core import (
+    ApiClient,
+)
+
+from . import (
+    _get_command,
+    _list_jobs,
+    _send_job,
+)
 
 
 def _new_batch_client() -> Cmd[BatchClient]:
     def _action() -> BatchClient:
         return boto3.client("batch")
 
-    return Cmd.wrap_impure(_action)
+    return Cmd[BatchClient].wrap_impure(_action)
 
 
 def new_client() -> Cmd[ApiClient]:
@@ -32,5 +32,5 @@ def new_client() -> Cmd[ApiClient]:
             lambda n, q, s: _list_jobs.list_jobs(client, n, q, s),
             lambda j: _send_job.send_job(client, j),
             lambda j: _get_command.get_command(client, j),
-        )
+        ),
     )

{fluidattacks_batch_client-0.2.1 → fluidattacks_batch_client-1.0.0}/fluidattacks_batch_client/api/_client_1/_get_command.py

@@ -1,22 +1,23 @@
 from __future__ import annotations
+
 from typing import TYPE_CHECKING, TypeVar
 
+from fa_purity import (
+    Cmd,
+    FrozenList,
+    Maybe,
+    ResultE,
+    cast_exception,
+)
 from mypy_boto3_batch.type_defs import (
     ContainerPropertiesOutputTypeDef,
     JobDefinitionTypeDef,
 )
+
 from fluidattacks_batch_client.core import (
     Command,
     JobDefinitionName,
 )
-from fa_purity import (
-    Cmd,
-    FrozenList,
-    Maybe,
-    Result,
-    ResultE,
-    cast_exception,
-)
 
 if TYPE_CHECKING:
     from mypy_boto3_batch.client import (
@@ -27,20 +28,16 @@ _T = TypeVar("_T")
 
 
 def _decode_command(raw: JobDefinitionTypeDef) -> Maybe[Command]:
-    props: Maybe[ContainerPropertiesOutputTypeDef] = Maybe.from_optional(
-        raw.get("containerProperties")
-    )
-    return props.bind_optional(lambda c: c.get("command")).map(
-        lambda c: Command(tuple(c))
-    )
+    props = Maybe[ContainerPropertiesOutputTypeDef].from_optional(raw.get("containerProperties"))
+    return props.bind_optional(lambda c: c.get("command")).map(lambda c: Command(tuple(c)))
 
 
 def _assert_one(items: FrozenList[_T]) -> ResultE[_T]:
     if len(items) == 0:
-        return Result.failure(ValueError("list does not have elements"))
+        return ResultE[_T].failure(ValueError("list does not have elements"))
     if len(items) > 1:
-        return Result.failure(ValueError("list has more than one element"))
-    return Result.success(items[0])
+        return ResultE[_T].failure(ValueError("list has more than one element"))
+    return ResultE[_T].success(items[0])
 
 
 def get_command(
@@ -49,20 +46,19 @@ def get_command(
 ) -> Cmd[ResultE[Maybe[Command]]]:
     def _action() -> ResultE[Maybe[Command]]:
         try:
-            result = client.describe_job_definitions(
-                jobDefinitionName=job_def.raw, status="ACTIVE"
-            )
-        except Exception as e:
-            return Result.failure(e)
+            result = client.describe_job_definitions(jobDefinitionName=job_def.raw, status="ACTIVE")
+        except Exception as e:  # noqa: BLE001
+            # all errors are intended to be returned
+            return ResultE[Maybe[Command]].failure(e)
         return (
             _assert_one(tuple(result["jobDefinitions"]))
             .alt(
                 lambda e: ValueError(
-                    f"Could not determine the current active job definition i.e. {e}"
-                )
+                    f"Could not determine the current active job definition i.e. {e}",
+                ),
             )
             .alt(cast_exception)
             .map(_decode_command)
         )
 
-    return Cmd.wrap_impure(_action)
+    return Cmd[ResultE[Maybe[Command]]].wrap_impure(_action)

{fluidattacks_batch_client-0.2.1 → fluidattacks_batch_client-1.0.0}/fluidattacks_batch_client/api/_client_1/_list_jobs.py

@@ -1,33 +1,36 @@
 from __future__ import annotations
-from typing import TYPE_CHECKING
-from fluidattacks_batch_client import (
-    _utils,
-)
-from fluidattacks_batch_client.core import (
-    BatchJob,
-    BatchJobObj,
-    JobArn,
-    JobId,
-    JobName,
-    JobStatus,
-    QueueName,
-)
+
 from dataclasses import (
     dataclass,
 )
+from typing import TYPE_CHECKING
+
 from fa_purity import (
     Cmd,
     FrozenList,
     Maybe,
+    PureIterFactory,
     ResultE,
+    ResultTransform,
     Stream,
-    PureIterFactory,
     StreamFactory,
     StreamTransform,
-    ResultTransform,
     Unsafe,
 )
 
+from fluidattacks_batch_client import (
+    _utils,
+)
+from fluidattacks_batch_client.core import (
+    BatchJob,
+    BatchJobObj,
+    JobArn,
+    JobId,
+    JobName,
+    JobStatus,
+    QueueName,
+)
+
 if TYPE_CHECKING:
     from mypy_boto3_batch.client import (
         BatchClient,
@@ -48,7 +51,7 @@ def _decode_job(raw: JobSummaryTypeDef) -> ResultE[BatchJob]:
                 Maybe.from_optional(raw.get("statusReason")),
                 Maybe.from_optional(raw.get("startedAt")),
                 Maybe.from_optional(raw.get("stoppedAt")),
-            )
+            ),
         )
 
     return _utils.handle_key_error(_inner).bind(lambda x: x)
@@ -62,7 +65,7 @@ def _decode_job_obj(
         _id = JobId(raw["jobId"])
         _name = JobName.new(raw["jobName"])
         return _name.bind(
-            lambda name: _decode_job(raw).map(lambda j: BatchJobObj(_id, _arn, name, j))
+            lambda name: _decode_job(raw).map(lambda j: BatchJobObj(_id, _arn, name, j)),
         )
 
     return _utils.handle_key_error(_inner).bind(lambda x: x)
@@ -76,9 +79,7 @@ class JobsPage:
 
 def _decode_respose(response: ListJobsResponseTypeDef) -> ResultE[JobsPage]:
     def _inner() -> ResultE[JobsPage]:
-        items = PureIterFactory.from_list(response["jobSummaryList"]).map(
-            _decode_job_obj
-        )
+        items = PureIterFactory.from_list(response["jobSummaryList"]).map(_decode_job_obj)
         _next = Maybe.from_optional(response.get("nextToken"))
         return ResultTransform.all_ok(items.to_list()).map(lambda i: JobsPage(i, _next))
 
@@ -92,11 +93,9 @@ def _list_jobs_page(
     _next: Maybe[str],
 ) -> Cmd[JobsPage]:
     def _action() -> JobsPage:
-        _filter: FrozenList[KeyValuesPairTypeDef] = (
-            {"name": "JOB_NAME", "values": [name.raw]},
-        )
+        _filter: FrozenList[KeyValuesPairTypeDef] = ({"name": "JOB_NAME", "values": [name.raw]},)
         result = _next.map(
-            lambda n: client.list_jobs(jobQueue=queue.raw, filters=_filter, nextToken=n)
+            lambda n: client.list_jobs(jobQueue=queue.raw, filters=_filter, nextToken=n),
         ).or_else_call(lambda: client.list_jobs(jobQueue=queue.raw, filters=_filter))
         return _decode_respose(result).alt(Unsafe.raise_exception).to_union()