Base Operations

Shared CRUD, messaging, attachment, and display helpers. The DomainNamespace base class provides common methods inherited by all domain namespace classes.

base

Base operations for Odoo models - shared functionality.

mask_binary_fields

mask_binary_fields(records: list[dict[str, Any]], binary_fields: set[str]) -> list[dict[str, Any]]

Replace binary field values with a human-readable size summary.

Binary fields in Odoo are returned as base64-encoded strings which can be very large and flood terminal output. This function replaces them with a placeholder like <binary 14.2 KB>.

PARAMETER	DESCRIPTION
records	List of record dictionaries (modified in place and returned). TYPE: list[dict[str, Any]]
binary_fields	Set of field names known to be binary. TYPE: set[str]

RETURNS	DESCRIPTION
list[dict[str, Any]]	The same list with binary values replaced by summary strings.

Source code in src/vodoo/base.py

def mask_binary_fields(
    records: list[dict[str, Any]],
    binary_fields: set[str],
) -> list[dict[str, Any]]:
    """Replace binary field values with a human-readable size summary.

    Binary fields in Odoo are returned as base64-encoded strings which can be
    very large and flood terminal output.  This function replaces them with a
    placeholder like ``<binary 14.2 KB>``.

    Args:
        records: List of record dictionaries (modified in place and returned).
        binary_fields: Set of field names known to be binary.

    Returns:
        The same list with binary values replaced by summary strings.
    """
    for record in records:
        for fname in binary_fields:
            val = record.get(fname)
            if isinstance(val, str) and val:
                raw_bytes = len(val) * 3 // 4  # approximate decoded size
                if raw_bytes < 1024:
                    size_str = f"{raw_bytes} B"
                elif raw_bytes < 1024 * 1024:
                    size_str = f"{raw_bytes / 1024:.1f} KB"
                else:
                    size_str = f"{raw_bytes / (1024 * 1024):.1f} MB"
                record[fname] = f"<binary {size_str}>"
    return records

detect_binary_fields

detect_binary_fields(client: OdooClient, model: str, field_names: list[str] | None = None) -> set[str]

Return the set of field names that are binary type.

PARAMETER	DESCRIPTION
client	Odoo client TYPE: OdooClient
model	Model name TYPE: str
field_names	If given, only check these fields. Otherwise check all. TYPE: list[str] | None DEFAULT: None

RETURNS	DESCRIPTION
set[str]	Set of field names with type binary.

Source code in src/vodoo/base.py

def detect_binary_fields(
    client: OdooClient,
    model: str,
    field_names: list[str] | None = None,
) -> set[str]:
    """Return the set of field names that are binary type.

    Args:
        client: Odoo client
        model: Model name
        field_names: If given, only check these fields. Otherwise check all.

    Returns:
        Set of field names with type ``binary``.
    """
    fields_info = client.fields_get(model, fields=field_names, attributes=["type"])
    return {name for name, info in fields_info.items() if info.get("type") == "binary"}

save_binary_field

save_binary_field(data: str, output: Path) -> Path

Decode a base64 binary field value and save to a file.

PARAMETER	DESCRIPTION
data	Base64-encoded string from Odoo. TYPE: str
output	Destination file path. TYPE: Path

RETURNS	DESCRIPTION
Path	The resolved output path.

Source code in src/vodoo/base.py

def save_binary_field(data: str, output: Path) -> Path:
    """Decode a base64 binary field value and save to a file.

    Args:
        data: Base64-encoded string from Odoo.
        output: Destination file path.

    Returns:
        The resolved output path.
    """
    output.parent.mkdir(parents=True, exist_ok=True)
    output.write_bytes(base64.b64decode(data))
    return output.resolve()

list_records

list_records(client: OdooClient, model: str, domain: list[Any] | None = None, limit: int | None = 50, fields: list[str] | None = None, order: str = 'create_date desc') -> list[dict[str, Any]]

List records from a model.

PARAMETER	DESCRIPTION
client	Odoo client TYPE: OdooClient
model	Model name (e.g., 'helpdesk.ticket', 'project.task') TYPE: str
domain	Search domain filters TYPE: list[Any] | None DEFAULT: None
limit	Maximum number of records TYPE: int | None DEFAULT: 50
fields	List of fields to fetch (None = default fields) TYPE: list[str] | None DEFAULT: None
order	Sort order TYPE: str DEFAULT: 'create_date desc'

RETURNS	DESCRIPTION
list[dict[str, Any]]	List of record dictionaries

Source code in src/vodoo/base.py

def list_records(
    client: OdooClient,
    model: str,
    domain: list[Any] | None = None,
    limit: int | None = 50,
    fields: list[str] | None = None,
    order: str = "create_date desc",
) -> list[dict[str, Any]]:
    """List records from a model.

    Args:
        client: Odoo client
        model: Model name (e.g., 'helpdesk.ticket', 'project.task')
        domain: Search domain filters
        limit: Maximum number of records
        fields: List of fields to fetch (None = default fields)
        order: Sort order

    Returns:
        List of record dictionaries

    """
    return client.search_read(
        model,
        domain=domain,
        fields=fields,
        limit=limit,
        order=order,
    )

get_record

get_record(client: OdooClient, model: str, record_id: int, fields: list[str] | None = None) -> dict[str, Any]

Get detailed record information.

PARAMETER	DESCRIPTION
client	Odoo client TYPE: OdooClient
model	Model name TYPE: str
record_id	Record ID TYPE: int
fields	List of field names to read (None = all fields) TYPE: list[str] | None DEFAULT: None

RETURNS	DESCRIPTION
dict[str, Any]	Record dictionary

RAISES	DESCRIPTION
RecordNotFoundError	If record not found

Source code in src/vodoo/base.py

def get_record(
    client: OdooClient,
    model: str,
    record_id: int,
    fields: list[str] | None = None,
) -> dict[str, Any]:
    """Get detailed record information.

    Args:
        client: Odoo client
        model: Model name
        record_id: Record ID
        fields: List of field names to read (None = all fields)

    Returns:
        Record dictionary

    Raises:
        RecordNotFoundError: If record not found

    """
    records = client.read(model, [record_id], fields=fields)
    if not records:
        raise RecordNotFoundError(model, record_id)
    return records[0]

list_fields

list_fields(client: OdooClient, model: str) -> dict[str, Any]

Get all available fields for a model.

PARAMETER	DESCRIPTION
client	Odoo client TYPE: OdooClient
model	Model name TYPE: str

RETURNS	DESCRIPTION
dict[str, Any]	Dictionary of field definitions with field names as keys

Source code in src/vodoo/base.py

def list_fields(client: OdooClient, model: str) -> dict[str, Any]:
    """Get all available fields for a model.

    Args:
        client: Odoo client
        model: Model name

    Returns:
        Dictionary of field definitions with field names as keys

    """
    return client.fields_get(model)

set_record_fields

set_record_fields(client: OdooClient, model: str, record_id: int, values: dict[str, Any]) -> bool

Update fields on a record.

PARAMETER	DESCRIPTION
client	Odoo client TYPE: OdooClient
model	Model name TYPE: str
record_id	Record ID TYPE: int
values	Dictionary of field names and values to update TYPE: dict[str, Any]

RETURNS	DESCRIPTION
bool	True if successful

Examples:

>>> set_record_fields(client, "project.task", 42, {"name": "New title", "priority": "1"})
>>> set_record_fields(client, "helpdesk.ticket", 42, {"user_id": 5, "stage_id": 3})

Source code in src/vodoo/base.py

def set_record_fields(
    client: OdooClient,
    model: str,
    record_id: int,
    values: dict[str, Any],
) -> bool:
    """Update fields on a record.

    Args:
        client: Odoo client
        model: Model name
        record_id: Record ID
        values: Dictionary of field names and values to update

    Returns:
        True if successful

    Examples:
        >>> set_record_fields(client, "project.task", 42, {"name": "New title", "priority": "1"})
        >>> set_record_fields(client, "helpdesk.ticket", 42, {"user_id": 5, "stage_id": 3})

    """
    return client.write(model, [record_id], values)

add_comment

add_comment(client: OdooClient, model: str, record_id: int, message: str, user_id: int | None = None, markdown: bool = True) -> bool

Add a comment to a record (visible to customers).

user_id requests displayed author attribution only. Cross-user attribution requires an internal authenticated user; Odoo may reject or override it for share users, which can reliably attribute only to their own partner.

PARAMETER	DESCRIPTION
client	Odoo client TYPE: OdooClient
model	Model name TYPE: str
record_id	Record ID TYPE: int
message	Comment message (plain text or markdown) TYPE: str
user_id	User whose partner is requested as author (uses default if None) TYPE: int | None DEFAULT: None
markdown	If True, convert markdown to HTML (default: True) TYPE: bool DEFAULT: True

RETURNS	DESCRIPTION
bool	True if successful

Source code in src/vodoo/base.py

def add_comment(
    client: OdooClient,
    model: str,
    record_id: int,
    message: str,
    user_id: int | None = None,
    markdown: bool = True,
) -> bool:
    """Add a comment to a record (visible to customers).

    ``user_id`` requests displayed author attribution only. Cross-user attribution
    requires an internal authenticated user; Odoo may reject or override it for share
    users, which can reliably attribute only to their own partner.

    Args:
        client: Odoo client
        model: Model name
        record_id: Record ID
        message: Comment message (plain text or markdown)
        user_id: User whose partner is requested as author (uses default if None)
        markdown: If True, convert markdown to HTML (default: True)

    Returns:
        True if successful

    """
    body = _convert_to_html(message, markdown)
    return message_post_sudo(
        client,
        model,
        record_id,
        body,
        user_id=user_id,
        is_note=False,
    )

add_note

add_note(client: OdooClient, model: str, record_id: int, message: str, user_id: int | None = None, markdown: bool = True) -> bool

Add an internal note to a record (not visible to customers).

user_id requests displayed author attribution only. Cross-user attribution requires an internal authenticated user; Odoo may reject or override it for share users, which can reliably attribute only to their own partner.

PARAMETER	DESCRIPTION
client	Odoo client TYPE: OdooClient
model	Model name TYPE: str
record_id	Record ID TYPE: int
message	Note message (plain text or markdown) TYPE: str
user_id	User whose partner is requested as author (uses default if None) TYPE: int | None DEFAULT: None
markdown	If True, convert markdown to HTML (default: True) TYPE: bool DEFAULT: True

RETURNS	DESCRIPTION
bool	True if successful

Source code in src/vodoo/base.py

def add_note(
    client: OdooClient,
    model: str,
    record_id: int,
    message: str,
    user_id: int | None = None,
    markdown: bool = True,
) -> bool:
    """Add an internal note to a record (not visible to customers).

    ``user_id`` requests displayed author attribution only. Cross-user attribution
    requires an internal authenticated user; Odoo may reject or override it for share
    users, which can reliably attribute only to their own partner.

    Args:
        client: Odoo client
        model: Model name
        record_id: Record ID
        message: Note message (plain text or markdown)
        user_id: User whose partner is requested as author (uses default if None)
        markdown: If True, convert markdown to HTML (default: True)

    Returns:
        True if successful

    """
    body = _convert_to_html(message, markdown)
    return message_post_sudo(
        client,
        model,
        record_id,
        body,
        user_id=user_id,
        is_note=True,
    )

list_tags

list_tags(client: OdooClient, model: str) -> list[dict[str, Any]]

List available tags for a model.

PARAMETER	DESCRIPTION
client	Odoo client TYPE: OdooClient
model	Tag model name (e.g., 'helpdesk.tag', 'project.tags') TYPE: str

RETURNS	DESCRIPTION
list[dict[str, Any]]	List of tag dictionaries

Source code in src/vodoo/base.py

def list_tags(client: OdooClient, model: str) -> list[dict[str, Any]]:
    """List available tags for a model.

    Args:
        client: Odoo client
        model: Tag model name (e.g., 'helpdesk.tag', 'project.tags')

    Returns:
        List of tag dictionaries

    """
    fields = _TAG_FIELDS
    return client.search_read(model, fields=fields, order="name")

add_tag_to_record

add_tag_to_record(client: OdooClient, model: str, record_id: int, tag_id: int) -> bool

Add a tag to a record.

PARAMETER	DESCRIPTION
client	Odoo client TYPE: OdooClient
model	Model name TYPE: str
record_id	Record ID TYPE: int
tag_id	Tag ID TYPE: int

RETURNS	DESCRIPTION
bool	True if successful

Source code in src/vodoo/base.py

def add_tag_to_record(
    client: OdooClient,
    model: str,
    record_id: int,
    tag_id: int,
) -> bool:
    """Add a tag to a record.

    Args:
        client: Odoo client
        model: Model name
        record_id: Record ID
        tag_id: Tag ID

    Returns:
        True if successful

    """
    record = get_record(client, model, record_id, fields=["tag_ids"])
    current_tags = record.get("tag_ids", [])

    # Add new tag if not already present
    if tag_id not in current_tags:
        current_tags.append(tag_id)
        return client.write(
            model,
            [record_id],
            {"tag_ids": [(6, 0, current_tags)]},
        )

    return True

list_messages

list_messages(client: OdooClient, model: str, record_id: int, limit: int | None = None) -> list[dict[str, Any]]

List messages/chatter for a record.

PARAMETER	DESCRIPTION
client	Odoo client TYPE: OdooClient
model	Model name TYPE: str
record_id	Record ID TYPE: int
limit	Maximum number of messages (None = all) TYPE: int | None DEFAULT: None

RETURNS	DESCRIPTION
list[dict[str, Any]]	List of message dictionaries

Source code in src/vodoo/base.py

def list_messages(
    client: OdooClient,
    model: str,
    record_id: int,
    limit: int | None = None,
) -> list[dict[str, Any]]:
    """List messages/chatter for a record.

    Args:
        client: Odoo client
        model: Model name
        record_id: Record ID
        limit: Maximum number of messages (None = all)

    Returns:
        List of message dictionaries

    """
    domain = [
        ("model", "=", model),
        ("res_id", "=", record_id),
    ]
    fields = _MESSAGE_FIELDS

    return client.search_read(
        "mail.message",
        domain=domain,
        fields=fields,
        order="date desc",
        limit=limit,
    )

list_attachments

list_attachments(client: OdooClient, model: str, record_id: int) -> list[dict[str, Any]]

List attachments for a record.

PARAMETER	DESCRIPTION
client	Odoo client TYPE: OdooClient
model	Model name TYPE: str
record_id	Record ID TYPE: int

RETURNS	DESCRIPTION
list[dict[str, Any]]	List of attachment dictionaries

Source code in src/vodoo/base.py

def list_attachments(
    client: OdooClient,
    model: str,
    record_id: int,
) -> list[dict[str, Any]]:
    """List attachments for a record.

    Args:
        client: Odoo client
        model: Model name
        record_id: Record ID

    Returns:
        List of attachment dictionaries

    """
    domain = [
        ("res_model", "=", model),
        ("res_id", "=", record_id),
    ]
    fields = _ATTACHMENT_LIST_FIELDS

    return client.search_read("ir.attachment", domain=domain, fields=fields)

download_attachment

download_attachment(client: OdooClient, attachment_id: int, output_path: Path | None = None) -> Path

Download an attachment.

PARAMETER	DESCRIPTION
client	Odoo client TYPE: OdooClient
attachment_id	Attachment ID TYPE: int
output_path	Output file path (defaults to attachment name in current dir) TYPE: Path | None DEFAULT: None

RETURNS	DESCRIPTION
Path	Path to downloaded file

RAISES	DESCRIPTION
RecordNotFoundError	If attachment not found

Source code in src/vodoo/base.py

def download_attachment(
    client: OdooClient,
    attachment_id: int,
    output_path: Path | None = None,
) -> Path:
    """Download an attachment.

    Args:
        client: Odoo client
        attachment_id: Attachment ID
        output_path: Output file path (defaults to attachment name in current dir)

    Returns:
        Path to downloaded file

    Raises:
        RecordNotFoundError: If attachment not found

    """
    attachments = client.read("ir.attachment", [attachment_id], _ATTACHMENT_READ_FIELDS)

    if not attachments:
        raise RecordNotFoundError("ir.attachment", attachment_id)

    attachment = attachments[0]
    filename = attachment.get("name", f"attachment_{attachment_id}")

    if output_path is None:
        output_path = Path.cwd() / filename
    elif output_path.is_dir():
        output_path = output_path / filename

    # Decode base64 data and write to file
    if attachment.get("datas"):
        data = base64.b64decode(attachment["datas"])
        output_path.write_bytes(data)
    else:
        raise RecordNotFoundError("ir.attachment", attachment_id)

    return output_path

download_record_attachments

download_record_attachments(client: OdooClient, model: str, record_id: int, output_dir: Path | None = None, extension: str | None = None) -> list[Path]

Download all attachments for a record.

PARAMETER	DESCRIPTION
client	Odoo client TYPE: OdooClient
model	Model name TYPE: str
record_id	Record ID TYPE: int
output_dir	Output directory (defaults to current directory) TYPE: Path | None DEFAULT: None
extension	File extension filter (e.g., 'pdf', 'jpg') TYPE: str | None DEFAULT: None

RETURNS	DESCRIPTION
list[Path]	List of paths to downloaded files

Source code in src/vodoo/base.py

def download_record_attachments(
    client: OdooClient,
    model: str,
    record_id: int,
    output_dir: Path | None = None,
    extension: str | None = None,
) -> list[Path]:
    """Download all attachments for a record.

    Args:
        client: Odoo client
        model: Model name
        record_id: Record ID
        output_dir: Output directory (defaults to current directory)
        extension: File extension filter (e.g., 'pdf', 'jpg')

    Returns:
        List of paths to downloaded files

    """
    if output_dir is None:
        output_dir = Path.cwd()
    elif not output_dir.exists():
        output_dir.mkdir(parents=True, exist_ok=True)

    attachments = list_attachments(client, model, record_id)

    # Filter by extension if provided
    if extension:
        ext = extension.lower().lstrip(".")
        attachments = [
            att for att in attachments if att.get("name", "").lower().endswith(f".{ext}")
        ]

    downloaded_files: list[Path] = []

    for attachment in attachments:
        filename = attachment.get("name", f"attachment_{attachment['id']}")
        try:
            att_data = client.read("ir.attachment", [attachment["id"]], _ATTACHMENT_READ_FIELDS)
            if not att_data:
                continue

            att = att_data[0]
            filename = att.get("name", f"attachment_{attachment['id']}")
            output_path = output_dir / filename

            if att.get("datas"):
                data = base64.b64decode(att["datas"])
                output_path.write_bytes(data)
                downloaded_files.append(output_path)
        except Exception as e:
            import logging

            logging.getLogger("vodoo").warning("Failed to download %s: %s", filename, e)
            continue

    return downloaded_files

get_attachment_data

get_attachment_data(client: OdooClient, attachment_id: int) -> bytes

Read an attachment and return its raw binary content.

Unlike :func:download_attachment, the file is never written to disk; the decoded bytes are returned directly.

PARAMETER	DESCRIPTION
client	Odoo client TYPE: OdooClient
attachment_id	Attachment ID TYPE: int

RETURNS	DESCRIPTION
bytes	Raw bytes of the attachment

RAISES	DESCRIPTION
RecordNotFoundError	If attachment not found or has no data

Source code in src/vodoo/base.py

def get_attachment_data(
    client: OdooClient,
    attachment_id: int,
) -> bytes:
    """Read an attachment and return its raw binary content.

    Unlike :func:`download_attachment`, the file is never written to disk;
    the decoded bytes are returned directly.

    Args:
        client: Odoo client
        attachment_id: Attachment ID

    Returns:
        Raw bytes of the attachment

    Raises:
        RecordNotFoundError: If attachment not found or has no data

    """
    attachments = client.read("ir.attachment", [attachment_id], _ATTACHMENT_READ_FIELDS)
    if not attachments:
        raise RecordNotFoundError("ir.attachment", attachment_id)

    return _decode_attachment_data(attachments[0], attachment_id)

get_record_attachment_data

get_record_attachment_data(client: OdooClient, model: str, record_id: int) -> list[tuple[int, str, bytes]]

Read all attachments for a record and return their binary content.

Unlike :func:download_record_attachments, files are never written to disk; each attachment's decoded bytes are returned in-memory.

PARAMETER	DESCRIPTION
client	Odoo client TYPE: OdooClient
model	Model name TYPE: str
record_id	Record ID TYPE: int

RETURNS	DESCRIPTION
list[tuple[int, str, bytes]]	List of (attachment_id, filename, data) tuples.
list[tuple[int, str, bytes]]	Attachments with empty or missing datas are silently skipped.

Source code in src/vodoo/base.py

def get_record_attachment_data(
    client: OdooClient,
    model: str,
    record_id: int,
) -> list[tuple[int, str, bytes]]:
    """Read all attachments for a record and return their binary content.

    Unlike :func:`download_record_attachments`, files are never written to
    disk; each attachment's decoded bytes are returned in-memory.

    Args:
        client: Odoo client
        model: Model name
        record_id: Record ID

    Returns:
        List of ``(attachment_id, filename, data)`` tuples.
        Attachments with empty or missing ``datas`` are silently skipped.

    """
    attachments = list_attachments(client, model, record_id)

    result: list[tuple[int, str, bytes]] = []
    for att_meta in attachments:
        att_id = att_meta["id"]
        try:
            att_data = client.read("ir.attachment", [att_id], ["id", *_ATTACHMENT_READ_FIELDS])
            if not att_data:
                continue
            decoded = _decode_attachment_record(att_data[0], att_id)
            if decoded is not None:
                result.append(decoded)
        except Exception:
            continue

    return result

create_attachment

create_attachment(client: OdooClient, model: str, record_id: int, file_path: Path | str | None = None, *, data: bytes | None = None, name: str | None = None) -> int

Create an attachment for a record.

PARAMETER	DESCRIPTION
client	Odoo client TYPE: OdooClient
model	Model name TYPE: str
record_id	Record ID TYPE: int
file_path	Path to file to attach (mutually exclusive with data) TYPE: Path | str | None DEFAULT: None
data	Raw bytes to attach (mutually exclusive with file_path) TYPE: bytes | None DEFAULT: None
name	Attachment name (defaults to filename; required when using data) TYPE: str | None DEFAULT: None

RETURNS	DESCRIPTION
int	ID of created attachment

RAISES	DESCRIPTION
ValueError	If arguments are invalid
FileNotFoundError	If file path is invalid

Examples:

>>> create_attachment(client, "project.task", 42, "screenshot.png")
>>> create_attachment(client, "helpdesk.ticket", 42, "/path/to/file.pdf", name="Report.pdf")
>>> create_attachment(client, "project.task", 42, data=b"content", name="doc.txt")

Source code in src/vodoo/base.py

def create_attachment(
    client: OdooClient,
    model: str,
    record_id: int,
    file_path: Path | str | None = None,
    *,
    data: bytes | None = None,
    name: str | None = None,
) -> int:
    """Create an attachment for a record.

    Args:
        client: Odoo client
        model: Model name
        record_id: Record ID
        file_path: Path to file to attach (mutually exclusive with data)
        data: Raw bytes to attach (mutually exclusive with file_path)
        name: Attachment name (defaults to filename; required when using data)

    Returns:
        ID of created attachment

    Raises:
        ValueError: If arguments are invalid
        FileNotFoundError: If file path is invalid

    Examples:
        >>> create_attachment(client, "project.task", 42, "screenshot.png")
        >>> create_attachment(client, "helpdesk.ticket", 42, "/path/to/file.pdf", name="Report.pdf")
        >>> create_attachment(client, "project.task", 42, data=b"content", name="doc.txt")

    """
    values = _prepare_attachment_upload(file_path, data, name, model, record_id)
    return client.create("ir.attachment", values)

get_record_url

get_record_url(client: OdooClient | Any, model: str, record_id: int) -> str

Get the web URL for a record.

Uses the canonical path URL for a selected JSON-2 transport and the legacy hash URL otherwise. Works with sync and async clients without making an additional request.

PARAMETER	DESCRIPTION
client	Odoo client (sync or async) TYPE: OdooClient | Any
model	Model name TYPE: str
record_id	Record ID TYPE: int

RETURNS	DESCRIPTION
str	URL to view the record in Odoo web interface

Examples:

>>> get_record_url(client, "helpdesk.ticket", 42)
'https://odoo.example.com/web#id=42&model=helpdesk.ticket&view_type=form'

Source code in src/vodoo/base.py

def get_record_url(client: OdooClient | Any, model: str, record_id: int) -> str:
    """Get the web URL for a record.

    Uses the canonical path URL for a selected JSON-2 transport and the
    legacy hash URL otherwise. Works with sync and async clients without
    making an additional request.

    Args:
        client: Odoo client (sync or async)
        model: Model name
        record_id: Record ID

    Returns:
        URL to view the record in Odoo web interface

    Examples:
        >>> get_record_url(client, "helpdesk.ticket", 42)
        'https://odoo.example.com/web#id=42&model=helpdesk.ticket&view_type=form'

    """
    return build_record_url(
        client.config.url,
        model,
        record_id,
        "json2" if getattr(client, "is_json2", False) else "jsonrpc",
    )

is_json_output

is_json_output() -> bool

Deprecated compatibility shim for the active CLI mode.

Source code in src/vodoo/base.py

def is_json_output() -> bool:
    """Deprecated compatibility shim for the active CLI mode."""
    return bool(_cli_output().is_json_output())

is_toon_output

is_toon_output() -> bool

Deprecated compatibility shim for the active CLI mode.

Source code in src/vodoo/base.py

def is_toon_output() -> bool:
    """Deprecated compatibility shim for the active CLI mode."""
    return bool(_cli_output().is_toon_output())

is_structured_output

is_structured_output() -> bool

Deprecated compatibility shim for the active CLI mode.

Source code in src/vodoo/base.py

def is_structured_output() -> bool:
    """Deprecated compatibility shim for the active CLI mode."""
    return bool(_cli_output().is_structured_output())

json_print

json_print(data: Any) -> None

Deprecated compatibility shim for JSON rendering.

Source code in src/vodoo/base.py

def json_print(data: Any) -> None:
    """Deprecated compatibility shim for JSON rendering."""
    _cli_output().json_print(data)

toon_print

toon_print(data: Any) -> None

Deprecated compatibility shim for TOON rendering.

Source code in src/vodoo/base.py

def toon_print(data: Any) -> None:
    """Deprecated compatibility shim for TOON rendering."""
    _cli_output().toon_print(data)

structured_print

structured_print(data: Any) -> None

Deprecated compatibility shim for structured rendering.

Source code in src/vodoo/base.py

def structured_print(data: Any) -> None:
    """Deprecated compatibility shim for structured rendering."""
    _cli_output().structured_print(data)

display_records

display_records(records: list[dict[str, Any]], title: str = 'Records') -> None

Deprecated compatibility shim for CLI record rendering.

Source code in src/vodoo/base.py

def display_records(records: list[dict[str, Any]], title: str = "Records") -> None:
    """Deprecated compatibility shim for CLI record rendering."""
    _cli_display().display_records(records, title)

display_record_detail

display_record_detail(record: dict[str, Any], *, show_html: bool = False, record_type: str = 'Record') -> None

Deprecated compatibility shim for CLI record-detail rendering.

Source code in src/vodoo/base.py

def display_record_detail(
    record: dict[str, Any],
    *,
    show_html: bool = False,
    record_type: str = "Record",
) -> None:
    """Deprecated compatibility shim for CLI record-detail rendering."""
    _cli_display().display_record_detail(
        record,
        show_html=show_html,
        record_type=record_type,
    )

display_tags

display_tags(tags: list[dict[str, Any]], title: str = 'Tags') -> None

Deprecated compatibility shim for CLI tag rendering.

Source code in src/vodoo/base.py

def display_tags(tags: list[dict[str, Any]], title: str = "Tags") -> None:
    """Deprecated compatibility shim for CLI tag rendering."""
    _cli_display().display_tags(tags, title)

display_messages

display_messages(messages: list[dict[str, Any]], show_html: bool = False) -> None

Deprecated compatibility shim for CLI message rendering.

Source code in src/vodoo/base.py

def display_messages(messages: list[dict[str, Any]], show_html: bool = False) -> None:
    """Deprecated compatibility shim for CLI message rendering."""
    _cli_display().display_messages(messages, show_html)

display_attachments

display_attachments(attachments: list[dict[str, Any]]) -> None

Deprecated compatibility shim for CLI attachment rendering.

Source code in src/vodoo/base.py

def display_attachments(attachments: list[dict[str, Any]]) -> None:
    """Deprecated compatibility shim for CLI attachment rendering."""
    _cli_display().display_attachments(attachments)