turbo-lambda 0.7.1__tar.gz → 0.9.0__tar.gz

{turbo_lambda-0.7.1 → turbo_lambda-0.9.0}/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.3
 Name: turbo-lambda
-Version: 0.7.1
+Version: 0.9.0
 Summary: Turbo Lambda Description
 Author: Sam Mosleh
 Author-email: Sam Mosleh <sam.mosleh.d@gmail.com>
 Requires-Dist: opentelemetry-api>=1.27.0
 Requires-Dist: pydantic-settings>=2.11.0
-Requires-Python: >=3.12
+Requires-Dist: psycopg[binary]>=3.3.4
+Requires-Python: >=3.14
 Description-Content-Type: text/markdown
 
 # turbo-lambda

{turbo_lambda-0.7.1 → turbo_lambda-0.9.0}/pyproject.toml

@@ -1,13 +1,14 @@
 [project]
 name = "turbo-lambda"
-version = "0.7.1"
+version = "0.9.0"
 description = "Turbo Lambda Description"
 readme = "README.md"
 authors = [{ name = "Sam Mosleh", email = "sam.mosleh.d@gmail.com" }]
-requires-python = ">=3.12"
+requires-python = ">=3.14"
 dependencies = [
     "opentelemetry-api>=1.27.0",
     "pydantic-settings>=2.11.0",
+    "psycopg[binary]>=3.3.4",
 ]
 
 [dependency-groups]
@@ -22,7 +23,7 @@ dev = [
 update-turbo-lambda-layer = "turbo_lambda.scripts.update_turbo_lambda_layer:main"
 
 [build-system]
-requires = ["uv_build>=0.9.2,<0.10.0"]
+requires = ["uv_build>=0.10.2,<0.11.0"]
 build-backend = "uv_build"
 
 [tool.mypy]
@@ -39,18 +40,20 @@ filterwarnings = ["error"]
 [tool.coverage.run]
 branch = true
 parallel = true
-relative_files = true
 source = ["src", "tests"]
 
 [tool.coverage.report]
 show_missing = true
-# skip_covered = true
 partial_branches = [
     "# pragma: no cover\\b",
     "# pragma: (nt|posix|cygwin|darwin|linux|msys|win32|cpython|pypy) (no )?cover\\b",
     "# pragma: (>=?|<=?|==|!=)\\d+\\.\\d+ cover\\b",
 ]
-exclude_also = ['case _:\n\s*assert_never\(.*\)', 'if __name__ == .__main__.:']
+exclude_also = [
+    'case _:\n\s*assert_never\(.*\)',
+    'if __name__ == .__main__.:',
+    'raise$',
+]
 
 [tool.ruff.lint]
 select = [
@@ -59,11 +62,16 @@ select = [
     "F",   # pyflakes
     "PL",  # pylint
     "I",   # isort
-    "C",   # flake8-comprehensions
+    "C4",  # flake8-comprehensions
     "B",   # flake8-bugbear
     "Q",   # flake8-quotes
     "T20", # flake8-print
     "S",   # flake8-bandit
+    "PIE", # flake8-pie
+    "RET", # flake8-return
+    "SIM", # flake8-simplify
+    "TC",  # flake8-type-checking
+    "C90", # mccabe
     "N",   # pep8-naming
     "UP",  # pyupgrade
     "RUF", # ruff
@@ -72,6 +80,9 @@ ignore = [
     "E501", # line too long, handled by formatter
 ]
 
+[tool.ruff.lint.flake8-type-checking]
+runtime-evaluated-base-classes = ["pydantic.BaseModel"]
+
 [tool.ruff.lint.per-file-ignores]
 "tests/*" = ["S101", "S311"]
 

turbo_lambda-0.9.0/src/turbo_lambda/constants.py

@@ -0,0 +1 @@
+MAX_DYNAMODB_BATCH_WRITE_ITEM = 25

{turbo_lambda-0.7.1 → turbo_lambda-0.9.0}/src/turbo_lambda/decorators.py

@@ -1,12 +1,10 @@
 import inspect
 import logging
-from collections.abc import Callable
 from concurrent.futures import ThreadPoolExecutor
 from contextlib import AbstractContextManager, ContextDecorator
 from contextlib import suppress as contextlib_suppress
 from functools import wraps
-from types import TracebackType
-from typing import Any, Protocol, overload
+from typing import TYPE_CHECKING, Any, Protocol, overload
 
 import pydantic
 from opentelemetry.trace import format_span_id, format_trace_id, get_current_span
@@ -18,6 +16,10 @@ from turbo_lambda.errors import (
 )
 from turbo_lambda.log import log_after_call, logger, logger_bind
 
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from types import TracebackType
+
 
 class LambdaHandlerT[ResponseT](Protocol):
     def __call__(

{turbo_lambda-0.7.1 → turbo_lambda-0.9.0}/src/turbo_lambda/errors.py

@@ -1,10 +1,11 @@
 from http import HTTPStatus
-from typing import Any
-
-import pydantic
+from typing import TYPE_CHECKING, Any
 
 from turbo_lambda import schemas
 
+if TYPE_CHECKING:
+    import pydantic
+
 
 class ApplicationError(Exception):
     pass

{turbo_lambda-0.7.1 → turbo_lambda-0.9.0}/src/turbo_lambda/log.py

@@ -1,3 +1,5 @@
+import annotationlib
+import base64
 import contextlib
 import contextvars
 import datetime
@@ -5,15 +7,16 @@ import inspect
 import logging
 import time
 import uuid
-from collections.abc import Callable, Generator, Iterable
 from enum import Enum
 from functools import wraps
-from typing import Any, overload
+from typing import TYPE_CHECKING, Any, overload
 
 import pydantic
 
 from turbo_lambda.schemas import IS_LAMBDA
 
+if TYPE_CHECKING:
+    from collections.abc import Callable, Generator, Iterable
 LOGGING_CTX: contextvars.ContextVar[dict[str, Any]] = contextvars.ContextVar(
     "LOGGING_CTX"
 )
@@ -44,6 +47,8 @@ def _json_custom_default(value: Any) -> Any:
             return str(value)
         case set():
             return list(value)
+        case bytes():
+            return base64.b64encode(value).decode()
         case _:
             raise TypeError(value.__class__.__name__)
 
@@ -57,6 +62,10 @@ def _setup_logger() -> None:  # pragma: no cover
         lambda_runtime_log_utils._json_encoder.default = _json_custom_default
 
 
+def _default_result_extractor[T](res: T) -> dict[str, T]:
+    return {"result": res}
+
+
 @overload
 def log_after_call[**P, T](func: Callable[P, T]) -> Callable[P, T]: ...
 
@@ -68,7 +77,7 @@ def log_after_call[**P, T](
     log_message: str = "call",
     log_exceptions: bool = False,
     excluded_fields: Iterable[str] = ("self",),
-    result_extractor: None = None,
+    result_extractor: bool = False,
 ) -> Callable[[Callable[P, T]], Callable[P, T]]: ...
 
 
@@ -89,10 +98,17 @@ def log_after_call[**P, T](  # noqa: PLR0913
     log_message: str = "call",
     log_exceptions: bool = False,
     excluded_fields: Iterable[str] = ("self",),
-    result_extractor: Callable[[T], dict[str, Any]] | None = None,
+    result_extractor: Callable[[T], dict[str, Any]] | bool = False,
 ) -> Callable[P, T] | Callable[[Callable[P, T]], Callable[P, T]]:
     def decorator(func: Callable[P, T]) -> Callable[P, T]:
-        sig = inspect.signature(func)
+        sig = inspect.signature(func, annotation_format=annotationlib.Format.STRING)
+        result_extractor_func = (
+            result_extractor
+            if callable(result_extractor)
+            else _default_result_extractor
+            if result_extractor
+            else None
+        )
 
         @wraps(func)
         def wrapper(*f_args: P.args, **f_kwargs: P.kwargs) -> T:
@@ -110,8 +126,8 @@ def log_after_call[**P, T](  # noqa: PLR0913
             st = time.monotonic()
             try:
                 result = func(*f_args, **f_kwargs)
-                if result_extractor:
-                    extra.update(result_extractor(result))
+                if result_extractor_func:
+                    extra.update(result_extractor_func(result))
                 return result
             except Exception as e:
                 if log_exceptions:

turbo_lambda-0.9.0/src/turbo_lambda/psycopg.py

@@ -0,0 +1,107 @@
+from typing import TYPE_CHECKING, Any
+
+import psycopg
+from psycopg import pq, sql
+from psycopg.raw_cursor import RawCursorMixin
+from psycopg.rows import Row
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+    from typing import Self
+
+    from psycopg.abc import Params, Query
+
+
+class UnoptimizedQueryError(Exception):
+    """Raised when a statement is planned using a sequential scan.
+
+    The detection is invisible to the interactor: every statement is planned
+    with ``EXPLAIN (FORMAT JSON)`` under the hood, so callers cannot tell that
+    the plan was inspected.
+    """
+
+    def __init__(self, query: str, plan: dict[str, Any]) -> None:
+        self.query = query
+        self.plan = plan
+        super().__init__(f"Unoptimized query uses a sequential scan: {query!r}")
+
+
+_EXPLAINABLE_COMMAND_TAGS = frozenset({"SELECT", "INSERT", "UPDATE", "DELETE"})
+
+
+def _plan_uses_seq_scan(node: dict[str, Any]) -> bool:
+    if "Seq Scan" in str(node.get("Node Type", "")):
+        return True
+    return any(_plan_uses_seq_scan(child) for child in node.get("Plans", []))
+
+
+def _reject_seq_scan(query: str, payload: list[dict[str, Any]]) -> None:
+    root_plan = payload[0]["Plan"]
+    if _plan_uses_seq_scan(root_plan):
+        raise UnoptimizedQueryError(query, root_plan)
+
+
+class SeqScanDetectingCursor(psycopg.Cursor[Row]):
+    """Raw cursor that rejects any statement planned with a sequential scan.
+
+    After running each explainable statement it transparently re-plans it with
+    ``EXPLAIN (FORMAT JSON)`` under ``SET LOCAL enable_seqscan = off``. A
+    sequential scan in that plan means no index can serve the query, even when
+    the session allows the planner to prefer sequential scans for optimization.
+    """
+
+    def execute(
+        self,
+        query: Query,
+        params: Params | None = None,
+        *,
+        prepare: bool | None = None,
+        binary: bool | None = None,
+    ) -> Self:
+        result = super().execute(
+            query,  # type: ignore
+            params,
+            prepare=prepare,
+            binary=binary,
+        )
+        if self._status_command() in _EXPLAINABLE_COMMAND_TAGS:
+            self._explain_no_seq_scan(query, params)
+        return result
+
+    def executemany(
+        self,
+        query: Query,
+        params_seq: Iterable[Params],
+        *,
+        returning: bool = False,
+    ) -> None:
+        params_list = list(params_seq)
+        super().executemany(query, params_list, returning=returning)
+        if self._status_command() in _EXPLAINABLE_COMMAND_TAGS:
+            for params in params_list:
+                self._explain_no_seq_scan(query, params)
+
+    def _status_command(self) -> str | None:
+        if self.connection.info.pipeline_status != pq.PipelineStatus.OFF:
+            self.connection._pipeline.sync()  # type: ignore[union-attr]
+        return self.statusmessage.split(maxsplit=1)[0] if self.statusmessage else None
+
+    def _explain_no_seq_scan(self, query: Query, params: Params | None) -> None:
+        explain_query = sql.SQL("EXPLAIN (FORMAT JSON) {}").format(
+            sql.SQL(query) if isinstance(query, str) else query
+        )
+        with psycopg.RawCursor(self.connection) as plan_cursor:
+            plan_cursor.execute(explain_query, params)
+            row = next(plan_cursor)
+        query_label = (
+            query
+            if isinstance(query, str)
+            else explain_query.as_string(self.connection)
+        )
+        _reject_seq_scan(query_label, row["QUERY PLAN"])
+
+
+class SeqScanDetectingRawCursor(
+    RawCursorMixin[psycopg.Connection[Any], Row], SeqScanDetectingCursor[Row]
+):
+    __module__ = "psycopg"

{turbo_lambda-0.7.1 → turbo_lambda-0.9.0}/src/turbo_lambda/scripts/update_turbo_lambda_layer.py

@@ -1,9 +1,12 @@
 import argparse
 import re
-from collections.abc import Sequence
+from typing import TYPE_CHECKING
 
 from turbo_lambda.version import __version__
 
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
 
 def main(version: str = __version__, argv: Sequence[str] | None = None) -> int:
     parser = argparse.ArgumentParser(