jamlib 3.0.0b13.dev2__tar.gz → 3.0.0b15__tar.gz

{jamlib-3.0.0b13.dev2/src/jamlib.egg-info → jamlib-3.0.0b15}/PKG-INFO

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

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

{jamlib-3.0.0b13.dev2 → jamlib-3.0.0b15}/src/jam/__init__.py

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

{jamlib-3.0.0b13.dev2 → jamlib-3.0.0b15}/src/jam/exceptions/__init__.py

@@ -4,16 +4,12 @@
 All Jam exceptions
 """
 
-from .base import (
-    JamError,
-    JamConfigurationError,
-    JamValidationError
-)
+from .base import JamError, JamConfigurationError, JamValidationError
 
 from .oauth2 import (
     JamOAuth2Error,
     JamOAuth2EmptyRaw,
-    JamOAuth2ProviderNotConfigured
+    JamOAuth2ProviderNotConfigured,
 )
 
 from .jwt import (
@@ -33,14 +29,14 @@ from .paseto import (
     JamPASETOInvalidSecp384r1Key,
     JamPASTOKeyVerificationError,
     JamPASETOInvalidPurpose,
-    JamPASETOInvalidTokenFormat
+    JamPASETOInvalidTokenFormat,
 )
 
 from .plugins import (
+    JamFlaskPluginConfigError,
+    JamFlaskPluginError,
     JamLitestarPluginConfigError,
     JamLitestarPluginError,
-    JamStarlettePluginConfigError,
-    JamStarlettePluginError
 )
 
 from .sessions import (
@@ -72,8 +68,8 @@ __all__ = [
     "JamPASTOKeyVerificationError",
     "JamLitestarPluginConfigError",
     "JamLitestarPluginError",
-    "JamStarlettePluginConfigError",
-    "JamStarlettePluginError",
+    "JamFlaskPluginConfigError",
+    "JamFlaskPluginError",
     "JamSessionNotFound",
     "JamSessionEmptyAESKey",
 ]

{jamlib-3.0.0b13.dev2 → jamlib-3.0.0b15}/src/jam/exceptions/plugins.py

@@ -16,15 +16,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 JamFlaskPluginConfigError(JamConfigurationError):
+    """Exception raised when a configuration error occurs for a flask plugin."""
 
+    default_message = "Configuration error occurred for a flask plugin."
+    default_code = "jam.configuration.plugin.flask"
 
-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"
+class JamFlaskPluginError(JamError):
+    """Exception raised when an error occurs for a flask plugin."""
+
+    default_message = "An error occurred for a flask plugin."
+    default_code = "jam.plugin.flask"

jamlib-3.0.0b15/src/jam/ext/flask/__init__.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+
+"""Flask integration.
+
+Flask docs: https://flask.palletsprojects.com
+"""
+
+from .extensions import (
+    JWTExtension,
+    OAuth2Extension,
+    PASETOExtension,
+    SessionExtension,
+)
+
+from .objects import (
+    Token,
+)
+
+
+__all__ = [
+    "Token",
+    "JWTExtension",
+    "SessionExtension",
+    "PASETOExtension",
+    "OAuth2Extension",
+]

jamlib-3.0.0b15/src/jam/ext/flask/extensions.py

@@ -0,0 +1,212 @@
+# -*- coding: utf-8 -*-
+
+from typing import Any
+
+import flask
+
+from jam.exceptions import JamFlaskPluginConfigError
+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.sessions import create_instance as create_session
+from jam.utils.config_maker import GENERIC_POINTER, __config_maker__
+
+
+class BaseExtension:
+    """Base Jam extension for Flask."""
+
+    MODULE: Any
+    _CONFIG_KEY: str
+
+    def __init__(
+        self,
+        app: flask.Flask | None = None,
+        auth: Any | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the extension.
+
+        Args:
+            app (flask.Flask | None): Flask application instance
+            auth (Any | None): Pre-created auth module instance
+            **kwargs: Configuration arguments
+        """
+        self.app = app
+        self._auth = auth
+        self._config = kwargs
+        if app is not None:
+            self.init_app(app)
+
+    def init_app(self, app: flask.Flask) -> None:
+        """Initialize the Flask application.
+
+        Args:
+            app (flask.Flask): Flask application instance
+        """
+        self.app = app
+        if self._auth is None:
+            self._auth = self.MODULE(**self._config)
+        app.extensions[self._CONFIG_KEY] = self._auth
+
+
+class BaseAuthExtension(BaseExtension):
+    """Base Jam authentication extension for Flask."""
+
+    MODULE: Any
+    _CONFIG_KEY: str
+
+    def __init__(
+        self,
+        app: flask.Flask | None = None,
+        auth: Any | None = None,
+        config: dict[str, Any] | str | None = None,
+        pointer: str = GENERIC_POINTER,
+        cookie_name: str | None = None,
+        header_name: str | None = None,
+        bearer: bool = True,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the authentication extension.
+
+        Args:
+            app (flask.Flask | None): Flask application instance
+            auth (Any | None): Pre-created auth module instance
+            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
+            bearer (bool): Strip "Bearer " prefix from header
+            **kwargs: Configuration arguments if config=None
+        """
+        self._cookie_name = cookie_name
+        self._header_name = header_name
+        self._bearer = bearer
+
+        if not cookie_name and not header_name:
+            raise JamFlaskPluginConfigError(
+                message="Cookie name and header name cannot be both None.",
+                details={
+                    "cookie_name": cookie_name,
+                    "header_name": header_name,
+                },
+            )
+
+        _config: dict[str, Any] | None = (
+            __config_maker__(config, pointer) if config else None
+        )
+
+        params = _config.pop(self._CONFIG_KEY) if _config else kwargs
+        super().__init__(app, auth=auth, **params)
+
+    def _get_token(self) -> str | None:
+        token = None
+        if self._header_name:
+            token = flask.request.headers.get(self._header_name, None)
+            if token and self._bearer and token.startswith("Bearer "):
+                token = token[7:]
+        elif self._cookie_name:
+            token = flask.request.cookies.get(self._cookie_name, None)
+        return token
+
+    def _get_payload(self) -> dict[str, Any] | None:
+        raise NotImplementedError
+
+    def init_app(self, app: flask.Flask) -> None:
+        """Initialize the Flask application."""
+        super().init_app(app)
+        app.before_request(self._put_auth_in_g)
+
+    def _put_auth_in_g(self) -> None:
+        setattr(flask.g, self._CONFIG_KEY, self._auth)
+        self._get_payload()
+
+
+class JWTExtension(BaseAuthExtension):
+    """JWT extension for Flask."""
+
+    MODULE = staticmethod(JWT)
+    _CONFIG_KEY = "jwt"
+
+    def _get_payload(self) -> dict[str, Any] | None:
+        token = self._get_token()
+        flask.g.payload = None
+        if not token:
+            return None
+        try:
+            payload = self._auth.decode(token)
+            flask.g.payload = payload
+            return payload
+        except Exception:
+            return None
+
+
+class SessionExtension(BaseAuthExtension):
+    """Session extension for Flask."""
+
+    MODULE = staticmethod(create_session)
+    _CONFIG_KEY = "sessions"
+
+    def _get_payload(self) -> dict[str, Any] | None:
+        token = self._get_token()
+        flask.g.payload = None
+        if not token:
+            return None
+        try:
+            payload = self._auth.get(token)
+            flask.g.payload = payload
+            return payload
+        except Exception:
+            return None
+
+
+class PASETOExtension(BaseAuthExtension):
+    """PASETO extension for Flask."""
+
+    MODULE = staticmethod(create_paseto)
+    _CONFIG_KEY = "paseto"
+
+    def _get_payload(self) -> dict[str, Any] | None:
+        token = self._get_token()
+        flask.g.payload = None
+        if not token:
+            return None
+        try:
+            data = self._auth.decode(token)
+            if not data:
+                return None
+            payload = data[0] if isinstance(data, tuple) else data
+            flask.g.payload = payload
+            return payload
+        except Exception:
+            return None
+
+
+class OAuth2Extension(BaseExtension):
+    """OAuth2 extension for Flask."""
+
+    MODULE = staticmethod(create_oauth2)
+    _CONFIG_KEY = "oauth2"
+
+    def __init__(
+        self,
+        app: flask.Flask | None = None,
+        auth: Any | None = None,
+        config: dict[str, Any] | str | None = None,
+        pointer: str = GENERIC_POINTER,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the OAuth2 extension.
+
+        Args:
+            app (flask.Flask | None): Flask application instance
+            auth (Any | None): Pre-created auth module instance
+            config (dict[str, Any] | str | None): Jam config as path/to/file or dict.
+            pointer (str): Config pointer
+            **kwargs: Configuration 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
+        super().__init__(app, auth=auth, **params)

jamlib-3.0.0b15/src/jam/ext/flask/objects.py

@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(slots=True)
+class Token:
+    """Data for Authresult."""
+
+    token: str | None

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

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

jamlib-3.0.0b15/src/jam/ext/starlette/auth_backends.py

@@ -0,0 +1,143 @@
+# -*- 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.0b15/src/jam/ext/starlette/value.py

@@ -0,0 +1,18 @@
+# -*- 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

{jamlib-3.0.0b13.dev2 → jamlib-3.0.0b15/src/jamlib.egg-info}/PKG-INFO

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

@@ -36,13 +36,14 @@ src/jam/ext/__init__.py
 src/jam/ext/fastapi/__init__.py
 src/jam/ext/flask/__init__.py
 src/jam/ext/flask/extensions.py
+src/jam/ext/flask/objects.py
 src/jam/ext/litestar/__init__.py
 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/backends.py
-src/jam/ext/starlette/objects.py
+src/jam/ext/starlette/auth_backends.py
+src/jam/ext/starlette/value.py
 src/jam/jwt/__algorithms__.py
 src/jam/jwt/__base__.py
 src/jam/jwt/__init__.py

jamlib-3.0.0b13.dev2/src/jam/ext/flask/__init__.py

@@ -1,11 +0,0 @@
-# -*- coding: utf-8 -*-
-
-"""Flask integration.
-
-Flask docs: https://flask.palletsprojects.com
-"""
-
-from .extensions import JamExtension, JWTExtension, SessionExtension
-
-
-__all__ = ["JamExtension", "JWTExtension", "SessionExtension"]