fluidattacks_refiner_sdk 0.1.1__py3-none-any.whl

fluidattacks_refiner_sdk/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.1"

fluidattacks_refiner_sdk/auth/__init__.py

@@ -0,0 +1,7 @@
+from ._core import (
+    Credentials,
+)
+
+__all__ = [
+    "Credentials",
+]

fluidattacks_refiner_sdk/auth/_core.py

@@ -0,0 +1,9 @@
+from dataclasses import (
+    dataclass,
+    field,
+)
+
+
+@dataclass(frozen=True)
+class Credentials:
+    api_key: str = field(repr=False)

fluidattacks_refiner_sdk/client/__init__.py

@@ -0,0 +1,33 @@
+from logging import (
+    Logger,
+)
+
+from fluidattacks_refiner_sdk.auth import (
+    Credentials,
+)
+from fluidattacks_refiner_sdk.client._get_contacts import (
+    get_contacts,
+)
+from fluidattacks_refiner_sdk.client._get_forms import (
+    get_forms,
+)
+from fluidattacks_refiner_sdk.client._get_reporting import (
+    get_nps_metrics,
+)
+from fluidattacks_refiner_sdk.client._get_responses import (
+    get_responses,
+)
+from fluidattacks_refiner_sdk.core import (
+    ApiClient,
+)
+
+__all__ = ["new_api_client"]
+
+
+def new_api_client(log: Logger, creds: Credentials) -> ApiClient:
+    return ApiClient(
+        get_forms=get_forms(log, creds),
+        get_responses=lambda form_id: get_responses(log, creds, form_id),
+        get_contacts=get_contacts(log, creds),
+        get_nps_metrics=get_nps_metrics(log, creds),
+    )

fluidattacks_refiner_sdk/client/_common.py

@@ -0,0 +1,123 @@
+import inspect
+import logging
+from collections.abc import (
+    Callable,
+)
+from dataclasses import (
+    dataclass,
+)
+from typing import (
+    Generic,
+    TypeVar,
+)
+
+from fa_purity import (
+    Cmd,
+    FrozenList,
+    Maybe,
+    Result,
+    ResultE,
+    cast_exception,
+)
+from fa_purity.json import (
+    JsonObj,
+    JsonPrimitiveUnfolder,
+    JsonUnfolder,
+    Unfolder,
+)
+from fluidattacks_etl_utils.bug import (
+    Bug,
+)
+from pure_requests.response import handle_status
+from pure_requests.retry import HandledErrorFactory, cmd_if_fail, retry_cmd, sleep_cmd
+from requests import HTTPError, RequestException, Response
+
+_T = TypeVar("_T")
+LOG = logging.getLogger(__name__)
+_HTTP_5XX_START = 500
+_HTTP_5XX_END = 600
+
+
+@dataclass(frozen=True)
+class DataPage(Generic[_T]):
+    items: FrozenList[_T]
+    next_cursor: Maybe[str]
+
+
+def decode_items(
+    raw: JsonObj,
+    decode: Callable[[JsonObj], ResultE[_T]],
+) -> ResultE[FrozenList[_T]]:
+    return JsonUnfolder.require(
+        raw,
+        "items",
+        lambda v: Unfolder.to_list_of(v, lambda j: Unfolder.to_json(j).bind(decode)),
+    ).alt(
+        lambda e: Bug[Exception].new(
+            "decode_items",
+            inspect.currentframe(),
+            e,
+            (JsonUnfolder.dumps(raw),),
+        ),
+    )
+
+
+def decode_next_cursor(raw: JsonObj) -> ResultE[Maybe[str]]:
+    return JsonUnfolder.require(
+        raw,
+        "pagination",
+        lambda v: Unfolder.to_json(v).bind(
+            lambda pag: JsonUnfolder.optional(
+                pag,
+                "next_page_cursor",
+                lambda vv: Unfolder.to_primitive(vv).bind(JsonPrimitiveUnfolder.to_str),
+            ),
+        ),
+    )
+
+
+def decode_page(
+    raw: JsonObj,
+    decode: Callable[[JsonObj], ResultE[_T]],
+) -> ResultE[DataPage[_T]]:
+    items = decode_items(raw, decode)
+    cursor = decode_next_cursor(raw)
+    return items.bind(lambda i: cursor.map(lambda c: DataPage(i, c))).alt(
+        lambda e: Bug[Exception].new(
+            "decode_page",
+            inspect.currentframe(),
+            e,
+            (JsonUnfolder.dumps(raw),),
+        ),
+    )
+
+
+def with_retry_handler(
+    raw_page: Cmd[Result[Response, RequestException]],
+    retries: int,
+) -> Cmd[ResultE[Response]]:
+    error_factory: HandledErrorFactory[HTTPError, Exception] = HandledErrorFactory()
+    handled_get_page = raw_page.map(
+        lambda r: (
+            r.alt(cast_exception)
+            .alt(error_factory.unhandled)
+            .bind(
+                lambda r: handle_status(r).alt(
+                    lambda e: (
+                        error_factory.handled(e)
+                        if e.errno and e.errno >= _HTTP_5XX_START and e.errno < _HTTP_5XX_END
+                        else error_factory.unhandled(cast_exception(e))
+                    ),
+                ),
+            )
+        ),
+    )
+    return retry_cmd(
+        handled_get_page,
+        lambda i, r: cmd_if_fail(
+            r,
+            Cmd[None].wrap_impure(lambda: LOG.info("Error handled i.e. %s", r))
+            + sleep_cmd(10 + 60 * (i - 1)),
+        ),
+        retries,
+    )

fluidattacks_refiner_sdk/client/_get_contacts.py

@@ -0,0 +1,212 @@
+import inspect
+import logging
+from logging import (
+    Logger,
+)
+
+from dateutil.parser import parse as parse_dt
+from fa_purity import (
+    Cmd,
+    FrozenDict,
+    FrozenList,
+    Maybe,
+    Result,
+    ResultE,
+    ResultSmash,
+    Stream,
+    cast_exception,
+)
+from fa_purity.json import (
+    JsonObj,
+    JsonPrimitive,
+    JsonPrimitiveUnfolder,
+    JsonUnfolder,
+    JsonValue,
+    UnfoldedFactory,
+    Unfolder,
+)
+from fluidattacks_etl_utils.bug import (
+    Bug,
+)
+from fluidattacks_etl_utils.paginate import (
+    cursor_pagination,
+)
+from pure_requests.basic import (
+    HttpClient,
+    HttpClientFactory,
+    Params,
+)
+from pure_requests.response import (
+    json_decode,
+)
+from requests import (
+    Response,
+)
+
+from fluidattacks_refiner_sdk.auth import (
+    Credentials,
+)
+from fluidattacks_refiner_sdk.client._common import (
+    DataPage,
+    decode_items,
+    decode_next_cursor,
+    with_retry_handler,
+)
+from fluidattacks_refiner_sdk.core import (
+    Account,
+    AccountDomain,
+    AccountId,
+    ContactId,
+    Person,
+    relative_endpoint,
+)
+
+LOG = logging.getLogger(__name__)
+
+_MAX_PAGE_LENGTH = 1000
+
+
+def _iso_to_unix(iso: str) -> ResultE[int]:
+    try:
+        return Result[int, Exception].success(int(parse_dt(iso).timestamp()))
+    except (ValueError, OverflowError) as e:
+        return Result[int, Exception].failure(e)
+
+
+def _decode_account_obj(obj: JsonObj) -> ResultE[Account]:
+    acc_id = JsonUnfolder.require(
+        obj,
+        "uuid",
+        lambda vv: Unfolder.to_primitive(vv).bind(JsonPrimitiveUnfolder.to_str),
+    ).map(AccountId)
+    remote_id = JsonUnfolder.optional(
+        obj,
+        "remote_id",
+        lambda vv: Unfolder.to_primitive(vv).bind(JsonPrimitiveUnfolder.to_str),
+    )
+    display_name = JsonUnfolder.optional(
+        obj,
+        "display_name",
+        lambda vv: Unfolder.to_primitive(vv).bind(JsonPrimitiveUnfolder.to_str),
+    )
+    domain = JsonUnfolder.optional(
+        obj,
+        "domain",
+        lambda vv: Unfolder.to_primitive(vv).bind(JsonPrimitiveUnfolder.to_str),
+    ).map(lambda m: m.map(AccountDomain))
+    return ResultSmash.smash_result_4(acc_id, remote_id, display_name, domain).map(
+        lambda t: Account(*t),
+    )
+
+
+def _decode_account(raw: JsonObj) -> ResultE[Maybe[Account]]:
+    return JsonUnfolder.optional(
+        raw,
+        "account",
+        lambda v: Unfolder.to_json(v).bind(_decode_account_obj),
+    )
+
+
+def _decode_person(raw: JsonObj) -> ResultE[Person]:
+    contact_id = JsonUnfolder.require(
+        raw,
+        "uuid",
+        lambda v: Unfolder.to_primitive(v).bind(JsonPrimitiveUnfolder.to_str),
+    ).map(ContactId)
+    remote_id = JsonUnfolder.optional(
+        raw,
+        "remote_id",
+        lambda v: Unfolder.to_primitive(v).bind(JsonPrimitiveUnfolder.to_str),
+    )
+    email = JsonUnfolder.optional(
+        raw,
+        "email",
+        lambda v: Unfolder.to_primitive(v).bind(JsonPrimitiveUnfolder.to_str),
+    )
+    display_name = JsonUnfolder.optional(
+        raw,
+        "display_name",
+        lambda v: Unfolder.to_primitive(v).bind(JsonPrimitiveUnfolder.to_str),
+    )
+    first_seen_at = JsonUnfolder.optional(
+        raw,
+        "first_seen_at",
+        lambda v: Unfolder.to_primitive(v).bind(JsonPrimitiveUnfolder.to_str).bind(_iso_to_unix),
+    )
+    last_seen_at = JsonUnfolder.optional(
+        raw,
+        "last_seen_at",
+        lambda v: Unfolder.to_primitive(v).bind(JsonPrimitiveUnfolder.to_str).bind(_iso_to_unix),
+    )
+    account = _decode_account(raw)
+    group_1 = ResultSmash.smash_result_4(contact_id, remote_id, email, display_name)
+    group_2 = ResultSmash.smash_result_3(first_seen_at, last_seen_at, account)
+    return ResultSmash.smash_result_2(group_1, group_2).map(
+        lambda t: Person(*t[0], *t[1]),
+    )
+
+
+def _decode_json_response(resp: Response) -> ResultE[DataPage[Person]]:
+    return (
+        json_decode(resp)
+        .alt(cast_exception)
+        .bind(
+            lambda c: c.map(
+                lambda obj: decode_items(obj, _decode_person).bind(
+                    lambda items: decode_next_cursor(obj).map(
+                        lambda cursor: DataPage(items, cursor),
+                    ),
+                ),
+                lambda lst: Result[DataPage[Person], Exception].failure(
+                    Bug[Exception].new(
+                        "_decode_json_response",
+                        inspect.currentframe(),
+                        ValueError(f"Expected json object but got list: {lst!r}"),
+                        (),
+                    ),
+                ),
+            ),
+        )
+    )
+
+
+def _get_contacts_page(
+    log: Logger,
+    client: HttpClient,
+    cursor: Maybe[str],
+) -> Cmd[tuple[FrozenList[Person], Maybe[str]]]:
+    params: dict[str, JsonValue] = {
+        "page_length": JsonValue.from_primitive(JsonPrimitive.from_int(_MAX_PAGE_LENGTH)),
+    }
+    cursor_params = cursor.map(
+        lambda c: {
+            "page_cursor": JsonValue.from_primitive(JsonPrimitive.from_str(c)),
+        },
+    ).value_or(dict[str, JsonValue]())
+    get_response = client.get(
+        relative_endpoint("v1/contacts"),
+        Params(FrozenDict({**params, **cursor_params})),
+    )
+    return Cmd[None].wrap_impure(
+        lambda: log.info("API: get_contacts_page()"),
+    ) + with_retry_handler(get_response, 3).map(
+        lambda r: r.bind(_decode_json_response),
+    ).map(
+        lambda r: Bug[DataPage[Person]].assume_success(
+            "_get_contacts_page",
+            inspect.currentframe(),
+            (),
+            r,
+        ),
+    ).map(
+        lambda page: (page.items, page.next_cursor),
+    )
+
+
+def get_contacts(
+    log: Logger,
+    creds: Credentials,
+) -> Stream[FrozenList[Person]]:
+    headers = UnfoldedFactory.from_dict({"Authorization": " ".join(["Bearer", creds.api_key])})
+    client = HttpClientFactory.new_client(None, headers, None)
+    return cursor_pagination(lambda cursor: _get_contacts_page(log, client, cursor))

fluidattacks_refiner_sdk/client/_get_forms.py

@@ -0,0 +1,144 @@
+import inspect
+import logging
+from logging import (
+    Logger,
+)
+
+from fa_purity import (
+    Cmd,
+    FrozenDict,
+    FrozenList,
+    Maybe,
+    Result,
+    ResultE,
+    Stream,
+    cast_exception,
+)
+from fa_purity.json import (
+    JsonObj,
+    JsonPrimitive,
+    JsonPrimitiveUnfolder,
+    JsonUnfolder,
+    JsonValue,
+    UnfoldedFactory,
+    Unfolder,
+)
+from fluidattacks_etl_utils.bug import (
+    Bug,
+)
+from fluidattacks_etl_utils.paginate import (
+    cursor_pagination,
+)
+from pure_requests.basic import (
+    HttpClient,
+    HttpClientFactory,
+    Params,
+)
+from pure_requests.response import (
+    json_decode,
+)
+from requests import (
+    Response,
+)
+
+from fluidattacks_refiner_sdk.auth import (
+    Credentials,
+)
+from fluidattacks_refiner_sdk.client._common import (
+    DataPage,
+    decode_items,
+    decode_next_cursor,
+    with_retry_handler,
+)
+from fluidattacks_refiner_sdk.core import (
+    Form,
+    FormId,
+    FormName,
+    relative_endpoint,
+)
+
+LOG = logging.getLogger(__name__)
+
+
+def _decode_form(raw: JsonObj) -> ResultE[Form]:
+    form_id = JsonUnfolder.require(
+        raw,
+        "uuid",
+        lambda v: Unfolder.to_primitive(v).bind(JsonPrimitiveUnfolder.to_str),
+    )
+    name = JsonUnfolder.require(
+        raw,
+        "name",
+        lambda v: Unfolder.to_primitive(v).bind(JsonPrimitiveUnfolder.to_str),
+    )
+    return form_id.bind(
+        lambda fid: name.map(
+            lambda n: Form(id=FormId(fid), name=FormName(n)),
+        ),
+    )
+
+
+def _decode_json_response(resp: Response) -> ResultE[DataPage[Form]]:
+    return (
+        json_decode(resp)
+        .alt(cast_exception)
+        .bind(
+            lambda c: c.map(
+                lambda obj: decode_items(obj, _decode_form).bind(
+                    lambda items: decode_next_cursor(obj).map(
+                        lambda cursor: DataPage(items, cursor),
+                    ),
+                ),
+                lambda _: Result[DataPage[Form], Exception].failure(
+                    Bug[Exception].new(
+                        "_decode_json_response",
+                        inspect.currentframe(),
+                        ValueError("Expected json object but got list"),
+                        (),
+                    ),
+                ),
+            ),
+        )
+    )
+
+
+def _get_forms_page(
+    log: Logger,
+    client: HttpClient,
+    cursor: Maybe[str],
+) -> Cmd[tuple[FrozenList[Form], Maybe[str]]]:
+    params: dict[str, JsonValue] = {
+        "page_length": JsonValue.from_primitive(JsonPrimitive.from_int(100)),
+    }
+    cursor_params = cursor.map(
+        lambda c: {
+            "page_cursor": JsonValue.from_primitive(JsonPrimitive.from_str(c)),
+        },
+    ).value_or(dict[str, JsonValue]())
+    get_response = client.get(
+        relative_endpoint("v1/forms"),
+        Params(FrozenDict({**params, **cursor_params})),
+    )
+    return Cmd[None].wrap_impure(
+        lambda: log.info("API: get_forms_page()"),
+    ) + with_retry_handler(get_response, 3).map(
+        lambda r: r.bind(_decode_json_response),
+    ).map(
+        lambda r: Bug[DataPage[Form]].assume_success(
+            "_get_forms_page",
+            inspect.currentframe(),
+            (),
+            r,
+        ),
+    ).map(
+        lambda page: (page.items, page.next_cursor),
+    )
+
+
+def get_forms(
+    log: Logger,
+    creds: Credentials,
+) -> Stream[FrozenList[Form]]:
+    headers = UnfoldedFactory.from_dict({"Authorization": " ".join(["Bearer", creds.api_key])})
+    client = HttpClientFactory.new_client(None, headers, None)
+    return cursor_pagination(lambda cursor: _get_forms_page(log, client, cursor))

fluidattacks_refiner_sdk/client/_get_reporting.py

@@ -0,0 +1,140 @@
+import inspect
+import logging
+from logging import (
+    Logger,
+)
+
+from fa_purity import (
+    Cmd,
+    FrozenDict,
+    FrozenList,
+    Result,
+    ResultE,
+    cast_exception,
+)
+from fa_purity.json import (
+    JsonObj,
+    JsonPrimitive,
+    JsonPrimitiveUnfolder,
+    JsonUnfolder,
+    JsonValue,
+    UnfoldedFactory,
+    Unfolder,
+)
+from fluidattacks_etl_utils.bug import (
+    Bug,
+)
+from pure_requests.basic import (
+    HttpClientFactory,
+    Params,
+)
+from pure_requests.response import (
+    json_decode,
+)
+from requests import (
+    Response,
+)
+
+from fluidattacks_refiner_sdk.auth import (
+    Credentials,
+)
+from fluidattacks_refiner_sdk.client._common import (
+    with_retry_handler,
+)
+from fluidattacks_refiner_sdk.core import (
+    NpsMetrics,
+    relative_endpoint,
+)
+
+LOG = logging.getLogger(__name__)
+
+
+def _decode_count(obj: JsonObj, key: str) -> ResultE[int]:
+    return JsonUnfolder.require(
+        obj,
+        key,
+        lambda v: Unfolder.to_primitive(v).bind(
+            lambda p: JsonPrimitiveUnfolder.to_int(p).lash(
+                lambda _: JsonPrimitiveUnfolder.to_float(p).map(int),
+            ),
+        ),
+    )
+
+
+def _decode_nps_obj(obj: JsonObj) -> ResultE[NpsMetrics]:
+    nps = JsonUnfolder.require(
+        obj,
+        "nps",
+        lambda v: Unfolder.to_primitive(v).bind(
+            lambda p: JsonPrimitiveUnfolder.to_int(p).lash(
+                lambda _: JsonPrimitiveUnfolder.to_float(p).map(int),
+            ),
+        ),
+    )
+    count = _decode_count(obj, "count")
+    data_obj = JsonUnfolder.require(obj, "data", Unfolder.to_json)
+    promoters_count = data_obj.bind(lambda d: _decode_count(d, "promoters"))
+    passives_count = data_obj.bind(lambda d: _decode_count(d, "passives"))
+    detractors_count = data_obj.bind(lambda d: _decode_count(d, "detractors"))
+    return nps.bind(
+        lambda n: count.bind(
+            lambda c: promoters_count.bind(
+                lambda pc: passives_count.bind(
+                    lambda pac: detractors_count.map(
+                        lambda dc: NpsMetrics(
+                            nps=n,
+                            promoter_count=pc,
+                            promoter_percent=pc / c * 100 if c else 0.0,
+                            passive_count=pac,
+                            passive_percent=pac / c * 100 if c else 0.0,
+                            detractor_count=dc,
+                            detractor_percent=dc / c * 100 if c else 0.0,
+                            response_count=c,
+                        ),
+                    ),
+                ),
+            ),
+        ),
+    )
+
+
+def _decode_nps_metrics(resp: Response) -> ResultE[NpsMetrics]:
+    def _decode_list(lst: FrozenList[JsonObj]) -> ResultE[NpsMetrics]:
+        if not lst:
+            return Result[NpsMetrics, Exception].failure(ValueError("Empty NPS metrics response"))
+        return _decode_nps_obj(lst[0])
+
+    return (
+        json_decode(resp).alt(cast_exception).bind(lambda c: c.map(_decode_nps_obj, _decode_list))
+    )
+
+
+def get_nps_metrics(
+    log: Logger,
+    creds: Credentials,
+) -> Cmd[NpsMetrics]:
+    headers = UnfoldedFactory.from_dict({"Authorization": " ".join(["Bearer", creds.api_key])})
+    client = HttpClientFactory.new_client(None, headers, None)
+    get_response = client.get(
+        relative_endpoint("v1/reporting"),
+        Params(
+            FrozenDict(
+                {
+                    "type": JsonValue.from_primitive(JsonPrimitive.from_str("nps")),
+                },
+            ),
+        ),
+    )
+    return Cmd[None].wrap_impure(lambda: log.info("API: get_nps_metrics()")) + with_retry_handler(
+        get_response,
+        3,
+    ).map(
+        lambda r: r.bind(_decode_nps_metrics),
+    ).map(
+        lambda r: Bug[NpsMetrics].assume_success(
+            "get_nps_metrics",
+            inspect.currentframe(),
+            (),
+            r,
+        ),
+    )

fluidattacks_refiner_sdk/client/_get_responses.py

@@ -0,0 +1,289 @@
+import inspect
+import logging
+from logging import (
+    Logger,
+)
+
+from dateutil.parser import parse as parse_dt
+from fa_purity import (
+    Cmd,
+    FrozenDict,
+    FrozenList,
+    Maybe,
+    Result,
+    ResultE,
+    ResultSmash,
+    Stream,
+    cast_exception,
+)
+from fa_purity.json import (
+    JsonObj,
+    JsonPrimitive,
+    JsonPrimitiveUnfolder,
+    JsonUnfolder,
+    JsonValue,
+    UnfoldedFactory,
+    Unfolder,
+)
+from fluidattacks_etl_utils.bug import (
+    Bug,
+)
+from fluidattacks_etl_utils.paginate import (
+    cursor_pagination,
+)
+from pure_requests.basic import (
+    HttpClient,
+    HttpClientFactory,
+    Params,
+)
+from pure_requests.response import (
+    json_decode,
+)
+from requests import (
+    Response,
+)
+
+from fluidattacks_refiner_sdk.auth import (
+    Credentials,
+)
+from fluidattacks_refiner_sdk.client._common import (
+    DataPage,
+    decode_items,
+    decode_next_cursor,
+    with_retry_handler,
+)
+from fluidattacks_refiner_sdk.core import (
+    Account,
+    AccountDomain,
+    AccountId,
+    Contact,
+    ContactId,
+    FormId,
+    FormName,
+    ResponseId,
+    SurveyResponse,
+    relative_endpoint,
+)
+
+LOG = logging.getLogger(__name__)
+
+_MAX_PAGE_LENGTH = 1000
+
+
+def _iso_to_unix(iso: str) -> ResultE[int]:
+    try:
+        return Result[int, Exception].success(int(parse_dt(iso).timestamp()))
+    except (ValueError, OverflowError) as e:
+        return Result[int, Exception].failure(e)
+
+
+def _decode_int_value(v: JsonValue) -> ResultE[int]:
+    return Unfolder.to_primitive(v).bind(JsonPrimitiveUnfolder.to_int)
+
+
+def _decode_str_value(v: JsonValue) -> ResultE[str]:
+    return Unfolder.to_primitive(v).bind(JsonPrimitiveUnfolder.to_str)
+
+
+def _decode_account_obj(obj: JsonObj) -> ResultE[Account]:
+    return JsonUnfolder.require(
+        obj,
+        "uuid",
+        lambda vv: Unfolder.to_primitive(vv).bind(JsonPrimitiveUnfolder.to_str),
+    ).map(
+        lambda acc_id: Account(
+            id=AccountId(acc_id),
+            remote_id=Maybe[str].empty(),
+            display_name=Maybe[str].empty(),
+            domain=Maybe[AccountDomain].empty(),
+        ),
+    )
+
+
+def _decode_account(raw: JsonObj) -> ResultE[Maybe[Account]]:
+    return JsonUnfolder.optional(
+        raw,
+        "account",
+        lambda v: Unfolder.to_json(v).bind(_decode_account_obj),
+    )
+
+
+def _decode_contact(raw: JsonObj) -> ResultE[Contact]:
+    contact_id = JsonUnfolder.require(
+        raw,
+        "uuid",
+        lambda v: Unfolder.to_primitive(v).bind(JsonPrimitiveUnfolder.to_str),
+    ).map(ContactId)
+    email = JsonUnfolder.optional(
+        raw,
+        "email",
+        lambda v: Unfolder.to_primitive(v).bind(JsonPrimitiveUnfolder.to_str),
+    )
+    display_name = JsonUnfolder.optional(
+        raw,
+        "display_name",
+        lambda v: Unfolder.to_primitive(v).bind(JsonPrimitiveUnfolder.to_str),
+    )
+    account = _decode_account(raw)
+    return ResultSmash.smash_result_4(contact_id, email, display_name, account).map(
+        lambda t: Contact(*t),
+    )
+
+
+def _find_nps_score(data: JsonObj) -> Maybe[int]:
+    for key in ("nps", "NPS", "score", "nps_score"):
+        found: Maybe[int] = JsonUnfolder.optional(
+            data,
+            key,
+            _decode_int_value,
+        ).value_or(Maybe[int].empty())
+        if found != Maybe[int].empty():
+            return found
+    return Maybe[int].empty()
+
+
+def _find_comment(data: JsonObj) -> Maybe[str]:
+    for key in ("comment", "feedback", "message", "text"):
+        found: Maybe[str] = JsonUnfolder.optional(
+            data,
+            key,
+            _decode_str_value,
+        ).value_or(Maybe[str].empty())
+        if found != Maybe[str].empty():
+            return found
+    return Maybe[str].empty()
+
+
+def _decode_response(raw: JsonObj) -> ResultE[SurveyResponse]:
+    resp_id = JsonUnfolder.require(
+        raw,
+        "uuid",
+        lambda v: Unfolder.to_primitive(v).bind(JsonPrimitiveUnfolder.to_str),
+    ).map(ResponseId)
+    completed_at = JsonUnfolder.optional(
+        raw,
+        "completed_at",
+        lambda v: Unfolder.to_primitive(v).bind(JsonPrimitiveUnfolder.to_str).bind(_iso_to_unix),
+    )
+    received_at = JsonUnfolder.optional(
+        raw,
+        "received_at",
+        lambda v: Unfolder.to_primitive(v).bind(JsonPrimitiveUnfolder.to_str).bind(_iso_to_unix),
+    )
+    dismissed_at = JsonUnfolder.optional(
+        raw,
+        "dismissed_at",
+        lambda v: Unfolder.to_primitive(v).bind(JsonPrimitiveUnfolder.to_str).bind(_iso_to_unix),
+    )
+    form_id = JsonUnfolder.require(
+        raw,
+        "form",
+        lambda v: Unfolder.to_json(v).bind(
+            lambda obj: JsonUnfolder.require(
+                obj,
+                "uuid",
+                lambda vv: Unfolder.to_primitive(vv).bind(JsonPrimitiveUnfolder.to_str),
+            ),
+        ),
+    ).map(FormId)
+    form_name = JsonUnfolder.require(
+        raw,
+        "form",
+        lambda v: Unfolder.to_json(v).bind(
+            lambda obj: JsonUnfolder.require(
+                obj,
+                "name",
+                lambda vv: Unfolder.to_primitive(vv).bind(JsonPrimitiveUnfolder.to_str),
+            ),
+        ),
+    ).map(FormName)
+    contact = JsonUnfolder.require(
+        raw,
+        "contact",
+        lambda v: Unfolder.to_json(v).bind(_decode_contact),
+    )
+    nps_score = JsonUnfolder.optional(
+        raw,
+        "data",
+        lambda v: Unfolder.to_json(v).map(_find_nps_score),
+    ).map(lambda m: m.bind(lambda x: x))
+    comment = JsonUnfolder.optional(
+        raw,
+        "data",
+        lambda v: Unfolder.to_json(v).map(_find_comment),
+    ).map(lambda m: m.bind(lambda x: x))
+    raw_data: ResultE[Maybe[str]] = Result[Maybe[str], Exception].success(Maybe[str].empty())
+    group_1 = ResultSmash.smash_result_5(resp_id, completed_at, received_at, dismissed_at, form_id)
+    group_2 = ResultSmash.smash_result_5(form_name, contact, nps_score, comment, raw_data)
+    return ResultSmash.smash_result_2(group_1, group_2).map(
+        lambda t: SurveyResponse(*t[0], *t[1]),
+    )
+
+
+def _decode_json_response(resp: Response) -> ResultE[DataPage[SurveyResponse]]:
+    return (
+        json_decode(resp)
+        .alt(cast_exception)
+        .bind(
+            lambda c: c.map(
+                lambda obj: decode_items(obj, _decode_response).bind(
+                    lambda items: decode_next_cursor(obj).map(
+                        lambda cursor: DataPage(items, cursor),
+                    ),
+                ),
+                lambda lst: Result[DataPage[SurveyResponse], Exception].failure(
+                    Bug[Exception].new(
+                        "_decode_json_response",
+                        inspect.currentframe(),
+                        ValueError(f"Expected json object but got list: {lst!r}"),
+                        (),
+                    ),
+                ),
+            ),
+        )
+    )
+
+
+def _get_responses_page(
+    log: Logger,
+    client: HttpClient,
+    form_id: FormId,
+    cursor: Maybe[str],
+) -> Cmd[tuple[FrozenList[SurveyResponse], Maybe[str]]]:
+    params: dict[str, JsonValue] = {
+        "page_length": JsonValue.from_primitive(JsonPrimitive.from_int(_MAX_PAGE_LENGTH)),
+        "form_uuid": JsonValue.from_primitive(JsonPrimitive.from_str(form_id.form)),
+    }
+    cursor_params = cursor.map(
+        lambda c: {
+            "page_cursor": JsonValue.from_primitive(JsonPrimitive.from_str(c)),
+        },
+    ).value_or(dict[str, JsonValue]())
+    get_response = client.get(
+        relative_endpoint("v1/responses"),
+        Params(FrozenDict({**params, **cursor_params})),
+    )
+    return Cmd[None].wrap_impure(
+        lambda: log.info("API: get_responses_page(form=%s)", form_id.form),
+    ) + with_retry_handler(get_response, 3).map(
+        lambda r: r.bind(_decode_json_response),
+    ).map(
+        lambda r: Bug[DataPage[SurveyResponse]].assume_success(
+            "_get_responses_page",
+            inspect.currentframe(),
+            (),
+            r,
+        ),
+    ).map(
+        lambda page: (page.items, page.next_cursor),
+    )
+
+
+def get_responses(
+    log: Logger,
+    creds: Credentials,
+    form_id: FormId,
+) -> Stream[FrozenList[SurveyResponse]]:
+    headers = UnfoldedFactory.from_dict({"Authorization": " ".join(["Bearer", creds.api_key])})
+    client = HttpClientFactory.new_client(None, headers, None)
+    return cursor_pagination(lambda cursor: _get_responses_page(log, client, form_id, cursor))

fluidattacks_refiner_sdk/core.py

@@ -0,0 +1,124 @@
+from collections.abc import (
+    Callable,
+)
+from dataclasses import (
+    dataclass,
+)
+
+from fa_purity import (
+    Cmd,
+    FrozenList,
+    Maybe,
+    Stream,
+)
+from pure_requests.basic import (
+    Endpoint,
+)
+
+REFINER_API = Endpoint("https://api.refiner.io")
+
+
+def relative_endpoint(relative: str) -> Endpoint:
+    return Endpoint(REFINER_API.raw.rstrip("/") + "/" + relative.lstrip("/"))
+
+
+@dataclass(frozen=True)
+class FormId:
+    form: str
+
+
+@dataclass(frozen=True)
+class FormName:
+    name: str
+
+
+@dataclass(frozen=True)
+class AccountId:
+    account: str
+
+
+@dataclass(frozen=True)
+class AccountName:
+    name: str
+
+
+@dataclass(frozen=True)
+class AccountDomain:
+    domain: str
+
+
+@dataclass(frozen=True)
+class Account:
+    id: AccountId
+    remote_id: Maybe[str]
+    display_name: Maybe[str]
+    domain: Maybe[AccountDomain]
+
+
+@dataclass(frozen=True)
+class ContactId:
+    contact: str
+
+
+@dataclass(frozen=True)
+class Contact:
+    id: ContactId
+    email: Maybe[str]
+    display_name: Maybe[str]
+    account: Maybe[Account]
+
+
+@dataclass(frozen=True)
+class ResponseId:
+    response: str
+
+
+@dataclass(frozen=True)
+class SurveyResponse:
+    id: ResponseId
+    completed_at: Maybe[int]
+    received_at: Maybe[int]
+    dismissed_at: Maybe[int]
+    form_id: FormId
+    form_name: FormName
+    contact: Contact
+    nps_score: Maybe[int]
+    comment: Maybe[str]
+    raw_data: Maybe[str]
+
+
+@dataclass(frozen=True)
+class Person:
+    id: ContactId
+    remote_id: Maybe[str]
+    email: Maybe[str]
+    display_name: Maybe[str]
+    first_seen_at: Maybe[int]
+    last_seen_at: Maybe[int]
+    account: Maybe[Account]
+
+
+@dataclass(frozen=True)
+class NpsMetrics:
+    nps: int
+    promoter_count: int
+    promoter_percent: float
+    passive_count: int
+    passive_percent: float
+    detractor_count: int
+    detractor_percent: float
+    response_count: int
+
+
+@dataclass(frozen=True)
+class Form:
+    id: FormId
+    name: FormName
+
+
+@dataclass(frozen=True)
+class ApiClient:
+    get_forms: Stream[FrozenList[Form]]
+    get_responses: Callable[[FormId], Stream[FrozenList[SurveyResponse]]]
+    get_contacts: Stream[FrozenList[Person]]
+    get_nps_metrics: Cmd[NpsMetrics]

fluidattacks_refiner_sdk-0.1.1.dist-info/METADATA

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: fluidattacks_refiner_sdk
+Version: 0.1.1
+Summary: refiner SDK
+Author-email: Product Team <development@fluidattacks.com>
+Requires-Python: >=3.11
+Requires-Dist: click >=8.3.0, <9.0.0
+Requires-Dist: fluidattacks-etl-utils >=5.0.0, <6.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

fluidattacks_refiner_sdk-0.1.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+fluidattacks_refiner_sdk/__init__.py,sha256=rnObPjuBcEStqSO0S6gsdS_ot8ITOQjVj_-P1LUUYpg,22
+fluidattacks_refiner_sdk/core.py,sha256=cq_RkGp_ngAR7GRX94Xwp67IALK4dBVE435g8ZAqIII,2156
+fluidattacks_refiner_sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fluidattacks_refiner_sdk/auth/__init__.py,sha256=N28zBB_AOpt43qbLf1Duy56dj4DQ-Z7WBAMBEc8erRA,74
+fluidattacks_refiner_sdk/auth/_core.py,sha256=dJaZZCfsc8ZW56jXPSZREmhNw84R5u-6Vrrza_OjCNY,136
+fluidattacks_refiner_sdk/client/__init__.py,sha256=pZYeiKSpC71NLlCATvAavefjj6lEEO4_icivwPG0enk,822
+fluidattacks_refiner_sdk/client/_common.py,sha256=AGfCg5q0hWBjj_Ep7gZMakRUFI1-HIJ3cAUmV6DxPiw,3101
+fluidattacks_refiner_sdk/client/_get_contacts.py,sha256=1KZzSiNL0TRMDwu1I7tFpF0rk-qP7zvbe74-cBE-MM8,5974
+fluidattacks_refiner_sdk/client/_get_forms.py,sha256=ZT_lrxKd-DDfgNUxY832e8MBEvYJoFG13YYHxvMaQzE,3614
+fluidattacks_refiner_sdk/client/_get_reporting.py,sha256=80lOOf1MdVw2OTDdlLOXxDFOicHJehC5Je7AgDqz1xw,3900
+fluidattacks_refiner_sdk/client/_get_responses.py,sha256=omhdtzXTL_xiG9qc7MfMw5d7QIRvklJvkAMjflIJN54,8424
+fluidattacks_refiner_sdk-0.1.1.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+fluidattacks_refiner_sdk-0.1.1.dist-info/METADATA,sha256=R03A18lk4pEkiuZlt6BsjHXS5IqW5UcXCoKNItq_Dyk,395
+fluidattacks_refiner_sdk-0.1.1.dist-info/RECORD,,

fluidattacks_refiner_sdk-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.12.0
+Root-Is-Purelib: true
+Tag: py3-none-any