querysource 4.5.10__tar.gz → 4.5.12__tar.gz

{querysource-4.5.10 → querysource-4.5.12}/Makefile

@@ -10,12 +10,11 @@ PYTHON_VERSION := 3.11
 HAS_UV := $(shell command -v uv 2> /dev/null)
 HAS_PIP := $(shell command -v pip 2> /dev/null)
 
-# Run maturin via `uv run` so it resolves the project venv (.venv) regardless of
-# whether the venv is activated or on PATH. `--with maturin` ensures the tool is
-# available ephemerally, so no separate `uv pip install maturin` step is needed.
-# (Each Makefile recipe line runs in its own subshell, so installing maturin in
-# one line does not put it on PATH for the next.)
-MATURIN := uv run --with maturin maturin
+# maturin is a dev dependency (pyproject.toml), so it lives in .venv/bin/.
+# Run it via the venv Python so it always targets the project virtualenv.
+# NOTE: `uv run --with maturin` must NOT be used — it creates an ephemeral
+# environment and maturin installs the extension there instead of .venv.
+MATURIN := .venv/bin/maturin
 
 # Install uv for faster workflows
 install-uv:

{querysource-4.5.10 → querysource-4.5.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: querysource
-Version: 4.5.10
+Version: 4.5.12
 Summary: Aiohttp web service for querying several databases easily
 Author-email: Jesus Lara <jesuslarag@gmail.com>
 License: BSD-3-Clause
@@ -123,6 +123,7 @@ Requires-Dist: pytest-asyncio==1.3.0; extra == "dev"
 Requires-Dist: pytest-xdist==3.3.1; extra == "dev"
 Requires-Dist: pytest-assume==2.4.3; extra == "dev"
 Requires-Dist: ruff>=0.6.0; extra == "dev"
+Requires-Dist: maturin<2.0,>=1.7; extra == "dev"
 Dynamic: license-file
 
 # QuerySource #

{querysource-4.5.10 → querysource-4.5.12}/pyproject.toml

@@ -165,7 +165,8 @@ dev = [
     "pytest-asyncio==1.3.0",
     "pytest-xdist==3.3.1",
     "pytest-assume==2.4.3",
-    "ruff>=0.6.0"
+    "ruff>=0.6.0",
+    "maturin>=1.7,<2.0"
 ]
 
 [project.scripts]

{querysource-4.5.10 → querysource-4.5.12}/querysource/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '4.5.11.dev0+g8016640fc.d20260723'
-__version_tuple__ = version_tuple = (4, 5, 11, 'dev0', 'g8016640fc.d20260723')
+__version__ = version = '4.5.13.dev0+gc681e50a6.d20260825'
+__version_tuple__ = version_tuple = (4, 5, 13, 'dev0', 'gc681e50a6.d20260825')
 
-__commit_id__ = commit_id = 'g8016640fc'
+__commit_id__ = commit_id = 'gc681e50a6'

{querysource-4.5.10 → querysource-4.5.12}/querysource/exceptions.py

@@ -72,4 +72,24 @@ class ParserError(QueryException):
 
 
 class OutputError(QueryException):
-    pass
+    """Raised when a MultiQuery Output/destination fails.
+
+    Optionally carries the failing destination ``step_name`` and an error
+    ``category`` (``"data"`` | ``"infra"``) so the HTTP handler layer can
+    pick an appropriate status code (422 vs 500). Both are backwards
+    compatible: existing ``OutputError(message)`` call sites keep working
+    unchanged.
+    """
+
+    def __init__(
+        self,
+        message: str = "",
+        code: int = 0,
+        *,
+        step_name: str = None,
+        category: str = None,
+        **kwargs,
+    ):
+        super().__init__(message, code=code, **kwargs)
+        self.step_name = step_name
+        self.category = category

{querysource-4.5.10 → querysource-4.5.12}/querysource/handlers/abstract.py

@@ -154,7 +154,7 @@ class AbstractHandler(BaseHandler):
         # Map HTTP status code to a formatter category
         if code == 404:
             category = "not_found"
-        elif code in (400, 401, 402, 403, 406, 412, 428):
+        elif code in (400, 401, 402, 403, 406, 412, 422, 428):
             category = "query_error"
         else:
             category = "server_error"
@@ -190,6 +190,8 @@ class AbstractHandler(BaseHandler):
             obj = web.HTTPPreconditionFailed(**args)
         elif code == 428:
             obj = web.HTTPPreconditionRequired(**args)
+        elif code == 422:  # Unprocessable Entity (e.g. data/validation errors)
+            obj = web.HTTPUnprocessableEntity(**args)
         else:
             obj = web.HTTPBadRequest(**args)
         return obj
@@ -238,7 +240,12 @@ class AbstractHandler(BaseHandler):
         }
         # Only expose the raw exception string in the X-ERROR header when debug
         if self.debug and exception is not None:
-            response_headers["X-ERROR"] = str(exception)
+            # HTTP header values may not contain embedded CR/LF (aiohttp
+            # raises on write) — FEAT-146 routes multi-line OutputError text
+            # through this path via Except(code=500), so collapse to a
+            # single line here too (same treatment as payload["error"] in
+            # build_error_payload and the X-Output-Errors header).
+            response_headers["X-ERROR"] = " ".join(str(exception).splitlines())
 
         args = {
             "reason": payload["error"],

{querysource-4.5.10 → querysource-4.5.12}/querysource/handlers/multi.py

@@ -9,10 +9,10 @@ from ..exceptions import (
     DriverError,
     QueryException,
     SlugNotFound,
+    OutputError,
 )
 from .abstract import AbstractHandler
 from ..queries import MultiQS
-from ..outputs.destinations import get_destination
 from ..queries.multi.operators import Filter, GroupBy
 from ..conf import (
     CSV_DEFAULT_DELIMITER,
@@ -264,6 +264,50 @@ class QueryHandler(AbstractHandler):
                 exception=pe,
                 code=401
             )
+        except OutputError as oe:
+            # FEAT-146: MultiQS is the single authoritative Output executor;
+            # a raised OutputError means a destination failed. Map its
+            # category to a differentiated HTTP status: data -> 422 (via
+            # self.Error, a client/query_error category) and infra/unknown
+            # -> 500 (via self.Except, the existing server-error responder —
+            # self.Error() has no code=500 branch and would otherwise fall
+            # through to 400). Both routes call build_error_payload, which
+            # exposes the real OutputError detail in the body regardless of
+            # `debug` (TASK-712). Placed BEFORE the broader
+            # (QueryException, DriverError) branch since OutputError is
+            # itself a QueryException subclass.
+            trace = traceback.format_exc()
+            self.logger.exception(oe, stack_info=True)
+            # step_name is attacker-influenced (it's the Output step's dict
+            # key straight from the request body — e.g. an unregistered
+            # destination name echoed back by get_destination()'s error), so
+            # it must be sanitized the same way header_detail is below.
+            step = " ".join(
+                str(getattr(oe, "step_name", None) or "Output").splitlines()
+            )
+            if getattr(oe, "category", None) == "data":
+                err = self.Error(
+                    message=str(oe),
+                    exception=oe,
+                    stacktrace=trace,
+                    code=422,
+                )
+            else:
+                err = self.Except(
+                    message=str(oe),
+                    exception=oe,
+                    stacktrace=trace,
+                    code=500,
+                )
+            # X-Output-Errors retained as supplementary detail (not the only
+            # signal anymore — the status code + body now carry the failure).
+            # HTTP header values may not contain embedded CR/LF (aiohttp
+            # raises on write) — destination messages (e.g. TableOutput's
+            # multi-line "Unconsumed column names" text) are collapsed to a
+            # single line here; the full detail is still in the body.
+            header_detail = " ".join(str(oe).splitlines())
+            err.headers['X-Output-Errors'] = f"{step}: {header_detail}"
+            raise err
         except (QueryException, DriverError) as qe:
             trace = traceback.format_exc()
             _remote_queries_on_err = getattr(qs, '_remote_queries', [])
@@ -365,23 +409,11 @@ class QueryHandler(AbstractHandler):
                     'X-Total-Time': f'{total_time:.2f} seconds',
                 }
             )
-        output_errors: list[str] = []
-        if isinstance(data, dict):
-            if 'Output' in options:
-                ## Optionally saving result to destination (registry-based dispatch)
-                for step in options['Output']:
-                    for step_name, component in step.items():
-                        try:
-                            destination_cls = get_destination(step_name)
-                            obj = destination_cls(data=result, **component)
-                            result = await obj.run()
-                        except Exception as dest_err:
-                            self.logger.error(
-                                "QueryHandler: output destination '%s' failed: %s",
-                                step_name,
-                                dest_err,
-                            )
-                            output_errors.append(f"{step_name}: {dest_err}")
+        # FEAT-146: Output is now executed exactly once, solely by
+        # MultiQS.query() above (single authoritative Output executor). A
+        # failed destination raises OutputError there and is mapped to a
+        # 422/500 response in the `except OutputError` branch — there is no
+        # longer a duplicate Output loop here.
         ### Step 6: passing Result to DataOutput
         try:
             if result is None or isinstance(result, DataFrame) and result.empty:
@@ -412,8 +444,6 @@ class QueryHandler(AbstractHandler):
             remote_queries = getattr(qs, '_remote_queries', [])
             if remote_queries:
                 response.headers['X-Remote-Queries'] = ','.join(remote_queries)
-            if output_errors:
-                response.headers['X-Output-Errors'] = ' | '.join(output_errors)
             return response
         except (DataNotFound) as ex:
             return self.NoData(

{querysource-4.5.10 → querysource-4.5.12}/querysource/queries/multi/__init__.py

@@ -7,7 +7,8 @@ from ...exceptions import (
     QueryException,
     DriverError,
     DataNotFound,
-    ParserError
+    ParserError,
+    OutputError
 )
 from importlib import import_module
 from ..base import BaseQuery
@@ -21,6 +22,36 @@ from .sources.executors import RemoteConfig
 from ...conf import QWORKER_HOST, QWORKER_PORT, QWORKER_TIMEOUT, QWORKER_WORKERS
 
 
+# Best-effort data-vs-infra classification for MultiQuery Output/destination
+# failures (FEAT-146). Deliberately small and centralized so it can be
+# refined later (spec §8: precise classifier is an open question). Matches
+# on the underlying (chained) exception's class name rather than importing
+# a specific driver's exception module, so this stays dependency-light and
+# works across destinations. Defaults to ``None`` (-> HTTP 500 downstream)
+# when unrecognized, to avoid masking infrastructure issues as client errors.
+_DATA_ERROR_TYPES = frozenset({"IntegrityError", "DataError", "ProgrammingError"})
+_INFRA_ERROR_TYPES = frozenset({
+    "OperationalError", "InterfaceError", "TimeoutError", "ConnectionError"
+})
+
+
+def classify_output_error(exc: BaseException) -> Optional[str]:
+    """Classify a destination failure as ``"data"`` or ``"infra"``.
+
+    Inspects the chained cause (``exc.__cause__``) when present, since
+    destinations typically wrap the real driver exception via
+    ``raise OutputError(...) from err``. Returns ``None`` when the
+    exception type is not recognized.
+    """
+    cause = exc.__cause__ if exc.__cause__ is not None else exc
+    type_name = type(cause).__name__
+    if type_name in _DATA_ERROR_TYPES:
+        return "data"
+    if type_name in _INFRA_ERROR_TYPES:
+        return "infra"
+    return None
+
+
 def get_operator_module(clsname: str):
     """
     Get an Operator Module
@@ -185,7 +216,15 @@ class MultiQS(BaseQuery):
                 self._options = slug_data
                 self._queries = slug_data.pop('queries', {})
                 self._files = slug_data.pop('files', {})
-                self._sources = slug_data.pop('sources', [])
+                # Normalize sources exactly like the inline (__init__) path does
+                # (see line ~98). Without this, a slug whose `sources` is the
+                # dict convenience form ({"alias": {"type": ...}}) is left as a
+                # raw dict, and the dispatch loop's `for entry in self._sources:
+                # for source_type, config in entry.items()` iterates the dict's
+                # string keys, raising "'str' object has no attribute 'items'".
+                self._sources = self._normalize_sources(
+                    slug_data.pop('sources', [])
+                )
                 # TODO: making replacements based on POST data.
             else:
                 # Single-query slug: wrap it for the multi-query executor
@@ -529,6 +568,9 @@ class MultiQS(BaseQuery):
             # reduce to one single Dataframe:
             result = list(result.values())[0]
         ### Step 5: Optionally saving result to destination (registry-based dispatch)
+        # Single authoritative Output executor (FEAT-146): fail-fast — the
+        # first destination failure raises immediately and stops the loop
+        # (no "continue to next destination" swallow).
         if _output:
             for step in _output:
                 for step_name, component in step.items():
@@ -537,13 +579,31 @@ class MultiQS(BaseQuery):
                         destination_cls = get_destination(step_name)
                         obj = destination_cls(data=result, **component)
                         result = await obj.run()
+                    except OutputError as oe:
+                        if getattr(oe, "step_name", None) is None:
+                            oe.step_name = step_name
+                        if getattr(oe, "category", None) is None:
+                            oe.category = classify_output_error(oe)
+                        logging.error(
+                            "MultiQS: output destination '%s' failed: %s",
+                            step_name,
+                            oe,
+                        )
+                        raise
+                    except DataNotFound:
+                        # Preserve DataNotFound semantics unchanged.
+                        raise
                     except Exception as dest_err:
                         logging.error(
                             "MultiQS: output destination '%s' failed: %s",
                             step_name,
                             dest_err,
                         )
-                        # Per spec: continue to next destination on failure
+                        raise OutputError(
+                            str(dest_err),
+                            step_name=step_name,
+                            category=classify_output_error(dest_err),
+                        ) from dest_err
         if result is None or len(result) == 0:
             raise DataNotFound(
                 "QS Empty Result"

{querysource-4.5.10 → querysource-4.5.12}/querysource/types/dt/filters.py

@@ -299,9 +299,12 @@ def drop_duplicates(df: pd.DataFrame, columns: Optional[list] = None, **kwargs):
     :return: The DataFrame with duplicates dropped.
     """
     if columns and isinstance(columns, list):
-        df.set_index(columns, inplace=True, drop=False)
-        df = df.sort_values(by=columns)
-        df = df.drop_duplicates(subset=columns, **kwargs)
+        # NOTE: do not ``set_index(columns, drop=False)`` here — it leaves the
+        # same names as both an index level and a column, which makes the
+        # subsequent ``sort_values(by=columns)`` raise "is both an index level
+        # and a column label, which is ambiguous". Sorting on the columns
+        # directly keeps ``keep='first'`` deterministic without that clash.
+        df = df.sort_values(by=columns).drop_duplicates(subset=columns, **kwargs)
     return df
 
 

{querysource-4.5.10 → querysource-4.5.12}/querysource/utils/errors.py

@@ -17,6 +17,8 @@ import traceback
 import uuid
 from typing import Any, Optional
 
+from ..exceptions import OutputError
+
 __all__ = ["GENERIC_MESSAGES", "build_error_payload"]
 
 # ---------------------------------------------------------------------------
@@ -68,6 +70,14 @@ def build_error_payload(
         public_message: If supplied, overrides the generic message from
             ``GENERIC_MESSAGES`` in the public ``"error"`` field.
 
+    Note:
+        When ``exception`` is a ``querysource.exceptions.OutputError`` and no
+        ``public_message`` is supplied, the exception's own message is used
+        as the public ``"error"`` field **even when** ``debug=False``. This
+        is a scoped, accepted data-exposure tradeoff for MultiQuery Output
+        failures only (FEAT-146) — every other exception type keeps the
+        generic redacted message in production.
+
     Returns:
         dict: Client-safe payload.  Production shape::
 
@@ -106,11 +116,27 @@ def build_error_payload(
     )
 
     # 5. Resolve the public message (never expose raw DB / internal text)
-    safe_message = (
-        public_message
-        if public_message is not None
-        else GENERIC_MESSAGES.get(category, GENERIC_MESSAGES[_DEFAULT_CATEGORY])
-    )
+    # Scoped override (FEAT-146): OutputError detail is client-visible even
+    # in production (debug=False), since navigator-front-next needs the real
+    # destination failure text to surface to the user. Every other exception
+    # type keeps the generic, redacted message.
+    if public_message is not None:
+        safe_message = public_message
+    elif isinstance(exception, OutputError):
+        safe_message = detail
+    else:
+        safe_message = GENERIC_MESSAGES.get(category, GENERIC_MESSAGES[_DEFAULT_CATEGORY])
+
+    # 5b. Callers (AbstractHandler.NotFound/Error/Except) reuse this value
+    # verbatim as both the HTTP reason phrase and the X-MESSAGE header —
+    # neither may contain embedded CR/LF (RFC 7230), which aiohttp enforces
+    # by raising ValueError. Real destination failure text (e.g.
+    # TableOutput's multi-line "Unconsumed column names" message, now
+    # surfaced verbatim per the OutputError override above) can legitimately
+    # contain newlines, so collapse them to keep the message intact while
+    # staying header/reason-safe.
+    if safe_message:
+        safe_message = " ".join(safe_message.splitlines())
 
     # 6. Build and return the payload
     payload: dict = {

{querysource-4.5.10 → querysource-4.5.12}/querysource/version.py

@@ -6,7 +6,7 @@ __description__ = (
     'QuerySource Query parser and generator.'
     'Supports SQL, NoSQL, MongoDB, Cassandra, Elasticsearch, etc.'
 )
-__version__ = '4.5.10'
+__version__ = '4.5.12'
 __url__ = 'https://github.com/phenobarbital/querysource'
 __copyright__ = 'Copyright (c) 2018-2025 Jesus Lara'
 __author__ = 'Jesus Lara'

{querysource-4.5.10 → querysource-4.5.12}/querysource.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: querysource
-Version: 4.5.10
+Version: 4.5.12
 Summary: Aiohttp web service for querying several databases easily
 Author-email: Jesus Lara <jesuslarag@gmail.com>
 License: BSD-3-Clause
@@ -123,6 +123,7 @@ Requires-Dist: pytest-asyncio==1.3.0; extra == "dev"
 Requires-Dist: pytest-xdist==3.3.1; extra == "dev"
 Requires-Dist: pytest-assume==2.4.3; extra == "dev"
 Requires-Dist: ruff>=0.6.0; extra == "dev"
+Requires-Dist: maturin<2.0,>=1.7; extra == "dev"
 Dynamic: license-file
 
 # QuerySource #

{querysource-4.5.10 → querysource-4.5.12}/querysource.egg-info/SOURCES.txt

@@ -550,6 +550,7 @@ tests/test_multi_destinations_subpackage.py
 tests/test_multiqs_column_transforms.py
 tests/test_multiqs_destination_dispatch.py
 tests/test_multiqs_remote_dispatch.py
+tests/test_multiqs_slug_sources_normalize.py
 tests/test_multiqs_sources_integration.py
 tests/test_queryslug_concurrency.py
 tests/test_querysource_setup_airtable.py
@@ -597,6 +598,7 @@ tests/handlers/test_querymanager_pagination.py
 tests/handlers/test_queryservice_pbac_smoke.py
 tests/integration/__init__.py
 tests/integration/test_datasource_endpoint.py
+tests/integration/test_multiquery_output_errors.py
 tests/integration/test_pbac_credentials.py
 tests/integration/test_pbac_enforcement.py
 tests/integration/test_pbac_listing.py
@@ -620,6 +622,10 @@ tests/services/__init__.py
 tests/services/test_querysource_setup_pbac.py
 tests/unit/test_cython_filter_fallback.py
 tests/unit/test_datasource_redaction.py
+tests/unit/test_error_payload.py
+tests/unit/test_handler_output_status.py
+tests/unit/test_multiqs_output_raise.py
+tests/unit/test_output_error.py
 tests/unit/test_provider_raw_query_validated.py
 tests/unit/test_qs_parsers_validated.py
 tests/unit/test_raw_query_cond_definition_wiring.py

{querysource-4.5.10 → querysource-4.5.12}/querysource.egg-info/requires.txt

@@ -84,6 +84,7 @@ pytest-asyncio==1.3.0
 pytest-xdist==3.3.1
 pytest-assume==2.4.3
 ruff>=0.6.0
+maturin<2.0,>=1.7
 
 [geo]
 timezonefinder