sqlobjects 1.7.0__tar.gz → 1.9.0__tar.gz

{sqlobjects-1.7.0 → sqlobjects-1.9.0}/CHANGELOG.md

@@ -1,3 +1,38 @@
+## 1.9.0 (2026-03-27)
+
+### Feat
+
+- **logging**: wire ObjectLogger into QueryExecutor, zero-config caller rewriting
+- **logging**: replace SQLCallerFilter with ObjectLogger, remove SQLCallerFilter
+- **logging**: add ObjectLogger and _install_object_logger
+
+### Fix
+
+- **logging**: skip stdlib logging frames in _should_skip_frame, add end-to-end test
+- **logging**: use logging._lock context manager for Python 3.13 compatibility
+- **logging**: add _should_skip_frame tests and fix assertion quality
+
+### Refactor
+
+- **logging**: extract _should_skip_frame and add _find_user_frame
+
+## 1.8.0 (2026-03-26)
+
+### Feat
+
+- **logging**: export SQLCallerFilter and get_caller_frame in public API
+- **logging**: emit SQL log records in QueryExecutor
+- **logging**: add SQLCallerFilter
+- **logging**: add get_caller_frame() helper
+
+### Fix
+
+- **logging**: eliminate isEnabledFor race and fix test name
+- **logging**: restore logger level in test_no_log_when_logger_disabled
+- **logging**: guard timing code with isEnabledFor check
+- **logging**: simplify SQLCallerFilter extra_skip_packages handling
+- **logging**: fix frame-skip edge cases and improve code quality
+
 ## 1.7.0 (2026-03-26)
 
 ### Feat

{sqlobjects-1.7.0/sqlobjects.egg-info → sqlobjects-1.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlobjects
-Version: 1.7.0
+Version: 1.9.0
 Summary: Django-style async ORM library based on SQLAlchemy with chainable queries, Q objects, and relationship loading
 Author-email: XtraVisions <gitadmin@xtravisions.com>, Chen Hao <chenhao@xtravisions.com>
 Maintainer-email: XtraVisions <gitadmin@xtravisions.com>, Chen Hao <chenhao@xtravisions.com>

{sqlobjects-1.7.0 → sqlobjects-1.9.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sqlobjects"
-version = "1.7.0"
+version = "1.9.0"
 description = "Django-style async ORM library based on SQLAlchemy with chainable queries, Q objects, and relationship loading"
 readme = "README.md"
 license = "MIT"

{sqlobjects-1.7.0 → sqlobjects-1.9.0}/sqlobjects/__init__.py

@@ -16,6 +16,7 @@ from .objects import (
     TransactionMode,
 )
 from .queryset import Q, QuerySet
+from .sql_logging import ObjectLogger, get_caller_frame
 
 
 __version__ = "0.3.0"
@@ -41,4 +42,7 @@ __all__ = [
     "TransactionMode",
     "ErrorHandling",
     "ConflictResolution",
+    # SQL logging
+    "ObjectLogger",
+    "get_caller_frame",
 ]

{sqlobjects-1.7.0 → sqlobjects-1.9.0}/sqlobjects/queries/executor.py

@@ -1,5 +1,7 @@
 import asyncio
 import gc
+import logging
+import time
 from collections.abc import AsyncGenerator
 from typing import Any, TypeVar, overload
 
@@ -12,6 +14,8 @@ from sqlalchemy import (
     update,
 )
 
+from ..sql_logging import _sql_logger
+
 
 _T = TypeVar("_T")
 
@@ -230,8 +234,33 @@ class QueryExecutor:
             else:  # exists
                 return False
 
+        # Compile SQL for logging only when the logger is active (avoids overhead)
+        _logging_active = _sql_logger.isEnabledFor(logging.DEBUG)
+        sql_str = ""
+        params: dict = {}
+        t0 = 0.0
+        if _logging_active:
+            try:
+                compiled = query.compile(
+                    dialect=session.bind.dialect,
+                    compile_kwargs={"literal_binds": False},
+                )
+                sql_str = str(compiled)
+                params = dict(compiled.params) if compiled.params else {}
+            except Exception:
+                sql_str = str(query)
+                params = {}
+            t0 = time.perf_counter()
+
         result = await session.execute(query)
 
+        if _logging_active:
+            duration_ms = (time.perf_counter() - t0) * 1000
+            _sql_logger.debug(
+                sql_str,
+                extra={"sql": sql_str, "params": params, "duration_ms": duration_ms},
+            )
+
         if query_type == "all":
             rows = result.fetchall()
             if model_class:

sqlobjects-1.9.0/sqlobjects/sql_logging.py

@@ -0,0 +1,200 @@
+"""SQL logging utilities for sqlobjects.
+
+Provides ObjectLogger (a logging.Logger subclass that auto-rewrites caller
+fields to user-code location) and get_caller_frame() for custom scenarios.
+
+Frame-skip strategy:
+- Skips frames from site-packages (covers pip-installed sqlobjects/sqlalchemy)
+- Skips frames whose module name starts with "sqlobjects." or "sqlalchemy."
+  (covers editable installs via `pip install -e .`)
+- Skips frames from extra_skip_packages specified by the caller
+"""
+
+from __future__ import annotations
+
+import inspect
+import logging
+import os
+from collections.abc import Mapping
+from typing import Any
+
+
+__all__ = ["get_caller_frame", "ObjectLogger"]
+
+# Exact module names that are always considered internal
+_INTERNAL_MODULES = {"sqlobjects", "sqlalchemy", "logging"}
+
+# Module name prefixes that are always considered internal
+_INTERNAL_PREFIXES = ("sqlobjects.", "sqlalchemy.")
+
+# Absolute path of this file, used to skip itself reliably
+_THIS_FILE = os.path.abspath(__file__)
+
+
+def _should_skip_frame(
+    filepath: str,
+    module: str,
+    extra_skip_prefixes: tuple[str, ...],
+) -> bool:
+    """Return True if this frame should be skipped (library/internal frame).
+
+    Args:
+        filepath: frame_info.filename
+        module: frame.f_globals.get("__name__", "")
+        extra_skip_prefixes: tuple of module name prefixes to skip in addition
+            to the built-in sqlobjects/sqlalchemy prefixes.
+    """
+    if "site-packages" in filepath:
+        return True
+    if filepath.startswith("<"):
+        return True
+    if module in _INTERNAL_MODULES or module.startswith(_INTERNAL_PREFIXES):
+        return True
+    if filepath == _THIS_FILE or os.path.abspath(filepath) == _THIS_FILE:
+        return True
+    if extra_skip_prefixes and module.startswith(extra_skip_prefixes):
+        return True
+    return False
+
+
+def _find_user_frame(
+    extra_skip_packages: list[str] | None = None,
+) -> inspect.FrameInfo | None:
+    """Return the first user-code FrameInfo, skipping library frames.
+
+    Applies the same skip rules as get_caller_frame() but returns the raw
+    FrameInfo instead of a formatted string. Returns None if no frame found.
+    """
+    extra_skip_prefixes: tuple[str, ...] = tuple(extra_skip_packages) if extra_skip_packages else ()
+    for frame_info in inspect.stack():
+        module = frame_info.frame.f_globals.get("__name__", "")
+        if not _should_skip_frame(frame_info.filename, module, extra_skip_prefixes):
+            return frame_info
+    return None
+
+
+def get_caller_frame(
+    extra_skip_packages: list[str] | None = None,
+    max_frames: int = 1,
+) -> str | list[str]:
+    """Inspect the call stack and return the first user-code frame(s).
+
+    Skips frames from:
+    - site-packages (pip install)
+    - sqlobjects.* and sqlalchemy.* modules (editable install)
+    - extra_skip_packages prefixes provided by the caller
+
+    Args:
+        extra_skip_packages: Additional module name prefixes to skip
+            (e.g. ["myapp.middleware"]). Matched against frame's __name__.
+        max_frames: How many user-code frames to return.
+            1 returns a str; >1 returns a list[str].
+
+    Returns:
+        Frame string "path/to/file.py:lineno in funcname", or a list of such
+        strings when max_frames > 1.
+    """
+    extra_skip_prefixes: tuple[str, ...] = tuple(extra_skip_packages) if extra_skip_packages else ()
+    frames: list[str] = []
+
+    for frame_info in inspect.stack():
+        module = frame_info.frame.f_globals.get("__name__", "")
+        if _should_skip_frame(frame_info.filename, module, extra_skip_prefixes):
+            continue
+        rel_path = _relative_path(frame_info.filename)
+        frames.append(f"{rel_path}:{frame_info.lineno} in {frame_info.function}")
+        if len(frames) >= max_frames:
+            break
+
+    if not frames:
+        return "<unknown>" if max_frames == 1 else ["<unknown>"]
+    return frames[0] if max_frames == 1 else frames
+
+
+def _relative_path(filepath: str) -> str:
+    """Return path relative to cwd, or absolute if outside cwd."""
+    try:
+        return os.path.relpath(filepath)
+    except ValueError:
+        return filepath
+
+
+class ObjectLogger(logging.Logger):
+    """logging.Logger subclass that rewrites LogRecord caller fields to user-code location.
+
+    Overrides makeRecord() to replace the standard caller fields
+    (filename, funcName, lineno, pathname) with the first user-code frame
+    found by _find_user_frame(). This means any handler attached to this logger
+    — including loguru InterceptHandlers — will display the real call site
+    without any additional Filter configuration.
+
+    Args:
+        name: Logger name (passed to logging.Logger).
+        level: Initial log level (default NOTSET).
+        extra_skip_packages: Additional module name prefixes to skip when
+            searching for the user-code frame (e.g. ["myapp.middleware"]).
+    """
+
+    def __init__(
+        self,
+        name: str,
+        level: int = logging.NOTSET,
+        extra_skip_packages: list[str] | None = None,
+    ) -> None:
+        super().__init__(name, level)
+        self.extra_skip_packages = extra_skip_packages
+
+    def makeRecord(  # noqa: N802
+        self,
+        name: str,
+        level: int,
+        fn: str,
+        lno: int,
+        msg: object,
+        args: Any,
+        exc_info: Any,
+        func: str | None = None,
+        extra: Mapping[str, object] | None = None,
+        sinfo: str | None = None,
+    ) -> logging.LogRecord:
+        record = super().makeRecord(name, level, fn, lno, msg, args, exc_info, func, extra, sinfo)
+        frame_info = _find_user_frame(self.extra_skip_packages)
+        if frame_info:
+            record.pathname = os.path.abspath(frame_info.filename)
+            record.filename = os.path.basename(frame_info.filename)
+            record.module = os.path.splitext(record.filename)[0]
+            record.funcName = frame_info.function
+            record.lineno = frame_info.lineno
+        return record
+
+
+def _install_object_logger(name: str) -> ObjectLogger:
+    """Create an ObjectLogger and register it in the logging system.
+
+    Directly writes into logging.root.manager.loggerDict so that
+    logging.getLogger(name) returns this ObjectLogger instance.
+    Migrates handlers, level, and propagate from any pre-existing Logger
+    (but not from PlaceHolder sentinels, which are logging internals).
+
+    Thread-safe: acquires the logging module lock during the operation.
+
+    Known limitation: code that obtained a reference via getLogger(name)
+    *before* this function runs will still hold the old Logger instance.
+    """
+    with logging._lock:  # type: ignore[attr-defined]  # noqa: SLF001
+        existing = logging.root.manager.loggerDict.get(name)
+        logger = ObjectLogger(name)
+        logger.parent = logging.root
+        logger.propagate = True
+        if isinstance(existing, logging.Logger):
+            for handler in existing.handlers:
+                logger.addHandler(handler)
+            if existing.level != logging.NOTSET:
+                logger.setLevel(existing.level)
+            logger.propagate = existing.propagate
+        logging.root.manager.loggerDict[name] = logger
+    return logger
+
+
+# Module-level instance — imported by executor.py and usable by callers
+_sql_logger: ObjectLogger = _install_object_logger("sqlobjects.sql")

{sqlobjects-1.7.0 → sqlobjects-1.9.0/sqlobjects.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlobjects
-Version: 1.7.0
+Version: 1.9.0
 Summary: Django-style async ORM library based on SQLAlchemy with chainable queries, Q objects, and relationship loading
 Author-email: XtraVisions <gitadmin@xtravisions.com>, Chen Hao <chenhao@xtravisions.com>
 Maintainer-email: XtraVisions <gitadmin@xtravisions.com>, Chen Hao <chenhao@xtravisions.com>

{sqlobjects-1.7.0 → sqlobjects-1.9.0}/sqlobjects.egg-info/SOURCES.txt

@@ -20,6 +20,7 @@ sqlobjects/model.py
 sqlobjects/queryset.py
 sqlobjects/session.py
 sqlobjects/signals.py
+sqlobjects/sql_logging.py
 sqlobjects/validators.py
 sqlobjects.egg-info/PKG-INFO
 sqlobjects.egg-info/SOURCES.txt