From cbbf53e0edce8939ccf5e5f3aa617d4541d023de Mon Sep 17 00:00:00 2001 From: Trinh Anh Ngoc Date: Wed, 4 Oct 2023 15:49:54 +0700 Subject: [PATCH] Update stubs --- odoo-stubs/fields.pyi | 29 +++++++++-------------------- odoo-stubs/models.pyi | 33 ++++++++++++++++----------------- odoo-stubs/osv/expression.pyi | 22 ++++++++++------------ 3 files changed, 35 insertions(+), 49 deletions(-) diff --git a/odoo-stubs/fields.pyi b/odoo-stubs/fields.pyi index 448a0a3..a1f9e4e 100644 --- a/odoo-stubs/fields.pyi +++ b/odoo-stubs/fields.pyi @@ -23,11 +23,6 @@ from .tools import date_utils, float_utils _FieldT = TypeVar("_FieldT", bound=Field) _FieldValueT = TypeVar("_FieldValueT") _ModelT = TypeVar("_ModelT", bound=BaseModel) -_Selection = list[tuple[str, str]] -_SelectionRaw = _Selection | Callable[..., _Selection] | str -_Domain = list -_DomainRaw = _Domain | Callable[..., _Domain] -_CommandList = list[tuple[BaseModel, list]] _SeqIntT = TypeVar("_SeqIntT", bound=Sequence[int]) DATE_LENGTH: int @@ -347,11 +342,11 @@ class Image(Binary): class Selection(Field[str]): type: str column_type: tuple[str, str] - selection: _SelectionRaw + selection: list | Callable | str validate: bool ondelete: dict[str, Any] | None def __init__( - self, selection: _SelectionRaw = ..., string: str = ..., **kwargs + self, selection: list | Callable | str = ..., string: str = ..., **kwargs ) -> None: ... def setup_nonrelated(self, model: BaseModel) -> None: ... def setup_related(self, model: BaseModel): ... @@ -381,12 +376,12 @@ class Reference(Selection): class _Relational(Field[BaseModel]): relational: bool - domain: _DomainRaw + domain: list | Callable context: dict check_company: bool comodel_name: str def setup_nonrelated(self, model: BaseModel) -> None: ... - def get_domain_list(self, model: BaseModel) -> _Domain: ... + def get_domain_list(self, model: BaseModel) -> list: ... class Many2one(_Relational): type: str @@ -515,9 +510,7 @@ class _RelationalMulti(_Relational): def get_depends(self, model: BaseModel): ... def create(self, record_values: list[tuple[BaseModel, Any]]) -> None: ... def write(self, records: BaseModel, value) -> None: ... - def write_batch( - self, records_commands_list: _CommandList, create: bool = ... - ) -> None: ... + def write_batch(self, records_commands_list: list, create: bool = ...) -> None: ... class One2many(_RelationalMulti): type: str @@ -535,10 +528,8 @@ class One2many(_RelationalMulti): def update_db(self, model: BaseModel, columns) -> None: ... def get_domain_list(self, records: BaseModel): ... def read(self, records: BaseModel): ... - def write_real( - self, records_commands_list: _CommandList, create: bool = ... - ) -> None: ... - def write_new(self, records_commands_list: _CommandList): ... + def write_real(self, records_commands_list: list, create: bool = ...) -> None: ... + def write_new(self, records_commands_list: list): ... class Many2many(_RelationalMulti): type: str @@ -562,10 +553,8 @@ class Many2many(_RelationalMulti): @property def groupable(self) -> bool: ... def read(self, records: BaseModel) -> None: ... - def write_real( - self, records_commands_list: _CommandList, create: bool = ... - ) -> None: ... - def write_new(self, records_commands_list: _CommandList) -> None: ... + def write_real(self, records_commands_list: list, create: bool = ...) -> None: ... + def write_new(self, records_commands_list: list) -> None: ... class Id(Field[int]): type: str diff --git a/odoo-stubs/models.pyi b/odoo-stubs/models.pyi index 75451be..e150fd3 100644 --- a/odoo-stubs/models.pyi +++ b/odoo-stubs/models.pyi @@ -28,7 +28,6 @@ from .tools.query import Query _T = TypeVar("_T") _ModelT = TypeVar("_ModelT", bound=BaseModel) _Model2T = TypeVar("_Model2T", bound=BaseModel) -_Domain = list regex_alphanumeric: Pattern[str] regex_order: Pattern[str] @@ -178,17 +177,17 @@ class BaseModel(metaclass=MetaModel): def default_get(self, fields_list: list[str]) -> dict[str, Any]: ... def _rec_name_fallback(self) -> str: ... def user_has_groups(self, groups: str) -> bool: ... - def search_count(self, domain: _Domain, limit: int | None = ...) -> int: ... + def search_count(self, domain: list, limit: int | None = ...) -> int: ... def search( self: _ModelT, - domain: _Domain, + domain: list, offset: int = ..., limit: int | None = ..., order: str | None = ..., ) -> _ModelT: ... def search_fetch( self: _ModelT, - domain: _Domain, + domain: list, field_names: Collection[str], offset: int = ..., limit: int | None = ..., @@ -200,14 +199,14 @@ class BaseModel(metaclass=MetaModel): def name_search( self, name: str = ..., - args: _Domain | None = ..., + args: list | None = ..., operator: str = ..., limit: int = ..., ) -> list[tuple[int, str]]: ... def _name_search( self, name: str = ..., - domain: _Domain | None = ..., + domain: list | None = ..., operator: str = ..., limit: int = ..., order: str | None = ..., @@ -217,10 +216,10 @@ class BaseModel(metaclass=MetaModel): def clear_caches(cls) -> None: ... def _read_group( self, - domain: _Domain, + domain: list, groupby: Iterable[str] = ..., aggregates: Iterable[str] = ..., - having: _Domain = ..., + having: list = ..., offset: int = ..., limit: int | None = ..., order: str | None = ..., @@ -232,7 +231,7 @@ class BaseModel(metaclass=MetaModel): self, groupby_spec: str, query: Query ) -> tuple[str, list[str]]: ... def _read_group_having( - self, having_domain: _Domain, query: Query + self, having_domain: list, query: Query ) -> tuple[str, list, list[str]]: ... def _read_group_orderby( self, order: str | None, groupby_terms: dict, query: Query @@ -248,11 +247,11 @@ class BaseModel(metaclass=MetaModel): self, aggregate_spec: str, raw_values ) -> Iterator: ... def _read_group_expand_full( - self, groups: _ModelT, domain: _Domain | None, order: str | None + self, groups: _ModelT, domain: list | None, order: str | None ) -> _ModelT: ... def _read_group_fill_results( self, - domain: _Domain, + domain: list, groupby: str, annoted_aggregates: dict[str, str], read_group_result: list[dict], @@ -275,7 +274,7 @@ class BaseModel(metaclass=MetaModel): ) -> None: ... def read_group( self, - domain: _Domain, + domain: list, fields: list[str], groupby: str | list[str], offset: int = ..., @@ -364,7 +363,7 @@ class BaseModel(metaclass=MetaModel): def _load_records_write(self, values: dict[str, Any]) -> None: ... def _load_records_create(self, values: list[dict[str, Any]]): ... def _load_records(self, data_list: list[dict], update: bool = ...) -> BaseModel: ... - def _where_calc(self, domain: _Domain, active_test: bool = ...) -> Query: ... + def _where_calc(self, domain: list, active_test: bool = ...) -> Query: ... def _check_qorder(self, word: str) -> bool: ... def _apply_ir_rules(self, query: Query, mode: str = ...) -> None: ... def _generate_m2o_order_by( @@ -386,14 +385,14 @@ class BaseModel(metaclass=MetaModel): def _generate_order_by(self, order_spec: str | None, query: Query) -> str: ... def _flush_search( self, - domain: _Domain, + domain: list, fields: Sequence[str] | None = ..., order: str | None = ..., seen: set | None = ..., ) -> None: ... def _search( self: _ModelT, - domain: _Domain, + domain: list, offset: int = ..., limit: int | None = ..., order: str | None = ..., @@ -417,7 +416,7 @@ class BaseModel(metaclass=MetaModel): def is_transient(cls) -> bool: ... def search_read( self, - domain: _Domain | None = ..., + domain: list | None = ..., fields: list[str] | None = ..., offset: int = ..., limit: int | None = ..., @@ -467,7 +466,7 @@ class BaseModel(metaclass=MetaModel): def grouped(self: _ModelT, key: Callable[[_ModelT], _T]) -> dict[_T, _ModelT]: ... @overload def grouped(self: _ModelT, key: str) -> dict[Any, _ModelT]: ... - def filtered_domain(self: _ModelT, domain: _Domain) -> _ModelT: ... + def filtered_domain(self: _ModelT, domain: list) -> _ModelT: ... @overload def sorted( self: _ModelT, key: Callable[[_ModelT], Any] = ..., reverse: bool = ... diff --git a/odoo-stubs/osv/expression.pyi b/odoo-stubs/osv/expression.pyi index 94c915e..e0a1e84 100644 --- a/odoo-stubs/osv/expression.pyi +++ b/odoo-stubs/osv/expression.pyi @@ -5,8 +5,6 @@ from ..models import BaseModel from ..sql_db import Cursor from ..tools.query import Query -_Domain = list - NOT_OPERATOR: str OR_OPERATOR: str AND_OPERATOR: str @@ -22,14 +20,14 @@ FALSE_LEAF: tuple TRUE_DOMAIN: list[tuple] FALSE_DOMAIN: list[tuple] -def normalize_domain(domain: _Domain) -> _Domain: ... -def is_false(model, domain: _Domain) -> bool: ... -def combine(operator: str, unit, zero, domains: list[_Domain]) -> _Domain: ... -def AND(domains: list[_Domain]) -> _Domain: ... -def OR(domains: list[_Domain]) -> _Domain: ... -def distribute_not(domain: _Domain) -> _Domain: ... -def domain_combine_anies(domain: _Domain, model: BaseModel) -> _Domain: ... -def prettify_domain(domain: _Domain, pre_indent: int = ...) -> str: ... +def normalize_domain(domain: list) -> list: ... +def is_false(model, domain: list) -> bool: ... +def combine(operator: str, unit, zero, domains: list[list]) -> list: ... +def AND(domains: list[list]) -> list: ... +def OR(domains: list[list]) -> list: ... +def distribute_not(domain: list) -> list: ... +def domain_combine_anies(domain: list, model: BaseModel) -> list: ... +def prettify_domain(domain: list, pre_indent: int = ...) -> str: ... def normalize_leaf(element): ... def is_operator(element) -> bool: ... def is_leaf(element, internal: bool = ...) -> bool: ... @@ -40,12 +38,12 @@ def get_unaccent_wrapper(cr: Cursor) -> Callable[[Any], str]: ... class expression: root_model: BaseModel root_alias: str | None - expression: _Domain + expression: list query: Query | None result: tuple[str, list] def __init__( self, - domain: _Domain, + domain: list, model: BaseModel, alias: str | None = ..., query: Query | None = ...,