CLI Typer Compatibility

oduit.cli_typer remains as a compatibility facade for older imports. The canonical Typer composition root now lives in oduit.cli.app.

Compatibility Exports

Compatibility facade for the canonical Typer app in oduit.cli.app.

class oduit.cli_typer.AddonsPathManager(addons_path: str)

Bases: object

Manages discovery and loading of Odoo modules from addons paths.

__init__(addons_path: str)

Initialize AddonsPathManager with comma-separated addons paths.

Parameters:

addons_path – Comma-separated string of addon directory paths

get_all_paths() → list[str]

Get all addon paths (configured + base Odoo paths).

Returns:

List of all addon paths

get_configured_paths() → list[str]

Get only configured addon paths (excluding base Odoo paths).

Returns:

List of configured addon paths

get_base_addons_paths() → list[str]

Get auto-discovered base Odoo addon paths.

find_duplicate_module_names() → dict[str, list[str]]

Return module names that appear in more than one addons path.

get_collection_from_path(path: str, skip_invalid: bool = False) → ManifestCollection

Get ManifestCollection from a specific addon path.

Parameters:

• path – Path to addon directory

• skip_invalid – If True, skip modules with invalid manifests

Returns:

ManifestCollection containing modules from the specified path

Raises:

ManifestError – If manifest is invalid and skip_invalid is False

get_collection_from_paths(paths: list[str], skip_invalid: bool = False) → ManifestCollection

Get ManifestCollection from multiple specific addon paths.

Parameters:

• paths – List of addon directory paths

• skip_invalid – If True, skip modules with invalid manifests

Returns:

ManifestCollection containing modules from all specified paths (duplicates are excluded)

Raises:

ManifestError – If manifest is invalid and skip_invalid is False

get_all_collections(skip_invalid: bool = False) → ManifestCollection

Get ManifestCollection from all configured and base addon paths.

Parameters:

skip_invalid – If True, skip modules with invalid manifests

Returns:

ManifestCollection containing all modules from all paths (duplicates are excluded)

Raises:

ManifestError – If manifest is invalid and skip_invalid is False

get_collection_by_filter(filter_dir: str, skip_invalid: bool = False) → ManifestCollection

Get ManifestCollection filtered by directory basename.

Parameters:

• filter_dir – Directory basename to filter by

• skip_invalid – If True, skip modules with invalid manifests

Returns:

ManifestCollection containing modules from paths matching filter

Raises:

ManifestError – If manifest is invalid and skip_invalid is False

find_module_path(module_name: str) → str | None

Find the absolute path to a module.

Parameters:

module_name – Name of the module to find

Returns:

Absolute path to module directory or None if not found

get_manifest(module_name: str) → Manifest | None

Get the manifest for a module.

Parameters:

module_name – Name of the module

Returns:

Manifest instance or None if module not found

get_module_names(filter_dir: str | None = None) → list[str]

Get sorted list of all module names.

Parameters:

filter_dir – Optional directory basename to filter by

Returns:

Sorted list of module names

class oduit.cli_typer.ConfigLoader(config_dir: str | None = None)

Bases: object

Handles loading and managing Odoo environment configurations.

__init__(config_dir: str | None = None)

Initialize ConfigLoader with optional custom config directory.

get_config_path(env_name: str, format_type: str = 'yaml') → str

Returns full path to environment-specific config.

has_local_config() → bool

Check if a local .oduit.toml file exists in current directory.

get_local_config_path() → str

Return the absolute path to the local .oduit.toml file.

resolve_config_path(env_name: str) → tuple[str, str]

Resolve the config path and format for an environment name.

load_local_config() → dict[str, Any]

Load config from .oduit.toml in current directory.

load_local_config_details() → LoadedConfigDetails

Load local config plus canonical normalized metadata.

inspect_odoo_conf_import(conf_path: str, sectioned: bool = False) → ImportedOdooConfDetails

Import Odoo configuration and return migration-friendly metadata.

import_odoo_conf(conf_path: str, sectioned: bool = False) → dict[str, Any]

Import Odoo configuration from .conf file and convert to oduit format.

Parameters:

• conf_path – Path to the Odoo .conf file

• sectioned – If True, return configuration in sectioned format

Returns:

Dictionary with oduit-compatible configuration

Raises:

• FileNotFoundError – If conf file doesn’t exist

• ValueError – If conf file format is invalid

load_config(env_name: str) → dict[str, Any]

Load config from ~/.config/oduit/<env>.(yaml|toml|conf) or from a direct file path

load_config_details(env_name: str) → LoadedConfigDetails

Load config plus canonical normalized metadata.

get_available_environments() → list[str]

Return a list of available environment names based on config files.

load_demo_config(sectioned: bool = False) → dict[str, Any]

Load a demo configuration for testing without a real Odoo server

Parameters:

sectioned – If True, return configuration in sectioned format

Returns:

Dictionary with demo configuration including demo_mode=True flag

class oduit.cli_typer.ModuleManager(addons_path: str)

Bases: object

Manages Odoo module operations and dependency resolution.

__init__(addons_path: str)

Initialize ModuleManager.

Parameters:

addons_path – Comma-separated string of addon directory paths

static parse_cycle_error(message: str) → list[str]

Extract the module cycle path from an error message.

find_module_dirs(filter_dir: str | None = None) → list[str]

Return all module directories with __manifest__.py in configured paths

Parameters:

filter_dir – Optional directory name to filter results. Only modules in directories with exact basename match will be returned.

Returns:

Sorted list of module directory names

find_modules(filter_dir: str | None = None, skip_invalid: bool = False) → ManifestCollection

Return all modules with manifests in configured paths as a collection

Parameters:

• filter_dir – Optional directory name to filter results. Only modules in directories with exact basename match will be returned.

• skip_invalid – If True, skip modules with invalid manifests instead of raising an exception

Returns:

ManifestCollection containing all found modules

Raises:

ManifestError – If a manifest is invalid and skip_invalid is False

find_module_path(module_name: str) → str | None

Find the absolute path to a module within addons_path and Odoo base addons

Parameters:

module_name – Name of the module to find

Returns:

Absolute path to module directory or None if not found

get_manifest(module_name: str) → Manifest | None

Get the manifest for a module.

Parameters:

module_name – Name of the module to get manifest for

Returns:

Manifest instance or None if module not found

parse_manifest(module_name: str) → dict[str, Any] | None

Parse and return module’s __manifest__.py content.

Parameters:

module_name – Name of the module to parse manifest for

Returns:

Dictionary containing manifest data or None if not found

Raises:

ValueError – If manifest exists but contains invalid Python syntax

Note

This method is maintained for backward compatibility. Consider using get_manifest() for new code.

get_module_codependencies(module_name: str) → list[str]

Get codependencies from module’s manifest ‘depends’ field.

Codependencies are modules that this module depends on, meaning changes to those modules may impact this module.

Parameters:

module_name – Name of the module to get codependencies for

Returns:

List of codependency module names, empty list if no codependencies or module not found

get_direct_dependencies(*module_names: str) → list[str]

Get direct dependencies needed to install a set of modules.

Direct dependencies are the minimal set of external modules (not in the provided set) needed to install the specified modules.

Parameters:

*module_names – One or more module names to get direct dependencies for

Returns:

Sorted list of module names that are direct dependencies (external to the provided set) needed for installation

Example

For modules a, b, c where: - a depends on [‘b’, ‘c’] - b depends on [‘crm’] - c depends on [‘mail’] get_direct_dependencies(‘a’, ‘b’, ‘c’) returns [‘crm’, ‘mail’]

build_dependency_graph(module_name: str) → dict[str, list[str]]

Build complete dependency graph for a module and all its codependencies.

Parameters:

module_name – Name of the root module to build graph for

Returns:

Dictionary mapping each module to its direct codependencies. Format: {module_name: [list_of_codependencies]}

Raises:

ValueError – If circular dependency is detected

get_dependency_tree(module_name: str, max_depth: int | None = None) → dict[str, Any]

Get hierarchical dependency tree for a module.

Parameters:

• module_name – Name of the module to get dependency tree for

• max_depth – Maximum depth to traverse (None for unlimited)

Returns:

Nested dictionary representing the dependency tree. Format: {module_name: {codependency1: {subdeps…}, codependency2: {}}}

Raises:

ValueError – If circular dependency is detected

get_dependencies_at_depth(module_names: list[str], max_depth: int | None = None) → list[str]

Get all dependencies up to a specified depth for a list of modules.

Parameters:

• module_names – List of module names to get dependencies for

• max_depth – Maximum depth to traverse (None for unlimited)

Returns:

Sorted list of unique dependency names (excluding input modules)

get_install_order(*module_names: str) → list[str]

Get the proper installation order for one or more modules and their codependencies.

Uses topological sorting to determine the correct order for installing modules such that all codependencies are installed before the modules that depend on them.

Parameters:

*module_names – One or more module names to get install order for

Returns:

List of module names in the order they should be installed. Codependencies come first, then modules that depend on them.

Raises:

ValueError – If circular dependency is detected

analyze_dependency_cycle(*module_names: str) → dict[str, Any]

Return structured diagnostics for the first detected dependency cycle.

find_missing_dependencies(module_name: str) → list[str]

Find codependencies that are not available in the addons_path.

Parameters:

module_name – Name of the module to check codependencies for

Returns:

List of codependency names that could not be found in addons_path. Empty list if all codependencies are available.

Raises:

ValueError – If circular dependency is detected during graph traversal

get_reverse_dependencies(target_module: str) → list[str]

Get all modules that directly or indirectly depend on the target module.

This method searches through all available modules to find which ones have the target module in their codependency chain.

Parameters:

target_module – Name of the module to find reverse dependencies for

Returns:

List of module names that depend on the target module. Empty list if no modules depend on the target.

detect_odoo_series() → OdooSeries | None

Detect the Odoo series from available modules.

Scans all available modules and attempts to detect the Odoo series from their version strings.

Returns:

OdooSeries if detected, None if unable to detect

get_module_version_display(module_name: str, odoo_series: OdooSeries | None = None) → str

Get formatted version string for display in dependency trees.

Parameters:

• module_name – Name of the module

• odoo_series – Detected Odoo series (if None, will try to detect)

Returns:

• “16.0+ce” for core CE addons

• ”16.0+ee” for core EE addons

• ”1.0.2” for custom addons (actual version)

• ”✘ not installed” for missing addons

Return type:

Formatted version string

get_formatted_dependency_tree(module_name: str, max_depth: int | None = None) → list[str]

Get formatted dependency tree for display.

Parameters:

• module_name – Name of the module to get dependency tree for

• max_depth – Maximum depth to traverse (None for unlimited)

Returns:

List of formatted lines representing the dependency tree

sort_modules(module_names: list[str], sorting: SortingChoice | str = SortingChoice.ALPHABETICAL) → list[str]

Sort module names according to the specified sorting method.

Parameters:

• module_names – List of module names to sort

• sorting – Sorting method - either ‘alphabetical’ or ‘topological’

Returns:

Sorted list of module names

Raises:

ValueError – If circular dependency is detected in topological sort

class oduit.cli_typer.OdooOperations(env_config: dict, verbose: bool = False)

Bases: object

Compatibility facade over smaller internal Odoo operation services.

__init__(env_config: dict, verbose: bool = False)

run_odoo(no_http: bool = False, dev: str | None = None, log_level: str | None = None, stop_after_init: bool = False) → None

Start the Odoo server with the specified configuration.

run_shell(shell_interface: str | None = 'python', no_http: bool = True, compact: bool = False, log_level: str | None = None) → dict

Start an interactive Odoo shell or execute piped commands.

update_module(module: str, no_http: bool = False, suppress_output: bool = False, raise_on_error: bool = False, compact: bool = False, log_level: str | None = None, max_cron_threads: int | None = None, without_demo: str | bool = False, stop_after_init: bool = True, i18n_overwrite: bool = False, language: str | None = None) → dict

Update a module and return operation result

install_module(module: str, verbose: bool = False, no_http: bool = False, suppress_output: bool = False, raise_on_error: bool = False, compact: bool = False, max_cron_threads: int | None = None, log_level: str | None = None, without_demo: str | bool = False, language: str | None = None, with_demo: bool = False, stop_after_init: bool = True) → dict

Install a module and return operation result

export_module_language(module: str, filename: str, language: str, no_http: bool = False, log_level: str | None = None, suppress_output: bool = False) → dict

Export language translations for a specific module to a file.

run_tests(module: str | None = None, stop_on_error: bool = False, install: str | None = None, update: str | None = None, coverage: str | None = None, test_file: str | None = None, test_tags: str | None = None, compact: bool = False, suppress_output: bool = False, raise_on_error: bool = False, log_level: str | None = None) → dict

Run tests for a module

db_exists(with_sudo: bool = True, suppress_output: bool = False, raise_on_error: bool = False, db_user: str | None = None) → dict

Check if database exists and return operation result

drop_db(with_sudo: bool = True, suppress_output: bool = False, raise_on_error: bool = False) → dict

Drop database and return operation result

create_db(with_sudo: bool = True, suppress_output: bool = False, create_role: bool = False, alter_role: bool = False, extension: str | None = None, raise_on_error: bool = False, db_user: str | None = None, with_demo: bool = False, without_demo: bool = False, country: str | None = None, language: str | None = None, username: str = 'admin', password: str = 'admin', odoo_series: OdooSeries | None = None) → dict

Create database and return operation result

list_db(with_sudo: bool = True, suppress_output: bool = False, raise_on_error: bool = False, db_user: str | None = None) → dict

List all databases and return operation result

create_addon(addon_name: str, destination: str | None = None, template: str | None = None, suppress_output: bool = False) → dict

Create a new Odoo addon using the scaffold command.

get_odoo_version(suppress_output: bool = False, raise_on_error: bool = False) → dict

Get the Odoo version from odoo-bin

get_environment_context(env_name: str | None = None, config_source: str | None = None, config_path: str | None = None, odoo_series: OdooSeries | None = None) → EnvironmentContext

Return a typed environment snapshot for planning and inspection.

inspect_addon(module_name: str, odoo_series: OdooSeries | None = None) → AddonInspection

Return a typed inspection payload for one addon.

addon_info(module_name: str, *, odoo_series: OdooSeries | None = None, database: str | None = None, timeout: float = 30.0) → AddonInfo

Return a combined addon summary for onboarding and planning.

plan_update(module_name: str, odoo_series: OdooSeries | None = None) → UpdatePlan

Return a typed, read-only update plan for one addon.

inspect_addons(module_names: list[str], odoo_series: OdooSeries | None = None) → list[AddonInspection]

Return typed inspection payloads for multiple addons.

locate_model(module_name: str, model: str) → ModelSourceLocation

Return static source candidates for a model extension.

locate_field(module_name: str, model: str, field_name: str) → FieldSourceLocation

Return static field source candidates inside one addon.

list_addon_tests(module_name: str, model: str | None = None, field_name: str | None = None) → AddonTestInventory

Return likely addon test files for one addon.

list_addon_models(module_name: str) → AddonModelInventory

Return a static model inventory for one addon.

recommend_tests(module_name: str, paths: list[str]) → dict[str, Any]

Return changed-file to test recommendations for one addon.

find_model_extensions(model: str, database: str | None = None, timeout: float = 30.0, source_roots: list[tuple[str, str]] | None = None, scan_cache: SourceScanCache | None = None) → ModelExtensionInventory

Return combined source and installed metadata for one model.

list_duplicates() → dict[str, list[str]]

Return duplicate module names across configured addon paths.

list_addons_inventory(module_names: list[str], odoo_series: OdooSeries | None = None) → list[dict[str, Any]]

Return structured addon inventory records.

get_addon_install_state(module: str, *, database: str | None = None, timeout: float = 30.0) → AddonInstallState

Return the runtime install state for one addon.

list_installed_dependents(module: str, *, database: str | None = None, timeout: float = 30.0) → InstalledAddonInventory

Return installed addons that depend on the target module.

uninstall_module(module: str, *, suppress_output: bool = False, raise_on_error: bool = False, compact: bool = False, log_level: str | None = None, allow_uninstall: bool = False, check_dependents: bool = True) → dict[str, Any]

Uninstall a module through a trusted runtime action.

list_installed_addons(*, modules: list[str] | None = None, states: list[str] | None = None, database: str | None = None, timeout: float = 30.0) → InstalledAddonInventory

Return runtime addon inventory from ir.module.module.

dependency_graph(module_names: list[str]) → dict[str, Any]

Return dependency graph data for one or more addons.

build_addon_documentation(module_name: str, *, odoo_series: OdooSeries | None = None, database: str | None = None, timeout: float = 30.0, source_only: bool = False, include_arch: bool = False, field_attributes: list[str] | tuple[str, ...] | None = None, view_types: list[str] | tuple[str, ...] | None = None, max_models: int | None = None, max_fields_per_model: int | None = None, path_prefix: str | None = None, progress: Callable[[str, dict[str, Any]], None] | None = None, progress_level: str = 'compact') → AddonDocumentation

Build one addon documentation bundle.

build_model_documentation(model: str, *, database: str | None = None, timeout: float = 30.0, source_only: bool = False, include_arch: bool = False, field_attributes: list[str] | tuple[str, ...] | None = None, view_types: list[str] | tuple[str, ...] | None = None, max_fields: int | None = None, source_modules: list[str] | tuple[str, ...] | None = None, path_prefix: str | None = None) → ModelDocumentation

Build one model documentation bundle.

build_addons_documentation(module_names: list[str], *, odoo_series: OdooSeries | None = None, database: str | None = None, timeout: float = 30.0, source_only: bool = False, include_arch: bool = False, field_attributes: list[str] | tuple[str, ...] | None = None, view_types: list[str] | tuple[str, ...] | None = None, max_models: int | None = None, max_fields_per_model: int | None = None, path_prefix: str | None = None) → MultiAddonDocumentation

Build one documentation bundle spanning multiple addons.

build_technical_documentation(target: str, *, template: str = 'arc42', odoo_series: OdooSeries | None = None, database: str | None = None, timeout: float = 30.0, source_only: bool = False, include_arch: bool = False, field_attributes: list[str] | tuple[str, ...] | None = None, view_types: list[str] | tuple[str, ...] | None = None, max_models: int | None = None, max_fields_per_model: int | None = None, path_prefix: str | None = None, path_base_dir: str | None = None, documentation_policy: DocumentationDirectoryPolicy | None = None, progress: Callable[[str, dict[str, Any]], None] | None = None, progress_level: str = 'compact', render_markdown: bool = True) → TechnicalDocumentation

Build one technical-documentation bundle for an addon target.

refresh_technical_documentation(target: str, *, odoo_series: OdooSeries | None = None, database: str | None = None, timeout: float = 30.0, source_only: bool | None = None, include_arch: bool | None = None, field_attributes: list[str] | tuple[str, ...] | None = None, view_types: list[str] | tuple[str, ...] | None = None, max_models: int | None = None, max_fields_per_model: int | None = None, path_prefix: str | None = None, path_base_dir: str | None = None, documentation_policy: DocumentationDirectoryPolicy | None = None, overwrite_edited: bool = False, add_missing: bool = False, write: bool = False) → dict[str, Any]

Refresh managed generated blocks in addon-local architecture docs.

build_technical_evidence(target: str, *, template: str = 'arc42', odoo_series: OdooSeries | None = None, database: str | None = None, timeout: float = 30.0, source_only: bool = False, include_arch: bool = False, field_attributes: list[str] | tuple[str, ...] | None = None, view_types: list[str] | tuple[str, ...] | None = None, max_models: int | None = None, max_fields_per_model: int | None = None, path_prefix: str | None = None, path_base_dir: str | None = None, documentation_policy: DocumentationDirectoryPolicy | None = None, progress: Callable[[str, dict[str, Any]], None] | None = None, progress_level: str = 'compact', render_markdown: bool = True, evidence_version: int | None = None) → TechnicalDocumentation

Build split deterministic technical evidence bundle.

write_technical_evidence(target: str, *, force: bool = False, template: str = 'arc42', odoo_series: OdooSeries | None = None, database: str | None = None, timeout: float = 30.0, source_only: bool = False, include_arch: bool = False, field_attributes: list[str] | tuple[str, ...] | None = None, view_types: list[str] | tuple[str, ...] | None = None, max_models: int | None = None, max_fields_per_model: int | None = None, path_base_dir: str | None = None, documentation_policy: DocumentationDirectoryPolicy | None = None, progress: Callable[[str, dict[str, Any]], None] | None = None, progress_level: str = 'compact') → dict[str, Any]

Write split deterministic evidence markdown and sidecar.

build_technical_report_seed(target: str, *, evidence_metadata: Any | None = None, generate_evidence_if_missing: bool = True, template: str = 'arc42', odoo_series: OdooSeries | None = None, database: str | None = None, timeout: float = 30.0, source_only: bool = False, include_arch: bool = False, field_attributes: list[str] | tuple[str, ...] | None = None, view_types: list[str] | tuple[str, ...] | None = None, max_models: int | None = None, max_fields_per_model: int | None = None, path_base_dir: str | None = None, documentation_policy: DocumentationDirectoryPolicy | None = None, progress: Callable[[str, dict[str, Any]], None] | None = None, progress_level: str = 'compact') → TechnicalDocumentation

Build split LLM/human report seed bundle.

diff_technical_report_evidence(target: str, *, include_diff: bool = False, significant_only: bool = False, path_base_dir: str | None = None, documentation_policy: DocumentationDirectoryPolicy | None = None) → dict[str, Any]

Diff report snapshots against current evidence document.

build_dependency_graph_documentation(module_names: list[str], *, database: str | None = None, timeout: float = 30.0, source_only: bool = False, installed_only: bool = False, transitive: bool = True, path_prefix: str | None = None) → DependencyGraphDocumentation

Build dependency graph documentation for one or more addons.

query_model(model: str, domain: list[Any] | tuple[Any, ...] | None = None, fields: list[str] | tuple[str, ...] | None = None, limit: int = 80, include_total_count: bool = False, database: str | None = None, timeout: float = 30.0) → QueryModelResult

Delegate typed read-only model queries to OdooQuery.

read_record(model: str, record_id: int, fields: list[str] | tuple[str, ...] | None = None, database: str | None = None, timeout: float = 30.0) → RecordReadResult

Delegate typed single-record reads to OdooQuery.

search_count(model: str, domain: list[Any] | tuple[Any, ...] | None = None, database: str | None = None, timeout: float = 30.0) → SearchCountResult

Delegate typed count queries to OdooQuery.

get_model_fields(model: str, attributes: list[str] | tuple[str, ...] | None = None, module: str | None = None, database: str | None = None, timeout: float = 30.0) → ModelFieldsResult

Delegate typed field metadata queries to OdooQuery.

get_model_views(model: str, view_types: list[str] | tuple[str, ...] | None = None, database: str | None = None, timeout: float = 30.0, include_arch: bool = True) → ModelViewInventory

Return primary and extension DB views for one model.

get_models_documentation_runtime(models: list[str], *, module_name: str | None = None, attributes: list[str] | tuple[str, ...] | None = None, view_types: list[str] | tuple[str, ...] | None = None, include_arch: bool = False, progress: Callable[[str, dict[str, Any]], None] | None = None, database: str | None = None, timeout: float = 60.0) → DocumentationRuntimeInventory

Return batched runtime metadata for documentation generation.

execute_python_code(python_code: str, no_http: bool = True, capture_output: bool = True, suppress_output: bool = False, raise_on_error: bool = False, shell_interface: str | None = None, log_level: str | None = None) → dict

Execute Python code in the Odoo shell environment

execute_code(code: str, *, database: str | None = None, commit: bool = False, timeout: float = 30.0) → dict[str, Any]

Execute trusted arbitrary Python through the embedded executor.

inspect_ref(xmlid: str, *, database: str | None = None, timeout: float = 30.0) → dict[str, Any]

Resolve one XMLID through the embedded Odoo runtime.

inspect_cron(xmlid: str, *, trigger: bool = False, database: str | None = None, timeout: float = 30.0) → dict[str, Any]

Inspect or explicitly trigger one cron job by XMLID.

inspect_modules(*, state: str | None = None, names_only: bool = False, database: str | None = None, timeout: float = 30.0) → dict[str, Any]

Return runtime addon inventory with inspect-command semantics.

inspect_subtypes(model: str, *, database: str | None = None, timeout: float = 30.0) → dict[str, Any]

List message subtypes registered for one model.

inspect_model(model: str, *, database: str | None = None, timeout: float = 30.0) → dict[str, Any]

Inspect runtime model registration metadata.

inspect_field(model: str, field: str, *, with_db: bool = False, database: str | None = None, timeout: float = 30.0) → dict[str, Any]

Inspect runtime field metadata.

inspect_recordset(expression: str, *, database: str | None = None, timeout: float = 30.0) → dict[str, Any]

Execute a trusted recordset expression as an inspection escape hatch.

describe_table(table_name: str, *, database: str | None = None, timeout: float = 30.0) → dict[str, Any]

Describe one PostgreSQL table through the live Odoo connection.

describe_column(table_name: str, column_name: str, *, database: str | None = None, timeout: float = 30.0) → dict[str, Any]

Describe one PostgreSQL column through the live Odoo connection.

list_constraints(table_name: str, *, database: str | None = None, timeout: float = 30.0) → dict[str, Any]

List PostgreSQL constraints for one table.

list_tables(pattern: str | None = None, *, database: str | None = None, timeout: float = 30.0) → dict[str, Any]

List PostgreSQL tables through the live Odoo connection.

inspect_m2m(model: str, field: str, *, database: str | None = None, timeout: float = 30.0) → dict[str, Any]

Inspect Many2many relation-table metadata.

performance_table_scans(*, limit: int = 20, database: str | None = None, timeout: float = 30.0) → dict[str, Any]

Return sequential scan metrics for PostgreSQL tables.

performance_slow_queries(*, limit: int = 10, database: str | None = None, timeout: float = 30.0) → dict[str, Any]

Return slow-query metrics from pg_stat_statements when available.

performance_indexes(*, limit: int = 20, database: str | None = None, timeout: float = 30.0) → dict[str, Any]

Return basic index-usage metrics for PostgreSQL tables.

oduit.cli_typer.cli_main() → None

Entry point for the CLI application.

oduit.cli_typer.configure_output(format_type: str = 'text', non_interactive: bool = False) → None

Configure the global output formatter.

oduit.cli_typer.create_global_config(env: str | None = None, json: bool = False, non_interactive: bool = False, verbose: bool = False, no_http: bool = False, odoo_series: OdooSeries | None = None) → GlobalConfig

Create and validate global configuration.

oduit.cli_typer.main(ctx: Context, env: str | None = <typer.models.OptionInfo object>, json: bool = <typer.models.OptionInfo object>, non_interactive: bool = <typer.models.OptionInfo object>, verbose: bool = <typer.models.OptionInfo object>, no_http: bool = <typer.models.OptionInfo object>, odoo_series: OdooSeries | None = <typer.models.OptionInfo object>) → None

Odoo CLI tool for starting odoo-bin and running tasks.

oduit.cli_typer.validate_addon_name(addon_name: str) → bool

Validate addon name follows basic Odoo conventions

Canonical Module

For new code, import the root app object and entrypoint from oduit.cli.app instead:

oduit.cli.app.create_global_config(env: str | None = None, json: bool = False, non_interactive: bool = False, verbose: bool = False, no_http: bool = False, odoo_series: OdooSeries | None = None) → GlobalConfig

Create and validate global configuration.

oduit.cli.app.cli_main() → None

Entry point for the CLI application.