Lazy evaluation of RecordList, in order to use search_read

Author: florentx

CHANGES.rst

@@ -9,6 +9,11 @@ Changelog
   ``limit`` and ``offset`` become keyword-only, and undocumented
   argument ``reverse`` is abandoned.
 
+* New: :meth:`Model.search` returns a :class:`RecordList` which is
+  lazily evaluated. API method is called only when needed: if attributes
+  are read or methods are called.  It will use `search_read` API method
+  when it's adequate.
+
 * Remove undocumented :meth:`Env._web`.
 
 * Refactor code for ``read`` field formatter.

odooly.py

@@ -974,11 +974,7 @@ def models(self, name='', transient=False):
             fld_transient = 'transient' if 'transient' in ir_model._keys else 'osv_memory'
             domain = [('abstract', '=', False)] if 'abstract' in ir_model._keys else []  # Odoo 19
             try:
-                if self.client.version_info < 8.0:
-                    recs = ir_model.search(domain)
-                    models = ir_model.read(recs.ids, ('model', fld_transient))
-                else:
-                    models = ir_model.search_read(domain, ('model', fld_transient))
+                models = ir_model.search_read(domain, ('model', fld_transient))
             except ServerError:
                 # Only Odoo 15 prevents non-admin user to retrieve models
                 models = ir_model.get_available_models() if self.client.version_info >= 16.0 else {}
@@ -1578,8 +1574,6 @@ def drop_database(self, passwd, database):
 
 class BaseModel:
 
-    ids = ()
-
     def sudo(self, user=None):
         """Attach to the provided user, or Superuser."""
         return self.with_env(self.env.sudo(user=user))
@@ -1675,13 +1669,22 @@ def browse(self, ids=()):
 
     def search(self, domain, **kwargs):
         """Search for records in the `domain`."""
-        ids = self._execute('search', domain, **kwargs)
-        return RecordList(self, ids)
+        return RecordList._prepared(self, domain, kwargs)
 
     def search_count(self, domain=None):
         """Count the records in the `domain`."""
         return self._execute('search_count', domain or [])
 
+    def search_read(self, domain=None, fields=None, **kwargs):
+        """Combine search and read."""
+        fields, fmt = self._parse_format(fields, browse=False)
+        if self.env.client.version_info < 8.0:
+            ids = self._execute('search', domain or [], **kwargs)
+            res = self._execute('read', ids, fields)
+        else:
+            res = self._execute('search_read', domain or [], fields, **kwargs)
+        return fmt(res)
+
     def get(self, domain, *args, **kwargs):
         """Return a single :class:`Record`.
 
@@ -1888,7 +1891,7 @@ def __init__(self, res_model, arg):
         self.__dict__.update(attrs)
 
     def __repr__(self):
-        ids = f'length={len(self.ids)}' if len(self.ids) > 16 else self.id
+        ids = f'length={len(self.ids)}' if len(self.ids) > 6 else self.id
         return f"<{self.__class__.__name__} '{self._name},{ids}'>"
 
     def __dir__(self):
@@ -2131,15 +2134,34 @@ class RecordList(BaseRecord):
     to assign a single value to all the selected records.
     """
 
-    def __init__(self, res_model, arg):
+    def __init__(self, res_model, arg, search=None):
         super().__init__(res_model, arg)
-        idnames = arg or ()
-        ids = list(idnames)
-        for index, id_ in enumerate(arg):
-            if isinstance(id_, (list, tuple)):
-                ids[index] = id_ = id_[0]
-            assert isinstance(id_, int), repr(id_)
-        self.__dict__.update({'id': ids, 'ids': ids, '_idnames': idnames})
+        if search is None:
+            idnames = arg or ()
+            ids = list(idnames)
+            for index, id_ in enumerate(arg):
+                if isinstance(id_, (list, tuple)):
+                    ids[index] = id_ = id_[0]
+                assert isinstance(id_, int), repr(id_)
+            self.__dict__.update({'id': ids, 'ids': ids, '_idnames': idnames, '_search_args': None})
+        else:
+            self.__dict__['_search_args'] = search
+
+    @classmethod
+    def _prepared(cls, res_model, domain, params):
+        [domain] = searchargs((domain,))
+        return cls(res_model, None, search={'domain': domain, **params})
+
+    def refresh(self):
+        """Reset :class:`RecordList` content."""
+        if self._search_args:
+            for key in 'id', 'ids', '_idnames':
+                self.__dict__.pop(key, None)
+
+    def with_env(self, env):
+        if 'id' in self.__dict__:
+            return super().with_env(env)
+        return RecordList(env[self._name], None, {**self._search_args})
 
     def read(self, fields=None):
         """Read the `fields` of the :class:`RecordList`.
@@ -2151,10 +2173,16 @@ def read(self, fields=None):
 
         if fields == ['id']:
             values = [{'id': res_id} for res_id in self.ids]
-        elif self.id:
-            values = self._model.read(self.id, fields, order=True)
+        elif 'id' not in self.__dict__:
+            params = {**self._search_args}
+            domain = params.pop('domain')
+            values = self._model.search_read(domain, fields, **params)
+            ids = idnames = [val['id'] for val in values]
+            if values and 'display_name' in values[0]:
+                idnames = [(val['id'], val['display_name']) for val in values]
+            self.__dict__.update({'id': ids, 'ids': ids, '_idnames': idnames})
         else:
-            values = []
+            values = self._model.read(self.id, fields, order=True) if self.id else []
 
         return fmt(values)
 
@@ -2183,6 +2211,11 @@ def _external_id(self):
         return [xml_ids.get(res_id, False) for res_id in self.id]
 
     def __getattr__(self, attr):
+        if attr in ('id', 'ids', '_idnames'):
+            params = {**self._search_args}
+            ids = self._execute('search', params.pop('domain'), **params)
+            self.__dict__.update({'id': ids, 'ids': ids, '_idnames': ids})
+            return self.__dict__[attr]
         if attr in self._model._keys:
             return self.read(attr)
         if attr.startswith('_'):

tests/test_client.py

@@ -348,16 +348,16 @@ def test_list_modules(self):
 
     def test_module_upgrade(self):
         self.service.object.execute_kw.side_effect = [
-            (42, 0), [42], [], ANY, [42],
+            (42, 0), [], [42], ANY, [42],
             [{'id': 42, 'state': ANY, 'name': ANY}], ANY]
 
         result = self.env.upgrade('dummy')
         self.assertIsNone(result)
 
         self.assertCalls(
             imm('update_list'),
-            imm('search', [('name', 'in', ('dummy',))]),
             imm('search', [('state', 'not in', STABLE)]),
+            imm('search', [('name', 'in', ('dummy',))]),
             imm('button_upgrade', [42]),
             imm('search', [('state', 'not in', STABLE)]),
             imm('read', [42], ['name', 'state']),
@@ -581,24 +581,25 @@ def test_report_get(self):
 
     def _module_upgrade(self, button='upgrade'):
         execute_return = [
-            [7, 0], [42], [], {'name': 'Upgrade'},
+            [7, 0], [], [42], {'name': 'Upgrade'},
             [{'id': 4, 'state': ANY, 'name': ANY},
              {'id': 5, 'state': ANY, 'name': ANY},
              {'id': 42, 'state': ANY, 'name': ANY}], ANY]
         action = getattr(self.env, button)
 
         expected_calls = [
             imm('update_list'),
-            imm('search', [('name', 'in', ('dummy', 'spam'))]),
             imm('search_read', [('state', 'not in', STABLE)], ['name', 'state']),
+            imm('search', [('name', 'in', ('dummy', 'spam'))]),
             imm('button_' + button, [42]),
             imm('search_read', [('state', 'not in', STABLE)], ['name', 'state']),
             bmu('upgrade_module', []),
         ]
         if float(self.server_version) < 8.0:
             execute_return[4:4] = [[4, 42, 5]]
-            expected_calls[2:5] = [
+            expected_calls[1:5] = [
                 imm('search', [('state', 'not in', STABLE)]),
+                imm('search', [('name', 'in', ('dummy', 'spam'))]),
                 imm('button_' + button, [42]),
                 imm('search', [('state', 'not in', STABLE)]),
                 imm('read', [4, 42, 5], ['name', 'state']),
@@ -632,7 +633,7 @@ def _module_upgrade(self, button='upgrade'):
 
         self.service.object.execute_kw.side_effect = [[0, 0], []]
         self.assertIsNone(action())
-        self.assertCalls(expected_calls[0], expected_calls[2])
+        self.assertCalls(*expected_calls[:2])
         self.assertOutput('0 module(s) updated\n')
 
     def test_module_upgrade(self):

tests/test_model.py

@@ -183,16 +183,28 @@ def test_search(self):
         domain = [('name', 'like', 'Morice')]
         domain2 = [('name', '=', 'mushroom'), ('state', '!=', 'draft')]
 
+        # Search itself does not execute API calls
         self.assertIsInstance(FooBar.search([searchterm]), odooly.RecordList)
         FooBar.search([searchterm], limit=2)
         FooBar.search([searchterm], offset=80, limit=99)
         FooBar.search([searchterm], order='name ASC')
         FooBar.search(['name = mushroom', 'state != draft'])
         FooBar.search([('name', 'like', 'Morice')])
-        FooBar._execute('search', [('name like Morice')])
         FooBar.search([])
+        self.assertCalls()
+
+        # Low-level search will execute API call immediately
+        FooBar._execute('search', [searchterm])
+        self.assertCalls(OBJ('foo.bar', 'search', domain))
+
+        FooBar.search([searchterm], limit=2).ids
+        FooBar.search([searchterm], offset=80, limit=99).id
+        FooBar.search([searchterm], order='name ASC')[:3]
+        FooBar.search(['name = mushroom', 'state != draft']) or 42
+        FooBar.search([('name', 'like', 'Morice')]).ids
+        FooBar._execute('search', [('name like Morice')])[0]
+        FooBar.search([]).ids
         self.assertCalls(
-            OBJ('foo.bar', 'search', domain),
             OBJ('foo.bar', 'search', domain, 0, 2, None),
             OBJ('foo.bar', 'search', domain, 80, 99, None),
             OBJ('foo.bar', 'search', domain, 0, None, 'name ASC'),
@@ -206,7 +218,11 @@ def test_search(self):
         FooBar.search(searchterm)
         FooBar.search([searchterm], limit=2, fields=['birthdate', 'city'])
         FooBar.search([searchterm], missingkey=42)
+        self.assertCalls()
 
+        FooBar.search(searchterm).ids
+        FooBar.search([searchterm], limit=2, fields=['birthdate', 'city']).ids
+        FooBar.search([searchterm], missingkey=42).ids
         self.assertCalls(
             OBJ('foo.bar', 'search', searchterm),
             # Invalid keyword arguments are passed to the API