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