fluidattacks_integrates_dal 2.2.1__tar.gz → 2.3.1__tar.gz

{fluidattacks_integrates_dal-2.2.1 → fluidattacks_integrates_dal-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fluidattacks_integrates_dal
-Version: 2.2.1
+Version: 2.3.1
 Summary: ASM Synchronous Data Access Layer
 Author-email: Engineering Team <development@fluidattacks.com>
 Requires-Python: >=3.11
@@ -8,4 +8,5 @@ Classifier: License :: OSI Approved :: MIT License
 Requires-Dist: boto3 >=1.40.53, <2.0.0
 Requires-Dist: click >=8.1.7, <9.0.0
 Requires-Dist: fa-purity >=2.5.2, <3.0.0
+Requires-Dist: fluidattacks-etl-utils >=5.1.0, <6.0.0
 Requires-Dist: fluidattacks-utils-logger >=3.0.0, <4.0.0

{fluidattacks_integrates_dal-2.2.1 → fluidattacks_integrates_dal-2.3.1}/fluidattacks_integrates_dal/__init__.py

@@ -6,6 +6,6 @@ from ._logger import (
     set_logger,
 )
 
-__version__ = "2.2.1"
+__version__ = "2.3.1"
 
 Unsafe.compute(set_logger(__name__, __version__))

{fluidattacks_integrates_dal-2.2.1 → fluidattacks_integrates_dal-2.3.1}/fluidattacks_integrates_dal/_cli.py

@@ -31,19 +31,23 @@ LOG = logging.getLogger(__name__)
 @click.command(help="Requires AWS authentication (retrieved from the environment)")
 def list_all_groups() -> NoReturn:
     clients = new_session().bind(
-        lambda s: new_client(s)
-        .map(new_org_client)
-        .bind(lambda o: new_resource(s).map(new_group_client).map(lambda g: (o, g))),
+        lambda s: (
+            new_client(s)
+            .map(new_org_client)
+            .bind(lambda o: new_resource(s).map(new_group_client).map(lambda g: (o, g)))
+        ),
     )
     cmd: Cmd[None] = clients.bind(
-        lambda t: list_groups.list_all_groups(t[0], t[1])
-        .map(lambda gs: "\n".join(g.name for g in gs))
-        .bind(
-            lambda s: Cmd.wrap_impure(
-                lambda: sys.stdout.write(s + "\n"),  # type: ignore[misc]
-            ).map(
-                lambda _: None,  # type: ignore[misc]
-            ),
+        lambda t: (
+            list_groups.list_all_groups(t[0], t[1])
+            .map(lambda gs: "\n".join(g.name for g in gs))
+            .bind(
+                lambda s: Cmd.wrap_impure(
+                    lambda: sys.stdout.write(s + "\n"),  # type: ignore[misc]
+                ).map(
+                    lambda _: None,  # type: ignore[misc]
+                ),
+            )
         ),
     )
     cmd.compute()

{fluidattacks_integrates_dal-2.2.1 → fluidattacks_integrates_dal-2.3.1}/fluidattacks_integrates_dal/client.py

@@ -6,12 +6,14 @@ from dataclasses import (
 )
 
 from fa_purity import (
+    FrozenList,
     Stream,
 )
 
 from .core import (
     GroupId,
     OrganizationId,
+    OutOfScopeRoot,
 )
 
 
@@ -23,3 +25,8 @@ class OrgsClient:
 @dataclass(frozen=True)
 class GroupsClient:
     get_groups: Callable[[OrganizationId], Stream[GroupId]]
+
+
+@dataclass(frozen=True)
+class OutOfScopeRootsClient:
+    get_roots: Callable[[OrganizationId], Stream[FrozenList[OutOfScopeRoot]]]

{fluidattacks_integrates_dal-2.2.1 → fluidattacks_integrates_dal-2.3.1}/fluidattacks_integrates_dal/clients/__init__.py

@@ -5,6 +5,7 @@ from fa_purity import (
 from fluidattacks_integrates_dal.client import (
     GroupsClient,
     OrgsClient,
+    OutOfScopeRootsClient,
 )
 from fluidattacks_integrates_dal.utils import (
     new_client,
@@ -18,6 +19,9 @@ from .group import (
 from .organization import (
     new_client as _new_org_client,
 )
+from .out_of_scope import (
+    new_client as _new_out_of_scope_client,
+)
 
 
 def new_group_client() -> Cmd[GroupsClient]:
@@ -26,3 +30,7 @@ def new_group_client() -> Cmd[GroupsClient]:
 
 def new_org_client() -> Cmd[OrgsClient]:
     return new_session().bind(new_client).map(_new_org_client)
+
+
+def new_out_of_scope_client() -> Cmd[OutOfScopeRootsClient]:
+    return new_session().bind(new_resource).map(_new_out_of_scope_client)

{fluidattacks_integrates_dal-2.2.1 → fluidattacks_integrates_dal-2.3.1}/fluidattacks_integrates_dal/clients/group/__init__.py

@@ -134,17 +134,19 @@ def _get_groups(table: Table, org: OrganizationId) -> Stream[GroupId]:
     return (
         PureIterFactory.infinite_gen(
             lambda wp: wp.bind(
-                lambda p: _get_groups_page(table, org, p.last_index).map(_union.inl)
-                if p and p.last_index
-                else Cmd.wrap_value(None).map(_union.inr),
+                lambda p: (
+                    _get_groups_page(table, org, p.last_index).map(_union.inl)
+                    if p and p.last_index
+                    else Cmd.wrap_value(None).map(_union.inr)
+                ),
             ),
             init.map(_union.inl),
         )
-        .transform(lambda s: StreamFactory.from_commands(s))
-        .transform(lambda s: StreamTransform.until_none(s))
-        .map(lambda x: _to_group(x))
-        .map(lambda x: PureIterFactory.from_list(x))
-        .transform(lambda s: StreamTransform.chain(s))
+        .transform(StreamFactory.from_commands)
+        .transform(StreamTransform.until_none)
+        .map(_to_group)
+        .map(PureIterFactory.from_list)
+        .transform(StreamTransform.chain)
     )
 
 

{fluidattacks_integrates_dal-2.2.1 → fluidattacks_integrates_dal-2.3.1}/fluidattacks_integrates_dal/clients/organization/__init__.py

@@ -106,9 +106,9 @@ def _all_orgs(client: DynamoDBClient) -> Stream[OrganizationId]:
         Unsafe.pure_iter_from_cmd(Cmd.wrap_impure(_new_iter)),  # type: ignore[misc]
     )
     return (
-        data.map(lambda x: _to_items(x))  # type: ignore[misc]
-        .map(lambda x: PureIterFactory.from_list(x))
-        .transform(lambda s: StreamTransform.chain(s))
+        data.map(_to_items)  # type: ignore[misc]
+        .map(PureIterFactory.from_list)
+        .transform(StreamTransform.chain)
     )
 
 

fluidattacks_integrates_dal-2.3.1/fluidattacks_integrates_dal/clients/out_of_scope/__init__.py

@@ -0,0 +1,126 @@
+from __future__ import (
+    annotations,
+)
+
+import logging
+from collections.abc import (
+    Mapping,
+    Sequence,
+)
+from decimal import (
+    Decimal,
+)
+from typing import TYPE_CHECKING
+
+from boto3.dynamodb.conditions import (
+    Key,
+)
+from fa_purity import (
+    Cmd,
+    FrozenList,
+    Maybe,
+    PureIterFactory,
+    PureIterTransform,
+    ResultE,
+    Stream,
+)
+from fa_purity.json import (
+    JsonPrimitiveFactory,
+    JsonPrimitiveUnfolder,
+)
+from fluidattacks_etl_utils.paginate import (
+    cursor_pagination,
+)
+
+from fluidattacks_integrates_dal.client import (
+    OutOfScopeRootsClient,
+)
+from fluidattacks_integrates_dal.core import (
+    OrganizationId,
+    OutOfScopeRoot,
+)
+
+if TYPE_CHECKING:
+    from mypy_boto3_dynamodb import (
+        DynamoDBServiceResource,
+    )
+    from mypy_boto3_dynamodb.service_resource import (
+        Table,
+    )
+LOG = logging.getLogger(__name__)
+_ORGS_TABLE = "integrates_vms"
+_Cursor = Mapping[
+    str,
+    bytes
+    | bytearray
+    | str
+    | int
+    | Decimal
+    | bool
+    | set[int]
+    | set[Decimal]
+    | set[str]
+    | set[bytes]
+    | set[bytearray]
+    | Sequence[object]
+    | Mapping[str, object]
+    | None,
+]
+
+
+def _decode_str(item: Mapping[str, object], key: str) -> ResultE[str]:
+    return JsonPrimitiveFactory.from_any(item.get(key)).bind(JsonPrimitiveUnfolder.to_str)
+
+
+def _decode_root(item: Mapping[str, object]) -> ResultE[OutOfScopeRoot]:
+    return _decode_str(item, "nickname").bind(
+        lambda nickname: _decode_str(item, "status").bind(
+            lambda status: OutOfScopeRoot.new(nickname, status),
+        ),
+    )
+
+
+def _warn_skip(error: Exception) -> Maybe[OutOfScopeRoot]:
+    LOG.warning("Skipping malformed out-of-scope root: %s", error)
+    return Maybe[OutOfScopeRoot].empty()
+
+
+def _ignore_errors(result: ResultE[OutOfScopeRoot]) -> Maybe[OutOfScopeRoot]:
+    # A malformed cloning record (e.g. still in progress with no status) must not
+    # abort the enumeration: log it and drop it. The log is a negligible impurity.
+    return result.map(Maybe[OutOfScopeRoot].some).alt(_warn_skip).to_union()
+
+
+def _get_page(
+    table: Table,
+    org: OrganizationId,
+    cursor: Maybe[_Cursor],
+) -> Cmd[tuple[FrozenList[OutOfScopeRoot], Maybe[_Cursor]]]:
+    def _action() -> tuple[FrozenList[OutOfScopeRoot], Maybe[_Cursor]]:
+        # pk holds the org, sk starts with CLONING# per the
+        # organization_out_of_scope_root facet; queried on the main table.
+        condition = Key("pk").eq(f"ORG#{org.uuid}") & Key("sk").begins_with("CLONING#")
+        response = cursor.map(
+            lambda start_key: table.query(
+                KeyConditionExpression=condition,
+                ExclusiveStartKey=start_key,
+            ),
+        ).or_else_call(lambda: table.query(KeyConditionExpression=condition))
+        roots = (
+            PureIterFactory.from_list(tuple(response["Items"]))
+            .map(_decode_root)
+            .map(_ignore_errors)
+            .transform(PureIterTransform.filter_maybe)
+            .to_list()
+        )
+        return (roots, Maybe.from_optional(response.get("LastEvaluatedKey")))
+
+    return Cmd.wrap_impure(_action)
+
+
+def _get_roots(table: Table, org: OrganizationId) -> Stream[FrozenList[OutOfScopeRoot]]:
+    return cursor_pagination(lambda cursor: _get_page(table, org, cursor))
+
+
+def new_client(resource: DynamoDBServiceResource) -> OutOfScopeRootsClient:
+    return OutOfScopeRootsClient(lambda o: _get_roots(resource.Table(_ORGS_TABLE), o))

{fluidattacks_integrates_dal-2.2.1 → fluidattacks_integrates_dal-2.3.1}/fluidattacks_integrates_dal/core.py

@@ -54,3 +54,17 @@ class OrganizationId:
             return Result.failure(err, OrganizationId).alt(cast_exception)
 
         return Result.success(OrganizationId(_Private(), _name, _uuid), Exception)
+
+
+@dataclass(frozen=True)
+class OutOfScopeRoot:
+    _private: _Private = field(repr=False, hash=False, compare=False)
+    nickname: str
+    status: str
+
+    @staticmethod
+    def new(nickname: str, status: str) -> ResultE[OutOfScopeRoot]:
+        if not nickname:
+            err = ValueError("Out-of-scope root nickname is empty")
+            return Result.failure(err, OutOfScopeRoot).alt(cast_exception)
+        return Result.success(OutOfScopeRoot(_Private(), nickname, status), Exception)

{fluidattacks_integrates_dal-2.2.1 → fluidattacks_integrates_dal-2.3.1}/fluidattacks_integrates_dal/utils.py

@@ -19,7 +19,7 @@ if TYPE_CHECKING:
 def new_session() -> Cmd[Session]:
     # This impure procedure gets inputs (credentials) through the environment
     # e.g. AWS_DEFAULT_REGION
-    return Cmd.wrap_impure(lambda: Session())
+    return Cmd.wrap_impure(Session)
 
 
 def new_resource(session: Session) -> Cmd[DynamoDBServiceResource]:

{fluidattacks_integrates_dal-2.2.1 → fluidattacks_integrates_dal-2.3.1}/pyproject.toml

@@ -11,6 +11,7 @@ dependencies = [
     "boto3 >=1.40.53, <2.0.0",
     "click >=8.1.7, <9.0.0",
     "fa-purity >=2.5.2, <3.0.0",
+    "fluidattacks-etl-utils >=5.1.0, <6.0.0",
     "fluidattacks-utils-logger >=3.0.0, <4.0.0",
 ]
 description = "ASM Synchronous Data Access Layer"
@@ -27,10 +28,14 @@ build-backend = "flit_core.buildapi"
 dev = [
     "arch-lint >=5.0.0, <6.0.0",
     "mypy >=1.18.2, <2.0.0",
-    "pytest >=8.4.2, <9.0.0",
+    "pytest >=9.0.3, <10.0.0",
     "pytest-cov >=7.0.0, <8.0.0",
     "ruff >=0.14.1, <1.0.0",
     "botocore-stubs >=1.40.53, <2.0.0",
     "boto3-stubs >=1.40.53, <2.0.0",
     "mypy-boto3-dynamodb >=1.40.40, <2.0.0",
 ]
+
+[tool.uv]
+exclude-newer = "7 days"
+exclude-newer-package = { fluidattacks-core = "2099-01-01", fluid-blends = "2099-01-01" , fluidattacks-utils-logger = "2099-01-01" }

{fluidattacks_integrates_dal-2.2.1 → fluidattacks_integrates_dal-2.3.1}/tests/arch/arch.py

@@ -24,7 +24,7 @@ _dag: Dict[str, FrozenList[FrozenList[str] | str]] = {
         "_logger",
         "_typing",
     ),
-    "fluidattacks_integrates_dal.clients": (("group", "organization"),),
+    "fluidattacks_integrates_dal.clients": (("group", "organization", "out_of_scope"),),
 }
 
 

fluidattacks_integrates_dal-2.3.1/tests/test_core.py

@@ -0,0 +1,30 @@
+from fa_purity import (
+    Unsafe,
+)
+
+from fluidattacks_integrates_dal.core import (
+    GroupId,
+    OrganizationId,
+    OutOfScopeRoot,
+)
+
+
+def test_group() -> None:
+    assert GroupId.new("foo")
+
+
+def test_org() -> None:
+    assert OrganizationId.new("aaaaaaaa-aaaa-4aaa-baaa-aaaaaaaaaaaa", "foo_org")
+
+
+def test_out_of_scope_root() -> None:
+    root = OutOfScopeRoot.new("my-repo", "OK").alt(Unsafe.raise_exception).to_union()
+    assert root.nickname == "my-repo"
+    assert root.status == "OK"
+
+
+def test_out_of_scope_root_empty_nickname_fails() -> None:
+    outcome = (
+        OutOfScopeRoot.new("", "OK").map(lambda _: "created").alt(lambda _: "rejected").to_union()
+    )
+    assert outcome == "rejected"

{fluidattacks_integrates_dal-2.2.1 → fluidattacks_integrates_dal-2.3.1}/tests/test_list_groups.py

@@ -32,13 +32,13 @@ def test_list_groups() -> None:
     )
     mock_group = GroupId.new("foo_group").alt(Unsafe.raise_exception).to_union()
     groups = PureIterFactory.from_list((mock_group,))
-    mock = OrgsClient(StreamFactory.from_commands(orgs.map(lambda o: Cmd.wrap_value(o))))
+    mock = OrgsClient(StreamFactory.from_commands(orgs.map(Cmd.wrap_value)))
     mock_2 = GroupsClient(
-        lambda _: StreamFactory.from_commands(groups.map(lambda i: Cmd.wrap_value(i))),
+        lambda _: StreamFactory.from_commands(groups.map(Cmd.wrap_value)),
     )
 
     def check(items: FrozenList[GroupId]) -> None:
         assert items == (mock_group,)
 
     with pytest.raises(SystemExit):
-        list_all_groups(mock, mock_2).map(lambda f: check(f)).compute()
+        list_all_groups(mock, mock_2).map(check).compute()