odoo-agent-cli 0.2.0__py3-none-any.whl

odoocli/errors.py

@@ -0,0 +1,99 @@
+"""Typed exceptions for odoocli, classified from Odoo JSON-RPC error payloads."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+class OdooError(Exception):
+    """Base error. ``exit_code`` is what the CLI returns for this class."""
+
+    exit_code: int = 1
+    default_code: str = "odoo_error"
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        code: str | None = None,
+        data: dict[str, Any] | None = None,
+    ) -> None:
+        self.message = message
+        self.code = code or self.default_code
+        self.data = data
+        super().__init__(message)
+
+    def to_dict(self) -> dict[str, Any]:
+        out: dict[str, Any] = {"code": self.code, "message": self.message}
+        if self.data:
+            # Keep what helps a caller decide; drop the server traceback.
+            odoo = {k: v for k, v in self.data.items() if k in ("name", "message", "arguments")}
+            if odoo:
+                out["odoo"] = odoo
+        return out
+
+
+class OdooConnectionError(OdooError):
+    """Cannot reach or talk JSON-RPC with the server (network, HTTP status, bad URL)."""
+
+    exit_code = 3
+    default_code = "connection_error"
+
+
+class OdooAuthError(OdooError):
+    """Credentials rejected."""
+
+    exit_code = 3
+    default_code = "auth_failed"
+
+
+class OdooAccessError(OdooError):
+    """Authenticated but not allowed (ACL, record rule)."""
+
+    default_code = "access_error"
+
+
+class OdooValidationError(OdooError):
+    """Business rule rejected the call (ValidationError, UserError)."""
+
+    default_code = "validation_error"
+
+
+class OdooMissingError(OdooError):
+    """Record does not exist."""
+
+    default_code = "missing_record"
+
+
+class OdooRefusedError(OdooError):
+    """The CLI itself refused the operation (guards), Odoo was never called."""
+
+    exit_code = 4
+    default_code = "refused"
+
+
+class OdooUsageError(OdooError):
+    """Bad arguments that the CLI can detect before calling Odoo."""
+
+    exit_code = 2
+    default_code = "usage_error"
+
+
+_BY_EXCEPTION_NAME: dict[str, type[OdooError]] = {
+    "odoo.exceptions.AccessDenied": OdooAuthError,
+    "odoo.exceptions.AccessError": OdooAccessError,
+    "odoo.exceptions.ValidationError": OdooValidationError,
+    "odoo.exceptions.UserError": OdooValidationError,
+    "odoo.exceptions.RedirectWarning": OdooValidationError,
+    "odoo.exceptions.MissingError": OdooMissingError,
+}
+
+
+def classify_rpc_error(error: dict[str, Any]) -> OdooError:
+    """Map the ``error`` object of a JSON-RPC response to a typed exception."""
+    data = error.get("data") or {}
+    name = str(data.get("name", ""))
+    message = str(data.get("message") or error.get("message") or "Unknown Odoo error")
+    cls = _BY_EXCEPTION_NAME.get(name, OdooError)
+    code = None if cls is not OdooError else "rpc_error"
+    return cls(message, code=code, data=data or None)

odoocli/lenient.py

@@ -0,0 +1,93 @@
+"""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"
+    )

odoocli/security.py

@@ -0,0 +1,83 @@
+"""Guards ported from UpBoard's connector: sensitive models, secret fields, read-safe methods."""
+
+from __future__ import annotations
+
+from typing import Any
+
+# Models holding secrets or allowing code execution. Refused unless the
+# caller explicitly opts in (--include-sensitive / allow_sensitive).
+SENSITIVE_MODELS: frozenset[str] = frozenset(
+    {
+        "ir.config_parameter",
+        "ir.property",
+        "ir.cron",
+        "ir.actions.server",
+        "ir.rule",
+        "ir.model.access",
+        "base.module.update",
+        "base.module.upgrade",
+        "base.language.install",
+        "res.users.apikeys",
+        "auth.totp.device",
+        "ir.mail_server",
+        "fetchmail.server",
+    }
+)
+
+# Field-name substrings whose VALUE is masked in output (case-insensitive).
+SENSITIVE_FIELD_PATTERNS: tuple[str, ...] = (
+    "password",
+    "passwd",
+    "smtp_pass",
+    "api_key",
+    "apikey",
+    "secret",
+    "private_key",
+    "totp_secret",
+)
+
+# Methods that never change data: callable without allow_writes or --yes.
+READ_SAFE_METHODS: frozenset[str] = frozenset(
+    {
+        "search",
+        "search_read",
+        "search_count",
+        "read",
+        "read_group",
+        "fields_get",
+        "name_search",
+        "name_get",
+        "default_get",
+        "get_metadata",
+        "check_access_rights",
+        "get_views",
+        "web_search_read",
+        "web_read_group",
+        "has_group",
+        "get_external_id",
+    }
+)
+
+REDACTED = "[redacted]"
+
+
+def is_sensitive_model(model: str) -> bool:
+    return model in SENSITIVE_MODELS
+
+
+def is_sensitive_field(name: str) -> bool:
+    lowered = name.lower()
+    return any(p in lowered for p in SENSITIVE_FIELD_PATTERNS)
+
+
+def redact(data: Any) -> Any:
+    """Replace values of secret-named keys, recursively, in lists and dicts."""
+    if isinstance(data, list):
+        return [redact(i) for i in data]
+    if isinstance(data, dict):
+        return {k: (REDACTED if is_sensitive_field(str(k)) else redact(v)) for k, v in data.items()}
+    return data
+
+
+def is_read_safe_method(method: str) -> bool:
+    return method in READ_SAFE_METHODS

odoocli/sync.py

@@ -0,0 +1,126 @@
+"""Blocking wrapper around AsyncOdooClient for plain scripts."""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import threading
+from collections.abc import Coroutine
+from types import TracebackType
+from typing import Any, TypeVar
+
+from odoocli.client import AsyncOdooClient, Domain
+
+T = TypeVar("T")
+
+
+class OdooClient:
+    """Same API as :class:`AsyncOdooClient`, without ``await``.
+
+    Runs a private event loop on a daemon thread so the underlying httpx
+    client keeps one connection pool for the life of the object.
+    """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        self._async = AsyncOdooClient(*args, **kwargs)
+        self._loop = asyncio.new_event_loop()
+        self._thread = threading.Thread(
+            target=self._loop.run_forever, name="odoocli-loop", daemon=True
+        )
+        self._thread.start()
+        self._closed = False
+
+    def _run(self, coro: Coroutine[Any, Any, T]) -> T:
+        if self._closed:
+            coro.close()
+            raise RuntimeError("OdooClient is closed")
+        return asyncio.run_coroutine_threadsafe(coro, self._loop).result()
+
+    # ----- lifecycle -----
+
+    def close(self) -> None:
+        if self._closed:
+            return
+        self._closed = True
+        asyncio.run_coroutine_threadsafe(self._async.close(), self._loop).result()
+        self._loop.call_soon_threadsafe(self._loop.stop)
+        self._thread.join(timeout=5)
+        self._loop.close()
+
+    def __enter__(self) -> OdooClient:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        self.close()
+
+    def __del__(self) -> None:
+        with contextlib.suppress(Exception):  # never raise from a destructor
+            self.close()
+
+    # ----- mirror -----
+
+    @property
+    def uid(self) -> int | None:
+        return self._async.uid
+
+    @property
+    def context(self) -> dict[str, Any]:
+        """Client-wide Odoo context, merged into every call (mutable)."""
+        return self._async.context
+
+    def version(self) -> dict[str, Any]:
+        return self._run(self._async.version())
+
+    def authenticate(self) -> int:
+        return self._run(self._async.authenticate())
+
+    def execute(self, model: str, method: str, *args: Any, **kwargs: Any) -> Any:
+        return self._run(self._async.execute(model, method, *args, **kwargs))
+
+    def search(
+        self,
+        model: str,
+        domain: Domain | None = None,
+        limit: int | None = None,
+        offset: int = 0,
+        order: str | None = None,
+    ) -> list[int]:
+        return self._run(self._async.search(model, domain, limit, offset, order))
+
+    def search_read(
+        self,
+        model: str,
+        domain: Domain | None = None,
+        fields: list[str] | None = None,
+        limit: int | None = None,
+        offset: int = 0,
+        order: str | None = None,
+    ) -> list[dict[str, Any]]:
+        return self._run(self._async.search_read(model, domain, fields, limit, offset, order))
+
+    def search_count(self, model: str, domain: Domain | None = None) -> int:
+        return self._run(self._async.search_count(model, domain))
+
+    def read(
+        self, model: str, ids: list[int], fields: list[str] | None = None
+    ) -> list[dict[str, Any]]:
+        return self._run(self._async.read(model, ids, fields))
+
+    def create(self, model: str, values: dict[str, Any] | list[dict[str, Any]]) -> Any:
+        return self._run(self._async.create(model, values))
+
+    def write(self, model: str, ids: list[int], values: dict[str, Any]) -> bool:
+        return self._run(self._async.write(model, ids, values))
+
+    def unlink(self, model: str, ids: list[int]) -> bool:
+        return self._run(self._async.unlink(model, ids))
+
+    def fields_get(
+        self, model: str, attributes: list[str] | None = None
+    ) -> dict[str, dict[str, Any]]:
+        return self._run(self._async.fields_get(model, attributes))