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

odoocli/cli/read_cmds.py

@@ -0,0 +1,223 @@
+"""Read-only commands: info, models, fields, search, count, read."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import typer
+
+from odoocli.cli.app import app, check_model, emit, run, session, warn
+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
+from odoocli.lenient import lenient_search_read
+
+DEFAULT_LIMIT = 80
+PAGE_SIZE = 200
+FIELD_ATTRIBUTES = ["string", "type", "required", "readonly", "store", "relation", "selection"]
+
+WhereOpt = typer.Option(
+    [], "--where", "-w", help="Condition 'field op value'. Repeatable, AND-ed together."
+)
+DomainOpt = typer.Option(None, "--domain", "-d", help="Odoo domain as JSON, AND-ed with -w.")
+FieldsOpt = typer.Option(None, "--fields", help="Comma-separated field names.")
+
+
+@app.command()
+def info(
+    ctx: typer.Context,
+    modules: bool = typer.Option(False, "--modules", help="Also list installed module names."),
+) -> None:
+    """Server version, authenticated uid and connection source. Use it to test a connection."""
+
+    async def go(client: AsyncOdooClient, profile: Profile) -> dict[str, Any]:
+        version = await client.version()
+        uid = await client.authenticate()
+        out: dict[str, Any] = {
+            "url": profile.url,
+            "database": profile.database,
+            "login": profile.login,
+            "uid": uid,
+            "source": profile.source,
+            "allow_writes": profile.allow_writes,
+            "server_version": version.get("server_version"),
+            "server_version_info": version.get("server_version_info"),
+        }
+        if modules:
+            rows = await client.search_read(
+                "ir.module.module", [["state", "=", "installed"]], ["name"], limit=2000
+            )
+            out["modules"] = sorted(r["name"] for r in rows if r.get("name"))
+        return out
+
+    emit(ctx, run(ctx, go))
+
+
+@app.command()
+def models(
+    ctx: typer.Context,
+    like: str | None = typer.Option(None, "--like", help="Substring of the technical name."),
+    where: list[str] = WhereOpt,
+) -> None:
+    """List models (technical name, label, transient)."""
+
+    async def go(client: AsyncOdooClient, _profile: Profile) -> list[dict[str, Any]]:
+        domain = build_domain(None, where)
+        if like:
+            domain.append(["model", "ilike", like])
+        return await client.search_read(
+            "ir.model", domain, ["model", "name", "transient"], order="model"
+        )
+
+    emit(ctx, run(ctx, go))
+
+
+@app.command()
+def fields(
+    ctx: typer.Context,
+    model: str = typer.Argument(..., help="Technical model name, e.g. res.partner"),
+    type_: str | None = typer.Option(None, "--type", help="Keep only this field type."),
+    stored: bool = typer.Option(
+        False, "--stored", help="Keep only stored fields (searchable and orderable)."
+    ),
+    search: str | None = typer.Option(None, "--search", help="Substring of the name or label."),
+    all_attributes: bool = typer.Option(
+        False, "--all-attributes", help="Return every attribute Odoo has, not the curated set."
+    ),
+) -> None:
+    """Introspect a model: field types, required, store, relation, selection values."""
+    sess = session(ctx)
+
+    async def go(client: AsyncOdooClient, profile: Profile) -> dict[str, dict[str, Any]]:
+        check_model(sess, profile, model)
+        return await client.fields_get(model, None if all_attributes else FIELD_ATTRIBUTES)
+
+    data = run(ctx, go)
+    needle = search.lower() if search else None
+    out = {
+        name: info
+        for name, info in data.items()
+        if (type_ is None or info.get("type") == type_)
+        and (not stored or bool(info.get("store")))
+        and (
+            needle is None
+            or needle in name.lower()
+            or needle in str(info.get("string", "")).lower()
+        )
+    }
+    rows = [
+        {
+            "field": name,
+            "type": info.get("type"),
+            "label": info.get("string"),
+            "required": info.get("required", False),
+            "store": info.get("store", False),
+            "relation": info.get("relation", ""),
+        }
+        for name, info in out.items()
+    ]
+    emit(ctx, out, table_rows=rows)
+
+
+@app.command()
+def search(
+    ctx: typer.Context,
+    model: str = typer.Argument(..., help="Technical model name"),
+    where: list[str] = WhereOpt,
+    domain: str | None = DomainOpt,
+    fields_: str | None = FieldsOpt,
+    limit: int | None = typer.Option(
+        None, "--limit", "-l", help=f"Max records (default {DEFAULT_LIMIT})."
+    ),
+    offset: int = typer.Option(0, "--offset"),
+    order: str | None = typer.Option(None, "--order", help='e.g. "date_order desc, id"'),
+    all_: bool = typer.Option(
+        False, "--all", help="Fetch every match, paginated. Prefer --format jsonl."
+    ),
+    lenient: bool = typer.Option(
+        False, "--lenient-fields", help="Drop fields Odoo rejects and retry (warns on stderr)."
+    ),
+    ids_only: bool = typer.Option(
+        False, "--ids-only", help="Return matching ids only (ORM search instead of search_read)."
+    ),
+) -> None:
+    """search_read on a model. Output is the raw Odoo result."""
+    sess = session(ctx)
+
+    async def fetch(
+        client: AsyncOdooClient, dom: list[Any], flds: list[str] | None, lim: int | None, off: int
+    ) -> list[dict[str, Any]]:
+        if lenient:
+            return await lenient_search_read(
+                client, model, dom, flds, lim, off, order, on_warning=warn
+            )
+        return await client.search_read(model, dom, flds, lim, off, order)
+
+    async def go(client: AsyncOdooClient, profile: Profile) -> list[Any]:
+        check_model(sess, profile, model)
+        dom = build_domain(domain, where)
+        flds = split_fields(fields_)
+        if ids_only:
+            return await client.search(
+                model,
+                dom,
+                None if all_ else (DEFAULT_LIMIT if limit is None else limit),
+                offset,
+                order,
+            )
+        if not all_:
+            return await fetch(client, dom, flds, DEFAULT_LIMIT if limit is None else limit, offset)
+        rows: list[dict[str, Any]] = []
+        off = offset
+        while True:
+            page = await fetch(client, dom, flds, PAGE_SIZE, off)
+            rows.extend(page)
+            if len(page) < PAGE_SIZE:
+                return rows
+            off += PAGE_SIZE
+
+    emit(ctx, run(ctx, go))
+
+
+@app.command()
+def count(
+    ctx: typer.Context,
+    model: str = typer.Argument(...),
+    where: list[str] = WhereOpt,
+    domain: str | None = DomainOpt,
+) -> None:
+    """search_count on a model. Prints a bare integer."""
+    sess = session(ctx)
+
+    async def go(client: AsyncOdooClient, profile: Profile) -> int:
+        check_model(sess, profile, model)
+        return await client.search_count(model, build_domain(domain, where))
+
+    emit(ctx, run(ctx, go))
+
+
+@app.command()
+def read(
+    ctx: typer.Context,
+    model: str = typer.Argument(...),
+    ids: list[str] = typer.Argument(..., help="Record ids, space or comma separated."),
+    fields_: str | None = FieldsOpt,
+) -> None:
+    """Read records by id. Exit 1 (missing_record) if any id is missing or not visible."""
+    sess = session(ctx)
+
+    async def go(client: AsyncOdooClient, profile: Profile) -> list[dict[str, Any]]:
+        check_model(sess, profile, model)
+        id_list = parse_ids(ids)
+        rows = await client.read(model, id_list, split_fields(fields_))
+        missing = [i for i in id_list if i not in {r.get("id") for r in rows}]
+        if missing:
+            raise OdooMissingError(
+                f"{model} records not found or not visible: {missing}",
+                data={"missing_ids": missing, "records": rows},
+            )
+        return rows
+
+    emit(ctx, run(ctx, go))

odoocli/cli/values.py

@@ -0,0 +1,51 @@
+"""Parsing of -v key=value pairs, id lists and JSON arguments."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from odoocli.domain import parse_value
+from odoocli.errors import OdooUsageError
+
+
+def parse_ids(tokens: list[str]) -> list[int]:
+    ids: list[int] = []
+    for tok in tokens:
+        for part in tok.split(","):
+            part = part.strip()
+            if not part:
+                continue
+            try:
+                ids.append(int(part))
+            except ValueError as e:
+                raise OdooUsageError(f"Record id must be an integer, got {part!r}") from e
+    if not ids:
+        raise OdooUsageError("At least one record id is required")
+    return ids
+
+
+def parse_kv(pairs: list[str]) -> dict[str, Any]:
+    out: dict[str, Any] = {}
+    for pair in pairs:
+        key, sep, raw = pair.partition("=")
+        if not sep or not key.strip():
+            raise OdooUsageError(f"Expected key=value, got {pair!r}")
+        out[key.strip()] = parse_value(raw)
+    return out
+
+
+def parse_json_arg(text: str | None, kind: str) -> Any:
+    if text is None or not text.strip():
+        return None
+    try:
+        return json.loads(text)
+    except ValueError as e:
+        raise OdooUsageError(f"--{kind} must be valid JSON: {e}") from e
+
+
+def split_fields(text: str | None) -> list[str] | None:
+    if text is None:
+        return None
+    fields = [f.strip() for f in text.split(",") if f.strip()]
+    return fields or None

odoocli/cli/write_cmds.py

@@ -0,0 +1,178 @@
+"""Write commands, all behind allow_writes; unlink and non read-safe call also need --yes."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import typer
+
+from odoocli.cli.app import (
+    app,
+    check_model,
+    emit,
+    require_writes,
+    require_yes,
+    run,
+    session,
+    warn,
+)
+from odoocli.cli.values import parse_ids, parse_json_arg, parse_kv
+from odoocli.client import AsyncOdooClient
+from odoocli.config import Profile
+from odoocli.errors import OdooUsageError
+from odoocli.security import is_read_safe_method
+
+ValuesOpt = typer.Option(
+    [], "--value", "-v", help="field=value. Repeatable. Overrides keys from --values."
+)
+JsonValuesOpt = typer.Option(None, "--values", help="Values as a JSON object.")
+DryRunOpt = typer.Option(False, "--dry-run", help="Print the payload, call nothing, exit 0.")
+YesOpt = typer.Option(False, "--yes", "-y", help="Confirm a destructive or arbitrary call.")
+
+# Sentinel returned by a dry run so the command prints nothing more.
+_DRY = object()
+
+
+def _merge_values(pairs: list[str], json_values: str | None) -> dict[str, Any]:
+    base = parse_json_arg(json_values, "values") or {}
+    if not isinstance(base, dict):
+        raise OdooUsageError("--values must be a JSON object")
+    base.update(parse_kv(pairs))
+    if not base:
+        raise OdooUsageError("No values given. Use -v field=value or --values '{...}'.")
+    return base
+
+
+def _dry_run(
+    ctx: typer.Context, model: str, method: str, args: list[Any], kwargs: dict[str, Any]
+) -> object:
+    emit(ctx, {"dry_run": True, "model": model, "method": method, "args": args, "kwargs": kwargs})
+    return _DRY
+
+
+def _log_write(model: str, method: str, ids: list[int], fields: list[str]) -> None:
+    warn({"write": {"model": model, "method": method, "ids": ids, "fields": fields}})
+
+
+def _emit_unless_dry(ctx: typer.Context, result: Any) -> None:
+    if result is not _DRY:
+        emit(ctx, result)
+
+
+@app.command()
+def create(
+    ctx: typer.Context,
+    model: str = typer.Argument(...),
+    values: list[str] = ValuesOpt,
+    json_values: str | None = JsonValuesOpt,
+    dry_run: bool = DryRunOpt,
+) -> None:
+    """Create one record. Prints the new id."""
+    sess = session(ctx)
+
+    async def go(client: AsyncOdooClient, profile: Profile) -> Any:
+        check_model(sess, profile, model)
+        vals = _merge_values(values, json_values)
+        if dry_run:
+            return _dry_run(ctx, model, "create", [vals], {})
+        require_writes(profile)
+        new_id = await client.create(model, vals)
+        ids = [new_id] if isinstance(new_id, int) else list(new_id)
+        _log_write(model, "create", ids, sorted(vals))
+        return new_id
+
+    _emit_unless_dry(ctx, run(ctx, go))
+
+
+@app.command()
+def write(
+    ctx: typer.Context,
+    model: str = typer.Argument(...),
+    ids: list[str] = typer.Argument(..., help="Record ids, space or comma separated."),
+    values: list[str] = ValuesOpt,
+    json_values: str | None = JsonValuesOpt,
+    dry_run: bool = DryRunOpt,
+) -> None:
+    """Update records. Prints true."""
+    sess = session(ctx)
+
+    async def go(client: AsyncOdooClient, profile: Profile) -> Any:
+        check_model(sess, profile, model)
+        id_list = parse_ids(ids)
+        vals = _merge_values(values, json_values)
+        if dry_run:
+            return _dry_run(ctx, model, "write", [id_list, vals], {})
+        require_writes(profile)
+        ok = await client.write(model, id_list, vals)
+        _log_write(model, "write", id_list, sorted(vals))
+        return ok
+
+    _emit_unless_dry(ctx, run(ctx, go))
+
+
+@app.command()
+def unlink(
+    ctx: typer.Context,
+    model: str = typer.Argument(...),
+    ids: list[str] = typer.Argument(..., help="Record ids, space or comma separated."),
+    yes: bool = YesOpt,
+    dry_run: bool = DryRunOpt,
+) -> None:
+    """Delete records. Needs allow_writes and --yes."""
+    sess = session(ctx)
+
+    async def go(client: AsyncOdooClient, profile: Profile) -> Any:
+        check_model(sess, profile, model)
+        id_list = parse_ids(ids)
+        if dry_run:
+            return _dry_run(ctx, model, "unlink", [id_list], {})
+        require_writes(profile)
+        require_yes(sess, yes, f"Deleting {len(id_list)} {model} record(s)")
+        ok = await client.unlink(model, id_list)
+        _log_write(model, "unlink", id_list, [])
+        return ok
+
+    _emit_unless_dry(ctx, run(ctx, go))
+
+
+@app.command()
+def call(
+    ctx: typer.Context,
+    model: str = typer.Argument(...),
+    method: str = typer.Argument(
+        ..., help="Any model method, e.g. action_confirm, name_search, read_group"
+    ),
+    ids: str | None = typer.Option(
+        None, "--ids", help="Record ids (comma separated), prepended as the first positional arg."
+    ),
+    args: str | None = typer.Option(None, "--args", help="Positional args as a JSON list."),
+    kwargs: str | None = typer.Option(None, "--kwargs", help="Keyword args as a JSON object."),
+    yes: bool = YesOpt,
+    dry_run: bool = DryRunOpt,
+) -> None:
+    """Call a model method through execute_kw. Read-only methods need no guard."""
+    sess = session(ctx)
+
+    async def go(client: AsyncOdooClient, profile: Profile) -> Any:
+        check_model(sess, profile, model)
+        pos = parse_json_arg(args, "args") or []
+        if not isinstance(pos, list):
+            raise OdooUsageError("--args must be a JSON list")
+        kw = parse_json_arg(kwargs, "kwargs") or {}
+        if not isinstance(kw, dict):
+            raise OdooUsageError("--kwargs must be a JSON object")
+        id_list = parse_ids([ids]) if ids else []
+        if id_list:
+            pos = [id_list, *pos]
+        if dry_run:
+            return _dry_run(ctx, model, method, pos, kw)
+        mutating = not is_read_safe_method(method)
+        if mutating:
+            require_writes(profile)
+            require_yes(sess, yes, f"Calling {model}.{method}")
+        result = await client.execute(model, method, *pos, **kw)
+        if mutating:
+            _log_write(model, method, id_list, [])
+        return result
+
+    _emit_unless_dry(ctx, run(ctx, go))