def __init__(self, _id=None, *args, **kwargs): import pydocs import expression_parser __id = _id if type(_id) in [str, unicode]: __id = expression_parser.to_mongobd(_id, *args, **kwargs) elif isinstance(_id, pydocs.Fields): __id = pydocs.get_field_expr(_id) elif isinstance(_id, tuple): _id == Project(*_id, **kwargs).stage elif isinstance(_id, dict): self.__stage__ = expression_parser.to_mongobd(_id, *args, **kwargs) if not self.__stage__.has_key("_id"): self.__stage__.update({"_id": None}) return self _selector = {"_id": __id} if args.__len__() > 0: for item in args: if type(item) in [str, unicode]: _selector.update( {item: expression_parser.to_mongobd(item)}) elif isinstance(item, pydocs.Fields): _selector.update({item.to_mongodb()}) self.__stage__ = _selector
def __lookup_with_pipeline(self, coll, let, pipeline, alias): import pyquery import pydocs import expression_parser _l = let if isinstance(alias, pydocs.Fields): alias = pydocs.get_field_expr(alias, True) if type(coll) not in [str, unicode]: raise Exception("'coll' must be 'str' or 'unicode'") if type(alias) not in [str, unicode]: raise Exception("'alias' must be 'str' or 'unicode'") if not (pipeline, pyquery.query): raise Exception("'pipeline' must be query") if isinstance(let, tuple): _l = let[0] _params = tuple([x for x in let if let.index(x) > 0]) _l = expression_parser.to_mongobd(_l, *_params) elif isinstance(let, pydocs.Fields): _l = pydocs.get_field_expr(_l, True) elif type(let) in [str, unicode]: _l = expression_parser.to_mongobd(_l) self.__stage__ = { "from": coll, "pipeline": pipeline.pipeline, "as": alias } if let != None: self.__stage__.update({"let": let})
def __init__(self, groupBy, boundaries, default, output, *args, **kwargs): import pydocs import expression_parser _groupBy = groupBy _boundaries = boundaries _output = output _default = default if type(groupBy) in [str, unicode]: _groupBy = expression_parser.to_mongobd(groupBy, *args, **kwargs) elif isinstance(groupBy, pydocs.Fields): _groupBy = pydocs.get_field_expr(groupBy) if type(output) in [str, unicode]: _output = output elif isinstance(output, pydocs.Fields): _output = pydocs.get_field_expr(output) if type(default) in [str, unicode]: _default = expression_parser.to_mongobd(default, *args, **kwargs) elif isinstance(default, pydocs.Fields): _default = pydocs.get_field_expr(default) self.__stage__ = { "groupBy": _groupBy, "boundaries": boundaries, "output": _output, "default": "default" }
def __apply__(fn, a, b): if isinstance(b, Fields): ret_tree = {fn: [get_field_expr(a), get_field_expr(b)]} setattr(a, "__tree__", ret_tree) elif type(b) in [str, unicode]: import expression_parser ret_tree = {fn: [get_field_expr(a), expression_parser.to_mongobd(b)]} setattr(a, "__tree__", ret_tree) elif isinstance(b, tuple) and b.__len__() > 0: _b = b[0] _params = [] for i in range(1, b.__len__(), 1): _params.append(b[i]) import expression_parser ret_tree = { fn: [ get_field_expr(a), expression_parser.to_mongobd(_b, *tuple(_params)) ] } setattr(a, "__tree__", ret_tree) else: ret_tree = {fn: [get_field_expr(a), b]} setattr(a, "__tree__", ret_tree) return a
def __init__(self, _id, *args, **kwargs): import pydocs import expression_parser __id = _id if type(_id) in [str, unicode]: __id = expression_parser.to_mongobd(_id, *args, **kwargs) elif isinstance(_id, pydocs.Fields): __id = pydocs.get_field_expr(_id) elif isinstance(_id, tuple): _id == Project(*_id, **kwargs).stage elif isinstance(_id, dict): self.__stage__ = expression_parser.to_mongobd(_id, *args, **kwargs) if not self.__stage__.has_key("_id"): self.__stage__.update({"_id": None}) return self _selector = {"_id": __id} if args.__len__() > 0: for item in args: if type(item) in [str, unicode]: _selector.update( {item: expression_parser.to_mongobd(item)}) elif isinstance(item, pydocs.Fields): cValue = item.to_mongodb() if not isinstance(cValue, dict): raise Exception( "Select item in group must be alias, not a fiel\n" "Example: group(None,pymqr.docs.MyFielsdName<<pymqr.funcs.first(pymqr.docs.MyFielsdName)" ) _selector.update(item.to_mongodb()) self.__stage__ = _selector
def __init__(self, *args, **kwargs): import pydocs import expression_parser self.__stage__ = {} data = kwargs if args.__len__() > 0: for item in args: if type(item) in [str, unicode]: self.__stage__.update( {expression_parser.to_mongobd(item): 1}) elif isinstance(item, tuple): _v = item[0] _p = tuple([x for x in item if item.index(x) > 0]) self.__stage__.update( {expression_parser.to_mongobd(_v, *_p): 1}) elif isinstance(item, dict): self.__stage__.update(self.__parse__(item)) elif isinstance(item, pydocs.Fields): if item.__dict__.has_key("__alias__"): self.__stage__.update({ item.__dict__["__alias__"]: pydocs.get_field_expr(item) }) else: right = pydocs.get_field_expr(item, True) if type(right) in [str, unicode]: self.__stage__.update({right: 1}) elif isinstance(right, dict): self.__stage__.update(right) return data = args[0] for k, v in data.items(): if type(v) in [str, unicode]: self.__stage__.update({k: expression_parser.to_mongobd(v)}) elif isinstance(v, tuple): _v = v[0] _p = tuple([x for x in v if v.index(x) > 0]) self.__stage__.update( {k: expression_parser.to_mongobd(_v, *_p)}) elif isinstance(v, pydocs.Fields): if v.__dict__.has_key("__alias__"): self.__stage__.update({k: pydocs.get_field_expr(v, True)}) else: self.__stage__.update({k: pydocs.get_field_expr(v, True)})
def __init__(self, groupBy, buckets, output, granularity=None, *args, **kwargs): import pydocs import expression_parser _groupBy = groupBy _buckets = buckets _output = output _granularity = granularity if type(groupBy) in [str, unicode]: _groupBy = expression_parser.to_mongobd(groupBy, *args, **kwargs) elif isinstance(groupBy, pydocs.Fields): _groupBy = pydocs.get_field_expr(groupBy) if type(output) in [str, unicode]: _output = output elif isinstance(output, pydocs.Fields): _output = pydocs.get_field_expr(output) self.__stage__ = { "groupBy": _groupBy, "buckets": _buckets, "output": _output } if granularity != None: self.__stage__.update({"granularity": granularity})
def compile(expression, *args, **kwargs): if isinstance(expression, Fields): return get_field_expr(expression) if type(expression) in [str, unicode]: import expression_parser return expression_parser.to_mongobd(expression, *args, **kwargs) if isinstance(expression, dict): return expression
def addFields(self, fields, *args, **kwargs): """ :param selectors: :param args: :param kwargs: :return: """ _project = {} if (isinstance(fields, dict)): for k, v in fields.items(): _project.update( {k: expression_parser.to_mongobd(v, *args, **kwargs)}) self.pipeline.append({"$addFields": _project}) return self else: raise Exception("selector must be dict")
def get_field_expr(x, not_prefix=False): if isinstance(x, Fields): if x.__tree__ == None: if x.__name__ == None: return "this" else: if not not_prefix: return "$" + x.__name__ else: return x.__name__ else: return x.__tree__ elif type(x) in [str, unicode]: import expression_parser return expression_parser.to_mongobd(x) else: return x
def __init__(self, expr, *args, **kwargs): import pydocs import expression_parser if type(expr) in [str, unicode]: self.__stage__ = { "newRoot": expression_parser.to_mongobd(expr, *args, **kwargs) } elif isinstance(expr, pydocs.Fields): self.__stage__ = {"newRoot": pydocs.get_field_expr(expr)} elif isinstance(expr, dict): data = {} for k, v in expr.items(): _k = k if isinstance(k, pydocs.Fields): _k = pydocs.get_field_expr(k, True) data.update({_k: pydocs.get_field_expr(v)}) self.__stage__ = {"newRoot": data}
def __lshift__(self, 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, tuple) and other.__len__() > 0: _other = other[0] _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): other.__dict__.update({"__alias__": get_field_expr(self, True)}) return other
def __apply__(fn, a, b): if isinstance(b, Fields): ret_tree = { fn: [get_field_expr(a), get_field_expr(b)] } setattr(a, "__tree__", ret_tree) elif type(b) in [str, unicode]: # ret_tree = { # fn: [get_field_expr (a), get_field_expr (b)] # } # setattr (a, "__tree__", ret_tree) # import expression_parser # try: # right = expression_parser.to_mongobd(b) # except Exception as ex: # raise Exception("Can not apply operator +,-,*,/,.. with string constant\n" # "Please use pyfuncs.concat or other text function in this package") ret_tree = { fn: [get_field_expr(a), b] } setattr(a, "__tree__", ret_tree) elif isinstance(b, tuple) and b.__len__() > 0: _b = b[0] _params = [] for i in range(1, b.__len__(), 1): _params.append(b[i]) import expression_parser ret_tree = { fn: [get_field_expr(a), expression_parser.to_mongobd(_b, *tuple(_params))] } setattr(a, "__tree__", ret_tree) else: ret_tree = { fn: [get_field_expr(a), b] } setattr(a, "__tree__", ret_tree) return a
def __parse__(self, data): import pydocs import expression_parser ret = {} if isinstance(data, dict): for k, v in data.items(): if isinstance(v, pydocs.Fields): ret.update({k: pydocs.get_field_expr(v)}) elif isinstance(v, dict): ret.update({k: self.__parse__(v)}) elif isinstance(v, tuple): _v = v[0] _p = [x for x in v if v.index(x) > 0] ret.update({k: expression_parser.to_mongobd()}) elif isinstance(v, pydocs.Fields): if v.__dict__.has_key("__alias__"): ret.update({ v.__dict__["__alias__"]: pydocs.get_field_expr(v) }) else: ret.update({pydocs.get_field_expr(v, True): 1}) 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