tina4-python 0.2.133__tar.gz → 0.2.134__tar.gz

{tina4_python-0.2.133 → tina4_python-0.2.134}/.gitignore

@@ -32,3 +32,4 @@
 /migrations/__test_user_item.sql
 /tina4_python.egg-info/
 /src/templates/crud/
+/.venv/

tina4_python-0.2.134/PKG-INFO

@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: tina4-python
+Version: 0.2.134
+Summary: Tina4Python - This is not another framework for Python
+Author-email: Andre van Zuydam <andrevanzuydam@gmail.com>
+Requires-Python: <4.0,>=3.12
+Requires-Dist: asyncer>=0.0.8
+Requires-Dist: bcrypt<5.0.0,>=4.2.1
+Requires-Dist: cryptography<45.0.0,>=44.0.0
+Requires-Dist: jinja2<4.0.0,>=3.1.5
+Requires-Dist: libsass<0.24.0,>=0.23.0
+Requires-Dist: litequeue<0.10,>=0.9
+Requires-Dist: pyjwt<3.0.0,>=2.10.1
+Requires-Dist: python-dotenv<2.0.0,>=1.0.1
+Requires-Dist: simple-websocket<2.0.0,>=1.1.0
+Requires-Dist: uvicorn>=0.38.0
+Requires-Dist: watchdog<7.0.0,>=6.0.0
+Description-Content-Type: text/markdown
+
+# Tina4 Python — This is not a framework
+
+Laravel joy. Python speed. 10× less code.
+
+```python app.py
+from tina4_python import run_web_server
+from tina4_python.Router import get
+
+
+@get("/")
+async def get_hello_world(request, response):
+    return response("Hello World!")
+
+
+def app():
+    run_web_server()
+
+
+if __name__ == "__main__":
+    app()
+```
+
+That’s it. Save the code above as `app.py`, run it, and you have a fully working Tina4 Python web server.
+
+```bash
+pip install tina4-python
+python app.py
+# → http://localhost:7145
+```
+
+You just built your first Tina4 app — zero configuration, zero classes, zero boilerplate.
+
+## Features
+
+- Full ASGI compliance, use any ASGI compliant webserver
+- Full async support out of the box
+- Built in JWT and Session handling
+- Automatic Swagger docs at `/swagger`
+- Instant CRUD interfaces with one line: `result.to_crud(request)`
+- Built-in Twig templating, migrations, WebSockets, authentication and middleware
+- Works with SQLite, PostgreSQL, MySQL, MariaDB, MSSQL, Firebird
+- Hot reload in development (`uv run python -m jurigged app.py`)
+
+## Install
+
+```bash
+pip install tina4-python
+```
+
+## Documentation
+
+https://tina4.com/
+
+## Community
+
+- GitHub: https://github.com/tina4stack/tina4-python
+
+## License
+
+MIT © 2007 – 2025 Tina4 Stack  
+https://opensource.org/licenses/MIT
+
+---
+
+**Tina4** – The framework that keeps out of the way of your coding.

tina4_python-0.2.134/README.md

@@ -0,0 +1,65 @@
+# Tina4 Python — This is not a framework
+
+Laravel joy. Python speed. 10× less code.
+
+```python app.py
+from tina4_python import run_web_server
+from tina4_python.Router import get
+
+
+@get("/")
+async def get_hello_world(request, response):
+    return response("Hello World!")
+
+
+def app():
+    run_web_server()
+
+
+if __name__ == "__main__":
+    app()
+```
+
+That’s it. Save the code above as `app.py`, run it, and you have a fully working Tina4 Python web server.
+
+```bash
+pip install tina4-python
+python app.py
+# → http://localhost:7145
+```
+
+You just built your first Tina4 app — zero configuration, zero classes, zero boilerplate.
+
+## Features
+
+- Full ASGI compliance, use any ASGI compliant webserver
+- Full async support out of the box
+- Built in JWT and Session handling
+- Automatic Swagger docs at `/swagger`
+- Instant CRUD interfaces with one line: `result.to_crud(request)`
+- Built-in Twig templating, migrations, WebSockets, authentication and middleware
+- Works with SQLite, PostgreSQL, MySQL, MariaDB, MSSQL, Firebird
+- Hot reload in development (`uv run python -m jurigged app.py`)
+
+## Install
+
+```bash
+pip install tina4-python
+```
+
+## Documentation
+
+https://tina4.com/
+
+## Community
+
+- GitHub: https://github.com/tina4stack/tina4-python
+
+## License
+
+MIT © 2007 – 2025 Tina4 Stack  
+https://opensource.org/licenses/MIT
+
+---
+
+**Tina4** – The framework that keeps out of the way of your coding.

{tina4_python-0.2.133 → tina4_python-0.2.134}/pyproject.toml

@@ -1,44 +1,62 @@
-[project]
-name = "tina4-python"
-version = "0.2.133"
-description = "Tina4Python - This is not another framework for Python"
-authors = [
-    {name = "Andre van Zuydam",email = "andrevanzuydam@gmail.com"}
-]
-readme = "README.md"
-requires-python = ">=3.12,<4.0"
-dependencies = [
-    "jinja2>=3.1.5,<4.0.0",
-    "libsass (>=0.23.0,<0.24.0)",
-    "python-dotenv (>=1.0.1,<2.0.0)",
-    "pyjwt (>=2.10.1,<3.0.0)",
-    "cryptography (>=44.0.0,<45.0.0)",
-    "watchdog (>=6.0.0,<7.0.0)",
-    "bcrypt (>=4.2.1,<5.0.0)",
-    "litequeue (>=0.9,<0.10)",
-    "simple-websocket (>=1.1.0,<2.0.0)",
-    "hypercorn (>=0.17.3,<0.18.0)",
-    "asyncer>=0.0.8",
-]
-
-[dependency-groups]
-dev = [
-    "flake8>=7.2.0",
-    "jurigged>=0.6.0",
-    "mysql-connector-python>=9.3.0",
-    "psycopg2-binary>=2.9.10",
-    "pytest>=8.3.5",
-    "ruff>=0.11.9",
-    "safety>=3.5.0",
-]
-
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[tool.hatch.build]
-include = [
-    "tina4_python/**/*"
-]
-
-
+[project]
+name = "tina4-python"
+version = "0.2.134"
+description = "Tina4Python - This is not another framework for Python"
+authors = [
+    {name = "Andre van Zuydam",email = "andrevanzuydam@gmail.com"}
+]
+readme = "README.md"
+requires-python = ">=3.12,<4.0"
+dependencies = [
+    "jinja2>=3.1.5,<4.0.0",
+    "libsass (>=0.23.0,<0.24.0)",
+    "python-dotenv (>=1.0.1,<2.0.0)",
+    "pyjwt (>=2.10.1,<3.0.0)",
+    "cryptography (>=44.0.0,<45.0.0)",
+    "watchdog (>=6.0.0,<7.0.0)",
+    "bcrypt (>=4.2.1,<5.0.0)",
+    "litequeue (>=0.9,<0.10)",
+    "simple-websocket (>=1.1.0,<2.0.0)",
+    "asyncer>=0.0.8",
+    "uvicorn>=0.38.0",
+]
+
+[dependency-groups]
+dev = [
+    "flake8>=7.2.0",
+    "jurigged>=0.6.0",
+    "mkdocs>=1.6.1",
+    "mysql-connector-python>=9.3.0",
+    "psycopg2-binary>=2.9.10",
+    "pydoc-markdown>=4.8.2",
+    "pytest>=8.3.5",
+    "ruff>=0.11.9",
+    "safety>=3.5.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build]
+include = [
+    "tina4_python/**/*"
+]
+
+[project.scripts]
+tina4 = "tina4_python.cli:main"
+
+[[tool.pydoc-markdown.loaders]]
+type = "python"
+search_path = [ "./tina4_python" ]
+
+[tool.pydoc-markdown.renderer]
+type = "mkdocs"
+site_name= "Tina4Python"
+
+[[tool.pydoc-markdown.renderer.pages]]
+title = "API Documentation"
+name = "index"
+
+contents = [ "*" ]
+

tina4_python-0.2.134/tina4_python/Auth.py

@@ -0,0 +1,323 @@
+#
+# Tina4 - This is not a 4ramework.
+# Copy-right 2007 - current Tina4
+# License: MIT https://opensource.org/licenses/MIT
+#
+# flake8: noqa: E501
+import datetime
+import os
+import jwt
+import bcrypt
+from json import JSONEncoder
+from cryptography import x509
+from cryptography.x509 import NameOID
+from cryptography.hazmat.primitives import serialization, hashes
+from cryptography.hazmat.primitives.asymmetric import rsa
+from cryptography.hazmat.backends import default_backend
+
+class AuthJSONSerializer(JSONEncoder):
+    """
+    Custom JSON encoder used by PyJWT when serializing payload objects.
+
+    Ensures that ``datetime.datetime`` instances are correctly converted to ISO-8601
+    strings so they can be embedded in JWT claims.
+    """
+
+    def default(self, o):
+        if isinstance(o, datetime.datetime):
+            return o.isoformat()
+        return super().default(o)
+
+
+class Auth:
+    """
+    Authentication & authorization helper for Tina4 projects.
+
+    Handles:
+      - Password hashing/verification (bcrypt)
+      - Automatic creation and loading of an RSA private/public key pair
+      - Self-signed certificate generation for local HTTPS development
+      - Signing JWT tokens with RS256 (private key)
+      - Verifying JWT tokens with RS256 (public key)
+      - Simple API-KEY fallback validation
+
+    Keys and certificates are stored in ``<root_path>/secrets/``:
+        - private.key   → encrypted PEM private key
+        - public.key    → PEM public key (unencrypted)
+        - domain.cert   → self-signed certificate (for local dev servers)
+
+    Environment variables used:
+        - ``SECRET``            → passphrase used to encrypt the private key
+        - ``API_KEY``           → optional static API key (checked before JWT)
+        - ``TINA4_TOKEN_LIMIT`` → default token lifetime in minutes (default: 2)
+        - Country/State/City/Organization/Domain variables for the cert
+    """
+
+    # ------------------------------------------------------------------
+    # Class-level attributes (set in __init__)
+    # ------------------------------------------------------------------
+    secret: str | None = None          # Passphrase for private key encryption
+    private_key: str = None            # Path to encrypted private key file
+    public_key: str = None             # Path to public key file
+    self_signed: str = None            # Path to self-signed cert file
+    root_path: str = None              # Project root directory
+
+    # Cached key objects (avoid reloading from disk on every request)
+    loaded_private_key = None
+    loaded_public_key = None
+
+    # ------------------------------------------------------------------
+    # Password handling (bcrypt)
+    # ------------------------------------------------------------------
+    def hash_password(self, text: str) -> str:
+        """
+        Generate a bcrypt hash for the given plain-text password.
+
+        Args:
+            text (str): Plain-text password.
+
+        Returns:
+            str: bcrypt hash (as UTF-8 string). Safe to store in a database.
+        """
+        password_bytes = text.encode("utf-8")
+        salt = bcrypt.gensalt()
+        return bcrypt.hashpw(password_bytes, salt).decode("utf-8")
+
+    def check_password(self, password_hash: str, text: str) -> bool:
+        """
+        Verify a plain-text password against a previously created bcrypt hash.
+
+        Args:
+            password_hash (str): Hash returned by :meth:`hash_password`.
+            text (str): Plain-text password to verify.
+
+        Returns:
+            bool: ``True`` if the password matches the hash.
+        """
+        password_bytes = text.encode("utf-8")
+        return bcrypt.checkpw(password_bytes, password_hash.encode("utf-8"))
+
+    # ------------------------------------------------------------------
+    # Private / public key loading (with caching)
+    # ------------------------------------------------------------------
+    def load_private_key(self):
+        """
+        Load (and cache) the RSA private key from ``secrets/private.key``.
+
+        The key is encrypted with the passphrase stored in ``self.secret``
+        (which comes from the environment variable ``SECRET``).
+
+        Returns:
+            cryptography.hazmat.primitives.asymmetric.rsa.RSAPrivateKey
+        """
+        if self.loaded_private_key:
+            return self.loaded_private_key
+
+        with open(self.private_key, "rb") as f:
+            private_key = serialization.load_pem_private_key(
+                f.read(),
+                password=self.secret.encode(),
+                backend=default_backend(),
+            )
+            self.loaded_private_key = private_key
+            return private_key
+
+    def load_public_key(self):
+        """
+        Load (and cache) the RSA public key from ``secrets/public.key``.
+
+        Returns:
+            cryptography.hazmat.primitives.asymmetric.rsa.RSAPublicKey
+        """
+        if self.loaded_public_key:
+            return self.loaded_public_key
+
+        with open(self.public_key, "rb") as f:
+            public_key = serialization.load_pem_public_key(
+                f.read(), backend=default_backend()
+            )
+            self.loaded_public_key = public_key
+            return public_key
+
+    # ------------------------------------------------------------------
+    # Constructor – creates secrets folder & keys if missing
+    # ------------------------------------------------------------------
+    def __init__(self, root_path: str):
+        """
+        Initialise the Auth helper and ensure cryptographic material exists.
+
+        Args:
+            root_path (str): Absolute path to the project root (where the
+                             ``secrets`` folder will be created).
+        """
+        self.root_path = root_path
+        self.secret = os.environ.get("SECRET", "{self.secret}")
+        self.private_key = os.path.join(root_path, "secrets", "private.key")
+        self.public_key = os.path.join(root_path, "secrets", "public.key")
+        self.self_signed = os.path.join(root_path, "secrets", "domain.cert")
+
+        # Ensure secrets directory exists
+        os.makedirs(os.path.join(root_path, "secrets"), exist_ok=True)
+
+        # ------------------------------------------------------------------
+        # 1. Private key – generate if missing
+        # ------------------------------------------------------------------
+        if not os.path.isfile(self.private_key):
+            private_key = rsa.generate_private_key(
+                public_exponent=65537,
+                key_size=2048,
+            )
+            with open(self.private_key, "wb") as f:
+                f.write(private_key.private_bytes(
+                    encoding=serialization.Encoding.PEM,
+                    format=serialization.PrivateFormat.TraditionalOpenSSL,
+                    encryption_algorithm=serialization.BestAvailableEncryption(self.secret.encode()),
+                ))
+        else:
+            private_key = self.load_private_key()
+
+        # ------------------------------------------------------------------
+        # 2. Public key – derive from private key if missing
+        # ------------------------------------------------------------------
+        if not os.path.isfile(self.public_key):
+            public_key = private_key.public_key()
+            public_pem = public_key.public_bytes(
+                encoding=serialization.Encoding.PEM,
+                format=serialization.PublicFormat.SubjectPublicKeyInfo,
+            )
+            with open(self.public_key, "wb") as f:
+                f.write(public_pem)
+
+        # ------------------------------------------------------------------
+        # 3. Self-signed certificate (useful for local HTTPS servers)
+        # ------------------------------------------------------------------
+        if not os.path.isfile(self.self_signed):
+            subject = issuer = x509.Name(
+                [
+                    x509.NameAttribute(NameOID.COUNTRY_NAME, os.environ.get("COUNTRY", "ZA")),
+                    x509.NameAttribute(NameOID.STATE_OR_PROVINCE_NAME, os.environ.get("STATE", "WESTERN CAPE")),
+                    x509.NameAttribute(NameOID.LOCALITY_NAME, os.environ.get("CITY", "CAPE TOWN")),
+                    x509.NameAttribute(NameOID.ORGANIZATION_NAME, os.environ.get("ORGANIZATION", "Tina4")),
+                    x509.NameAttribute(NameOID.COMMON_NAME, os.environ.get("DOMAIN_NAME", "localhost")),
+                ]
+            )
+            cert = (
+                x509.CertificateBuilder()
+                .subject_name(subject)
+                .issuer_name(issuer)
+                .public_key(private_key.public_key())
+                .serial_number(x509.random_serial_number())
+                .not_valid_before(datetime.datetime.now(datetime.timezone.utc))
+                .not_valid_after(datetime.datetime.now(datetime.timezone.utc) + datetime.timedelta(days=99999))
+                .add_extension(x509.SubjectAlternativeName([x509.DNSName("localhost")]), critical=False)
+                .sign(private_key, hashes.SHA256())
+            )
+
+            with open(self.self_signed, "wb") as f:
+                f.write(cert.public_bytes(serialization.Encoding.PEM))
+
+    # ------------------------------------------------------------------
+    # JWT creation & verification
+    # ------------------------------------------------------------------
+    def get_token(self, payload_data: dict, expiry_minutes: int = 0) -> str:
+        """
+        Create a signed JWT (RS256) containing the supplied payload.
+
+        If ``expires`` is not present in ``payload_data`` an expiration claim
+        will be added automatically using ``TINA4_TOKEN_LIMIT`` (default 2 minutes)
+        or the value supplied via ``expiry_minutes``.
+
+        Args:
+            payload_data (dict): Claims to embed in the token.
+            expiry_minutes (int): Override default token lifetime (0 = use env default).
+
+        Returns:
+            str: Signed JWT (compact serialization).
+        """
+        private_key = self.load_private_key()
+        now = datetime.datetime.now(datetime.timezone.utc)
+
+        if "expires" not in payload_data:
+            token_limit_minutes = int(os.environ.get("TINA4_TOKEN_LIMIT", 2))
+            if expiry_minutes != 0:
+                token_limit_minutes = expiry_minutes
+            expiry_time = now + datetime.timedelta(minutes=token_limit_minutes)
+            payload_data["expires"] = expiry_time.isoformat()
+
+        token = jwt.encode(
+            payload=payload_data,
+            key=private_key,
+            algorithm="RS256",
+            json_encoder=AuthJSONSerializer,
+        )
+        return token
+
+    def get_payload(self, token: str) -> dict | None:
+        """
+        Decode a JWT and return its payload (without verification of expiry).
+
+        Used when you only need the claims and will perform your own validation.
+
+        Args:
+            token (str): JWT to decode.
+
+        Returns:
+            dict | None: Payload dictionary or ``None`` on invalid signature.
+        """
+        public_key = self.load_public_key()
+        try:
+            payload = jwt.decode(token, key=public_key, algorithms=["RS256"])
+            return payload
+        except jwt.InvalidSignatureError:
+            return None
+
+    def validate(self, token: str) -> bool:
+        """
+        Full token validation.
+
+        Checks:
+          1. Optional static ``API_KEY`` environment variable (quick bypass)
+          2. RS256 signature using the public key
+          3. Presence and validity of the ``expires`` claim
+
+        Args:
+            token (str): Bearer token.
+
+        Returns:
+            bool: ``True`` if the token is valid and not expired.
+        """
+        # Simple API-KEY fallback (useful for quick internal scripts)
+        if os.environ.get("API_KEY") and token == os.environ.get("API_KEY"):
+            return True
+
+        public_key = self.load_public_key()
+        try:
+            payload = jwt.decode(token, key=public_key, algorithms=["RS256"])
+
+            if "expires" not in payload:
+                return False
+
+            expiry_time = datetime.datetime.fromisoformat(payload["expires"])
+            if expiry_time.tzinfo is None:
+                # Treat naive datetime as UTC for backward compatibility
+                expiry_time = expiry_time.replace(tzinfo=datetime.timezone.utc)
+
+            return datetime.datetime.now(datetime.timezone.utc) <= expiry_time
+
+        except Exception:  # noqa: BLE001 – we intentionally catch everything here
+            return False
+
+    # ------------------------------------------------------------------
+    # Alias for backward compatibility
+    # ------------------------------------------------------------------
+    def valid(self, token: str) -> bool:
+        """
+        Alias of :meth:`validate`. Kept for older codebases.
+
+        Args:
+            token (str): Bearer token.
+
+        Returns:
+            bool: ``True`` if token is valid.
+        """
+        return self.validate(token)