def anonymous_filter(self) -> Filter:
return search_util.create_subquery_filter(
model.Tag.tag_id,
model.TagName.tag_id,
model.TagName.name,
search_util.create_str_filter,
)
def anonymous_filter(self):
return search_util.create_subquery_filter(
db.Post.post_id,
db.PostTag.post_id,
db.TagName.name,
search_util.create_str_filter,
lambda subquery: subquery.join(db.Tag).join(db.TagName))
def anonymous_filter(self) -> Filter:
return search_util.create_subquery_filter(
model.Pool.pool_id,
model.PoolName.pool_id,
model.PoolName.name,
search_util.create_str_filter,
)
def anonymous_filter(self) -> Optional[Filter]:
return search_util.create_subquery_filter(
model.Post.post_id,
model.PostTag.post_id,
model.TagName.name,
search_util.create_str_filter,
lambda subquery: subquery.join(model.Tag).join(model.TagName))
def anonymous_filter(self) -> Optional[Filter]:
return search_util.create_subquery_filter(
model.Post.post_id,
model.PostTag.post_id,
model.TagName.name,
search_util.create_str_filter,
lambda subquery: subquery.join(model.Tag).join(model.TagName))
def named_filters(self) -> Dict[str, Filter]:
return util.unalias_dict([
(
["name"],
search_util.create_subquery_filter(
model.Tag.tag_id,
model.TagName.tag_id,
model.TagName.name,
search_util.create_str_filter,
),
),
(
["category"],
search_util.create_subquery_filter(
model.Tag.category_id,
model.TagCategory.tag_category_id,
model.TagCategory.name,
search_util.create_str_filter,
),
),
(
["creation-date", "creation-time"],
search_util.create_date_filter(model.Tag.creation_time),
),
(
[
"last-edit-date",
"last-edit-time",
"edit-date",
"edit-time",
],
search_util.create_date_filter(model.Tag.last_edit_time),
),
(
["usage-count", "post-count", "usages"],
search_util.create_num_filter(model.Tag.post_count),
),
(
["suggestion-count"],
search_util.create_num_filter(model.Tag.suggestion_count),
),
(
["implication-count"],
search_util.create_num_filter(model.Tag.implication_count),
),
])
def named_filters(self) -> Dict[str, Filter]:
return util.unalias_dict([
(
['name'],
search_util.create_subquery_filter(
model.Tag.tag_id,
model.TagName.tag_id,
model.TagName.name,
search_util.create_str_filter)
),
(
['category'],
search_util.create_subquery_filter(
model.Tag.category_id,
model.TagCategory.tag_category_id,
model.TagCategory.name,
search_util.create_str_filter)
),
(
['creation-date', 'creation-time'],
search_util.create_date_filter(model.Tag.creation_time)
),
(
['last-edit-date', 'last-edit-time', 'edit-date', 'edit-time'],
search_util.create_date_filter(model.Tag.last_edit_time)
),
(
['usage-count', 'post-count', 'usages'],
search_util.create_num_filter(model.Tag.post_count)
),
(
['suggestion-count'],
search_util.create_num_filter(model.Tag.suggestion_count)
),
(
['implication-count'],
search_util.create_num_filter(model.Tag.implication_count)
),
])
def named_filters(self) -> Dict[str, Filter]:
return util.unalias_dict([
(
['name'],
search_util.create_subquery_filter(
model.Tag.tag_id,
model.TagName.tag_id,
model.TagName.name,
search_util.create_str_filter)
),
(
['category'],
search_util.create_subquery_filter(
model.Tag.category_id,
model.TagCategory.tag_category_id,
model.TagCategory.name,
search_util.create_str_filter)
),
(
['creation-date', 'creation-time'],
search_util.create_date_filter(model.Tag.creation_time)
),
(
['last-edit-date', 'last-edit-time', 'edit-date', 'edit-time'],
search_util.create_date_filter(model.Tag.last_edit_time)
),
(
['usage-count', 'post-count', 'usages'],
search_util.create_num_filter(model.Tag.post_count)
),
(
['suggestion-count'],
search_util.create_num_filter(model.Tag.suggestion_count)
),
(
['implication-count'],
search_util.create_num_filter(model.Tag.implication_count)
),
])
def _note_filter(query: SaQuery, criterion: Optional[criteria.BaseCriterion],
negated: bool) -> SaQuery:
assert criterion
return search_util.create_subquery_filter(
model.Post.post_id,
model.PostNote.post_id,
model.PostNote.text,
search_util.create_str_filter,
)(query, criterion, negated)
def _pool_filter(query: SaQuery, criterion: Optional[criteria.BaseCriterion],
negated: bool) -> SaQuery:
assert criterion
return search_util.create_subquery_filter(
model.Post.post_id,
model.PoolPost.post_id,
model.PoolPost.pool_id,
search_util.create_num_filter,
)(query, criterion, negated)
def _note_filter(
query: SaQuery,
criterion: Optional[criteria.BaseCriterion],
negated: bool) -> SaQuery:
assert criterion
return search_util.create_subquery_filter(
model.Post.post_id,
model.PostNote.post_id,
model.PostNote.text,
search_util.create_str_filter)(query, criterion, negated)
def _user_filter(query: SaQuery, criterion: Optional[criteria.BaseCriterion],
negated: bool) -> SaQuery:
assert criterion
if isinstance(criterion, criteria.PlainCriterion) \
and not criterion.value:
# pylint: disable=singleton-comparison
expr = model.Post.user_id == None
if negated:
expr = ~expr
return query.filter(expr)
return search_util.create_subquery_filter(
model.Post.user_id, model.User.user_id, model.User.name,
search_util.create_str_filter)(query, criterion, negated)
def wrapper(query, criterion, negated):
if isinstance(criterion, criteria.PlainCriterion) \
and not criterion.value:
# pylint: disable=singleton-comparison
expr = db.Post.user_id == None
if negated:
expr = ~expr
return query.filter(expr)
return search_util.create_subquery_filter(
db.Post.user_id,
db.User.user_id,
db.User.name,
search_util.create_str_filter)(query, criterion, negated)
def named_filters(self) -> Dict[str, Filter]:
return util.unalias_dict([
(
["name"],
search_util.create_subquery_filter(
model.Pool.pool_id,
model.PoolName.pool_id,
model.PoolName.name,
search_util.create_str_filter,
),
),
(
["category"],
search_util.create_subquery_filter(
model.Pool.category_id,
model.PoolCategory.pool_category_id,
model.PoolCategory.name,
search_util.create_str_filter,
),
),
(
["creation-date", "creation-time"],
search_util.create_date_filter(model.Pool.creation_time),
),
(
[
"last-edit-date",
"last-edit-time",
"edit-date",
"edit-time",
],
search_util.create_date_filter(model.Pool.last_edit_time),
),
(
["post-count"],
search_util.create_num_filter(model.Pool.post_count),
),
])
def _user_filter(query: SaQuery, criterion: Optional[criteria.BaseCriterion],
negated: bool) -> SaQuery:
assert criterion
if isinstance(criterion, criteria.PlainCriterion) and not criterion.value:
expr = model.Post.user_id == None # noqa: E711
if negated:
expr = ~expr
return query.filter(expr)
return search_util.create_subquery_filter(
model.Post.user_id,
model.User.user_id,
model.User.name,
search_util.create_str_filter,
)(query, criterion, negated)
def named_filters(self):
return util.unalias_dict({
'name': search_util.create_subquery_filter(
db.Tag.tag_id,
db.TagName.tag_id,
db.TagName.name,
search_util.create_str_filter),
'category': search_util.create_subquery_filter(
db.Tag.category_id,
db.TagCategory.tag_category_id,
db.TagCategory.name,
search_util.create_str_filter),
('creation-date', 'creation-time'):
search_util.create_date_filter(db.Tag.creation_time),
('last-edit-date', 'last-edit-time', 'edit-date', 'edit-time'):
search_util.create_date_filter(db.Tag.last_edit_time),
('usage-count', 'post-count', 'usages'):
search_util.create_num_filter(db.Tag.post_count),
'suggestion-count':
search_util.create_num_filter(db.Tag.suggestion_count),
'implication-count':
search_util.create_num_filter(db.Tag.implication_count),
})
def _user_filter(
query: SaQuery,
criterion: Optional[criteria.BaseCriterion],
negated: bool) -> SaQuery:
assert criterion
if isinstance(criterion, criteria.PlainCriterion) \
and not criterion.value:
# pylint: disable=singleton-comparison
expr = model.Post.user_id == None
if negated:
expr = ~expr
return query.filter(expr)
return search_util.create_subquery_filter(
model.Post.user_id,
model.User.user_id,
model.User.name,
search_util.create_str_filter)(query, criterion, negated)
def named_filters(self) -> Dict[str, Filter]:
return util.unalias_dict([
(
['id'],
search_util.create_num_filter(model.Post.post_id)
),
(
['tag'],
search_util.create_subquery_filter(
model.Post.post_id,
model.PostTag.post_id,
model.TagName.name,
search_util.create_str_filter,
lambda subquery:
subquery.join(model.Tag).join(model.TagName))
),
(
['score'],
search_util.create_num_filter(model.Post.score)
),
(
['uploader', 'upload', 'submit'],
_user_filter
),
(
['comment'],
search_util.create_subquery_filter(
model.Post.post_id,
model.Comment.post_id,
model.User.name,
search_util.create_str_filter,
lambda subquery: subquery.join(model.User))
),
(
['fav'],
search_util.create_subquery_filter(
model.Post.post_id,
model.PostFavorite.post_id,
model.User.name,
search_util.create_str_filter,
lambda subquery: subquery.join(model.User))
),
(
['liked'],
_create_score_filter(1)
),
(
['disliked'],
_create_score_filter(-1)
),
(
['tag-count'],
search_util.create_num_filter(model.Post.tag_count)
),
(
['comment-count'],
search_util.create_num_filter(model.Post.comment_count)
),
(
['fav-count'],
search_util.create_num_filter(model.Post.favorite_count)
),
(
['note-count'],
search_util.create_num_filter(model.Post.note_count)
),
(
['relation-count'],
search_util.create_num_filter(model.Post.relation_count)
),
(
['feature-count'],
search_util.create_num_filter(model.Post.feature_count)
),
(
['type'],
search_util.create_str_filter(
model.Post.type, _type_transformer)
),
(
['content-checksum'],
search_util.create_str_filter(model.Post.checksum)
),
(
['file-size'],
search_util.create_num_filter(model.Post.file_size)
),
(
['image-width', 'width'],
search_util.create_num_filter(model.Post.canvas_width)
),
(
['image-height', 'height'],
search_util.create_num_filter(model.Post.canvas_height)
),
(
['image-area', 'area'],
search_util.create_num_filter(model.Post.canvas_area)
),
(
['image-aspect-ratio', 'image-ar', 'aspect-ratio', 'ar'],
search_util.create_num_filter(
model.Post.canvas_aspect_ratio,
transformer=search_util.float_transformer)
),
(
['creation-date', 'creation-time', 'date', 'time'],
search_util.create_date_filter(model.Post.creation_time)
),
(
['last-edit-date', 'last-edit-time', 'edit-date', 'edit-time'],
search_util.create_date_filter(model.Post.last_edit_time)
),
(
['comment-date', 'comment-time'],
search_util.create_date_filter(
model.Post.last_comment_creation_time)
),
(
['fav-date', 'fav-time'],
search_util.create_date_filter(model.Post.last_favorite_time)
),
(
['feature-date', 'feature-time'],
search_util.create_date_filter(model.Post.last_feature_time)
),
(
['safety', 'rating'],
search_util.create_str_filter(
model.Post.safety, _safety_transformer)
),
(
['note-text'],
_note_filter
),
(
['flag'],
search_util.create_str_filter(
model.Post.flags, _flag_transformer)
),
])
def named_filters(self) -> Dict[str, Filter]:
return util.unalias_dict([
(["id"], search_util.create_num_filter(model.Post.post_id)),
(
["tag"],
search_util.create_subquery_filter(
model.Post.post_id,
model.PostTag.post_id,
model.TagName.name,
search_util.create_str_filter,
lambda subquery: subquery.join(model.Tag).join(model.
TagName),
),
),
(["score"], search_util.create_num_filter(model.Post.score)),
(["uploader", "upload", "submit"], _user_filter),
(
["comment"],
search_util.create_subquery_filter(
model.Post.post_id,
model.Comment.post_id,
model.User.name,
search_util.create_str_filter,
lambda subquery: subquery.join(model.User),
),
),
(
["fav"],
search_util.create_subquery_filter(
model.Post.post_id,
model.PostFavorite.post_id,
model.User.name,
search_util.create_str_filter,
lambda subquery: subquery.join(model.User),
),
),
(["liked"], _create_score_filter(1)),
(["disliked"], _create_score_filter(-1)),
(
["source"],
search_util.create_str_filter(model.Post.source,
_source_transformer),
),
(
["tag-count"],
search_util.create_num_filter(model.Post.tag_count),
),
(
["comment-count"],
search_util.create_num_filter(model.Post.comment_count),
),
(
["fav-count"],
search_util.create_num_filter(model.Post.favorite_count),
),
(
["note-count"],
search_util.create_num_filter(model.Post.note_count),
),
(
["relation-count"],
search_util.create_num_filter(model.Post.relation_count),
),
(
["feature-count"],
search_util.create_num_filter(model.Post.feature_count),
),
(
["type"],
search_util.create_str_filter(model.Post.type,
_type_transformer),
),
(
["content-checksum", "sha1"],
search_util.create_str_filter(model.Post.checksum),
),
(
["md5"],
search_util.create_str_filter(model.Post.checksum_md5),
),
(
["file-size"],
search_util.create_num_filter(model.Post.file_size),
),
(
["image-width", "width"],
search_util.create_num_filter(model.Post.canvas_width),
),
(
["image-height", "height"],
search_util.create_num_filter(model.Post.canvas_height),
),
(
["image-area", "area"],
search_util.create_num_filter(model.Post.canvas_area),
),
(
["image-aspect-ratio", "image-ar", "aspect-ratio", "ar"],
search_util.create_num_filter(
model.Post.canvas_aspect_ratio,
transformer=search_util.float_transformer,
),
),
(
[
"creation-date",
"creation-time",
"date",
"time",
"posted",
],
search_util.create_date_filter(model.Post.creation_time),
),
(
[
"last-edit-date",
"last-edit-time",
"edit-date",
"edit-time",
"edited",
],
search_util.create_date_filter(model.Post.last_edit_time),
),
(
["date-taken", "time-taken", "taken"],
search_util.create_date_filter(model.Post.date_taken),
),
(
["comment-date", "comment-time"],
search_util.create_date_filter(
model.Post.last_comment_creation_time),
),
(
["fav-date", "fav-time"],
search_util.create_date_filter(model.Post.last_favorite_time),
),
(
["feature-date", "feature-time"],
search_util.create_date_filter(model.Post.last_feature_time),
),
(
["safety", "rating"],
search_util.create_str_filter(model.Post.safety,
_safety_transformer),
),
(["note-text"], _note_filter),
(
["flag"],
search_util.create_str_filter(model.Post.flags_string,
_flag_transformer),
),
(["pool"], _pool_filter),
])
def anonymous_filter(self) -> Filter:
return search_util.create_subquery_filter(
model.Tag.tag_id,
model.TagName.tag_id,
model.TagName.name,
search_util.create_str_filter)
def named_filters(self) -> Dict[str, Filter]:
return util.unalias_dict([
(
['id'],
search_util.create_num_filter(model.Post.post_id)
),
(
['tag'],
search_util.create_subquery_filter(
model.Post.post_id,
model.PostTag.post_id,
model.TagName.name,
search_util.create_str_filter,
lambda subquery:
subquery.join(model.Tag).join(model.TagName))
),
(
['score'],
search_util.create_num_filter(model.Post.score)
),
(
['uploader', 'upload', 'submit'],
_user_filter
),
(
['comment'],
search_util.create_subquery_filter(
model.Post.post_id,
model.Comment.post_id,
model.User.name,
search_util.create_str_filter,
lambda subquery: subquery.join(model.User))
),
(
['fav'],
search_util.create_subquery_filter(
model.Post.post_id,
model.PostFavorite.post_id,
model.User.name,
search_util.create_str_filter,
lambda subquery: subquery.join(model.User))
),
(
['liked'],
_create_score_filter(1)
),
(
['disliked'],
_create_score_filter(-1)
),
(
['source'],
search_util.create_str_filter(
model.Post.source, _source_transformer)
),
(
['tag-count'],
search_util.create_num_filter(model.Post.tag_count)
),
(
['comment-count'],
search_util.create_num_filter(model.Post.comment_count)
),
(
['fav-count'],
search_util.create_num_filter(model.Post.favorite_count)
),
(
['note-count'],
search_util.create_num_filter(model.Post.note_count)
),
(
['relation-count'],
search_util.create_num_filter(model.Post.relation_count)
),
(
['feature-count'],
search_util.create_num_filter(model.Post.feature_count)
),
(
['type'],
search_util.create_str_filter(
model.Post.type, _type_transformer)
),
(
['content-checksum'],
search_util.create_str_filter(model.Post.checksum)
),
(
['file-size'],
search_util.create_num_filter(model.Post.file_size)
),
(
['image-width', 'width'],
search_util.create_num_filter(model.Post.canvas_width)
),
(
['image-height', 'height'],
search_util.create_num_filter(model.Post.canvas_height)
),
(
['image-area', 'area'],
search_util.create_num_filter(model.Post.canvas_area)
),
(
['image-aspect-ratio', 'image-ar', 'aspect-ratio', 'ar'],
search_util.create_num_filter(
model.Post.canvas_aspect_ratio,
transformer=search_util.float_transformer)
),
(
['creation-date', 'creation-time', 'date', 'time'],
search_util.create_date_filter(model.Post.creation_time)
),
(
['last-edit-date', 'last-edit-time', 'edit-date', 'edit-time'],
search_util.create_date_filter(model.Post.last_edit_time)
),
(
['comment-date', 'comment-time'],
search_util.create_date_filter(
model.Post.last_comment_creation_time)
),
(
['fav-date', 'fav-time'],
search_util.create_date_filter(model.Post.last_favorite_time)
),
(
['feature-date', 'feature-time'],
search_util.create_date_filter(model.Post.last_feature_time)
),
(
['safety', 'rating'],
search_util.create_str_filter(
model.Post.safety, _safety_transformer)
),
(
['note-text'],
_note_filter
),
(
['flag'],
search_util.create_str_filter(
model.Post.flags_string, _flag_transformer)
),
])
def anonymous_filter(self):
return search_util.create_subquery_filter(
db.Tag.tag_id,
db.TagName.tag_id,
db.TagName.name,
search_util.create_str_filter)
def named_filters(self):
return util.unalias_dict({
'id': search_util.create_num_filter(db.Post.post_id),
'tag': search_util.create_subquery_filter(
db.Post.post_id,
db.PostTag.post_id,
db.TagName.name,
search_util.create_str_filter,
lambda subquery: subquery.join(db.Tag).join(db.TagName)),
'score': search_util.create_num_filter(db.Post.score),
('uploader', 'upload', 'submit'):
_create_user_filter(),
'comment': search_util.create_subquery_filter(
db.Post.post_id,
db.Comment.post_id,
db.User.name,
search_util.create_str_filter,
lambda subquery: subquery.join(db.User)),
'fav': search_util.create_subquery_filter(
db.Post.post_id,
db.PostFavorite.post_id,
db.User.name,
search_util.create_str_filter,
lambda subquery: subquery.join(db.User)),
'liked': _create_score_filter(1),
'disliked': _create_score_filter(-1),
'tag-count': search_util.create_num_filter(db.Post.tag_count),
'comment-count':
search_util.create_num_filter(db.Post.comment_count),
'fav-count':
search_util.create_num_filter(db.Post.favorite_count),
'note-count': search_util.create_num_filter(db.Post.note_count),
'relation-count':
search_util.create_num_filter(db.Post.relation_count),
'feature-count':
search_util.create_num_filter(db.Post.feature_count),
'type':
search_util.create_str_filter(
db.Post.type, _type_transformer),
'content-checksum': search_util.create_str_filter(
db.Post.checksum),
'file-size': search_util.create_num_filter(db.Post.file_size),
('image-width', 'width'):
search_util.create_num_filter(db.Post.canvas_width),
('image-height', 'height'):
search_util.create_num_filter(db.Post.canvas_height),
('image-area', 'area'):
search_util.create_num_filter(db.Post.canvas_area),
('creation-date', 'creation-time', 'date', 'time'):
search_util.create_date_filter(db.Post.creation_time),
('last-edit-date', 'last-edit-time', 'edit-date', 'edit-time'):
search_util.create_date_filter(db.Post.last_edit_time),
('comment-date', 'comment-time'):
search_util.create_date_filter(
db.Post.last_comment_creation_time),
('fav-date', 'fav-time'):
search_util.create_date_filter(db.Post.last_favorite_time),
('feature-date', 'feature-time'):
search_util.create_date_filter(db.Post.last_feature_time),
('safety', 'rating'):
search_util.create_str_filter(
db.Post.safety, _safety_transformer),
})
