jongo 0.2.0__tar.gz → 0.2.2__tar.gz

{jongo-0.2.0 → jongo-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jongo
-Version: 0.2.0
+Version: 0.2.2
 Summary: A full-stack Python web framework: routes, server code and reactive UI in one language.
 Author: Joshua Harty
 License: MIT
@@ -331,12 +331,12 @@ cd examples/todo && ../../.venv/bin/jongo dev
 
 ## Status
 
-Version 0.2 — 0.1 hardened by a stress audit (see `CHANGELOG.md`). Known limits:
+Version 0.2 — 0.1 hardened over two stress-audit passes (see `CHANGELOG.md`). Known limits:
 - SQLite only.
 - No WebSockets yet.
 - No classes in browser code.
 - Components re-render their subtree without memoisation.
-- Integers beyond 2⁵³ lose precision in browser code (JavaScript numbers are float64); do big-integer work in a `@server` function.
 - `x__ne=v` / `.exclude(field=v)` also match rows where the column is `NULL` (matching Python's `None != v`, not SQL's three-valued logic).
+- Browser (post-hydration) code inherits JavaScript's value model, so a few things differ from CPython (the server is always correct): integers past 2⁵³ lose precision and `str(2.0)` shows `"2"` (one number type — format explicitly, e.g. `f"{x:.2f}"`); a dict keyed by ints iterates string keys; `len("😀")` counts UTF-16 units; `(1,2) == [1,2]` is true. Do exact numeric/big-integer work in a `@server` function.
 
 Bug reports and ideas are welcome.

{jongo-0.2.0 → jongo-0.2.2}/README.md

@@ -301,12 +301,12 @@ cd examples/todo && ../../.venv/bin/jongo dev
 
 ## Status
 
-Version 0.2 — 0.1 hardened by a stress audit (see `CHANGELOG.md`). Known limits:
+Version 0.2 — 0.1 hardened over two stress-audit passes (see `CHANGELOG.md`). Known limits:
 - SQLite only.
 - No WebSockets yet.
 - No classes in browser code.
 - Components re-render their subtree without memoisation.
-- Integers beyond 2⁵³ lose precision in browser code (JavaScript numbers are float64); do big-integer work in a `@server` function.
 - `x__ne=v` / `.exclude(field=v)` also match rows where the column is `NULL` (matching Python's `None != v`, not SQL's three-valued logic).
+- Browser (post-hydration) code inherits JavaScript's value model, so a few things differ from CPython (the server is always correct): integers past 2⁵³ lose precision and `str(2.0)` shows `"2"` (one number type — format explicitly, e.g. `f"{x:.2f}"`); a dict keyed by ints iterates string keys; `len("😀")` counts UTF-16 units; `(1,2) == [1,2]` is true. Do exact numeric/big-integer work in a `@server` function.
 
 Bug reports and ideas are welcome.

{jongo-0.2.0 → jongo-0.2.2}/jongo/__init__.py

@@ -23,7 +23,7 @@ from .vdom import (
     state,
 )
 
-__version__ = "0.2.0"
+__version__ = "0.2.2"
 
 __all__ = [
     "Jongo", "Page", "Request", "Response", "redirect", "json_response",

{jongo-0.2.0 → jongo-0.2.2}/jongo/app.py

@@ -18,6 +18,7 @@ import urllib.parse
 from pathlib import Path
 
 from . import vdom
+from . import log as jlog
 from .errors import CompileError, HTTPError, NotFound
 from .http import (
     CSRF_COOKIE,
@@ -63,6 +64,7 @@ class Jongo:
         login_url: str = "/login",
         session_max_age: int = 14 * 24 * 3600,
         static_url: str = "/static",
+        trust_proxy: bool = False,
     ):
         self.name = name or "app"
         module = sys.modules.get(name) if name else None
@@ -79,6 +81,7 @@ class Jongo:
         self.login_url = login_url
         self.session_max_age = session_max_age
         self.static_url = static_url.rstrip("/")
+        self.trust_proxy = trust_proxy  # trust X-Forwarded-Proto only when behind a known proxy
         self.router = Router()
         self.boot_id = secrets.token_hex(8)
         self.before_request_hooks: list = []
@@ -168,27 +171,38 @@ class Jongo:
 
     def handle(self, request: Request) -> Response:
         started = time.perf_counter()
-        try:
-            self._load_session(request)
-            response = None
-            for hook in self.before_request_hooks:
-                result = hook(request)
-                if result is not None:
-                    response = self.to_response(result, request)
-                    break
-            if response is None:
-                response = self._dispatch(request)
-        except HTTPError as exc:
-            response = self.http_error(request, exc)
-        except Exception as exc:
-            response = self.server_error(request, exc)
-        for hook in self.after_request_hooks:
-            response = hook(request, response) or response
-        self._finish(request, response)
-        if self.dev and not request.path.startswith("/_jongo/"):
-            elapsed = (time.perf_counter() - started) * 1000
-            log.info("%s %s -> %s (%.1f ms)", request.method, request.full_path, response.status, elapsed)
-        return response
+        with jlog.request_scope():
+            try:
+                self._load_session(request)
+                response = None
+                for hook in self.before_request_hooks:
+                    result = hook(request)
+                    if result is not None:
+                        response = self.to_response(result, request)
+                        break
+                if response is None:
+                    response = self._dispatch(request)
+            except HTTPError as exc:
+                response = self.http_error(request, exc)
+            except Exception as exc:
+                response = self.server_error(request, exc)
+            try:
+                for hook in self.after_request_hooks:
+                    response = hook(request, response) or response
+                self._finish(request, response)
+            except Exception as exc:
+                # A failing after_request hook or _finish (e.g. a non-serialisable session)
+                # must still yield a proper 500 instead of escaping to the WSGI server.
+                response = self.server_error(request, exc)
+                try:
+                    self._finish(request, response)
+                except Exception:
+                    jlog.get_logger("http").error("failed to finalise error response", exc_info=True)
+            if self.dev and not (request.path.startswith("/_jongo/app") or request.path == "/_jongo/live"):
+                elapsed = (time.perf_counter() - started) * 1000
+                route_name = getattr(getattr(request, "route", None), "name", None)
+                jlog.request_done(request.method, request.full_path, response.status, elapsed, route=route_name)
+            return response
 
     def _dispatch(self, request: Request) -> Response:
         route, params = self.router.match(request.method, request.path)
@@ -381,7 +395,7 @@ class Jongo:
         return Response(http_error_page(exc), exc.status, headers)
 
     def server_error(self, request: Request, exc: Exception) -> Response:
-        log.error("error handling %s %s\n%s", request.method, request.full_path, "".join(traceback.format_exception(exc)))
+        jlog.get_logger("http").error("error handling %s %s", request.method, request.full_path, exc_info=exc)
         if request.path.startswith("/_jongo/rpc/"):
             error = {"type": type(exc).__name__, "message": str(exc) if self.dev else "Server error"}
             if self.dev:

{jongo-0.2.0 → jongo-0.2.2}/jongo/cli.py

@@ -177,7 +177,7 @@ def cmd_build(args):
 
 def main(argv=None):
     parser = argparse.ArgumentParser(prog="jongo", description="Full-stack Python web framework")
-    parser.add_argument("--version", action="version", version="jongo 0.2.0")
+    parser.add_argument("--version", action="version", version="jongo 0.2.2")
     sub = parser.add_subparsers(dest="command", metavar="command")
 
     def add(name, fn, help_text, app_arg=True):

{jongo-0.2.0 → jongo-0.2.2}/jongo/compiler/pyrt.js

@@ -121,12 +121,23 @@ function $cmp(a, b) {
   return a < b ? -1 : a > b ? 1 : 0;
 }
 
+// Python hashes True as 1 and False as 0, so a bool used as a set element or dict key
+// is the same as the int. JS keeps them distinct (Set) / stringifies to "true" (object),
+// so normalise bools to numbers wherever a value is used as a key/member.
+function $key(x) {
+  return typeof x === "boolean" ? +x : x;
+}
+
+function $set(items) {
+  return new Set(items.map($key));
+}
+
 function $in(x, c) {
   if (typeof c === "string") return c.includes(x);
   if (Array.isArray(c)) return c.some((y) => $eq(x, y));
-  if (c instanceof Set || c instanceof Map) return c.has(x);
-  if ($isPlain(c)) return $hasOwn(c, x);
-  if (c !== null && typeof c === "object") return x in c;
+  if (c instanceof Set || c instanceof Map) return c.has($key(x));
+  if ($isPlain(c)) return $hasOwn(c, $key(x));
+  if (c !== null && typeof c === "object") return $key(x) in c;
   throw $b.TypeError(`argument of type '${$typename(c)}' is not iterable`);
 }
 
@@ -144,6 +155,8 @@ function $iadd(a, b) {
 }
 
 function $mul(a, b) {
+  if (typeof a === "boolean") a = +a; // Python: True*[1]==[1], False*[1]==[]
+  if (typeof b === "boolean") b = +b;
   if (typeof a === "number" && typeof b !== "number") [a, b] = [b, a];
   if (typeof a === "string") return b > 0 ? a.repeat(b) : "";
   if (Array.isArray(a)) {
@@ -165,10 +178,18 @@ function $mod(a, b) {
   return ((a % b) + b) % b;
 }
 
+// JS bitwise operators are 32-bit signed; use BigInt so ints up to the float64 range
+// stay correct (1<<40, 0xFFFFFFFF & …) instead of wrapping/going negative.
+function $bigint(x, op) {
+  if (typeof x === "boolean") return x ? 1n : 0n;
+  if (typeof x === "number" && Number.isInteger(x)) return BigInt(x);
+  throw $b.TypeError(`unsupported operand type(s) for ${op}: '${$typename(x)}'`);
+}
+
 function $bor(a, b) {
   if ($isPlain(a) && $isPlain(b)) return { ...a, ...b };
   if (a instanceof Set && b instanceof Set) return new Set([...a, ...b]);
-  return a | b;
+  return Number($bigint(a, "|") | $bigint(b, "|"));
 }
 
 function $sub(a, b) {
@@ -178,14 +199,22 @@ function $sub(a, b) {
 
 function $band(a, b) {
   if (a instanceof Set && b instanceof Set) return new Set([...a].filter((x) => b.has(x)));
-  return a & b;
+  return Number($bigint(a, "&") & $bigint(b, "&"));
 }
 
 function $bxor(a, b) {
   if (a instanceof Set && b instanceof Set) {
     return new Set([...a].filter((x) => !b.has(x)).concat([...b].filter((x) => !a.has(x))));
   }
-  return a ^ b;
+  return Number($bigint(a, "^") ^ $bigint(b, "^"));
+}
+
+function $lshift(a, b) {
+  return Number($bigint(a, "<<") << $bigint(b, "<<"));
+}
+
+function $rshift(a, b) {
+  return Number($bigint(a, ">>") >> $bigint(b, ">>"));
 }
 
 // ---- iteration, indexing, attributes ------------------------------------------
@@ -219,8 +248,9 @@ function $gi(o, k) {
       return o[i];
     }
   } else if ($isPlain(o)) {
-    if (!$hasOwn(o, k)) throw $b.KeyError($repr(k));
-    return o[k];
+    const nk = $key(k);
+    if (!$hasOwn(o, nk)) throw $b.KeyError($repr(k));
+    return o[nk];
   } else if (o instanceof Map) {
     if (!o.has(k)) throw $b.KeyError($repr(k));
     return o.get(k);
@@ -382,6 +412,7 @@ function $fmt(x, spec) {
   const p = prec === undefined ? undefined : +prec;
   let body;
   let signStr = "";
+  let prefix = "";
   if (typeof x === "number") {
     const n = Math.abs(x);
     switch (type) {
@@ -393,36 +424,55 @@ function $fmt(x, spec) {
       case "X": body = Math.trunc(n).toString(16).toUpperCase(); break;
       case "b": body = Math.trunc(n).toString(2); break;
       case "o": body = Math.trunc(n).toString(8); break;
-      case "g": case "G": body = String(p === undefined ? n : +n.toPrecision(p || 1)); break;
-      default: body = p === undefined ? String(n) : String(+n.toPrecision(p || 1));
-    }
-    if (type === "E") body = body.toUpperCase();
-    if (alt) {
-      const prefix = { x: "0x", X: "0X", o: "0o", b: "0b" }[type];
-      if (prefix) body = prefix + body;
+      case "c": body = String.fromCodePoint(Math.trunc(x)); break;
+      case "g": case "G": body = $gformat(n, p === undefined ? 6 : p || 1); break;
+      default: body = p === undefined ? String(n) : $gformat(n, p || 1);
     }
+    if (type === "E" || type === "G") body = body.toUpperCase();
+    if (alt) prefix = { x: "0x", X: "0X", o: "0o", b: "0b" }[type] || "";
     if (group) body = body.replace(/^(\d+)/, (d) => d.replace(/\B(?=(\d{3})+(?!\d))/g, group));
     if (type === "%") body += "%";
-    signStr = x < 0 ? "-" : sign === "+" ? "+" : sign === " " ? " " : "";
-    if (zero && !align) {
-      fill = "0";
-      align = "=";
+    if (type === "c") {
+      align = align || "<"; // a char is aligned like a string and carries no sign
+    } else {
+      signStr = x < 0 ? "-" : sign === "+" ? "+" : sign === " " ? " " : "";
+      if (zero && !align) {
+        fill = "0";
+        align = "=";
+      }
+      align = align || ">";
     }
-    align = align || ">";
   } else {
     body = $str(x);
     if (p !== undefined) body = body.slice(0, p);
     align = align || "<";
   }
   const w = width === undefined ? 0 : +width;
-  const pad = Math.max(0, w - body.length - signStr.length);
-  if (align === "=") return signStr + fill.repeat(pad) + body;
-  const text = signStr + body;
+  const pad = Math.max(0, w - body.length - signStr.length - prefix.length);
+  // "=" fills between the sign/prefix and the digits, so f"{255:#06x}" -> "0x00ff".
+  if (align === "=") return signStr + prefix + fill.repeat(pad) + body;
+  const text = signStr + prefix + body;
   if (align === "<") return text + fill.repeat(pad);
   if (align === "^") return fill.repeat(Math.floor(pad / 2)) + text + fill.repeat(Math.ceil(pad / 2));
   return fill.repeat(pad) + text;
 }
 
+// Python's general ("g") float format: shortest of fixed/exponential at `pr` significant
+// digits, trailing zeros stripped, exponent shown when < -4 or >= pr.
+function $gformat(n, pr) {
+  if (n === 0) return "0";
+  const exp = parseInt(n.toExponential().split("e")[1], 10);
+  if (exp < -4 || exp >= pr) {
+    let [mant, e] = n.toExponential(pr - 1).split("e");
+    if (mant.indexOf(".") >= 0) mant = mant.replace(/0+$/, "").replace(/\.$/, "");
+    const en = parseInt(e, 10);
+    return mant + "e" + (en < 0 ? "-" : "+") + String(Math.abs(en)).padStart(2, "0");
+  }
+  let s = n.toFixed(Math.max(0, pr - 1 - exp));
+  if (s.indexOf(".") >= 0) s = s.replace(/0+$/, "").replace(/\.$/, "");
+  return s;
+}
+
 function $percentFormat(template, values) {
   const positional = Array.isArray(values) ? values : [values];
   let index = 0;
@@ -513,17 +563,41 @@ function $minmax(which) {
 }
 
 function $toInt(x, base) {
-  if (typeof x === "string") {
-    const text = x.trim().replace(/_/g, "");
-    const n = parseInt(text, base || 10);
-    if (Number.isNaN(n) || !/^[-+]?[0-9a-zA-Z]+$/.test(text)) {
-      throw $b.ValueError(`invalid literal for int() with base ${base || 10}: ${$repr(x)}`);
-    }
-    return n;
-  }
   if (typeof x === "boolean") return x ? 1 : 0;
   if (x === undefined) return 0;
-  return Math.trunc(x);
+  if (typeof x === "number") return Math.trunc(x);
+  if (typeof x !== "string") {
+    throw $b.TypeError(`int() argument must be a string or a number, not '${$typename(x)}'`);
+  }
+  const b = base === undefined ? 10 : base;
+  const fail = () => {
+    throw $b.ValueError(`invalid literal for int() with base ${b}: ${$repr(x)}`);
+  };
+  let s = x.trim();
+  let sign = 1;
+  if (s[0] === "+" || s[0] === "-") {
+    if (s[0] === "-") sign = -1;
+    s = s.slice(1);
+  }
+  let radix = b;
+  const low = s.toLowerCase();
+  if (b === 0) {
+    if (low.startsWith("0x")) (radix = 16), (s = s.slice(2));
+    else if (low.startsWith("0o")) (radix = 8), (s = s.slice(2));
+    else if (low.startsWith("0b")) (radix = 2), (s = s.slice(2));
+    else radix = 10;
+  } else if (b === 16 && low.startsWith("0x")) s = s.slice(2);
+  else if (b === 8 && low.startsWith("0o")) s = s.slice(2);
+  else if (b === 2 && low.startsWith("0b")) s = s.slice(2);
+  if (radix < 2 || radix > 36) throw $b.ValueError("int() base must be >= 2 and <= 36, or 0");
+  if (/^_|_$|__/.test(s)) fail(); // underscores only as single separators between digits
+  s = s.replace(/_/g, "");
+  if (s === "") fail();
+  const digits = "0123456789abcdefghijklmnopqrstuvwxyz".slice(0, radix);
+  if (!new RegExp(`^[${digits}]+$`, "i").test(s)) fail(); // reject trailing garbage like "1a"/"42px"
+  const n = parseInt(s, radix);
+  if (Number.isNaN(n)) fail();
+  return sign * n;
 }
 
 function $round(x, n) {
@@ -567,10 +641,16 @@ Object.assign($b, {
   str: (x = "") => $str(x),
   int: $toInt,
   float(x = 0) {
-    const n = typeof x === "string" ? Number(x.trim()) : Number(x);
-    if (Number.isNaN(n) && !/^\s*nan\s*$/i.test(String(x))) {
-      throw $b.ValueError(`could not convert string to float: ${$repr(x)}`);
-    }
+    if (typeof x === "boolean") return x ? 1 : 0;
+    if (typeof x === "number") return x;
+    const s = String(x).trim();
+    const body = s.replace(/^[+-]/, "");
+    const low = body.toLowerCase();
+    if (low === "inf" || low === "infinity") return s[0] === "-" ? -Infinity : Infinity;
+    if (low === "nan") return NaN;
+    if (/^_|_$|__/.test(body)) throw $b.ValueError(`could not convert string to float: ${$repr(x)}`);
+    const n = Number(s.replace(/_/g, "")); // Python allows single "_" digit separators
+    if (Number.isNaN(n)) throw $b.ValueError(`could not convert string to float: ${$repr(x)}`);
     return n;
   },
   bool: (x) => $t(x),
@@ -625,7 +705,8 @@ Object.assign($b, {
     if (Array.isArray(T)) return T.some((t) => $b.isinstance(x, t));
     switch (T) {
       case $b.str: return typeof x === "string";
-      case $b.int: return Number.isInteger(x);
+      // bool is a subclass of int in Python (isinstance(True, int) is True).
+      case $b.int: return typeof x === "boolean" || (typeof x === "number" && Number.isInteger(x));
       case $b.float: return typeof x === "number";
       case $b.bool: return typeof x === "boolean";
       case $b.list: case $b.tuple: return Array.isArray(x);
@@ -795,19 +876,19 @@ const $LIST = {
 };
 
 const $DICT = {
-  get: (d, [k, dflt = null]) => ($hasOwn(d, k) ? d[k] : dflt),
+  get: (d, [k, dflt = null]) => ($hasOwn(d, $key(k)) ? d[$key(k)] : dflt),
   keys: (d) => Object.keys(d),
   values: (d) => Object.values(d),
   items: (d) => Object.entries(d),
   pop(d, args) {
-    const k = args[0];
+    const k = $key(args[0]);
     if ($hasOwn(d, k)) {
       const v = d[k];
       delete d[k];
       return v;
     }
     if (args.length > 1) return args[1];
-    throw $b.KeyError($repr(k));
+    throw $b.KeyError($repr(args[0]));
   },
   update(d, [o], kw) {
     if (o !== undefined && o !== null) {
@@ -817,8 +898,9 @@ const $DICT = {
     Object.assign(d, kw);
   },
   setdefault(d, [k, v = null]) {
-    if (!$hasOwn(d, k)) d[k] = v;
-    return d[k];
+    const nk = $key(k);
+    if (!$hasOwn(d, nk)) d[nk] = v;
+    return d[nk];
   },
   copy: (d) => ({ ...d }),
   clear(d) { for (const k of Object.keys(d)) delete d[k]; },

{jongo-0.2.0 → jongo-0.2.2}/jongo/compiler/transpile.py

@@ -574,13 +574,14 @@ class FunctionTranspiler:
                 return f"({left} - {right})"
             return f"$sub({left}, {right})"  # set difference when both are sets
         simple = {
-            ast.Div: "/", ast.Pow: "**", ast.LShift: "<<", ast.RShift: ">>",
+            ast.Div: "/", ast.Pow: "**",
         }
         if kind in simple:
             return f"({left} {simple[kind]} {right})"
         helpers = {
             ast.FloorDiv: "$floordiv", ast.Mod: "$mod", ast.BitOr: "$bor",
             ast.BitAnd: "$band", ast.BitXor: "$bxor",  # set intersection / symmetric difference
+            ast.LShift: "$lshift", ast.RShift: "$rshift",  # BigInt-backed, not 32-bit JS shifts
         }
         if kind in helpers:
             return f"{helpers[kind]}({left}, {right})"
@@ -646,7 +647,7 @@ class FunctionTranspiler:
     x_Tuple = x_List
 
     def x_Set(self, node):
-        return f"new Set([{self._elements(node.elts)}])"
+        return f"$set([{self._elements(node.elts)}])"  # normalises bool/int members (True == 1)
 
     def x_Dict(self, node):
         items = []
@@ -656,7 +657,7 @@ class FunctionTranspiler:
             elif isinstance(key, ast.Constant) and isinstance(key.value, str):
                 items.append(f"{js_string(key.value)}: {self.expr(value)}")
             else:
-                items.append(f"[{self.expr(key)}]: {self.expr(value)}")
+                items.append(f"[$key({self.expr(key)})]: {self.expr(value)}")  # True/False key == 1/0
         return "({" + ", ".join(items) + "})"
 
     def comprehension(self, node, kind) -> str:
@@ -679,9 +680,9 @@ class FunctionTranspiler:
                 for cond in gen.ifs:
                     code.append(f"if (!{self.test(cond)}) continue;")
             if kind == "dict":
-                code.append(f"$r[{self.expr(node.key)}] = {self.expr(node.value)};")
+                code.append(f"$r[$key({self.expr(node.key)})] = {self.expr(node.value)};")
             elif kind == "set":
-                code.append(f"$r.add({self.expr(node.elt)});")
+                code.append(f"$r.add($key({self.expr(node.elt)}));")
             else:
                 code.append(f"$r.push({self.expr(node.elt)});")
             code.append("}" * len(generators))

{jongo-0.2.0 → jongo-0.2.2}/jongo/db/connection.py

@@ -5,11 +5,14 @@ from __future__ import annotations
 import itertools
 import os
 import sqlite3
+import time
 import threading
 import weakref
 from contextlib import ContextDecorator, contextmanager
 from typing import Any, Callable, Iterator, Sequence
 
+from .. import log as _jlog
+
 MEMORY = ":memory:"
 DEFAULT_DATABASE = "db.sqlite3"
 ENV_VAR = "JONGO_DATABASE"
@@ -24,8 +27,34 @@ _memory_connection: _Connection | None = None
 _savepoint_ids = itertools.count(1)
 
 
+_WRITE = frozenset(("INSERT", "UPDATE", "DELETE", "REPLACE"))
+
+
 class _Connection(sqlite3.Connection):
-    """A sqlite3 connection that can be weakly referenced (so we can track it)."""
+    """A sqlite3 connection that can be weakly referenced (so we can track it).
+
+    Its ``execute`` is the single choke point for data-modifying statements: it
+    times and logs INSERT/UPDATE/DELETE via ``jongo.log`` — including the
+    row-level writes ``Model.save`` issues straight on the connection, which
+    would otherwise bypass the module-level ``execute``. Reads are logged in
+    ``fetch`` (which knows the row count); transaction-control and PRAGMA
+    statements are left silent. When SQL logging is off (production) this adds
+    only one ``isEnabledFor`` check per statement.
+    """
+
+    def execute(self, sql, parameters=()):  # type: ignore[override]
+        if not _jlog.sql_enabled():
+            return super().execute(sql, parameters)
+        head = sql.lstrip()[:12].split(None, 1)[0].upper() if sql.strip() else ""
+        if head not in _WRITE:
+            return super().execute(sql, parameters)  # reads -> fetch(); control -> silent
+        t0 = time.perf_counter()
+        cursor = super().execute(sql, parameters)
+        ms = (time.perf_counter() - t0) * 1000
+        rows = cursor.rowcount if cursor.rowcount is not None and cursor.rowcount >= 0 else None
+        _jlog.sql(sql, ms, rows)
+        _jlog.record_sql(ms)
+        return cursor
 
 
 def _parse_url(url: str | os.PathLike) -> str:
@@ -140,7 +169,10 @@ def locked() -> Iterator[sqlite3.Connection]:
 
 
 def execute(sql: str, params: Sequence[Any] | dict = ()) -> sqlite3.Cursor:
-    """Execute one SQL statement and return the cursor."""
+    """Execute one SQL statement and return the cursor.
+
+    Data-modifying statements are timed and logged by ``_Connection.execute``.
+    """
     with locked() as conn:
         return conn.execute(sql, params)
 
@@ -148,7 +180,14 @@ def execute(sql: str, params: Sequence[Any] | dict = ()) -> sqlite3.Cursor:
 def fetch(sql: str, params: Sequence[Any] | dict = ()) -> list[sqlite3.Row]:
     """Execute a query and return all rows (fetched while holding the lock)."""
     with locked() as conn:
-        return conn.execute(sql, params).fetchall()
+        if not _jlog.sql_enabled():
+            return conn.execute(sql, params).fetchall()
+        t0 = time.perf_counter()
+        rows = conn.execute(sql, params).fetchall()
+        ms = (time.perf_counter() - t0) * 1000
+        _jlog.sql(sql, ms, len(rows))
+        _jlog.record_sql(ms)
+        return rows
 
 
 def query(sql: str, params: Sequence[Any] | dict = ()) -> list[dict[str, Any]]:

{jongo-0.2.0 → jongo-0.2.2}/jongo/db/fields.py

@@ -356,12 +356,15 @@ class DateTime(Field):
         return super().required and not (self.auto_now or self.auto_now_add)
 
     def to_db(self, value: Any) -> Any:
-        # Normalise to UTC before storing so the ISO text sorts and range-compares
-        # chronologically (mixed offsets would otherwise sort lexicographically).
+        # Normalise aware datetimes to UTC (so mixed offsets sort/range-compare chronologically)
+        # while leaving naive datetimes naive, so each round-trips to an equal value of the same
+        # kind. (Mixing naive and aware values in one column is the only case left unsorted.)
         if isinstance(value, datetime):
-            return _to_utc(value).isoformat(timespec="microseconds")
+            if value.tzinfo is not None:
+                value = value.astimezone(timezone.utc)
+            return value.isoformat(timespec="microseconds")
         if isinstance(value, date):
-            return datetime.combine(value, time(), tzinfo=timezone.utc).isoformat(timespec="microseconds")
+            return datetime.combine(value, time()).isoformat(timespec="microseconds")
         return value
 
     def to_python(self, value: Any) -> Any:
@@ -397,7 +400,7 @@ class Date(Field):
 
     def to_db(self, value: Any) -> Any:
         if isinstance(value, datetime):
-            return value.date().isoformat()
+            return _to_utc(value).date().isoformat()  # UTC date, consistent with DateTime
         if isinstance(value, date):
             return value.isoformat()
         return value
@@ -416,14 +419,15 @@ class Date(Field):
         if value is None or _is_blank_string(value):
             return None
         if isinstance(value, datetime):
-            return value.date()
+            return _to_utc(value).date() if value.tzinfo is not None else value.date()
         if isinstance(value, date):
             return value
         if isinstance(value, str):
             text = value.strip()
             try:
                 if len(text) > 10:
-                    return _parse_datetime_string(text).date()
+                    parsed = _parse_datetime_string(text)
+                    return (_to_utc(parsed).date() if parsed.tzinfo is not None else parsed.date())
                 return date.fromisoformat(text)
             except ValueError:
                 pass