def do_init(self):
class_ = self.parent.class_
def comparator():
return self.parent._get_property(self.key, resolve_synonyms=True).comparator
self.logger.info("register managed attribute %s on class %s" % (self.key, class_.__name__))
if self.descriptor is None:
class SynonymProp(object):
def __set__(s, obj, value):
setattr(obj, self.name, value)
def __delete__(s, obj):
delattr(obj, self.name)
def __get__(s, obj, owner):
if obj is None:
return s
return getattr(obj, self.name)
self.descriptor = SynonymProp()
sessionlib.register_attribute(
class_, self.key, uselist=False, proxy_property=self.descriptor, useobject=False, comparator=comparator
)
def _init_composite_attribute(self):
self.logger.info(
"register managed composite attribute %s on class %s" %
(self.key, self.parent.class_.__name__))
def copy(obj):
return self.parent_property.composite_class(
*obj.__composite_values__())
def compare(a, b):
for col, aprop, bprop in zip(self.columns,
a.__composite_values__(),
b.__composite_values__()):
if not col.type.compare_values(aprop, bprop):
return False
else:
return True
sessionlib.register_attribute(
self.parent.class_,
self.key,
uselist=False,
useobject=False,
copy_function=copy,
compare_function=compare,
mutable_scalars=True,
comparator=self.parent_property.comparator)
def do_init(self):
class_ = self.parent.class_
def comparator():
return self.parent._get_property(self.key,
resolve_synonyms=True).comparator
self.logger.info("register managed attribute %s on class %s" %
(self.key, class_.__name__))
if self.descriptor is None:
class SynonymProp(object):
def __set__(s, obj, value):
setattr(obj, self.name, value)
def __delete__(s, obj):
delattr(obj, self.name)
def __get__(s, obj, owner):
if obj is None:
return s
return getattr(obj, self.name)
self.descriptor = SynonymProp()
sessionlib.register_attribute(class_,
self.key,
uselist=False,
proxy_property=self.descriptor,
useobject=False,
comparator=comparator)
def _register_attribute(self, class_, callable_=None, impl_class=None, **kwargs):
self.logger.info("%s register managed %s attribute" % (self, (self.uselist and "collection" or "scalar")))
attribute_ext = util.to_list(self.parent_property.extension) or []
if self.parent_property.backref:
attribute_ext.append(self.parent_property.backref.extension)
if self.key in self.parent._validators:
attribute_ext.append(mapperutil.Validator(self.key, self.parent._validators[self.key]))
sessionlib.register_attribute(
class_,
self.key,
uselist=self.uselist,
useobject=True,
extension=attribute_ext,
trackparent=True,
typecallable=self.parent_property.collection_class,
callable_=callable_,
comparator=self.parent_property.comparator,
parententity=self.parent,
impl_class=impl_class,
**kwargs
)
def _register_attribute(self, compare_function, copy_function, mutable_scalars,
comparator_factory, callable_=None, proxy_property=None, active_history=False):
self.logger.info("%s register managed attribute" % self)
attribute_ext = util.to_list(self.parent_property.extension) or []
if self.key in self.parent._validators:
attribute_ext.append(mapperutil.Validator(self.key, self.parent._validators[self.key]))
for mapper in self.parent.polymorphic_iterator():
if (mapper is self.parent or not mapper.concrete) and mapper.has_property(self.key):
sessionlib.register_attribute(
mapper.class_,
self.key,
uselist=False,
useobject=False,
copy_function=copy_function,
compare_function=compare_function,
mutable_scalars=mutable_scalars,
comparator=comparator_factory(self.parent_property, mapper),
parententity=mapper,
callable_=callable_,
extension=attribute_ext,
proxy_property=proxy_property,
active_history=active_history
)
def do_init(self):
"""Set up a proxy to the unmanaged descriptor."""
class_ = self.parent.class_
# refactor me
sessionlib.register_attribute(
class_, self.key, uselist=False, proxy_property=self.descriptor, useobject=False, comparator=self.comparator
)
def do_init(self):
"""Set up a proxy to the unmanaged descriptor."""
class_ = self.parent.class_
# refactor me
sessionlib.register_attribute(class_, self.key, uselist=False,
proxy_property=self.descriptor,
useobject=False,
comparator=self.comparator)
def _init_scalar_attribute(self):
self.logger.info("register managed attribute %s on class %s" %
(self.key, self.parent.class_.__name__))
coltype = self.columns[0].type
sessionlib.register_attribute(
self.parent.class_,
self.key,
uselist=False,
useobject=False,
copy_function=coltype.copy_value,
compare_function=coltype.compare_values,
mutable_scalars=self.columns[0].type.is_mutable(),
comparator=self.parent_property.comparator)
def _init_composite_attribute(self):
self.logger.info("register managed composite attribute %s on class %s" % (self.key, self.parent.class_.__name__))
def copy(obj):
return self.parent_property.composite_class(
*obj.__composite_values__())
def compare(a, b):
for col, aprop, bprop in zip(self.columns,
a.__composite_values__(),
b.__composite_values__()):
if not col.type.compare_values(aprop, bprop):
return False
else:
return True
sessionlib.register_attribute(self.parent.class_, self.key, uselist=False, useobject=False, copy_function=copy, compare_function=compare, mutable_scalars=True, comparator=self.parent_property.comparator)
def _register_attribute(self, class_, callable_=None, **kwargs):
self.logger.info("register managed %s attribute %s on class %s" %
((self.uselist and "list-holding" or "scalar"),
self.key, self.parent.class_.__name__))
sessionlib.register_attribute(
class_,
self.key,
uselist=self.uselist,
useobject=True,
extension=self.attributeext,
cascade=self.cascade,
trackparent=True,
typecallable=self.parent_property.collection_class,
callable_=callable_,
comparator=self.parent_property.comparator,
**kwargs)
def _init_scalar_attribute(self):
self.logger.info("register managed attribute %s on class %s" % (self.key, self.parent.class_.__name__))
coltype = self.columns[0].type
sessionlib.register_attribute(self.parent.class_, self.key, uselist=False, useobject=False, copy_function=coltype.copy_value, compare_function=coltype.compare_values, mutable_scalars=self.columns[0].type.is_mutable(), comparator=self.parent_property.comparator)
def _register_attribute(self, class_, callable_=None, **kwargs):
self.logger.info("register managed %s attribute %s on class %s" % ((self.uselist and "list-holding" or "scalar"), self.key, self.parent.class_.__name__))
sessionlib.register_attribute(class_, self.key, uselist=self.uselist, useobject=True, extension=self.attributeext, cascade=self.cascade, trackparent=True, typecallable=self.parent_property.collection_class, callable_=callable_, comparator=self.parent_property.comparator, **kwargs)
