def load(self, cr, module): """ Load a given module in the registry, and return the names of the modified models. At the Python level, the modules are already loaded, but not yet on a per-registry level. This method populates a registry with the given modules, i.e. it instanciates all the classes of a the given module and registers them in the registry. """ from .. import models loaded_models = OrderedSet() def mark_loaded(model): # recursively mark model and its children loaded_models.add(model._name) for child_name in model._inherit_children: mark_loaded(self[child_name]) lazy_property.reset_all(self) # Instantiate registered classes (via the MetaModel automatic discovery # or via explicit constructor call), and add them to the pool. for cls in models.MetaModel.module_to_models.get(module.name, []): # models register themselves in self.models model = cls._build_model(self, cr) mark_loaded(model) return list(loaded_models)
def setup_models(self, cr): """ Complete the setup of models. This must be called after loading modules and before using the ORM. """ lazy_property.reset_all(self) env = odoo.api.Environment(cr, SUPERUSER_ID, {}) # add manual models if self._init_modules: env['ir.model']._add_manual_models() # prepare the setup on all models models = list(env.values()) for model in models: model._prepare_setup() # do the actual setup from a clean state self._m2m = {} for model in models: model._setup_base() for model in models: model._setup_fields() for model in models: model._setup_complete() self.registry_invalidated = True
def setup_models(self, cr, partial=False): """ Complete the setup of models. This must be called after loading modules and before using the ORM. :param partial: ``True`` if all models have not been loaded yet. """ lazy_property.reset_all(self) env = odoo.api.Environment(cr, SUPERUSER_ID, {}) # load custom models ir_model = env['ir.model'] cr.execute('SELECT * FROM ir_model WHERE state=%s', ('manual',)) for model_data in cr.dictfetchall(): model_class = ir_model._instanciate(model_data) model_class._build_model(self, cr) # prepare the setup on all models models = env.values() for model in models: model._prepare_setup() # do the actual setup from a clean state self._m2m = {} for model in models: model._setup_base(partial) for model in models: model._setup_fields(partial) for model in models: model._setup_complete()
def setup_models(self, cr): """ Complete the setup of models. This must be called after loading modules and before using the ORM. """ env = odoo.api.Environment(cr, SUPERUSER_ID, {}) # Uninstall registry hooks. Because of the condition, this only happens # on a fully loaded registry, and not on a registry being loaded. if self.ready: for model in env.values(): model._unregister_hook() # clear cache to ensure consistency, but do not signal it self.__cache.clear() lazy_property.reset_all(self) self.registry_invalidated = True if env.all.tocompute: _logger.error( "Remaining fields to compute before setting up registry: %s", env.all.tocompute, stack_info=True, ) # add manual models if self._init_modules: env['ir.model']._add_manual_models() # prepare the setup on all models models = list(env.values()) for model in models: model._prepare_setup() # do the actual setup from a clean state self._m2m = defaultdict(list) for model in models: model._setup_base() for model in models: model._setup_fields() for model in models: model._setup_complete() # determine field_depends and field_depends_context self.field_depends = {} self.field_depends_context = {} for model in models: for field in model._fields.values(): depends, depends_context = field.get_depends(model) self.field_depends[field] = tuple(depends) self.field_depends_context[field] = tuple(depends_context) # Reinstall registry hooks. Because of the condition, this only happens # on a fully loaded registry, and not on a registry being loaded. if self.ready: for model in env.values(): model._register_hook() env['base'].flush()
def load(self, cr, module): """ Load a given module in the registry, and return the names of the modified models. At the Python level, the modules are already loaded, but not yet on a per-registry level. This method populates a registry with the given modules, i.e. it instantiates all the classes of a the given module and registers them in the registry. """ from .. import models # clear cache to ensure consistency, but do not signal it self.__cache.clear() lazy_property.reset_all(self) # Instantiate registered classes (via the MetaModel automatic discovery # or via explicit constructor call), and add them to the pool. model_names = [] for cls in models.MetaModel.module_to_models.get(module.name, []): # models register themselves in self.models model = cls._build_model(self, cr) model_names.append(model._name) return self.descendants(model_names, '_inherit', '_inherits')
def setup_models(self, cr): """ Complete the setup of models. This must be called after loading modules and before using the ORM. """ env = odoo.api.Environment(cr, SUPERUSER_ID, {}) # Uninstall registry hooks. Because of the condition, this only happens # on a fully loaded registry, and not on a registry being loaded. if self.ready: for model in env.values(): model._unregister_hook() lazy_property.reset_all(self) # add manual models if self._init_modules: env['ir.model']._add_manual_models() # prepare the setup on all models models = list(env.values()) for model in models: model._prepare_setup() # do the actual setup from a clean state self._m2m = {} for model in models: model._setup_base() for model in models: model._setup_fields() for model in models: model._setup_complete() self.registry_invalidated = True # Reinstall registry hooks. Because of the condition, this only happens # on a fully loaded registry, and not on a registry being loaded. if self.ready: for model in env.values(): model._register_hook()
def load(self, cr, module): """ Load a given module in the registry, and return the names of the modified models. At the Python level, the modules are already loaded, but not yet on a per-registry level. This method populates a registry with the given modules, i.e. it instanciates all the classes of a the given module and registers them in the registry. """ from .. import models lazy_property.reset_all(self) # Instantiate registered classes (via the MetaModel automatic discovery # or via explicit constructor call), and add them to the pool. model_names = [] for cls in models.MetaModel.module_to_models.get(module.name, []): # models register themselves in self.models model = cls._build_model(self, cr) model_names.append(model._name) return self.descendants(model_names, '_inherit', '_inherits')
def setup_models(self, cr): """ Complete the setup of models. This must be called after loading modules and before using the ORM. """ self.clear_caches() lazy_property.reset_all(self) self.registry_invalidated = True env = odoo.api.Environment(cr, SUPERUSER_ID, {}) if env.all.tocompute: _logger.error( "Remaining fields to compute before setting up registry: %s", env.all.tocompute, stack_info=True, ) # add manual models if self._init_modules: env['ir.model']._add_manual_models() # prepare the setup on all models models = list(env.values()) for model in models: model._prepare_setup() # do the actual setup from a clean state self._m2m = defaultdict(list) for model in models: model._setup_base() for model in models: model._setup_fields() for model in models: model._setup_complete() self.registry_invalidated = True
def setup_models(self, cr): """ Complete the setup of models. This must be called after loading modules and before using the ORM. """ lazy_property.reset_all(self) env = odoo.api.Environment(cr, SUPERUSER_ID, {}) # add manual models if self._init_modules: env['ir.model']._add_manual_models() # prepare the setup on all models models = list(env.values()) for model in models: model._prepare_setup() # do the actual setup from a clean state self._m2m = defaultdict(list) for model in models: model._setup_base() for model in models: model._setup_fields() # determine field dependencies dependencies = {} for model in models: if model._abstract: continue for field in model._fields.values(): # dependencies of custom fields may not exist; ignore that case exceptions = (Exception,) if field.manual else () with ignore(*exceptions): dependencies[field] = set(field.resolve_depends(model)) # determine transitive dependencies def transitive_dependencies(field, seen=[]): if field in seen: return for seq1 in dependencies[field]: yield seq1 for seq2 in transitive_dependencies(seq1[-1], seen + [field]): yield concat(seq1[:-1], seq2) def concat(seq1, seq2): if seq1 and seq2: f1, f2 = seq1[-1], seq2[0] if f1.type == 'one2many' and f2.type == 'many2one' and \ f1.model_name == f2.comodel_name and f1.inverse_name == f2.name: return concat(seq1[:-1], seq2[1:]) return seq1 + seq2 # determine triggers based on transitive dependencies triggers = {} for field in dependencies: for path in transitive_dependencies(field): if path: tree = triggers for label in reversed(path): tree = tree.setdefault(label, {}) tree.setdefault(None, set()).add(field) self.field_triggers = triggers for model in models: model._setup_complete() self.registry_invalidated = True
def setup_models(self, cr): """ Complete the setup of models. This must be called after loading modules and before using the ORM. """ env = odoo.api.Environment(cr, SUPERUSER_ID, {}) # Uninstall registry hooks. Because of the condition, this only happens # on a fully loaded registry, and not on a registry being loaded. if self.ready: for model in env.values(): model._unregister_hook() lazy_property.reset_all(self) if env.all.tocompute: _logger.error( "Remaining fields to compute before setting up registry: %s", env.all.tocompute, stack_info=True, ) # add manual models if self._init_modules: env['ir.model']._add_manual_models() # prepare the setup on all models models = list(env.values()) for model in models: model._prepare_setup() # do the actual setup from a clean state self._m2m = defaultdict(list) for model in models: model._setup_base() for model in models: model._setup_fields() # determine field dependencies dependencies = {} for model in models: if model._abstract: continue for field in model._fields.values(): # dependencies of custom fields may not exist; ignore that case exceptions = (Exception, ) if field.base_field.manual else () with ignore(*exceptions): dependencies[field] = set(field.resolve_depends(model)) # determine transitive dependencies def transitive_dependencies(field, seen=[]): if field in seen: return for seq1 in dependencies.get(field, ()): yield seq1 for seq2 in transitive_dependencies(seq1[-1], seen + [field]): yield concat(seq1[:-1], seq2) def concat(seq1, seq2): if seq1 and seq2: f1, f2 = seq1[-1], seq2[0] if f1.type == 'one2many' and f2.type == 'many2one' and \ f1.model_name == f2.comodel_name and f1.inverse_name == f2.name: return concat(seq1[:-1], seq2[1:]) return seq1 + seq2 # determine triggers based on transitive dependencies triggers = {} for field in dependencies: for path in transitive_dependencies(field): if path: tree = triggers for label in reversed(path): tree = tree.setdefault(label, {}) tree.setdefault(None, set()).add(field) self.field_triggers = triggers for model in models: model._setup_complete() self.registry_invalidated = True # Reinstall registry hooks. Because of the condition, this only happens # on a fully loaded registry, and not on a registry being loaded. if self.ready: for model in env.values(): model._register_hook() env['base'].flush()