Beispiel #1
0
def result():
    if not request.args:
        return redirect(url_for('hello'))
    all_languages = any_(['ru', 'sr'])
    all_semantics = any_([x.semantics for x in session.query(Semantics).all()])
    all_speech_acts = any_(
        [x.speech_act for x in session.query(SpeechAct).all()])
    word = request.args.get('word')
    language = request.args.get('language')
    if not language:
        language = all_languages
    pr_sem = request.args.get('pr_sem')
    if not pr_sem:
        pr_sem = all_semantics
    speech_act = request.args.get('speech_act')
    if not speech_act:
        speech_act = all_speech_acts
    add_sem = request.args.getlist('add_sem')
    if not add_sem:
        add_sem = all_semantics
    else:
        add_sem = any_(add_sem)

    new_query = session.query(DF)
    records = new_query.filter(
        DF.language == language,
        DF.primary_semantics.has(Semantics.semantics == pr_sem),
        DF.speech_act.has(SpeechAct.speech_act == speech_act),
        DF.additional_semantics.has(Semantics.semantics == add_sem)).all()

    records = merge_dfs(records)

    return render_template('result.html', records=records)
Beispiel #2
0
def _update_feed_entries(source_user_id, target_user_id):
    # Transfer feed entries to the target user only if no similar entry
    # already exists in the target user feed items.
    shared_doc_ids = DBSession.query(DocumentChange.document_id). \
        filter(DocumentChange.user_id == target_user_id). \
        intersect(
            DBSession.query(DocumentChange.document_id).
            filter(DocumentChange.user_id == source_user_id)
        ).subquery()
    DBSession.execute(
        DocumentChange.__table__.update().where(and_(
            DocumentChange.user_id == source_user_id,
            ~DocumentChange.document_id.in_(shared_doc_ids)
        )).values({
            DocumentChange.user_id: target_user_id
        })
    )
    # Remove remaining feed items since they already exist for the target user
    DBSession.query(DocumentChange). \
        filter(DocumentChange.user_id == source_user_id).delete()

    # If target user_id is already in the list of users associated
    # to feed items (user_ids), simply remove source user_id from the list:
    DBSession.execute(
        DocumentChange.__table__.update().where(and_(
            any_(DocumentChange.user_ids) == source_user_id,
            any_(DocumentChange.user_ids) == target_user_id
        )).values({
            DocumentChange.user_ids: func.array_remove(
                DocumentChange.user_ids, source_user_id)
        })
    )
    # Else replace source user_id by target user_id in user_ids
    DBSession.execute(
        DocumentChange.__table__.update().where(
            any_(DocumentChange.user_ids) == source_user_id
        ).values({
            DocumentChange.user_ids: func.array_replace(
                DocumentChange.user_ids, source_user_id, target_user_id)
        })
    )

    # Remove subscriptions to/of the source user
    DBSession.query(FollowedUser). \
        filter(or_(
            FollowedUser.followed_user_id == source_user_id,
            FollowedUser.follower_user_id == source_user_id
        )).delete()

    # Remove feed filter prefs
    DBSession.query(FilterArea). \
        filter(FilterArea.user_id == source_user_id).delete()
 def find_by_year_and_genere(cls, _year, _genre):
     return cls.query.filter(
                                 and_(
                                     _genre == any_(cls.genres),
                                     cls.startYear == datetime.strptime(_year, '%Y')
                                     )
                                ).order_by(cls.primaryTitle)
Beispiel #4
0
def tag_array(tagids):
    if not tagids:
        return None
    st = d.meta.tables['searchtag']
    return sa.func.array(
        sa.select([st.c.title])
        .where(st.c.tagid == any_(list(tagids)))
        .as_scalar())
Beispiel #5
0
    def list(pred_id: int, task_type: str):
        filters = []

        if pred_id is not None:
            filters.append(Task.pred_id == pred_id)
        if task_type is not None:
            filters.append(Task.type.like(any_(task_type)))

        return Task.query.filter(*filters)
Beispiel #6
0
    def bucket_links(cls, identities):
        if not identities:
            return []
        q = (cls.get_media_query().filter(
            getattr(cls, cls._identity) == any_(list(identities))))

        buckets = {identity: {} for identity in identities}
        for link in q:
            media_data = link.media_item.serialize(link=link)
            buckets[getattr(link,
                            cls._identity)].setdefault(link.link_type,
                                                       []).append(media_data)
        return list(buckets.values())
Beispiel #7
0
def select_list(map_table, targetids):
    if not targetids:
        return {}

    mt = map_table
    q = (
        d.sa
        .select([mt.c.targetid, d.sa.func.array_agg(mt.c.tagid)])
        .select_from(mt)
        .where(mt.c.targetid == any_(targetids))
        .group_by(mt.c.targetid))

    db = d.connect()
    return dict(list(db.execute(q)))
 def find_by_movie(cls, _knownForTitles: str):
     return cls.query.filter(
         _knownForTitles == any_(cls.knownForTitles)).all()
Beispiel #9
0
def get_group_topics(  # noqa
        request: Request, after: Optional[str], before: Optional[str],
        order: Optional[TopicSortOption], per_page: int,
        rank_start: Optional[int], tag: Optional[Ltree], unfiltered: bool,
        **kwargs: Any) -> dict:
    """Get a listing of topics in the group."""
    # period needs special treatment so we can distinguish between missing and None
    period = kwargs.get("period", missing)

    is_home_page = request.matched_route.name == "home"

    if is_home_page:
        # on the home page, include topics from the user's subscribed groups
        # (or all groups, if logged-out)
        if request.user:
            groups = [sub.group for sub in request.user.subscriptions]
        else:
            groups = [
                group for group in request.query(Group).all()
                if group.path != "test"
            ]
        subgroups = None
    else:
        # otherwise, just topics from the single group that we're looking at
        groups = [request.context]

        subgroups = (request.query(Group).filter(
            Group.path.descendant_of(request.context.path),
            Group.path != request.context.path,
        ).all())

    default_settings = _get_default_settings(request, order)

    if not order:
        order = default_settings.order

    if period is missing:
        period = default_settings.period

    # set up the basic query for topics
    query = (request.query(Topic).join_all_relationships().inside_groups(
        groups, include_subgroups=not is_home_page).exclude_ignored().
             apply_sort_option(order))

    # restrict the time period, if not set to "all time"
    if period:
        query = query.inside_time_period(period)

    # restrict to a specific tag, if we're viewing a single one
    if tag:
        query = query.has_tag(str(tag))

    # apply before/after pagination restrictions if relevant
    if before:
        query = query.before_id36(before)

    if after:
        query = query.after_id36(after)

    # apply topic tag filters unless they're disabled or viewing a single tag
    if request.user and request.user.filtered_topic_tags and not (tag or
                                                                  unfiltered):
        query = query.filter(~Topic.tags.descendant_of(  # type: ignore
            any_(cast(request.user.filtered_topic_tags, TagList))))

    topics = query.get_page(per_page)

    # don't show pinned topics on home page
    if request.matched_route.name == "home":
        pinned_topics = []
    else:
        # get pinned topics
        pinned_query = (request.query(Topic).join_all_relationships(
        ).inside_groups(groups).is_pinned(True).apply_sort_option(order))

        pinned_topics = pinned_query.all()

    period_options = [
        SimpleHoursPeriod(hours) for hours in (1, 12, 24, 72, 168)
    ]

    # add the current period to the bottom of the dropdown if it's not one of the
    # "standard" ones
    if period and period not in period_options:
        period_options.append(period)

    if isinstance(request.context, Group):
        wiki_pages = (request.query(GroupWikiPage).filter(
            GroupWikiPage.group == request.context).order_by(
                GroupWikiPage.path).all())

        # remove the index from the page list, we'll output it separately
        if any(page.path == "index" for page in wiki_pages):
            wiki_has_index = True
            wiki_pages = [page for page in wiki_pages if page.path != "index"]
        else:
            wiki_has_index = False
    else:
        wiki_pages = None
        wiki_has_index = False

    if isinstance(request.context, Group):
        # Get the most recent topic from each scheduled topic in this group
        # I'm not even going to attempt to write this query in pure SQLAlchemy
        topic_id_subquery = """
            SELECT topic_id FROM (SELECT topic_id, schedule_id, row_number() OVER
            (PARTITION BY schedule_id ORDER BY created_time DESC) AS rownum FROM topics)
            AS t WHERE schedule_id IS NOT NULL AND rownum = 1
        """
        most_recent_scheduled_topics = (
            request.query(Topic).join(TopicSchedule).filter(
                Topic.topic_id.in_(text(topic_id_subquery)),  # type: ignore
                TopicSchedule.group == request.context,
                TopicSchedule.next_post_time != None,  # noqa
            ).order_by(TopicSchedule.next_post_time).all())
    else:
        most_recent_scheduled_topics = None

    if is_home_page:
        financial_data = get_financial_data(request.db_session)
    else:
        financial_data = None

    return {
        "group":
        request.context,
        "groups":
        groups,
        "topics":
        topics,
        "pinned_topics":
        pinned_topics,
        "order":
        order,
        "order_options":
        TopicSortOption,
        "period":
        period,
        "period_options":
        period_options,
        "is_default_period":
        period == default_settings.period,
        "is_default_view": (period == default_settings.period
                            and order == default_settings.order),
        "rank_start":
        rank_start,
        "tag":
        tag,
        "unfiltered":
        unfiltered,
        "wiki_pages":
        wiki_pages,
        "wiki_has_index":
        wiki_has_index,
        "subgroups":
        subgroups,
        "most_recent_scheduled_topics":
        most_recent_scheduled_topics,
        "financial_data":
        financial_data,
        "current_time":
        utc_now(),
    }
Beispiel #10
0
def get_group_topics(
    request: Request,
    order: Any,  # more specific would be better, but missing isn't typed
    period: Any,  # more specific would be better, but missing isn't typed
    after: str,
    before: str,
    per_page: int,
    rank_start: Optional[int],
    tag: Optional[Ltree],
    unfiltered: bool,
) -> dict:
    """Get a listing of topics in the group."""
    # pylint: disable=too-many-arguments, too-many-branches, too-many-locals
    if request.matched_route.name == "home":
        # on the home page, include topics from the user's subscribed groups
        # (or all groups, if logged-out)
        if request.user:
            groups = [sub.group for sub in request.user.subscriptions]
        else:
            groups = [
                group for group in request.query(Group).all()
                if group.path != "test"
            ]
    else:
        # otherwise, just topics from the single group that we're looking at
        groups = [request.context]

    default_settings = _get_default_settings(request, order)

    if order is missing:
        order = default_settings.order

    if period is missing:
        period = default_settings.period

    # set up the basic query for topics
    query = (request.query(Topic).join_all_relationships().inside_groups(
        groups).apply_sort_option(order))

    # restrict the time period, if not set to "all time"
    if period:
        query = query.inside_time_period(period)

    # restrict to a specific tag, if we're viewing a single one
    if tag:
        query = query.has_tag(tag)

    # apply before/after pagination restrictions if relevant
    if before:
        query = query.before_id36(before)

    if after:
        query = query.after_id36(after)

    # apply topic tag filters unless they're disabled or viewing a single tag
    if request.user and not (tag or unfiltered):
        # pylint: disable=protected-access
        query = query.filter(~Topic._tags.descendant_of(  # type: ignore
            any_(cast(request.user._filtered_topic_tags, ArrayOfLtree))))

    topics = query.get_page(per_page)

    period_options = [
        SimpleHoursPeriod(hours) for hours in (1, 12, 24, 72, 168)
    ]

    # add the current period to the bottom of the dropdown if it's not one of the
    # "standard" ones
    if period and period not in period_options:
        period_options.append(period)

    if isinstance(request.context, Group):
        wiki_pages = (request.query(GroupWikiPage).filter(
            GroupWikiPage.group == request.context).order_by(
                GroupWikiPage.slug).all())

        # remove the index from the page list, we'll output it separately
        if any(page.slug == "index" for page in wiki_pages):
            wiki_has_index = True
            wiki_pages = [page for page in wiki_pages if page.slug != "index"]
        else:
            wiki_has_index = False
    else:
        wiki_pages = None
        wiki_has_index = False

    return {
        "group":
        request.context,
        "groups":
        groups,
        "topics":
        topics,
        "order":
        order,
        "order_options":
        TopicSortOption,
        "period":
        period,
        "period_options":
        period_options,
        "is_default_period":
        period == default_settings.period,
        "is_default_view": (period == default_settings.period
                            and order == default_settings.order),
        "rank_start":
        rank_start,
        "tag":
        tag,
        "unfiltered":
        unfiltered,
        "wiki_pages":
        wiki_pages,
        "wiki_has_index":
        wiki_has_index,
    }
Beispiel #11
0
 def _count_associated_feed_entries(self, user_id):
     return self.session.query(DocumentChange). \
         filter(any_(DocumentChange.user_ids) == user_id).count()
Beispiel #12
0
    intonations = {line['intonation_id'], line['source_construction_intonation_id']}
    pr_ints = set([x.intonation for x in session.query(Intonation).all()])
    lack_ints = intonations - pr_ints
    for intonation in lack_ints:
        nums = session.query(Intonation).all()
        if nums:
            num = nums[-1].id
        else:
            num = 0
        element = Intonation(id=num+1, intonation=intonation)
        session.add(element)

    ps = session.query(Semantics).filter_by(semantics=prim_sem[0]).one()
    line['primary_semantics_id'] = ps.id

    ads = session.query(Semantics).filter_by(semantics=any_(add_sem)).all()
    line['additional_semantics_id'] = '|'.join([str(x.id) for x in ads])

    sas = session.query(SpeechAct).filter_by(speech_act=line['speech_act_1_id']).one()
    line['speech_act_1_id'] = sas.id

    sa_1s = session.query(SpeechAct).filter_by(speech_act=line['speech_act_id']).one()
    line['speech_act_id'] = sa_1s.id

    intonations = session.query(Intonation).filter_by(intonation=str(line['intonation_id'])).one()
    line['intonation_id'] = intonations.id

    intonantions_source = session.query(Intonation).filter_by(
        intonation=str(line['source_construction_intonation_id'])
    ).all()
Beispiel #13
0
def get_group_topics(  # noqa
        request: Request, after: Optional[str], before: Optional[str],
        order: Optional[TopicSortOption], per_page: int,
        rank_start: Optional[int], tag: Optional[Ltree], unfiltered: bool,
        **kwargs: Any) -> dict:
    """Get a listing of topics in the group."""
    # period needs special treatment so we can distinguish between missing and None
    period = kwargs.get("period", missing)

    is_home_page = request.matched_route.name in [
        "home", "home_atom", "home_rss"
    ]
    is_atom = request.matched_route.name in ["home_atom", "group_topics_atom"]
    is_rss = request.matched_route.name in ["home_rss", "group_topics_rss"]

    if is_home_page:
        # on the home page, include topics from the user's subscribed groups
        # (or all groups, if logged-out)
        if request.user:
            groups = [sub.group for sub in request.user.subscriptions]
        else:
            groups = [
                group for group in request.query(Group).all()
                if group.path != "test"
            ]
        subgroups = None
    else:
        # otherwise, just topics from the single group that we're looking at
        groups = [request.context]

        subgroups = (request.query(Group).filter(
            Group.path.descendant_of(request.context.path),
            Group.path != request.context.path,
        ).all())

    default_settings = _get_default_settings(request, order)

    if not order:
        order = default_settings.order

    if period is missing:
        period = default_settings.period

    # force Newest sort order, and All Time period, for RSS feeds
    if is_atom or is_rss:
        order = TopicSortOption.NEW
        period = None

    # set up the basic query for topics
    query = (request.query(Topic).join_all_relationships().inside_groups(
        groups, include_subgroups=not is_home_page).exclude_ignored().
             apply_sort_option(order))

    # restrict the time period, if not set to "all time"
    if period:
        query = query.inside_time_period(period)

    # restrict to a specific tag, if we're viewing a single one
    if tag:
        query = query.has_tag(str(tag))

    # apply before/after pagination restrictions if relevant
    if before:
        query = query.before_id36(before)

    if after:
        query = query.after_id36(after)

    # apply topic tag filters unless they're disabled
    if request.user and request.user.filtered_topic_tags and not unfiltered:
        filtered_topic_tags = request.user.filtered_topic_tags

        # if viewing single tag, don't filter that tag and its ancestors
        # for example, if viewing "ask.survey", don't filter "ask.survey" or "ask"
        if tag:
            filtered_topic_tags = [
                ft for ft in filtered_topic_tags
                if not tag.descendant_of(ft.replace(" ", "_"))
            ]

        query = query.filter(~Topic.tags.descendant_of(  # type: ignore
            any_(cast(filtered_topic_tags, TagList))))

    topics = query.get_page(per_page)

    period_options = [
        SimpleHoursPeriod(hours) for hours in (1, 12, 24, 72, 168)
    ]

    # add the current period to the bottom of the dropdown if it's not one of the
    # "standard" ones
    if period and period not in period_options:
        period_options.append(period)

    if isinstance(request.context, Group):
        wiki_pages = (request.query(GroupWikiPage).filter(
            GroupWikiPage.group == request.context).order_by(
                GroupWikiPage.path).all())

        # remove the index from the page list, we'll output it separately
        if any(page.path == "index" for page in wiki_pages):
            wiki_has_index = True
            wiki_pages = [page for page in wiki_pages if page.path != "index"]
        else:
            wiki_has_index = False
    else:
        wiki_pages = None
        wiki_has_index = False

    if isinstance(request.context, Group):
        # Get the most recent topic from each scheduled topic in this group
        group_schedules = (
            request.query(TopicSchedule).options(
                joinedload(TopicSchedule.latest_topic)).filter(
                    TopicSchedule.group == request.context,
                    TopicSchedule.next_post_time != None,  # noqa
                ).order_by(TopicSchedule.next_post_time).all())
        most_recent_scheduled_topics = [
            schedule.latest_topic for schedule in group_schedules
        ]
    else:
        most_recent_scheduled_topics = []

    if is_home_page:
        financial_data = get_financial_data(request.db_session)
    else:
        financial_data = None

    if is_atom:
        request.response.content_type = "application/atom+xml"
    if is_rss:
        request.response.content_type = "application/rss+xml"

    return {
        "group":
        request.context,
        "groups":
        groups,
        "topics":
        topics,
        "order":
        order,
        "order_options":
        TopicSortOption,
        "period":
        period,
        "period_options":
        period_options,
        "is_default_period":
        period == default_settings.period,
        "is_default_view": (period == default_settings.period
                            and order == default_settings.order),
        "rank_start":
        rank_start,
        "tag":
        tag,
        "unfiltered":
        unfiltered,
        "wiki_pages":
        wiki_pages,
        "wiki_has_index":
        wiki_has_index,
        "subgroups":
        subgroups,
        "most_recent_scheduled_topics":
        most_recent_scheduled_topics,
        "financial_data":
        financial_data,
        "current_time":
        utc_now(),
    }