fluidattacks_zoho_sdk 1.0.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

fluidattacks_zoho_sdk/__init__.py

@@ -1,8 +1,6 @@
+from fluidattacks_zoho_sdk._http_client import TokenManager
 from fluidattacks_zoho_sdk.auth import AuthApiFactory, Credentials
 
-__version__ = "1.0.0"
+__version__ = "2.0.0"
 
-__all__ = [
-    "AuthApiFactory",
-    "Credentials",
-]
+__all__ = ["AuthApiFactory", "Credentials", "TokenManager"]

fluidattacks_zoho_sdk/_decoders.py

@@ -1,13 +1,26 @@
+from collections.abc import Callable
+from datetime import UTC, datetime
 from typing import (
     IO,
+    TypeVar,
 )
 
-from fa_purity import Maybe, ResultE, Unsafe
+from fa_purity import (
+    Coproduct,
+    FrozenList,
+    Maybe,
+    PureIterFactory,
+    Result,
+    ResultE,
+    ResultTransform,
+    Unsafe,
+)
 from fa_purity.date_time import DatetimeUTC
 from fa_purity.json import (
     JsonObj,
     JsonPrimitiveUnfolder,
     JsonUnfolder,
+    JsonValueFactory,
     UnfoldedFactory,
     Unfolder,
 )
@@ -27,6 +40,21 @@ from fluidattacks_zoho_sdk.ids import (
     TicketId,
     UserId,
 )
+from fluidattacks_zoho_sdk.zoho_desk.core import OptionalId
+
+_T = TypeVar("_T")
+
+
+def decode_list_objs(
+    items: FrozenList[JsonObj],
+    transaform: Callable[[JsonObj], ResultE[_T]],
+) -> ResultE[FrozenList[_T]]:
+    if not items:
+        return Result.failure(ValueError("Expected a list"))
+
+    return ResultTransform.all_ok(
+        PureIterFactory.from_list(items).map(lambda v: transaform(v)).to_list(),
+    )
 
 
 def _decode_zoho_creds(raw: JsonObj) -> ResultE[Credentials]:
@@ -72,6 +100,31 @@ def decode_optional_date(raw: JsonObj, key: str) -> ResultE[Maybe[DatetimeUTC]]:
     )
 
 
+def decode_datetime_assume_utc(s: str) -> ResultE[Maybe[DatetimeUTC]]:
+    try:
+        if not s or not s.strip():
+            return Result.success(Maybe.empty())
+
+        dt = datetime.strptime(s, "%Y-%m-%d %H:%M:%S").replace(tzinfo=UTC)
+        return DecodeUtils.to_opt_date_time(JsonValueFactory.from_unfolded(str(dt)))
+
+    except ValueError as e:
+        return Result.failure(e)
+
+
+def flatten_decoder_date(
+    y: Result[Maybe[ResultE[Maybe[DatetimeUTC]]], Exception],
+) -> ResultE[Maybe[DatetimeUTC]]:
+    return y.bind(lambda maybe_inner: maybe_inner.value_or(Result.success(Maybe.empty())))
+
+
+def decode_opt_date_to_utc(raw: JsonObj, key: str) -> ResultE[Maybe[DatetimeUTC]]:
+    date = JsonUnfolder.optional(raw, key, DecodeUtils.to_opt_str).map(
+        lambda maybe_str: maybe_str.bind(lambda j: j).map(lambda v: decode_datetime_assume_utc(v)),
+    )
+    return flatten_decoder_date(date)
+
+
 def decode_require_date(raw: JsonObj, key: str) -> ResultE[DatetimeUTC]:
     return JsonUnfolder.require(raw, key, DecodeUtils.to_date_time)
 
@@ -110,68 +163,99 @@ def decode_profile_id(raw: JsonObj) -> ResultE[ProfileId]:
     )
 
 
+def decode_account_id_bulk(raw: JsonObj) -> ResultE[AccountId]:
+    return JsonUnfolder.require(raw, "Account ID", DecodeUtils.to_str).bind(
+        lambda v: Natural.from_int(int(v)).map(AccountId),
+    )
+
+
 def decode_account_id(raw: JsonObj) -> ResultE[AccountId]:
     return (
-        JsonUnfolder.require(raw, "accountId", DecodeUtils.to_str)
+        JsonUnfolder.require(raw, "Account ID", DecodeUtils.to_str)
         .bind(lambda v: Natural.from_int(int(v)))
         .map(AccountId)
     )
 
 
 def decode_crm_id(raw: JsonObj) -> ResultE[CrmId]:
+    return JsonUnfolder.require(raw, "CRM ID", DecodeUtils.to_str).bind(
+        lambda v: Natural.from_int(int(v)).map(CrmId),
+    )
+
+
+def decode_department_id(raw: JsonObj) -> ResultE[DeparmentId]:
     return (
-        JsonUnfolder.require(get_sub_json(raw, "zohoCRMContact"), "id", DecodeUtils.to_str)
+        JsonUnfolder.require(raw, "Department", DecodeUtils.to_str)
         .bind(lambda v: Natural.from_int(int(v)))
-        .map(lambda obj: CrmId(obj))
+        .map(DeparmentId)
     )
 
 
-def decode_deparment_id(raw: JsonObj) -> ResultE[DeparmentId]:
+def decode_department_id_team(raw: JsonObj) -> ResultE[DeparmentId]:
     return (
-        JsonUnfolder.optional(raw, "departmentId", DecodeUtils.to_opt_str)
-        .map(
-            lambda v: v.bind(lambda x: x).map(
-                lambda j: Natural.from_int(int(j)).alt(Unsafe.raise_exception).to_union(),
-            ),
-        )
-        .map(lambda obj: DeparmentId(obj))
+        JsonUnfolder.require(raw, "departmentId", DecodeUtils.to_str)
+        .bind(lambda v: Natural.from_int(int(v)))
+        .map(DeparmentId)
     )
 
 
-def decode_product_id(raw: JsonObj) -> ResultE[ProductId]:
-    return (
-        JsonUnfolder.optional(raw, "productId", DecodeUtils.to_opt_str)
-        .map(
-            lambda v: v.bind(lambda x: x).map(
-                lambda j: Natural.from_int(int(j)).alt(Unsafe.raise_exception).to_union(),
-            ),
-        )
-        .map(lambda obj: ProductId(obj))
+def decode_require_product_id(raw: JsonObj) -> ResultE[ProductId]:
+    return JsonUnfolder.require(raw, "Product ID", DecodeUtils.to_str).bind(
+        lambda v: Natural.from_int(int(v)).map(lambda obj: ProductId(obj)),
     )
 
 
 def decode_team_id(raw: JsonObj) -> ResultE[TeamId]:
-    return JsonUnfolder.require(raw, "teamId", DecodeUtils.to_str).bind(
+    return JsonUnfolder.require(raw, "Team Id", DecodeUtils.to_str).bind(
         lambda v: Natural.from_int(int(v)).map(lambda obj: TeamId(obj)),
     )
 
 
 def decode_ticket_id(raw: JsonObj) -> ResultE[TicketId]:
-    return JsonUnfolder.require(raw, "id", DecodeUtils.to_str).bind(
+    return JsonUnfolder.require(raw, "ID", DecodeUtils.to_str).bind(
         lambda v: Natural.from_int(int(v)).map(lambda obj: TicketId(obj)),
     )
 
 
 def decode_contact_id(raw: JsonObj) -> ResultE[ContactId]:
-    return JsonUnfolder.require(get_sub_json(raw, "contact"), "id", DecodeUtils.to_str).bind(
+    return JsonUnfolder.require(raw, "Contact ID", DecodeUtils.to_str).bind(
+        lambda v: Natural.from_int(int(v)).map(lambda obj: ContactId(obj)),
+    )
+
+
+def decode_contact_id_bulk(raw: JsonObj) -> ResultE[ContactId]:
+    return JsonUnfolder.require(raw, "ID", DecodeUtils.to_str).bind(
         lambda v: Natural.from_int(int(v)).map(lambda obj: ContactId(obj)),
     )
 
 
-def decode_account_id_ticket(raw: JsonObj) -> ResultE[AccountId]:
-    account_obj = get_sub_json(raw, "contact")
-    return JsonUnfolder.require(
-        get_sub_json(account_obj, "account"),
-        "id",
-        DecodeUtils.to_str,
-    ).bind(lambda v: Natural.from_int(int(v)).map(lambda obj: AccountId(obj)))
+def decode_id_team(raw: JsonObj) -> ResultE[TeamId]:
+    return JsonUnfolder.require(raw, "id", DecodeUtils.to_str).bind(
+        lambda v: Natural.from_int(int(v)).map(lambda obj: TeamId(obj)),
+    )
+
+
+def decode_user_id_bulk(raw: JsonObj) -> ResultE[UserId]:
+    return JsonUnfolder.require(raw, "ID", DecodeUtils.to_str).bind(
+        lambda v: Natural.from_int(int(v)).map(UserId),
+    )
+
+
+def decode_optional_id(raw: JsonObj, key: str) -> ResultE[Maybe[OptionalId]]:
+    return JsonUnfolder.optional(raw, key, DecodeUtils.to_opt_str).map(
+        lambda v: v.bind(lambda x: x).map(lambda j: OptionalId(j)),
+    )
+
+
+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")),
+    )
+
+
+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,
+    )

fluidattacks_zoho_sdk/_http_client/__init__.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass
+
+from fluidattacks_zoho_sdk.auth import Credentials
+from fluidattacks_zoho_sdk.ids import OrgId
+
+from ._client import Client
+from ._core import HttpJsonClient, RelativeEndpoint, TokenManager
+
+
+@dataclass(frozen=True)
+class ClientFactory:
+    @staticmethod
+    def new(creds: Credentials, org_id: OrgId, token_manager: TokenManager) -> HttpJsonClient:
+        return Client.new(creds, org_id, token_manager).client
+
+
+__all__ = ["Client", "HttpJsonClient", "RelativeEndpoint", "TokenManager"]

fluidattacks_zoho_sdk/_http_client/_client.py

@@ -0,0 +1,348 @@
+from __future__ import (
+    annotations,
+)
+
+import logging
+from collections.abc import Callable
+from dataclasses import (
+    dataclass,
+)
+from typing import (
+    TypeVar,
+)
+
+from fa_purity import Cmd, Coproduct, FrozenDict, FrozenList, Maybe, Result, UnitType
+from fa_purity.json import JsonObj, JsonPrimitiveFactory, JsonUnfolder, JsonValue
+from fluidattacks_etl_utils.decode import int_to_str
+from fluidattacks_etl_utils.smash import bind_chain
+from pure_requests import (
+    response,
+)
+from pure_requests import (
+    retry as _retry,
+)
+from pure_requests.basic import Data, Endpoint, HttpClient, HttpClientFactory, Params
+from pure_requests.retry import (
+    HandledError,
+    MaxRetriesReached,
+)
+from requests import Response
+
+from fluidattacks_zoho_sdk.auth import AuthApiFactory, Credentials, Token
+from fluidattacks_zoho_sdk.ids import OrgId
+
+from ._core import (
+    HandledErrors,
+    HTTPError,
+    HttpJsonClient,
+    JSONDecodeError,
+    RelativeEndpoint,
+    RequestException,
+    TokenManager,
+    UnhandledErrors,
+)
+
+LOG = logging.getLogger(__name__)
+
+_S = TypeVar("_S")
+_F = TypeVar("_F")
+HTTP_UNAUTHORIZED: int = 401
+
+
+def _refresh_access_token(creds: Credentials) -> Cmd[Token]:
+    return AuthApiFactory.auth_api(creds).new_access_token
+
+
+def _is_404(error: Maybe[HTTPError]) -> tuple[bool, int]:
+    status: int = error.map(
+        lambda v: v.raw.response.status_code,  # type: ignore[misc]
+    ).value_or(0)
+    status_is_404: bool = (
+        error.map(lambda e: e.raw.response.status_code == HTTP_UNAUTHORIZED).value_or(False)  # type: ignore[misc]
+    )
+    return (status_is_404, status)
+
+
+def _extract_http_error(error: HandledError[HandledErrors, UnhandledErrors]) -> Maybe[HTTPError]:
+    return error.value.map(
+        lambda handled: handled.error.map(
+            lambda http_err: Maybe.some(http_err),
+            lambda _: Maybe.empty(),
+        ),
+        lambda _: Maybe.empty(),
+    )
+
+
+def _retry_cmd(
+    retry: int,
+    item: Result[_S, _F],
+    client_zoho: Client,
+    make_request: Callable[[HttpClient], Cmd[Result[_S, _F]]],
+) -> Cmd[Result[_S, _F]]:
+    def handle_401(error: _F) -> Cmd[Result[_S, _F]]:
+        is_401 = _is_404(_extract_http_error(error))  # type: ignore[arg-type]
+        if is_401[0]:
+            return Cmd.wrap_impure(lambda: LOG.info("Refreshing token...")) + _refresh_access_token(
+                client_zoho.creds,
+            ).bind(
+                lambda new_token: client_zoho.update_token(new_token),
+            ).bind(
+                lambda _: client_zoho.build_headers()
+                .map(
+                    lambda headers: HttpClientFactory.new_client(
+                        None,
+                        headers,
+                        False,
+                    ),  # HttpClient
+                )
+                .bind(make_request),
+            )
+
+        log = Cmd.wrap_impure(
+            lambda: LOG.info(
+                "retry #%2s waiting... ",
+                retry,
+            ),
+        )
+        return _retry.cmd_if_fail(item, log + _retry.sleep_cmd(retry**2))
+
+    return item.map(lambda _: Cmd.wrap_value(item)).alt(handle_401).to_union()
+
+
+def _http_error_handler(
+    error: HTTPError,
+) -> HandledError[HandledErrors, UnhandledErrors]:
+    err_code: int = error.raw.response.status_code  # type: ignore[misc]
+    handled = (
+        401,
+        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))))
+
+
+def _handled_request_exception(
+    error: RequestException,
+) -> HandledError[HandledErrors, UnhandledErrors]:
+    return (
+        error.to_chunk_error()
+        .map(lambda e: HandledError.handled(HandledErrors(Coproduct.inr(Coproduct.inl(e)))))
+        .lash(
+            lambda _: error.to_connection_error().map(
+                lambda e: HandledError.handled(HandledErrors(Coproduct.inr(Coproduct.inr(e)))),
+            ),
+        )
+        .value_or(HandledError.unhandled(UnhandledErrors(Coproduct.inr(Coproduct.inr(error)))))
+    )
+
+
+def _handled_errors(
+    error: Coproduct[JSONDecodeError, Coproduct[HTTPError, RequestException]],
+) -> HandledError[HandledErrors, UnhandledErrors]:
+    """Classify errors."""
+    return error.map(
+        lambda _: HandledError.unhandled(UnhandledErrors(error)),
+        lambda c: c.map(
+            _http_error_handler,
+            _handled_request_exception,
+        ),
+    )
+
+
+def _handled_errors_response(
+    error: Coproduct[HTTPError, RequestException],
+) -> HandledError[HandledErrors, UnhandledErrors]:
+    return error.map(
+        _http_error_handler,
+        _handled_request_exception,
+    )
+
+
+def _adjust_unhandled(
+    error: UnhandledErrors | MaxRetriesReached,
+) -> Coproduct[UnhandledErrors, MaxRetriesReached]:
+    return Coproduct.inr(error) if isinstance(error, MaxRetriesReached) else Coproduct.inl(error)
+
+
+@dataclass(frozen=True)
+class Client:
+    _creds: Credentials
+    _max_retries: int
+    _org_id: OrgId
+    _token: TokenManager
+
+    def _full_endpoint(self, endpoint: RelativeEndpoint) -> Endpoint:
+        return Endpoint("/".join(("https://desk.zoho.com/api/v1", *endpoint.paths)))
+
+    @staticmethod
+    def new(creds: Credentials, org_id: OrgId, token: TokenManager) -> Client:
+        return Client(creds, 3, org_id, token)
+
+    def _headers(self, access_token: Token) -> JsonObj:
+        return FrozenDict(
+            {
+                "orgId": JsonValue.from_primitive(
+                    JsonPrimitiveFactory.from_raw(int_to_str(self._org_id.org_id.value)),
+                ),
+                "Authorization": JsonValue.from_primitive(
+                    JsonPrimitiveFactory.from_raw(f"Zoho-oauthtoken {access_token.raw_token}"),
+                ),
+            },
+        )
+
+    def get(
+        self,
+        endpoint: RelativeEndpoint,
+        params: JsonObj,
+    ) -> Cmd[
+        Result[
+            Coproduct[JsonObj, FrozenList[JsonObj]],
+            Coproduct[UnhandledErrors, MaxRetriesReached],
+        ]
+    ]:
+        _full = self._full_endpoint(endpoint)
+        log = Cmd.wrap_impure(
+            lambda: LOG.info("[API] get: %s\nparams = %s", _full, JsonUnfolder.dumps(params)),
+        )
+
+        token_manager_cmd = self._token.get
+        client_cmd = token_manager_cmd.map(
+            lambda token: HttpClientFactory.new_client(None, self._headers(token), False),
+        )
+
+        def make_request(
+            new_client: HttpClient,
+        ) -> Cmd[
+            Result[
+                Coproduct[JsonObj, FrozenList[JsonObj]],
+                HandledError[HandledErrors, UnhandledErrors],
+            ]
+        ]:
+            return (
+                new_client.get(_full, Params(params))
+                .map(lambda r: r.alt(RequestException))
+                .map(lambda r: bind_chain(r, lambda i: response.handle_status(i).alt(HTTPError)))
+                .map(
+                    lambda r: bind_chain(
+                        r,
+                        lambda i: response.json_decode(i).alt(JSONDecodeError),
+                    ).alt(_handled_errors),
+                )
+            )
+
+        handled = log + client_cmd.bind(make_request)
+
+        return _retry.retry_cmd(
+            handled,
+            lambda retry, item: _retry_cmd(retry, item, self, make_request),
+            self._max_retries,
+        ).map(lambda r: r.alt(_adjust_unhandled))
+
+    def post(
+        self,
+        endpoint: RelativeEndpoint,
+        params: JsonObj,
+    ) -> Cmd[
+        Result[
+            Coproduct[JsonObj, FrozenList[JsonObj]],
+            Coproduct[UnhandledErrors, MaxRetriesReached],
+        ]
+    ]:
+        _full = self._full_endpoint(endpoint)
+        log = Cmd.wrap_impure(lambda: LOG.info("[API] call (post): %s", _full))
+
+        client_cmd = self._token.get.map(
+            lambda t: HttpClientFactory.new_client(
+                None,
+                self._headers(t),
+                False,
+            ),
+        )
+
+        def make_request(
+            new_client: HttpClient,
+        ) -> Cmd[
+            Result[
+                Coproduct[JsonObj, FrozenList[JsonObj]],
+                HandledError[HandledErrors, UnhandledErrors],
+            ]
+        ]:
+            return (
+                new_client.post(
+                    _full,
+                    Params(FrozenDict({})),
+                    Data(params),
+                )
+                .map(lambda r: r.alt(RequestException))
+                .map(lambda r: bind_chain(r, lambda i: response.handle_status(i).alt(HTTPError)))
+                .map(
+                    lambda r: bind_chain(
+                        r,
+                        lambda i: response.json_decode(i).alt(JSONDecodeError),
+                    ).alt(_handled_errors),
+                )
+            )
+
+        handled = log + client_cmd.bind(make_request)
+
+        return _retry.retry_cmd(
+            handled,
+            lambda retry, item: _retry_cmd(retry, item, self, make_request),
+            self._max_retries,
+        ).map(lambda r: r.alt(_adjust_unhandled))
+
+    def get_response(
+        self,
+        endpoint: RelativeEndpoint,
+        params: JsonObj,
+    ) -> Cmd[Result[Response, Coproduct[UnhandledErrors, MaxRetriesReached]]]:
+        _full = self._full_endpoint(endpoint)
+        log = Cmd.wrap_impure(
+            lambda: LOG.info("[API] get: %s\nparams = %s", _full, JsonUnfolder.dumps(params)),
+        )
+
+        client_cmd = self._token.get.map(
+            lambda t: HttpClientFactory.new_client(
+                None,
+                self._headers(t),
+                False,
+            ),
+        )
+
+        def make_request(
+            new_client: HttpClient,
+        ) -> Cmd[
+            Result[
+                Response,
+                HandledError[HandledErrors, UnhandledErrors],
+            ]
+        ]:
+            return (
+                new_client.get(_full, Params(params))
+                .map(lambda r: r.alt(RequestException))
+                .map(lambda r: bind_chain(r, lambda i: response.handle_status(i).alt(HTTPError)))
+                .map(lambda r: r.alt(_handled_errors_response))
+            )
+
+        handled = log + client_cmd.bind(make_request)
+
+        return _retry.retry_cmd(
+            handled,
+            lambda retry, item: _retry_cmd(retry, item, self, make_request),
+            self._max_retries,
+        ).map(lambda r: r.alt(_adjust_unhandled))
+
+    @property
+    def client(self) -> HttpJsonClient:
+        return HttpJsonClient(self.get, self.post, self.get_response)
+
+    @property
+    def creds(self) -> Credentials:
+        return self._creds
+
+    def build_headers(self) -> Cmd[JsonObj]:
+        return self._token.get.map(lambda t: self._headers(t))
+
+    def update_token(self, new_token: Token) -> Cmd[UnitType]:
+        return self._token.update(new_token)