def create(self):
import pydocs
import types
from inspect import isfunction
field_types = __GOBBLE__.get_fields_info(
self.__dict__["__origin__"].__dict__)
field_defaults = __GOBBLE__.get_dict_default_value(self.__dict__)
ret = {}
ret_type = {}
for k, v in field_types.items():
data_type = v
is_require = False
if isinstance(v, tuple):
fn = None
if v.__len__() == 1:
v = v[0]
if v.__len__() > 1:
is_require = v[1]
data_type = v[0]
if v.__len__() > 2:
fn = v[2]
if isinstance(fn, types.BuiltinFunctionType):
fn = fn()
elif isfunction(fn):
fn = fn()
if is_require and fn == None:
if data_type in [int, float]:
fn = 0
elif data_type in [str, unicode]:
fn = ""
elif data_type == bool:
fn = False
elif data_type == uuid.UUID:
fn = uuid.uuid4()
elif data_type == datetime.datetime:
fn = datetime.datetime.now()
elif isinstance(v[0], BaseDocuments):
fn = v[0].create()
ret.update({k: fn})
ret_type.update({k: (data_type, is_require)})
if isinstance(v, BaseDocuments):
ret.update({k: v.object()})
ret_type.update({k: (BaseDocuments, False)})
if isinstance(v, BaseEmbedArray):
ret.update({k: []})
ret_type.update({k: (BaseDocuments, False)})
if isinstance(v, list):
ret.update({k: []})
ret_type.update({k: (BaseDocuments, False)})
if isinstance(v, type):
ret.update({k: None})
ret_type.update({k: (v, False)})
import mobject
ret_obj = mobject.dynamic_object(ret)
ret_obj.__dict__.update({"__properties_types__": ret_type})
return ret_obj
def object(self):
ret = list(self.items)
if ret.__len__() > 0:
return mobject.dynamic_object(ret[0])
else:
return mobject.dynamic_object({})
def get_page_of_object(self, page_size, page_index):
import mobject
ret = self.get_page(page_size, page_index)
ret.items = [mobject.dynamic_object(x) for x in ret.items]
return ret
def find_to_objects(self):
ret = self.find()
for item in ret:
yield mobject.dynamic_object(item)
def objects(self):
for item in self.items:
yield mobject.dynamic_object(item)
def find_to_object(self):
ret = self.find_one()
return mobject.dynamic_object(ret)
def object(self):
return mobject.dynamic_object(self.find_one())
def object(self):
import datetime
obj = self.find_one()
ret = mobject.dynamic_object(obj)
return ret
def __lshift__(self, other):
if isinstance(other,dict):
if self.__dict__.has_key("__origin__"):
ret_data = self.__dict__["__origin__"].create()
ret_data.__dict__.update(other)
return ret_data
else:
import mobject
return mobject.dynamic_object(other)
import expression_parser
if type(other) in [str, unicode]:
ret = Fields()
ret.__tree__ = get_field_expr(other, True)
ret.__dict__.update({
"__alias__": self.__name__
})
return ret
elif isinstance(other, set):
_other = list(other)
ret_data = {}
for item in _other:
if isinstance(item, Fields):
right = get_field_expr(item, True)
if type(right) in [str, unicode]:
ret_data.update({
right: 1
})
elif isinstance(right, dict):
ret_data.update({
self.__name__: right
})
ret = Fields()
ret.__tree__ = ret_data
ret.__dict__.update({
"__alias__": self.__name__
})
return ret
elif isinstance(other, tuple) and other.__len__() > 0:
_other = other[0]
if type(_other) in [str, unicode]:
_param = tuple([x for x in other if other.index(x) > 0])
ret = Fields()
ret.__tree__ = expression_parser.to_mongobd(_other, *_param)
ret.__dict__.update({
"__alias__": self.__name__
})
return ret
elif isinstance(_other, Fields):
ret_dic = {}
for item in other:
ret_dic.update({
get_field_expr(item, True): 1
})
ret = Fields()
ret.__tree__ = ret_dic
ret.__dict__.update({
"__alias__": self.__name__
})
return ret
elif isinstance(other, list):
ret_dic = []
for item in other:
ret_dic.append(
get_field_expr(item, True)
)
ret = Fields()
ret.__tree__ = ret_dic
ret.__dict__.update({
"__alias__": self.__name__
})
return ret
elif isinstance(other, Fields):
other.__dict__.update({
"__alias__": get_field_expr(self, True)
})
return other
else:
x = other
def __lshift__(self, other):
if other is 0:
ret = Fields()
ret.__tree__ = get_field_expr(other, True)
ret.__dict__.update({"__alias__": self.__name__})
return ret
if isinstance(other, dict):
if self.__dict__.has_key("__origin__") or self.__dict__.has_key(
"__type__"):
_other = {}
for k, v in other.items():
if isinstance(k, Fields):
if k.__parent__.__origin__ == self.__origin__:
f = k.__name__[k.__parent__.__name__.__len__() +
1:k.__name__.__len__()]
_other.update({f: v})
else:
f = get_field_expr(k, True)
_other.update({f: v})
else:
_other.update({k: v})
doc = self.__dict__.get("__origin__",
self.__dict__.get("__type__"))
if isinstance(doc, tuple):
doc = doc[0]
if isinstance(doc, list):
doc = doc[0]
data = doc.__origin__()
default = [(k, v[2]) for k, v in data.__dict__.items()
if isinstance(v, tuple) and v.__len__() == 3
and v[1] == True]
required = [(k, v[1]) for k, v in data.__dict__.items()
if isinstance(v, tuple) and v.__len__() > 1
and v[1] == True]
missing = list(
set([x[0] for x in required]).difference(
set(_other)).difference(set([x[0] for x in required])))
if missing.__len__() > 0:
raise Exception("{0} is missing fields {1}".format(
self.__name__, missing))
wrong_types = [(k, data.__dict__[k][0], type(v)) for k, v in _other.items() if
data.__dict__.has_key(k) and \
(not ((type(v) in [str, unicode] and data.__dict__[k][0] in [str, unicode]) or \
(type(v) == data.__dict__[k][0]) or \
(v == None and data.__dict__[k][1] == False) or \
(type(v) == list and type(data.__dict__[k][0]))))]
if wrong_types.__len__() > 0:
raise Exception("{0} in {1} must be {2} not {3}".format(
wrong_types[0][0], self.__name__, wrong_types[0][1],
wrong_types[0][2]))
unkown = list(set(_other).difference(set(data.__dict__)))
if unkown.__len__() > 0:
raise Exception("{0} not in {1}".format(
unkown, self.__name__))
data.__dict__.update(_other)
for x in default:
if not _other.has_key(x[0]):
if callable(x[1]):
data.__dict__.update({x[0]: x[1]()})
else:
data.__dict__.update({x[0]: x[1]})
import mobject
ret_obj = mobject.dynamic_object()
ret_obj.__dict__.update(data.__dict__)
ret_obj.__dict__.update(
{"__properties__": doc.__origin__().__dict__})
return ret_obj
elif self.__dict__.get("__type__", None) != None:
_type_ = self.__dict__["__type__"]
if hasattr(_type_, "__origin__"):
_type_ = _type_.__origin__
else:
_type_ = _type_()
def feed(x):
for k, v in x.__dict__.items():
if isinstance(v[0], object):
v = v[0]()
elif v.__len__() == 3:
if callable(v[2]):
v = v[2]()
else:
v = v[2]
else:
v = None
x.__dict__.update({k: v})
return x
x = feed(_type_)
return x
# ret_data =_type_.create()
# return self.__dict__["__type__"]<<{}
else:
import mobject
return mobject.dynamic_object(other)
import expression_parser
if type(other) in [str, unicode]:
ret = Fields()
ret.__tree__ = get_field_expr(other, True)
ret.__dict__.update({"__alias__": self.__name__})
return ret
elif isinstance(other, set):
_other = list(other)
ret_data = {}
for item in _other:
if isinstance(item, Fields):
right = get_field_expr(item, True)
if type(right) in [str, unicode]:
ret_data.update({right: 1})
elif isinstance(right, dict):
ret_data.update({self.__name__: right})
ret = Fields()
ret.__tree__ = ret_data
ret.__dict__.update({"__alias__": self.__name__})
return ret
elif isinstance(other, tuple) and other.__len__() > 0:
_other = other[0]
if type(_other) in [str, unicode]:
_param = tuple([x for x in other if other.index(x) > 0])
ret = Fields()
ret.__tree__ = expression_parser.to_mongobd(_other, *_param)
ret.__dict__.update({"__alias__": self.__name__})
return ret
elif isinstance(_other, Fields):
ret_dic = {}
for item in other:
ret_dic.update({get_field_expr(item, True): 1})
ret = Fields()
ret.__tree__ = ret_dic
ret.__dict__.update({"__alias__": self.__name__})
return ret
elif isinstance(other, list):
ret_dic = []
for item in other:
ret_dic.append(get_field_expr(item, True))
ret = Fields()
ret.__tree__ = ret_dic
ret.__dict__.update({"__alias__": self.__name__})
return ret
elif isinstance(other, Fields):
other.__dict__.update({"__alias__": get_field_expr(self, True)})
return other
else:
x = other
