tina4-python 0.2.175__tar.gz → 0.2.183__tar.gz

{tina4_python-0.2.175 → tina4_python-0.2.183}/.gitignore

@@ -27,6 +27,11 @@
 /tests/.env
 /tests/app.py
 /test.db
+*.db-wal
+*.db-shm
+*.db-journal
+test_queue*.db
+/queue.db
 /logs/
 /migrations/__test_user.sql
 /migrations/__test_user_item.sql
@@ -36,7 +41,6 @@
 /publish.bat
 /Dockerfile
 /data.db
-/test_queue.db-shm
 /publish.sh
 /src/scss/
 /broken

{tina4_python-0.2.175 → tina4_python-0.2.183}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tina4-python
-Version: 0.2.175
+Version: 0.2.183
 Summary: Tina4Python - This is not another framework for Python
 Author-email: Andre van Zuydam <andrevanzuydam@gmail.com>
 Requires-Python: <4.0,>=3.12

{tina4_python-0.2.175 → tina4_python-0.2.183}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tina4-python"
-version = "0.2.175"
+version = "0.2.183"
 description = "Tina4Python - This is not another framework for Python"
 authors = [
     {name = "Andre van Zuydam",email = "andrevanzuydam@gmail.com"}

{tina4_python-0.2.175 → tina4_python-0.2.183}/tina4_python/Api.py

@@ -4,6 +4,27 @@
 # License: MIT https://opensource.org/licenses/MIT
 #
 # flake8: noqa: E501
+"""HTTP client for consuming external REST APIs.
+
+The ``Api`` class is a lightweight wrapper around ``requests`` that
+simplifies common patterns when calling third-party services from
+Tina4 applications.
+
+Features:
+    - Base URL with automatic path joining
+    - Bearer token and custom ``Authorization`` header support
+    - HTTP Basic authentication
+    - Persistent and per-request custom headers
+    - Automatic JSON serialisation of request bodies
+    - SSL verification toggle
+    - Consistent response dict: ``{status_code, data, headers}``
+
+Example::
+
+    api = Api("https://api.example.com", token="sk-...")
+    result = api.get("/users")
+    user = api.post("/users", {"name": "Alice"})
+"""
 
 import json
 from typing import Optional, Dict, Any, Union, List

{tina4_python-0.2.175 → tina4_python-0.2.183}/tina4_python/Auth.py

@@ -4,6 +4,33 @@
 # License: MIT https://opensource.org/licenses/MIT
 #
 # flake8: noqa: E501
+"""JWT authentication and password hashing for Tina4.
+
+Provides the ``Auth`` class which handles:
+    - RS256 JWT token creation and validation using auto-generated
+      self-signed certificates (stored in the ``cert/`` directory)
+    - Configurable token expiry (default 24 hours, override via
+      ``TINA4_TOKEN_EXPIRES_IN`` environment variable)
+    - Password hashing and verification using bcrypt
+    - Payload extraction from valid or expired tokens
+
+The framework creates a global ``tina4_python.tina4_auth`` instance at
+startup. Sessions, secured routes, and middleware all delegate to this
+instance for token operations.
+
+Example::
+
+    from tina4_python import tina4_auth
+
+    token = tina4_auth.get_token({"user_id": 42})
+    is_valid = tina4_auth.valid(token)
+    payload = tina4_auth.get_payload(token)
+    hashed = tina4_auth.get_password("secret")
+    ok = tina4_auth.check_password("secret", hashed)
+"""
+
+__all__ = ["Auth", "AuthJSONSerializer"]
+
 import datetime
 import os
 import jwt
@@ -271,7 +298,7 @@ class Auth:
         try:
             payload = jwt.decode(token, key=public_key, algorithms=["RS256"])
             return payload
-        except jwt.InvalidSignatureError:
+        except Exception:
             return None
 
     def validate(self, token: str) -> bool:

{tina4_python-0.2.175 → tina4_python-0.2.183}/tina4_python/CLAUDE.md

@@ -62,6 +62,7 @@ async def create_user(request, response):
 - **POST/PUT/PATCH/DELETE** require `Authorization: Bearer <token>`
 - Use `@noauth()` to make a write route public
 - Use `@secured()` to protect a GET route
+- Make sure you use formToken filter in forms when you need to POST data.
 
 ```python
 from tina4_python.Router import post, noauth, secured
@@ -105,6 +106,14 @@ from tina4_python.Response import Response
 Response.add_header("X-Custom", "value")
 ```
 
+## Sessions
+
+TINA4_TOKEN_LIMIT is used to set the session time, recommend 15-30 minutes
+
+### Authentication & Security
+- Use `tina4_python.tina4_auth.hash_password()` to hash passwords — never use hashlib directly.
+- Use `tina4_python.tina4_auth.check_password(hash, password)` to verify passwords.
+
 ## Templates (Twig)
 
 Templates use Jinja2/Twig syntax and live in `src/templates/`.

{tina4_python-0.2.175 → tina4_python-0.2.183}/tina4_python/CRUD.py

@@ -4,6 +4,28 @@
 # License: MIT https://opensource.org/licenses/MIT
 #
 # flake8: noqa: E501
+"""Automatic CRUD interface generator for Tina4 database results.
+
+The ``CRUD`` class turns any SQL result set into a searchable, paginated
+HTML + JSON interface with automatic RESTful route registration. It is
+the base class of ``DatabaseResult``, so every query result inherits
+these capabilities.
+
+Features:
+    - Zero-configuration table detection from SELECT queries
+    - Automatic route registration (GET, POST, DELETE) for a full CRUD UI
+    - Built-in server-side search and pagination
+    - Safe JSON serialisation (Decimal, datetime, bytes → base64)
+    - Per-table Twig template auto-copy for customisation
+    - Works with all supported database drivers
+
+Example::
+
+    result = db.fetch("select * from articles")
+    html = result.to_crud(request, {"primary_key": "id", "limit": 25})
+"""
+
+__all__ = ["CRUD"]
 
 import base64
 import datetime
@@ -345,7 +367,7 @@ class CRUD:
         except Exception as e:
             return "Error rendering CRUD: "+str(e)
 
-    def to_array(self, _filter=None, base64_encode = True):
+    def to_array(self, filter_fn=None, base64_encode = True):
         """
         Convert the internal records to a JSON-serializable list of dictionaries.
 
@@ -355,11 +377,11 @@ class CRUD:
           • bytes/memoryview → base64 encoded string
 
         Args:
-            _filter (callable, optional): Function applied to each record dict before returning.
+            filter_fn (callable, optional): Function applied to each record dict before returning.
 
         Returns:
             list[dict]: Serializable records.
-            :param _filter:
+            :param filter_fn:
             :param base64_encode: Override default base64 encoding
         """
         if self.error is not None:
@@ -379,7 +401,7 @@ class CRUD:
                             json_record[key] = base64.b64encode(record[key].tobytes()).decode('utf-8')
                         else:
                             json_record[key] = record[key].tobytes().decode("utf-8")
-                    elif isinstance(record[key], bytes) and base64_encode:
+                    elif isinstance(record[key], bytes):
                         if base64_encode:
                             json_record[key] = base64.b64encode(record[key]).decode('utf-8')
                         else:
@@ -387,8 +409,8 @@ class CRUD:
                     else:
                         json_record[key] = record[key]
 
-                if _filter is not None:
-                    json_record = _filter(json_record)
+                if filter_fn is not None:
+                    json_record = filter_fn(json_record)
 
                 json_records.append(json_record)
 
@@ -396,13 +418,13 @@ class CRUD:
         else:
             return []
 
-    def to_list(self, _filter=None, base64_encode = True):
+    def to_list(self, filter_fn=None, base64_encode = True):
         """Alias of to_array() for readability."""
-        return self.to_array(_filter, base64_encode=base64_encode)
+        return self.to_array(filter_fn, base64_encode=base64_encode)
 
-    def to_json(self, _filter=None, base64_encode = True):
+    def to_json(self, filter_fn=None, base64_encode = True):
         """Return records as a JSON encoded string."""
-        return json.dumps(self.to_array(_filter, base64_encode=base64_encode))
+        return json.dumps(self.to_array(filter_fn, base64_encode=base64_encode))
 
     def __iter__(self):
         """Allow iteration over records (yields results from to_array())."""

{tina4_python-0.2.175 → tina4_python-0.2.183}/tina4_python/Constant.py

@@ -18,6 +18,24 @@ They are intentionally simple strings/integers to allow direct comparison
 and use in decorators, routing, and response handling.
 """
 
+__all__ = [
+    # Logging levels
+    "TINA4_LOG_INFO", "TINA4_LOG_WARNING", "TINA4_LOG_DEBUG",
+    "TINA4_LOG_ERROR", "TINA4_LOG_ALL",
+    # HTTP methods
+    "TINA4_GET", "TINA4_POST", "TINA4_ANY", "TINA4_PATCH",
+    "TINA4_PUT", "TINA4_DELETE", "TINA4_OPTIONS",
+    # HTTP status codes
+    "HTTP_OK", "HTTP_CREATED", "HTTP_ACCEPTED", "HTTP_NO_CONTENT",
+    "HTTP_PARTIAL_CONTENT", "HTTP_REDIRECT_MOVED", "HTTP_REDIRECT",
+    "HTTP_REDIRECT_OTHER", "HTTP_BAD_REQUEST", "HTTP_UNAUTHORIZED",
+    "HTTP_FORBIDDEN", "HTTP_NOT_FOUND", "HTTP_SERVER_ERROR",
+    "LOOKUP_HTTP_CODE",
+    # MIME types
+    "TEXT_HTML", "TEXT_CSS", "TEXT_PLAIN", "TEXT_JAVASCRIPT",
+    "APPLICATION_JSON", "APPLICATION_XML",
+]
+
 # ----------------------------------------------------------------------
 # Logging Levels
 # ----------------------------------------------------------------------

{tina4_python-0.2.175 → tina4_python-0.2.183}/tina4_python/Database.py

@@ -4,6 +4,42 @@
 # License: MIT https://opensource.org/licenses/MIT
 #
 # flake8: noqa: E501
+"""Multi-driver database abstraction layer for Tina4.
+
+This module provides the ``Database`` class — a unified interface for
+connecting to and querying relational databases. Driver selection is
+automatic based on the connection-string prefix:
+
+Supported drivers:
+    - ``sqlite`` — SQLite 3 (built-in, file-based)
+    - ``mysql`` — MySQL / MariaDB via ``mysql-connector-python``
+    - ``postgres`` — PostgreSQL via ``psycopg2``
+    - ``firebird`` — Firebird via ``firebirdsql``
+    - ``mssql`` — Microsoft SQL Server via ``pymssql``
+    - ``odbc`` — Generic ODBC via ``pyodbc``
+
+Key features:
+    - Connection-string parsing (``driver:host/port:schema``)
+    - Parameter-based queries with ``?`` placeholders
+    - Built-in pagination via ``fetch(sql, limit, skip)``
+    - Full-text search across specified columns
+    - CRUD helpers: ``insert``, ``update``, ``delete``
+    - Transaction support: ``begin``, ``commit``, ``rollback``
+    - Metadata introspection: ``get_database_tables``, ``get_table_info``
+    - Automatic JSON/Decimal/datetime serialisation in results
+
+Example::
+
+    from tina4_python.Database import Database
+
+    db = Database("sqlite:my_app.db")
+    result = db.fetch("select * from users", limit=10, skip=0)
+    for row in result:
+        print(row)
+"""
+
+__all__ = ["Database"]
+
 import base64
 import os
 import re
@@ -19,24 +55,24 @@ import datetime
 
 class Database:
 
-    def __init__(self, _connection_string, _username="", _password=""):
+    def __init__(self, connection_string, username="", password=""):
         """
         Initializes a database connection
-        :param _connection_string:
+        :param connection_string:
         """
         # split out the connection string
         # driver:host/port:schema/path
-        params = _connection_string.split(":", 1)
+        params = connection_string.split(":", 1)
 
         try:
-            if _connection_string is None:
-                _connection_string = os.environ.get("DATABASE_PATH", None)
-            if _username == "":
-                _username = os.environ.get("DATABASE_USERNAME", "")
-            if _password == "":
-                _password = os.environ.get("DATABASE_PASSWORD", "")
-
-            if _connection_string is None:
+            if connection_string is None:
+                connection_string = os.environ.get("DATABASE_PATH", None)
+            if username == "":
+                username = os.environ.get("DATABASE_USERNAME", "")
+            if password == "":
+                password = os.environ.get("DATABASE_PASSWORD", "")
+
+            if connection_string is None:
                 raise Exception("Database connection string is missing, try declaring DATABASE_PATH in the .env file.")
 
             self.database_module = importlib.import_module(params[0])
@@ -58,8 +94,8 @@ class Database:
 
         self.database_engine = params[0]
         self.database_path = params[1]
-        self.username = _username
-        self.password = _password
+        self.username = username
+        self.password = password
 
         if self.database_engine == SQLITE:
             self.dba = self.database_module.connect(self.database_path)

{tina4_python-0.2.175 → tina4_python-0.2.183}/tina4_python/DatabaseResult.py

@@ -4,17 +4,40 @@
 # License: MIT https://opensource.org/licenses/MIT
 #
 # flake8: noqa: E501
+"""Database query result container with serialisation and CRUD support.
+
+``DatabaseResult`` wraps the rows returned by a database query and extends
+``CRUD`` so that any result set can be converted to JSON, paginated HTML,
+or a full CRUD interface with a single method call.
+
+Serialisation formats:
+    - ``to_array()`` / ``to_list()`` — Python list of dicts (JSON-safe)
+    - ``to_json()`` — JSON string
+    - ``to_paginate()`` — dict ready for DataTables-style pagination
+    - ``to_csv()`` — CSV text with headers
+    - ``to_crud(request, options)`` — full HTML + REST CRUD interface
+
+Example::
+
+    result = db.fetch("select * from products", limit=25)
+    print(result.to_json())         # JSON array
+    print(result.to_csv())          # CSV text
+    paginated = result.to_paginate()  # {recordsTotal, data, ...}
+"""
+
+__all__ = ["DatabaseResult"]
+
 import csv
 import io
 from tina4_python.CRUD import CRUD
 
 class DatabaseResult(CRUD):
-    def __init__(self, _records=None, _columns=None, _error=None, count=None, limit=None, skip=None, sql=None, dba=None):
+    def __init__(self, records_list=None, columns=None, error=None, count=None, limit=None, skip=None, sql=None, dba=None):
         """
         DatabaseResult constructor
-        :param _records:
-        :param _columns:
-        :param _error:
+        :param records_list:
+        :param columns:
+        :param error:
         :param count:
         :param limit:
         :param skip:
@@ -35,15 +58,15 @@ class DatabaseResult(CRUD):
         else:
             self.skip = 0
 
-        if _records is not None:
-            self.records = _records
+        if records_list is not None:
+            self.records = records_list
         else:
             self.records = []
 
         self.count = len(self.records)
 
-        if _columns is not None:
-            self.columns = _columns
+        if columns is not None:
+            self.columns = columns
         else:
             self.columns = []
 
@@ -53,7 +76,7 @@ class DatabaseResult(CRUD):
         if dba is not None:
             self.dba = dba
 
-        self.error = _error
+        self.error = error
 
     def to_paginate(self):
         """

{tina4_python-0.2.175 → tina4_python-0.2.183}/tina4_python/DatabaseTypes.py

@@ -4,6 +4,20 @@
 # License: MIT https://opensource.org/licenses/MIT
 #
 # flake8: noqa: E501
+"""Database driver identifiers and install instructions.
+
+Maps short driver names to their Python module paths and provides
+human-readable installation commands for each supported database.
+"""
+
+__all__ = [
+    "SQLITE",
+    "FIREBIRD", "FIREBIRD_INSTALL",
+    "MYSQL", "MYSQL_INSTALL",
+    "POSTGRES", "POSTGRES_INSTALL",
+    "MSSQL", "MSSQL_INSTALL",
+]
+
 SQLITE = "sqlite3"
 FIREBIRD = "firebird.driver"
 FIREBIRD_INSTALL = "pip install firebird-driver or poetry add firebird-driver"

tina4_python-0.2.183/tina4_python/Debug.py

@@ -0,0 +1,225 @@
+#
+# Tina4 - This is not a 4ramework.
+# Copy-right 2007 - current Tina4
+# License: MIT https://opensource.org/licenses/MIT
+#
+# flake8: noqa: E501
+"""Centralised logging and debug output for Tina4 Python.
+
+This module provides a dual-output logging system:
+
+- **Console handler** -- coloured output whose verbosity is controlled by the
+  ``TINA4_DEBUG_LEVEL`` environment variable (default ``All``).
+- **File handler** -- a rotating log file at ``./logs/debug.log`` that always
+  captures *all* levels (DEBUG and above), regardless of the console setting.
+
+The module exposes a single callable singleton, ``Debug``, which can be used
+either as a function or via its convenience static methods::
+
+    from tina4_python.Debug import Debug
+
+    Debug("Server started on port", port)       # default INFO level
+    Debug.error("Something went wrong:", err)   # ERROR level
+    Debug.warning("Disk space low")             # WARNING level
+    Debug.debug("Verbose trace info")           # DEBUG level
+
+Valid values for the ``TINA4_DEBUG_LEVEL`` env var (case-insensitive):
+``All``, ``Debug``, ``Info``, ``Warning``, ``Error``.
+"""
+
+__all__ = ["Debug", "setup_logging"]
+
+import os
+import sys
+import logging
+from logging.handlers import RotatingFileHandler
+
+from tina4_python.Constant import (
+    TINA4_LOG_ALL,
+    TINA4_LOG_DEBUG,
+    TINA4_LOG_INFO,
+    TINA4_LOG_WARNING,
+    TINA4_LOG_ERROR,
+)
+from tina4_python.ShellColors import ShellColors
+
+
+class ColoredFormatter(logging.Formatter):
+    """Custom logging formatter that applies ANSI colour codes to log output.
+
+    Each log level is mapped to a colour from ``ShellColors`` so that console
+    output is easy to scan visually.  Both the message body and the level name
+    are wrapped in the appropriate colour escape sequences.
+
+    Attributes:
+        LEVEL_COLORS (dict): Mapping of ``logging`` level constants to ANSI
+            colour escape strings.
+    """
+
+    LEVEL_COLORS = {
+        logging.DEBUG: ShellColors.green,
+        logging.INFO: ShellColors.cyan,
+        logging.WARNING: ShellColors.bright_yellow,
+        logging.ERROR: ShellColors.bright_red,
+        logging.CRITICAL: ShellColors.bright_red + ShellColors.bold,
+    }
+
+    def format(self, record):
+        """Format a log record with ANSI colour codes.
+
+        Args:
+            record (logging.LogRecord): The log record to format.
+
+        Returns:
+            str: The formatted, colour-coded log string.
+        """
+        color = self.LEVEL_COLORS.get(record.levelno, "")
+        record.msg = f"{color}{record.msg}{ShellColors.end}"
+        record.levelname = f"{color}{record.levelname}{ShellColors.end}"
+        return super().format(record)
+
+
+def setup_logging():
+    """Initialise the ``TINA4`` logger with console and file handlers.
+
+    This function is idempotent -- if the logger already has handlers
+    attached it returns immediately, so it is safe to call multiple times.
+
+    Behaviour:
+
+    * Reads the ``TINA4_DEBUG_LEVEL`` environment variable (falling back to
+      ``All``) and maps it to a Python ``logging`` level for the console handler.
+    * Creates a ``StreamHandler`` on ``sys.stdout`` with coloured output via
+      ``ColoredFormatter``.
+    * Creates a ``RotatingFileHandler`` at ``./logs/debug.log`` (5 MB per file,
+      10 backups) that always logs at ``DEBUG`` level.
+    """
+    logger = logging.getLogger("TINA4")
+    if logger.handlers:
+        return
+
+    raw = str(os.getenv("TINA4_DEBUG_LEVEL", TINA4_LOG_ALL))
+    clean = "".join(c for c in raw if c.isalnum() or c == "_").upper()
+
+    level_map = {
+        "ALL": logging.DEBUG, "TINA4_LOG_ALL": logging.DEBUG,
+        "DEBUG": logging.DEBUG, "TINA4_LOG_DEBUG": logging.DEBUG,
+        "INFO": logging.INFO, "TINA4_LOG_INFO": logging.INFO,
+        "WARN": logging.WARNING, "WARNING": logging.WARNING, "TINA4_LOG_WARNING": logging.WARNING,
+        "ERROR": logging.ERROR, "TINA4_LOG_ERROR": logging.ERROR,
+    }
+    console_level = level_map.get(clean, logging.INFO)
+
+    # Root logger = console level → blocks lower messages on console
+    logger.setLevel(console_level)
+
+    # Console – respects the level
+    console = logging.StreamHandler(sys.stdout)
+    console.setLevel(console_level)
+    console.setFormatter(ColoredFormatter(
+        fmt="%(levelname)-8s: %(asctime)s: %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S"
+    ))
+    logger.addHandler(console)
+
+    # File – ALWAYS logs everything (DEBUG and above)
+    os.makedirs("./logs", exist_ok=True)
+    file_handler = RotatingFileHandler(
+        "./logs/debug.log",
+        maxBytes=5*1024*1024,
+        backupCount=10,
+        encoding="utf-8"
+    )
+    file_handler.setLevel(logging.DEBUG)
+    file_handler.setFormatter(logging.Formatter(
+        "%(levelname)-8s: %(asctime)s: %(message)s"
+    ))
+    logger.addHandler(file_handler)
+
+
+class _Debug:
+    """Callable singleton that wraps the ``TINA4`` logger.
+
+    Instances of this class act as both a function and an object with static
+    convenience methods (``info``, ``error``, ``warning``, ``debug``).
+    The module creates a single global instance named ``Debug`` (see bottom
+    of module) which is the public API.
+
+    Examples::
+
+        Debug("Processing request", request_id)            # INFO (default)
+        Debug("trace data", data, level=TINA4_LOG_DEBUG)   # explicit level
+        Debug.error("Unexpected failure:", exc)             # static shortcut
+    """
+
+    def __init__(self):
+        """Create the debug wrapper around the ``TINA4`` logger."""
+        self.logger = logging.getLogger("TINA4")
+
+    def __call__(self, *messages, level=TINA4_LOG_INFO):
+        """Log one or more values at the given level.
+
+        All positional arguments are stringified and joined with spaces.
+
+        Args:
+            *messages: Values to log.  Each is converted to ``str`` and
+                concatenated with a single space separator.
+            level (str): One of the ``TINA4_LOG_*`` constants from
+                ``tina4_python.Constant``.  Defaults to ``TINA4_LOG_INFO``.
+        """
+        msg = " ".join(str(m) for m in messages)
+        mapping = {
+            TINA4_LOG_ALL:     self.logger.debug,
+            TINA4_LOG_DEBUG:   self.logger.debug,
+            TINA4_LOG_INFO:    self.logger.info,
+            TINA4_LOG_WARNING: self.logger.warning,
+            TINA4_LOG_ERROR:   self.logger.error,
+        }
+        func = mapping.get(level, self.logger.info)
+        func(msg)
+
+    @staticmethod
+    def info(*m):
+        """Log a message at INFO level.
+
+        Args:
+            *m: Values to log.  Each is converted to ``str`` and joined
+                with a single space.
+        """
+        logging.getLogger("TINA4").info(" ".join(str(x) for x in m))
+
+    @staticmethod
+    def error(*m):
+        """Log a message at ERROR level.
+
+        Args:
+            *m: Values to log.  Each is converted to ``str`` and joined
+                with a single space.
+        """
+        logging.getLogger("TINA4").error(" ".join(str(x) for x in m))
+
+    @staticmethod
+    def warning(*m):
+        """Log a message at WARNING level.
+
+        Args:
+            *m: Values to log.  Each is converted to ``str`` and joined
+                with a single space.
+        """
+        logging.getLogger("TINA4").warning(" ".join(str(x) for x in m))
+
+    @staticmethod
+    def debug(*m):
+        """Log a message at DEBUG level.
+
+        Args:
+            *m: Values to log.  Each is converted to ``str`` and joined
+                with a single space.
+        """
+        logging.getLogger("TINA4").debug(" ".join(str(x) for x in m))
+
+
+# Global callable instance — created after class is defined
+Debug = _Debug()
+
+__all__ = ["Debug"]