odoo-agent-cli 0.5.0__tar.gz → 0.6.0__tar.gz

{odoo_agent_cli-0.5.0 → odoo_agent_cli-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: odoo-agent-cli
-Version: 0.5.0
+Version: 0.6.0
 Summary: Odoo JSON-RPC CLI and Python client built for AI agents and scripts.
 Project-URL: Homepage, https://github.com/Organize-IT/odoo-cli
 Project-URL: Issues, https://github.com/Organize-IT/odoo-cli/issues
@@ -43,8 +43,10 @@ uv tool install odoo-agent-cli   # or: pipx install odoo-agent-cli
 odoo --version
 ```
 
-Requires Python 3.11+. Works with Odoo 17, 18 and 19 (integration-tested in CI), and should
-work with any version exposing `/jsonrpc` with API keys (14+).
+Requires Python 3.11+. Works with Odoo 15 through 20 (integration-tested in CI on 15.0,
+16.0, 17.0, 18.0, 19.0 and 20.0, Community), and should work with any version exposing
+`/jsonrpc` with API keys (14+). Odoo 20 still serves `/jsonrpc` but logs it as deprecated;
+Odoo plans to remove it in 22.
 
 ## 60 seconds
 
@@ -196,7 +198,10 @@ odoo group invoices -w overdue --by partner_id --sum amount_residual \
 odoo group invoices --by invoice_date:month --sum amount_total
 ```
 
-`read_group` under the hood: counts and totals per group without pulling the records.
+`read_group` under the hood: counts and totals per group without pulling the records. On
+Odoo 20, whose `read_group` no longer answers JSON-RPC callers, it is `formatted_read_group`,
+and its answer is passed through as is: totals are keyed `amount_residual:sum` rather than
+`amount_residual`, and each group's filter is `__extra_domain`.
 
 ## Writes
 
@@ -254,14 +259,17 @@ async with AsyncOdooClient(url, db, login, key) as odoo:
 ```
 
 Exceptions: `OdooError` (base, `.code`, `.message`, `.data`), `OdooConnectionError`,
-`OdooAuthError`, `OdooAccessError`, `OdooValidationError`, `OdooMissingError`.
+`OdooAuthError`, `OdooAccessError`, `OdooValidationError`, `OdooMissingError`,
+`OdooFieldMissingError`.
 
 Both clients accept `context={...}` (merged into every call; a per-call `context=` keyword
 wins), `verify_ssl=False` and `max_retries`. HTTP 429 is always retried with backoff and
 `Retry-After`; network errors, timeouts and HTTP 5xx are retried only for calls that cannot
 change data, so a `create` that timed out is never replayed. Logs go to the `odoocli.rpc`
-logger. Domain helpers live in `odoocli.domain`, guards in `odoocli.security`, the opt-in
-repair loop in `odoocli.lenient`.
+logger. Domain helpers live in `odoocli.domain`, guards in `odoocli.security`, the repair
+loop in `odoocli.lenient`: `lenient_search_read` drops rejected fields from `fields` and
+`order` on its own, but a rejected field in the domain raises `OdooFieldMissingError` unless
+you pass `strip_domain=True`, because removing a filter widens the query.
 
 ## Development
 
@@ -274,13 +282,15 @@ uv run pytest --cov --cov-report=term-missing   # gated at 93% in CI
 uv run --group docs mkdocs serve     # the documentation site
 
 ODOO_VERSION=17.0 scripts/start-odoo.sh                     # throwaway Odoo in Docker
+                                   # 15.0 to 20.0; 20.0 is built from docker/odoo20/SHA;
+                                   # ODOO_PORT=8169 if 8069 is taken
 ODOO_URL=http://localhost:8069 ODOO_DB=test ODOO_LOGIN=admin ODOO_API_KEY=admin \
 ODOO_ALLOW_WRITES=1 uv run pytest -m integration -o addopts=""
 docker compose -f docker/odoo-compose.yml down -v
 ```
 
 CI runs the unit suite on Python 3.11-3.13 and builds the docs on every PR; the integration
-matrix (Odoo 17.0, 18.0, 19.0) runs on `main`, tags and manual dispatch. Releases are
+matrix (Odoo 15.0 to 20.0) runs on `main`, tags and manual dispatch. Releases are
 published to PyPI on `v*` tags through trusted publishing, with every action pinned to a
 commit digest.
 

{odoo_agent_cli-0.5.0 → odoo_agent_cli-0.6.0}/README.md

@@ -16,8 +16,10 @@ uv tool install odoo-agent-cli   # or: pipx install odoo-agent-cli
 odoo --version
 ```
 
-Requires Python 3.11+. Works with Odoo 17, 18 and 19 (integration-tested in CI), and should
-work with any version exposing `/jsonrpc` with API keys (14+).
+Requires Python 3.11+. Works with Odoo 15 through 20 (integration-tested in CI on 15.0,
+16.0, 17.0, 18.0, 19.0 and 20.0, Community), and should work with any version exposing
+`/jsonrpc` with API keys (14+). Odoo 20 still serves `/jsonrpc` but logs it as deprecated;
+Odoo plans to remove it in 22.
 
 ## 60 seconds
 
@@ -169,7 +171,10 @@ odoo group invoices -w overdue --by partner_id --sum amount_residual \
 odoo group invoices --by invoice_date:month --sum amount_total
 ```
 
-`read_group` under the hood: counts and totals per group without pulling the records.
+`read_group` under the hood: counts and totals per group without pulling the records. On
+Odoo 20, whose `read_group` no longer answers JSON-RPC callers, it is `formatted_read_group`,
+and its answer is passed through as is: totals are keyed `amount_residual:sum` rather than
+`amount_residual`, and each group's filter is `__extra_domain`.
 
 ## Writes
 
@@ -227,14 +232,17 @@ async with AsyncOdooClient(url, db, login, key) as odoo:
 ```
 
 Exceptions: `OdooError` (base, `.code`, `.message`, `.data`), `OdooConnectionError`,
-`OdooAuthError`, `OdooAccessError`, `OdooValidationError`, `OdooMissingError`.
+`OdooAuthError`, `OdooAccessError`, `OdooValidationError`, `OdooMissingError`,
+`OdooFieldMissingError`.
 
 Both clients accept `context={...}` (merged into every call; a per-call `context=` keyword
 wins), `verify_ssl=False` and `max_retries`. HTTP 429 is always retried with backoff and
 `Retry-After`; network errors, timeouts and HTTP 5xx are retried only for calls that cannot
 change data, so a `create` that timed out is never replayed. Logs go to the `odoocli.rpc`
-logger. Domain helpers live in `odoocli.domain`, guards in `odoocli.security`, the opt-in
-repair loop in `odoocli.lenient`.
+logger. Domain helpers live in `odoocli.domain`, guards in `odoocli.security`, the repair
+loop in `odoocli.lenient`: `lenient_search_read` drops rejected fields from `fields` and
+`order` on its own, but a rejected field in the domain raises `OdooFieldMissingError` unless
+you pass `strip_domain=True`, because removing a filter widens the query.
 
 ## Development
 
@@ -247,13 +255,15 @@ uv run pytest --cov --cov-report=term-missing   # gated at 93% in CI
 uv run --group docs mkdocs serve     # the documentation site
 
 ODOO_VERSION=17.0 scripts/start-odoo.sh                     # throwaway Odoo in Docker
+                                   # 15.0 to 20.0; 20.0 is built from docker/odoo20/SHA;
+                                   # ODOO_PORT=8169 if 8069 is taken
 ODOO_URL=http://localhost:8069 ODOO_DB=test ODOO_LOGIN=admin ODOO_API_KEY=admin \
 ODOO_ALLOW_WRITES=1 uv run pytest -m integration -o addopts=""
 docker compose -f docker/odoo-compose.yml down -v
 ```
 
 CI runs the unit suite on Python 3.11-3.13 and builds the docs on every PR; the integration
-matrix (Odoo 17.0, 18.0, 19.0) runs on `main`, tags and manual dispatch. Releases are
+matrix (Odoo 15.0 to 20.0) runs on `main`, tags and manual dispatch. Releases are
 published to PyPI on `v*` tags through trusted publishing, with every action pinned to a
 commit digest.
 

{odoo_agent_cli-0.5.0 → odoo_agent_cli-0.6.0}/SKILL.md

@@ -116,7 +116,9 @@ odoo cache path|list|clear                  the schema cache
 `MODEL` accepts an alias on every read command. `odoo group` runs `read_group`, so you
 get counts and totals per group without pulling the records:
 `odoo group invoices -w overdue --by partner_id --sum amount_residual`.
-Grouping keys accept a date granularity: `--by invoice_date:month`.
+Grouping keys accept a date granularity: `--by invoice_date:month`. On Odoo 20 it runs
+`formatted_read_group` and passes its answer through: totals are keyed `amount_residual:sum`
+instead of `amount_residual`, and each group's filter is `__extra_domain`.
 
 Conditions (`-w`, repeatable, AND-ed together, combined with `--domain`):
 
@@ -174,7 +176,7 @@ One2many and many2many fields take Odoo commands, written as JSON in `-v` or `--
 5. Many2one values come back as `[id, name]`. Filter on them with the id
    (`-w partner_id=42`) or through a related field (`-w partner_id.name~acme`).
 6. Dates are strings, `YYYY-MM-DD` or `YYYY-MM-DD HH:MM:SS` in UTC.
-7. Field names drift between Odoo 17, 18 and 19 (for example `account.account.company_id`
+7. Field names drift between Odoo 15 and 20 (for example `account.account.company_id`
    became `company_ids`). If a field is rejected, `odoo fields` is the truth.
    `--lenient-fields` on `search` removes rejected fields and retries. It prints the rows and
    then exits 5, because they answer a wider question than the one you asked. Use it to

{odoo_agent_cli-0.5.0 → odoo_agent_cli-0.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "odoo-agent-cli"
-version = "0.5.0"
+version = "0.6.0"
 description = "Odoo JSON-RPC CLI and Python client built for AI agents and scripts."
 readme = "README.md"
 license = "MIT"

{odoo_agent_cli-0.5.0 → odoo_agent_cli-0.6.0}/src/odoocli/AGENT_GUIDE.md

@@ -111,7 +111,9 @@ odoo cache path|list|clear                  the schema cache
 `MODEL` accepts an alias on every read command. `odoo group` runs `read_group`, so you
 get counts and totals per group without pulling the records:
 `odoo group invoices -w overdue --by partner_id --sum amount_residual`.
-Grouping keys accept a date granularity: `--by invoice_date:month`.
+Grouping keys accept a date granularity: `--by invoice_date:month`. On Odoo 20 it runs
+`formatted_read_group` and passes its answer through: totals are keyed `amount_residual:sum`
+instead of `amount_residual`, and each group's filter is `__extra_domain`.
 
 Conditions (`-w`, repeatable, AND-ed together, combined with `--domain`):
 
@@ -169,7 +171,7 @@ One2many and many2many fields take Odoo commands, written as JSON in `-v` or `--
 5. Many2one values come back as `[id, name]`. Filter on them with the id
    (`-w partner_id=42`) or through a related field (`-w partner_id.name~acme`).
 6. Dates are strings, `YYYY-MM-DD` or `YYYY-MM-DD HH:MM:SS` in UTC.
-7. Field names drift between Odoo 17, 18 and 19 (for example `account.account.company_id`
+7. Field names drift between Odoo 15 and 20 (for example `account.account.company_id`
    became `company_ids`). If a field is rejected, `odoo fields` is the truth.
    `--lenient-fields` on `search` removes rejected fields and retries. It prints the rows and
    then exits 5, because they answer a wider question than the one you asked. Use it to

{odoo_agent_cli-0.5.0 → odoo_agent_cli-0.6.0}/src/odoocli/__init__.py

@@ -7,6 +7,7 @@ from odoocli.errors import (
     OdooAuthError,
     OdooConnectionError,
     OdooError,
+    OdooFieldMissingError,
     OdooMissingError,
     OdooRefusedError,
     OdooRepairedError,
@@ -22,6 +23,7 @@ __all__ = [
     "OdooClient",
     "OdooConnectionError",
     "OdooError",
+    "OdooFieldMissingError",
     "OdooMissingError",
     "OdooRefusedError",
     "OdooRepairedError",

{odoo_agent_cli-0.5.0 → odoo_agent_cli-0.6.0}/src/odoocli/_version.py

@@ -1,3 +1,3 @@
 """Single source of the package version (kept import-free to avoid cycles)."""
 
-__version__ = "0.5.0"
+__version__ = "0.6.0"

{odoo_agent_cli-0.5.0 → odoo_agent_cli-0.6.0}/src/odoocli/cli/read_cmds.py

@@ -21,7 +21,7 @@ from odoocli.cli.values import parse_ids, split_fields
 from odoocli.client import AsyncOdooClient
 from odoocli.config import Profile
 from odoocli.domain import build_domain
-from odoocli.errors import OdooMissingError, OdooRepairedError, OdooUsageError
+from odoocli.errors import OdooError, OdooMissingError, OdooRepairedError, OdooUsageError
 from odoocli.lenient import lenient_search_read
 
 DEFAULT_LIMIT = 80
@@ -175,7 +175,15 @@ def search(
     ) -> list[dict[str, Any]]:
         if lenient:
             return await lenient_search_read(
-                client, target, dom, flds, lim, off, order, on_warning=note_repair
+                client,
+                target,
+                dom,
+                flds,
+                lim,
+                off,
+                order,
+                strip_domain=True,
+                on_warning=note_repair,
             )
         return await client.search_read(target, dom, flds, lim, off, order)
 
@@ -281,21 +289,62 @@ def group(
             domain=dom,
             order=order,
         )
-        kwargs: dict[str, Any] = {"lazy": False}
+        page: dict[str, Any] = {}
         if limit is not None:
-            kwargs["limit"] = limit
+            page["limit"] = limit
         if offset:
-            kwargs["offset"] = offset
-        if order:
-            kwargs["orderby"] = order
-        result = await client.execute(
-            target, "read_group", dom, groupby + aggregates, groupby, **kwargs
-        )
+            page["offset"] = offset
+        try:
+            result = await client.execute(
+                target,
+                "read_group",
+                dom,
+                groupby + aggregates,
+                groupby,
+                lazy=False,
+                **page,
+                **({"orderby": order} if order else {}),
+            )
+        except OdooError as e:
+            if not _read_group_is_gone(e):
+                raise
+            # Odoo 20: the public read_group is the ORM's tuple API, the JSON one is
+            # formatted_read_group. Its answer is passed through as is: aggregate keys
+            # read "amount_total:sum" and the group filter is "__extra_domain".
+            if order:
+                page["order"] = _aggregate_order(order, groupby, aggregates)
+            result = await client.execute(
+                target, "formatted_read_group", dom, groupby, ["__count", *aggregates], **page
+            )
         return list(result) if isinstance(result, list) else []
 
     emit(ctx, run(ctx, go))
 
 
+def _read_group_is_gone(error: OdooError) -> bool:
+    """Whether the server's read_group no longer takes the web client's arguments (Odoo 20)."""
+    name = (error.data or {}).get("name")
+    return name == "builtins.TypeError" and "'lazy'" in error.message
+
+
+def _aggregate_order(order: str, groupby: list[str], aggregates: list[str]) -> str:
+    """Rewrite ``amount_total desc`` as ``amount_total:sum desc`` for formatted_read_group.
+
+    It only orders by a groupby or an aggregate spec; read_group took the bare field name.
+    The first aggregate given for a field wins.
+    """
+    specs: dict[str, str] = {}
+    for spec in aggregates:
+        specs.setdefault(spec.split(":", 1)[0], spec)
+    terms = []
+    for term in (t.strip() for t in order.split(",") if t.strip()):
+        name, _, direction = term.partition(" ")
+        if name not in groupby and name in specs:
+            term = f"{specs[name]} {direction}".strip()
+        terms.append(term)
+    return ", ".join(terms)
+
+
 @app.command()
 def read(
     ctx: typer.Context,

{odoo_agent_cli-0.5.0 → odoo_agent_cli-0.6.0}/src/odoocli/domain.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import ast
 import json
 import re
+from collections.abc import Callable
 from datetime import date
 from typing import Any
 
@@ -104,18 +105,22 @@ def _parse(tokens: list[Any], pos: int) -> tuple[Any, int]:
     return ("leaf", tok), pos + 1
 
 
-def _mentions(node: Any, bad_field: str) -> bool:
+PathMatcher = Callable[[str], bool]
+"""Decides whether a leaf's field path (``"partner_id.name"``) is one to remove."""
+
+
+def _mentions(node: Any, matches: PathMatcher) -> bool:
     kind = node[0]
     if kind == "leaf":
         term = node[1]
-        return bool(_is_leaf(term) and term[0] == bad_field)
+        return bool(_is_leaf(term) and matches(term[0]))
     if kind == "not":
-        return _mentions(node[1], bad_field)
-    return _mentions(node[2], bad_field) or _mentions(node[3], bad_field)
+        return _mentions(node[1], matches)
+    return _mentions(node[2], matches) or _mentions(node[3], matches)
 
 
-def _serialize(node: Any, bad_field: str) -> Any:
-    """Replace every leaf on ``bad_field`` with "matches everything", then simplify.
+def _serialize(node: Any, matches: PathMatcher) -> Any:
+    """Replace every leaf whose path ``matches`` with "matches everything", then simplify.
 
     Repairing a query may only ever widen it. Two places make that non-obvious:
 
@@ -127,16 +132,16 @@ def _serialize(node: Any, bad_field: str) -> Any:
     kind = node[0]
     if kind == "leaf":
         term = node[1]
-        if _is_leaf(term) and term[0] == bad_field:
+        if _is_leaf(term) and matches(term[0]):
             return _TRUE
         return [term]
     if kind == "not":
-        if _mentions(node[1], bad_field):
+        if _mentions(node[1], matches):
             return _TRUE
-        return [_UNARY_OP, *_serialize(node[1], bad_field)]
+        return [_UNARY_OP, *_serialize(node[1], matches)]
     _, operator, left_node, right_node = node
-    left = _serialize(left_node, bad_field)
-    right = _serialize(right_node, bad_field)
+    left = _serialize(left_node, matches)
+    right = _serialize(right_node, matches)
     if operator == "|":
         if left is _TRUE or right is _TRUE:
             return _TRUE
@@ -150,12 +155,14 @@ def _serialize(node: Any, bad_field: str) -> Any:
     return [operator, *left, *right]
 
 
-def strip_field_from_domain(domain: Any, bad_field: str) -> Any:
-    """Remove every constraint on ``bad_field``, widening the domain and never narrowing it.
+def strip_leaves_from_domain(domain: Any, matches: PathMatcher) -> Any:
+    """Remove every leaf whose field path ``matches``, widening the domain and never narrowing it.
 
-    Every record the original domain matched still matches the result. That is the only
-    property that makes an automatic repair defensible: returning extra rows is visible,
-    losing rows the caller asked for is not.
+    A removed leaf means "matches everything", so every record the original domain matched
+    still matches the result. That is the only property that makes an automatic repair
+    defensible: returning extra rows is visible, losing rows the caller asked for is not.
+    ``matches`` receives the whole path, so a caller can remove ``product_id.detailed_type``
+    when Odoo rejected ``detailed_type`` on ``product.product``.
     """
     if not isinstance(domain, list) or not domain:
         return domain
@@ -164,7 +171,7 @@ def strip_field_from_domain(domain: Any, bad_field: str) -> Any:
         pos = 0
         while pos < len(domain):
             node, pos = _parse(domain, pos)
-            serialized = _serialize(node, bad_field)
+            serialized = _serialize(node, matches)
             if serialized is not _TRUE:
                 cleaned.extend(serialized)
         return cleaned
@@ -173,6 +180,14 @@ def strip_field_from_domain(domain: Any, bad_field: str) -> Any:
         return domain
 
 
+def strip_field_from_domain(domain: Any, bad_field: str) -> Any:
+    """Remove every constraint on the field named exactly ``bad_field``, only ever widening.
+
+    See ``strip_leaves_from_domain``; dotted paths are matched whole, not by segment.
+    """
+    return strip_leaves_from_domain(domain, lambda path: path == bad_field)
+
+
 # ----- -w DSL -----
 
 _WORD_OPS = (

{odoo_agent_cli-0.5.0 → odoo_agent_cli-0.6.0}/src/odoocli/errors.py

@@ -90,6 +90,36 @@ class OdooRepairedError(OdooError):
     default_code = "result_repaired"
 
 
+class OdooFieldMissingError(OdooError):
+    """A field the query filters on is not available on this server, and was not removed.
+
+    Removing a leaf from a domain widens the query, so the rows would answer another
+    question. Raised instead of repairing unless the caller opted in (``strip_domain=True``).
+    Exit 2 like any other unknown field.
+    """
+
+    exit_code = 2
+    default_code = "field_missing"
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        model: str,
+        field: str,
+        where: str = "domain",
+        code: str | None = None,
+        data: dict[str, Any] | None = None,
+    ) -> None:
+        self.model = model
+        self.field = field
+        self.where = where
+        super().__init__(message, code=code, data=data)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {**super().to_dict(), "model": self.model, "field": self.field, "where": self.where}
+
+
 _BY_EXCEPTION_NAME: dict[str, type[OdooError]] = {
     "odoo.exceptions.AccessDenied": OdooAuthError,
     "odoo.exceptions.AccessError": OdooAccessError,

odoo_agent_cli-0.6.0/src/odoocli/lenient.py

@@ -0,0 +1,161 @@
+"""search_read that repairs fields Odoo rejects and retries (version drift).
+
+Dropping a field from ``fields`` or ``order`` changes the shape of the answer, never which
+records it holds, so it is always repaired. Dropping one from the domain widens the query:
+the caller asked for cash accounts and would get every account. That is only done when the
+caller opts in with ``strip_domain=True``; otherwise ``OdooFieldMissingError`` is raised and
+nothing is replayed.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Callable
+from typing import Any
+
+from odoocli.client import AsyncOdooClient, Domain
+from odoocli.domain import PathMatcher, strip_leaves_from_domain
+from odoocli.errors import OdooError, OdooFieldMissingError
+
+# "Invalid field 'mobile' on model 'res.partner'" (read), "Invalid field 'date_planned'",
+# "Invalid field account.account.deprecated in condition" / "in leaf" (domain, 15 to 20).
+_INVALID_FIELD_RE = re.compile(
+    r"Invalid field '?([\w.]+)'?(?: on model '?([\w.]+)'?)?", re.IGNORECASE
+)
+# "Cannot convert product.product.qty_available to SQL because it is not stored" and
+# "Field 'is_storable' cannot be used in domain"
+_NON_STORED_RE = re.compile(
+    r"Cannot convert ([\w.]+) to SQL|[Ff]ield '?([\w.]+)'? cannot be used in domain",
+    re.IGNORECASE,
+)
+
+Warn = Callable[[dict[str, Any]], None]
+
+
+def _rejected(name: str, on_model: str | None, queried: str) -> tuple[str, str]:
+    """``(model, field)`` that Odoo rejected, from the name its error message printed.
+
+    ``account.account.deprecated`` is qualified: the model is everything before the last dot.
+    A bare name is taken to be on the queried model.
+    """
+    if on_model:
+        return on_model, name.rsplit(".", 1)[-1]
+    if "." in name:
+        model, field = name.rsplit(".", 1)
+        return model, field
+    return queried, name
+
+
+def _path_matcher(queried: str, rejected_model: str, bad_field: str) -> PathMatcher:
+    """Which domain paths the rejection is about.
+
+    A rejection on the queried model is about the *first* segment of a path only:
+    ``name`` missing on ``sale.order.line`` says nothing about ``product_id.name``, and
+    matching it there would refuse, or strip, a filter that is perfectly valid.
+
+    A rejection naming another model (the qualified ``product.product.detailed_type`` form
+    Odoo prints for the model the failing segment was resolved on) can only come from a
+    deeper segment, so any segment after the first is matched. Segments are compared
+    exactly, so a missing ``type`` is never confused with ``move_type``.
+
+    Without the schema this cannot tell a self-referencing path (``parent_id.x`` on
+    ``res.partner``) from a root one; such a leaf is not matched and the original error is
+    raised, which is the safe way to be wrong.
+    """
+    if rejected_model == queried:
+        return lambda path: path.split(".")[0] == bad_field
+    return lambda path: bad_field in path.split(".")[1:]
+
+
+def _in_domain(domain: Domain, matches: PathMatcher) -> bool:
+    """Whether a top-level leaf of ``domain`` has a path ``matches`` accepts."""
+    return any(
+        isinstance(term, list | tuple)
+        and len(term) == 3
+        and isinstance(term[0], str)
+        and matches(term[0])
+        for term in domain
+    )
+
+
+def _field_missing(model: str, bad_field: str, cause: OdooError) -> OdooFieldMissingError:
+    return OdooFieldMissingError(
+        f"Field {model}.{bad_field} is not available in the domain on this Odoo version",
+        model=model,
+        field=bad_field,
+        where="domain",
+        data=cause.data,
+    )
+
+
+def _strip_order(order: str, bad_field: str) -> str | None:
+    parts = [p.strip() for p in order.split(",") if p.strip() and p.strip().split()[0] != bad_field]
+    return ", ".join(parts) if parts else None
+
+
+async def lenient_search_read(
+    client: AsyncOdooClient,
+    model: str,
+    domain: Domain | None,
+    fields: list[str] | None,
+    limit: int | None,
+    offset: int,
+    order: str | None,
+    *,
+    max_retries: int = 3,
+    strip_domain: bool = False,
+    on_warning: Warn | None = None,
+) -> list[dict[str, Any]]:
+    """Like ``client.search_read`` but removes rejected fields and retries.
+
+    A rejected field in ``fields`` or ``order`` is removed and the query replayed. A rejected
+    field in the domain raises ``OdooFieldMissingError`` before any replay, unless
+    ``strip_domain`` is true: then the leaves holding it are removed, dotted paths included
+    (the domain only ever widens, see ``strip_leaves_from_domain``) and the rows answer a
+    wider question than the one asked. ``_path_matcher`` decides which leaves hold it.
+
+    ``fields`` and ``order`` are only repaired for a rejection on the queried model itself.
+
+    Every removal is reported through ``on_warning`` as
+    ``{"warning": <kind>, "field": <name>, "from": ["fields" | "domain" | "order", ...]}``.
+    """
+    domain = list(domain or [])
+    fields = list(fields) if fields else None
+    for _ in range(max_retries + 1):
+        try:
+            return await client.search_read(model, domain, fields, limit, offset, order)
+        except OdooError as e:
+            text = e.message
+            invalid = _INVALID_FIELD_RE.search(text)
+            non_stored = None if invalid else _NON_STORED_RE.search(text)
+            if invalid:
+                kind, name, on_model = "invalid_field_removed", invalid.group(1), invalid.group(2)
+            elif non_stored:
+                kind, on_model = "non_stored_field_removed", None
+                name = non_stored.group(1) or non_stored.group(2) or ""
+            else:
+                raise
+            owner, bad = _rejected(name, on_model, model)
+            matches = _path_matcher(model, owner, bad)
+            in_domain = bool(bad) and _in_domain(domain, matches)
+            if in_domain and not strip_domain:
+                raise _field_missing(owner, bad, e) from e
+            on_root = owner == model
+            removed: list[str] = []
+            # A non-stored field reads fine, so it never has to leave ``fields``.
+            if invalid and on_root and fields and bad in fields:
+                fields = [f for f in fields if f != bad] or None
+                removed.append("fields")
+            if in_domain:
+                domain = strip_leaves_from_domain(domain, matches)
+                removed.append("domain")
+            if on_root and bad and order and bad in order:
+                order = _strip_order(order, bad)
+                removed.append("order")
+            if not removed:
+                raise
+            if on_warning:
+                on_warning({"warning": kind, "field": bad, "from": removed})
+    raise OdooError(
+        f"Gave up repairing the query after {max_retries} retries", code="retry_exhausted"
+    )

{odoo_agent_cli-0.5.0 → odoo_agent_cli-0.6.0}/src/odoocli/security.py

@@ -44,6 +44,7 @@ READ_SAFE_METHODS: frozenset[str] = frozenset(
         "search_count",
         "read",
         "read_group",
+        "formatted_read_group",
         "fields_get",
         "name_search",
         "name_get",

odoo_agent_cli-0.5.0/src/odoocli/lenient.py

@@ -1,93 +0,0 @@
-"""Opt-in search_read that strips fields Odoo rejects and retries (version drift)."""
-
-from __future__ import annotations
-
-import re
-from collections.abc import Callable
-from typing import Any
-
-from odoocli.client import AsyncOdooClient, Domain
-from odoocli.domain import strip_field_from_domain
-from odoocli.errors import OdooError
-
-# "Invalid field 'date_planned'" and "Invalid field account.account.deprecated in condition"
-_INVALID_FIELD_RE = re.compile(r"Invalid field '?([\w.]+)'?", re.IGNORECASE)
-# "Cannot convert qty_available to SQL because it is not stored" and
-# "Field 'is_storable' cannot be used in domain"
-_NON_STORED_RE = re.compile(
-    r"Cannot convert ([\w.]+) to SQL|[Ff]ield '?([\w.]+)'? cannot be used in domain",
-    re.IGNORECASE,
-)
-
-Warn = Callable[[dict[str, Any]], None]
-
-
-def _strip_order(order: str, bad_field: str) -> str | None:
-    parts = [p.strip() for p in order.split(",") if p.strip() and p.strip().split()[0] != bad_field]
-    return ", ".join(parts) if parts else None
-
-
-async def lenient_search_read(
-    client: AsyncOdooClient,
-    model: str,
-    domain: Domain | None,
-    fields: list[str] | None,
-    limit: int | None,
-    offset: int,
-    order: str | None,
-    *,
-    max_retries: int = 3,
-    on_warning: Warn | None = None,
-) -> list[dict[str, Any]]:
-    """Like ``client.search_read`` but removes rejected fields and retries.
-
-    Every removal is reported through ``on_warning`` as
-    ``{"warning": <kind>, "field": <name>, "from": ["fields" | "domain" | "order", ...]}``.
-    """
-    domain = list(domain or [])
-    fields = list(fields) if fields else None
-    for _ in range(max_retries + 1):
-        try:
-            return await client.search_read(model, domain, fields, limit, offset, order)
-        except OdooError as e:
-            text = e.message
-            invalid = _INVALID_FIELD_RE.search(text)
-            if invalid:
-                bad = invalid.group(1).split(".")[-1]
-                removed: list[str] = []
-                if fields and bad in fields:
-                    fields = [f for f in fields if f != bad] or None
-                    removed.append("fields")
-                if bad in str(domain):
-                    domain = strip_field_from_domain(domain, bad)
-                    removed.append("domain")
-                if order and bad in order:
-                    order = _strip_order(order, bad)
-                    removed.append("order")
-                if removed:
-                    if on_warning:
-                        on_warning(
-                            {"warning": "invalid_field_removed", "field": bad, "from": removed}
-                        )
-                    continue
-                raise
-            non_stored = _NON_STORED_RE.search(text)
-            if non_stored:
-                bad = (non_stored.group(1) or non_stored.group(2) or "").split(".")[-1]
-                removed = []
-                if bad and bad in str(domain):
-                    domain = strip_field_from_domain(domain, bad)
-                    removed.append("domain")
-                if bad and order and bad in order:
-                    order = _strip_order(order, bad)
-                    removed.append("order")
-                if removed:
-                    if on_warning:
-                        on_warning(
-                            {"warning": "non_stored_field_removed", "field": bad, "from": removed}
-                        )
-                    continue
-            raise
-    raise OdooError(
-        f"Gave up repairing the query after {max_retries} retries", code="retry_exhausted"
-    )