def __init__(self,
name=u"",
type=u"node",
id=None,
schema=None,
attrs=None,
system_attrs=None,
orderpos=None):
self.name = name
if not isinstance(type, unicode):
warn(
"type arg of Node should be unicode (hint: don't create nodes with Node(type='{}')!)"
.format(type), DeprecationWarning)
if "/" in type:
warn(
"use separate type and schema parameters instead of 'type/schema'",
DeprecationWarning)
type, schema = type.split("/")
self.type = type
self.attrs = MutableDict()
self.system_attrs = MutableDict()
if id:
self.id = id
if schema:
self.schema = schema
if attrs:
self.attrs.update(attrs)
if system_attrs:
self.system_attrs.update(system_attrs)
if orderpos:
self.orderpos = orderpos
def hasProperty(session, Object, key):
#return session.query(Object).join((Object.Properties,Object.properties.local_attr)).filter_by(key=key)
return [
obj for obj in session.query(Object).filter(
Object.properties != (MutableDict({}))).all()
if obj.properties.get(key)
]
def coerce(cls, key, value):
if value is None:
return None
if not isinstance(value, cls.model):
msg = "Attribute '%s' does not accept objects of type %s"
raise ValueError(msg % (key, type(value)))
if not cls.model.__custom_root_type__:
object.__setattr__(value, '__dict__', MutableDict(value.__dict__))
return value
root = cls.model.__fields__[ROOT_KEY]
if root.shape == SHAPE_MAPPING:
value.__dict__[ROOT_KEY] = MutableDict(value.__dict__[ROOT_KEY])
elif root.shape == SHAPE_LIST:
value.__dict__[ROOT_KEY] = MutableList(value.__dict__[ROOT_KEY])
return value
class User(Base):
__tablename__ = 'users'
id = Column(Integer, primary_key=True)
first_name = Column(Unicode)
last_name = Column(Unicode)
data = Column(MutableDict.as_mutable(JSONB), default=MutableDict())
def __unicode__(self):
return u"User #{}".format(self.id)
def __str__(self):
return self.__unicode__().encode('utf8')
def __repr__(self):
return self.__str__()
def __init__(self):
self.key = uuid4().hex
self.startmoment = datetime.now()
self.values = MutableDict()
self.values['check'] = uuid4().hex
def process_result_value(self, value, dialect):
if not value:
return MutableDict()
ret = MutableDict({k: json.loads(v) for k, v in value.items()})
return ret
