fluidattacks_batch_client 0.1.0__py3-none-any.whl

fluidattacks_batch_client/api/_client_1/_send_job.py

@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+from mypy_boto3_batch.type_defs import (
+    ContainerOverridesTypeDef,
+    SubmitJobRequestTypeDef,
+)
+
+from fluidattacks_batch_client import (
+    _utils,
+)
+from fluidattacks_batch_client.core import (
+    ContainerOverride,
+    DependentJobRequest,
+    EnvVars,
+    JobArn,
+    JobDefOverride,
+    JobDependencies,
+    JobId,
+    ResourceRequirement,
+)
+from fa_purity import (
+    Cmd,
+    NewFrozenList,
+    PureIterFactory,
+)
+import logging
+
+from typing import (
+    TYPE_CHECKING,
+    List,
+    Tuple,
+)
+
+if TYPE_CHECKING:
+    from mypy_boto3_batch.client import (
+        BatchClient,
+    )
+    from mypy_boto3_batch.type_defs import (
+        JobDependencyTypeDef,
+        KeyValuePairTypeDef,
+        ResourceRequirementTypeDef,
+        SubmitJobResponseTypeDef,
+    )
+LOG = logging.getLogger(__name__)
+
+
+def _encode_req(req: ResourceRequirement) -> ResourceRequirementTypeDef:
+    return {
+        "type": req.resource.value,
+        "value": _utils.int_to_str(req.value.to_int),
+    }
+
+
+def _to_pair(key: str, val: str) -> KeyValuePairTypeDef:
+    return {
+        "name": key,
+        "value": val,
+    }
+
+
+def _encode_env_vars(environment: EnvVars) -> NewFrozenList[KeyValuePairTypeDef]:
+    return NewFrozenList(tuple(environment.items.items())).map(lambda t: _to_pair(*t))
+
+
+def _decode_respose(
+    response: SubmitJobResponseTypeDef,
+) -> Tuple[JobId, JobArn]:
+    return (JobId(response["jobId"]), JobArn(response["jobArn"]))
+
+
+def _encode_deps(deps: JobDependencies) -> List[JobDependencyTypeDef]:
+    def _transform(_id: JobId) -> JobDependencyTypeDef:
+        return {"jobId": _id.raw}
+
+    result = PureIterFactory.from_list(tuple(deps.items)).map(_transform).to_list()
+    return list(result)
+
+
+def _apply_container_overrides(
+    override: ContainerOverride,
+) -> ContainerOverridesTypeDef:
+    def _merge(
+        base: ContainerOverridesTypeDef, override: ContainerOverridesTypeDef
+    ) -> ContainerOverridesTypeDef:
+        return ContainerOverridesTypeDef({**base, **override})
+
+    empty: ContainerOverridesTypeDef = {}
+    command_override: ContainerOverridesTypeDef = override.command.map(
+        lambda c: ContainerOverridesTypeDef({"command": c.raw})
+    ).value_or(empty)
+    environment_override: ContainerOverridesTypeDef = override.environment.map(
+        lambda e: ContainerOverridesTypeDef({"environment": _encode_env_vars(e).items})
+    ).value_or(empty)
+    resources_override: ContainerOverridesTypeDef = override.resources.map(
+        lambda r: ContainerOverridesTypeDef(
+            {"resourceRequirements": r.map(_encode_req).items}
+        )
+    ).value_or(empty)
+    overrides = NewFrozenList[ContainerOverridesTypeDef].new(
+        command_override,
+        environment_override,
+        resources_override,
+    )
+    return PureIterFactory.from_list(
+        overrides.items,
+    ).reduce(lambda b, c: _merge(b, c), empty)
+
+
+def _apply_overrides(
+    base: SubmitJobRequestTypeDef, override: JobDefOverride
+) -> SubmitJobRequestTypeDef:
+    def _merge(
+        base: SubmitJobRequestTypeDef, override: SubmitJobRequestTypeDef
+    ) -> SubmitJobRequestTypeDef:
+        return SubmitJobRequestTypeDef({**base, **override})
+
+    container_override: SubmitJobRequestTypeDef = override.container.map(
+        lambda c: SubmitJobRequestTypeDef(
+            {**base, "containerOverrides": _apply_container_overrides(c)}
+        )
+    ).value_or(base)
+    timeout_override: SubmitJobRequestTypeDef = override.timeout.map(
+        lambda t: SubmitJobRequestTypeDef(
+            {
+                **base,
+                "timeout": {"attemptDurationSeconds": t.seconds.to_int},
+            }
+        )
+    ).value_or(base)
+    attempts_override: SubmitJobRequestTypeDef = override.retries.map(
+        lambda r: SubmitJobRequestTypeDef(
+            {
+                **base,
+                "retryStrategy": {"attempts": r.maximum.to_int},
+            }
+        )
+    ).value_or(base)
+    tags_override: SubmitJobRequestTypeDef = override.tags.map(
+        lambda t: SubmitJobRequestTypeDef(
+            {
+                **base,
+                "tags": dict(t.items),
+            }
+        )
+    ).value_or(base)
+    propagate_override: SubmitJobRequestTypeDef = override.propagate_tags.map(
+        lambda p: SubmitJobRequestTypeDef(
+            {
+                **base,
+                "propagateTags": p,
+            }
+        )
+    ).value_or(base)
+    overrides = NewFrozenList[SubmitJobRequestTypeDef].new(
+        container_override,
+        timeout_override,
+        attempts_override,
+        tags_override,
+        propagate_override,
+    )
+    return PureIterFactory.from_list(
+        overrides.items,
+    ).reduce(lambda b, c: _merge(b, c), base)
+
+
+def send_job(
+    client: BatchClient, job_request: DependentJobRequest
+) -> Cmd[Tuple[JobId, JobArn]]:
+    job = job_request.job
+
+    def _action() -> Tuple[JobId, JobArn]:
+        LOG.info("Submiting job: %s", job.name.raw)
+        args: SubmitJobRequestTypeDef = {
+            "arrayProperties": {"size": job.parallel.size.to_int}
+            if job.parallel.size.to_int > 1
+            else {},
+            "jobDefinition": job.job_def.raw,
+            "jobName": job.name.raw,
+            "jobQueue": job.queue.raw,
+            "dependsOn": job_request.dependencies.map(_encode_deps).value_or([]),
+        }
+        response = client.submit_job(
+            **job.override.map(lambda o: _apply_overrides(args, o)).value_or(args)
+        )
+        result = _decode_respose(response)
+        LOG.info("Job sent! id=%s arn=%s", result[0].raw, result[1].raw)
+        return result
+
+    return Cmd.wrap_impure(_action)

fluidattacks_batch_client/api/_core.py

@@ -0,0 +1,33 @@
+from fluidattacks_batch_client.core import (
+    BatchJobObj,
+    Command,
+    DependentJobRequest,
+    JobArn,
+    JobDefinitionName,
+    JobId,
+    JobName,
+    JobStatus,
+    QueueName,
+)
+from collections.abc import (
+    Callable,
+)
+from dataclasses import (
+    dataclass,
+)
+from fa_purity import (
+    Cmd,
+    Maybe,
+    ResultE,
+    Stream,
+)
+from typing import (
+    Tuple,
+)
+
+
+@dataclass(frozen=True)
+class ApiClient:
+    list_jobs: Callable[[JobName, QueueName, frozenset[JobStatus]], Stream[BatchJobObj]]
+    send_job: Callable[[DependentJobRequest], Cmd[Tuple[JobId, JobArn]]]
+    get_job_def_command: Callable[[JobDefinitionName], Cmd[ResultE[Maybe[Command]]]]

fluidattacks_batch_client/core.py

@@ -0,0 +1,310 @@
+from __future__ import (
+    annotations,
+)
+
+from fluidattacks_batch_client import (
+    _utils,
+)
+from dataclasses import (
+    dataclass,
+    field,
+)
+from enum import (
+    Enum,
+)
+from fa_purity import (
+    Cmd,
+    FrozenDict,
+    FrozenList,
+    Maybe,
+    NewFrozenList,
+    Result,
+    ResultE,
+    PureIterFactory,
+    PureIterTransform,
+    Unsafe,
+)
+import os
+from typing import (
+    FrozenSet,
+)
+
+from fluidattacks_batch_client._utils import LibraryBug
+
+
+@dataclass(frozen=True)
+class Natural:
+    @dataclass(frozen=True)
+    class _Private:
+        pass
+
+    _private: Natural._Private = field(repr=False, hash=False, compare=False)
+    to_int: int
+
+    @staticmethod
+    def assert_natural(raw: int) -> ResultE[Natural]:
+        if raw >= 0:
+            return Result.success(Natural(Natural._Private(), raw))
+        err = ValueError("The supplied integer is not a natural number")
+        return Result.failure(Exception(err))
+
+    @classmethod
+    def abs(cls, raw: int) -> Natural:
+        return (
+            cls.assert_natural(abs(raw))
+            .alt(LibraryBug)
+            .alt(Unsafe.raise_exception)
+            .to_union()
+        )
+
+
+@dataclass(frozen=True)
+class QueueName:
+    raw: str
+
+
+@dataclass(frozen=True)
+class Attempts:
+    @dataclass(frozen=True)
+    class _Private:
+        pass
+
+    _private: Attempts._Private = field(repr=False, hash=False, compare=False)
+    maximum: Natural
+
+    @staticmethod
+    def new(raw: Natural) -> ResultE[Attempts]:
+        if raw.to_int <= 10:
+            return Result.success(Attempts(Attempts._Private(), raw))
+        err = ValueError("Attempts must be a Natural <= 10")
+        return Result.failure(Exception(err))
+
+
+@dataclass(frozen=True)
+class Timeout:
+    @dataclass(frozen=True)
+    class _Private:
+        pass
+
+    _private: Timeout._Private = field(repr=False, hash=False, compare=False)
+    seconds: Natural
+
+    @staticmethod
+    def new(raw: Natural) -> ResultE[Timeout]:
+        if raw.to_int >= 60:
+            return Result.success(Timeout(Timeout._Private(), raw))
+        err = ValueError("Timeout must be a Natural >= 60")
+        return Result.failure(Exception(err))
+
+
+@dataclass(frozen=True)
+class Command:
+    raw: FrozenList[str]
+
+
+@dataclass(frozen=True)
+class JobDefinitionName:
+    raw: str
+
+
+@dataclass(frozen=True)
+class EnvVarPointer:
+    name: str
+
+    def get_value(self) -> Cmd[Maybe[str]]:
+        return Cmd.wrap_impure(lambda: Maybe.from_optional(os.environ.get(self.name)))
+
+
+class ResourceType(Enum):
+    VCPU = "VCPU"
+    MEMORY = "MEMORY"
+
+    @staticmethod
+    def to_req_type(raw: str) -> ResultE[ResourceType]:
+        return _utils.handle_value_error(lambda: ResourceType(raw.upper()))
+
+
+@dataclass(frozen=True)
+class ResourceRequirement:
+    resource: ResourceType
+    value: Natural
+
+
+@dataclass(frozen=True)
+class Tags:
+    items: FrozenDict[str, str]
+
+
+@dataclass(frozen=True)
+class EnvVar:
+    name: str
+    value: str
+
+
+@dataclass(frozen=True)
+class EnvVars:
+    items: FrozenDict[str, str]
+
+
+@dataclass(frozen=True)
+class JobSize:
+    @dataclass(frozen=True)
+    class _Private:
+        pass
+
+    _private: JobSize._Private = field(repr=False, hash=False, compare=False)
+    size: Natural
+
+    @staticmethod
+    def new(raw: Natural) -> ResultE[JobSize]:
+        if raw.to_int >= 1 and raw.to_int <= 10000:
+            return Result.success(JobSize(JobSize._Private(), raw))
+        err = ValueError("JobSize must be a Natural between 1 and 10000")
+        return Result.failure(Exception(err))
+
+
+class JobStatus(Enum):
+    SUBMITTED = "SUBMITTED"
+    PENDING = "PENDING"
+    RUNNABLE = "RUNNABLE"
+    STARTING = "STARTING"
+    RUNNING = "RUNNING"
+    SUCCEEDED = "SUCCEEDED"
+    FAILED = "FAILED"
+
+    @staticmethod
+    def to_status(raw: str) -> ResultE[JobStatus]:
+        return _utils.handle_value_error(lambda: JobStatus(raw.upper()))
+
+
+@dataclass(frozen=True)
+class JobName:
+    @dataclass(frozen=True)
+    class _Private:
+        pass
+
+    _private: JobName._Private = field(repr=False, hash=False, compare=False)
+    raw: str
+
+    @staticmethod
+    def new(raw: str) -> ResultE[JobName]:
+        def _check(index: int, char: str) -> bool:
+            if index == 1:
+                return char.isalnum()
+            return char.isalnum() or char in ["_", "-"]
+
+        validation = (
+            PureIterFactory.from_list(tuple(raw)).enumerate(1).map(lambda t: _check(*t))
+        )
+        if len(raw) <= 128 and all(validation):
+            return Result.success(JobName(JobName._Private(), raw))
+        err = ValueError("JobName does not fulfill naming rules")
+        return Result.failure(Exception(err))
+
+    @staticmethod
+    def normalize(raw: str) -> JobName:
+        def _normalize(index: int, char: str) -> str:
+            if index == 1 and not char.isalnum():
+                return "X"
+            if char.isalnum() or char in ["_"]:
+                return char
+            else:
+                return "-"
+
+        text = (
+            PureIterFactory.from_list(tuple(raw))
+            .enumerate(1)
+            .map(lambda t: (t[0], _normalize(*t)))
+        )
+        truncated = PureIterTransform.until_none(
+            text.map(lambda t: t[1] if t[0] <= 128 else None)
+        )
+        return JobName(JobName._Private(), "".join(truncated))
+
+
+@dataclass(frozen=True)
+class JobId:
+    raw: str
+
+
+@dataclass(frozen=True)
+class JobArn:
+    raw: str
+
+
+@dataclass(frozen=True)
+class JobDependencies:
+    @dataclass(frozen=True)
+    class _Private:
+        pass
+
+    _private: JobDependencies._Private = field(repr=False, hash=False, compare=False)
+    items: FrozenSet[JobId]
+
+    @staticmethod
+    def new(items: FrozenSet[JobId]) -> ResultE[JobDependencies]:
+        if len(items) >= 1 and len(items) <= 20:
+            return Result.success(JobDependencies(JobDependencies._Private(), items))
+        err = ValueError("The maximun number of dependencies for a job is 20")
+        return Result.failure(Exception(err))
+
+
+@dataclass(frozen=True)
+class BatchJob:
+    created_at: int
+    status: JobStatus
+    status_reason: Maybe[str]
+    started_at: Maybe[int]
+    stoped_at: Maybe[int]
+
+
+@dataclass(frozen=True)
+class BatchJobObj:
+    job_id: JobId
+    arn: JobArn
+    name: JobName
+    job: BatchJob
+
+
+@dataclass(frozen=True)
+class ContainerOverride:
+    command: Maybe[Command]
+    environment: Maybe[EnvVars]
+    resources: Maybe[NewFrozenList[ResourceRequirement]]
+
+
+@dataclass(frozen=True)
+class JobDefOverride:
+    retries: Maybe[Attempts]
+    timeout: Maybe[Timeout]
+    container: Maybe[ContainerOverride]
+    tags: Maybe[Tags]
+    propagate_tags: Maybe[bool]
+
+
+@dataclass(frozen=True)
+class JobRequest:
+    name: JobName
+    job_def: JobDefinitionName
+    queue: QueueName
+    parallel: JobSize
+    override: Maybe[JobDefOverride]
+
+
+@dataclass(frozen=True)
+class DependentJobRequest:
+    job: JobRequest
+    dependencies: Maybe[JobDependencies]
+
+
+@dataclass(frozen=True)
+class AllowDuplicates:
+    value: bool
+
+
+@dataclass(frozen=True)
+class JobPipeline:
+    jobs: NewFrozenList[JobRequest]
+
+    def __repr__(self) -> str:
+        return f"JobPipeline(drafts={self.jobs.items})"

fluidattacks_batch_client/decode.py

@@ -0,0 +1,175 @@
+from __future__ import (
+    annotations,
+)
+from dataclasses import dataclass
+
+from fluidattacks_batch_client.core import (
+    Attempts,
+    Command,
+    ContainerOverride,
+    EnvVar,
+    EnvVars,
+    JobDefOverride,
+    JobDefinitionName,
+    JobRequest,
+    JobName,
+    JobPipeline,
+    JobSize,
+    QueueName,
+    Natural,
+    ResourceRequirement,
+    ResourceType,
+    Tags,
+    Timeout,
+)
+from fa_purity import (
+    FrozenDict,
+    NewFrozenList,
+    Result,
+    ResultE,
+    ResultSmash,
+    ResultTransform,
+)
+from fa_purity.json import (
+    JsonObj,
+    JsonPrimitiveUnfolder,
+    JsonUnfolder,
+    JsonValue,
+    Unfolder,
+)
+
+
+def _to_str(raw: JsonValue) -> ResultE[str]:
+    return Unfolder.to_primitive(raw).bind(JsonPrimitiveUnfolder.to_str)
+
+
+def _to_int(raw: JsonValue) -> ResultE[int]:
+    return Unfolder.to_primitive(raw).bind(JsonPrimitiveUnfolder.to_int)
+
+
+def _to_bool(raw: JsonValue) -> ResultE[bool]:
+    return Unfolder.to_primitive(raw).bind(JsonPrimitiveUnfolder.to_bool)
+
+
+@dataclass(frozen=True)
+class JobDefDecoder:
+    external_env_vars: FrozenDict[str, str]
+
+    def _get_env_var(self, name: str) -> ResultE[str]:
+        try:
+            return Result.success(self.external_env_vars[name])
+        except KeyError:
+            return Result.failure(
+                KeyError(f"Environment variable `{name}` is not present")
+            )
+
+    def _decode_env_var(self, raw: JsonObj) -> ResultE[EnvVar]:
+        _name = JsonUnfolder.require(raw, "name", _to_str)
+
+        def _get_value(name: str) -> ResultE[str]:
+            return JsonUnfolder.optional(raw, "value", _to_str).bind(
+                lambda m: m.to_coproduct().map(
+                    lambda s: Result.success(s),
+                    lambda _: self._get_env_var(name),
+                )
+            )
+
+        return _name.bind(
+            lambda name: _get_value(name).map(lambda value: EnvVar(name, value))
+        )
+
+    def _decode_vars(self, raw: JsonValue) -> ResultE[EnvVars]:
+        return (
+            Unfolder.to_list_of(
+                raw, lambda v: Unfolder.to_json(v).bind(self._decode_env_var)
+            )
+            .map(NewFrozenList)
+            .map(lambda i: i.map(lambda e: (e.name, e.value)))
+            .map(lambda i: EnvVars(FrozenDict(dict(i))))
+        )
+
+    def _decode_resource_req(self, raw: JsonObj) -> ResultE[ResourceRequirement]:
+        _resource = JsonUnfolder.require(raw, "resource", _to_str).bind(
+            ResourceType.to_req_type
+        )
+        _value = JsonUnfolder.require(
+            raw, "value", lambda v: _to_int(v).bind(Natural.assert_natural)
+        )
+        return ResultSmash.smash_result_2(
+            _resource,
+            _value,
+        ).map(lambda t: ResourceRequirement(*t))
+
+    def _decode_container_override(self, raw: JsonObj) -> ResultE[ContainerOverride]:
+        _command = JsonUnfolder.optional(
+            raw, "command", lambda v: Unfolder.to_list_of(v, _to_str).map(Command)
+        )
+        _environment = JsonUnfolder.optional(raw, "environment", self._decode_vars)
+        _resources = JsonUnfolder.optional(
+            raw,
+            "resources",
+            lambda v: Unfolder.to_list_of(
+                v, lambda i: Unfolder.to_json(i).bind(self._decode_resource_req)
+            ).map(NewFrozenList),
+        )
+        return ResultSmash.smash_result_3(
+            _command,
+            _environment,
+            _resources,
+        ).map(lambda t: ContainerOverride(*t))
+
+    def _decode_override(self, raw: JsonObj) -> ResultE[JobDefOverride]:
+        _retries = JsonUnfolder.optional(
+            raw,
+            "retries",
+            lambda v: _to_int(v).bind(Natural.assert_natural).bind(Attempts.new),
+        )
+        _timeout = JsonUnfolder.optional(
+            raw,
+            "timeout",
+            lambda v: _to_int(v).bind(Natural.assert_natural).bind(Timeout.new),
+        )
+        _container = JsonUnfolder.optional(
+            raw,
+            "container",
+            lambda v: Unfolder.to_json(v).bind(self._decode_container_override),
+        )
+        _tags = JsonUnfolder.optional(
+            raw, "tags", lambda v: Unfolder.to_dict_of(v, _to_str).map(Tags)
+        )
+        _propagate_tags = JsonUnfolder.optional(raw, "propagate_tags", _to_bool)
+        return ResultSmash.smash_result_5(
+            _retries,
+            _timeout,
+            _container,
+            _tags,
+            _propagate_tags,
+        ).map(lambda t: JobDefOverride(*t))
+
+    def decode_job(self, raw: JsonObj) -> ResultE[JobRequest]:
+        _name = JsonUnfolder.require(raw, "name", _to_str).bind(JobName.new)
+        _job_def = JsonUnfolder.require(raw, "definition", _to_str).map(
+            JobDefinitionName
+        )
+        _queue = JsonUnfolder.require(raw, "queue", _to_str).map(QueueName)
+        _size = (
+            JsonUnfolder.require(raw, "parallel", _to_int)
+            .bind(Natural.assert_natural)
+            .bind(JobSize.new)
+        )
+        _override = JsonUnfolder.optional(
+            raw, "override", lambda v: Unfolder.to_json(v).bind(self._decode_override)
+        )
+        return ResultSmash.smash_result_5(
+            _name,
+            _job_def,
+            _queue,
+            _size,
+            _override,
+        ).map(lambda t: JobRequest(*t))
+
+    def decode_pipeline(
+        self,
+        raw: NewFrozenList[JsonObj],
+    ) -> ResultE[JobPipeline]:
+        return ResultTransform.all_ok_2(raw.map(self.decode_job)).map(JobPipeline)