nlbone 0.1.37__tar.gz → 0.2.0__tar.gz

{nlbone-0.1.37 → nlbone-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nlbone
-Version: 0.1.37
+Version: 0.2.0
 Summary: Backbone package for interfaces and infrastructure in Python projects
 Author-email: Amir Hosein Kahkbazzadeh <a.khakbazzadeh@gmail.com>
 License: MIT

{nlbone-0.1.37 → nlbone-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nlbone"
-version = "0.1.37"
+version = "0.2.0"
 description = "Backbone package for interfaces and infrastructure in Python projects"
 readme = "README.md"
 requires-python = ">=3.10"

{nlbone-0.1.37 → nlbone-0.2.0}/src/nlbone/adapters/auth/keycloak.py

@@ -11,7 +11,7 @@ class KeycloakAuthService(AuthService):
             server_url=s.KEYCLOAK_SERVER_URL.__str__(),
             client_id=s.KEYCLOAK_CLIENT_ID,
             realm_name=s.KEYCLOAK_REALM_NAME,
-            client_secret_key=s.KEYCLOAK_CLIENT_SECRET.__str__(),
+            client_secret_key=s.KEYCLOAK_CLIENT_SECRET.get_secret_value().strip(),
         )
 
     def has_access(self, token, permissions):

{nlbone-0.1.37 → nlbone-0.2.0}/src/nlbone/adapters/db/query_builder.py

@@ -6,7 +6,7 @@ from sqlalchemy.orm import Session, Query
 from sqlalchemy.dialects.postgresql import ENUM as PGEnum
 
 from nlbone.interfaces.api.exceptions import UnprocessableEntityException
-from nlbone.interfaces.api.pagination import PaginateRequest
+from nlbone.interfaces.api.pagination import PaginateRequest, PaginateResponse
 
 NULL_SENTINELS = {"None", "null", ""}
 
@@ -15,7 +15,7 @@ class _InvalidEnum(Exception):
     pass
 
 
-def _apply_order(pagination, entity, query):
+def _apply_order(pagination: PaginateRequest, entity, query):
     if pagination.sort:
         order_clauses = []
         for sort in pagination.sort:
@@ -177,3 +177,13 @@ def apply_pagination(pagination: PaginateRequest, entity, session: Session, limi
     if limit:
         query = query.limit(pagination.limit).offset(pagination.offset)
     return query
+
+
+def get_paginated_response(pagination: PaginateRequest, entity, session: Session, with_count=True) -> PaginateResponse:
+    query = apply_pagination(pagination, entity, session, not with_count)
+    total_count = None
+    if with_count:
+        total_count = query.count()
+        query = query.limit(pagination.limit).offset(pagination.offset)
+    return PaginateResponse(total_count=total_count, data=query.all(), limit=pagination.limit,
+                            offset=pagination.offset).to_dict()

{nlbone-0.1.37 → nlbone-0.2.0}/src/nlbone/config/settings.py

@@ -15,8 +15,8 @@ def _guess_env_file() -> str | None:
     if cwd_env.exists():
         return str(cwd_env)
 
-    for i in range(1, 8):
-        p = Path(__file__).resolve().parents[i]
+    for i in range(0, 8):
+        p = Path.cwd().resolve().parents[i]
         f = p / ".env"
         if f.exists():
             return str(f)

nlbone-0.2.0/src/nlbone/interfaces/api/dependencies/auth.py

@@ -0,0 +1,48 @@
+import functools
+
+from nlbone.adapters.auth import KeycloakAuthService
+from nlbone.interfaces.api.exceptions import ForbiddenException, UnauthorizedException
+from nlbone.utils.context import current_request
+
+
+def client_has_access(*, permissions=None):
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            request = current_request()
+            if not KeycloakAuthService().client_has_access(request.state.token, permissions=permissions):
+                raise ForbiddenException(f"Forbidden {permissions}")
+
+            return func(*args, **kwargs)
+
+        return wrapper
+    return decorator
+
+
+
+def user_authenticated(func):
+    @functools.wraps(func)
+    async def wrapper(*args, **kwargs):
+        request = current_request()
+        if not request.state.user_id:
+            raise UnauthorizedException()
+        return await func(*args, **kwargs)
+
+    return wrapper
+
+
+def has_access(*, permissions=None):
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            request = current_request()
+            if not request.state.user_id:
+                raise UnauthorizedException()
+            if not KeycloakAuthService().has_access(request.state.token, permissions=permissions):
+                raise ForbiddenException(f"Forbidden {permissions}")
+
+            return func(*args, **kwargs)
+
+        return wrapper
+    return decorator
+

nlbone-0.2.0/src/nlbone/interfaces/api/exceptions.py

@@ -0,0 +1,67 @@
+from typing import Any, Iterable
+from fastapi import HTTPException, status
+
+
+def _error_entry(loc: Iterable[Any] | None, msg: str, type_: str) -> dict:
+    return {
+        "loc": list(loc) if loc else [],
+        "msg": msg,
+        "type": type_,
+    }
+
+
+def _errors(loc: Iterable[Any] | None, msg: str, type_: str) -> list[dict]:
+    return [_error_entry(loc, msg, type_)]
+
+
+class BadRequestException(HTTPException):
+    def __init__(self, msg: str):
+        super().__init__(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=msg,
+        )
+
+
+class UnauthorizedException(HTTPException):
+    def __init__(self, msg: str = "unauthorized"):
+        super().__init__(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail=msg,
+        )
+
+
+class ForbiddenException(HTTPException):
+    def __init__(self, msg: str = "forbidden"):
+        super().__init__(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail=msg,
+        )
+
+
+class NotFoundException(HTTPException):
+    def __init__(self, msg: str = "not found"):
+        super().__init__(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=msg,
+        )
+
+
+class ConflictException(HTTPException):
+    def __init__(self, msg: str = "conflict"):
+        super().__init__(
+            status_code=status.HTTP_409_CONFLICT,
+            detail=msg,
+        )
+
+
+class UnprocessableEntityException(HTTPException):
+    def __init__(self, msg: str, loc: Iterable[Any] | None = None, type_: str = "unprocessable_entity"):
+        super().__init__(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=_errors(loc, msg, type_),
+        )
+
+
+class LogicalValidationException(UnprocessableEntityException):
+    def __init__(self, msg: str, loc: Iterable[Any] | None = None, type_: str = "logical_error"):
+        super().__init__(msg=msg, loc=loc, type_=type_)

nlbone-0.2.0/src/nlbone/interfaces/api/pagination/__init__.py

@@ -0,0 +1,9 @@
+from fastapi import Depends
+
+from .offset_base import PaginateResponse, PaginateRequest
+
+
+def get_pagination(
+        req: PaginateRequest = Depends(PaginateRequest)
+) -> PaginateRequest:
+    return req

{nlbone-0.1.37 → nlbone-0.2.0}/src/nlbone/interfaces/api/pagination/offset_base.py

@@ -1,6 +1,3 @@
-# src/nlbone/interfaces/api/pagination.py
-from __future__ import annotations
-
 import json
 from math import ceil
 from typing import Any, Optional
@@ -21,7 +18,7 @@ class PaginateRequest:
         limit: int = 10,
         offset: int = 0,
         sort: Optional[str] = None,
-        filters: Optional[str] = Query(None, description="e.g. title:abc or JSON"),
+        filters: Optional[str] = Query(None, description="e.g. title:abc"),
     ) -> None:
         self.limit = max(0, limit)
         self.offset = max(0, offset)
@@ -78,26 +75,6 @@ class PaginateRequest:
             filters_dict[key] = value_cast
         return filters_dict
 
-    # Helpers for SQLAlchemy usage:
-    def build_order_by(self, model) -> list[Any]:
-        """
-        Translate parsed sort to SQLAlchemy order_by list.
-        Example: model.created_at.desc(), model.id.asc()
-        """
-        items: list[Any] = []
-        for item in self.sort:
-            field = getattr(model, item["field"], None)
-            if field is None:
-                continue
-            items.append(desc(field) if item["order"] == "desc" else asc(field))
-        return items
-
-    def filter_kwargs(self) -> dict[str, Any]:
-        """
-        Return simple equality filters (for model.filter_by(**kwargs)).
-        For advanced ops, extend this to parse operators (gt, lt, like, in, etc.).
-        """
-        return {k: v for k, v in self.filters.items() if k != "$"}
 
 
 class PaginateResponse:

nlbone-0.1.37/src/nlbone/interfaces/api/exceptions.py

@@ -1,8 +0,0 @@
-from fastapi import HTTPException, status
-
-class UnprocessableEntityException(HTTPException):
-    def __init__(self, detail: str, loc: list[str] | None = None):
-        super().__init__(
-            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-            detail={"msg": detail, "loc": loc or []},
-        )

nlbone-0.1.37/src/nlbone/interfaces/api/pagination/__init__.py

@@ -1 +0,0 @@
-from .offset_base import PaginateResponse, PaginateRequest