skoll 0.0.1__py3-none-any.whl

skoll/infras/postgresql.py

@@ -0,0 +1,154 @@
+import typing as t
+from json import dumps
+from attrs import define
+import collections.abc as c
+from asyncpg.pool import Pool, PoolConnectionProxy
+from asyncpg import Record, create_pool, UniqueViolationError
+
+
+from skoll.utils import from_json
+from skoll.domain import EntityState
+from skoll.result import Result, is_fail
+from skoll.errors import InternalError, NotFound, Conflict
+from skoll.application import DB, Repository, Criteria, ListCriteria, ListPage
+
+
+__all__ = ["PostgresDB", "PostgresRepo", "parse_pg_row"]
+
+
+def parse_pg_row(row: t.Any, errors_hints: dict[str, t.Any] | None = None) -> dict[str, t.Any]:
+    raw = {}
+    if row is None:
+        raise NotFound(hints=errors_hints or {})
+    if not isinstance(row, Record):
+        raise InternalError(debug={"row": row, "message": "Invalid row PG data", "errors_hints": errors_hints})
+    for key, value in row.items():
+        json_value = from_json(value)
+        raw[key] = json_value if isinstance(value, str) and json_value is not None else value
+    return raw
+
+
+class PostgresDB(DB[PoolConnectionProxy]):
+
+    dsn: str
+    __pool: Pool | None
+
+    def __init__(self, dsn: str = "PG_DB_DSN") -> None:
+        self.dsn = dsn
+        self.__pool = None
+
+    @t.override
+    async def connect(self) -> None:
+        if self.__pool is None:
+            try:
+                self.__pool = await create_pool(dsn=self.dsn, min_size=1, max_size=10)
+            except Exception as exc:
+                raise InternalError.from_exception(exc)
+
+    @t.override
+    async def close(self) -> None:
+        if self.__pool is not None:
+            await self.__pool.close()
+            self.__pool = None
+
+    @t.override
+    async def session(self) -> c.AsyncGenerator[PoolConnectionProxy]:
+        if self.__pool is None:
+            raise RuntimeError("Database pool is not initialized.")
+        async with self.__pool.acquire() as conn:
+            yield conn
+
+    @t.override
+    async def transaction(self) -> c.AsyncGenerator[PoolConnectionProxy]:
+        if self.__pool is None:
+            raise RuntimeError("Database pool is not initialized.")
+        async with self.__pool.acquire() as conn:
+            async with conn.transaction():
+                yield conn
+
+
+@define(kw_only=True, frozen=True, slots=True)
+class PostgresRepo[T: EntityState](Repository[T]):
+
+    table: str
+    conn: PoolConnectionProxy
+    restore_func: t.Callable[[dict[str, t.Any]], Result[T]]
+
+    @t.override
+    async def get(self, criteria: Criteria) -> T | None:
+        try:
+            qry, params = criteria.as_sql
+            record = await self.conn.fetchrow(qry, *params)
+            if not isinstance(record, Record):
+                return None
+            res = self.restore_func(parse_pg_row(record))
+            if is_fail(res):
+                raise ValueError("Entity Parsing failed")
+            return res.value
+        except Exception as exc:
+            raise InternalError.from_exception(exc, extra={"criteria": criteria.as_sql})
+
+    @t.override
+    async def exists(self, criteria: Criteria) -> bool:
+        try:
+            qry, params = criteria.as_sql
+            record = await self.conn.fetchrow(qry, *params)
+            return record is not None
+        except Exception as exc:
+            raise InternalError.from_exception(exc, extra={"criteria": criteria.as_sql})
+
+    @t.override
+    async def delete(self, criteria: Criteria) -> None:
+        try:
+            qry, params = criteria.as_sql
+            await self.conn.execute(qry.replace("SELECT *", "DELETE"), *params)
+        except Exception as exc:
+            raise InternalError.from_exception(exc, extra={"criteria": criteria.as_sql})
+
+    @t.override
+    async def list(self, criteria: ListCriteria) -> ListPage[T]:
+        try:
+            qry, params = criteria.as_sql
+            rows = await self.conn.fetch(qry, *params)
+            items: list[T] = []
+            for row in rows:
+                if not isinstance(row, Record):
+                    raise ValueError("Invalid row type")
+                res = self.restore_func(parse_pg_row(row))
+                if is_fail(res):
+                    raise ValueError("Entity Parsing failed")
+                items.append(res.value)
+            return ListPage(cursor="NOOP", items=items)  # TODO: Implement cursor
+        except Exception as exc:
+            raise InternalError.from_exception(exc, extra={"criteria": criteria.as_sql})
+
+    @t.override
+    async def save(self, state: T) -> None:
+        try:
+            raw = state.serialize()
+            sql_stm, params = self.__prepare_insert(raw) if state.version.value == 0 else self.__prepare_update(raw)
+            _ = await self.conn.execute(sql_stm, *params)
+        except UniqueViolationError as exc:
+            raise Conflict(debug={"raw": state.serialize(), "table": self.table})
+        except Exception as exc:
+            raise InternalError.from_exception(exc, extra={"raw": state.serialize(), "table": self.table})
+
+    def __prepare_insert(self, raw: dict[str, t.Any]):
+        params: list[t.Any] = []
+        attrs: list[str] = []
+        keys: list[str] = []
+        for idx, kv in enumerate(raw.items()):
+            attrs.append(kv[0])
+            keys.append(f"${idx + 1}")
+            params.append(dumps(kv[1]) if isinstance(kv[1], (dict, list)) else kv[1])
+        sql_stm = f"INSERT INTO {self.table}({", ".join(attrs)}) VALUES({", ".join(keys)})"
+        return sql_stm, params
+
+    def __prepare_update(self, raw: dict[str, t.Any]):
+        params = [raw["uid"], raw["version"] - 1]
+        changes: list[str] = []
+        for idx, kv in enumerate(raw.items()):
+            changes.append(f"{kv[0]} = ${idx + 3}")
+            params.append(dumps(kv[1]) if isinstance(kv[1], (dict, list)) else kv[1])
+        sql_stm = f"UPDATE {self.table} SET {", ".join(changes)} WHERE uid = $1 AND version = $2"
+        return sql_stm, params

skoll/infras/spicedb.py

@@ -0,0 +1,183 @@
+import typing as t
+from json import loads
+from attrs import define
+from re import match as re_match
+from aiohttp import ClientSession
+
+from skoll.utils import sanitize_dict
+from skoll.config import SpiceDBConfig
+from skoll.errors import Forbidden, InternalError
+from skoll.application import AuthzWriteChange, AuthzPrecondition, AuthzLookupResult, Authz
+
+
+__all__ = ["SpiceDBAuthz"]
+
+
+TUPLE_PATTERN = r"(?P<resource>.+?):(?P<resource_id>.*?)#(?P<relation>.*?)@(?P<subject>.*?):(?P<subject_id>.*)"
+
+
+@define(frozen=True, kw_only=True)
+class TupleObject:
+    resource: str
+    subject: str | None = None
+    relation: str | None = None
+    subject_id: str | None = None
+    resource_id: str | None = None
+    subject_relation: str | None = None
+
+
+class SpiceDBAuthz(Authz):
+
+    url: str
+    token: str
+
+    def __init__(self, config: SpiceDBConfig):
+        if config.uri is None or config.token is None:
+            raise InternalError(debug={"message": "Invalid SpiceDB config", "config": config})
+        self.url = config.uri
+        self.token = config.token
+
+    def make_headers(self) -> dict[str, str]:
+        return {"Authorization": f"Bearer {self.token}"}
+
+    @t.override
+    async def write(self, changes: list[AuthzWriteChange], preconditions: list[AuthzPrecondition] | None = None) -> str:
+        uri = self.url + "/v1/relationships/write"
+        data = {"updates": get_changes(changes), "optionalAuthzPreconditions": get_preconditions(preconditions or [])}
+        async with ClientSession() as session:
+            async with session.post(uri, json=sanitize_dict(data), ssl=False, headers=self.make_headers()) as response:
+                if response.status != 200:
+                    print(await response.text())
+                    raise ValueError(f"Failed to write changes {changes} with preconditions {preconditions}")
+                return (await response.json()).get("writtenAt", {}).get("token", "")
+
+    @t.override
+    async def lookup(
+        self, filter: str, cxt: dict[str, t.Any] | None = None, limit: int | None = None, cursor: str | None = None
+    ) -> AuthzLookupResult:
+        tuple_obj = tuple_from(filter)
+        if not tuple_obj:
+            raise ValueError(f"Invalid tuple: {filter}")
+
+        data: dict[str, t.Any] = {
+            "context": cxt,
+            "consistency": {"minimizeLatency": True},
+            "optionalCursor": {"token": cursor} if cursor else None,
+        }
+        uri = self.url + "/v1/permissions"
+        if tuple_obj.subject_id is not None:  # ResourceLookup
+            uri += "/resources"
+            data["optionalLimit"] = limit
+            data["permission"] = tuple_obj.relation
+            data["resourceObjectType"] = tuple_obj.resource
+            data["subject"] = {
+                "optionalRelation": tuple_obj.subject_relation,
+                "object": {"objectType": tuple_obj.subject, "objectId": tuple_obj.subject_id},
+            }
+        else:  # SubjectLookup
+            uri += "/subjects"
+            data["optionalConcreteLimit"] = limit
+            data["permission"] = tuple_obj.relation
+            data["subjectObjectType"] = tuple_obj.subject
+            data["optionalSubjectRelation"] = tuple_obj.subject_relation
+            data["resource"] = {"objectType": tuple_obj.resource, "objectId": tuple_obj.resource_id}
+
+        async with ClientSession() as session:
+            async with session.post(uri, json=sanitize_dict(data), ssl=False, headers=self.make_headers()) as response:
+                if response.status != 200:
+                    raise Exception(
+                        f"Failed to lookup  {filter} with context {cxt} and limit {limit} and cursor {cursor}. status code: {response.status}"
+                    )
+                lines = [loads(line) for line in (await response.text()).split("\n")[:-1]]
+                id_key = "resourceObjectId" if tuple_obj.subject_id is not None else "subjectObjectId"
+                return AuthzLookupResult(
+                    uids=[line.get("result", {}).get(id_key, "") for line in lines],
+                    cursor=lines[-1].get("result", {}).get("afterResultCursor", {}).get("token"),
+                )
+
+    @t.override
+    async def check(self, tuple: str, cxt: dict[str, t.Any] | None = None) -> None:
+        uri = self.url + "/v1/permissions/check"
+        tuple_obj = tuple_from(tuple)
+        if not tuple_obj:
+            raise ValueError(f"Invalid tuple: {tuple}")
+
+        data: dict[str, t.Any] = {
+            "context": cxt,
+            "permission": tuple_obj.relation,
+            "consistency": {"minimizeLatency": True},
+            "resource": {"objectType": tuple_obj.resource, "objectId": tuple_obj.resource_id},
+            "subject": {
+                "optionalRelation": tuple_obj.subject_relation,
+                "object": {"objectType": tuple_obj.subject, "objectId": tuple_obj.subject_id},
+            },
+        }
+
+        async with ClientSession() as session:
+            async with session.post(uri, json=sanitize_dict(data), ssl=False, headers=self.make_headers()) as response:
+                res = await response.json()
+                if res.get("permissionship", "") != "PERMISSIONSHIP_HAS_PERMISSION":
+                    raise Forbidden(debug={"tuple": tuple, "context": cxt})
+                return None
+
+
+def tuple_from(tuple_str: str) -> TupleObject | None:
+    match = re_match(TUPLE_PATTERN, tuple_str)
+    if match:
+        data = match.groupdict()
+        subject_id = data["subject_id"].split("#")
+        data["subject_id"] = subject_id[0]
+        data["subject_relation"] = subject_id[1] if len(subject_id) > 1 else None
+        return TupleObject(
+            resource=data["resource"],
+            subject_relation=data["subject_relation"],
+            subject=data["subject"] if len(data["subject"]) > 0 else None,
+            relation=data["relation"] if len(data["relation"]) > 0 else None,
+            subject_id=data["subject_id"] if len(data["subject_id"]) > 0 else None,
+            resource_id=data["resource_id"] if len(data["resource_id"]) > 0 else None,
+        )
+    return None
+
+
+def get_changes(changes: list[AuthzWriteChange]) -> list[dict[str, t.Any]]:
+    updates = []
+    for ch in changes:
+        tuple_obj = tuple_from(ch[1])
+        if not tuple_obj:
+            raise ValueError(f"Invalid tuple: {ch[1]}")
+        update: dict[str, t.Any] = {
+            "operation": "OPERATION_DELETE" if ch[0] == "DELETE" else "OPERATION_TOUCH",
+            "relationship": {
+                "relation": tuple_obj.relation,
+                "resource": {"objectType": tuple_obj.resource, "objectId": tuple_obj.resource_id},
+                "subject": {
+                    "optionalRelation": tuple_obj.subject_relation,
+                    "object": {"objectType": tuple_obj.subject, "objectId": tuple_obj.subject_id},
+                },
+                "optionalExpiresAt": ch[3].iso_format if ch[3] else None,
+                "optionalCaveat": {"caveatName": ch[2][0], "context": ch[2][1]} if ch[2] else None,
+            },
+        }
+        updates.append(update)
+    return updates
+
+
+def get_preconditions(precondition: list[AuthzPrecondition]) -> list[dict[str, t.Any]]:
+    return [{"operation": f"OPERATION_{pr[0]}", "filter": relation_filter_from(pr[1])} for pr in precondition]
+
+
+def relation_filter_from(tuple: str) -> dict[str, t.Any]:
+    tuple_obj = tuple_from(tuple)
+    if not tuple_obj:
+        raise ValueError(f"Invalid tuple: {tuple}")
+    return {
+        "resourceType": tuple_obj.resource,
+        "optionalResourceId": tuple_obj.resource_id,
+        "optionalResourceIdPrefix": tuple_obj.resource_id,
+        "optionalRelation": tuple_obj.relation,
+        "optionalSubjectFilter": {
+            "subjectType": tuple_obj.subject,
+            "optionalSubjectId": tuple_obj.subject_id,
+            "optionalRelation": {"relation": tuple_obj.subject_relation},
+        },
+    }

skoll/result.py

@@ -0,0 +1,58 @@
+import typing as t
+from attrs import define
+
+from .errors import Error, InvalidField
+
+
+__all__ = ["Result", "ok", "fail", "is_ok", "is_fail", "combine"]
+
+
+type Result[T] = _Ok[T] | _Fail
+V = t.TypeVar("V", covariant=True)
+
+
+@define(frozen=True, slots=True)
+class _Ok(t.Generic[V]):
+
+    value: V
+
+
+@define(frozen=True, slots=True)
+class _Fail:
+
+    err: Error
+
+
+def ok(value: V) -> Result[V]:
+    return _Ok(value)
+
+
+def fail(err: Error) -> Result[t.Any]:
+    return _Fail(err)
+
+
+def is_ok[T](res: Result[T]) -> t.TypeIs[_Ok[T]]:
+    return isinstance(res, _Ok)
+
+
+def is_fail[T](res: Result[T]) -> t.TypeIs[_Fail]:
+    return isinstance(res, _Fail)
+
+
+@t.overload
+def combine(results: list[Result[t.Any]]) -> Result[list[t.Any]]: ...
+
+
+@t.overload
+def combine(results: dict[str, Result[t.Any]]) -> Result[dict[str, t.Any]]: ...
+
+
+def combine(results: list[Result[t.Any]] | dict[str, Result[t.Any]]):
+    if isinstance(results, dict):
+        dict_values = {k: r.value for k, r in results.items() if isinstance(r, _Ok)}
+        errs = [r.err for r in results.values() if isinstance(r, _Fail)]
+        return _Ok(dict_values) if not errs else _Fail(InvalidField(errors=errs))
+
+    list_values = [r.value for r in results if isinstance(r, _Ok)]
+    errs = [r.err for r in results if isinstance(r, _Fail)]
+    return _Ok(list_values) if not errs else _Fail(InvalidField(errors=errs))

skoll/utils/__init__.py

@@ -0,0 +1,2 @@
+from .functional import *
+from .dep_injection import *

skoll/utils/dep_injection.py

@@ -0,0 +1,89 @@
+import inspect
+import typing as t
+from attrs import define
+import collections.abc as c
+from contextlib import AsyncExitStack, AbstractAsyncContextManager
+
+from .functional import to_context_manager, get_signature
+
+
+type Cache = dict[t.Any, t.Any]
+type Context = dict[str, t.Any]
+type DepFn = t.Callable[..., t.Any]
+type BaseFn[T] = t.Callable[..., c.Coroutine[t.Any, t.Any, T]]
+
+
+__all__ = [
+    "depend",
+    "resolve",
+    "Dependent",
+    "get_dependant",
+    "call_with_dependencies",
+]
+
+
+@define(slots=True, kw_only=True)
+class Dependent:
+
+    call: t.Callable[..., t.Any]
+
+
+def depend(call: t.Callable[..., t.Any]) -> Dependent:
+    return Dependent(call=call)
+
+
+async def call_with_dependencies[T](fn: BaseFn[T], context: Context | None = None) -> T:
+    async with AsyncExitStack() as stack:
+        kwargs = await resolve(fn, cache={}, context=context or {}, exit_stack=stack, no_call=True)
+        return await fn(**kwargs)
+
+
+def get_dependant(annotation: t.Any) -> Dependent | None:
+    if t.get_origin(annotation) is not t.Annotated:
+        return None
+
+    _, *metadata = t.get_args(annotation)
+    for meta in metadata:
+        if isinstance(meta, Dependent):
+            return meta
+    return None
+
+
+async def resolve(
+    fn: DepFn, cache: Cache, context: Context, exit_stack: AsyncExitStack, no_call: bool = False
+) -> t.Any:
+    if fn in cache:
+        return cache[fn]
+
+    kwargs: dict[str, t.Any] = {}
+
+    for param in get_signature(fn):
+        if context.get(param.name) is not None:
+            kwargs[param.name] = context[param.name]
+            continue
+
+        dep = get_dependant(param.annotation)
+        if dep is not None:
+            kwargs[param.name] = await resolve(dep.call, cache=cache, context=context, exit_stack=exit_stack)
+            continue
+
+        if param.default is inspect.Parameter.empty:
+            raise TypeError(f"Unresolvable dependency parameter: {param.name}")
+
+        kwargs[param.name] = param.default
+
+    if no_call:
+        return kwargs
+
+    result: t.Any = fn(**kwargs)
+    result = to_context_manager(result) if inspect.isasyncgen(result) else result
+
+    if isinstance(result, AbstractAsyncContextManager):
+        value = await exit_stack.enter_async_context(result)
+    elif inspect.isawaitable(result):
+        value = await result
+    else:
+        value = result
+
+    cache[fn] = value
+    return value

skoll/utils/functional.py

@@ -0,0 +1,169 @@
+import re
+import os
+import inspect
+import functools
+import typing as t
+from ulid import ulid
+from json import loads
+import collections.abc as c
+from zoneinfo import ZoneInfo
+from datetime import datetime, timezone
+from contextlib import asynccontextmanager
+
+
+__all__ = [
+    "to_tz",
+    "new_ulid",
+    "safe_call",
+    "from_json",
+    "serialize",
+    "impartial",
+    "sanitize_dict",
+    "to_camel_case",
+    "to_snake_case",
+    "get_signature",
+    "unwrapped_call",
+    "get_config_var",
+    "to_context_manager",
+]
+
+
+new_ulid: t.Callable[[], str] = lambda: ulid().lower()
+
+
+def from_json(val: t.Any) -> t.Any:
+    try:
+        return loads(val)
+    except:
+        return None
+
+
+def sanitize_dict(obj: dict[str, t.Any]) -> dict[str, t.Any]:
+    return {
+        k: sanitize_dict(t.cast(dict[str, t.Any], v)) if isinstance(v, dict) else v
+        for k, v in obj.items()
+        if v is not None
+    }
+
+
+def to_snake_case(val: t.Any) -> t.Any:
+    if isinstance(val, dict):
+        return {to_snake_case(k): to_snake_case(v) for k, v in val.items()}
+    if isinstance(val, list):
+        return [to_snake_case(i) for i in val]
+    if isinstance(val, str):
+        # Insert underscores before capitals and lowercase everything
+        s = re.sub(r"(.)([A-Z][a-z]+)", r"\1_\2", val)
+        return re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", s).lower()
+    return val
+
+
+def to_camel_case(val: t.Any) -> t.Any:
+    if isinstance(val, dict):
+        return {to_camel_case(k): to_camel_case(v) for k, v in val.items()}
+    if isinstance(val, list):
+        return [to_camel_case(i) for i in val]
+    if isinstance(val, str):
+        components = val.split("_")
+        return components[0] + "".join(x.title() for x in components[1:])
+    return val
+
+
+def serialize(data: t.Any) -> t.Any:
+    if hasattr(data, "serialize") and callable(getattr(data, "serialize")):
+        return data.serialize()
+    if isinstance(data, (list, tuple)):
+        return [serialize(x) for x in data]
+    if isinstance(data, dict):
+        res_dict = {}
+        for key, data in data.items():
+            res_dict[key] = serialize(data)
+        return res_dict
+    return data
+
+
+def iso_to_timestamp(date_string: str, format: str = "%Y-%m-%dT%H:%M:%SZ"):
+    dt = datetime.strptime(date_string, format)
+    dt = dt.replace(tzinfo=timezone.utc)
+    return int(dt.timestamp() * 1000)
+
+
+def timestamp_to_iso(timestamp: int, format: str = "%Y-%m-%dT%H:%M:%SZ") -> str:
+    dt = datetime.fromtimestamp(timestamp / 1000, tz=timezone.utc)
+    return dt.strftime(format)
+
+
+def find_item[T](match_with: t.Callable[[T], bool], items: list[T]) -> T | None:
+    found_item: T | None = None
+    for item in items:
+        if match_with(item):
+            found_item = item
+            break
+    return found_item
+
+
+def to_tz(tz_str: str) -> ZoneInfo:
+    try:
+        return ZoneInfo(key=tz_str)
+    except:
+        return ZoneInfo("UTC")
+
+
+def names_from_email(email: str) -> tuple[str, str]:
+    names = email.split("@")[0].split(".")
+    if len(names) == 0:
+        return "", ""
+    if len(names) == 1:
+        return names[0], ""
+    return " ".join(names[:-1]), names[-1]
+
+
+def safe_call[T](func: t.Callable[..., T], *args: t.Any, **kwargs: t.Any) -> T | None:
+    try:
+        return func(*args, **kwargs)
+    except:
+        return None
+
+
+@asynccontextmanager
+async def to_context_manager(gen: c.AsyncGenerator[t.Any, t.Any]):
+    try:
+        value = await gen.__anext__()
+        yield value
+    finally:
+        await gen.aclose()
+
+
+def get_signature(fn: t.Callable[..., t.Any]) -> list[inspect.Parameter]:
+    unwrapped = unwrapped_call(fn)
+    if unwrapped is None:
+        return []
+    return list(inspect.signature(unwrapped).parameters.values())
+
+
+def unwrapped_call(call: t.Callable[..., t.Any] | None) -> t.Callable[..., t.Any] | None:
+    if call is None:
+        return call
+    unwrapped = inspect.unwrap(impartial(call))
+    return unwrapped
+
+
+def impartial(func: t.Callable[..., t.Any]) -> t.Callable[..., t.Any]:
+    while isinstance(func, functools.partial):
+        func = func.func
+    return func
+
+
+def get_config_var(keys: list[str], default: str | None = None) -> t.Callable[[], str | None]:
+
+    def get_var() -> str | None:
+        for key in keys:
+            if "/" in key:
+                with open(key, "r") as f:
+                    return f.read().strip()
+            value = os.getenv(key)
+            if value:
+                return value
+        return default
+
+    return get_var

skoll-0.0.1.dist-info/METADATA

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: skoll
+Version: 0.0.1
+Summary: A simple package that provide a basic API python framework based on starlette and some domain driven design concepts
+Author-email: Monzon Diarra <diarramonzon4@gmail.com>
+License-File: LICENSE
+Requires-Python: >=3.13
+Requires-Dist: aiohttp>=3.13.3
+Requires-Dist: asyncpg>=0.31.0
+Requires-Dist: attrs>=25.4.0
+Requires-Dist: certifi>=2026.1.4
+Requires-Dist: starlette>=0.49.3
+Requires-Dist: ulid>=1.1
+Description-Content-Type: text/markdown
+
+# Skoll
+
+A simple package that provide a basic API python framework based on starlette and some domain driven design concepts.
+
+## Installation
+
+```bash
+pip install skoll
+```
+
+## Usage
+
+Comming soon...
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.