fluidattacks_gitlab_sdk 4.0.0__tar.gz → 6.0.0__tar.gz

{fluidattacks_gitlab_sdk-4.0.0 → fluidattacks_gitlab_sdk-6.0.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: fluidattacks_gitlab_sdk
-Version: 4.0.0
+Version: 6.0.0
 Summary: gitlab SDK
 Author-email: Product Team <development@fluidattacks.com>
-Requires-Python: >=3.11
+Requires-Python: >=3.13.14, <3.14
 Requires-Dist: gql >=3.5.0, <4.0.0
 Requires-Dist: requests-toolbelt >=1.0.0, <2.0.0
 Requires-Dist: fa-purity >=2.5.2, <3.0.0
 Requires-Dist: pure-requests >=3.0.0, <4.0.0
 Requires-Dist: python-dateutil >=2.8.0, <3.0.0
 Requires-Dist: fluidattacks-etl-utils >=4.0.0, <5.1.1
-Requires-Dist: fluidattacks-utils-logger >=3.0.2, <4.0.0
+Requires-Dist: fluidattacks-utils-logger >=3.0.5, <4.0.0

fluidattacks_gitlab_sdk-6.0.0/build/default.nix

@@ -0,0 +1,13 @@
+{ src }:
+{
+  inherit src;
+  root_path = "observes/sdk/gitlab";
+  module_name = "fluidattacks_gitlab_sdk";
+  pypi_token = {
+    method = "oidc";
+  };
+  override.checks = {
+    deptry = false;
+    import_linter = false;
+  };
+}

{fluidattacks_gitlab_sdk-4.0.0 → fluidattacks_gitlab_sdk-6.0.0}/flake.lock

@@ -5,11 +5,11 @@
         "nixpkgs-lib": "nixpkgs-lib"
       },
       "locked": {
-        "lastModified": 1762810396,
-        "narHash": "sha256-dxFVgQPG+R72dkhXTtqUm7KpxElw3u6E+YlQ2WaDgt8=",
+        "lastModified": 1768135262,
+        "narHash": "sha256-PVvu7OqHBGWN16zSi6tEmPwwHQ4rLPU9Plvs8/1TUBY=",
         "owner": "hercules-ci",
         "repo": "flake-parts",
-        "rev": "0bdadb1b265fb4143a75bd1ec7d8c915898a9923",
+        "rev": "80daad04eddbbf5a4d883996a73f3f542fa437ac",
         "type": "github"
       },
       "original": {
@@ -33,43 +33,29 @@
         "type": "github"
       }
     },
-    "nix_filter_2": {
-      "locked": {
-        "lastModified": 1731533336,
-        "narHash": "sha256-oRam5PS1vcrr5UPgALW0eo1m/5/pls27Z/pabHNy2Ms=",
-        "owner": "numtide",
-        "repo": "nix-filter",
-        "rev": "f7653272fd234696ae94229839a99b73c9ab7de0",
-        "type": "github"
-      },
-      "original": {
-        "owner": "numtide",
-        "repo": "nix-filter",
-        "type": "github"
-      }
-    },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1736441877,
-        "narHash": "sha256-m3+PhBFkDwqo9lBplG4AyMW8P4/KcioJRS1UG8N7okM=",
+        "lastModified": 1785133411,
+        "narHash": "sha256-Yjv0WEg39KRYS0rBdTbu6Fc/or/ihAKk13W9sQ6VWd0=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "ce3899414dab3297cf025bfa356dc2da426feefd",
+        "rev": "2f5a153c270b70cb0f8c11f46d96d6d3bc39f4e3",
         "type": "github"
       },
       "original": {
         "owner": "nixos",
         "repo": "nixpkgs",
+        "rev": "2f5a153c270b70cb0f8c11f46d96d6d3bc39f4e3",
         "type": "github"
       }
     },
     "nixpkgs-lib": {
       "locked": {
-        "lastModified": 1761765539,
-        "narHash": "sha256-b0yj6kfvO8ApcSE+QmA6mUfu8IYG6/uU28OFn4PaC8M=",
+        "lastModified": 1765674936,
+        "narHash": "sha256-k00uTP4JNfmejrCLJOwdObYC9jHRrr/5M/a/8L2EIdo=",
         "owner": "nix-community",
         "repo": "nixpkgs.lib",
-        "rev": "719359f4562934ae99f5443f20aa06c2ffff91fc",
+        "rev": "2075416fcb47225d9b68ac469a5c4801a9c4dd85",
         "type": "github"
       },
       "original": {
@@ -126,68 +112,6 @@
         "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"
-      }
-    },
-    "observes_flake_builder": {
-      "inputs": {
-        "nix_filter": "nix_filter",
-        "nixpkgs_flake": "nixpkgs_flake",
-        "pynix_flake": "pynix_flake",
-        "pyproject-build-systems": "pyproject-build-systems",
-        "pyproject-nix": "pyproject-nix_2",
-        "shell-helpers": "shell-helpers",
-        "uv2nix": "uv2nix_2"
-      },
-      "locked": {
-        "dir": "observes/common/std_flake_2",
-        "lastModified": 1764767408,
-        "narHash": "sha256-CYGyCtQuboXbHQ0OUXNNdXXIcPOM1ZhOM94LUNjEQig=",
-        "ref": "refs/heads/trunk",
-        "rev": "28bda83eeda56c9c4016f43c86aaf93a366446c3",
-        "shallow": true,
-        "type": "git",
-        "url": "ssh://git@gitlab.com/fluidattacks/universe"
-      },
-      "original": {
-        "dir": "observes/common/std_flake_2",
-        "rev": "28bda83eeda56c9c4016f43c86aaf93a366446c3",
-        "shallow": true,
-        "type": "git",
-        "url": "ssh://git@gitlab.com/fluidattacks/universe"
-      }
-    },
-    "pynix_flake": {
-      "inputs": {
-        "nix_filter": "nix_filter_2",
-        "nixpkgs": "nixpkgs"
-      },
-      "locked": {
-        "lastModified": 1758642502,
-        "narHash": "sha256-PD/bQMz2dqZSkydHyvRh+jS/0qoV8SdcIVs6sassteQ=",
-        "owner": "dmurciaatfluid",
-        "repo": "python_nix_builder",
-        "rev": "809aafe2e1995e72c15378d099bf251b78f04a20",
-        "type": "gitlab"
-      },
-      "original": {
-        "owner": "dmurciaatfluid",
-        "repo": "python_nix_builder",
-        "type": "gitlab"
-      }
-    },
     "pyproject-build-systems": {
       "inputs": {
         "nixpkgs": "nixpkgs_2",
@@ -211,7 +135,7 @@
     "pyproject-nix": {
       "inputs": {
         "nixpkgs": [
-          "observes_flake_builder",
+          "python_builder",
           "pyproject-build-systems",
           "nixpkgs"
         ]
@@ -251,7 +175,7 @@
     "pyproject-nix_3": {
       "inputs": {
         "nixpkgs": [
-          "observes_flake_builder",
+          "python_builder",
           "uv2nix",
           "nixpkgs"
         ]
@@ -270,32 +194,62 @@
         "type": "github"
       }
     },
+    "python_builder": {
+      "inputs": {
+        "nix_filter": "nix_filter",
+        "nixpkgs_flake": [
+          "nixpkgs"
+        ],
+        "pyproject-build-systems": "pyproject-build-systems",
+        "pyproject-nix": "pyproject-nix_2",
+        "shell-helpers": "shell-helpers",
+        "uv2nix": "uv2nix_2"
+      },
+      "locked": {
+        "dir": "common/utils/python-builder",
+        "lastModified": 1787753967,
+        "narHash": "sha256-1kWAiANGMA4B9flxHFj73EwvOpF8r0nXGg1RVXNKPK8=",
+        "ref": "refs/heads/trunk",
+        "rev": "2490a24f91f075f7580cd0b9df5bc01dbc467a50",
+        "shallow": true,
+        "type": "git",
+        "url": "ssh://git@gitlab.com/fluidattacks/universe"
+      },
+      "original": {
+        "dir": "common/utils/python-builder",
+        "rev": "2490a24f91f075f7580cd0b9df5bc01dbc467a50",
+        "shallow": true,
+        "type": "git",
+        "url": "ssh://git@gitlab.com/fluidattacks/universe"
+      }
+    },
     "root": {
       "inputs": {
-        "observes_flake_builder": "observes_flake_builder"
+        "nixpkgs": "nixpkgs",
+        "python_builder": "python_builder"
       }
     },
     "shell-helpers": {
       "inputs": {
         "flake-parts": "flake-parts",
         "nixpkgs": [
-          "observes_flake_builder",
+          "python_builder",
           "nixpkgs_flake"
         ]
       },
       "locked": {
         "dir": "common/utils/shell-helpers",
-        "lastModified": 1762806066,
-        "narHash": "sha256-Wz99Fl7SpPU1NkTHJ36XOo6DjOEAMXCw3ThRABOS2Hs=",
+        "lastModified": 1787145059,
+        "narHash": "sha256-i5i+qLR9JhcNasrQvzG4S/0AotpZAqTHXa4/68MmvwA=",
         "ref": "refs/heads/trunk",
-        "rev": "d73cfdc7ae9e7f547e22a4481d4c2ccce38b26a8",
+        "rev": "e0d58302690af6f38b7544265e59c625b63df76f",
         "shallow": true,
         "type": "git",
         "url": "ssh://git@gitlab.com/fluidattacks/universe"
       },
       "original": {
         "dir": "common/utils/shell-helpers",
-        "rev": "d73cfdc7ae9e7f547e22a4481d4c2ccce38b26a8",
+        "rev": "e0d58302690af6f38b7544265e59c625b63df76f",
         "shallow": true,
         "type": "git",
         "url": "ssh://git@gitlab.com/fluidattacks/universe"
@@ -304,12 +258,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_gitlab_sdk-4.0.0 → fluidattacks_gitlab_sdk-6.0.0}/flake.nix

@@ -2,8 +2,10 @@
   description = "Singer target for fluidattacks warehouse";
 
   inputs = {
-    observes_flake_builder = {
-      url = "git+ssh://git@gitlab.com/fluidattacks/universe?shallow=1&rev=28bda83eeda56c9c4016f43c86aaf93a366446c3&dir=observes/common/std_flake_2";
+    nixpkgs.url = "github:nixos/nixpkgs/2f5a153c270b70cb0f8c11f46d96d6d3bc39f4e3";
+    python_builder = {
+      url = "git+ssh://git@gitlab.com/fluidattacks/universe?shallow=1&rev=2490a24f91f075f7580cd0b9df5bc01dbc467a50&dir=common/utils/python-builder";
+      inputs.nixpkgs_flake.follows = "nixpkgs";
     };
   };
 
@@ -19,11 +21,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_gitlab_sdk-4.0.0 → fluidattacks_gitlab_sdk-6.0.0}/fluidattacks_gitlab_sdk/__init__.py

@@ -11,7 +11,7 @@ from ._logger import (
     set_logger,
 )
 
-__version__ = "4.0.0"
+__version__ = "6.0.0"
 
 Unsafe.compute(set_logger(__name__, __version__))
 LOG = logging.getLogger(__name__)

{fluidattacks_gitlab_sdk-4.0.0 → fluidattacks_gitlab_sdk-6.0.0}/fluidattacks_gitlab_sdk/_decoders.py

@@ -1,6 +1,5 @@
 from collections.abc import Callable
 from datetime import date
-from typing import TypeVar
 
 from fa_purity import (
     Bool,
@@ -41,20 +40,18 @@ from fluidattacks_gitlab_sdk.ids import (
     ProjectId,
 )
 
-_T = TypeVar("_T")
 
-
-def decode_maybe_single(items: NewFrozenList[_T]) -> Maybe[_T]:
+def decode_maybe_single[T](items: NewFrozenList[T]) -> Maybe[T]:
     return Bool.from_primitive(len(items.items) <= 1).map(
-        lambda _: ResultTransform.get_index(items, 0).map(Maybe.some).value_or(Maybe.empty()),
-        lambda _: Maybe.empty(),
+        lambda _: ResultTransform.get_index(items, 0).map(Maybe[T].some).value_or(Maybe[T].empty()),
+        lambda _: Maybe[T].empty(),
     )
 
 
-def _decode_internal_id(
+def _decode_internal_id[T](
     raw: JsonObj,
-    iid_transform: Callable[[Natural], _T],
-) -> ResultE[tuple[ProjectId, _T]]:
+    iid_transform: Callable[[Natural], T],
+) -> ResultE[tuple[ProjectId, T]]:
     _project = (
         JsonUnfolder.require(raw, "project_id", DecodeUtils.to_int)
         .bind(Natural.from_int)
@@ -158,13 +155,15 @@ def decode_date(raw: str) -> ResultE[date]:
 
 def assert_single(item: Coproduct[JsonObj, FrozenList[JsonObj]]) -> ResultE[JsonObj]:
     return item.map(
-        Result.success,
-        lambda _: Result.failure(ValueError("Expected a json not a list")),
+        Result[JsonObj, Exception].success,
+        lambda _: Result[JsonObj, Exception].failure(ValueError("Expected a json not a list")),
     )
 
 
 def assert_multiple(item: Coproduct[JsonObj, FrozenList[JsonObj]]) -> ResultE[FrozenList[JsonObj]]:
     return item.map(
-        lambda _: Result.failure(ValueError("Expected a json list not a single json")),
-        Result.success,
+        lambda _: Result[FrozenList[JsonObj], Exception].failure(
+            ValueError("Expected a json list not a single json"),
+        ),
+        Result[FrozenList[JsonObj], Exception].success,
     )

{fluidattacks_gitlab_sdk-4.0.0 → fluidattacks_gitlab_sdk-6.0.0}/fluidattacks_gitlab_sdk/_gql_client/_client.py

@@ -27,7 +27,6 @@ from fluidattacks_etl_utils.retry import (
     sleep_cmd,
 )
 from fluidattacks_etl_utils.typing import (
-    Dict,
     TypeVar,
 )
 from gql import (
@@ -38,18 +37,23 @@ from gql.transport.requests import (
     RequestsHTTPTransport,
 )
 
-from . import _handlers
 from ._error import (
     ApiError,
 )
+from ._handlers import (
+    api_error_handler,
+    connection_error_handler,
+    server_error_handler,
+    too_many_requests_handler,
+)
 
 API_ENDPOINT = "https://gitlab.com/api/graphql"
 _T = TypeVar("_T")
 
 
 def error_handler(cmd: Cmd[_T]) -> Cmd[ResultE[_T]]:
-    return _handlers.too_many_requests_handler(
-        _handlers.server_error_handler(_handlers.connection_error_handler(cmd)),
+    return too_many_requests_handler(
+        server_error_handler(connection_error_handler(cmd)),
     ).map(lambda a: a.bind(lambda b: b.bind(lambda c: c)))
 
 
@@ -65,12 +69,12 @@ class GraphQlGitlabClient:
     @staticmethod
     def new(token: str) -> Cmd[GraphQlGitlabClient]:
         def _new() -> GraphQlGitlabClient:
-            headers: Dict[str, str] = {"Authorization": f"Bearer {token}"}
+            headers: dict[str, str] = {"Authorization": f"Bearer {token}"}
             transport = RequestsHTTPTransport(API_ENDPOINT, headers)
             client = Client(transport=transport, fetch_schema_from_transport=False)
             return GraphQlGitlabClient(_GraphQlAsmClient(client))
 
-        return Cmd.wrap_impure(_new)
+        return Cmd[GraphQlGitlabClient].wrap_impure(_new)
 
     def _get(self, query: str, values: FrozenDict[str, str]) -> Cmd[JsonObj]:
         def _action() -> JsonObj:
@@ -79,11 +83,11 @@ class GraphQlGitlabClient:
                 inspect.currentframe(),
                 (query, str(values)),
                 JsonValueFactory.from_any(
-                    self._inner.client.execute(gql(query), dict(values)),  # type: ignore[misc]
+                    self._inner.client.execute(gql(query), dict(values)),  # type: ignore[misc]  # pyright: ignore[reportUnknownMemberType]
                 ).bind(Unfolder.to_json),
             )
 
-        return Cmd.wrap_impure(_action)
+        return Cmd[JsonObj].wrap_impure(_action)
 
     def get(self, query: str, values: FrozenDict[str, str]) -> Cmd[Result[JsonObj, ApiError]]:
         result = retry_cmd(
@@ -98,4 +102,4 @@ class GraphQlGitlabClient:
                 r,
             ),
         )
-        return _handlers.api_error_handler(result)
+        return api_error_handler(result)

{fluidattacks_gitlab_sdk-4.0.0 → fluidattacks_gitlab_sdk-6.0.0}/fluidattacks_gitlab_sdk/_gql_client/_handlers.py

@@ -44,7 +44,7 @@ def http_status_handler(is_handled: Callable[[int], bool], cmd: Cmd[_T]) -> Cmd[
                 return factory.failure(err)
             raise
 
-    return Cmd.new_cmd(_action)
+    return Cmd[ResultE[_T]].new_cmd(_action)
 
 
 def api_error_handler(cmd: Cmd[_T]) -> Cmd[Result[_T, ApiError]]:
@@ -65,7 +65,7 @@ def api_error_handler(cmd: Cmd[_T]) -> Cmd[Result[_T, ApiError]]:
             )
             return factory.failure(ApiError(errors))
 
-    return Cmd.new_cmd(_action)
+    return Cmd[Result[_T, ApiError]].new_cmd(_action)
 
 
 def too_many_requests_handler(cmd: Cmd[_T]) -> Cmd[ResultE[_T]]:
@@ -80,8 +80,8 @@ def server_error_handler(cmd: Cmd[_T]) -> Cmd[ResultE[_T]]:
 def connection_error_handler(cmd: Cmd[_T]) -> Cmd[ResultE[_T]]:
     def _action(unwrapper: CmdUnwrapper) -> ResultE[_T]:
         try:
-            return Result.success(unwrapper.act(cmd))
+            return Result[_T, Exception].success(unwrapper.act(cmd))
         except RequestsConnectionError as err:
-            return Result.failure(Exception(err))
+            return Result[_T, Exception].failure(Exception(err))
 
-    return Cmd.new_cmd(_action)
+    return Cmd[ResultE[_T]].new_cmd(_action)

{fluidattacks_gitlab_sdk-4.0.0 → fluidattacks_gitlab_sdk-6.0.0}/fluidattacks_gitlab_sdk/_handlers.py

@@ -1,24 +1,21 @@
 from collections.abc import Callable
 from dataclasses import dataclass
-from typing import TypeVar
 
 from fa_purity import Coproduct, Result, ResultE, cast_exception
 
 from fluidattacks_gitlab_sdk._http_client import HTTPError, UnhandledErrors
 
-_T = TypeVar("_T")
-
 
 @dataclass
 class NotFound(Exception):
     parent: Exception | None
 
 
-def handle_value_error(value: Callable[[], _T]) -> ResultE[_T]:
+def handle_value_error[T](value: Callable[[], T]) -> ResultE[T]:
     try:
-        return Result.success(value())
+        return Result[T, Exception].success(value())
     except ValueError as error:
-        return Result.failure(error)
+        return Result[T, Exception].failure(error)
 
 
 def _handle_not_found(error: HTTPError) -> Coproduct[NotFound, Exception]:
@@ -26,15 +23,15 @@ def _handle_not_found(error: HTTPError) -> Coproduct[NotFound, Exception]:
     err_code: int = error.raw.response.status_code  # type: ignore[misc]
 
     if err_code == not_found_code:
-        return Coproduct.inl(NotFound(error.raw))
-    return Coproduct.inr(error.raw)
+        return Coproduct[NotFound, Exception].inl(NotFound(error.raw))
+    return Coproduct[NotFound, Exception].inr(error.raw)
 
 
 def handle_not_found(error: UnhandledErrors) -> Coproduct[NotFound, Exception]:
     return error.error.map(
-        lambda e: Coproduct.inr(cast_exception(e.raw)),
+        lambda e: Coproduct[NotFound, Exception].inr(cast_exception(e.raw)),
         lambda c: c.map(
             _handle_not_found,
-            lambda e: Coproduct.inr(cast_exception(e.raw)),
+            lambda e: Coproduct[NotFound, Exception].inr(cast_exception(e.raw)),
         ),
     )

{fluidattacks_gitlab_sdk-4.0.0 → fluidattacks_gitlab_sdk-6.0.0}/fluidattacks_gitlab_sdk/_http_client/_client_1.py

@@ -6,9 +6,6 @@ import logging
 from dataclasses import (
     dataclass,
 )
-from typing import (
-    TypeVar,
-)
 
 from fa_purity import (
     Cmd,
@@ -44,6 +41,7 @@ from pure_requests.retry import (
 )
 
 from ._core import (
+    ChunkedEncodingError,
     Credentials,
     HandledErrors,
     HTTPError,
@@ -51,18 +49,15 @@ from ._core import (
     JSONDecodeError,
     RelativeEndpoint,
     RequestException,
+    RequestsConnectionError,
     UnhandledErrors,
 )
 
 LOG = logging.getLogger(__name__)
 
 
-_S = TypeVar("_S")
-_F = TypeVar("_F")
-
-
-def _retry_cmd(retry: int, item: Result[_S, _F]) -> Cmd[Result[_S, _F]]:
-    log = Cmd.wrap_impure(lambda: LOG.info("retry #%2s waiting...", retry))
+def _retry_cmd[S, F](retry: int, item: Result[S, F]) -> Cmd[Result[S, F]]:
+    log = Cmd[None].wrap_impure(lambda: LOG.info("retry #%2s waiting...", retry))
     return _retry.cmd_if_fail(item, log + _retry.sleep_cmd(retry**2))
 
 
@@ -75,8 +70,21 @@ def _http_error_handler(
         429,
     )
     if err_code in range(500, 600) or err_code in handled:
-        return HandledError.handled(HandledErrors(Coproduct.inl(error)))
-    return HandledError.unhandled(UnhandledErrors(Coproduct.inr(Coproduct.inl(error))))
+        return HandledError[HandledErrors, UnhandledErrors].handled(
+            HandledErrors(
+                Coproduct[
+                    HTTPError,
+                    Coproduct[ChunkedEncodingError, RequestsConnectionError],
+                ].inl(error),
+            ),
+        )
+    return HandledError[HandledErrors, UnhandledErrors].unhandled(
+        UnhandledErrors(
+            Coproduct[JSONDecodeError, Coproduct[HTTPError, RequestException]].inr(
+                Coproduct[HTTPError, RequestException].inl(error),
+            ),
+        ),
+    )
 
 
 def _handled_request_exception(
@@ -84,13 +92,37 @@ def _handled_request_exception(
 ) -> HandledError[HandledErrors, UnhandledErrors]:
     return (
         error.to_chunk_error()
-        .map(lambda e: HandledError.handled(HandledErrors(Coproduct.inr(Coproduct.inl(e)))))
+        .map(
+            lambda e: HandledError[HandledErrors, UnhandledErrors].handled(
+                HandledErrors(
+                    Coproduct[
+                        HTTPError,
+                        Coproduct[ChunkedEncodingError, RequestsConnectionError],
+                    ].inr(Coproduct[ChunkedEncodingError, RequestsConnectionError].inl(e)),
+                ),
+            ),
+        )
         .lash(
             lambda _: error.to_connection_error().map(
-                lambda e: HandledError.handled(HandledErrors(Coproduct.inr(Coproduct.inr(e)))),
+                lambda e: HandledError[HandledErrors, UnhandledErrors].handled(
+                    HandledErrors(
+                        Coproduct[
+                            HTTPError,
+                            Coproduct[ChunkedEncodingError, RequestsConnectionError],
+                        ].inr(Coproduct[ChunkedEncodingError, RequestsConnectionError].inr(e)),
+                    ),
+                ),
+            ),
+        )
+        .value_or(
+            HandledError[HandledErrors, UnhandledErrors].unhandled(
+                UnhandledErrors(
+                    Coproduct[JSONDecodeError, Coproduct[HTTPError, RequestException]].inr(
+                        Coproduct[HTTPError, RequestException].inr(error),
+                    ),
+                ),
             ),
         )
-        .value_or(HandledError.unhandled(UnhandledErrors(Coproduct.inr(Coproduct.inr(error)))))
     )
 
 
@@ -99,7 +131,7 @@ def _handled_errors(
 ) -> HandledError[HandledErrors, UnhandledErrors]:
     """Classify errors."""
     return error.map(
-        lambda _: HandledError.unhandled(UnhandledErrors(error)),
+        lambda _: HandledError[HandledErrors, UnhandledErrors].unhandled(UnhandledErrors(error)),
         lambda c: c.map(
             _http_error_handler,
             _handled_request_exception,
@@ -110,7 +142,11 @@ def _handled_errors(
 def _adjust_unhandled(
     error: UnhandledErrors | MaxRetriesReached,
 ) -> Coproduct[UnhandledErrors, MaxRetriesReached]:
-    return Coproduct.inr(error) if isinstance(error, MaxRetriesReached) else Coproduct.inl(error)
+    return (
+        Coproduct[UnhandledErrors, MaxRetriesReached].inr(error)
+        if isinstance(error, MaxRetriesReached)
+        else Coproduct[UnhandledErrors, MaxRetriesReached].inl(error)
+    )
 
 
 @dataclass(frozen=True)
@@ -149,7 +185,7 @@ class Client1:
         ]
     ]:
         _full = self._full_endpoint(endpoint)
-        log = Cmd.wrap_impure(
+        log = Cmd[None].wrap_impure(
             lambda: LOG.debug(
                 "[API] get: %s\nparams = %s",
                 _full,
@@ -177,7 +213,7 @@ class Client1:
         endpoint: RelativeEndpoint,
     ) -> Cmd[Result[UnitType, Coproduct[UnhandledErrors, MaxRetriesReached]]]:
         _full = self._full_endpoint(endpoint)
-        log = Cmd.wrap_impure(lambda: LOG.info("API call (post): %s", _full))
+        log = Cmd[None].wrap_impure(lambda: LOG.info("API call (post): %s", _full))
         client = HttpClientFactory.new_client(None, self._headers, False)
         handled = log + client.post(
             self._full_endpoint(endpoint),
@@ -185,7 +221,9 @@ class Client1:
             Data(FrozenDict({})),
         ).map(lambda r: r.alt(RequestException)).map(
             lambda r: bind_chain(r, lambda i: response.handle_status(i).alt(HTTPError)).alt(
-                lambda e: _handled_errors(Coproduct.inr(e)),
+                lambda e: _handled_errors(
+                    Coproduct[JSONDecodeError, Coproduct[HTTPError, RequestException]].inr(e),
+                ),
             ),
         )
         return _retry.retry_cmd(