jamlib 3.0.0a10__py3-none-any.whl

jam/aio/instance.py

@@ -0,0 +1,371 @@
+# -*- coding: utf-8 -*-
+
+from datetime import datetime
+from this import d
+from typing import Any, Optional, Union, Literal
+import uuid
+
+from jam.__base__ import BaseJam
+from jam.logger import BaseLogger, JamLogger
+from jam.encoders import BaseEncoder, JsonEncoder
+
+
+class Jam(BaseJam):
+    """Main instance for aio."""
+
+    MODULES: dict[str, str] = {}
+
+    def __init__(
+        self,
+        config: Union[str, dict[str, Any]] = "pyproject.toml",
+        pointer: str = "jam",
+        *,
+        logger: type(BaseLogger) = JamLogger,
+        log_level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] = "INFO",
+        serializer: Union[BaseEncoder, type[BaseEncoder]] = JsonEncoder,
+    ) -> None:
+        super().__init__(config, pointer, logger, log_level, serializer)
+        self.__logger.warn("AIO VERSION NOT WORKING IN unstable VERSION")
+
+
+
+
+    async def jwt_make_payload(
+        self, exp: Optional[int], data: dict[str, Any]
+    ) -> dict[str, Any]:
+        """Make JWT-specific payload.
+
+        Args:
+            exp (int | None): Token expire, if None -> use default
+            data (dict[str, Any]): Data to payload
+
+        Returns:
+            dict[str, Any]: Payload
+        """
+        payload = {
+            "iat": datetime.now().timestamp(),
+            "exp": (datetime.now().timestamp() + exp) if exp else None,
+            "jti": str(uuid.uuid4()),
+        }
+        payload = payload | data
+        return payload
+
+    async def jwt_create_token(self, payload: dict[str, Any]) -> str:
+        """Create JWT token.
+
+        Args:
+            payload (dict[str, Any]): Data payload
+
+        Returns:
+            str: New token
+
+        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.jwt.encode(payload=payload)
+
+    async def jwt_verify_token(
+        self, token: str, check_exp: bool = True, check_list: bool = True
+    ) -> dict[str, Any]:
+        """Verify and decode JWT token.
+
+        Args:
+            token (str): JWT token
+            check_exp (bool): Check expire
+            check_list (bool): Check white/black list. Docs: https://jam.makridenko.ru/jwt/lists/what/
+
+        Returns:
+            dict[str, Any]: Decoded payload
+
+        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
+        """
+        return self.jwt.decode(token)
+
+    async def session_create(
+        self, session_key: str, data: dict[str, Any]
+    ) -> str:
+        """Create new session.
+
+        Args:
+            session_key (str): Key for session
+            data (dict[str, Any]): Session data
+
+        Returns:
+            str: New session ID
+        """
+        return await self.session.create(session_key, data)
+
+    async def session_get(self, session_id: str) -> Optional[dict[str, Any]]:
+        """Get data from session.
+
+        Args:
+            session_id (str): Session ID
+
+        Returns:
+            dict[str, Any] | None: Session data if exist
+        """
+        return await self.session.get(session_id)
+
+    async def session_delete(self, session_id: str) -> None:
+        """Delete session.
+
+        Args:
+            session_id (str): Session ID
+        """
+        return await self.session.delete(session_id)
+
+    async def session_update(
+        self, session_id: str, data: dict[str, Any]
+    ) -> None:
+        """Update session data.
+
+        Args:
+            session_id (str): Session ID
+            data (dict[str, Any]): New data
+        """
+        return await self.session.update(session_id, data)
+
+    async def session_clear(self, session_key: str) -> None:
+        """Delete all sessions by key.
+
+        Args:
+            session_key (str): Key of session
+        """
+        return await self.session.clear(session_key)
+
+    async def session_rework(self, old_session_id: str) -> str:
+        """Rework session.
+
+        Args:
+            old_session_id (str): Old session id
+
+        Returns:
+            str: New session id
+        """
+        return await self.session.rework(old_session_id)
+
+    def otp_code(
+        self, secret: Union[str, bytes], factor: Optional[int] = None
+    ) -> str:
+        """Generates an OTP.
+
+        Args:
+            secret (str | bytes): User secret key.
+            factor (int | None, optional): Unixtime for TOTP(if none, use now time) / Counter for HOTP.
+
+        Returns:
+            str: OTP code (fixed-length string).
+        """
+        self._otp_checker()
+        return self._otp_module(
+            secret=secret, digits=self._otp.digits, digest=self._otp.digest
+        ).at(factor)
+
+    def otp_uri(
+        self,
+        secret: str,
+        name: Optional[str] = None,
+        issuer: Optional[str] = None,
+        counter: Optional[int] = None,
+    ) -> str:
+        """Generates an otpauth:// URI for Google Authenticator.
+
+        Args:
+            secret (str): User secret key.
+            name (str): Account name (e.g., email).
+            issuer (str): Service name (e.g., "GitHub").
+            counter (int | None, optional): Counter (for HOTP). Default is None.
+
+        Returns:
+            str: A string of the form "otpauth://..."
+        """
+        self._otp_checker()
+        return self._otp_module(
+            secret=secret, digits=self._otp.digits, digest=self._otp.digest
+        ).provisioning_uri(
+            name=name, issuer=issuer, type_=self._otp.type, counter=counter
+        )
+
+    def otp_verify_code(
+        self,
+        secret: Union[str, bytes],
+        code: str,
+        factor: Optional[int] = None,
+        look_ahead: Optional[int] = 1,
+    ) -> bool:
+        """Checks the OTP code, taking into account the acceptable window.
+
+        Args:
+            secret (str | bytes): User secret key.
+            code (str): The code entered.
+            factor (int | None, optional): Unixtime for TOTP(if none, use now time) / Counter for HOTP.
+            look_ahead (int, optional): Acceptable deviation in intervals (±window(totp) / ±look ahead(hotp)). Default is 1.
+
+        Returns:
+            bool: True if the code matches, otherwise False.
+        """
+        self._otp_checker()
+        return self._otp_module(
+            secret=secret, digits=self._otp.digits, digest=self._otp.digest
+        ).verify(code=code, factor=factor, look_ahead=look_ahead)
+
+    async def oauth2_get_authorized_url(
+        self, provider: str, scope: list[str], **extra_params: Any
+    ) -> str:
+        """Generate full OAuth2 authorization URL.
+
+        Args:
+            provider (str): Provider name
+            scope (list[str]): Auth scope
+            extra_params (Any): Extra ath params
+
+        Returns:
+            str: Authorization url
+        """
+        from jam.exceptions import ProviderNotConfigurError
+
+        if provider not in self.oauth2:
+            raise ProviderNotConfigurError(
+                f"Provider {provider} not configured"
+            )
+        return await self.oauth2[provider].get_authorization_url(
+            scope, **extra_params
+        )
+
+    async def oauth2_fetch_token(
+        self,
+        provider: str,
+        code: str,
+        grant_type: str = "authorization_code",
+        **extra_params: Any,
+    ) -> dict[str, Any]:
+        """Exchange authorization code for access token.
+
+        Args:
+            provider (str): Provider name
+            code (str): OAuth2 code
+            grant_type (str): Type of oauth2 grant
+            extra_params (Any): Extra auth params if needed
+
+        Returns:
+            dict: OAuth2 token
+        """
+        from jam.exceptions import ProviderNotConfigurError
+
+        if provider not in self.oauth2:
+            raise ProviderNotConfigurError(
+                f"Provider {provider} not configured"
+            )
+        return await self.oauth2[provider].fetch_token(
+            code, grant_type, **extra_params
+        )
+
+    async def oauth2_refresh_token(
+        self,
+        provider: str,
+        refresh_token: str,
+        grant_type: str = "refresh_token",
+        **extra_params: Any,
+    ) -> dict[str, Any]:
+        """Use refresh token to obtain a new access token.
+
+        Args:
+            provider (str): Provider name
+            refresh_token (str): Refresh token
+            grant_type (str): Grant type
+            extra_params (Any): Extra auth params if needed
+
+        Returns:
+            dict: Refresh token
+        """
+        from jam.exceptions import ProviderNotConfigurError
+
+        if provider not in self.oauth2:
+            raise ProviderNotConfigurError(
+                f"Provider {provider} not configured"
+            )
+        return await self.oauth2[provider].refresh_token(
+            refresh_token, grant_type, **extra_params
+        )
+
+    async def oauth2_client_credentials_flow(
+        self,
+        provider: str,
+        scope: Optional[list[str]] = None,
+        **extra_params: Any,
+    ) -> dict[str, Any]:
+        """Obtain access token using client credentials flow (no user interaction).
+
+        Args:
+            provider (str): Provider name
+            scope (list[str] | None): Auth scope
+            extra_params (Any): Extra auth params if needed
+
+        Returns:
+            dict: JSON with access token
+        """
+        from jam.exceptions import ProviderNotConfigurError
+
+        if provider not in self.oauth2:
+            raise ProviderNotConfigurError(
+                f"Provider {provider} not configured"
+            )
+        return await self.oauth2[provider].client_credentials_flow(
+            scope, **extra_params
+        )
+
+    async def paseto_make_payload(
+        self, exp: Optional[int] = None, **data: dict[str, Any]
+    ) -> dict[str, Any]:
+        """Generate payload for PASETO.
+
+        Args:
+            exp (int | None): Token expire
+            data (dict[str, Any]): Custom data
+
+        Returns:
+            dict: Payload
+        """
+        from jam.paseto.utils import payload_maker
+
+        return payload_maker(expire=exp, data=data)
+
+    async def paseto_create(
+        self,
+        payload: dict[str, Any],
+        footer: Optional[Union[dict[str, Any], str]],
+    ) -> str:
+        """Create new PASETO.
+
+        Args:
+            payload (dict[str, Any]): Payload
+            footer (dict | str  | None): Footer
+
+        Returns:
+            str: New token
+        """
+        return self.paseto.encode(payload=payload, footer=footer)
+
+    async def paseto_decode(
+        self, token: str, check_exp: bool = True, check_list: bool = True
+    ) -> dict[str, Union[dict, Union[str, dict, None]]]:
+        """Decode PASETO.
+
+        Args:
+            token (str): Token
+            check_exp (bool): Check exp in payload
+            check_list (bool): Check token in list
+
+        Returns:
+            dict: {'payload' PAYLOAD, 'footer': FOOTER}
+        """
+        payload, footer = self.paseto.decode(token)
+        return {"payload": payload, "footer": footer}

jam/aio/jwt/__init__.py

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

jam/aio/jwt/lists/__init__.py

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

jam/aio/jwt/lists/json.py

@@ -0,0 +1,88 @@
+# -*- coding: utf-8 -*-
+
+from asyncio import to_thread
+import datetime
+from typing import Literal
+
+from jam.jwt.lists.__abc_list_repo__ import BaseJWTList
+
+
+try:
+    from tinydb import Query, TinyDB
+except ImportError:
+    raise ImportError(
+        """
+        No required packages found, looks like you didn't install them:
+        `pip install "jamlib[json]"`
+        """
+    )
+
+
+class JSONList(BaseJWTList):
+    """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]`
+
+    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)
+
+    async 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(),
+        }
+
+        await to_thread(self.__list__.insert, _doc)
+        return None
+
+    async 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 = await to_thread(self.__list__.search, cond.token == token)
+        return bool(_token)
+
+    async def delete(self, token: str) -> None:
+        """Method for removing token from list.
+
+        Args:
+            token (str): Your jwt token
+
+        Returns:
+            (None)
+        """
+        cond = Query()
+        await to_thread(self.__list__.remove, cond.token == token)

jam/aio/jwt/lists/redis.py

@@ -0,0 +1,88 @@
+# -*- coding: utf-8 -*-
+
+import datetime
+from typing import Literal, Optional, Union
+
+from jam.jwt.lists.__abc_list_repo__ import BaseJWTList
+
+
+try:
+    from redis.asyncio import Redis
+except ImportError:
+    raise ImportError(
+        """
+        No required packages found, looks like you didn't install them:
+        `pip install "jamlib[redis]"`
+        """
+    )
+
+
+class RedisList(BaseJWTList):
+    """Black/White lists in Redis, most optimal format.
+
+    Dependency required: `pip install jamlib[redis]`
+
+    Attributes:
+        __list__ (Redis): Redis instance
+        exp (int | None): Token lifetime
+    """
+
+    def __init__(
+        self,
+        type: Literal["white", "black"],
+        redis_uri: Union[str, Redis],
+        in_list_life_time: Optional[int] = None,
+    ) -> None:
+        """Class constructor.
+
+        Args:
+            type (Literal["white", "black"]): Type of list
+            redis_uri (str): Uri to redis connect
+            in_list_life_time (int | None): The lifetime of a token in the list
+        """
+        super().__init__(list_type=type)
+        if isinstance(redis_uri, str):
+            self.__list__ = Redis.from_url(redis_uri, decode_responses=True)
+        else:
+            self.__list__ = redis_uri
+        self.exp = in_list_life_time
+
+    async def add(self, token: str) -> None:
+        """Method for adding token to list.
+
+        Args:
+            token (str): Your JWT token
+
+        Returns:
+            (None)
+        """
+        await self.__list__.set(
+            name=token, value=str(datetime.datetime.now()), ex=self.exp
+        )
+        return None
+
+    async 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 = await self.__list__.get(name=token)
+        if _token:
+            return True
+        return False
+
+    async def delete(self, token: str) -> None:
+        """Method for removing a token from a list.
+
+        Args:
+            token (str): Your JWT token
+
+        Returns:
+            None
+        """
+        await self.__list__.delete(token)
+        return None

jam/aio/jwt/tools.py

@@ -0,0 +1,88 @@
+# -*- coding: utf-8 -*-
+
+from asyncio import to_thread
+from typing import Any, Optional
+
+from jam.jwt.tools import __gen_jwt__, __payload_maker__, __validate_jwt__
+
+
+async def __gen_jwt_async__(
+    header: dict[str, Any],
+    payload: dict[str, Any],
+    secret: Optional[str] = None,
+    private_key: Optional[str] = None,
+) -> str:
+    """Method for generating JWT token with different algorithms.
+
+    Example:
+    ```python
+    token = await __gen_jwt_async__(
+        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
+    """
+    return await to_thread(__gen_jwt__, header, payload, secret, private_key)
+
+
+async def __validate_jwt_async__(
+    token: str,
+    check_exp: bool = False,
+    secret: Optional[str] = None,
+    public_key: Optional[str] = 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.
+    """
+    return await to_thread(
+        __validate_jwt__, token, check_exp, secret, public_key
+    )
+
+
+async def __payload_maker_async__(
+    exp: Optional[int] = None, **data: Any
+) -> dict[str, Any]:
+    """Tool for making base payload.
+
+    Args:
+        exp (int | None): Token expire
+        **data: Data for payload
+
+    Returns:
+        (dict[str, Any])
+    """
+    return await to_thread(__payload_maker__, exp, **data)

jam/aio/oauth2/__init__.py

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+
+"""Async OAuth2 modules."""
+
+from typing import Any
+
+from .builtin.github import GitHubOAuth2Client
+from .builtin.gitlab import GitLabOAuth2Client
+from .builtin.google import GoogleOAuth2Client
+from .builtin.yandex import YandexOAuth2Client
+from jam.oauth2.__abc_oauth2_repo__ import BaseOAuth2Client
+from jam.logger import BaseLogger, logger
+
+
+BUILTIN_PROVIDERS = {
+    "github": "jam.aio.oauth2.builtin.github.GitHubOAuth2Client",
+    "gitlab": "jam.aio.oauth2.builtin.gitlab.GitLabOAuth2Client",
+    "google": "jam.aio.oauth2.builtin.google.GoogleOAuth2Client",
+    "yandex": "jam.aio.oauth2.builtin.yandex.YandexOAuth2Client",
+}
+
+
+def create_instance(
+    providers: dict[str, dict],
+    logger: BaseLogger = logger,
+    **kwargs: Any
+) -> dict[str, BaseOAuth2Client]:
+    """Create async OAuth2 clients for configured providers.
+
+    Args:
+        providers: {provider_name: {client_id, client_secret, redirect_uri, ...}}
+        logger: Logger instance
+        **kwargs: Additional params
+
+    Returns:
+        dict: {provider_name: OAuth2Client instance}
+    """
+    from jam.utils.config_maker import __module_loader__
+
+    result = {}
+    for name, cfg in providers.items():
+        cfg = cfg.copy()  # Don't modify original config
+        
+        if "custom_module" in cfg:
+            module_cls = __module_loader__(cfg.pop("custom_module"))
+        else:
+            module_path = BUILTIN_PROVIDERS.get(name, "jam.aio.oauth2.client.OAuth2Client")
+            module_cls = __module_loader__(module_path)
+        
+        result[name] = module_cls(**cfg)
+    
+    return result
+
+
+__all__ = [
+    "GitLabOAuth2Client",
+    "GitHubOAuth2Client",
+    "GoogleOAuth2Client",
+    "YandexOAuth2Client",
+    "create_instance",
+]

jam/aio/oauth2/builtin/__init__.py

@@ -0,0 +1,3 @@
+# -*- coding: utf-8 -*-
+
+"""Built-in OAuth2 providers."""