cubicweb: comparison cubicweb/schema.py

equal deleted inserted replaced

-:2fc04786dd36
+:3fa6c9ef2f51
-# copyright 2003-2016 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# copyright 2003 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
 # contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
 #
 # This file is part of CubicWeb.
 #
 # CubicWeb is free software: you can redistribute it and/or modify it under the
 # with CubicWeb.  If not, see <http://www.gnu.org/licenses/>.
 """classes to define schemas for CubicWeb"""
 from __future__ import print_function
-import pkgutil
 import re
-from os.path import join, basename
+from os.path import join
 from hashlib import md5
 from logging import getLogger
 from warnings import warn
 from six import PY2, text_type, string_types, add_metaclass
 from six.moves import range
-from logilab.common import tempattr
 from logilab.common.decorators import cached, clear_cache, monkeypatch, cachedproperty
 from logilab.common.logging_ext import set_log_methods
 from logilab.common.deprecation import deprecated
 from logilab.common.textutils import splitstrip
 from logilab.common.graph import get_cycles
 RelationDefinitionSchema, PermissionMixIn, role_name
 from yams.constraints import (BaseConstraint, FormatConstraint,
 cstr_json_dumps, cstr_json_loads)
 from yams.reader import (CONSTRAINTS, PyFileReader, SchemaLoader,
 cleanup_sys_modules, fill_schema_from_namespace)
+from yams.buildobjs import _add_relation as yams_add_relation
-from rql import parse, nodes, RQLSyntaxError, TypeResolverException
+from rql import parse, nodes, stmts, RQLSyntaxError, TypeResolverException
 from rql.analyze import ETypeResolver
 import cubicweb
+from cubicweb import server
 from cubicweb import ETYPE_NAME_MAP, ValidationError, Unauthorized, _
-from cubicweb import server
 PURE_VIRTUAL_RTYPES = set(('identity', 'has_text',))
 VIRTUAL_RTYPES = set(('eid', 'identity', 'has_text',))
 # set of meta-relations available for every entity types
 def ERSchema_display_name(self, req, form='', context=None):
 """return a internationalized string for the entity/relation type name in
 a given form
 """
 return display_name(req, self.type, form, context)
 ERSchema.display_name = ERSchema_display_name
 @cached
 def get_groups(self, action):
 assert action in self.ACTIONS, action
 try:
 return frozenset(g for g in self.permissions[action] if isinstance(g, string_types))
 except KeyError:
 return ()
 PermissionMixIn.get_groups = get_groups
 @cached
 def get_rqlexprs(self, action):
 assert action in self.ACTIONS, action
 try:
 return tuple(g for g in self.permissions[action] if not isinstance(g, string_types))
 except KeyError:
 return ()
 PermissionMixIn.get_rqlexprs = get_rqlexprs
 def set_action_permissions(self, action, permissions):
 """set the groups and rql expressions allowing to perform <action> on
 :param permissions: the groups and rql expressions allowing the given action
 """
 orig_set_action_permissions(self, action, tuple(permissions))
 clear_cache(self, 'get_rqlexprs')
 clear_cache(self, 'get_groups')
 orig_set_action_permissions = PermissionMixIn.set_action_permissions
 PermissionMixIn.set_action_permissions = set_action_permissions
 def has_local_role(self, action):
 if self.get_rqlexprs(action):
 return True
 if action in ('update', 'delete'):
 return 'owners' in self.get_groups(action)
 return False
 PermissionMixIn.has_local_role = has_local_role
 def may_have_permission(self, action, req):
 if action != 'read' and not (self.has_local_role('read') or
 self.has_perm(req, 'read')):
 return False
 return self.has_local_role(action) or self.has_perm(req, action)
 PermissionMixIn.may_have_permission = may_have_permission
 def has_perm(self, _cw, action, **kwargs):
 """return true if the action is granted globally or locally"""
 try:
 self.check_perm(_cw, action, **kwargs)
 return True
 except Unauthorized:
 return False
 PermissionMixIn.has_perm = has_perm
 def check_perm(self, _cw, action, **kwargs):
 # NB: _cw may be a server transaction or a request object.
 for rqlexpr in self.get_rqlexprs(action)]))
 if any(rqlexpr.check(_cw, **kwargs)
 for rqlexpr in self.get_rqlexprs(action)):
 return
 raise Unauthorized(action, str(self))
 PermissionMixIn.check_perm = check_perm
 CubicWebRelationDefinitionSchema._RPROPERTIES['eid'] = None
 # remember rproperties defined at this point. Others will have to be serialized in
 def main_attribute(self):
 """convenience method that returns the *main* (i.e. the first non meta)
 attribute defined in the entity schema
 """
-for rschema, _ in self.attribute_definitions():
+for rschema, __ in self.attribute_definitions():
 if not (rschema in META_RTYPES
 or self.is_metadata(rschema)):
 return rschema
 def add_subject_relation(self, rschema):
 # dunno if the validation error `occurred` on eidfrom or eidto (from
 # user interface point of view)
 #
 # possible enhancement: check entity being created, it's probably
 # the main eid unless this is a composite relation
-if eidto is None or 'S' in self.mainvars or not 'O' in self.mainvars:
+if eidto is None or 'S' in self.mainvars or 'O' not in self.mainvars:
 maineid = eidfrom
 qname = role_name(rtype, 'subject')
 else:
 maineid = eidto
 qname = role_name(rtype, 'object')
 if self.msg:
 msg = session._(self.msg)
 else:
 msg = '%(constraint)s %(expression)s failed' % {
-'constraint':  session._(self.type()),
+'constraint': session._(self.type()),
 'expression': self.expression}
 raise ValidationError(maineid, {qname: msg})
 def exec_query(self, _cw, eidfrom, eidto):
 if eidto is None:
 return len(self.exec_query(session, eidfrom, eidto)) <= 1
 # workflow extensions #########################################################
-from yams.buildobjs import _add_relation as yams_add_relation
 class workflowable_definition(ybo.metadefinition):
 """extends default EntityType's metaclass to add workflow relations
 (i.e. in_state, wf_info_for and custom_workflow). This is the default
 metaclass for WorkflowableEntityType.
 """
 """return a Schema instance from the schema definition read
 from <directory>
 """
 self.info('loading %s schemas', ', '.join(config.cubes()))
 try:
-return super(CubicWebSchemaLoader, self).load(config, config.schema_modnames(), **kwargs)
+return super(CubicWebSchemaLoader, self).load(
+config, config.schema_modnames(), **kwargs)
 finally:
 # we've to cleanup modules imported from cubicweb.schemas as well
 cleanup_sys_modules([join(cubicweb.CW_SOFTWARE_ROOT, 'schemas')])
 # these are overridden by set_log_methods below
 hasperm = cw.user.matching_groups(MAY_USE_TEMPLATE_FORMAT)
 if hasperm:
 return self.regular_formats + tuple(NEED_PERM_FORMATS)
 return self.regular_formats
 # XXX itou for some Statement methods
-from rql import stmts
 def bw_get_etype(self, name):
 return orig_get_etype(self, bw_normalize_etype(name))
 orig_get_etype = stmts.ScopeNode.get_etype
 stmts.ScopeNode.get_etype = bw_get_etype
 def bw_add_main_variable_delete(self, etype, vref):
 return orig_add_main_variable_delete(self, bw_normalize_etype(etype), vref)
 orig_add_main_variable_delete = stmts.Delete.add_main_variable
 stmts.Delete.add_main_variable = bw_add_main_variable_delete
 def bw_add_main_variable_insert(self, etype, vref):
 return orig_add_main_variable_insert(self, bw_normalize_etype(etype), vref)
 orig_add_main_variable_insert = stmts.Insert.add_main_variable
 stmts.Insert.add_main_variable = bw_add_main_variable_insert
 def bw_set_statement_type(self, etype):
 return orig_set_statement_type(self, bw_normalize_etype(etype))
 orig_set_statement_type = stmts.Select.set_statement_type
 stmts.Select.set_statement_type = bw_set_statement_type

branch	3.25
changeset 12210	3fa6c9ef2f51
parent 12086	39c9e548f0ce
child 12258	46a8146f9703