odoorpc-cli 0.1.0__py3-none-any.whl

odoorpc_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

odoorpc_cli/cli.py

@@ -0,0 +1,33 @@
+import click
+
+from odoorpc_cli import __version__
+from odoorpc_cli.commands import auth, call_method, create, model, search, unlink, write
+from odoorpc_cli.tools.odoo_client import odoorpc_client
+
+
+@click.group(context_settings={"help_option_names": ["-h", "--help"]})
+@click.version_option(version=__version__, prog_name="odoorpc_cli")
+@click.pass_context
+def odoo(ctx):
+    """Odoo CLI - interact with your Odoo instance from the command line"""
+    ctx.ensure_object(dict)
+    try:
+        ctx.obj["odoo"] = odoorpc_client.from_config()
+    except Exception:
+        ctx.obj["odoo"] = None
+        if ctx.invoked_subcommand != "auth":
+            click.echo("Not authenticated — run 'odoo auth login' to authenticate")
+            ctx.exit(1)
+
+
+odoo.add_command(auth)
+odoo.add_command(model)
+odoo.add_command(search)
+odoo.add_command(create)
+odoo.add_command(write)
+odoo.add_command(unlink)
+odoo.add_command(call_method)
+
+
+if __name__ == "__main__":
+    odoo(obj={})  # pragma: no cover - script entrypoint

odoorpc_cli/commands/__init__.py

@@ -0,0 +1,17 @@
+from .auth import auth
+from .call_method import call_method
+from .create import create
+from .model import model
+from .search import search
+from .unlink import unlink
+from .write import write
+
+__all__ = [
+    "auth",
+    "call_method",
+    "create",
+    "model",
+    "search",
+    "unlink",
+    "write",
+]

odoorpc_cli/commands/auth/__init__.py

@@ -0,0 +1,14 @@
+import click
+
+from .info import info as auth_info
+from .login import login as auth_login
+
+
+@click.group("auth")
+def auth():
+    """Authentication related commands"""
+    pass
+
+
+auth.add_command(auth_login)
+auth.add_command(auth_info)

odoorpc_cli/commands/auth/info.py

@@ -0,0 +1,15 @@
+import json
+
+import click
+
+
+@click.command("info")
+@click.pass_context
+def info(ctx):
+    """Display information about the currently authenticated user."""
+    client = ctx.obj.get("odoo")
+    if client is None:
+        click.echo("Not authenticated — run 'odoo auth login' to authenticate")
+        return
+    res = client.get_current_user()
+    click.echo(json.dumps(res, indent=2, ensure_ascii=False))

odoorpc_cli/commands/auth/login.py

@@ -0,0 +1,26 @@
+import click
+
+from odoorpc_cli.settings import Settings
+from odoorpc_cli.tools.odoo_client import odoorpc_client
+
+
+@click.command("login")
+@click.option(
+    "--host",
+    prompt="Odoo server base URL",
+    help="Odoo server base URL, e.g. http://localhost:8069",
+)
+@click.option("--db", prompt="Odoo database name", help="Odoo database name")
+@click.option("--username", prompt="Odoo username", help="Odoo username")
+@click.option(
+    "--password",
+    prompt="Odoo password",
+    hide_input=True,
+    confirmation_prompt=True,
+    help="Odoo API key or password",
+)
+def login(host, db, username, password):
+    """Authenticate and save Odoo connection settings."""
+    odoorpc_client(host=host, db=db, username=username, password=password)
+    Settings.save(host=host, db=db, username=username, password=password)
+    click.echo("Login successful!")

odoorpc_cli/commands/call_method.py

@@ -0,0 +1,29 @@
+import json
+
+import click
+
+from odoorpc_cli.tools.click_types import JSON
+
+
+@click.command("call-method")
+@click.argument("model")
+@click.option("--method", required=True, help="Model method to call")
+@click.option(
+    "--args",
+    type=JSON(expected="list"),
+    default=lambda: [],
+    help="JSON list of positional args, e.g. '[1, \"a\"]'. Defaults to an empty list.",
+)
+@click.option(
+    "--kwargs",
+    type=JSON(expected="dict"),
+    default=lambda: {},
+    help='JSON object of keyword args, e.g. \'{"key": "value"}\'.'
+    " Defaults to an empty object.",
+)
+@click.pass_context
+def call_method(ctx, model, method, args, kwargs):
+    """Call a model method on `model`"""
+    client = ctx.obj.get("odoo")
+    res = client.execute_method(model, method, args=args, kwargs=kwargs)
+    click.echo(json.dumps(res, indent=2, ensure_ascii=False))

odoorpc_cli/commands/create.py

@@ -0,0 +1,21 @@
+import json
+
+import click
+
+from odoorpc_cli.tools.click_types import JSON
+
+
+@click.command("create")
+@click.argument("model")
+@click.option(
+    "--values",
+    type=JSON(expected="list"),
+    required=True,
+    help=('JSON list of record objects to create. Example: \'[{"name": "A"}]\'.'),
+)
+@click.pass_context
+def create(ctx, model: str, values) -> None:
+    """Create multiple records in `model`"""
+    client = ctx.obj.get("odoo")
+    ids = client.create(model, values)
+    click.echo(json.dumps({"ids": ids}, ensure_ascii=False))

odoorpc_cli/commands/model/__init__.py

@@ -0,0 +1,14 @@
+import click
+
+from .field import model_field
+from .search import model_search
+
+
+@click.group("model")
+def model():
+    """Model-introspection commands"""
+    pass
+
+
+model.add_command(model_field)
+model.add_command(model_search)

odoorpc_cli/commands/model/field.py

@@ -0,0 +1,13 @@
+import json
+
+import click
+
+
+@click.command("field")
+@click.argument("model", required=True)
+@click.pass_context
+def model_field(ctx, model: str):
+    """Retrieve metadata for fields of `model`"""
+    client = ctx.obj.get("odoo")
+    res = client.model_field(model)
+    click.echo(json.dumps(res, indent=2, ensure_ascii=False))

odoorpc_cli/commands/model/search.py

@@ -0,0 +1,13 @@
+import json
+
+import click
+
+
+@click.command("search")
+@click.argument("query", required=True)
+@click.pass_context
+def model_search(ctx, query: str):
+    """Search for models by name or substring `query`"""
+    client = ctx.obj.get("odoo")
+    res = client.model_search(query)
+    click.echo(json.dumps(res, indent=2, ensure_ascii=False))

odoorpc_cli/commands/search/__init__.py

@@ -0,0 +1,14 @@
+import click
+
+from .count import search_count
+from .read import search_read
+
+
+@click.group("search")
+def search():
+    """Search related commands"""
+    pass
+
+
+search.add_command(search_count)
+search.add_command(search_read)

odoorpc_cli/commands/search/count.py

@@ -0,0 +1,24 @@
+import json
+
+import click
+
+from odoorpc_cli.tools.click_types import JSON
+
+
+@click.command("count")
+@click.argument("model", required=True)
+@click.option(
+    "--domain",
+    type=JSON(expected="list"),
+    default=lambda: [],
+    help=(
+        'Odoo domain as a JSON list, e.g. \'[["name", "ilike", "test"]]\''
+        " Defaults to an empty list (no filter)."
+    ),
+)
+@click.pass_context
+def search_count(ctx, model: str, domain: list):
+    """Count records in `model` matching domain"""
+    client = ctx.obj.get("odoo")
+    res = client.search_count(model, domain)
+    click.echo(json.dumps({"count": res}, indent=2, ensure_ascii=False))

odoorpc_cli/commands/search/read.py

@@ -0,0 +1,44 @@
+import json
+
+import click
+
+from odoorpc_cli.tools.click_types import JSON
+
+
+@click.command("read")
+@click.argument("model", required=True)
+@click.option(
+    "--domain",
+    type=JSON(expected="list"),
+    default=lambda: [],
+    help=(
+        'Odoo domain as a JSON list, e.g. \'[["name", "ilike", "test"]]\'.'
+        " Defaults to an empty list (no filter)."
+    ),
+)
+@click.option(
+    "--fields",
+    default="all",
+    help=(
+        "Comma-separated fields to read, e.g. 'name,email'."
+        " Defaults to 'all' (all fields)."
+    ),
+)
+@click.option(
+    "--limit",
+    type=int,
+    help="Limit the number of records returned. Defaults to None (no limit).",
+)
+@click.pass_context
+def search_read(ctx, model: str, domain, fields: str, limit: int | None):
+    """Search and read records from `model`"""
+    client = ctx.obj.get("odoo")
+
+    # prepare fields argument
+    if fields == "all" or not fields:
+        fields_arg = ["id"]
+    else:
+        fields_arg = [f.strip() for f in fields.split(",")]
+
+    res = client.search_read(model, domain, fields_arg, limit)
+    click.echo(json.dumps(res, indent=2, ensure_ascii=False))

odoorpc_cli/commands/unlink.py

@@ -0,0 +1,19 @@
+import json
+
+import click
+
+
+@click.command("unlink")
+@click.argument("model")
+@click.option(
+    "--ids",
+    required=True,
+    help="Comma-separated record IDs to unlink (delete), e.g. '1,2,3'.",
+)
+@click.pass_context
+def unlink(ctx, model: str, ids: str) -> None:
+    """Delete records in `model`"""
+    client = ctx.obj.get("odoo")
+    id_list = [int(x.strip()) for x in ids.split(",") if x.strip()]
+    res = client.unlink(model, id_list)
+    click.echo(json.dumps({"success": bool(res)}))

odoorpc_cli/commands/write.py

@@ -0,0 +1,24 @@
+import json
+
+import click
+
+from odoorpc_cli.tools.click_types import JSON
+
+
+@click.command("write")
+@click.argument("model")
+@click.option("--id", "ids", required=True, help="Comma-separated id(s) to update")
+@click.option(
+    "--value",
+    type=JSON(expected="dict"),
+    required=True,
+    help='JSON object of values to write to the records, e.g. \'{"name": "New"}\'.',
+)
+@click.pass_context
+def write(ctx, model: str, ids: str, value) -> None:
+    """Update records in `model`"""
+    client = ctx.obj.get("odoo")
+    vals = value
+    id_list = [int(x.strip()) for x in ids.split(",") if x.strip()]
+    ok = client.write(model, id_list, vals)
+    click.echo(json.dumps({"success": bool(ok)}))

odoorpc_cli/settings.py

@@ -0,0 +1,83 @@
+import json
+import os
+
+from cryptography.fernet import Fernet
+
+
+class Settings:
+    CONFIG_DIR = os.path.expanduser("~/.odoo")
+    CONFIG_PATH = os.path.join(CONFIG_DIR, "config.json")
+    KEY_PATH = os.path.join(CONFIG_DIR, "machine.key")
+
+    @classmethod
+    def ensure_dir(cls) -> None:
+        if not os.path.isdir(cls.CONFIG_DIR):
+            os.makedirs(cls.CONFIG_DIR, exist_ok=True)
+
+    @classmethod
+    def _get_or_create_key(cls) -> bytes:
+        """Return a persistent Fernet key stored in `~/.odoo/machine.key`.
+
+        The key is created once and written with restrictive permissions (0600).
+        """
+        cls.ensure_dir()
+        if os.path.isfile(cls.KEY_PATH):
+            with open(cls.KEY_PATH, "rb") as f:
+                return f.read()
+
+        key = Fernet.generate_key()
+        # Write atomically and restrict permissions
+        temp_path = cls.KEY_PATH + ".tmp"
+        with open(temp_path, "wb") as f:
+            f.write(key)
+        try:
+            os.replace(temp_path, cls.KEY_PATH)
+            os.chmod(cls.KEY_PATH, 0o600)
+        finally:
+            if os.path.exists(temp_path):
+                try:
+                    os.remove(temp_path)
+                except Exception:
+                    pass
+        return key
+
+    @classmethod
+    def encrypt_password(cls, plain: str) -> str:
+        key = cls._get_or_create_key()
+        f = Fernet(key)
+        return f.encrypt(plain.encode("utf-8")).decode("utf-8")
+
+    @classmethod
+    def decrypt_password(cls, token: str) -> str:
+        key = cls._get_or_create_key()
+        f = Fernet(key)
+        return f.decrypt(token.encode("utf-8")).decode("utf-8")
+
+    @classmethod
+    def save(cls, host: str, db: str, username: str, password: str) -> None:
+        cls.ensure_dir()
+        token = cls.encrypt_password(password)
+        conf = {
+            "host": host,
+            "db": db,
+            "username": username,
+            "password_encrypted": token,
+        }
+        with open(cls.CONFIG_PATH, "w", encoding="utf-8") as f:
+            json.dump(conf, f, indent=2)
+
+    @classmethod
+    def load(cls) -> tuple[str, str, str, str]:
+        cls.ensure_dir()
+        if not os.path.isfile(cls.CONFIG_PATH):
+            raise RuntimeError('Config not found; run "odoo auth" first')
+        with open(cls.CONFIG_PATH, encoding="utf-8") as f:
+            conf = json.load(f)
+        host = conf.get("host")
+        db = conf.get("db")
+        username = conf.get("username")
+        token = conf.get("password_encrypted")
+        if token is None:
+            raise RuntimeError("Encrypted password missing from config")
+        password = cls.decrypt_password(token)
+        return host, db, username, password

odoorpc_cli/tools/click_types.py

@@ -0,0 +1,39 @@
+import json
+
+import click
+
+
+class JSON(click.ParamType):
+    """Click parameter type that parses JSON strings into Python objects.
+
+    Args:
+        expected: Optional expected Python type as a string: "list" or "dict".
+            If provided, the value is validated to be that type.
+    """
+
+    name = "json"
+
+    def __init__(self, expected: str | None = None):
+        if expected not in (None, "list", "dict"):
+            raise ValueError("expected must be None, 'list' or 'dict'")
+        self.expected = expected
+
+    def convert(self, value, param, ctx):
+        # If the value was already parsed (click may pass defaults), accept it
+        if not isinstance(value, str):
+            obj = value
+        else:
+            try:
+                obj = json.loads(value)
+            except Exception as exc:  # pragma: no cover - error path
+                self.fail(f"Failed to parse JSON: {exc}", param, ctx)
+
+        if self.expected == "list" and not isinstance(obj, list):
+            self.fail("Value must be a JSON list", param, ctx)
+        if self.expected == "dict" and not isinstance(obj, dict):
+            self.fail("Value must be a JSON object", param, ctx)
+
+        return obj
+
+    def __repr__(self):
+        return f"JSON(expected={self.expected!r})"

odoorpc_cli/tools/odoo_client.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+import urllib.parse
+from typing import Any
+
+import odoorpc
+
+from ..settings import Settings
+
+
+class odoorpc_client:
+    """
+    A thin Odoo JSON-RPC client using odoorpc (mirrors patterns from biszx-odoo-mcp)
+    """
+
+    def __init__(
+        self, host: str, db: str, username: str, password: str, timeout: int = 30
+    ):
+        self.host = host.rstrip("/")
+        self.db = db
+        self.username = username
+        self.password = password
+        self.timeout = timeout
+        parsed = urllib.parse.urlparse(self.host)
+        self.hostname = parsed.hostname or "localhost"
+        self.port = parsed.port
+        self.is_https = parsed.scheme == "https"
+        self._connect()
+
+    def _connect(self) -> None:
+        protocol = "jsonrpc+ssl" if self.is_https else "jsonrpc"
+        port = self.port or (443 if self.is_https else 80)
+        self.odoo = odoorpc.ODOO(
+            self.hostname, protocol=protocol, port=port, timeout=self.timeout
+        )
+        # login will raise on auth failure
+        self.odoo.login(self.db, self.username, self.password)
+
+        # fetch user info
+        user_model = self.odoo.env["res.users"]
+        self.user = user_model.search_read(
+            [("login", "=", self.username)],
+            [
+                "id",
+                "name",
+                "login",
+                "email",
+                "lang",
+                "tz",
+                "company_id",
+                "partner_id",
+                "employee_ids",
+            ],
+            limit=1,
+        )[0]
+        self.uid = self.user["id"]
+
+    def get_current_user(self) -> dict:
+        """Return the current authenticated user's information."""
+        return getattr(self, "user", {})
+
+    def model_search(self, query: str) -> dict:
+        IrModel = self.odoo.env["ir.model"]
+        domain = ["|", ("model", "like", query), ("name", "like", query)]
+        models = (
+            IrModel.search_read(domain, ["model", "name"])
+            if hasattr(IrModel, "search_read")
+            else []
+        )
+        return {"length": len(models), "models": models}
+
+    def model_field(self, model: str):
+        m = self.odoo.env[model]
+        return m.fields_get()
+
+    def search_read(
+        self, model: str, domain: list[Any], fields: list[str], limit: int | None = None
+    ):
+        m = self.odoo.env[model]
+        return m.search_read(domain, fields=fields, limit=limit)
+
+    def search_count(self, model: str, domain: list[Any]):
+        m = self.odoo.env[model]
+        try:
+            return m.search_count(domain)
+        except Exception:
+            return len(m.search(domain))
+
+    def create(self, model: str, vals: list[dict]):
+        m = self.odoo.env[model]
+        return m.create(vals)
+
+    def write(self, model: str, ids: list[int], vals: dict):
+        m = self.odoo.env[model]
+        return m.write(ids, vals)
+
+    def unlink(self, model: str, ids: list[int]):
+        m = self.odoo.env[model]
+        return m.unlink(ids)
+
+    def execute_method(
+        self,
+        model: str,
+        method: str,
+        args: list | None = None,
+        kwargs: dict | None = None,
+    ):
+        m = self.odoo.env[model]
+        func = getattr(m, method)
+        if kwargs:
+            return func(*(args or []), **(kwargs or {}))
+        return func(*(args or []))
+
+    @classmethod
+    def from_config(cls):
+        host, db, username, password = Settings.load()
+        return cls(host=host, db=db, username=username, password=password)

odoorpc_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: odoorpc-cli
+Version: 0.1.0
+Summary: Command-line tool for Odoo using xmlrpc
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: click>=8.0
+Requires-Dist: cryptography>=48.0
+Requires-Dist: odoorpc>=0.10.1
+
+# Odoo CLI
+
+A command-line interface for Odoo, providing quick access to common operations like authentication, searching, creating, updating, and deleting records. It is designed for AI, developers and administrators who prefer working in the terminal.
+
+## Installation
+
+### Homebrew (tap)
+
+Install `odoorpc_cli` from the project's Homebrew tap (recommended):
+
+```bash
+brew tap biszx/tap https://github.com/biszx/homebrew-tap
+brew install biszx/tap/odoorpc_cli
+```
+
+### Windows
+
+Standalone executable (no Python required): download the `odoorpc_cli` Windows executable from a release's assets (the repository contains a CI workflow that builds an exe with PyInstaller and uploads it as an artifact). Place the exe on `PATH` or run it directly.
+
+Installer (recommended): download the Inno Setup installer (`odoorpc_cli-X.Y.Z-setup.exe`) from a release's assets — it creates shortcuts and an uninstaller for easy setup on Windows.
+
+### Python (pip)
+
+Install from PyPI:
+
+```bash
+pip install odoorpc_cli
+```
+
+## Usage
+
+Authenticate and save credentials (interactive):
+
+```
+odoo auth login --host https://odoo.example.com --db demo --username admin --password secret
+```
+
+Search for records:
+
+```
+odoo search read res.partner --domain "[[\"name\", \"ilike\", \"Acme\"]]" --fields name,email
+```
+
+Call a custom model method:
+
+```
+odoo call-method res.partner --method custom_method --args "[]" --kwargs "{}"
+```
+
+## Contributing
+
+Please open issues and pull requests on the repository. Run tests with `pytest`.