def apply_sort(self, query: ModelSelect, _sort: dict):
for field, value in _sort.items():
if value == 1:
query = query.order_by(getattr(self.entity_class, field))
elif value == -1:
query = query.order_by(
getattr(self.entity_class, field).desc())
return query
def get_data_for_sending(query: ModelSelect, require_where=False):
page, limit, where_count = 1, Config.DEFAULT_API_LIST_LIMIT, 0
for arg_name, arg_value in request.args.items():
if len(arg_value) == 0:
continue
if arg_name in ("order_by", "order_by_desc"):
fields = get_fields_by_names(query.model, [arg_value])
if len(fields) == 0:
abort(400)
field = fields[0] if "order_by" == arg_name else fields[0].desc()
query = query.order_by(field)
elif arg_name == "page":
page = int(arg_value)
elif arg_name == "limit":
limit = int(arg_value)
limit = limit if limit <= Config.MAX_API_LIST_LIMIT else Config.MAX_API_LIST_LIMIT
elif arg_name.startswith("where:") or arg_name.startswith("or_where:"):
operations = arg_name.split(":")
is_or_where = operations[0] == "or_where"
if len(operations) == 2:
operator = "equal"
else:
operator = operations[1]
fields = get_fields_by_names(query.model, [operations[-1]])
if len(fields) == 0:
abort(400)
else:
field = fields[0]
expression = get_expression_by_operator(field, arg_value, operator)
if expression is None:
abort(400)
if is_or_where:
query = query.orwhere(expression)
else:
query = query.where(expression)
where_count += 1
if require_where and where_count == 0:
abort(400)
count = query.count()
if count == 0:
abort(404)
pages_count = math.ceil(count / limit)
data = [get_model_dict(sm) for sm in query.paginate(page, limit)]
return {
"data": data,
"page": page,
"pages": pages_count,
"count": count,
"limit": limit
}
def append_select(self, p_select: ModelSelect):
if not self.b_initialized:
return p_select
expression = None
# TODO, this needs to be tested with dateline
for bounds in self.query_params.bounds:
xmin = bounds.xmin
ymin = bounds.ymin
xmax = bounds.xmax
ymax = bounds.ymax
a = (xmin <= self.west_field) & (xmax >= self.west_field)
b = (xmin >= self.west_field) & (self.east_field >= xmin)
ab = a | b
c = (self.south_field <= ymin) & (self.north_field >= ymin)
d = (self.south_field > ymin) & (ymax >= self.south_field)
cd = c | d
abcd = ab & cd
expression_part = abcd
if not expression:
expression = expression_part
else:
expression = expression | expression_part
# TODO process append_select for geometries:
# for polygon_wkb in self.query_params.geometry_bag.geometry_binaries:
if expression:
return p_select.where(expression)
return p_select
def create_search_query(db_model: Type[Model], query: ModelSelect,
data: dict = None) -> ModelSelect:
if data is None:
data = {}
filters = data.get('search', {})
sql_expressions = []
helper = Helper()
for filter in filters:
field = getattr(db_model, filter['field_name'])
field_value = filter['field_value']
if isinstance(field_value, str) and not field_value.strip():
continue
sql_expression = helper.build_sql_expression(field,
filter['field_operator'],
field_value)
sql_expressions.append(sql_expression)
if sql_expressions:
query = query.where(*sql_expressions)
return query
async def get_or_404(
query: ModelSelect,
*conditions: Any,
prefetches: Optional[Any] = None,
**filters: Any,
) -> PeeweeModel:
if conditions:
query = query.where(*conditions)
elif filters:
query = query.filter(**filters)
query = prefetch(query, *prefetches) if prefetches else execute(query)
obj = first(await query)
if obj is None:
raise NotFound
return obj # type: ignore
def apply_filter(self, query: ModelSelect, _filter: Dict[str, Any]):
for key, value in _filter.items():
if key.endswith('__not'):
query = query.where(
getattr(self.entity_class, key.replace("__not", "")) !=
value)
elif key.endswith('__in'):
query = query.where(
getattr(self.entity_class, key.replace("__in", "")) in
value)
elif key.endswith('__gt'):
query = query.where(
getattr(self.entity_class, key.replace("__gt", "")) > value
)
elif key.endswith('__gte'):
query = query.where(
getattr(self.entity_class, key.replace("__gte", "")) >=
value)
elif key.endswith('__lt'):
query = query.where(
getattr(self.entity_class, key.replace("__gt", "")) < value
)
elif key.endswith('__lte'):
query = query.where(
getattr(self.entity_class, key.replace("__gte", "")) <=
value)
elif '__' not in key:
query = query.where(
getattr(self.entity_class, key.replace("__gte", "")) ==
value)
return query
def query(self, query: peewee.ModelSelect) -> dict:
"""Custom query, returns a generator that will return
a dictionary (corresponding to a row).
Parameters:
query (peewee.ModelSelect) : Custom query.
"""
for res in query.dicts():
yield res
def query_to_pandas(self, query: peewee.ModelSelect, array_cols: list = None) -> pd.DataFrame:
"""Convert a model query to a pandas dataframe."""
df = pd.DataFrame(query.dicts())
if not array_cols:
array_cols = self._array_types # Try to use the new data to infer what the format should be
# Convert array columns to numpy arrays. Leave as string if not specified
if array_cols:
for key in array_cols:
df[key] = df.apply(lambda x: np.array(ast.literal_eval(x[key]), dtype=x[f'{key}_dtype']), axis=1)
df.drop(f'{key}_dtype', axis=1, inplace=True)
return df
def join_to_clusters(
base_citation_query: ModelSelect,
) -> Tuple[ModelSelect, ModelAlias, ModelAlias]:
CitingOpinion, CitedOpinion = Opinion.alias(), Opinion.alias()
CitingCluster, CitedCluster = Cluster.alias(), Cluster.alias()
return (
(base_citation_query.join_from(
Citation, CitingOpinion, on=Citation.citing_opinion).join_from(
Citation, CitedOpinion,
on=Citation.cited_opinion).join_from(
CitingOpinion,
CitingCluster).join_from(CitedOpinion, CitedCluster)),
CitingCluster,
CitedCluster,
)
def query_paginator(query: ModelSelect, mapping: typing.Callable[[_V], dict]):
size = try_or_fail_contrain(int, 'size', default='50')
max_constrain(50, 'size', size)
min_constrain(2, 'size', size)
offset = try_or_fail_contrain(int, 'offset', default='0')
min_constrain(0, 'offset', offset)
res = []
for obj in query.limit(size + 1).offset(offset):
res.append(mapping(obj))
more = len(res) > size
if more:
res[-1:] = []
return jsonify({
'more': more,
'next': offset + size if more else None,
'results': res,
})
def append_select(self, p_select: ModelSelect):
if not self.b_initialized:
return p_select
expression = None
for i in range(0, len(self.query_params.values), 2):
left_val = self.query_params.values[i]
right_val = self.query_params.values[i + 1]
expression_part = (self.left_field == left_val).bin_and(
self.right_field == right_val)
if not expression:
expression = expression_part
else:
expression = (expression | expression_part)
return p_select.where(expression)
def append_select(self, p_select: ModelSelect):
if self.query_params.sort_direction == epl_imagery_pb2.ASCENDING:
p_select = p_select.order_by(self.field)
elif self.query_params.sort_direction == epl_imagery_pb2.DESCENDING:
p_select = p_select.order_by(self.field.desc())
if self.query_params.values or self.query_params.excluded_values:
if self.query_params.values:
p_select = p_select.where(
self.field << list(self.query_params.values))
if self.query_params.excluded_values:
p_select = p_select.where(
~(self.field << list(self.query_params.excluded_values)))
if self.query_params.include_ranges:
p_select = p_select.where(
self._append_ranges(self.query_params.include_ranges, False))
if self.query_params.exclude_ranges:
p_select = p_select.where(
self._append_ranges(self.query_params.exclude_ranges, True))
return p_select
def _create_access_type(query: peewee.ModelSelect):
if query.count() == 0:
return AccessType.READ_WRITE
else:
return AccessType(query[0].access_type)
def _query_to_dataframe(cls, query: peewee.ModelSelect) -> pd.DataFrame:
dict_query = {indice: row for indice, row in enumerate(query.dicts())}
return pd.DataFrame.from_dict(dict_query, orient='index')