fluidattacks_integrates_dal 2.3.0__tar.gz → 2.3.2__tar.gz

{fluidattacks_integrates_dal-2.3.0 → fluidattacks_integrates_dal-2.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fluidattacks_integrates_dal
-Version: 2.3.0
+Version: 2.3.2
 Summary: ASM Synchronous Data Access Layer
 Author-email: Engineering Team <development@fluidattacks.com>
 Requires-Python: >=3.11
@@ -10,3 +10,4 @@ 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
+Requires-Dist: mypy-boto3-dynamodb >=1.40.40, <2.0.0

{fluidattacks_integrates_dal-2.3.0 → fluidattacks_integrates_dal-2.3.2}/build/default.nix

@@ -1,13 +1,9 @@
-{
-  nixpkgs,
-  builders,
-  scripts,
-  src,
-}:
+{ src }:
 {
   inherit src;
   root_path = "observes/common/integrates-dal";
   module_name = "fluidattacks_integrates_dal";
-  pypi_token_var = "INTEGRATES_DAL_TOKEN";
-  override = b: b;
+  pypi_token = {
+    method = "oidc";
+  };
 }

{fluidattacks_integrates_dal-2.3.0 → fluidattacks_integrates_dal-2.3.2}/flake.lock

@@ -98,11 +98,11 @@
     },
     "nixpkgs_flake": {
       "locked": {
-        "lastModified": 1762812764,
-        "narHash": "sha256-MNqrovkO8AEQeYQK7e3X2GDx2H8vfDIxV4K/VEaIjjo=",
+        "lastModified": 1778253243,
+        "narHash": "sha256-KkH2QvU6iRLDTGGEwH5jnMqHWj4zMTuHxi1S1zdr01w=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "400156fe527ab6b54cf6f70cca2c8385548a29c4",
+        "rev": "4fcda7103530b23c5ca44286344912082aad4220",
         "type": "github"
       },
       "original": {
@@ -111,49 +111,6 @@
         "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": 1770672786,
-        "narHash": "sha256-W4qMpuS/Zg9P/PooFDsqW7EzjF3A+ITsxKbp1SWdARI=",
-        "ref": "refs/heads/trunk",
-        "rev": "ad927cc6545df64a7d622696a43bcee225b9867b",
-        "shallow": true,
-        "type": "git",
-        "url": "ssh://git@gitlab.com/fluidattacks/universe"
-      },
-      "original": {
-        "dir": "observes/common/std_flake_2",
-        "rev": "ad927cc6545df64a7d622696a43bcee225b9867b",
-        "shallow": true,
-        "type": "git",
-        "url": "ssh://git@gitlab.com/fluidattacks/universe"
-      }
-    },
     "pyproject-build-systems": {
       "inputs": {
         "nixpkgs": "nixpkgs",
@@ -177,7 +134,7 @@
     "pyproject-nix": {
       "inputs": {
         "nixpkgs": [
-          "observes_flake_builder",
+          "python_builder",
           "pyproject-build-systems",
           "nixpkgs"
         ]
@@ -217,7 +174,7 @@
     "pyproject-nix_3": {
       "inputs": {
         "nixpkgs": [
-          "observes_flake_builder",
+          "python_builder",
           "uv2nix",
           "nixpkgs"
         ]
@@ -236,23 +193,28 @@
         "type": "github"
       }
     },
-    "pythonix_flake": {
+    "python_builder": {
       "inputs": {
-        "nixpkgs_flake": "nixpkgs_flake_2"
+        "nix_filter": "nix_filter",
+        "nixpkgs_flake": "nixpkgs_flake",
+        "pyproject-build-systems": "pyproject-build-systems",
+        "pyproject-nix": "pyproject-nix_2",
+        "shell-helpers": "shell-helpers",
+        "uv2nix": "uv2nix_2"
       },
       "locked": {
-        "dir": "observes/common/pythonix_mirror",
-        "lastModified": 1767370831,
-        "narHash": "sha256-VR86TSrJsNHQq31Ksga+1dvsrkv9u1pKa0MKuKYeIAc=",
+        "dir": "common/utils/python-builder",
+        "lastModified": 1785790367,
+        "narHash": "sha256-Br5oTB6LNGANZMUecvZhlXpA0k0wb0EKmOqyQeYCe7A=",
         "ref": "refs/heads/trunk",
-        "rev": "0678f8ff3bfe02cfe23bc819bfa739c53bd6e4b6",
+        "rev": "f66f38301987775ceb39ee72388ef0885ef30d13",
         "shallow": true,
         "type": "git",
         "url": "ssh://git@gitlab.com/fluidattacks/universe"
       },
       "original": {
-        "dir": "observes/common/pythonix_mirror",
-        "rev": "0678f8ff3bfe02cfe23bc819bfa739c53bd6e4b6",
+        "dir": "common/utils/python-builder",
+        "rev": "f66f38301987775ceb39ee72388ef0885ef30d13",
         "shallow": true,
         "type": "git",
         "url": "ssh://git@gitlab.com/fluidattacks/universe"
@@ -260,14 +222,14 @@
     },
     "root": {
       "inputs": {
-        "observes_flake_builder": "observes_flake_builder"
+        "python_builder": "python_builder"
       }
     },
     "shell-helpers": {
       "inputs": {
         "flake-parts": "flake-parts",
         "nixpkgs": [
-          "observes_flake_builder",
+          "python_builder",
           "nixpkgs_flake"
         ]
       },
@@ -292,12 +254,12 @@
     "uv2nix": {
       "inputs": {
         "nixpkgs": [
-          "observes_flake_builder",
+          "python_builder",
           "pyproject-build-systems",
           "nixpkgs"
         ],
         "pyproject-nix": [
-          "observes_flake_builder",
+          "python_builder",
           "pyproject-build-systems",
           "pyproject-nix"
         ]

{fluidattacks_integrates_dal-2.3.0 → fluidattacks_integrates_dal-2.3.2}/flake.nix

@@ -2,8 +2,8 @@
   description = "Common Integrates-dal";
 
   inputs = {
-    observes_flake_builder = {
-      url = "git+ssh://git@gitlab.com/fluidattacks/universe?shallow=1&rev=ad927cc6545df64a7d622696a43bcee225b9867b&dir=observes/common/std_flake_2";
+    python_builder = {
+      url = "git+ssh://git@gitlab.com/fluidattacks/universe?shallow=1&rev=f66f38301987775ceb39ee72388ef0885ef30d13&dir=common/utils/python-builder";
     };
   };
 
@@ -19,11 +19,10 @@
           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;
+      packages = inputs.python_builder.outputs.build build_args;
     };
 }

{fluidattacks_integrates_dal-2.3.0 → fluidattacks_integrates_dal-2.3.2}/fluidattacks_integrates_dal/__init__.py

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

{fluidattacks_integrates_dal-2.3.0 → fluidattacks_integrates_dal-2.3.2}/fluidattacks_integrates_dal/_cli.py

@@ -42,10 +42,10 @@ def list_all_groups() -> NoReturn:
             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 s: (
+                    Cmd[int]
+                    .wrap_impure(lambda: sys.stdout.write(s + "\n"))  # type: ignore[misc]
+                    .map(lambda _: None)
                 ),
             )
         ),

fluidattacks_integrates_dal-2.3.2/fluidattacks_integrates_dal/_typing.py

@@ -0,0 +1,11 @@
+from collections.abc import Callable, Iterable, Iterator
+from typing import Generic, NoReturn, TypeVar
+
+__all__ = [
+    "Callable",
+    "Generic",
+    "Iterable",
+    "Iterator",
+    "NoReturn",
+    "TypeVar",
+]

{fluidattacks_integrates_dal-2.3.0 → fluidattacks_integrates_dal-2.3.2}/fluidattacks_integrates_dal/clients/group/__init__.py

@@ -125,7 +125,7 @@ def _get_groups_page(
         LOG.debug(page)
         return page
 
-    return Cmd.wrap_impure(_action)
+    return Cmd[_Page].wrap_impure(_action)
 
 
 def _get_groups(table: Table, org: OrganizationId) -> Stream[GroupId]:
@@ -137,7 +137,7 @@ def _get_groups(table: Table, org: OrganizationId) -> Stream[GroupId]:
                 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)
+                    else Cmd[None].wrap_value(None).map(_union.inr)
                 ),
             ),
             init.map(_union.inl),

{fluidattacks_integrates_dal-2.3.0 → fluidattacks_integrates_dal-2.3.2}/fluidattacks_integrates_dal/clients/organization/__init__.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING
+from typing import (
+    TYPE_CHECKING,
+)
 
 from fa_purity import (
     Cmd,
@@ -20,9 +22,11 @@ from fa_purity.json import (
     JsonPrimitiveFactory,
     JsonPrimitiveUnfolder,
 )
+from mypy_boto3_dynamodb.type_defs import (
+    QueryOutputTypeDef,
+)
 
 from fluidattacks_integrates_dal._typing import (
-    Dict,
     Iterable,
     TypeVar,
 )
@@ -37,37 +41,40 @@ if TYPE_CHECKING:
     from mypy_boto3_dynamodb import (
         DynamoDBClient,
     )
-    from mypy_boto3_dynamodb.type_defs import (
-        QueryOutputTypeDef,
-    )
 LOG = logging.getLogger(__name__)
 _T = TypeVar("_T")
 _K = TypeVar("_K")
 _DB_TABLE = "integrates_vms"
 
 
-def _require_key(item: Dict[_K, _T], key: _K) -> ResultE[_T]:
+def _require_key(item: dict[_K, _T], key: _K) -> ResultE[_T]:
     try:
-        return Result.success(item[key])
+        return Result[_T, Exception].success(item[key])
     except KeyError as err:
-        return Result.failure(err).alt(cast_exception)
+        return Result[_T, KeyError].failure(err).alt(cast_exception)
 
 
-def _decode_dynamo_str(item: _T) -> ResultE[JsonPrimitive]:
+def _decode_dynamo_str(item: object) -> ResultE[JsonPrimitive]:
     if isinstance(item, dict):
-        return _require_key(item, "S").bind(  # type: ignore[misc]
-            JsonPrimitiveFactory.from_any,
+        # isinstance narrows to dict[Unknown, Unknown]; the actual key/value
+        # types are only known by convention (DynamoDB's typed-attribute maps).
+        s_value: ResultE[str] = _require_key(
+            item,  # pyright: ignore[reportUnknownArgumentType]
+            "S",
         )
-    return Result.failure(TypeError(f"Expected `dict` instance; got `{type(item)}`")).alt(
-        cast_exception,
+        return s_value.bind(JsonPrimitiveFactory.from_any)
+    return (
+        Result[JsonPrimitive, TypeError]
+        .failure(TypeError(f"Expected `dict` instance; got `{type(item)}`"))
+        .alt(cast_exception)
     )
 
 
-def _decode_dynamo_key_str(item: Dict[str, _T], key: str) -> ResultE[JsonPrimitive]:
+def _decode_dynamo_key_str(item: dict[str, _T], key: str) -> ResultE[JsonPrimitive]:
     return _require_key(item, key).bind(_decode_dynamo_str)
 
 
-def _decode_org_id(raw: Dict[str, _T]) -> ResultE[OrganizationId]:
+def _decode_org_id(raw: dict[str, _T]) -> ResultE[OrganizationId]:
     _pk = _decode_dynamo_key_str(raw, "pk").bind(JsonPrimitiveUnfolder.to_str)
     _sk = _decode_dynamo_key_str(raw, "sk").bind(JsonPrimitiveUnfolder.to_str)
     return _pk.bind(lambda pk: _sk.bind(lambda sk: OrganizationId.new(pk, sk)))
@@ -85,7 +92,7 @@ def _to_items(page: QueryOutputTypeDef) -> FrozenList[OrganizationId]:
 def _all_orgs(client: DynamoDBClient) -> Stream[OrganizationId]:
     def _new_iter() -> Iterable[Cmd[QueryOutputTypeDef]]:
         LOG.debug("Getting all orgs")
-        exp_attrs_values: Dict[str, Dict[str, str]] = {
+        exp_attrs_values: dict[str, dict[str, str]] = {
             ":pk": {"S": "ORG#all"},
             ":sk": {"S": "ORG#"},
         }
@@ -100,10 +107,12 @@ def _all_orgs(client: DynamoDBClient) -> Stream[OrganizationId]:
             IndexName="gsi_2",
         )
         LOG.debug("all orgs retrieved!")
-        return map(Cmd.wrap_value, response)  # type: ignore[misc]
+        return (Cmd[QueryOutputTypeDef].wrap_value(v) for v in response)  # type: ignore[misc]
 
     data = StreamFactory.from_commands(  # type: ignore[misc]
-        Unsafe.pure_iter_from_cmd(Cmd.wrap_impure(_new_iter)),  # type: ignore[misc]
+        Unsafe.pure_iter_from_cmd(
+            Cmd[Iterable[Cmd[QueryOutputTypeDef]]].wrap_impure(_new_iter),  # type: ignore[misc]
+        ),
     )
     return (
         data.map(_to_items)  # type: ignore[misc]

{fluidattacks_integrates_dal-2.3.0 → fluidattacks_integrates_dal-2.3.2}/fluidattacks_integrates_dal/clients/out_of_scope/__init__.py

@@ -19,8 +19,10 @@ from fa_purity import (
     Cmd,
     FrozenList,
     Maybe,
+    PureIterFactory,
+    PureIterTransform,
+    ResultE,
     Stream,
-    Unsafe,
 )
 from fa_purity.json import (
     JsonPrimitiveFactory,
@@ -66,15 +68,29 @@ _Cursor = Mapping[
 ]
 
 
-def _attr_str(item: Mapping[str, object], key: str) -> str:
-    return (
-        JsonPrimitiveFactory.from_any(item.get(key))
-        .bind(JsonPrimitiveUnfolder.to_str)
-        .alt(Unsafe.raise_exception)
-        .to_union()
+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,
@@ -90,15 +106,16 @@ def _get_page(
                 ExclusiveStartKey=start_key,
             ),
         ).or_else_call(lambda: table.query(KeyConditionExpression=condition))
-        roots = tuple(
-            OutOfScopeRoot.new(_attr_str(i, "nickname"), _attr_str(i, "status"))
-            .alt(Unsafe.raise_exception)
-            .to_union()
-            for i in response["Items"]
+        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 (roots, Maybe[_Cursor].from_optional(response.get("LastEvaluatedKey")))
 
-    return Cmd.wrap_impure(_action)
+    return Cmd[tuple[FrozenList[OutOfScopeRoot], Maybe[_Cursor]]].wrap_impure(_action)
 
 
 def _get_roots(table: Table, org: OrganizationId) -> Stream[FrozenList[OutOfScopeRoot]]:

{fluidattacks_integrates_dal-2.3.0 → fluidattacks_integrates_dal-2.3.2}/fluidattacks_integrates_dal/core.py

@@ -31,8 +31,8 @@ class GroupId:
         pattern = r"^[\w\s-]+$"
         if not re.match(pattern, _name):
             err = ValueError(rf"Group name is not `^[\w- ]+$` i.e. {_name}")
-            return Result.failure(err, GroupId).alt(cast_exception)
-        return Result.success(GroupId(_Private(), _name), Exception)
+            return Result[GroupId, ValueError].failure(err).alt(cast_exception)
+        return Result[GroupId, Exception].success(GroupId(_Private(), _name))
 
 
 @dataclass(frozen=True)
@@ -47,13 +47,13 @@ class OrganizationId:
         _uuid = uuid.removeprefix("ORG#")
         if not _name.isalnum():
             err = ValueError(f"Org name is not alphanum i.e. {_name}")
-            return Result.failure(err, OrganizationId).alt(cast_exception)
+            return Result[OrganizationId, ValueError].failure(err).alt(cast_exception)
         uuidv4 = "^[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$"
         if re.match(uuidv4, _uuid, re.IGNORECASE) is None:
             err = ValueError(f"Org id is not an UUIDv4 i.e. {_uuid}")
-            return Result.failure(err, OrganizationId).alt(cast_exception)
+            return Result[OrganizationId, ValueError].failure(err).alt(cast_exception)
 
-        return Result.success(OrganizationId(_Private(), _name, _uuid), Exception)
+        return Result[OrganizationId, Exception].success(OrganizationId(_Private(), _name, _uuid))
 
 
 @dataclass(frozen=True)
@@ -66,5 +66,7 @@ class OutOfScopeRoot:
     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)
+            return Result[OutOfScopeRoot, ValueError].failure(err).alt(cast_exception)
+        return Result[OutOfScopeRoot, Exception].success(
+            OutOfScopeRoot(_Private(), nickname, status),
+        )

fluidattacks_integrates_dal-2.3.2/fluidattacks_integrates_dal/utils.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from boto3 import (
+    Session,
+)
+from fa_purity import (
+    Cmd,
+)
+from mypy_boto3_dynamodb import (
+    DynamoDBClient,
+    DynamoDBServiceResource,
+)
+
+
+def new_session() -> Cmd[Session]:
+    # This impure procedure gets inputs (credentials) through the environment
+    # e.g. AWS_DEFAULT_REGION
+    return Cmd[Session].wrap_impure(Session)
+
+
+def new_resource(session: Session) -> Cmd[DynamoDBServiceResource]:
+    # boto3-stubs' resource() overload set is partially unknown because
+    # only mypy_boto3_dynamodb is installed.
+    return Cmd[DynamoDBServiceResource].wrap_impure(
+        lambda: session.resource(  # pyright: ignore[reportUnknownMemberType]
+            service_name="dynamodb",
+            use_ssl=True,
+            verify=True,
+        ),
+    )
+
+
+def new_client(session: Session) -> Cmd[DynamoDBClient]:
+    # boto3-stubs' client() overload set is partially unknown because
+    # only mypy_boto3_dynamodb is installed.
+    return Cmd[DynamoDBClient].wrap_impure(
+        lambda: session.client("dynamodb"),  # pyright: ignore[reportUnknownMemberType]
+    )

{fluidattacks_integrates_dal-2.3.0 → fluidattacks_integrates_dal-2.3.2}/pyproject.toml

@@ -13,6 +13,7 @@ dependencies = [
     "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",
+    "mypy-boto3-dynamodb >=1.40.40, <2.0.0",
 ]
 description = "ASM Synchronous Data Access Layer"
 dynamic = ["version"]
@@ -33,9 +34,9 @@ dev = [
     "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",
+    "basedpyright >=1.39.8, <2.0.0",
 ]
 
 [tool.uv]
 exclude-newer = "7 days"
-exclude-newer-package = { fluidattacks-core = "2099-01-01", fluid-blends = "2099-01-01" }
+exclude-newer-package = { fluidattacks-core = "2099-01-02T00:00:00Z", fluid-blends = "2099-01-02T00:00:00Z" , fluidattacks-utils-logger = "2099-01-02T00:00:00Z" }

{fluidattacks_integrates_dal-2.3.0 → fluidattacks_integrates_dal-2.3.2}/tests/arch/arch.py

@@ -8,13 +8,8 @@ from fa_purity import (
     FrozenList,
 )
 
-from fluidattacks_integrates_dal._typing import (
-    Dict,
-    FrozenSet,
-)
-
 root = FullPathModule.assert_module("fluidattacks_integrates_dal")
-_dag: Dict[str, FrozenList[FrozenList[str] | str]] = {
+_dag: dict[str, FrozenList[FrozenList[str] | str]] = {
     "fluidattacks_integrates_dal": (
         "_cli",
         "list_groups",
@@ -35,8 +30,8 @@ def project_dag() -> DagMap:
     return item
 
 
-def forbidden_allowlist() -> Dict[FullPathModule, FrozenSet[FullPathModule]]:
-    _raw: Dict[str, FrozenSet[str]] = {}
+def forbidden_allowlist() -> dict[FullPathModule, frozenset[FullPathModule]]:
+    _raw: dict[str, frozenset[str]] = {}
     return {
         FullPathModule.assert_module(k): frozenset(FullPathModule.assert_module(i) for i in v)
         for k, v in _raw.items()

{fluidattacks_integrates_dal-2.3.0 → fluidattacks_integrates_dal-2.3.2}/tests/arch/test_arch.py

@@ -20,7 +20,7 @@ from .arch import (
 
 
 def test_dag_creation() -> None:
-    project_dag()
+    _ = project_dag()
 
 
 def test_dag() -> None:
@@ -34,7 +34,7 @@ def test_dag_completeness() -> None:
 
 
 def test_forbidden_creation() -> None:
-    forbidden_allowlist()
+    _ = forbidden_allowlist()
 
 
 def test_forbidden() -> None:

{fluidattacks_integrates_dal-2.3.0 → fluidattacks_integrates_dal-2.3.2}/tests/test_list_groups.py

@@ -32,9 +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(Cmd.wrap_value)))
+    mock = OrgsClient(
+        StreamFactory.from_commands(orgs.map(Cmd[OrganizationId].wrap_value)),
+    )
     mock_2 = GroupsClient(
-        lambda _: StreamFactory.from_commands(groups.map(Cmd.wrap_value)),
+        lambda _: StreamFactory.from_commands(
+            groups.map(Cmd[GroupId].wrap_value),
+        ),
     )
 
     def check(items: FrozenList[GroupId]) -> None: