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
