tryton 7.0.7__py3-none-any.whl → 7.4.4__py3-none-any.whl

tryton/gui/window/view_form/model/field.py

@@ -2,19 +2,22 @@
 # this repository contains the full copyright notices and license terms.
 import datetime
 import decimal
+import functools
 import locale
 import logging
 import math
+import operator
 import os
-import tempfile
 from decimal import Decimal
 from itertools import chain
+from pathlib import Path
 
 import tryton.common as common
 from tryton.common import (
     EvalEnvironment, RPCException, RPCExecute, concat, domain_inversion,
     eval_domain, extract_reference_models, filter_leaf, inverse_leaf,
-    localize_domain, merge, prepare_reference_domain, simplify, unique_value)
+    localize_domain, merge, prepare_reference_domain, simplify, tempfile,
+    unique_value)
 from tryton.common.htmltextbuffer import guess_decode
 from tryton.config import CONFIG
 from tryton.pyson import PYSONDecoder
@@ -618,12 +621,10 @@ class O2MField(Field):
         from .group import Group
         parent_name = self.attrs.get('relation_field', '')
         fields = fields or {}
-        context = record.expr_eval(self.attrs.get('context', {}))
         group = Group(self.attrs['relation'], fields,
                 parent=record,
                 parent_name=parent_name,
                 child_name=self.name,
-                context=context,
                 parent_datetime_field=self.attrs.get('datetime_field'))
         if not fields and record.model_name == self.attrs['relation']:
             group.fields = record.group.fields
@@ -699,7 +700,8 @@ class O2MField(Field):
                         skip={self.attrs.get('relation_field', '')}))
         return result
 
-    def _set_value(self, record, value, default=False, modified=False):
+    def _set_value(
+            self, record, value, default=False, modified=False, data=None):
         self._set_default_value(record)
         group = record.value[self.name]
         if value is None:
@@ -709,23 +711,42 @@ class O2MField(Field):
         else:
             mode = 'list values'
 
-        if mode == 'list values':
+        if mode == 'list values' or data:
             context = self.get_context(record)
-            field_names = set(f for v in value for f in v
-                if f not in group.fields and '.' not in f)
-            if field_names:
+            if mode == 'list values':
+                fields = set(f for v in value for f in v)
+            else:
+                fields = functools.reduce(
+                    operator.or_, (d.keys() for d in data), set())
+            field_names = {f for f in fields
+                if (f not in group.fields
+                    and '.' not in f
+                    and ':' not in f
+                    and not f.startswith('_'))}
+            attr_fields = functools.reduce(
+                operator.or_,
+                (v['fields'] for v in self.attrs.get('views', {}).values()),
+                {})
+            fields = {n: attr_fields[n]
+                for n in field_names
+                if n in attr_fields}
+            if to_fetch := (field_names - attr_fields.keys()):
                 try:
-                    fields = RPCExecute('model', self.attrs['relation'],
-                        'fields_get', list(field_names), context=context)
+                    fields |= RPCExecute('model', self.attrs['relation'],
+                        'fields_get', list(to_fetch), context=context)
                 except RPCException:
                     return
+
+            if fields:
                 group.load_fields(fields)
 
         if mode == 'list ids':
             records_to_remove = [r for r in group if r.id not in value]
             for record_to_remove in records_to_remove:
                 group.remove(record_to_remove, remove=True, modified=False)
-            group.load(value, modified=modified or default)
+            group.load(
+                value, modified=modified or default,
+                preloaded={v['id']: v for v in (data or [])})
         else:
             for vals in value:
                 if 'id' in vals:
@@ -746,7 +767,7 @@ class O2MField(Field):
             # Trigger modified only once
             group.record_modified()
 
-    def set(self, record, value, _default=False):
+    def set(self, record, value, _default=False, preloaded=None):
         group = record.value.get(self.name)
         fields = {}
         if group is not None:
@@ -766,7 +787,7 @@ class O2MField(Field):
 
         # Prevent to trigger group-cleared
         group.parent = None
-        self._set_value(record, value, default=_default)
+        self._set_value(record, value, default=_default, data=preloaded)
         group.parent = record
 
     def set_client(self, record, value, force_change=False):
@@ -1048,26 +1069,56 @@ class ReferenceField(Field):
 
 
 class _FileCache(object):
-    def __init__(self, path):
-        self.path = path
+    def __init__(self, data=None):
+        _, filename = tempfile.mkstemp(prefix='tryton_')
+        self.path = Path(filename)
+        self.suffixes = {}
+        if data:
+            with open(self.path, 'wb') as fp:
+                fp.write(data)
+
+    @property
+    def data(self):
+        with open(self.path, 'rb') as fp:
+            return fp.read()
 
     def __del__(self):
         try:
             os.remove(self.path)
         except IOError:
             pass
+        for path in self.suffixes.values():
+            try:
+                os.remove(path)
+            except IOError:
+                pass
+
+    def with_suffix(self, suffix):
+        if suffix in self.suffixes:
+            return self.suffixes[suffix]
+        _, filename = tempfile.mkstemp(prefix='tryton_', suffix=suffix)
+        self.suffixes[suffix] = path = Path(filename)
+        with open(path, 'wb') as fp:
+            fp.write(self.data)
+        return path
 
 
 class BinaryField(Field):
 
     _default = None
 
+    def _set_file_cache(self, record, data):
+        if isinstance(data, str):
+            data = data.encode('utf-8')
+        file_cache = _FileCache(data)
+        self.set(record, file_cache)
+        return file_cache
+
     def get(self, record):
         result = record.value.get(self.name, self._default)
         if isinstance(result, _FileCache):
             try:
-                with open(result.path, 'rb') as fp:
-                    result = fp.read()
+                result = result.data
             except IOError:
                 result = self.get_data(record)
         return result
@@ -1076,13 +1127,7 @@ class BinaryField(Field):
         return self.get(record)
 
     def set_client(self, record, value, force_change=False):
-        _, filename = tempfile.mkstemp(prefix='tryton_')
-        data = value or b''
-        if isinstance(data, str):
-            data = data.encode('utf-8')
-        with open(filename, 'wb') as fp:
-            fp.write(data)
-        self.set(record, _FileCache(filename))
+        self._set_file_cache(record, value or b'')
         self.sig_changed(record)
         record.validate(softvalidation=True)
         record.set_modified(self.name)
@@ -1106,15 +1151,20 @@ class BinaryField(Field):
                     [record.id], [self.name], context=context)
             except RPCException:
                 return b''
-            _, filename = tempfile.mkstemp(prefix='tryton_')
-            data = values[self.name] or b''
-            if isinstance(data, str):
-                data = data.encode('utf-8')
-            with open(filename, 'wb') as fp:
-                fp.write(data)
-            self.set(record, _FileCache(filename))
+            self._set_file_cache(record, values[self.name] or b'')
         return self.get(record)
 
+    def get_filename(self, record, suffix=None):
+        data = self.get_data(record)
+        file_cache = record.value.get(self.name)
+        if not isinstance(file_cache, _FileCache):
+            file_cache = self._set_file_cache(record, data)
+        if suffix:
+            filename = file_cache.with_suffix(suffix)
+        else:
+            filename = file_cache.path
+        return filename
+
 
 class DictField(Field):
 
@@ -1126,10 +1176,10 @@ class DictField(Field):
         self.keys = {}
 
     def get(self, record):
-        return super(DictField, self).get(record) or self._default
+        return (super().get(record) or self._default).copy()
 
     def get_client(self, record):
-        return super(DictField, self).get_client(record) or self._default
+        return super().get_client(record)
 
     def validation_domains(self, record, pre_validate=None):
         screen_domain, attr_domain = self.domains_get(record, pre_validate)

tryton/gui/window/view_form/model/group.py

@@ -128,6 +128,7 @@ class Group(list):
         self._group_list_changed('record-removed', record, idx)
         super(Group, self).remove(record)
         del self.__id2record[record.id]
+        record.destroy()
 
     def clear(self):
         # Use reversed order to minimize the cursor reposition as the cursor
@@ -239,7 +240,7 @@ class Group(list):
                 return []
         return list({}.fromkeys(res))
 
-    def load(self, ids, modified=False, position=-1):
+    def load(self, ids, modified=False, position=-1, preloaded=None):
         if not ids:
             return True
 
@@ -256,6 +257,8 @@ class Group(list):
                 else:
                     self.insert(position, new_record)
                     position += 1
+            if preloaded and (already_loaded := preloaded.get(id)):
+                new_record.set(already_loaded, modified=False, validate=False)
             new_records.append(new_record)
 
         # Remove previously removed or deleted records
@@ -406,7 +409,9 @@ class Group(list):
                 if record not in self.record_deleted:
                     self.record_deleted.append(record)
         record.modified_fields.setdefault('id')
-        if record.id < 0 or force_remove:
+        if (record.id < 0
+                or (self.parent and self.parent.id < 0)
+                or force_remove):
             self._remove(record)
 
         if len(self):

tryton/gui/window/view_form/model/record.py

@@ -1,6 +1,8 @@
 # This file is part of Tryton.  The COPYRIGHT file at the top level of
 # this repository contains the full copyright notices and license terms.
+import functools
 import logging
+import operator
 
 import tryton.common as common
 from tryton.common import RPCException, RPCExecute
@@ -12,6 +14,30 @@ from . import field as fields
 logger = logging.getLogger(__name__)
 
 
+def get_x2m_sub_fields(f_attrs, prefix):
+    if f_attrs.get('visible') and f_attrs.get('views'):
+        sub_fields = functools.reduce(
+            operator.or_,
+            (v.get('fields', {}) for v in f_attrs['views'].values()),
+            {})
+        x2m_sub_fields = []
+        for s_field, f_def in sub_fields.items():
+            x2m_sub_fields.append(f"{prefix}.{s_field}")
+            if f_def['type'] in {'many2one', 'one2one', 'reference'}:
+                x2m_sub_fields.append(f"{prefix}.{s_field}.rec_name")
+            elif f_def['type'] in {'selection', 'multiselection'}:
+                x2m_sub_fields.append(f"{prefix}.{s_field}:string")
+            elif f_def['type'] in {'one2many', 'many2many'}:
+                x2m_sub_fields.extend(
+                    get_x2m_sub_fields(f_def, f"{prefix}.{s_field}"))
+        x2m_sub_fields.extend(
+            f"{prefix}.{f}"
+            for f in ['_timestamp', '_write', '_delete'])
+        return x2m_sub_fields
+    else:
+        return []
+
+
 class Record:
 
     id = -1
@@ -73,12 +99,15 @@ class Record:
                 fields = ((fname, field)
                     for fname, field in self.group.fields.items()
                     if field.attrs.get('loading', 'eager') == 'eager')
+                views_operator = set.issubset
             else:
                 fields = self.group.fields.items()
+                views_operator = set.intersection
 
             fnames = [fname for fname, field in fields
                 if fname not in self._loaded
-                and (not views or (views & field.views))]
+                and (not views or views_operator(views, field.views))]
+            related_read_limit = 0
             for fname in list(fnames):
                 f_attrs = self.group.fields[fname].attrs
                 if f_attrs['type'] in {'many2one', 'one2one', 'reference'}:
@@ -86,6 +115,11 @@ class Record:
                 elif (f_attrs['type'] in {'selection', 'multiselection'}
                         and f_attrs.get('loading', 'lazy') == 'eager'):
                     fnames.append('%s:string' % fname)
+                elif f_attrs['type'] in {'many2many', 'one2many'}:
+                    sub_fields = get_x2m_sub_fields(f_attrs, fname)
+                    fnames.extend(sub_fields)
+                    if sub_fields:
+                        related_read_limit += len(sub_fields)
             if 'rec_name' not in fnames:
                 fnames.append('rec_name')
             fnames.extend(['_timestamp', '_write', '_delete'])
@@ -132,21 +166,25 @@ class Record:
             ctx.update(dict(('%s.%s' % (self.model_name, fname), 'size')
                     for fname, field in self.group.fields.items()
                     if field.attrs['type'] == 'binary' and fname in fnames))
-            exception = False
+            if related_read_limit:
+                ctx['related_read_limit'] = (
+                    CONFIG['client.limit'] // min(related_read_limit, 10))
             try:
                 values = RPCExecute('model', self.model_name, 'read',
                     list(id2record.keys()), fnames, context=ctx,
                     process_exception=process_exception)
             except RPCException:
-                values = [{'id': x} for x in id2record]
-                default_values = dict((f, None) for f in fnames)
-                for value in values:
-                    value.update(default_values)
-                self.exception = exception = True
+                for record in id2record.values():
+                    record.exception = True
+                if process_exception:
+                    values = []
+                    default_values = {f: None for f in fnames if f != 'id'}
+                    for id in id2record:
+                        values.append({'id': id, **default_values})
+                else:
+                    raise
             id2value = dict((value['id'], value) for value in values)
             for id, record in id2record.items():
-                if not record.exception:
-                    record.exception = exception
                 value = id2value.get(id)
                 if record and not record.destroyed and value:
                     for key in record.modified_fields:
@@ -261,20 +299,13 @@ class Record:
         return self.group.fields
 
     def _check_load(self, fields=None):
-        if fields is not None:
-            if not self.get_loaded(fields):
-                self.reload(fields)
-                return True
-            return False
-        if not self.loaded:
-            self.reload()
-            return True
-        return False
+        if not self.get_loaded(fields):
+            self.reload(fields)
 
     def get_loaded(self, fields=None):
-        if fields:
-            return set(fields) <= (self._loaded | set(self.modified_fields))
-        return set(self.group.fields.keys()) == self._loaded
+        if fields is None:
+            fields = self.group.fields.keys()
+        return set(fields) <= (self._loaded | set(self.modified_fields))
 
     loaded = property(get_loaded)
 
@@ -375,6 +406,7 @@ class Record:
         return self.id
 
     def default_get(self, defaults=None):
+        vals = {}
         if len(self.group.fields):
             context = self.get_context()
             if defaults is not None:
@@ -384,7 +416,7 @@ class Record:
                 vals = RPCExecute('model', self.model_name, 'default_get',
                     list(self.group.fields.keys()), context=context)
             except RPCException:
-                return
+                return vals
             if (self.parent
                     and self.parent_name in self.group.fields):
                 parent_field = self.group.fields[self.parent_name]
@@ -405,10 +437,7 @@ class Record:
             return ''
 
     def validate(self, fields=None, softvalidation=False, pre_validate=None):
-        if isinstance(fields, list) and fields:
-            self._check_load(fields)
-        elif fields is None:
-            self._check_load()
+        self._check_load(fields)
         res = True
         for field_name, field in list(self.group.fields.items()):
             if fields is not None and field_name not in fields:
@@ -496,7 +525,9 @@ class Record:
             self._loaded.add(fieldname)
             fieldnames.append(fieldname)
         for fieldname, value in later.items():
-            self.group.fields[fieldname].set(self, value)
+            if isinstance(
+                    field := self.group.fields[fieldname], fields.O2MField):
+                field.set(self, value, preloaded=val.get(f"{fieldname}."))
             self._loaded.add(fieldname)
             fieldnames.append(fieldname)
         if validate:
@@ -576,6 +607,7 @@ class Record:
             values.update(self._get_on_change_args(on_change))
 
         if values:
+            values['id'] = self.id
             try:
                 if len(fieldnames) == 1 or 'id' not in values:
                     changes = []
@@ -637,6 +669,7 @@ class Record:
                                 'on_change_with_' + fieldname,
                                 values, context=self.get_context()))
                 else:
+                    values['id'] = self.id
                     changed = RPCExecute(
                         'model', self.model_name, 'on_change_with',
                         values, list(fieldnames), context=self.get_context())
@@ -659,6 +692,7 @@ class Record:
                                 'on_change_with_' + fieldname,
                                 values, context=self.get_context()))
                 else:
+                    values['id'] = self.id
                     changed = RPCExecute(
                         'model', self.model_name, 'on_change_with',
                         values, list(later), context=self.get_context())
@@ -680,7 +714,8 @@ class Record:
         try:
             res = RPCExecute(
                 'model', self.model_name,
-                'autocomplete_' + fieldname, args, context=self.get_context())
+                'autocomplete_' + fieldname, args, context=self.get_context(),
+                process_exception=False)
         except RPCException:
             # ensure res is a list
             res = []
@@ -689,9 +724,13 @@ class Record:
     def on_scan_code(self, code, depends):
         depends = self.expr_eval(depends)
         values = self._get_on_change_args(depends)
-        changes = RPCExecute(
-            'model', self.model_name, 'on_scan_code', values, code,
-            context=self.get_context(), process_exception=False)
+        values['id'] = self.id
+        try:
+            changes = RPCExecute(
+                'model', self.model_name, 'on_scan_code', values, code,
+                context=self.get_context(), process_exception=False)
+        except RPCException:
+            changes = []
         self.set_on_change(changes)
         self.set_modified()
         return bool(changes)