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 __lookup__(self, coll, localField, foreignField, alias): import pydocs import documents import expression_parser _CC = coll _LF = localField _FF = foreignField _AS = alias if isinstance(alias, pydocs.Fields): _AS = pydocs.get_field_expr(alias, True) if type(coll) not in [str, unicode, documents.BaseDocuments]: raise Exception("'coll' must be 'str' or 'unicode'") if isinstance(coll, documents.BaseDocuments): _CC = coll.get_collection_name() if type(_AS) not in [str, unicode]: raise Exception("'alias' must be 'str' or 'unicode'") if isinstance(localField, pydocs.Fields): _LF = pydocs.get_field_expr(_LF, True) if isinstance(foreignField, pydocs.Fields): _FF = pydocs.get_field_expr(_FF, True) self.__stage__ = { "from": _CC, "localField": _LF, "foreignField": _FF, "as": _AS } return self
def __build_data__(data): ret = {} if isinstance(data, dict): import pydocs invalid_items = [ x for x, y in data.items() if type(x) not in [str, unicode, pydocs.Fields] ] if invalid_items.__len__() > 0: raise Exception("{0} with type {4} is invalid data type of key." " The valid data type of key is" "{1},{2} or {3}".format(invalid_items[0], str, unicode, pydocs.Fields, type(invalid_items[0]))) for k, v in data.items(): if isinstance(k, pydocs.Fields): field_name = pydocs.get_field_expr(k, True) if type(field_name) not in [str, unicode]: raise Exception("{0} is not str".format(field_name)) ret.update({pydocs.get_field_expr(k, True): __build_data__(v)}) elif hasattr(v, "to_dict"): ret.update({ pydocs.get_field_expr(k, True): __build_data__(v.to_dict()) }) else: ret.update({k: __build_data__(v)}) elif hasattr(data, "to_dict"): return __build_data__(data.to_dict()) elif hasattr(data, "__dict__"): return __build_data__(data.__dict__) else: return data return ret
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 __add_item__(self, item): import pydocs if item.__dict__.has_key("__alias__"): self.stage.update( {item.__dict__["__alias__"]: pydocs.get_field_expr(item)}) else: self.stage.update({pydocs.get_field_expr(item, True): 1}) return self
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, _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 __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, expr, includeArrayIndex=None, preserveNullAndEmptyArrays=None): import pydocs """ { $unwind: { path: <field path>, includeArrayIndex: <string>, preserveNullAndEmptyArrays: <boolean> } } :param expr: :param args: """ if type(expr) in [str, unicode]: self.__stage__ = {"path": "$" + expr} elif isinstance(expr, pydocs.Fields): self.__stage__ = {"path": pydocs.get_field_expr(expr)} if includeArrayIndex != None: self.__stage__.update({"includeArrayIndex": includeArrayIndex}) if preserveNullAndEmptyArrays != None: self.__stage__.update( {"preserveNullAndEmptyArrays": preserveNullAndEmptyArrays})
def __init__(self, *args, **kwargs): import pydocs data = kwargs if args.__len__() > 0: data = args[0] if data == None: self = None return if data != {}: self.__dict__.update({"__validator__": False}) for _k, v in data.items(): k = _k if isinstance(_k, pydocs.Fields): k = pydocs.get_field_expr(_k, True) if k[0:2] != "__" and k.count('.') == 0: self.__properties__.update({k: 1}) if type(v) is dict: setattr(self, k, dynamic_object(v)) elif type(v) is list: values = [] for x in v: if type(x) is dict: values.append(dynamic_object(x)) else: values.append(x) setattr(self, k, values) else: setattr(self, k, v) self.__dict__.update({"__validator__": True})
def __init__(self, coll, local_field_or_let, foreign_field_or_pipeline, alias): import pydocs import expression_parser import pyquery pipeline = None local_field = None foreign_field = None let = None is_use_pipeline = False if isinstance(foreign_field_or_pipeline, pyquery.query): pipeline = foreign_field_or_pipeline let = local_field_or_let is_use_pipeline = True elif isinstance(foreign_field_or_pipeline, pydocs.Fields): foreign_field = pydocs.get_field_expr(foreign_field_or_pipeline, True) local_field = local_field_or_let elif type(foreign_field_or_pipeline) in [str, unicode]: foreign_field = foreign_field_or_pipeline local_field = local_field_or_let if not is_use_pipeline: self.__lookup__(coll, local_field, foreign_field, alias) else: self.__lookup_with_pipeline(coll, let, pipeline, alias)
def map(field, In, alias): from . import pydocs from . import pyaggregatebuilders """ { $map: { input: <expression>, as: <string>, in: <expression> } } :return: """ _In = pyaggregatebuilders.Project(*In).stage ret_data = { "$map": { "input": pydocs.get_field_expr(field), "as": pydocs.get_field_expr(alias, True), "in": _In } } return __create__(ret_data)
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 __init__(self, expr, *args, **kwargs): import pydocs import expression_parser if isinstance(expr, pydocs.Fields): self.__stage__ = pydocs.get_field_expr(expr, True) elif type(expr) in [str, unicode]: self.__stage__ = expression_parser.to_mongobd_match( expr, *args, **kwargs)
def __init__(self, field=None, *args, **kwargs): import pydocs import expression_parser if field == None: field = "ret" if isinstance(field, pydocs.Fields): self.__stage__ = pydocs.get_field_expr(field, True) else: self.__stage__ = field
def __lookup__(self, coll, localField, foreignField, alias): import pydocs import expression_parser _CC = coll _LF = localField _FF = foreignField 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 isinstance(localField, pydocs.Fields): _LF = pydocs.get_field_expr(_LF, True) if isinstance(foreignField, pydocs.Fields): _FF = pydocs.get_field_expr(_FF, True) self.__stage__ = {"from": coll, "localField": _LF, "foreignField": _FF} return self
def where(self, expr, *args, **kwargs): # type:()->pycollection.entity if type(expr) is [str, unicode]: return pycollection.entity( self, expression_parser.to_mongobd_match(expr, *args, **kwargs)) elif isinstance(expr, pydocs.Fields): return pycollection.entity(self, pydocs.get_field_expr(expr)) else: raise Exception("invalid data type {0}".format(type(expr)))
def __is_contains_field__(self, item): import pydocs _field_ = item if isinstance(item, pydocs.Fields): _field_ = pydocs.get_field_expr(item, True) items = _field_.split('.') if items.__len__() == 1: return __GOBBLE__.get_dict_fields_type(self.__dict__).has_key(items[0]) else: next_field = ".".join([x for x in items if items.index(x) > 0]) child_object = __GOBBLE__.get_dict_fields_type(self.__dict__)[items[0]]() return child_object.__is_contains_field__(next_field)
def dictionary(value): if isinstance(value, dict): import pydocs ret_val = {} for k, v in value.items(): _k = k if isinstance(k, pydocs.Fields): _k = pydocs.get_field_expr(k, True) ret_val.update({_k: __GOBBLE__.dictionary(v)}) return ret_val else: return value
def get_from_dict(data): import pydocs ret = {} if isinstance(data, dict): for k, v in data.items(): _k = k if isinstance(k, pydocs.Fields): _k = pydocs.get_field_expr(k, True) ret.update({_k: __GOBBLE__.get_from_dict(v)}) else: return data return ret
def filter(field, iter, cond): """ { $filter: { input: <array>, as: <string>, cond: <expression> } } :return: """ import pydocs return __create_item__( "$filter", { "input": __get_field_expr__(field), "as": pydocs.get_field_expr(iter, True), "cond": __get_field_expr__(cond) })
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 __init__(self, *args, **kwargs): import pydocs import expression_parser data = {} if args.__len__() > 0: for item in args: data.update(item) else: for k, v in kwargs.items(): if type(k) in [str, unicode]: data.update({k: v}) elif isinstance(k, pydocs.Fields): data.update({pydocs.get_field_expr(k, True): v}) self.__stage__ = data
def filter_to_oject(self, *args, **kwargsk): import pydocs other = args field_list = [] for item in list(other): if isinstance(item, pydocs.Fields): field_list.append(pydocs.get_field_expr(item, True)) else: field_list.append(item) ret = {} filter = set(self.__dict__).intersection(field_list) for item in list(filter): ret.update({item: self.__dict__.get(item, None)}) return dynamic_object(ret)
def __init__(self, *args, **kwargs): import pydocs import expression_parser import pymongo from collections import OrderedDict data = OrderedDict() if args.__len__() > 0: for item in args: if item.items()[0][1] == 1: data[item.items()[0][0]] = pymongo.ASCENDING else: data[item.items()[0][0]] = pymongo.DESCENDING else: for k, v in kwargs.items(): if type(k) in [str, unicode]: data.update({k: v}) elif isinstance(k, pydocs.Fields): data.update({pydocs.get_field_expr(k, True): v}) self.__stage__ = data