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

odoocli/client.py

@@ -0,0 +1,312 @@
+"""Async Odoo JSON-RPC client. No env, no printing; logs through ``logging`` only."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import random
+import time
+from types import TracebackType
+from typing import Any
+
+import httpx
+
+from odoocli._version import __version__
+from odoocli.errors import OdooAuthError, OdooConnectionError, classify_rpc_error
+from odoocli.security import is_read_safe_method
+
+Domain = list[Any]
+
+logger = logging.getLogger("odoocli.rpc")
+
+
+class AsyncOdooClient:
+    """Talk to one Odoo database over ``/jsonrpc``.
+
+    ``api_key`` is what goes in the password slot of ``common.authenticate``:
+    an API key (Odoo 14+) or the user's password.
+
+    ``context`` is merged into every ``execute_kw`` call (``lang``,
+    ``allowed_company_ids``, ``active_test``, ...); a per-call ``context``
+    keyword argument overrides keys of the client-wide one.
+
+    Retry policy: HTTP 429 is always retried (Odoo rejected the request before
+    running it). Network errors, timeouts and HTTP 5xx are retried only for
+    calls that cannot change data (``common.*`` and read-safe ORM methods),
+    because a ``create`` that timed out may well have been committed.
+    """
+
+    def __init__(
+        self,
+        url: str,
+        database: str,
+        login: str,
+        api_key: str,
+        *,
+        timeout: float = 30.0,
+        max_retries: int = 3,
+        retry_base_delay: float = 1.0,
+        retry_max_delay: float = 8.0,
+        verify_ssl: bool = True,
+        context: dict[str, Any] | None = None,
+    ) -> None:
+        self.url = url.rstrip("/")
+        self.database = database
+        self.login = login
+        self._api_key = api_key
+        self.max_retries = max_retries
+        self.retry_base_delay = retry_base_delay
+        self.retry_max_delay = retry_max_delay
+        self.verify_ssl = verify_ssl
+        self.context: dict[str, Any] = dict(context or {})
+        # Connect tight so a dead host or firewall surfaces fast; keep the
+        # read budget close to the total.
+        self._timeout = httpx.Timeout(
+            connect=min(5.0, timeout),
+            read=max(1.0, timeout - 5.0),
+            write=max(1.0, timeout - 5.0),
+            pool=5.0,
+        )
+        self._uid: int | None = None
+        self._http: httpx.AsyncClient | None = None
+
+    def __repr__(self) -> str:
+        return (
+            f"AsyncOdooClient(url={self.url!r}, database={self.database!r}, "
+            f"login={self.login!r}, uid={self._uid!r})"
+        )
+
+    # ----- lifecycle -----
+
+    @property
+    def uid(self) -> int | None:
+        return self._uid
+
+    async def __aenter__(self) -> AsyncOdooClient:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        await self.close()
+
+    async def close(self) -> None:
+        if self._http is not None and not self._http.is_closed:
+            await self._http.aclose()
+        self._http = None
+
+    def _client(self) -> httpx.AsyncClient:
+        if self._http is None or self._http.is_closed:
+            self._http = httpx.AsyncClient(
+                timeout=self._timeout,
+                headers={"User-Agent": f"odoocli/{__version__}"},
+                verify=self.verify_ssl,
+            )
+        return self._http
+
+    # ----- transport -----
+
+    def _retry_delay(self, attempt: int, retry_after: str | None = None) -> float:
+        if retry_after:
+            try:
+                return max(0.0, min(float(retry_after), self.retry_max_delay))
+            except ValueError:
+                pass  # HTTP-date format: fall back to backoff
+        base = min(self.retry_base_delay * (2**attempt), self.retry_max_delay)
+        jitter: float = 0.5 + random.random() / 2
+        return float(base * jitter)
+
+    async def _rpc(
+        self, service: str, method: str, args: list[Any], *, retryable: bool = True
+    ) -> Any:
+        request_id = random.randint(1, 1_000_000)
+        payload = {
+            "jsonrpc": "2.0",
+            "method": "call",
+            "params": {"service": service, "method": method, "args": args},
+            "id": request_id,
+        }
+        url = f"{self.url}/jsonrpc"
+        client = self._client()
+        label = f"{service}.{method}" if service == "common" else f"{args[3]}.{args[4]}"
+        started = time.perf_counter()
+        logger.debug("-> %s id=%d", label, request_id)
+
+        response: httpx.Response | None = None
+        for attempt in range(self.max_retries + 1):
+            last = attempt == self.max_retries
+            try:
+                response = await client.post(url, json=payload)
+            except httpx.HTTPError as e:
+                if not retryable or last:
+                    raise OdooConnectionError(
+                        f"Cannot reach {url}: {e}", code="connection_error"
+                    ) from e
+                delay = self._retry_delay(attempt)
+                logger.warning(
+                    "%s failed (%s), retry %d/%d in %.1fs",
+                    label,
+                    type(e).__name__,
+                    attempt + 1,
+                    self.max_retries,
+                    delay,
+                )
+                await asyncio.sleep(delay)
+                continue
+            status = response.status_code
+            if status == 429 and not last:
+                delay = self._retry_delay(attempt, response.headers.get("Retry-After"))
+                logger.warning(
+                    "%s rate limited (429), retry %d/%d in %.1fs",
+                    label,
+                    attempt + 1,
+                    self.max_retries,
+                    delay,
+                )
+                await asyncio.sleep(delay)
+                continue
+            if status >= 500 and retryable and not last:
+                delay = self._retry_delay(attempt, response.headers.get("Retry-After"))
+                logger.warning(
+                    "%s got HTTP %d, retry %d/%d in %.1fs",
+                    label,
+                    status,
+                    attempt + 1,
+                    self.max_retries,
+                    delay,
+                )
+                await asyncio.sleep(delay)
+                continue
+            break
+
+        assert response is not None
+        elapsed_ms = (time.perf_counter() - started) * 1000
+        if response.status_code == 429:
+            raise OdooConnectionError(
+                f"Odoo rate limited the request (HTTP 429) after {self.max_retries + 1} attempts",
+                code="rate_limited",
+            )
+        if response.status_code >= 400:
+            raise OdooConnectionError(f"HTTP {response.status_code} from {url}", code="http_error")
+        try:
+            data = response.json()
+        except (json.JSONDecodeError, ValueError) as e:
+            raise OdooConnectionError(
+                f"{url} did not answer JSON-RPC (is this an Odoo server URL?)",
+                code="not_jsonrpc",
+            ) from e
+        if not isinstance(data, dict):
+            raise OdooConnectionError(f"{url} did not answer JSON-RPC", code="not_jsonrpc")
+        if "error" in data:
+            err = classify_rpc_error(data["error"])
+            logger.debug("!! %s id=%d %.1fms %s: %s", label, request_id, elapsed_ms, err.code, err)
+            raise err
+        logger.debug("<- %s id=%d %.1fms", label, request_id, elapsed_ms)
+        return data.get("result")
+
+    # ----- public API -----
+
+    async def version(self) -> dict[str, Any]:
+        """Server version info. Works without credentials."""
+        result = await self._rpc("common", "version", [])
+        return result if isinstance(result, dict) else {}
+
+    async def authenticate(self) -> int:
+        if self._uid is not None:
+            return self._uid
+        uid = await self._rpc(
+            "common", "authenticate", [self.database, self.login, self._api_key, {}]
+        )
+        if not isinstance(uid, int) or isinstance(uid, bool) or uid <= 0:
+            raise OdooAuthError(
+                f"Authentication failed for {self.login!r} on database {self.database!r}"
+            )
+        self._uid = uid
+        return uid
+
+    async def execute(self, model: str, method: str, *args: Any, **kwargs: Any) -> Any:
+        """``execute_kw`` with the client context merged into ``kwargs["context"]``."""
+        uid = await self.authenticate()
+        call_context = kwargs.pop("context", None) or {}
+        merged = {**self.context, **call_context}
+        if merged:
+            kwargs["context"] = merged
+        return await self._rpc(
+            "object",
+            "execute_kw",
+            [self.database, uid, self._api_key, model, method, list(args), kwargs],
+            retryable=is_read_safe_method(method),
+        )
+
+    @staticmethod
+    def _page_kwargs(
+        fields: list[str] | None, limit: int | None, offset: int, order: str | None
+    ) -> dict[str, Any]:
+        kwargs: dict[str, Any] = {}
+        if fields:
+            kwargs["fields"] = fields
+        if limit is not None:
+            kwargs["limit"] = limit
+        if offset:
+            kwargs["offset"] = offset
+        if order:
+            kwargs["order"] = order
+        return kwargs
+
+    async def search(
+        self,
+        model: str,
+        domain: Domain | None = None,
+        limit: int | None = None,
+        offset: int = 0,
+        order: str | None = None,
+    ) -> list[int]:
+        """Record ids matching ``domain``."""
+        kwargs = self._page_kwargs(None, limit, offset, order)
+        result = await self.execute(model, "search", domain or [], **kwargs)
+        return [int(i) for i in result] if isinstance(result, list) else []
+
+    async 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]]:
+        kwargs = self._page_kwargs(fields, limit, offset, order)
+        result = await self.execute(model, "search_read", domain or [], **kwargs)
+        return list(result) if isinstance(result, list) else []
+
+    async def search_count(self, model: str, domain: Domain | None = None) -> int:
+        result = await self.execute(model, "search_count", domain or [])
+        return int(result)
+
+    async def read(
+        self, model: str, ids: list[int], fields: list[str] | None = None
+    ) -> list[dict[str, Any]]:
+        kwargs: dict[str, Any] = {"fields": fields} if fields else {}
+        result = await self.execute(model, "read", ids, **kwargs)
+        return list(result) if isinstance(result, list) else []
+
+    async def create(self, model: str, values: dict[str, Any] | list[dict[str, Any]]) -> Any:
+        """Create one record (dict) or several (list of dicts). Returns id or ids."""
+        return await self.execute(model, "create", values)
+
+    async def write(self, model: str, ids: list[int], values: dict[str, Any]) -> bool:
+        return bool(await self.execute(model, "write", ids, values))
+
+    async def unlink(self, model: str, ids: list[int]) -> bool:
+        return bool(await self.execute(model, "unlink", ids))
+
+    async def fields_get(
+        self, model: str, attributes: list[str] | None = None
+    ) -> dict[str, dict[str, Any]]:
+        kwargs: dict[str, Any] = {"attributes": attributes} if attributes else {}
+        result = await self.execute(model, "fields_get", **kwargs)
+        return dict(result) if isinstance(result, dict) else {}

odoocli/config.py

@@ -0,0 +1,175 @@
+"""Profiles file and connection resolution. The only library module allowed to read env."""
+
+from __future__ import annotations
+
+import os
+import tomllib
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+import tomli_w
+
+from odoocli.errors import OdooConnectionError
+
+ENV_URL, ENV_DB, ENV_LOGIN, ENV_KEY = "ODOO_URL", "ODOO_DB", "ODOO_LOGIN", "ODOO_API_KEY"
+ENV_REQUIRED = (ENV_URL, ENV_DB, ENV_LOGIN, ENV_KEY)
+ENV_PROFILE = "ODOO_PROFILE"
+ENV_CONFIG = "ODOO_CONFIG"
+ENV_ALLOW_WRITES = "ODOO_ALLOW_WRITES"
+ENV_ALLOW_SENSITIVE = "ODOO_ALLOW_SENSITIVE"
+ENV_ASSUME_YES = "ODOO_ASSUME_YES"
+ENV_VERIFY_SSL = "ODOO_VERIFY_SSL"
+
+_TRUE = {"1", "true", "yes", "on"}
+_FALSE = {"0", "false", "no", "off"}
+
+NO_CONNECTION_HELP = (
+    "No Odoo connection configured. Use one of:\n"
+    "  1. odoo --profile NAME ... (or ODOO_PROFILE=NAME) after 'odoo profile add NAME ...'\n"
+    "  2. environment: ODOO_URL, ODOO_DB, ODOO_LOGIN, ODOO_API_KEY\n"
+    "  3. a profile named 'default' in the config file"
+)
+
+
+@dataclass(slots=True)
+class Profile:
+    name: str
+    url: str
+    database: str
+    login: str
+    api_key: str = field(repr=False)
+    allow_writes: bool = False
+    allow_sensitive: bool = False
+    verify_ssl: bool = True
+    source: str = "env"
+
+
+def env_flag(env: Mapping[str, str], name: str) -> bool:
+    return env.get(name, "").strip().lower() in _TRUE
+
+
+def env_flag_default_true(env: Mapping[str, str], name: str) -> bool:
+    return env.get(name, "").strip().lower() not in _FALSE
+
+
+def config_path(env: Mapping[str, str]) -> Path:
+    if env.get(ENV_CONFIG):
+        return Path(env[ENV_CONFIG]).expanduser()
+    base = env.get("XDG_CONFIG_HOME")
+    root = Path(base).expanduser() if base else Path.home() / ".config"
+    return root / "odoo-cli" / "config.toml"
+
+
+def _read(path: Path) -> dict[str, Any]:
+    if not path.exists():
+        return {}
+    with path.open("rb") as fh:
+        return tomllib.load(fh)
+
+
+def _write(path: Path, data: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    os.chmod(path.parent, 0o700)
+    tmp = path.with_suffix(".tmp")
+    with tmp.open("wb") as fh:
+        tomli_w.dump(data, fh)
+    os.chmod(tmp, 0o600)
+    os.replace(tmp, path)
+
+
+def load_profiles(path: Path) -> dict[str, dict[str, Any]]:
+    profiles = _read(path).get("profiles", {})
+    return {str(k): dict(v) for k, v in profiles.items() if isinstance(v, dict)}
+
+
+def save_profile(path: Path, name: str, data: dict[str, Any]) -> None:
+    doc = _read(path)
+    profiles = doc.setdefault("profiles", {})
+    profiles[name] = {k: v for k, v in data.items() if v is not None}
+    _write(path, doc)
+
+
+def remove_profile(path: Path, name: str) -> bool:
+    doc = _read(path)
+    profiles = doc.get("profiles", {})
+    if name not in profiles:
+        return False
+    del profiles[name]
+    _write(path, doc)
+    return True
+
+
+def profile_from_dict(name: str, data: Mapping[str, Any], env: Mapping[str, str]) -> Profile:
+    missing = [k for k in ("url", "database", "login") if not data.get(k)]
+    if missing:
+        raise OdooConnectionError(
+            f"Profile {name!r} is missing {', '.join(missing)}", code="invalid_profile"
+        )
+    api_key = data.get("api_key")
+    key_env = data.get("api_key_env")
+    if not api_key and key_env:
+        api_key = env.get(str(key_env))
+        if not api_key:
+            raise OdooConnectionError(
+                f"Profile {name!r} reads its key from ${key_env}, which is not set",
+                code="invalid_profile",
+            )
+    if not api_key:
+        raise OdooConnectionError(
+            f"Profile {name!r} has neither api_key nor api_key_env", code="invalid_profile"
+        )
+    return Profile(
+        name=name,
+        url=str(data["url"]),
+        database=str(data["database"]),
+        login=str(data["login"]),
+        api_key=str(api_key),
+        allow_writes=bool(data.get("allow_writes", False)),
+        allow_sensitive=bool(data.get("allow_sensitive", False)),
+        verify_ssl=bool(data.get("verify_ssl", True)),
+        source=f"profile:{name}",
+    )
+
+
+def _from_env(env: Mapping[str, str]) -> Profile:
+    return Profile(
+        name="env",
+        url=env[ENV_URL],
+        database=env[ENV_DB],
+        login=env[ENV_LOGIN],
+        api_key=env[ENV_KEY],
+        allow_writes=env_flag(env, ENV_ALLOW_WRITES),
+        allow_sensitive=env_flag(env, ENV_ALLOW_SENSITIVE),
+        verify_ssl=env_flag_default_true(env, ENV_VERIFY_SSL),
+        source="env",
+    )
+
+
+def resolve_profile(explicit: str | None, env: Mapping[str, str], path: Path) -> Profile:
+    """--profile > ODOO_PROFILE > ODOO_* env > profile 'default'. Never prompts."""
+    name = explicit or env.get(ENV_PROFILE) or None
+    if name:
+        profiles = load_profiles(path)
+        if name not in profiles:
+            raise OdooConnectionError(
+                f"Profile {name!r} not found in {path}. Run 'odoo profile add {name} ...'",
+                code="no_connection",
+            )
+        return profile_from_dict(name, profiles[name], env)
+
+    present = [k for k in ENV_REQUIRED if env.get(k)]
+    if present:
+        missing = [k for k in ENV_REQUIRED if not env.get(k)]
+        if missing:
+            raise OdooConnectionError(
+                f"Incomplete ODOO_* environment, missing: {', '.join(missing)}",
+                code="no_connection",
+            )
+        return _from_env(env)
+
+    profiles = load_profiles(path)
+    if "default" in profiles:
+        return profile_from_dict("default", profiles["default"], env)
+    raise OdooConnectionError(NO_CONNECTION_HELP, code="no_connection")

odoocli/domain.py

@@ -0,0 +1,208 @@
+"""Odoo domain helpers: normalisation, de-humanisation, safe field removal, -w DSL."""
+
+from __future__ import annotations
+
+import ast
+import json
+import re
+from typing import Any
+
+from odoocli.errors import OdooUsageError
+
+_BINARY_OPS = ("&", "|")
+_UNARY_OP = "!"
+# Trailing "(#42)" of a humanised many2one ("Name (#42)"), as produced by
+# LLM-facing layers. Recovered back to the int id when fed into a domain.
+_HUMANIZED_M2O_RE = re.compile(r"\(#(\d+)\)\s*$")
+_DROP = object()
+
+
+# ----- normalisation (ported from UpBoard's OdooConnector) -----
+
+
+def normalize_domain(domain: Any) -> list[Any]:
+    """Accept a list, a JSON string or a Python literal string; keep ``& | !``."""
+    if isinstance(domain, list):
+        out: list[Any] = []
+        for item in domain:
+            if isinstance(item, str) and item in ("|", "&", "!"):
+                out.append(item)
+            elif isinstance(item, str):
+                out.extend(normalize_domain(item))
+            else:
+                out.append(item)
+        return out
+    if isinstance(domain, str):
+        text = domain.strip()
+        if not text or text == "[]":
+            return []
+        parsed: Any = None
+        for parser in (json.loads, ast.literal_eval):
+            try:
+                parsed = parser(text)
+            except (ValueError, SyntaxError):
+                continue
+            if isinstance(parsed, list):
+                return parsed
+        raise OdooUsageError(f"Domain is neither JSON nor a Python list: {text[:80]!r}")
+    return []
+
+
+def _dehumanize(value: Any) -> Any:
+    if isinstance(value, str):
+        m = _HUMANIZED_M2O_RE.search(value)
+        return int(m.group(1)) if m else value
+    if isinstance(value, list | tuple):
+        return [_dehumanize(v) for v in value]
+    return value
+
+
+def sanitize_domain(domain: list[Any]) -> list[Any]:
+    """Turn ``"Name (#42)"`` operands on ``id``/``*_id``/``*_ids`` fields back into ints."""
+    out: list[Any] = []
+    for item in domain:
+        if isinstance(item, list | tuple) and len(item) == 3:
+            field, op, value = item
+            if isinstance(field, str) and (field == "id" or field.endswith(("_id", "_ids"))):
+                value = _dehumanize(value)
+            out.append([field, op, value])
+        else:
+            out.append(item)
+    return out
+
+
+# ----- safe field removal (used by lenient mode) -----
+
+
+def _is_leaf(term: Any) -> bool:
+    return isinstance(term, list | tuple) and len(term) == 3 and isinstance(term[0], str)
+
+
+def _parse(tokens: list[Any], pos: int) -> tuple[Any, int]:
+    tok = tokens[pos]
+    if tok in _BINARY_OPS:
+        left, pos = _parse(tokens, pos + 1)
+        right, pos = _parse(tokens, pos)
+        return ("op2", tok, left, right), pos
+    if tok == _UNARY_OP:
+        child, pos = _parse(tokens, pos + 1)
+        return ("not", child), pos
+    return ("leaf", tok), pos + 1
+
+
+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:
+            return _DROP
+        return [term]
+    if kind == "not":
+        child = _serialize(node[1], bad_field)
+        return _DROP if child is _DROP else [_UNARY_OP, *child]
+    _, operator, left_node, right_node = node
+    left = _serialize(left_node, bad_field)
+    right = _serialize(right_node, bad_field)
+    if left is _DROP and right is _DROP:
+        return _DROP
+    if left is _DROP:
+        return right
+    if right is _DROP:
+        return left
+    return [operator, *left, *right]
+
+
+def strip_field_from_domain(domain: Any, bad_field: str) -> Any:
+    """Remove every leaf on ``bad_field``; ``|``/``&`` fold onto the surviving operand."""
+    if not isinstance(domain, list) or not domain:
+        return domain
+    try:
+        cleaned: list[Any] = []
+        pos = 0
+        while pos < len(domain):
+            node, pos = _parse(domain, pos)
+            serialized = _serialize(node, bad_field)
+            if serialized is not _DROP:
+                cleaned.extend(serialized)
+        return cleaned
+    except (IndexError, TypeError):
+        # Malformed domain: leave it alone rather than risk a wrong filter.
+        return domain
+
+
+# ----- -w DSL -----
+
+_WORD_OPS = (
+    "not in",
+    "in",
+    "not ilike",
+    "ilike",
+    "not like",
+    "like",
+    "=like",
+    "=ilike",
+    "child_of",
+    "parent_of",
+    "not any",
+    "any",
+)
+_WORD_RE = re.compile(
+    r"^\s*([A-Za-z_][\w.]*)\s+(" + "|".join(re.escape(o) for o in _WORD_OPS) + r")\s+(.*?)\s*$"
+)
+_SYMBOL_RE = re.compile(r"^\s*([A-Za-z_][\w.]*)\s*(>=|<=|!=|!~|=|>|<|~)\s*(.*?)\s*$")
+_SYMBOL_MAP = {"~": "ilike", "!~": "not ilike"}
+_LIST_OPS = {"in", "not in"}
+
+
+def parse_value(raw: str) -> Any:
+    """Scalar parsing for -w and -v: quotes, booleans, null, JSON, numbers, else text."""
+    text = raw.strip()
+    if len(text) >= 2 and text[0] == text[-1] and text[0] in "'\"":
+        return text[1:-1]
+    lowered = text.lower()
+    if lowered in ("true", "yes"):
+        return True
+    if lowered in ("false", "no", "null", "none"):
+        return False
+    if text[:1] in "[{":
+        try:
+            return json.loads(text)
+        except ValueError as e:
+            raise OdooUsageError(f"Invalid JSON value: {text[:80]!r}") from e
+    try:
+        return int(text)
+    except ValueError:
+        pass
+    try:
+        return float(text)
+    except ValueError:
+        pass
+    return text
+
+
+def parse_where(expr: str) -> list[Any]:
+    """``field op value`` to one Odoo leaf. ``~`` is ilike, ``!~`` is not ilike."""
+    m = _WORD_RE.match(expr) or _SYMBOL_RE.match(expr)
+    if not m:
+        raise OdooUsageError(
+            f"Cannot parse condition {expr!r}. Expected 'field=value', 'field>=10', "
+            "'field~text', 'field in a,b' or 'field not in a,b'."
+        )
+    field, op, raw = m.group(1), m.group(2), m.group(3)
+    op = _SYMBOL_MAP.get(op, op)
+    value: Any
+    if op in _LIST_OPS:
+        value = (
+            parse_value(raw) if raw.startswith("[") else [parse_value(v) for v in raw.split(",")]
+        )
+        if not isinstance(value, list):
+            raise OdooUsageError(f"'{op}' needs a list, got {raw!r}")
+    else:
+        value = parse_value(raw)
+    return [field, op, value]
+
+
+def build_domain(domain: str | None, where: list[str]) -> list[Any]:
+    """AND a JSON domain (optional) with every ``-w`` condition."""
+    base = sanitize_domain(normalize_domain(domain)) if domain else []
+    return base + [parse_where(w) for w in where]