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
