jamlib 3.0.0b12.dev4__tar.gz → 3.0.0b13.dev0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jamlib
-Version: 3.0.0b12.dev4
+Version: 3.0.0b13.dev0
 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.dev4 → jamlib-3.0.0b13.dev0}/pyproject.toml

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

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

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

{jamlib-3.0.0b12.dev4 → jamlib-3.0.0b13.dev0}/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.dev4 → jamlib-3.0.0b13.dev0}/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.dev4 → jamlib-3.0.0b13.dev0}/src/jam/ext/litestar/plugins.py

@@ -26,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.",
@@ -51,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,
                 },
             )
 
@@ -68,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
@@ -89,7 +100,7 @@ class JamJWTPlugin(BasePlugin):
     """JWT plugin for litestar."""
 
     MODULE = JWT
-    _MIDDLEWARE = JWTMiddleware
+    MIDDLEWARE = JWTMiddleware
     _DI_KEY = "jwt"
     _CONFIG_KEY = "jwt"
 
@@ -98,7 +109,7 @@ class JamSessionPlugin(BasePlugin):
     """Sessions plugin for litestar."""
 
     MODULE = staticmethod(create_session)
-    _MIDDLEWARE = SessionMiddleware
+    MIDDLEWARE = SessionMiddleware
     _DI_KEY = "session"
     _CONFIG_KEY = "sessions"
 
@@ -107,13 +118,13 @@ 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."""
+    """OAuth2 plugin for litestar."""
 
     MODULE = staticmethod(create_oauth2)
     _DI_KEY = "oauth2"
@@ -128,9 +139,9 @@ class JamOAuth2Plugin(BasePlugin):
         """Initialize the OAuth2 plugin.
 
         Args:
-            config (str | dict[str, Any] | None): The configuration for the OAuth2 plugin.
-            pointer (str): The pointer to the configuration in the app config.
-            **kwargs: Additional keyword arguments.
+            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

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

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+
+"""Starlette integration.
+
+Starlette docs: https://starlette.dev
+"""

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

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+
+from collections.abc import Callable
+from typing import Any
+
+from starlette.authentication import AuthenticationBackend, BaseUser
+
+from jam.exceptions import JamStarlettePluginConfigError
+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] | None = None,
+        **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 _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),
+                },
+            )

{jamlib-3.0.0b12.dev4 → jamlib-3.0.0b13.dev0}/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.dev4 → jamlib-3.0.0b13.dev0/src/jamlib.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jamlib
-Version: 3.0.0b12.dev4
+Version: 3.0.0b13.dev0
 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.dev4 → jamlib-3.0.0b13.dev0}/src/jamlib.egg-info/SOURCES.txt

@@ -41,8 +41,7 @@ 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/jwt/__algorithms__.py
 src/jam/jwt/__base__.py
 src/jam/jwt/__init__.py

jamlib-3.0.0b12.dev4/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.dev4/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.dev4/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