jamlib 3.2.0b1__tar.gz → 3.2.0b3__tar.gz

{jamlib-3.2.0b1/src/jamlib.egg-info → jamlib-3.2.0b3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jamlib
-Version: 3.2.0b1
+Version: 3.2.0b3
 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.2.0b1 → jamlib-3.2.0b3}/pyproject.toml

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

{jamlib-3.2.0b1 → jamlib-3.2.0b3}/src/jam/__base__.py

@@ -6,7 +6,7 @@ from typing import Any, Literal
 
 from jam.encoders import BaseEncoder, JsonEncoder
 from jam.exceptions import JamConfigurationError
-from jam.jose.__base__ import BaseJWT
+from jam.jose.__base__ import BaseJWE, BaseJWS, BaseJWT
 from jam.logger import BaseLogger, JamLogger
 from jam.oauth2.__base__ import BaseOAuth2Client
 from jam.otp.__base__ import BaseOTP, OTPConfig
@@ -18,7 +18,7 @@ from jam.utils.config_maker import __config_maker__, __module_loader__
 class BaseJam(ABC):
     """Base jam instance."""
 
-    MODULES: dict[str, str] = {}
+    MODULES: dict[str, str | dict[str, str]] = {}
 
     def __init__(
         self,
@@ -55,6 +55,9 @@ class BaseJam(ABC):
         self._logger = logger(log_level)
         self._serializer = serializer
         self.jwt: BaseJWT | None = None
+        self.jws: BaseJWS | None = None
+        self.jwe: BaseJWE | None = None
+        self.jose: dict[str, Any] | None = None
         self.session: BaseSessionModule | None = None
         self.oauth2: dict[str, BaseOAuth2Client] | None = None
         self.otp: OTPConfig | None = None
@@ -69,7 +72,7 @@ class BaseJam(ABC):
         )
         self._logger.debug(
             "BaseJam initialization complete. Modules loaded:\n"
-            f" jwt={self.jwt is not None}, session={self.session is not None}, oauth2={self.oauth2 is not None}"
+            f" jwt={self.jwt is not None}, jose={self.jose is not None}, session={self.session is not None}, oauth2={self.oauth2 is not None}"
         )
         gc.collect()
 
@@ -139,6 +142,7 @@ class BaseJam(ABC):
         """Build instance.
 
         Load modules from configuration and initialize them.
+        Supports both flat modules (name -> path) and nested modules (name -> {subname -> path}).
 
         Args:
             config (dict[str, Any]): Configuration
@@ -151,24 +155,68 @@ class BaseJam(ABC):
                 self._logger.debug(f"Missing configuration for module {name}")
                 continue
 
-            try:
-                module_cls = __module_loader__(path)
-                self._logger.debug(f"Loading module {name} from {path}")
-                params = config.get(name, {})
-                self._logger.debug(
-                    f"Module {name} config params: {list(params.keys())}"
-                )
-                # params["logger"] = self._logger
-                # params["serializer"] = self._serializer
-                module_instance = module_cls(**params)
-                self.__setattr__(name, module_instance)
-                self._logger.debug(f"Module {name} initialized successfully")
-
-            except Exception as e:
-                self._logger.error(
-                    f"Failed to load module {name} from {path}: {e}",
-                    exc_info=True,
-                )
+            if isinstance(path, dict):
+                subconfig = config.get(name, {})
+                if not isinstance(subconfig, dict):
+                    subconfig = {}
+
+                for subname, subpath in path.items():
+                    if subname not in subconfig:
+                        self._logger.debug(
+                            f"Missing configuration for module {name}.{subname}"
+                        )
+                        continue
+
+                    try:
+                        module_cls = __module_loader__(subpath)
+                        self._logger.debug(
+                            f"Loading module {name}.{subname} from {subpath}"
+                        )
+                        params = subconfig.get(subname, {})
+                        self._logger.debug(
+                            f"Module {name}.{subname} config params: {list(params.keys())}"
+                        )
+                        module_instance = module_cls(**params)
+
+                        if self.jose is None:
+                            self.jose = {}
+                        self.jose[subname] = module_instance
+
+                        if subname == "jwt":
+                            self.jwt = module_instance
+                        elif subname == "jws":
+                            self.jws = module_instance
+                        elif subname == "jwe":
+                            self.jwe = module_instance
+
+                        self._logger.debug(
+                            f"Module {name}.{subname} initialized successfully"
+                        )
+
+                    except Exception as e:
+                        self._logger.error(
+                            f"Failed to load module {name}.{subname} from {subpath}: {e}",
+                            exc_info=True,
+                        )
+            else:
+                try:
+                    module_cls = __module_loader__(path)
+                    self._logger.debug(f"Loading module {name} from {path}")
+                    params = config.get(name, {})
+                    self._logger.debug(
+                        f"Module {name} config params: {list(params.keys())}"
+                    )
+                    module_instance = module_cls(**params)
+                    self.__setattr__(name, module_instance)
+                    self._logger.debug(
+                        f"Module {name} initialized successfully"
+                    )
+
+                except Exception as e:
+                    self._logger.error(
+                        f"Failed to load module {name} from {path}: {e}",
+                        exc_info=True,
+                    )
 
     def __otp(
         self, type: Literal["totp", "hotp"] | None = None
@@ -240,6 +288,70 @@ class BaseJam(ABC):
         """
         raise NotImplementedError
 
+    @abstractmethod
+    def jws_sign(
+        self,
+        data: dict[str, Any] | str,
+        header: dict[str, Any] | None = None,
+    ) -> str:
+        """Sign data using JWS.
+
+        Args:
+            data: Data to sign. If dict, will be JSON encoded.
+            header: JWS header.
+
+        Returns:
+            str: JWS token.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def jws_verify(self, token: str) -> dict[str, Any]:
+        """Verify JWS token.
+
+        Args:
+            token: JWS token.
+
+        Returns:
+            dict[str, Any]: Decoded payload.
+
+        Raises:
+            JamJWSVerificationError: If verification fails.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def jwe_encrypt(
+        self,
+        data: dict[str, Any] | str,
+        header: dict[str, Any] | None = None,
+    ) -> str:
+        """Encrypt data using JWE.
+
+        Args:
+            data: Data to encrypt. If dict, will be JSON encoded.
+            header: JWE header.
+
+        Returns:
+            str: JWE token.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def jwe_decrypt(self, token: str) -> bytes:
+        """Decrypt JWE token.
+
+        Args:
+            token: JWE token.
+
+        Returns:
+            bytes: Decrypted data.
+
+        Raises:
+            JamJWEDecryptionError: If decryption fails.
+        """
+        raise NotImplementedError
+
     @abstractmethod
     def session_create(self, session_key: str, data: dict[str, Any]) -> str:
         """Create new session.

{jamlib-3.2.0b1 → jamlib-3.2.0b3}/src/jam/__init__.py

@@ -12,5 +12,5 @@ from jam.encoders import JsonEncoder
 from jam.instance import Jam
 
 
-__version__ = "3.2.0b1"
+__version__ = "3.2.0b3"
 __all__ = ["Jam", "JsonEncoder", "BaseJam", "BaseEncoder"]

{jamlib-3.2.0b1 → jamlib-3.2.0b3}/src/jam/aio/__base__.py

@@ -6,15 +6,19 @@ from typing import Any
 from jam.__base__ import BaseJam
 from jam.aio.oauth2.__base__ import BaseAsyncOAuth2Client
 from jam.aio.sessions.__base__ import BaseAsyncSessionModule
+from jam.jose.__base__ import BaseJWE, BaseJWS
 
 
 class BaseAsyncJam(BaseJam):
     """Base async jam instance."""
 
-    MODULES: dict[str, str] = {}
+    MODULES: dict[str, str | dict[str, str]] = {}
 
     session: BaseAsyncSessionModule | None = None  # type: ignore[override]
     oauth2: dict[str, BaseAsyncOAuth2Client] | None = None  # type: ignore[override]
+    jose: dict[str, Any] | None = None  # type: ignore[override]
+    jws: BaseJWS | None = None  # type: ignore[override]
+    jwe: BaseJWE | None = None  # type: ignore[override]
 
     @abstractmethod
     async def jwt_make_payload(  # type: ignore[override]
@@ -340,6 +344,70 @@ class BaseAsyncJam(BaseJam):
         """
         raise NotImplementedError
 
+    @abstractmethod
+    async def jws_sign(
+        self,
+        data: dict[str, Any] | str,
+        header: dict[str, Any] | None = None,
+    ) -> str:
+        """Sign data using JWS.
+
+        Args:
+            data: Data to sign. If dict, will be JSON encoded.
+            header: JWS header.
+
+        Returns:
+            str: JWS token.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    async def jws_verify(self, token: str) -> dict[str, Any]:
+        """Verify JWS token.
+
+        Args:
+            token: JWS token.
+
+        Returns:
+            dict[str, Any]: Decoded payload.
+
+        Raises:
+            JamJWSVerificationError: If verification fails.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    async def jwe_encrypt(
+        self,
+        data: dict[str, Any] | str,
+        header: dict[str, Any] | None = None,
+    ) -> str:
+        """Encrypt data using JWE.
+
+        Args:
+            data: Data to encrypt. If dict, will be JSON encoded.
+            header: JWE header.
+
+        Returns:
+            str: JWE token.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    async def jwe_decrypt(self, token: str) -> bytes:
+        """Decrypt JWE token.
+
+        Args:
+            token: JWE token.
+
+        Returns:
+            bytes: Decrypted data.
+
+        Raises:
+            JamJWEDecryptionError: If decryption fails.
+        """
+        raise NotImplementedError
+
     @abstractmethod
     async def paseto_decode(  # type: ignore[override]
         self, token: str, check_exp: bool = True, check_list: bool = True

{jamlib-3.2.0b1 → jamlib-3.2.0b3}/src/jam/aio/instance.py

@@ -18,8 +18,12 @@ from jam.exceptions import (
 class Jam(BaseAsyncJam):
     """Main async Jam instance."""
 
-    MODULES: dict[str, str] = {
-        "jwt": "jam.aio.jwt.create_instance",
+    MODULES: dict[str, str | dict[str, str]] = {
+        "jose": {
+            "jwt": "jam.jose.create_jwt_instance",
+            "jws": "jam.jose.create_jws_instance",
+            "jwe": "jam.jose.create_jwe_instance",
+        },
         "session": "jam.aio.sessions.create_instance",
         "oauth2": "jam.aio.oauth2.create_instance",
         "paseto": "jam.paseto.create_instance",
@@ -184,6 +188,76 @@ class Jam(BaseAsyncJam):
             return {"header": headers, "payload": payload}
         return payload
 
+    async def jws_sign(
+        self,
+        data: dict[str, Any] | str,
+        header: dict[str, Any] | None = None,
+    ) -> str:
+        """Sign data using JWS.
+
+        Args:
+            data: Data to sign. If dict, will be JSON encoded.
+            header: JWS header.
+
+        Returns:
+            str: JWS token.
+        """
+        assert self.jws is not None
+        self._logger.debug(f"Signing data with JWS, header: {header}")
+        token = self.jws.sign(header or {}, data)
+        self._logger.debug(f"JWS token created, length: {len(token)}")
+        return token
+
+    async def jws_verify(self, token: str) -> dict[str, Any]:
+        """Verify JWS token.
+
+        Args:
+            token: JWS token.
+
+        Returns:
+            dict[str, Any]: Decoded payload.
+        """
+        assert self.jws is not None
+        self._logger.debug(f"Verifying JWS token, length: {len(token)}")
+        result = self.jws.verify(token)
+        self._logger.debug("JWS token verified successfully")
+        return result
+
+    async def jwe_encrypt(
+        self,
+        data: dict[str, Any] | str,
+        header: dict[str, Any] | None = None,
+    ) -> str:
+        """Encrypt data using JWE.
+
+        Args:
+            data: Data to encrypt. If dict, will be JSON encoded.
+            header: JWE header.
+
+        Returns:
+            str: JWE token.
+        """
+        assert self.jwe is not None
+        self._logger.debug(f"Encrypting data with JWE, header: {header}")
+        token = self.jwe.encrypt(data, header)
+        self._logger.debug(f"JWE token created, length: {len(token)}")
+        return token
+
+    async def jwe_decrypt(self, token: str) -> bytes:
+        """Decrypt JWE token.
+
+        Args:
+            token: JWE token.
+
+        Returns:
+            bytes: Decrypted data.
+        """
+        assert self.jwe is not None
+        self._logger.debug(f"Decrypting JWE token, length: {len(token)}")
+        result = self.jwe.decrypt(token)
+        self._logger.debug("JWE token decrypted successfully")
+        return result
+
     async def session_create(
         self, session_key: str, data: dict[str, Any]
     ) -> str:

{jamlib-3.2.0b1 → jamlib-3.2.0b3}/src/jam/ext/flask/extensions.py

@@ -5,7 +5,7 @@ from typing import Any
 import flask
 
 from jam.exceptions import JamFlaskPluginConfigError
-from jam.jwt import create_instance as create_jwt
+from jam.jose import create_instance as create_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
@@ -170,7 +170,8 @@ class JWTExtension(BaseAuthExtension):
         if not token:
             return None
         try:
-            payload = self._auth.decode(token)
+            result = self._auth.decode(token)
+            payload = result.get("payload", result)
             flask.g.payload = payload
             return payload
         except Exception:

{jamlib-3.2.0b1 → jamlib-3.2.0b3}/src/jam/ext/litestar/middleware.py

@@ -11,7 +11,7 @@ from litestar.middleware import (
 from jam.aio.sessions.__base__ import BaseAsyncSessionModule
 from jam.exceptions import JamLitestarPluginConfigError, JamLitestarPluginError
 from jam.ext.litestar.objects import BaseUser, Token
-from jam.jwt import JWT
+from jam.jose.__base__ import BaseJWT as JWTClass
 from jam.paseto import BasePASETO
 
 
@@ -46,7 +46,7 @@ class BaseMiddleware(AbstractAuthenticationMiddleware):
 class JWTMiddleware(BaseMiddleware):
     """JWT Middleware for litestar."""
 
-    AUTH_MODULE: JWT
+    AUTH_MODULE: JWTClass
     LIST: bool = False
 
     async def authenticate_request(  # noqa
@@ -57,7 +57,8 @@ class JWTMiddleware(BaseMiddleware):
         if not token:
             return AuthenticationResult(user=None, auth=token_model)
         try:
-            data = self.AUTH_MODULE.decode(token)
+            result = self.AUTH_MODULE.decode(token)
+            data = result.get("payload", result)
             if self.AUTH_MODULE.list and self.LIST:
                 match self.AUTH_MODULE.list.__list_type__:
                     case "white":

{jamlib-3.2.0b1 → jamlib-3.2.0b3}/src/jam/ext/litestar/plugins.py

@@ -16,7 +16,7 @@ from jam.ext.litestar.middleware import (
     SessionMiddleware,
 )
 from jam.ext.litestar.objects import BaseUser
-from jam.jwt import create_instance as create_jwt
+from jam.jose import create_instance as create_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__

{jamlib-3.2.0b1 → jamlib-3.2.0b3}/src/jam/ext/starlette/backends.py

@@ -14,7 +14,7 @@ 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 create_instance as create_jwt
+from jam.jose import create_instance as create_jwt
 from jam.paseto import create_instance as create_paseto
 from jam.utils.config_maker import GENERIC_POINTER, __config_maker__
 
@@ -141,7 +141,8 @@ class JWTBackend(BaseBackend):
                         if self._auth.list.check(token):
                             return AuthCredentials(None), UnauthenticatedUser()
             data = self._auth.decode(token)
-            user = self._user.from_payload(data)
+            payload = data.get("payload", data)
+            user = self._user.from_payload(payload)
             return AuthCredentials(["authenticated"]), user
 
         return AuthCredentials(None), UnauthenticatedUser()

{jamlib-3.2.0b1 → jamlib-3.2.0b3}/src/jam/instance.py

@@ -19,8 +19,12 @@ from jam.exceptions import (
 class Jam(BaseJam):
     """Main instance."""
 
-    MODULES: dict[str, str] = {
-        "jwt": "jam.jose.JWT",
+    MODULES: dict[str, str | dict[str, str]] = {
+        "jose": {
+            "jwt": "jam.jose.create_jwt_instance",
+            "jws": "jam.jose.create_jws_instance",
+            "jwe": "jam.jose.create_jwe_instance",
+        },
         "session": "jam.sessions.create_instance",
         "oauth2": "jam.oauth2.create_instance",
         "paseto": "jam.paseto.create_instance",
@@ -190,6 +194,79 @@ class Jam(BaseJam):
             return data
         return payload
 
+    def jws_sign(
+        self,
+        data: dict[str, Any] | str,
+        header: dict[str, Any] | None = None,
+    ) -> str:
+        """Sign data using JWS.
+
+        Args:
+            data: Data to sign. If dict, will be JSON encoded.
+            header: JWS header.
+
+        Returns:
+            str: JWS token.
+        """
+        assert self.jws is not None
+        self._logger.debug(f"Signing data with JWS, header: {header}")
+        token = self.jws.sign(header or {}, data)
+        self._logger.debug(f"JWS token created, length: {len(token)}")
+        return token
+
+    def jws_verify(self, token: str) -> dict[str, Any]:
+        """Verify JWS token.
+
+        Args:
+            token: JWS token.
+
+        Returns:
+            dict[str, Any]: Decoded payload.
+        """
+        assert self.jws is not None
+        self._logger.debug(f"Verifying JWS token, length: {len(token)}")
+        result = self.jws.verify(token)
+        self._logger.debug("JWS token verified successfully")
+        return result
+
+    def jwe_encrypt(
+        self,
+        data: dict[str, Any] | str,
+        header: dict[str, Any] | None = None,
+    ) -> str:
+        """Encrypt data using JWE.
+
+        Args:
+            data: Data to encrypt. If dict, will be JSON encoded.
+            header: JWE header.
+
+        Returns:
+            str: JWE token.
+        """
+        assert self.jwe is not None
+        self._logger.debug(f"Encrypting data with JWE, header: {header}")
+        token = self.jwe.encrypt(
+            self._serializer.dumps(data) if isinstance(data, dict) else data,
+            header,
+        )
+        self._logger.debug(f"JWE token created, length: {len(token)}")
+        return token
+
+    def jwe_decrypt(self, token: str) -> bytes:
+        """Decrypt JWE token.
+
+        Args:
+            token: JWE token.
+
+        Returns:
+            bytes: Decrypted data.
+        """
+        assert self.jwe is not None
+        self._logger.debug(f"Decrypting JWE token, length: {len(token)}")
+        result = self.jwe.decrypt(token)
+        self._logger.debug("JWE token decrypted successfully")
+        return result
+
     def session_create(self, session_key: str, data: dict[str, Any]) -> str:
         """Create new session.
 

jamlib-3.2.0b3/src/jam/jose/__init__.py

@@ -0,0 +1,113 @@
+# -*- coding: utf-8 -*-
+
+"""JOSE tools."""
+
+from typing import Any
+
+from jam.jose.jwk import JWK, JWKOct, JWKSet, JWKRSA, JWKEC
+from jam.jose.jws import JWS
+from jam.jose.jwe import JWE
+from jam.jose.jwt import JWT
+from jam.logger import BaseLogger, logger
+from jam.encoders import BaseEncoder, JsonEncoder
+
+
+def create_jwt_instance(
+    alg: str,
+    secret: Any = None,
+    secret_key: Any = None,
+    password: str | bytes | None = None,
+    list: dict[str, Any] | None = None,
+    logger: BaseLogger = logger,
+    serializer: BaseEncoder | type[BaseEncoder] = JsonEncoder,
+    **kwargs: Any,
+) -> JWT:
+    """Create JWT instance."""
+    if secret is None and secret_key is not None:
+        secret = secret_key
+    elif secret is None:
+        raise ValueError("Either 'secret' or 'secret_key' must be provided")
+
+    key = secret
+    if isinstance(secret, JWK):
+        key = secret._to_keylike()
+
+    return JWT(
+        alg=alg,
+        secret_key=key,
+        password=password,
+        list=list,
+        serializer=serializer,
+        logger=logger,
+    )
+
+
+def create_jws_instance(
+    alg: str,
+    key: Any = None,
+    password: bytes | None = None,
+    logger: BaseLogger = logger,
+    **kwargs: Any,
+) -> JWS:
+    """Create JWS instance."""
+    if key is None:
+        raise ValueError("'key' must be provided")
+
+    from jam.jose.jwk import JWK as JWKClass
+
+    if isinstance(key, JWKClass):
+        key = key._to_keylike()
+
+    return JWS(
+        alg=alg,
+        key=key,
+        password=password,
+        logger=logger,
+    )
+
+
+def create_jwe_instance(
+    alg: str,
+    enc: str,
+    key: Any = None,
+    password: bytes | None = None,
+    serializer: BaseEncoder | type[BaseEncoder] = JsonEncoder,
+    logger: BaseLogger = logger,
+    **kwargs: Any,
+) -> JWE:
+    """Create JWE instance."""
+    if key is None:
+        raise ValueError("'key' must be provided")
+
+    from jam.jose.jwk import JWK as JWKClass
+
+    if isinstance(key, JWKClass):
+        key = key._to_keylike()
+
+    return JWE(
+        alg=alg,
+        enc=enc,
+        key=key,
+        password=password,
+        serializer=serializer,
+        logger=logger,
+    )
+
+
+create_instance = create_jwt_instance
+
+
+__all__ = [
+    "JWK",
+    "JWKSet",
+    "JWS",
+    "JWE",
+    "JWT",
+    "JWKRSA",
+    "JWKEC",
+    "JWKOct",
+    "create_instance",
+    "create_jwt_instance",
+    "create_jws_instance",
+    "create_jwe_instance",
+]

{jamlib-3.2.0b1 → jamlib-3.2.0b3}/src/jam/jose/jwt.py

@@ -360,7 +360,7 @@ class JWT(BaseJWT):
     ) -> dict[str, Any]:
         now = int(datetime.now().timestamp())
         payload = {
-            "tid": str(uuid4()),
+            "jti": str(uuid4()),  # TODO: Make it replecable
             "iat": now,
             "iss": iss,
             "sub": sub,

{jamlib-3.2.0b1 → jamlib-3.2.0b3}/src/jam/jwt/__init__.py

@@ -62,4 +62,4 @@ def create_instance(
     )
 
 
-__all__ = ["JWT", "BaseJWT", "create_instance"]
+__all__ = ["JWT", "BaseJWT", "create_instance"]

{jamlib-3.2.0b1 → jamlib-3.2.0b3}/src/jam/tests/clients.py

@@ -7,7 +7,7 @@ import uuid
 
 from jam.aio import Jam as AioJam
 from jam.instance import Jam
-from jam.jwt.utils import base64url_decode
+from jam.jose.utils import __base64url_decode__ as base64url_decode
 from jam.tests.fakers import (
     fake_jwt_token,
     fake_oauth2_token,

{jamlib-3.2.0b1 → jamlib-3.2.0b3}/src/jam/tests/fakers.py

@@ -5,7 +5,7 @@ from secrets import token_urlsafe
 from typing import Any
 import uuid
 
-from jam.jwt.utils import base64url_encode
+from jam.jose.utils import __base64url_encode__ as base64url_encode
 from jam.utils import xor_my_data
 
 

{jamlib-3.2.0b1 → jamlib-3.2.0b3}/src/jam/utils/config_maker.py

@@ -6,6 +6,7 @@ import os
 import re
 import sys
 from typing import Any
+import warnings
 
 from jam.encoders import BaseEncoder, JsonEncoder
 from jam.exceptions import JamConfigurationError
@@ -351,18 +352,48 @@ def __config_maker__(
         ext = config.split(".")[-1].lower()
         match ext:
             case "yml" | "yaml":
-                return __yaml_config_parser(path=config, pointer=pointer).copy()
+                result = __yaml_config_parser(
+                    path=config, pointer=pointer
+                ).copy()
             case "toml":
-                return __toml_config_parser(path=config, pointer=pointer).copy()
+                result = __toml_config_parser(
+                    path=config, pointer=pointer
+                ).copy()
             case "json":
-                return __json_config_parser(path=config).copy()
+                result = __json_config_parser(path=config).copy()
             case _:
                 raise JamConfigurationError(
                     message="YML/YAML, TOML or JSON configs only!",
                     error_code="configuration.invalid_config_type",
                 )
     else:
-        return config.copy()
+        result = config.copy()
+
+    result = __apply_jwt_config_migration__(result)
+    return result
+
+
+# TODO: Delete this after deleting jam.jwt
+def __apply_jwt_config_migration__(config: dict) -> dict:
+    """Backward compatibility: copy jam.jwt -> jam.jose.jwt with deprecation warning.
+
+    Args:
+        config: Parsed configuration dict
+
+    Returns:
+        dict: Updated config with migration applied
+    """
+    if "jwt" in config and "jose" not in config:
+        warnings.warn(
+            "[jam.jwt] is deprecated. Use [jam.jose.jwt] instead. See: https://jam.makridenko.ru/usage/jose",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        config["jose"] = {"jwt": config["jwt"]}
+    elif "jwt" in config and "jose" in config:
+        if "jwt" not in config.get("jose", {}):
+            config["jose"]["jwt"] = config["jwt"]
+    return config
 
 
 def __module_loader__(path: str) -> Callable:

{jamlib-3.2.0b1 → jamlib-3.2.0b3/src/jamlib.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jamlib
-Version: 3.2.0b1
+Version: 3.2.0b3
 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.2.0b1/src/jam/jose/__init__.py

@@ -1,19 +0,0 @@
-# -*- coding: utf-8 -*-
-
-"""JOSE tools."""
-
-from jam.jose.jwk import JWK, JWKOct, JWKSet, JWKRSA, JWKEC
-from jam.jose.jws import JWS
-from jam.jose.jwe import JWE
-from jam.jose.jwt import JWT
-
-__all__ = [
-    "JWK",
-    "JWKSet",
-    "JWS",
-    "JWE",
-    "JWT",
-    "JWKRSA",
-    "JWKEC",
-    "JWKOct",
-]