jamlib 3.0.0b12.dev3__tar.gz → 3.0.0b13__tar.gz

{jamlib-3.0.0b12.dev3/src/jamlib.egg-info → jamlib-3.0.0b13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jamlib
-Version: 3.0.0b12.dev3
+Version: 3.0.0b13
 Summary: Simple and universal library for authorization.
 Author-email: Makridenko Adrian <adrianmakridenko@duck.com>, Ksenia Travnikova <kseniatravnikova@duck.com>
 License: Apache-2.0

{jamlib-3.0.0b12.dev3 → jamlib-3.0.0b13}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "jamlib"
-version = "3.0.0b12.dev3"
+version = "3.0.0b13"
 description = "Simple and universal library for authorization."
 authors = [
     {name = "Makridenko Adrian",email = "adrianmakridenko@duck.com"},

{jamlib-3.0.0b12.dev3 → jamlib-3.0.0b13}/src/jam/__init__.py

@@ -12,5 +12,5 @@ from jam.encoders import JsonEncoder
 from jam.instance import Jam
 
 
-__version__ = "3.0.0b12.dev3"
+__version__ = "3.0.0b13"
 __all__ = ["Jam", "JsonEncoder", "BaseJam", "BaseEncoder"]

{jamlib-3.0.0b12.dev3 → jamlib-3.0.0b13}/src/jam/exceptions/__init__.py

@@ -36,7 +36,12 @@ from .paseto import (
     JamPASETOInvalidTokenFormat
 )
 
-from .plugins import JamLitestarPluginConfigError, JamLitestarPluginError
+from .plugins import (
+    JamLitestarPluginConfigError,
+    JamLitestarPluginError,
+    JamStarlettePluginConfigError,
+    JamStarlettePluginError
+)
 
 from .sessions import (
     JamSessionNotFound,
@@ -67,6 +72,8 @@ __all__ = [
     "JamPASTOKeyVerificationError",
     "JamLitestarPluginConfigError",
     "JamLitestarPluginError",
+    "JamStarlettePluginConfigError",
+    "JamStarlettePluginError",
     "JamSessionNotFound",
     "JamSessionEmptyAESKey",
 ]

{jamlib-3.0.0b12.dev3 → jamlib-3.0.0b13}/src/jam/exceptions/plugins.py

@@ -15,3 +15,16 @@ class JamLitestarPluginError(JamError):
 
     default_message = "An error occurred for a litestar plugin."
     default_code = "jam.plugin.litestar"
+
+class JamStarlettePluginConfigError(JamConfigurationError):
+    """Exception raised when a configuration error occurs for a starlette plugin."""
+
+    default_message = "Configuration error occurred for a starlette plugin."
+    default_code = "jam.configuration.plugin.starlette"
+
+
+class JamStarlettePluginError(JamError):
+    """Exception raised when an error occurs for a starlette plugin."""
+
+    default_message = "An error occurred for a starlette plugin."
+    default_code = "jam.plugin.starlette"

{jamlib-3.0.0b12.dev3 → jamlib-3.0.0b13}/src/jam/ext/litestar/__init__.py

@@ -16,7 +16,8 @@ from .plugins import (
     BasePlugin,
     JamJWTPlugin,
     JamSessionPlugin,
-    JamPASETOPlugin
+    JamPASETOPlugin,
+    JamOAuth2Plugin,
 )
 
 __all__ = [
@@ -27,4 +28,5 @@ __all__ = [
     "JamJWTPlugin",
     "JamSessionPlugin",
     "JamPASETOPlugin",
+    "JamOAuth2Plugin",
 ]

{jamlib-3.0.0b12.dev3 → jamlib-3.0.0b13}/src/jam/ext/litestar/plugins.py

@@ -17,6 +17,7 @@ from jam.ext.litestar.middleware import (
 )
 from jam.ext.litestar.objects import BaseUser
 from jam.jwt import JWT
+from jam.oauth2 import create_instance as create_oauth2
 from jam.paseto import create_instance as create_paseto
 from jam.utils.config_maker import GENERIC_POINTER, __config_maker__
 
@@ -25,23 +26,34 @@ class BasePlugin(InitPlugin):
     """Base Litestar plugin."""
 
     MODULE: Callable
-    _MIDDLEWARE: type[BaseMiddleware]
+    MIDDLEWARE: type[BaseMiddleware]
     _DI_KEY: str
     _CONFIG_KEY: str
 
     def _setup_config(self, config: dict[str, Any]) -> None:
         self._auth = self.MODULE(**config)
 
-    def __init__(  # noqa
+    def __init__(
         self,
         config: dict[str, Any] | str | None = None,
         pointer: str = GENERIC_POINTER,
         cookie_name: str | None = None,
         header_name: str | None = None,
         middleware: bool = True,
-        middleware_user: type[BaseUser] | None = None,
+        user: type[BaseUser] | None = None,
         **kwargs,
     ) -> None:
+        """Initialize the plugin.
+
+        Args:
+            config (dict[str, Any] | str | None): Jam config as path/to/file or dict.
+            pointer (str): Config pointer
+            cookie_name (str | None): Cookie name to read token
+            header_name (str | None): Header name to read token
+            middleware (bool): Use middleware?
+            user (type[BaseUser]): User for request state. See: DOCUMENTATION
+            **kwargs: Config arguments if config=None
+        """
         if middleware and (not cookie_name and not header_name):
             raise JamLitestarPluginConfigError(
                 message="Cookie name and header name cannot be both None.",
@@ -50,11 +62,11 @@ class BasePlugin(InitPlugin):
                     "header_name": header_name,
                 },
             )
-        if middleware and not middleware_user:
+        if middleware and not user:
             raise JamLitestarPluginConfigError(
                 message="Middleware user cannot be None when middleware is True.",
                 details={
-                    "middleware_user": middleware_user,
+                    "middleware_user": user,
                 },
             )
 
@@ -67,11 +79,11 @@ class BasePlugin(InitPlugin):
         self._middleware = None
 
         if middleware:
-            _middleware = self._MIDDLEWARE
+            _middleware = self.MIDDLEWARE
             _middleware.COOKIE_NAME = cookie_name
             _middleware.HEADER_NAME = header_name
             _middleware.AUTH_MODULE = self._auth
-            _middleware.USER = middleware_user  # type: ignore
+            _middleware.USER = user  # type: ignore
             self._middleware = _middleware
 
     def on_app_init(self, app_config: AppConfig) -> AppConfig:  # noqa
@@ -88,7 +100,7 @@ class JamJWTPlugin(BasePlugin):
     """JWT plugin for litestar."""
 
     MODULE = JWT
-    _MIDDLEWARE = JWTMiddleware
+    MIDDLEWARE = JWTMiddleware
     _DI_KEY = "jwt"
     _CONFIG_KEY = "jwt"
 
@@ -97,7 +109,7 @@ class JamSessionPlugin(BasePlugin):
     """Sessions plugin for litestar."""
 
     MODULE = staticmethod(create_session)
-    _MIDDLEWARE = SessionMiddleware
+    MIDDLEWARE = SessionMiddleware
     _DI_KEY = "session"
     _CONFIG_KEY = "sessions"
 
@@ -106,6 +118,40 @@ class JamPASETOPlugin(BasePlugin):
     """PASETO plugin for litestar."""
 
     MODULE = staticmethod(create_paseto)
-    _MIDDLEWARE = PASETOMiddleware
+    MIDDLEWARE = PASETOMiddleware
     _DI_KEY = "paseto"
     _CONFIG_KEY = "paseto"
+
+
+class JamOAuth2Plugin(BasePlugin):
+    """OAuth2 plugin for litestar."""
+
+    MODULE = staticmethod(create_oauth2)
+    _DI_KEY = "oauth2"
+    _CONFIG_KEY = "oauth2"
+
+    def __init__(
+        self,
+        config: str | dict[str, Any] | None = None,
+        pointer: str = GENERIC_POINTER,
+        **kwargs,
+    ) -> None:
+        """Initialize the OAuth2 plugin.
+
+        Args:
+            config (dict[str, Any] | str | None): Jam config as path/to/file or dict.
+            pointer (str): Config pointer
+            **kwargs: Config arguments if config=None
+        """
+        _config: dict[str, Any] | None = (
+            __config_maker__(config, pointer) if config else None
+        )
+
+        params = _config.pop(self._CONFIG_KEY) if _config else kwargs
+        self._setup_config(params)
+
+    def on_app_init(self, app_config: AppConfig) -> AppConfig:  # noqa
+        app_config.dependencies[self._DI_KEY] = Provide(
+            lambda: self._auth, sync_to_thread=True
+        )
+        return app_config

jamlib-3.0.0b13/src/jam/ext/starlette/__init__.py

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+
+"""Starlette integration.
+
+Starlette docs: https://starlette.dev
+"""
+
+from .objects import BaseUser, SimpleUser
+from .backends import JWTBackend, SessionBackend, PASETOBackend
+
+
+__all__ = [
+    "BaseUser",
+    "SimpleUser",
+    "JWTBackend",
+    "SessionBackend",
+    "PASETOBackend",
+]

jamlib-3.0.0b13/src/jam/ext/starlette/backends.py

@@ -0,0 +1,153 @@
+# -*- coding: utf-8 -*-
+
+from collections.abc import Callable
+from typing import Any
+
+from starlette.authentication import (
+    AuthCredentials,
+    AuthenticationBackend,
+    UnauthenticatedUser,
+)
+from starlette.authentication import BaseUser as StarletteBaseUser
+from starlette.requests import HTTPConnection
+
+from jam.aio.sessions import create_instance as create_session
+from jam.exceptions import JamStarlettePluginConfigError
+from jam.ext.starlette.objects import BaseUser, SimpleUser
+from jam.jwt import JWT
+from jam.paseto import create_instance as create_paseto
+from jam.utils.config_maker import GENERIC_POINTER, __config_maker__
+
+
+class BaseBackend(AuthenticationBackend):
+    """Base Jam backend."""
+
+    MODULE: Callable
+    _CONFIG_KEY: str
+
+    def __init__(  # noqa
+        self,
+        config: str | dict[str, Any] | None = None,
+        pointer: str = GENERIC_POINTER,
+        cookie_name: str | None = None,
+        header_name: str | None = None,
+        user: type[BaseUser] = SimpleUser,
+        **kwargs,
+    ) -> None:
+        if not cookie_name and not header_name:
+            raise JamStarlettePluginConfigError(
+                message="cookie_name or header_name must be provided.",
+                details={
+                    "cookie_name": cookie_name,
+                    "header_name": header_name,
+                },
+            )
+        self._cookie_name = cookie_name
+        self._header_name = header_name
+        self._user = user
+        self._config_setup(config, pointer, kwargs)
+
+    def _get_auth_token(self, connection: HTTPConnection) -> str | None:
+        if self._cookie_name:
+            token = connection.cookies.get(self._cookie_name, None)
+        elif self._header_name:
+            token_bear = connection.headers.get(self._header_name, None)
+            if token_bear:
+                token = token_bear.split("Bearer ")[1]  # noqa: E701
+            else:
+                token = None  # noqa: E701
+        else:
+            raise JamStarlettePluginConfigError(
+                message="cookie_name or header_name must be provided.",
+                details={
+                    "cookie_name": self._cookie_name,
+                    "header_name": self._header_name,
+                },
+            )
+        return token
+
+    def _config_setup(
+        self,
+        config: dict[str, Any] | str | None,
+        pointer: str,
+        kwargs: dict[str, Any],
+    ) -> None:
+        try:
+            if config:
+                config_ = __config_maker__(config, pointer)[self._CONFIG_KEY]
+                self._auth = self.MODULE(**config_)
+            else:
+                self._auth = self.MODULE(**kwargs)
+        except Exception as e:
+            raise JamStarlettePluginConfigError(
+                message="Error while building auth modile.",
+                details={
+                    "module": self.MODULE.__str__,
+                    "config": {
+                        "config": config,
+                        "pointer": pointer,
+                        "kwargs": kwargs,
+                    },
+                    "config_key": self._CONFIG_KEY,
+                    "error": str(e),
+                },
+            )
+
+
+class JWTBackend(BaseBackend):
+    """JWT Backend for litestar."""
+
+    MODULE = JWT
+    _CONFIG_KEY = "jwt"
+
+    async def authenticate(  # noqa
+        self, conn: HTTPConnection
+    ) -> tuple[AuthCredentials, StarletteBaseUser] | None:
+        setattr(conn.state, "jwt", self._auth)
+        token = self._get_auth_token(conn)
+        if token:
+            data = self._auth.decode(token)
+            user = self._user.from_payload(data)
+            return AuthCredentials(["authenticated"]), user
+
+        return AuthCredentials(None), UnauthenticatedUser()
+
+
+class SessionBackend(BaseBackend):
+    """Session backend."""
+
+    MODULE = staticmethod(create_session)
+    _CONFIG_KEY = "sessions"
+
+    async def authenticate(  # noqa
+        self, conn: HTTPConnection
+    ) -> tuple[AuthCredentials, StarletteBaseUser] | None:
+        setattr(conn.state, "session", self._auth)
+        session_id = self._get_auth_token(conn)
+        if session_id:
+            data = await self._auth.get(session_id)
+            if data:
+                user = self._user.from_payload(data)
+                return AuthCredentials(["authenticated"]), user
+
+        return AuthCredentials(None), UnauthenticatedUser()
+
+
+class PASETOBackend(BaseBackend):
+    """PASETO auth backend."""
+
+    MODULE = staticmethod(create_paseto)
+    _CONFIG_KEY = "paseto"
+
+    async def authenticate(  # noqa
+        self, conn: HTTPConnection
+    ) -> tuple[AuthCredentials, StarletteBaseUser] | None:
+        setattr(conn.state, "paseto", self._auth)
+        token = self._get_auth_token(conn)
+        if token:
+            data = self._auth.decode(token)
+            if data:
+                user = self._user.from_payload(data)
+                return AuthCredentials(["authenticated"]), user
+
+        return AuthCredentials(None), UnauthenticatedUser()

jamlib-3.0.0b13/src/jam/ext/starlette/objects.py

@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Any, TypeVar
+
+from starlette.authentication import BaseUser as StarletteBaseUser
+
+
+User = TypeVar("User", bound="BaseUser")
+
+
+class BaseUser(ABC, StarletteBaseUser):
+    """BaseUser with builder from payload."""
+
+    @classmethod
+    @abstractmethod
+    def from_payload(cls, payload: dict[str, Any]) -> User:
+        """Create instance by payload.
+
+        Args:
+            payload (dict[str, Any]): Payload from auth
+
+        Example:
+        ```python
+
+        class MyUser(JamBaseUser):
+            id: int
+            username: str
+
+            @classmethod
+            def from_payload(cls, payload):
+                return cls(
+                    id=payload["id"],
+                    username=payload["username"]
+                )
+
+        payload = jwt.decode(token)
+        user = MyUser.from_payload(payload)
+        ```
+        """
+        raise NotImplementedError
+
+
+@dataclass(slots=True)
+class SimpleUser(BaseUser):
+    """Simple user with payload only."""
+
+    payload: dict[str, Any]
+
+    @classmethod
+    def from_payload(cls, payload: dict[str, Any]):  # noqa
+        return cls(payload=payload)

{jamlib-3.0.0b12.dev3 → jamlib-3.0.0b13}/src/jam/jwt/__algorithms__.py

@@ -100,7 +100,11 @@ class BaseAlgorithm(ABC):
         from pathlib import Path
 
         path = Path(data)
-        return path.read_bytes() if path.is_file() else data.encode()
+        try:
+            is_file = path.is_file()
+        except OSError:
+            is_file = False
+        return path.read_bytes() if is_file else data.encode()
 
     def _load_private_key(
         self, key_bytes: bytes | None, key_obj: Any | None

{jamlib-3.0.0b12.dev3 → jamlib-3.0.0b13/src/jamlib.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jamlib
-Version: 3.0.0b12.dev3
+Version: 3.0.0b13
 Summary: Simple and universal library for authorization.
 Author-email: Makridenko Adrian <adrianmakridenko@duck.com>, Ksenia Travnikova <kseniatravnikova@duck.com>
 License: Apache-2.0

{jamlib-3.0.0b12.dev3 → jamlib-3.0.0b13}/src/jamlib.egg-info/SOURCES.txt

@@ -41,8 +41,8 @@ src/jam/ext/litestar/middleware.py
 src/jam/ext/litestar/objects.py
 src/jam/ext/litestar/plugins.py
 src/jam/ext/starlette/__init__.py
-src/jam/ext/starlette/auth_backends.py
-src/jam/ext/starlette/value.py
+src/jam/ext/starlette/backends.py
+src/jam/ext/starlette/objects.py
 src/jam/jwt/__algorithms__.py
 src/jam/jwt/__base__.py
 src/jam/jwt/__init__.py

jamlib-3.0.0b12.dev3/src/jam/ext/starlette/__init__.py

@@ -1,12 +0,0 @@
-# -*- coding: utf-8 -*-
-
-"""
-Starlette integration.
-
-Starlette docs: https://starlette.dev
-"""
-
-from .auth_backends import JWTBackend, SessionBackend
-
-
-__all__ = ["JWTBackend", "SessionBackend"]

jamlib-3.0.0b12.dev3/src/jam/ext/starlette/auth_backends.py

@@ -1,143 +0,0 @@
-# -*- coding: utf-8 -*-
-
-from typing import Any
-
-from starlette.authentication import (
-    AuthCredentials,
-    AuthenticationBackend,
-    AuthenticationError,
-    BaseUser,
-)
-from starlette.requests import HTTPConnection
-
-from jam.__base__ import BaseJam
-from jam.utils.await_maybe import await_maybe
-
-from .value import Payload
-
-
-class JWTBackend(AuthenticationBackend):
-    """JWT Backend for Starlette AuthenticationMiddleware."""
-
-    def __init__(
-        self,
-        jam: BaseJam,
-        cookie_name: str | None = None,
-        header_name: str | None = "Authorization",
-    ) -> None:
-        """Constructor.
-
-        Args:
-            jam (BaseJam): Jam instance
-            cookie_name (str | None): Access token cookie name
-            header_name (str | None): Access token header name
-        """
-        self._jam = jam
-        self.cookie_name = cookie_name
-        self.header_name = header_name
-        self.__use_list = bool(getattr(self._jam.jwt, "list", False))
-
-    async def authenticate(
-        self, conn: HTTPConnection
-    ) -> tuple[AuthCredentials, BaseUser] | None:
-        """Starlette authentication handler."""
-        logger = self._jam._logger
-        token = None
-
-        logger.debug("JWTBackend: Attempting to extract token from request")
-        if self.cookie_name:
-            token = conn.cookies.get(self.cookie_name)
-            if token:
-                logger.debug(f"Token found in cookie '{self.cookie_name}'")
-
-        if not token and self.header_name:
-            header = conn.headers.get(self.header_name)
-            if header and header.startswith("Bearer "):
-                token = header.split("Bearer ")[1]
-                logger.debug(f"Token found in header '{self.header_name}'")
-
-        if not token:
-            logger.debug("No token found in request")
-            return None
-
-        logger.debug(
-            f"Verifying JWT token (length: {len(token)} chars), check_list={self.__use_list}"
-        )
-        try:
-            payload: dict[str, Any] = await await_maybe(
-                self._jam.jwt_verify_token(
-                    token=token, check_exp=True, check_list=self.__use_list
-                )
-            )
-            logger.debug(
-                f"JWT token verified successfully, payload keys: {list(payload.keys())}"
-            )
-        except Exception as e:
-            logger.warning(f"Token verify error: {e}")
-            raise AuthenticationError("Token verification failed.")
-
-        return AuthCredentials(["authenticated"]), Payload(payload=payload)
-
-
-class SessionBackend(AuthenticationBackend):
-    """Sessions backend for starlette."""
-
-    def __init__(
-        self,
-        jam: BaseJam,
-        cookie_name: str | None = "sessionId",
-        header_name: str | None = None,
-    ) -> None:
-        """Constructor.
-
-        Args:
-            jam (BaseJam): Jam instance
-            cookie_name (str | None): Session id cookie name
-            header_name (str | None): Session id header name
-        """
-        self._jam = jam
-        self.cookie_name = cookie_name
-        self.header_name = header_name
-
-    async def authenticate(
-        self, conn: HTTPConnection
-    ) -> tuple[AuthCredentials, BaseUser] | None:
-        """Starlette authentication handler."""
-        logger = self._jam._logger
-        session_id = None
-
-        logger.debug(
-            "SessionBackend: Attempting to extract session ID from request"
-        )
-        if self.cookie_name:
-            session_id = conn.cookies.get(self.cookie_name)
-            if session_id:
-                logger.debug(f"Session ID found in cookie '{self.cookie_name}'")
-
-        if not session_id and self.header_name:
-            header = conn.headers.get(self.header_name)
-            if header and header.startswith("Bearer "):
-                session_id = header.split("Bearer ")[1]
-                logger.debug(f"Session ID found in header '{self.header_name}'")
-
-        if not session_id:
-            logger.debug("No session ID found in request")
-            return None
-
-        logger.debug(f"Getting session data for session ID: {session_id}")
-        try:
-            payload: dict[str, Any] | None = await await_maybe(  # type: ignore[arg-type]
-                self._jam.session_get(session_id)  # type: ignore[arg-type]
-            )
-            if payload:
-                logger.debug(
-                    f"Session data retrieved successfully, keys: {list(payload.keys())}"
-                )
-            else:
-                logger.debug(f"Session {session_id} not found")
-                # TODO: Return unauthized user
-        except Exception as e:
-            logger.warning(f"Session retrieval error: {e}")
-            raise AuthenticationError("Token verification failed.")
-
-        return AuthCredentials(["authenticated"]), Payload(payload=payload)

jamlib-3.0.0b12.dev3/src/jam/ext/starlette/value.py

@@ -1,18 +0,0 @@
-# -*- coding: utf-8 -*-
-
-from typing import Any
-
-from starlette.authentication import BaseUser
-
-
-class Payload(BaseUser):
-    """Auth payload."""
-
-    def __init__(self, payload: dict[str, Any] | None):
-        """Auth payload."""
-        self.payload = payload
-
-    @property
-    def is_authenticated(self) -> bool:
-        """Auth checker."""
-        return True