jamlib 0.0.0__tar.gz

jamlib-0.0.0/LICENSE.md

@@ -0,0 +1,23 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Adrian Makridenko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+

jamlib-0.0.0/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: jamlib
+Version: 0.0.0
+Summary: Simple and univirsal library for authorization.
+Author-email: Makridenko Adrian <adrianmakridenko@duck.com>
+License: MIT License
+Project-URL: Homepage, https://github.com/lyaguxafrog/jam
+Project-URL: Repository, https://github.com/lyaguxafrog/jam
+Project-URL: Issues, https://github.com/lyaguxafrog/jam/issues
+Project-URL: Changelog, https://github.com/lyaguxafrog/jam/releases
+Keywords: auth,backend,jwt
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: pycryptodome<4.0.0,>=3.21.0
+Requires-Dist: cryptography<45.0.0,>=44.0.2
+Provides-Extra: json-lists
+Requires-Dist: tinydb>=4.8.2; extra == "json-lists"
+Provides-Extra: redis-lists
+Requires-Dist: redis>=5.2.1; extra == "redis-lists"
+Dynamic: license-file
+
+# Jam
+
+![logo](docs/assets/h_logo_n_title.png)
+
+![Static Badge](https://img.shields.io/badge/Python-3.13-blue?logo=python&logoColor=white)
+![tests](https://github.com/lyaguxafrog/jam/actions/workflows/run-tests.yml/badge.svg)
+![License](https://img.shields.io/badge/Licese-MIT-grey?link=https%3A%2F%2Fgithub.com%2Flyaguxafrog%2Fjam%2Fblob%2Frelease%2FLICENSE.md)
+![jam](https://img.shields.io/badge/jam-3.1.0_alpha-white?style=flat&labelColor=red)
+
+## Install
+```bash
+pip install jamlib
+```
+
+## Getting start
+```python
+# -*- coding: utf-8 -*-
+
+from typing import Any
+
+from jam import Jam
+
+config: dict[str, Any] = {
+        "jwt_secret_key": "some-secret",
+        "expire": 3600
+    }
+
+data = {
+    "user_id": 1,
+    "role": "admin"
+}
+
+jam = Jam(auth_type="jwt", config=config)
+
+payload = jam.make_payload(**data)
+token = jam.gen_jwt_token(**payload)
+```
+
+## Roadmap
+![Roadmap](https://github.com/lyaguxafrog/jam/blob/stable/docs/assets/roadmap.png)
+
+&copy; [Adrian Makridenko](https://github.com/lyaguxafrog) 2025

jamlib-0.0.0/README.md

@@ -0,0 +1,42 @@
+# Jam
+
+![logo](docs/assets/h_logo_n_title.png)
+
+![Static Badge](https://img.shields.io/badge/Python-3.13-blue?logo=python&logoColor=white)
+![tests](https://github.com/lyaguxafrog/jam/actions/workflows/run-tests.yml/badge.svg)
+![License](https://img.shields.io/badge/Licese-MIT-grey?link=https%3A%2F%2Fgithub.com%2Flyaguxafrog%2Fjam%2Fblob%2Frelease%2FLICENSE.md)
+![jam](https://img.shields.io/badge/jam-3.1.0_alpha-white?style=flat&labelColor=red)
+
+## Install
+```bash
+pip install jamlib
+```
+
+## Getting start
+```python
+# -*- coding: utf-8 -*-
+
+from typing import Any
+
+from jam import Jam
+
+config: dict[str, Any] = {
+        "jwt_secret_key": "some-secret",
+        "expire": 3600
+    }
+
+data = {
+    "user_id": 1,
+    "role": "admin"
+}
+
+jam = Jam(auth_type="jwt", config=config)
+
+payload = jam.make_payload(**data)
+token = jam.gen_jwt_token(**payload)
+```
+
+## Roadmap
+![Roadmap](https://github.com/lyaguxafrog/jam/blob/stable/docs/assets/roadmap.png)
+
+© [Adrian Makridenko](https://github.com/lyaguxafrog) 2025

jamlib-0.0.0/jam/__abc_instances__.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class __AbstractInstance(ABC):
+    """Abstract Instance object."""
+
+    @abstractmethod
+    def gen_jwt_token(self, payload) -> str:
+        """Generate new JWT token."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def verify_jwt_token(
+        self, token: str, check_exp: bool, check_list: bool
+    ) -> Any:
+        """Verify JWT token."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def make_payload(self, **payload) -> Any:
+        """Generate new template."""
+        raise NotImplementedError

jamlib-0.0.0/jam/__init__.py

@@ -0,0 +1,14 @@
+# -*- coding: utf-8 -*-
+
+"""
+JAM - Universal auth* library
+
+Source code: https://github.com/lyaguxafrog/jam
+Documentation: https://jam.makridenko.ru
+"""
+
+from jam.instance import Jam
+
+
+__version__ = "1.0.0"
+__all__ = ["Jam"]

jamlib-0.0.0/jam/exceptions/__init__.py

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+
+"""
+All Jam exceptions
+"""
+
+from .jwt import (
+    EmptyPublicKey,
+    EmptySecretKey,
+    EmtpyPrivateKey,
+    NotFoundSomeInPayload,
+    TokenInBlackList,
+    TokenLifeTimeExpired,
+    TokenNotInWhiteList,
+)

jamlib-0.0.0/jam/exceptions/jwt.py

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+
+from dataclasses import dataclass
+
+
+@dataclass
+class EmptySecretKey(Exception):
+    message: str | Exception = "Secret key cannot be NoneType"
+
+
+@dataclass
+class EmtpyPrivateKey(Exception):
+    message: str | Exception = "Private key cannot be NoneType"
+
+
+@dataclass
+class EmptyPublicKey(Exception):
+    message: str | Exception = "Public key cannot be NoneType"
+
+
+@dataclass
+class TokenLifeTimeExpired(Exception):
+    message: str | Exception = "Token lifetime has expired."
+
+
+class NotFoundSomeInPayload(Exception):
+    def __inti__(self, message: str | Exception) -> None:
+        self.message: str | Exception = message
+
+
+@dataclass
+class TokenNotInWhiteList(Exception):
+    message: str | Exception = "Token not found on white list."
+
+
+@dataclass
+class TokenInBlackList(Exception):
+    message: str | Exception = "The token is blacklisted."

jamlib-0.0.0/jam/instance.py

@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*-
+
+from typing import Any, Literal
+
+from jam.__abc_instances__ import __AbstractInstance
+from jam.modules import JWTModule
+
+
+class Jam(__AbstractInstance):
+    """Main instance."""
+
+    def __init__(
+        self,
+        auth_type: Literal["jwt"],
+        config: dict[str, Any],
+    ) -> None:
+        """Class construcotr.
+
+        Args:
+            auth_type (Literal["jwt"]): Type of auth*
+            config (dict[str, Any]): Config for Jam, can use `jam.utils.config_maker`
+        """
+        self.type = auth_type
+        if self.type == "jwt":
+            self.module = JWTModule(
+                alg=config["alg"],
+                secret_key=config["secret_key"],
+                public_key=config["public_key"],
+                private_key=config["private_key"],
+                expire=config["expire"],
+                list=config["list"],
+            )
+        else:
+            raise NotImplementedError
+
+    def gen_jwt_token(self, payload: dict[str, Any]) -> str:
+        """Creating a new token.
+
+        Args:
+            payload (dict[str, Any]): Payload with information
+
+        Raises:
+            EmptySecretKey: If the HMAC algorithm is selected, but the secret key is None
+            EmtpyPrivateKey: If RSA algorithm is selected, but private key None
+        """
+        return self.module.gen_token(**payload)
+
+    def verify_jwt_token(
+        self, token: str, check_exp: bool = True, check_list: bool = True
+    ) -> dict[str, Any]:
+        """A method for verifying a token.
+
+        Args:
+            token (str): The token to check
+            check_exp (bool): Check for expiration?
+            check_list (bool): Check if there is a black/white list
+
+        Raises:
+            ValueError: If the token is invalid.
+            EmptySecretKey: If the HMAC algorithm is selected, but the secret key is None.
+            EmtpyPublicKey: If RSA algorithm is selected, but public key None.
+            NotFoundSomeInPayload: If 'exp' not found in payload.
+            TokenLifeTimeExpired: If token has expired.
+            TokenNotInWhiteList: If the list type is white, but the token is  not there
+            TokenInBlackList: If the list type is black and the token is there
+
+        Returns:
+            (dict[str, Any]): Payload from token
+        """
+        return self.module.validate_payload(
+            token=token, check_exp=check_exp, check_list=check_list
+        )
+
+    def make_payload(self, exp: int | None = None, **data) -> dict[str, Any]:
+        """Payload maker tool.
+
+        Args:
+            exp (int | None): If none exp = JWTModule.exp
+            **data: Custom data
+        """
+        return self.module.make_payload(exp=exp, **data)

jamlib-0.0.0/jam/jwt/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

jamlib-0.0.0/jam/jwt/__utils__.py

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+
+import base64
+
+
+def __base64url_encode__(data: bytes) -> str:
+    """Encodes data using URL-safe Base64 encoding.
+
+    Removes padding characters ('=') typically added in standard Base64 encoding.
+
+    Args:
+        data (bytes): The data to encode.
+
+    Returns:
+        str: A URL-safe Base64 encoded string without padding.
+    """
+    return base64.urlsafe_b64encode(data).rstrip(b"=").decode("utf-8")
+
+
+def __base64url_decode__(data: str) -> bytes:
+    """Decodes a URL-safe Base64 encoded string back to bytes.
+
+    Automatically adds the necessary padding characters ('=') before decoding.
+
+    Args:
+        data (str): The Base64url encoded string to decode.
+
+    Returns:
+        bytes: The decoded byte data.
+    """
+    padding = "=" * (4 - len(data) % 4)
+    return base64.urlsafe_b64decode(data + padding)

jamlib-0.0.0/jam/jwt/lists/__abc_list_repo__.py

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+
+from abc import ABC, abstractmethod
+from typing import Literal, Protocol
+
+
+class ABCList(ABC):
+    """Abstrac class for lists manipulation."""
+
+    def __init__(self, list_type: Literal["white", "black"]) -> None:
+        """Class constructor."""
+        self.__list_type__ = list_type
+
+    @abstractmethod
+    def add(self, token: str) -> None:
+        """Method for adding token to list."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def check(self, token: str) -> bool:
+        """Method for checking if a token is present in the list."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete(self, token: str) -> None:
+        """Method for removing a token from a list."""
+        raise NotImplementedError
+
+
+class JWTList(Protocol):
+    """Protocol class for lists."""
+
+    __list_type__: Literal["black", "white"]
+
+    def add(self, token: str) -> None:
+        """Method for adding token to list."""
+        pass
+
+    def check(self, token: str) -> bool:
+        """Method for checking if a token is present in the list."""
+        pass
+
+    def delete(self, token: str) -> None:
+        """Method for removing a token from a list."""
+        pass

jamlib-0.0.0/jam/jwt/lists/__init__.py

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+
+from .__abc_list_repo__ import ABCList
+from .list_manipulations import JSONList, RedisList
+
+
+__all__ = ["JSONList", "RedisList", "ABCList"]

jamlib-0.0.0/jam/jwt/lists/list_manipulations.py

@@ -0,0 +1,151 @@
+# -*- coding: utf-8 -*-
+
+import datetime
+from typing import Literal
+
+from redis import Redis
+from tinydb import Query, TinyDB
+
+from jam.jwt.lists.__abc_list_repo__ import ABCList
+
+
+class JSONList(ABCList):
+    """Black/White list in JSON format, not recommended for blacklists  because it is not convenient to control token lifetime.
+
+    Dependency required:
+    `pip install jamlib[json-lists]`
+
+    Attributes:
+        __list__ (TinyDB): TinyDB instance
+
+    Methods:
+        add: adding token to list
+        check: check token in list
+        delete: removing token from list
+    """
+
+    def __init__(
+        self, type: Literal["white", "black"], json_path: str = "whitelist.json"
+    ) -> None:
+        """Class constructor.
+
+        Args:
+            type (Literal["white", "black"]): Type of list
+            json_path (str): Path to .json file
+        """
+        super().__init__(list_type=type)
+        self.__list__ = TinyDB(json_path)
+
+    def add(self, token: str) -> None:
+        """Method for adding token to list.
+
+        Args:
+            token (str): Your JWT token
+
+        Returns:
+            (None)
+        """
+        _doc = {
+            "token": token,
+            "timestamp": datetime.datetime.now().timestamp(),
+        }
+
+        from icecream import ic
+
+        ic(self.__list__.insert(_doc))
+        return None
+
+    def check(self, token: str) -> bool:
+        """Method for checking if a token is present in list.
+
+        Args:
+            token (str): Your jwt token
+
+        Returns:
+            (bool)
+        """
+        cond = Query()
+        _token = self.__list__.search(cond.token == token)
+        if _token:
+            return True
+        else:
+            return False
+
+    def delete(self, token: str) -> None:
+        """Method for removing token from list.
+
+        Args:
+            token (str): Your jwt token
+
+        Returns:
+            (None)
+        """
+        cond = Query()
+        self.__list__.remove(cond.token == token)
+
+
+class RedisList(ABCList):
+    """Black/White lists in Redis, most optimal format.
+
+    Dependency required: `pip install jamlib[redis-lists]`
+
+    Attributes:
+        __list__ (Redis): Redis instance
+        exp (int | None): Token lifetime
+    """
+
+    def __init__(
+        self,
+        type: Literal["white", "black"],
+        redis_instance: Redis,
+        in_list_life_time: int | None,
+    ) -> None:
+        """Class constructor.
+
+        Args:
+            type (Literal["white", "black"]): Type og list
+            redis_instance (Redis): `redis.Redis`
+            in_list_life_time (int | None): The lifetime of a token in the list
+        """
+        super().__init__(list_type=type)
+        self.__list__ = redis_instance
+        self.exp = in_list_life_time
+
+    def add(self, token: str) -> None:
+        """Method for adding token to list.
+
+        Args:
+            token (str): Your JWT token
+
+        Returns:
+            (None)
+        """
+        self.__list__.set(name=token, value="", ex=self.exp)
+        return None
+
+    def check(self, token: str) -> bool:
+        """Method for checking if a token is present in the list.
+
+        Args:
+            token (str): Your JWT token
+
+        Returns:
+            (bool)
+        """
+        _token = self.__list__.get(name=token)
+        if not _token:
+            return False
+        else:
+            return True
+
+    def delete(self, token: str) -> None:
+        """Method for removing a token from a list.
+
+        Args:
+            token (str): Your JWT token
+
+        Returns:
+            None
+        """
+        self.__list__.delete(token)
+        return None

jamlib-0.0.0/jam/jwt/tools.py

@@ -0,0 +1,168 @@
+# -*- coding: utf-8 -*-
+
+import hashlib
+import hmac
+import json
+from datetime import datetime
+from typing import Any
+from uuid import uuid4
+
+from Crypto.Hash import SHA256
+from Crypto.PublicKey import RSA
+from Crypto.Signature import pkcs1_15
+
+from jam.exceptions import (
+    EmptyPublicKey,
+    EmptySecretKey,
+    EmtpyPrivateKey,
+    NotFoundSomeInPayload,
+    TokenLifeTimeExpired,
+)
+from jam.jwt.__utils__ import __base64url_decode__, __base64url_encode__
+
+
+def __gen_jwt__(
+    header: dict[str, Any],
+    payload: dict[str, Any],
+    secret: str | None = None,
+    private_key: str | None = None,
+) -> str:
+    """Method for generating JWT token with different algorithms.
+
+    Example:
+    ```python
+    token = __gen_jwt__(
+        header={
+            "alg": "HS256",
+            "type": "jwt"
+        },
+        payload={
+            "id": 1
+        },
+        secret="SUPER_SECRET"
+    )
+    ```
+
+    Args:
+        header (Dict[str, str]): Dict with JWT headers
+        payload (Dict[str, Any]): Custom JWT payload
+        secret (str | None): Secret key for HMAC algorithms
+        private_key (str | None): Private key for RSA algorithms
+
+    Raises:
+        EmptySecretKey: If the HMAC algorithm is selected, but the secret key is None
+        EmtpyPrivateKey: If RSA algorithm is selected, but private key None
+
+    Returns:
+        (str): Access/refresh token
+    """
+    header_encoded = __base64url_encode__(json.dumps(header).encode("utf-8"))
+    payload_encoded = __base64url_encode__(json.dumps(payload).encode("utf-8"))
+
+    signature_input = f"{header_encoded}.{payload_encoded}".encode()
+
+    if header["alg"].startswith("HS"):
+        if secret is None:
+            raise EmptySecretKey
+        signature = hmac.new(
+            secret.encode("utf-8"), signature_input, hashlib.sha256
+        ).digest()
+    elif header["alg"].startswith("RS"):
+        if private_key is None:
+            raise EmtpyPrivateKey
+        rsa_key = RSA.import_key(private_key)
+        hash_obj = SHA256.new(signature_input)
+        signature = pkcs1_15.new(rsa_key).sign(hash_obj)
+    else:
+        raise ValueError("Unsupported algorithm")
+
+    signature_encoded = __base64url_encode__(signature)
+
+    jwt_token = f"{header_encoded}.{payload_encoded}.{signature_encoded}"
+    return jwt_token
+
+
+def __validate_jwt__(
+    token: str,
+    check_exp: bool = False,
+    secret: str | None = None,
+    public_key: str | None = None,
+) -> dict[str, Any]:
+    """Validate a JWT token and return the payload if valid.
+
+    Args:
+        token (str): The JWT token to validate.
+        check_exp (bool): true to check token lifetime.
+        secret (str | None): Secret key for HMAC algorithms.
+        public_key (str | None): Public key for RSA algorithms.
+
+    Returns:
+        (Dict[str, Any]): The payload if the token is valid.
+
+    Raises:
+        ValueError: If the token is invalid.
+        EmptySecretKey: If the HMAC algorithm is selected, but the secret key is None.
+        EmtpyPublicKey: If RSA algorithm is selected, but public key None.
+        NotFoundSomeInPayload: If 'exp' not found in payload.
+        TokenLifeTimeExpired: If token has expired.
+    """
+    try:
+        header_encoded, payload_encoded, signature_encoded = token.split(".")
+    except ValueError:
+        raise ValueError("Invalid token format")
+
+    header = json.loads(__base64url_decode__(header_encoded).decode("utf-8"))
+    payload = json.loads(__base64url_decode__(payload_encoded).decode("utf-8"))
+    signature = __base64url_decode__(signature_encoded)
+
+    signature_input = f"{header_encoded}.{payload_encoded}".encode()
+
+    if header["alg"].startswith("HS"):
+        if secret is None:
+            raise EmptySecretKey
+        expected_signature = hmac.new(
+            secret.encode("utf-8"), signature_input, hashlib.sha256
+        ).digest()
+    elif header["alg"].startswith("RS"):
+        if public_key is None:
+            raise EmptyPublicKey
+        rsa_key = RSA.import_key(public_key)
+        hash_obj = SHA256.new(signature_input)
+        try:
+            pkcs1_15.new(rsa_key).verify(hash_obj, signature)
+            expected_signature = signature
+        except (ValueError, TypeError):
+            raise ValueError("Invalid signature")
+    else:
+        raise ValueError("Unsupported algorithm")
+
+    if expected_signature != signature:
+        raise ValueError("Invalid token signature")
+
+    if check_exp:
+        if payload["exp"] is None:
+            raise NotFoundSomeInPayload('"exp" not found in payload')
+        if payload["exp"] < datetime.today().timestamp():
+            raise TokenLifeTimeExpired
+
+    return payload
+
+
+def __payload_maker__(exp: int | None, **data) -> dict[str, Any]:
+    """Tool for making base payload.
+
+    Args:
+        exp (int | None): Token expire
+        **data: Data for payload
+
+    Returns:
+        (Dict[str, Any])
+    """
+    base_payload: dict = {
+        "iat": datetime.now().timestamp(),
+        "exp": exp,
+        "jti": str(uuid4()),
+    }
+
+    base_payload.update(data)
+    return base_payload

jamlib-0.0.0/jam/modules.py

@@ -0,0 +1,159 @@
+# -*- coding: utf-8 -*-
+
+import datetime
+from typing import Any, Literal
+from uuid import uuid4
+
+from jam.exceptions import TokenInBlackList, TokenNotInWhiteList
+from jam.jwt.lists.__abc_list_repo__ import JWTList
+from jam.jwt.tools import __gen_jwt__, __validate_jwt__
+
+
+class BaseModule:
+    """The base module from which all other modules inherit."""
+
+    def __init__(
+        self,
+        module_type: Literal[
+            "jwt", "session-redis", "session-mongo", "session-custom"
+        ],
+    ) -> None:
+        """Class constructor.
+
+        Args:
+            module_type (Litetal["jwt", "session-redis", "session-mongo", "session-custom"]): Type of module
+        """
+        self._type = module_type
+
+    def __get_type(self) -> str:
+        return self._type
+
+
+class JWTModule(BaseModule):
+    """Module for JWT auth.
+
+    Methods:
+        make_payload(exp: int | None, **data): Creating a generic payload for a token
+    """
+
+    def __init__(
+        self,
+        alg: Literal[
+            "HS256",
+            "HS384",
+            "HS512",
+            "RS256",
+            "RS384",
+            "RS512",
+            # "PS256",
+            # "PS384",
+            # "PS512",
+        ] = "HS256",
+        secret_key: str | None = None,
+        public_key: str | None = None,
+        private_key: str | None = None,
+        expire: int = 3600,
+        list: JWTList | None = None,
+    ) -> None:
+        """Class constructor.
+
+        Args:
+            alg (Literal["HS256", "HS384", "HS512", "RS256", "RS384", "RS512", "PS512", "PS384", "PS512"]): Algorithm for token encryption
+            secret_key (str | None): Secret key for HMAC enecryption
+            private_key (str | None): Private key for RSA enecryption
+            public_key (str | None): Public key for RSA
+            expire (int): Token lifetime in seconds
+            list (JWTList | None): List module
+        """
+        super().__init__(module_type="jwt")
+        self._secret_key = secret_key
+        self.alg = alg
+        self._private_key = (private_key,)
+        self.public_key = public_key
+        self.exp = expire
+        self.list = list
+
+    def make_payload(self, exp: int | None = None, **data) -> dict[str, Any]:
+        """Payload maker tool.
+
+        Args:
+            exp (int | None): If none exp = JWTModule.exp
+            **data: Custom data
+        """
+        if not exp:
+            _exp = self.exp
+        else:
+            _exp = exp
+        payload = {
+            "jti": str(uuid4()),
+            "exp": _exp,
+            "iat": datetime.datetime.now().timestamp(),
+        }
+        payload.update(**data)
+        return payload
+
+    def gen_token(self, **payload) -> str:
+        """Creating a new token.
+
+        Args:
+            **payload: Payload with information
+
+        Raises:
+            EmptySecretKey: If the HMAC algorithm is selected, but the secret key is None
+            EmtpyPrivateKey: If RSA algorithm is selected, but private key None
+        """
+        header = {"alg": self.alg, "typ": "jwt"}
+        token = __gen_jwt__(
+            header=header,
+            payload=payload,
+            secret=self._secret_key,
+            private_key=self._private_key,  # type: ignore
+        )
+
+        if self.list:
+            if self.list.__list_type__ == "white":
+                self.list.add(token)
+        return token
+
+    def validate_payload(
+        self, token: str, check_exp: bool = False, check_list: bool = True
+    ) -> dict[str, Any]:
+        """A method for verifying a token.
+
+        Args:
+            token (str): The token to check
+            check_exp (bool): Check for expiration?
+            check_list (bool): Check if there is a black/white list
+
+        Raises:
+            ValueError: If the token is invalid.
+            EmptySecretKey: If the HMAC algorithm is selected, but the secret key is None.
+            EmtpyPublicKey: If RSA algorithm is selected, but public key None.
+            NotFoundSomeInPayload: If 'exp' not found in payload.
+            TokenLifeTimeExpired: If token has expired.
+            TokenNotInWhiteList: If the list type is white, but the token is  not there
+            TokenInBlackList: If the list type is black and the token is there
+
+        Returns:
+            (dict[str, Any]): Payload from token
+        """
+        if check_list:
+            if self.list.__list_type__ == "white":  # type: ignore
+                if not self.list.check(token):  # type: ignore
+                    raise TokenNotInWhiteList
+                else:
+                    pass
+            if self.list.__list_type__ == "black":  # type: ignore
+                if self.list.check(token):  # type: ignore
+                    raise TokenInBlackList
+                else:
+                    pass
+
+        payload = __validate_jwt__(
+            token=token,
+            check_exp=check_exp,
+            secret=self._secret_key,
+            public_key=self.public_key,
+        )
+
+        return payload

jamlib-0.0.0/jam/utils/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+
+from .config_maker import make_jwt_config
+from .rsa import generate_rsa_key_pair

jamlib-0.0.0/jam/utils/config_maker.py

@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+
+from typing import Any, Literal
+
+from jam.exceptions.jwt import EmptyPublicKey, EmptySecretKey, EmtpyPrivateKey
+from jam.jwt.lists.__abc_list_repo__ import JWTList
+
+
+def make_jwt_config(
+    alg: Literal[
+        "HS256",
+        "HS384",
+        "HS512",
+        "RS256",
+        "RS384",
+        "RS512",
+        # "PS256",
+        # "PS384",
+        # "PS512",
+    ] = "HS256",
+    secret_key: str | None = None,
+    public_key: str | None = None,
+    private_key: str | None = None,
+    expire: int = 3600,
+    list: JWTList | None = None,
+) -> dict[str, Any]:
+    """Util for making JWT config.
+
+    Args:
+        alg (Literal["HS256", "HS384", "HS512", "RS256", "RS384", "RS512", "PS512", "PS384", "PS512"]): Algorithm for token encryption
+        secret_key (str | None): Secret key for HMAC enecryption
+        private_key (str | None): Private key for RSA enecryption
+        public_key (str | None): Public key for RSA
+        expire (int): Token lifetime in seconds
+        list (JWTList | None): List module for checking
+
+    Raises:
+        EmptySecretKey: If HS* algorithm is selected, but the secret key is empty
+        EmtpyPrivateKey: If RS* algorithm is selected, but the private key is empty
+        EmtpyPublicKey: If RS* algorithm is selected, but the public key is empty
+    """
+    if alg.startswith("HS") and secret_key is None:
+        raise EmptySecretKey
+
+    if alg.startswith("RS") and private_key is None:
+        raise EmtpyPrivateKey
+
+    if alg.startswith("RS") and public_key is None:
+        raise EmptyPublicKey
+
+    return {
+        "alg": alg,
+        "secret_key": secret_key,
+        "private_key": private_key,
+        "public_key": public_key,
+        "expire": expire,
+        "list": list,
+    }

jamlib-0.0.0/jam/utils/rsa.py

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+
+from cryptography.hazmat.backends import default_backend
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import rsa
+
+
+def generate_rsa_key_pair(key_size: int = 2048) -> dict:
+    """RSA key generation utility.
+
+    Args:
+        key_size (int): Size of RSA key
+
+    Returns:
+        (dict): with public and private keys in format:
+
+    ```python
+    {
+        "public": "some_key",
+        "private": "key"
+    }
+    ```
+    """
+    private_key = rsa.generate_private_key(
+        public_exponent=65537, key_size=key_size, backend=default_backend()
+    )
+
+    public_key = private_key.public_key()
+
+    pem_private = private_key.private_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PrivateFormat.TraditionalOpenSSL,
+        encryption_algorithm=serialization.NoEncryption(),
+    )
+
+    pem_public = public_key.public_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PublicFormat.SubjectPublicKeyInfo,
+    )
+
+    return {
+        "public": pem_public.decode("utf-8"),
+        "private": pem_private.decode("utf-8"),
+    }

jamlib-0.0.0/jamlib.egg-info/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: jamlib
+Version: 0.0.0
+Summary: Simple and univirsal library for authorization.
+Author-email: Makridenko Adrian <adrianmakridenko@duck.com>
+License: MIT License
+Project-URL: Homepage, https://github.com/lyaguxafrog/jam
+Project-URL: Repository, https://github.com/lyaguxafrog/jam
+Project-URL: Issues, https://github.com/lyaguxafrog/jam/issues
+Project-URL: Changelog, https://github.com/lyaguxafrog/jam/releases
+Keywords: auth,backend,jwt
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: pycryptodome<4.0.0,>=3.21.0
+Requires-Dist: cryptography<45.0.0,>=44.0.2
+Provides-Extra: json-lists
+Requires-Dist: tinydb>=4.8.2; extra == "json-lists"
+Provides-Extra: redis-lists
+Requires-Dist: redis>=5.2.1; extra == "redis-lists"
+Dynamic: license-file
+
+# Jam
+
+![logo](docs/assets/h_logo_n_title.png)
+
+![Static Badge](https://img.shields.io/badge/Python-3.13-blue?logo=python&logoColor=white)
+![tests](https://github.com/lyaguxafrog/jam/actions/workflows/run-tests.yml/badge.svg)
+![License](https://img.shields.io/badge/Licese-MIT-grey?link=https%3A%2F%2Fgithub.com%2Flyaguxafrog%2Fjam%2Fblob%2Frelease%2FLICENSE.md)
+![jam](https://img.shields.io/badge/jam-3.1.0_alpha-white?style=flat&labelColor=red)
+
+## Install
+```bash
+pip install jamlib
+```
+
+## Getting start
+```python
+# -*- coding: utf-8 -*-
+
+from typing import Any
+
+from jam import Jam
+
+config: dict[str, Any] = {
+        "jwt_secret_key": "some-secret",
+        "expire": 3600
+    }
+
+data = {
+    "user_id": 1,
+    "role": "admin"
+}
+
+jam = Jam(auth_type="jwt", config=config)
+
+payload = jam.make_payload(**data)
+token = jam.gen_jwt_token(**payload)
+```
+
+## Roadmap
+![Roadmap](https://github.com/lyaguxafrog/jam/blob/stable/docs/assets/roadmap.png)
+
+&copy; [Adrian Makridenko](https://github.com/lyaguxafrog) 2025

jamlib-0.0.0/jamlib.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+LICENSE.md
+README.md
+pyproject.toml
+jam/__abc_instances__.py
+jam/__init__.py
+jam/instance.py
+jam/modules.py
+jam/exceptions/__init__.py
+jam/exceptions/jwt.py
+jam/jwt/__init__.py
+jam/jwt/__utils__.py
+jam/jwt/tools.py
+jam/jwt/lists/__abc_list_repo__.py
+jam/jwt/lists/__init__.py
+jam/jwt/lists/list_manipulations.py
+jam/utils/__init__.py
+jam/utils/config_maker.py
+jam/utils/rsa.py
+jamlib.egg-info/PKG-INFO
+jamlib.egg-info/SOURCES.txt
+jamlib.egg-info/dependency_links.txt
+jamlib.egg-info/requires.txt
+jamlib.egg-info/top_level.txt

jamlib-0.0.0/jamlib.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

jamlib-0.0.0/jamlib.egg-info/requires.txt

@@ -0,0 +1,8 @@
+pycryptodome<4.0.0,>=3.21.0
+cryptography<45.0.0,>=44.0.2
+
+[json-lists]
+tinydb>=4.8.2
+
+[redis-lists]
+redis>=5.2.1

jamlib-0.0.0/jamlib.egg-info/top_level.txt

@@ -0,0 +1 @@
+jam

jamlib-0.0.0/pyproject.toml

@@ -0,0 +1,86 @@
+[project]
+name = "jamlib"
+dynamic = ["version"]
+description = "Simple and univirsal library for authorization."
+authors = [
+    {name = "Makridenko Adrian",email = "adrianmakridenko@duck.com"}
+]
+license = {text = "MIT License"}
+readme = {file = "README.md", content-type = "text/markdown"}
+keywords = [
+    "auth",
+    "backend",
+    "jwt"
+]
+requires-python = ">=3.13"
+dependencies = [
+    "pycryptodome>=3.21.0,<4.0.0",
+    "cryptography (>=44.0.2,<45.0.0)",
+]
+
+[project.urls]
+Homepage = "https://github.com/lyaguxafrog/jam"
+Repository = "https://github.com/lyaguxafrog/jam"
+Issues = "https://github.com/lyaguxafrog/jam/issues"
+Changelog = "https://github.com/lyaguxafrog/jam/releases"
+
+[project.optional-dependencies]
+json-lists=["tinydb>=4.8.2"]
+redis-lists=["redis>=5.2.1"]
+
+[dependency-groups]
+dev = [
+    "black>=25.1.0",
+    "icecream>=2.1.4",
+    "isort>=6.0.1",
+    "mkdocs>=1.6.1",
+    "mkdocs-material>=9.6.9",
+    "mkdocstrings>=0.29.0",
+    "mkdocstrings-python>=1.16.7",
+    "mypy>=1.15.0",
+    "pre-commit>=4.2.0",
+    "pytest>=8.3.5",
+    "redis>=5.2.1",
+    "ruff>=0.11.2",
+    "termynal>=0.13.0",
+    "tinydb>=4.8.2",
+]
+
+
+[tool.ruff]
+target-version = "py313"
+line-length = 80
+ignore = ["UP009", "D100"]
+exclude = ["*__init__.py", "tests/", "*exceptions/"]
+
+[tool.ruff.lint]
+extend-select = ["UP", "D"]
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+[tool.isort]
+profile = "black"
+default_section = "THIRDPARTY"
+balanced_wrapping = true
+known_first_party = "src"
+line_length = 80
+lines_after_imports = 2
+lines_between_sections = 1
+multi_line_output = 3
+sections = ["FUTURE", "STDLIB", "THIRDPARTY", "FIRSTPARTY", "LOCALFOLDER"]
+skip = ["env", ".env", ".env.example", "migrations/", ".venv/"]
+
+[tool.black]
+line-length = 80
+skip-string-normalization = false
+
+[tool.mypy]
+disable_error_code = ["no-redef", "import-not-found", "import-untyped", "attr-defined"]
+
+[tool.pytest]
+#asyncio_default_fixture_loop_scope = "function"
+python_files = ["test*.py"]
+
+[tool.pytest.ini_options]
+addopts = "--capture=no"

jamlib-0.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+