skoll 0.0.1__py3-none-any.whl

skoll/domain/primitives.py

@@ -0,0 +1,319 @@
+from __future__ import annotations
+
+import re
+import typing as t
+from attrs import define, field
+from datetime import datetime, timedelta, UTC
+
+from skoll.errors import InvalidField
+from skoll.domain.base import Object
+from skoll.result import Result, ok, fail
+from skoll.utils import new_ulid, to_tz, to_snake_case, safe_call
+
+ID_REGEX = r"^[0-9a-z]{26}$"
+EMAIL_REGEX = r"^[^@]+@[^@]+$"
+TIME_REGEX = r"^(?:[01]?[0-9]|2[0-3]):[0-5][0-9]$"
+LOCALE_PATTERN = r"^[a-z]{2,3}(-[A-Z][a-z]{3})?(-[A-Z]{2}|-[0-9]{3})?$"
+
+__all__ = ["ID", "Time", "Email", "PositiveInt", "DateTime", "Latitude", "Longitude", "Locale", "LocalizedText"]
+
+
+@define(kw_only=True, slots=True, frozen=True)
+class ID(Object):
+
+    value: str
+
+    @classmethod
+    def new(cls) -> t.Self:
+        return cls(value=new_ulid())
+
+    @t.override
+    @classmethod
+    def prepare(cls, raw: t.Any) -> Result[t.Any]:
+        value = safe_call(str, raw)
+        if value is not None and re.fullmatch(ID_REGEX, value.strip()) is not None:
+            return ok(value.strip())
+        return fail(
+            InvalidField(
+                field=to_snake_case(cls.__name__),
+                hints={"expected": "string", "contraints": {"pattern": ID_REGEX}, "received": raw},
+            )
+        )
+
+
+@define(kw_only=True, slots=True, frozen=True)
+class PositiveInt(Object):
+
+    value: int
+
+    def increment(self) -> t.Self:
+        return self.__class__(value=self.value + 1)
+
+    def decrement(self) -> t.Self:
+        return self.__class__(value=self.value - 1)
+
+    @classmethod
+    def zero(cls) -> t.Self:
+        return cls(value=0)
+
+    @t.override
+    @classmethod
+    def prepare(cls, raw: t.Any) -> Result[t.Any]:
+        value = safe_call(int, raw)
+        if value is not None and value >= 0:
+            return ok(value)
+        return fail(
+            InvalidField(
+                field=to_snake_case(cls.__name__),
+                hints={"expected": "integer", "contraints": {"min": 0}, "received": raw},
+            )
+        )
+
+
+@define(kw_only=True, slots=True, frozen=True)
+class DateTime(Object):
+
+    value: datetime
+
+    @property
+    def timestamp(self) -> int:
+        return int(self.value.timestamp() * 1000)
+
+    @property
+    def week_day(self) -> int:
+        return self.value.weekday()
+
+    @property
+    def iso_format(self) -> str:
+        """ """
+        return self.value.strftime("%Y-%m-%dT%H:%M:%S") + "Z"
+
+    @t.override
+    def serialize(self):
+        return self.timestamp
+
+    def diff(self, other: t.Self) -> timedelta:
+        if other.value > self.value:
+            return other.value - self.value
+        return self.value - other.value
+
+    def plus(
+        self, days: int = 0, hours: int = 0, minutes: int = 0, seconds: int = 0, delta: timedelta | None = None
+    ) -> DateTime:
+        new_date = (
+            self.value + timedelta(days=days, hours=hours, minutes=minutes, seconds=seconds) + (delta or timedelta())
+        )
+        return DateTime(value=new_date)
+
+    def minus(
+        self, days: int = 0, hours: int = 0, minutes: int = 0, seconds: int = 0, delta: timedelta | None = None
+    ) -> DateTime:
+        new_date = (
+            self.value - timedelta(days=days, hours=hours, minutes=minutes, seconds=seconds) - (delta or timedelta())
+        )
+        return DateTime(value=new_date)
+
+    def __gt__(self, other: t.Self) -> bool:
+        return self.value > other.value
+
+    def __lt__(self, other: t.Self) -> bool:
+        return self.value < other.value
+
+    def __ge__(self, other: t.Self) -> bool:
+        return self.value >= other.value
+
+    def __le__(self, other: t.Self) -> bool:
+        return self.value <= other.value
+
+    def reset_second(self):
+        date = self.value.replace(second=0, microsecond=0)
+        return DateTime(value=date)
+
+    def reset_part(self, hour: bool = False, minute: bool = False):
+        date = self.value.replace(second=0, microsecond=0)
+
+        if hour:
+            date = date.replace(hour=0, minute=0)
+        elif minute:
+            date = date.replace(minute=0)
+        return DateTime(value=date)
+
+    def to_tz(self, tz_str: str = "UTC") -> DateTime:
+        return DateTime.from_timestamp(int(self.value.timestamp() * 1000), tz_str=tz_str)
+
+    @classmethod
+    def today(cls, tz_str: str = "UTC") -> DateTime:
+        tz = to_tz(tz_str)
+        value = datetime.combine(datetime.now(tz=tz), datetime.min.time()).replace(tzinfo=tz)
+        return cls.from_timestamp(int(value.timestamp() * 1000), tz_str=tz_str)
+
+    @classmethod
+    def tomorrow(cls, tz_str: str = "UTC") -> DateTime:
+        tz = to_tz(tz_str)
+        value = datetime.combine(datetime.now(tz=tz) + timedelta(days=1), datetime.min.time()).replace(tzinfo=tz)
+        return cls.from_timestamp(int(value.timestamp() * 1000), tz_str=tz_str)
+
+    @classmethod
+    def now(cls, tz_str: str = "UTC") -> DateTime:
+        tz = to_tz(tz_str)
+        value = int(datetime.now(tz=tz).timestamp() * 1000)
+        return cls.from_timestamp(value, tz_str=tz_str)
+
+    @classmethod
+    def from_timestamp(cls, timestamp: int, tz_str: str = "UTC") -> DateTime:
+        tz = to_tz(tz_str)
+        return DateTime(value=datetime.fromtimestamp(timestamp / 1000, tz=tz))
+
+    @t.override
+    @classmethod
+    def prepare(cls, raw: t.Any) -> Result[t.Any]:
+        value = safe_call(int, raw)
+        if value is not None and value >= 0:
+            return ok(datetime.fromtimestamp(value / 1000, tz=UTC))
+        return fail(
+            InvalidField(
+                field=to_snake_case(cls.__name__),
+                hints={"expected": "integer", "contraints": {"min": 0}, "received": raw},
+            )
+        )
+
+
+@define(kw_only=True, slots=True, frozen=True)
+class Latitude(Object):
+    value: float
+
+    @t.override
+    @classmethod
+    def prepare(cls, raw: t.Any) -> Result[t.Any]:
+        value = safe_call(float, raw)
+        if value is not None and -90 <= value <= 90:
+            return ok(value)
+        return fail(
+            InvalidField(
+                field=to_snake_case(cls.__name__),
+                hints={"expected": "float", "contraints": {"min": -90, "max": 90}, "received": raw},
+            )
+        )
+
+
+@define(kw_only=True, slots=True, frozen=True)
+class Longitude(Object):
+    value: float
+
+    @t.override
+    @classmethod
+    def prepare(cls, raw: t.Any) -> Result[t.Any]:
+        value = safe_call(float, raw)
+        if value is not None and -180 <= value <= 180:
+            return ok(value)
+        return fail(
+            InvalidField(
+                field=to_snake_case(cls.__name__),
+                hints={"expected": "float", "contraints": {"min": -180, "max": 180}, "received": raw},
+            )
+        )
+
+
+@define(kw_only=True, slots=True, frozen=True)
+class Time(Object):
+    value: str
+
+    @property
+    def as_hour(self) -> float:
+        return self.hour + (self.minute / 60)
+
+    @property
+    def hour(self) -> int:
+        return int(self.value.split(":")[0])
+
+    @property
+    def minute(self) -> int:
+        return int(self.value.split(":")[1])
+
+    @t.override
+    @classmethod
+    def prepare(cls, raw: t.Any) -> Result[t.Any]:
+        value = safe_call(str, raw)
+        if value is not None and re.fullmatch(TIME_REGEX, value.strip()) is not None:
+            return ok(value.strip())
+
+        return fail(
+            InvalidField(
+                field=to_snake_case(cls.__name__),
+                hints={"expected": "string", "contraints": {"pattern": TIME_REGEX}, "received": raw},
+            )
+        )
+
+
+@define(kw_only=True, slots=True, frozen=True)
+class Email(Object):
+
+    value: str
+
+    @property
+    def name(self) -> str:
+        return self.value.split("@")[0]
+
+    @classmethod
+    def anonymous(cls, id: ID) -> Email:
+        return cls(value=f"{id.value}.no-reply@email.com")
+
+    @t.override
+    @classmethod
+    def prepare(cls, raw: t.Any) -> Result[t.Any]:
+        value = safe_call(str, raw)
+        if value is not None and re.fullmatch(EMAIL_REGEX, value.strip()) is not None:
+            return ok(value.strip().lower())
+        return fail(
+            InvalidField(
+                field=to_snake_case(cls.__name__),
+                hints={"expected": "string", "contraints": {"pattern": EMAIL_REGEX}, "received": raw},
+            )
+        )
+
+
+@define(kw_only=True, slots=True, frozen=True)
+class Locale(Object):
+
+    value: str
+
+    @t.override
+    @classmethod
+    def prepare(cls, raw: t.Any) -> Result[t.Any]:
+        value = safe_call(str, raw)
+        if value is not None and re.fullmatch(LOCALE_PATTERN, value.strip()) is not None:
+            return ok(value.strip().lower())
+        return fail(
+            InvalidField(
+                field=to_snake_case(cls.__name__),
+                hints={"received": raw, "expected": "BCP47Locale"},
+            )
+        )
+
+
+@define(kw_only=True, slots=True, frozen=True)
+class LocalizedText(Object):
+
+    value: dict[str, str] = field(factory=dict)
+
+    @t.override
+    @classmethod
+    def prepare(cls, raw: t.Any) -> Result[t.Any]:
+        value = safe_call(dict, raw)
+
+        if value is not None:
+            keys_valid = all(isinstance(k, str) and re.fullmatch(LOCALE_PATTERN, k) for k in value.keys())
+            values_valid = all(isinstance(v, str) for v in value.values())
+            if keys_valid and values_valid:
+                return ok(t.cast(dict[str, str], value))
+
+        return fail(
+            InvalidField(
+                field=to_snake_case(cls.__name__),
+                hints={
+                    "received": raw,
+                    "expected": "Dictionaire<BCP47Locale, string>",
+                    "example": {"en-US": "English", "en": "An example"},
+                },
+            )
+        )

skoll/errors.py

@@ -0,0 +1,141 @@
+import attrs
+import typing as t
+
+from skoll.utils import sanitize_dict
+
+
+__all__ = [
+    "Error",
+    "NotFound",
+    "Conflict",
+    "Forbidden",
+    "BadRequest",
+    "InvalidField",
+    "MissingField",
+    "InternalError",
+    "Unauthenticated",
+    "ValidationFailed",
+]
+
+type ErrorStatusCode = t.Literal[500, 400, 401, 403, 404, 409]
+
+
+@attrs.define(kw_only=True, slots=True)
+class Error(Exception):
+
+    code: str
+    field: str | None = None
+    status: ErrorStatusCode | None = None
+    detail: str = "An expected error occurred."
+    errors: list["Error"] = attrs.field(factory=list)
+    debug: dict[str, t.Any] = attrs.field(factory=dict)
+    hints: dict[str, t.Any] = attrs.field(factory=dict)
+
+    def serialize(
+        self,
+        public_view: bool = False,
+        trace_id: str | None = None,
+    ) -> dict[str, t.Any]:
+        err_json: dict[str, t.Any] = {
+            "code": self.code,
+            "field": self.field,
+            "hints": self.hints,
+            "trace_id": trace_id,
+            "detail": self.detail,
+            "status": self.status,
+            "debug": self.debug if public_view is False else None,
+            "errors": [sub.serialize(public_view=public_view) for sub in self.errors],
+        }
+        return sanitize_dict(err_json)
+
+
+@attrs.define(kw_only=True, slots=True)
+class MissingField(Error):
+
+    code: str = attrs.field(default="missing_field", init=False)
+    hints: dict[str, t.Any] = attrs.field(factory=dict, init=False)
+    debug: dict[str, t.Any] = attrs.field(factory=dict, init=False)
+    status: ErrorStatusCode | None = attrs.field(default=None, init=False)
+    detail: str = attrs.field(default="This field is required to process your request", init=False)
+
+
+@attrs.define(kw_only=True, slots=True)
+class InvalidField(Error):
+
+    code: str = attrs.field(default="invalid_field", init=False)
+    debug: dict[str, t.Any] = attrs.field(factory=dict, init=False)
+    status: ErrorStatusCode | None = attrs.field(default=None, init=False)
+    detail: str = attrs.field(default="This field has invalid data, see hints for more details", init=False)
+
+
+@attrs.define(kw_only=True, slots=True)
+class InternalError(Error):
+
+    field: str | None = attrs.field(default=None, init=False)
+    code: str = attrs.field(default="internal_error", init=False)
+    hints: dict[str, t.Any] = attrs.field(factory=dict, init=False)
+    status: ErrorStatusCode | None = attrs.field(default=500, init=False)
+    detail: str = attrs.field(default="An expected error occurred. Please try again later.", init=False)
+
+    @classmethod
+    def from_exception(cls, exc: Exception, extra: dict[str, t.Any] | None = None) -> t.Self:
+        return cls(debug={**(extra or {}), **{"message": str(exc)}})
+
+
+@attrs.define(kw_only=True, slots=True)
+class BadRequest(Error):
+
+    field: str | None = attrs.field(default=None, init=False)
+    code: str = attrs.field(default="bad_request", init=False)
+    status: ErrorStatusCode | None = attrs.field(default=400, init=False)
+    detail: str = attrs.field(default="Your request is invalid. Check hints for more details", init=False)
+
+
+@attrs.define(kw_only=True, slots=True)
+class ValidationFailed(Error):
+
+    field: str | None = attrs.field(default=None, init=False)
+    debug: dict[str, t.Any] = attrs.field(factory=dict, init=False)
+    code: str = attrs.field(default="validation_failed", init=False)
+    status: ErrorStatusCode | None = attrs.field(default=400, init=False)
+    detail: str = attrs.field(
+        default="Your request contains invalid or missing data. Check hints for more details", init=False
+    )
+
+
+@attrs.define(kw_only=True, slots=True)
+class Unauthenticated(Error):
+
+    field: str | None = attrs.field(default=None, init=False)
+    code: str = attrs.field(default="unauthenticated", init=False)
+    status: ErrorStatusCode | None = attrs.field(default=401, init=False)
+    detail: str = attrs.field(default="This request requires is only allowed for authenticated users", init=False)
+
+
+@attrs.define(kw_only=True, slots=True)
+class Forbidden(Error):
+
+    code: str = attrs.field(default="forbidden", init=False)
+    field: str | None = attrs.field(default=None, init=False)
+    status: ErrorStatusCode | None = attrs.field(default=403, init=False)
+    detail: str = attrs.field(
+        default="You do not have required privilege for this operation. See hints for more details", init=False
+    )
+
+
+@attrs.define(kw_only=True, slots=True)
+class NotFound(Error):
+
+    code: str = attrs.field(default="not_found", init=False)
+    field: str | None = attrs.field(default=None, init=False)
+    status: ErrorStatusCode | None = attrs.field(default=404, init=False)
+    detail: str = attrs.field(default="There is no resource corresponding to your request", init=False)
+
+
+@attrs.define(kw_only=True, slots=True)
+class Conflict(Error):
+
+    code: str = attrs.field(default="conflict", init=False)
+    field: str | None = attrs.field(default=None, init=False)
+    status: ErrorStatusCode | None = attrs.field(default=409, init=False)
+    detail: str = "Can not perform this operation since it will put the system in an inconsistent state"

skoll/infras/__init__.py

@@ -0,0 +1,3 @@
+from .spicedb import *
+from .mediator import *
+from .postgresql import *

skoll/infras/mediator/__init__.py

@@ -0,0 +1,2 @@
+from .nats import *
+from .basic import *

skoll/infras/mediator/basic.py

@@ -0,0 +1,60 @@
+import typing as t
+from attrs import define, field
+from asyncio import Queue, Event, create_task, wait
+
+from skoll.domain import Message
+from skoll.result import Result, fail
+from skoll.application import Subscriber, MissingSubscriber, Mediator, Service, RawMessage
+
+from .utils import run_callback, is_subscribed
+
+__all__ = ["BasicMediator"]
+
+
+@define(kw_only=True, slots=True)
+class BasicMediator(Mediator):
+    """Basic in-memory mediator implementation."""
+
+    queue: Queue[Message | RawMessage] = field(factory=Queue)
+    stop_signal: Event = field(factory=Event)
+    subscribers: list[Subscriber] = field(factory=list)
+    handlers: dict[str, Subscriber] = field(factory=dict)
+
+    @t.override
+    async def publish(self, msg: Message | RawMessage) -> None:
+        self.queue.put_nowait(msg)
+
+    @t.override
+    async def disconnect(self):
+        self.stop_signal.set()
+
+    @t.override
+    async def request(self, msg: Message | RawMessage) -> Result[t.Any]:
+        topic = msg.topic if isinstance(msg, Message) else msg["topic"]
+        subscriber = self.handlers.get(topic)
+        if subscriber is not None:
+            return await run_callback(subscriber, msg)
+        return fail(err=MissingSubscriber(debug={"subject": topic}))
+
+    @t.override
+    def register(self, *services: Service) -> None:
+        for service in services:
+            for subscriber in service.subscribers:
+                if subscriber.with_reply:
+                    self.handlers[subscriber.topic] = subscriber
+                else:
+                    self.subscribers.append(subscriber)
+
+    @t.override
+    async def connect(self):
+        while not self.stop_signal.is_set() or not self.queue.empty():
+            try:
+                msg = await self.queue.get()
+                tasks = [
+                    create_task(run_callback(subscriber, msg))
+                    for subscriber in self.subscribers
+                    if is_subscribed(subscriber, msg)
+                ]
+                await wait(tasks)
+            except Exception as exc:
+                print(exc)

skoll/infras/mediator/nats.py

@@ -0,0 +1,51 @@
+import typing as t
+from skoll.domain import Message
+from skoll.result import Result, ok
+from skoll.config import NATSConfig
+from skoll.application.types import RawMessage
+from skoll.application import Mediator, Subscriber, Service
+
+
+__all__ = ["NATSMediator"]
+
+
+class NATSMediator(Mediator):
+    """NATS mediator implementation."""
+
+    seed: str
+    urls: list[str]
+    subscribers: list[Subscriber]
+    handlers: dict[str, Subscriber]
+
+    def __init__(self, config: NATSConfig) -> None:
+        if config.urls is None or config.seed is None:
+            raise ValueError("NATS URLs and seed are required")
+        self.urls = config.urls.split(",")
+        self.seed = config.seed
+        self.handlers = {}
+        self.subscribers = []
+
+    @t.override
+    def register(self, *services: Service) -> None:
+        for service in services:
+            for subscriber in service.subscribers:
+                if subscriber.with_reply:
+                    self.handlers[subscriber.topic] = subscriber
+                else:
+                    self.subscribers.append(subscriber)
+
+    @t.override
+    async def connect(self) -> None:
+        pass
+
+    @t.override
+    async def disconnect(self) -> None:
+        pass
+
+    @t.override
+    async def publish(self, msg: Message | RawMessage) -> None:
+        pass
+
+    @t.override
+    async def request(self, msg: Message | RawMessage) -> Result[t.Any]:
+        return ok(None)

skoll/infras/mediator/utils.py

@@ -0,0 +1,71 @@
+import typing as t
+
+from skoll.domain import Message
+from skoll.result import Result, fail, is_fail
+from skoll.utils import call_with_dependencies
+from skoll.application import Subscriber, RawMessage
+from skoll.errors import Error, InternalError, ValidationFailed
+
+
+async def run_callback(subscriber: Subscriber, message: Message | RawMessage) -> Result[t.Any]:
+    topic = message.topic if isinstance(message, Message) else message.get("topic")
+    try:
+        msg = get_message(subscriber.msg_cls, message)
+        return await call_with_dependencies(subscriber.callback, {subscriber.msg_arg: msg})
+    except Error as err:
+        return fail(err=err)
+    except Exception as exc:
+        return fail(err=InternalError.from_exception(exc, extra={"subject": topic, "message": message}))
+
+
+def get_message(cls: type[Message], message: Message | RawMessage) -> Message:
+    if isinstance(message, Message):
+        return message
+    res = cls.create(raw=message)
+    if is_fail(res):
+        raise ValidationFailed(errors=res.err.errors)
+
+    return res.value
+
+
+def is_subscribed(subscriber: Subscriber, message: Message | RawMessage) -> bool:
+    topic = message.topic if isinstance(message, Message) else message.get("topic")
+    s = topic.split(".") if topic else []
+    p = subscriber.topic.split(".") if subscriber.topic else []
+
+    i = j = 0
+    while i < len(s) and j < len(p):
+        if j + 1 < len(p) and p[j + 1] == ">":
+            # Next token is '>', so this token must match exactly
+            if p[j] != "*" and p[j] != s[i]:
+                return False
+            j += 2
+            i += 1
+            continue
+
+        if p[j] == ">":
+            return True
+
+        if p[j] == "*":
+            i += 1
+            j += 1
+            continue
+
+        if p[j] != s[i]:
+            return False
+
+        i += 1
+        j += 1
+
+    if i == len(s):
+        # Check remaining pattern tokens
+        while j < len(p):
+            if p[j] == ">":
+                return True
+            if p[j] != "*":
+                return False
+            j += 1
+        return True
+
+    # Subject has leftover tokens
+    return j < len(p) and p[j] == ">"