jamlib 0.0.2a0__tar.gz

jamlib-0.0.2a0/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.2a0/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.3
+Name: jamlib
+Version: 0.0.2a0
+Summary: Simple and univirsal library for authorization
+License: MIT
+Author: Makridenko Adrian
+Author-email: adrianmakridenko@duck.com
+Requires-Python: >=3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: pydantic (>=2.10.5,<3.0.0)
+Requires-Dist: pydantic-settings (>=2.7.1,<3.0.0)
+Project-URL: Homepage, https://github.com/lyaguxafrog/jam
+Project-URL: Issues, https://github.com/lyaguxafrog/jam/issues
+Project-URL: Repository, https://github.com/lyaguxafrog/jam
+Description-Content-Type: text/markdown
+
+# jam
+
+![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)
+
+
+> [!CAUTION]
+> In active development! Cannot be used in real projects!
+> 
+
+
+## Features
+- [ ] JWT Making
+- [ ] Another crypt alghorutms
+- [ ] White/Black lists
+- [ ] Session Maker
+- [ ] Integration with Django, FastAPI, Strawberry
+- [ ] OAuth2
+

jamlib-0.0.2a0/README.md

@@ -0,0 +1,18 @@
+# jam
+
+![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)
+
+
+> [!CAUTION]
+> In active development! Cannot be used in real projects!
+> 
+
+
+## Features
+- [ ] JWT Making
+- [ ] Another crypt alghorutms
+- [ ] White/Black lists
+- [ ] Session Maker
+- [ ] Integration with Django, FastAPI, Strawberry
+- [ ] OAuth2

jamlib-0.0.2a0/jam/__init__.py

@@ -0,0 +1,3 @@
+# -*- coding: utf-8 -*-
+
+from jam.config import JAMConfig

jamlib-0.0.2a0/jam/config.py

@@ -0,0 +1,28 @@
+# -*- coding: utf -*-
+
+from typing import Literal
+
+from pydantic_settings import BaseSettings
+
+
+class JAMConfig(BaseSettings):
+    JWT_ACCESS_SECRET_KEY: str | None
+    JWT_REFRESH_SECRET_KEY: str | None
+    JWT_ALGORITHM: Literal[
+        "HS256",
+        "HS384",
+        "HS512",
+        "RS256",
+        "RS384",
+        "RS512",
+        "ES256",
+        "ES384",
+        "ES512",
+        "PS256",
+        "PS384",
+        "PS512",
+    ] = "HS256"
+
+    JWT_ACCESS_EXP: int = 3600
+    JWT_REFRESH_EXP: int = JWT_ACCESS_EXP
+    JWT_HEADERS: dict = {}

jamlib-0.0.2a0/jam/jwt/__errors__.py

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+
+
+class JamNullJWTSecret(Exception):
+    def __init__(self, message="Secret keys cannot be Null") -> None:
+        self.message = message
+
+
+class JamJWTMakingError(Exception):
+    def __init__(self, message) -> None:
+        self.message = message
+
+
+class JamInvalidSignature(Exception):
+    def __init__(self, message="Invalid signature") -> None:
+        self.message = message

jamlib-0.0.2a0/jam/jwt/__init__.py

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

jamlib-0.0.2a0/jam/jwt/tools.py

@@ -0,0 +1,275 @@
+# -*- coding: utf-8 -*-
+
+import base64
+import hashlib
+import hmac
+import json
+import logging
+import secrets
+import time
+from typing import Literal
+
+from jam.config import JAMConfig
+from jam.jwt.__errors__ import JamInvalidSignature as InvalidSignature
+from jam.jwt.__errors__ import JamJWTMakingError as JWTError
+from jam.jwt.__errors__ import JamNullJWTSecret as NullSecret
+from jam.jwt.types import Tokens
+
+
+def __check_secrets__(config: JAMConfig) -> bool:
+    """
+    Private tool for check secrets in confg
+
+    :param config: Base jam config
+    :type config: jam.config.JAMConfig
+
+    :returns: True if secrets in config
+    :rtype: bool
+    """
+
+    if not config.JWT_ACCESS_SECRET_KEY or not config.JWT_REFRESH_SECRET_KEY:
+        raise NullSecret
+
+    else:
+        return True
+
+
+def __gen_access_token__(config: JAMConfig, payload: dict) -> str:
+    """
+    Private tool for generating access token
+
+    :param config: Standart jam confg
+    :type config: jam.config.JAMConfig
+    :param payload: Custom user payload
+    :type payload: dict
+
+    :returns: Returns access token by string
+    :rtype: str
+    """
+
+    if not config.JWT_ACCESS_SECRET_KEY:
+        raise NullSecret(message="JWT_ACCESS_SECRET_KEY is null")
+
+    __payload__: dict = {
+        "data": payload,
+        "exp": int(time.time()) + config.JWT_ACCESS_EXP,
+    }
+
+    encoded_header: str = (
+        base64.urlsafe_b64encode(
+            json.dumps({"alg": config.JWT_ALGORITHM, "typ": "JWT"}).encode()
+        )
+        .decode()
+        .rstrip("=")
+    )
+    encoded_payload: str = (
+        base64.urlsafe_b64encode(json.dumps(__payload__).encode())
+        .decode()
+        .rstrip("=")
+    )
+
+    __signature__: bytes = hmac.new(
+        config.JWT_ACCESS_SECRET_KEY.encode(),
+        f"{encoded_header}.{encoded_payload}".encode(),
+        hashlib.sha256,
+    ).digest()
+    encoded_signature: str = (
+        base64.urlsafe_b64encode(__signature__).decode().rstrip("=")
+    )
+
+    access_token: str = (
+        f"{encoded_header}.{encoded_payload}.{encoded_signature}"
+    )
+    return access_token
+
+
+def __gen_refresh_token__(config: JAMConfig, payload: dict) -> str:
+    """
+    Private tool for generating refresh token
+
+    :param config: Standart jam config
+    :type config: jam.config.JAMConfig
+    :param payload: Custom user payload
+    :type payload: dict
+
+    :returns: Returns refresh roken by string
+    :type: str
+    """
+
+    if not config.JWT_REFRESH_SECRET_KEY:
+        raise NullSecret(message="JWT_REFRESH_TOKEN is null")
+
+    __payload__: dict = {
+        "data": payload,
+        "exp": int(time.time()) + config.JWT_REFRESH_EXP,
+        "jti": secrets.token_hex(16),
+    }
+
+    encoded_header: str = (
+        base64.urlsafe_b64encode(
+            json.dumps({"alg": config.JWT_ALGORITHM, "typ": "JWT"}).encode()
+        )
+        .decode()
+        .rstrip("=")
+    )
+    encoded_payload: str = (
+        base64.urlsafe_b64encode(json.dumps(__payload__).encode())
+        .decode()
+        .rstrip("=")
+    )
+
+    __signature__: bytes = hmac.new(
+        config.JWT_REFRESH_SECRET_KEY.encode(),
+        f"{encoded_header}.{encoded_payload}".encode(),
+        hashlib.sha256,
+    ).digest()
+    encoded_signature: str = (
+        base64.urlsafe_b64encode(__signature__).decode().rstrip("=")
+    )
+
+    refresh_token: str = (
+        f"{encoded_header}.{encoded_payload}.{encoded_signature}"
+    )
+    return refresh_token
+
+
+def gen_jwt_tokens(*, config: JAMConfig, payload: dict = {}) -> Tokens:
+    """
+    Service for generating JWT tokens
+
+    Example:
+    ```
+    config = JAMConfig(
+        JWT_ACCESS_SECRET_KEY="SOME_SUPER_SECRET_KEY",
+        JWT_REFRESH_SECRET_KEY="ANOTHER_SECRET_KEY"
+    )
+
+    payload: dict = {
+        "id": 1,
+        "username": "lyaguxafrog"
+    }
+
+    tokens = gen_jwt_tokens(config=config, payload=payload)
+    ```
+
+    :param config: Standart jam config
+    :type config: jam.config.JAMConfig
+    :param payload: Custom user payload
+    :type payload: dict
+
+    :returns: Base model with access and refresh tokens
+    :rtype: jam.jwt.types.Tokens
+    """
+
+    try:
+        access: str = __gen_access_token__(config, payload)
+        refresh: str = __gen_refresh_token__(config, payload)
+
+    except Exception as e:
+        raise JWTError(message=e)
+
+    return Tokens(access=access, refresh=refresh)
+
+
+def check_jwt_signature(
+    *, config: JAMConfig, token_type: Literal["access", "refresh"], token: str
+) -> bool:
+    """
+    Service for checking JWT signature
+
+    :param config: Base jam config
+    :type config: jam.config.JAMConfig
+    :param token: JWT token
+    :type token: str
+    :param key_type: Type of JWT ( access token or refresh token )
+    :type key_type: str
+
+    :returns: Bool with signature status
+    :rtype: bool
+    """
+
+    if token_type == "access":
+        secret_key: str | None = config.JWT_ACCESS_SECRET_KEY
+
+    elif token_type == "refresh":
+        secret_key: str | None = config.JWT_REFRESH_SECRET_KEY
+
+    else:
+        raise ValueError("Invalid key type. Must be 'access' or 'refresh'.")
+
+    if not secret_key:
+        raise NullSecret("The specified secret key is missing.")
+
+    try:
+        header, payload, signature = token.split(".")
+    except ValueError:
+        raise ValueError(
+            "Invalid token format. Token must have three parts separated by '.'"
+        )
+
+    data_to_sign = f"{header}.{payload}".encode("utf-8")
+
+    expected_signature = (
+        base64.urlsafe_b64encode(
+            hmac.new(
+                secret_key.encode("utf-8"), data_to_sign, hashlib.sha256
+            ).digest()
+        )
+        .decode("utf-8")
+        .rstrip("=")
+    )
+
+    return expected_signature == signature
+
+
+def decode_token(
+    *,
+    config: JAMConfig,
+    token: str,
+    checksum: bool = False,
+    checksum_token_type: Literal["access", "refresh"] | None = None,
+) -> dict:
+    """
+    Service for decoding JWT token
+
+    :param config: Base jam config
+    :type config: jam.config.JAMConfig
+    :param token: Some jwt token
+    :type token: str
+    :param checksum: Use `check_jwt_signature` in decode?
+    :type checksum: bool
+    :param checksum_token_type: Type of JWT ( access or refresh )
+    :type checksum_token_type: str | None
+
+    :retutns: Dict with information in token
+    :rtype: dict
+    """
+
+    if checksum:
+        sum: bool = check_jwt_signature(
+            config=config, token_type=checksum_token_type, token=token  # type: ignore
+        )
+        if not sum:
+            raise InvalidSignature
+        else:
+            logging.info("Signature valid")
+            pass
+    else:
+        pass
+
+    if not config.JWT_ACCESS_SECRET_KEY or not config.JWT_REFRESH_SECRET_KEY:
+        raise NullSecret
+
+    try:
+        header, payload, signature = token.split(".")
+    except ValueError:
+        raise ValueError(
+            "Invalid token format. Token must have three parts separated by '.'"
+        )
+
+    try:
+        padding: str = "=" * (4 - len(payload) % 4)
+        decoded_payload: bytes = base64.urlsafe_b64decode(payload + padding)
+        return json.loads(decoded_payload)
+    except (ValueError, json.JSONDecodeError) as e:
+        raise ValueError("Failed to decode the payload: " + str(e))

jamlib-0.0.2a0/jam/jwt/types.py

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+
+
+from pydantic import BaseModel
+
+
+class Tokens(BaseModel):
+    """
+    Scop for tokens
+
+    * access: str
+    * refresh: str
+    """
+
+    access: str
+    refresh: str

jamlib-0.0.2a0/pyproject.toml

@@ -0,0 +1,79 @@
+[project]
+name = "jamlib"
+version = "0.0.2-alpha"
+description = "Simple and univirsal library for authorization"
+authors = [
+    {name = "Makridenko Adrian",email = "adrianmakridenko@duck.com"}
+]
+license = {text = "MIT"}
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "pydantic (>=2.10.5,<3.0.0)",
+    "pydantic-settings (>=2.7.1,<3.0.0)"
+]
+
+[project.urls]
+Homepage = "https://github.com/lyaguxafrog/jam"
+Repository = "https://github.com/lyaguxafrog/jam"
+Issues = "https://github.com/lyaguxafrog/jam/issues"
+
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry]
+packages = [
+    { include = "jam" },
+]
+
+[tool.poetry.group.dev.dependencies]
+pretty-errors = "^1.2.25"
+icecream = "^2.1.4"
+pre-commit = "^4.1.0"
+flake8 = "^7.1.1"
+isort = "^5.13.2"
+black = "^24.10.0"
+mypy = "^1.14.1"
+
+
+[tool.poetry.group.tests.dependencies]
+pytest = "^8.3.4"
+
+
+[tool.poetry.group.docs.dependencies]
+mkdocs = "^1.6.1"
+mkdocs-material = "^9.5.50"
+mkdocstrings = "^0.27.0"
+mkdocstrings-python = "^1.13.0"
+
+
+[tool.flake8]
+ignore = ["D203", "E501"]
+exclude = [".git", "__pycache__", "__init__.py", "docs/"]
+max-complexity = 18
+max-line-length = 80
+
+[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"]
+
+[tool.black]
+line-length = 80
+skip-string-normalization = false
+
+[tool.mypy]
+disable_error_code = ["no-redef", "import-not-found"]
+
+[tool.pytest]
+asyncio_default_fixture_loop_scope = "function"
+python_files = ["test*.py"]