Python Subreddit.user_subreddits方法代码示例

# 需要导入模块: from r2.models import Subreddit [as 别名]
# 或者: from r2.models.Subreddit import user_subreddits [as 别名]
def srids_from_site(user, site):
    if not isinstance(site, FakeSubreddit):
        srids = {site._id}
    elif isinstance(site, MultiReddit):
        srids = set(site.sr_ids)
    elif user and not isinstance(user, FakeAccount):
        srids = set(Subreddit.user_subreddits(user, ids=True) + [""])
    else:
        srids = set(Subreddit.user_subreddits(None, ids=True) + [""])
    return srids

# 需要导入模块: from r2.models import Subreddit [as 别名]
# 或者: from r2.models.Subreddit import user_subreddits [as 别名]
def srnames_from_site(user, site):
    if not isinstance(site, FakeSubreddit):
        srnames = {site.name}
    elif isinstance(site, MultiReddit):
        srnames = {sr.name for sr in site.srs}
    elif user and not isinstance(user, FakeAccount):
        srnames = {sr.name for sr in Subreddit.user_subreddits(user, ids=False)}
        srnames.add(Frontpage.name)
    else:
        srnames = {sr.name for sr in Subreddit.user_subreddits(None, ids=False)}
        srnames.add(Frontpage.name)
    return srnames

# 需要导入模块: from r2.models import Subreddit [as 别名]
# 或者: from r2.models.Subreddit import user_subreddits [as 别名]
def filter_links(links, filter_spam = False, multiple = True):
    # run the list through a builder to remove any that the user
    # isn't allowed to see
    from pylons import c
    from r2.models import IDBuilder, Link, Subreddit, NotFound
    links = IDBuilder([link._fullname for link in links],
                      skip = False).get_items()[0]
    if not links:
        return

    if filter_spam:
        # first, try to remove any spam
        links_nonspam = [ link for link in links
                          if not link._spam ]
        if links_nonspam:
            links = links_nonspam

    # if it occurs in one or more of their subscriptions, show them
    # that one first
    subs = set(Subreddit.user_subreddits(c.user, limit = None))
    def cmp_links(a, b):
        if a.sr_id in subs and b.sr_id not in subs:
            return -1
        elif a.sr_id not in subs and b.sr_id in subs:
            return 1
        else:
            return cmp(b._hot, a._hot)
    links = sorted(links, cmp = cmp_links)

    # among those, show them the hottest one
    return links if multiple else links[0]

# 需要导入模块: from r2.models import Subreddit [as 别名]
# 或者: from r2.models.Subreddit import user_subreddits [as 别名]
    def __init__(self):
        Wrapped.__init__(self)

        my_reddits = []
        sr_ids = Subreddit.user_subreddits(c.user if c.user_is_loggedin else None)
        if sr_ids:
            my_reddits = Subreddit._byID(sr_ids, True,
                                         return_dict = False)
            my_reddits.sort(key = lambda sr: sr.name.lower())

        drop_down_buttons = []    
        for sr in my_reddits:
            drop_down_buttons.append(SubredditButton(sr))

        #leaving the 'home' option out for now
        #drop_down_buttons.insert(0, NamedButton('home', sr_path = False,
        #                                        css_class = 'top-option',
        #                                        dest = '/'))
        drop_down_buttons.append(NamedButton('edit', sr_path = False,
                                             css_class = 'bottom-option',
                                             dest = '/reddits/'))
        self.sr_dropdown = SubredditMenu(drop_down_buttons,
                                         title = _('my reddits'),
                                         type = 'srdrop')

    
        pop_reddits = Subreddit.default_srs(c.content_langs, limit = 30)        
        buttons = [SubredditButton(sr) for sr in c.recent_reddits]
        for sr in pop_reddits:
            if sr not in c.recent_reddits:
                buttons.append(SubredditButton(sr))
    
        self.sr_bar = NavMenu(buttons, type='flatlist', separator = '-',
                                        _id = 'sr-bar')

# 需要导入模块: from r2.models import Subreddit [as 别名]
# 或者: from r2.models.Subreddit import user_subreddits [as 别名]
def srnames_from_site(user, site, include_subscriptions=True):
    is_logged_in = user and not isinstance(user, FakeAccount)
    over_18 = is_site_over18(site)
    srnames = set()

    if not isinstance(site, FakeSubreddit):
        srnames.add(site.name)
    elif isinstance(site, MultiReddit):
        srnames = srnames | {sr.name for sr in site.srs}
    else:
        srnames.add(Frontpage.name)

        if is_logged_in and include_subscriptions:
            subscriptions = Subreddit.user_subreddits(user, ids=False)

            # only use subreddits that aren't quarantined and have the same
            # age gate as the subreddit being viewed.
            subscriptions = filter(lambda sr: not sr.quarantine and sr.over_18 == over_18, subscriptions)

            subscription_srnames = {sr.name for sr in subscriptions}

            # remove any subscriptions that may have nsfw ads targeting
            # them because they're apart of a nsfw collection.
            nsfw_collection_srnames = get_nsfw_collections_srnames()

            if not over_18:
                subscription_srnames = subscription_srnames - nsfw_collection_srnames

            srnames = srnames | subscription_srnames

    return srnames

# 需要导入模块: from r2.models import Subreddit [as 别名]
# 或者: from r2.models.Subreddit import user_subreddits [as 别名]
    def nav(self):
        sr_ids = Subreddit.user_subreddits(c.user) if c.default_sr else [c.site._id]
        cloud = Tag.tag_cloud_for_subreddits(sr_ids)

        buttons =[]
        for tag, weight in cloud:
            buttons.append(NavButton(tag.name, tag.name, css_class=self.numbers[weight - 1]))

        return NavMenu(buttons, type="flatlist", separator=' ', base_path='/tag/')

# 需要导入模块: from r2.models import Subreddit [as 别名]
# 或者: from r2.models.Subreddit import user_subreddits [as 别名]
 def init_builder(self):
     user = c.user if c.user_is_loggedin else None
     sr_ids = Subreddit.user_subreddits(user)
     return UnbannedCommentBuilder(
         self.query(),
         sr_ids,
         num = 5,
         wrap = RecentItems.wrap_thing,
         skip = True
     )

# 需要导入模块: from r2.models import Subreddit [as 别名]
# 或者: from r2.models.Subreddit import user_subreddits [as 别名]
def get_promotion_list(user, site):
    if not isinstance(site, FakeSubreddit):
        srids = set([site._id])
    elif isinstance(site, MultiReddit):
        srids = set(site.sr_ids)
    elif user and not isinstance(user, FakeAccount):
        srids = set(Subreddit.reverse_subscriber_ids(user) + [""])
    else:
        srids = set(Subreddit.user_subreddits(None, ids=True) + [""])

    tuples = get_promotion_list_cached(srids)
    return [PromoTuple(*t) for t in tuples]

# 需要导入模块: from r2.models import Subreddit [as 别名]
# 或者: from r2.models.Subreddit import user_subreddits [as 别名]
def get_promotion_list(user, site):
    # site is specified, pick an ad from that site
    if not isinstance(site, FakeSubreddit):
        srids = set([site._id])
    elif isinstance(site, MultiReddit):
        srids = set(site.sr_ids)
    # site is Fake, user is not.  Pick based on their subscriptions.
    elif user and not isinstance(user, FakeAccount):
        srids = set(Subreddit.reverse_subscriber_ids(user) + [""])
    # both site and user are "fake" -- get the default subscription list
    else:
        srids = set(Subreddit.user_subreddits(None, True) + [""])

    return get_promotions_cached(srids)

# 需要导入模块: from r2.models import Subreddit [as 别名]
# 或者: from r2.models.Subreddit import user_subreddits [as 别名]
def assign_trial(account, ip, slash16):
    from r2.models import Jury, Subreddit, Trial
    from r2.lib.db import queries

    defendants_voted_upon = []
    defendants_assigned_to = []
    for jury in Jury.by_account(account):
        defendants_assigned_to.append(jury._thing2_id)
        if jury._name != '0':
            defendants_voted_upon.append(jury._thing2_id)

    subscribed_sr_ids = Subreddit.user_subreddits(account, ids=True, limit=None)

    # Pull defendants, except ones which already have lots of juryvotes
    defs = Trial.all_defendants(quench=True)

    # Filter out defendants outside this user's subscribed SRs
    defs = filter (lambda d: d.sr_id in subscribed_sr_ids, defs)

    # Dictionary of sr_id => SR for all defendants' SRs
    srs = Subreddit._byID(set([ d.sr_id for d in defs ]))

    # Dictionary of sr_id => eligibility bool
    submit_srs = {}
    for sr_id, sr in srs.iteritems():
        submit_srs[sr_id] = sr.can_submit(account) and not sr._spam

    # Filter out defendants with ineligible SRs
    defs = filter (lambda d: submit_srs.get(d.sr_id), defs)

    likes = queries.get_likes(account, defs)

    if not g.debug:
        # Filter out things that the user has upvoted or downvoted
        defs = filter (lambda d: likes.get((account, d)) is None, defs)

    # Prefer oldest trials
    defs.sort(key=lambda x: x._date)

    for defendant in defs:
        sr = srs[defendant.sr_id]

        if voir_dire(account, ip, slash16, defendants_voted_upon, defendant, sr):
            if defendant._id not in defendants_assigned_to:
                j = Jury._new(account, defendant)

            return defendant

    return None

# 需要导入模块: from r2.models import Subreddit [as 别名]
# 或者: from r2.models.Subreddit import user_subreddits [as 别名]
def default_queries():
    from r2.models import Link, Subreddit
    from r2.lib.db.operators import desc
    from copy import deepcopy

    queries = []

    q = Link._query(Link.c.sr_id == Subreddit.user_subreddits(None), sort=desc("_hot"), limit=37)

    queries.append(q)
    # add a higher limit one too
    q = deepcopy(q)
    q._limit = 75
    queries.append(q)

    return queries

# 需要导入模块: from r2.models import Subreddit [as 别名]
# 或者: from r2.models.Subreddit import user_subreddits [as 别名]
    def __init__(self, checkboxes = True):
        Wrapped.__init__(self)

        self.checkboxes = checkboxes
        if checkboxes:
            self.title = _('Customize your reddit')
            self.subtitle = _('Select which communities you want to see')
        else:
            self.title = _('Other reddit communities')
            self.subtitle = 'Visit your subscribed reddits (in bold) or explore new ones'
        self.create_link = ('/reddits/', menu.more)
        self.more_link   = ('/reddits/create', _('create'))

        my_reddits = []
        sr_ids = Subreddit.user_subreddits(c.user if c.user_is_loggedin else None)
        if sr_ids:
            my_reddits = Subreddit._byID(sr_ids, True,
                                         return_dict = False)
            my_reddits.sort(key = lambda sr: sr._downs, reverse = True)

        display_reddits = my_reddits[:g.num_side_reddits]
        
        #remove the current reddit
        display_reddits = filter(lambda x: x != c.site, display_reddits)

        pop_reddits = Subreddit.default_srs(c.content_langs, limit = g.num_side_reddits)
        #add english reddits to the list
        if c.content_langs != 'all' and 'en' not in c.content_langs:
            en_reddits = Subreddit.default_srs(['en'])
            pop_reddits += [sr for sr in en_reddits if sr not in pop_reddits]

        for sr in pop_reddits:
            if len(display_reddits) >= g.num_side_reddits:
                break

            if sr != c.site and sr not in display_reddits:
                display_reddits.append(sr)

        col1, col2 = [], []
        cur_col, other = col1, col2
        for sr in display_reddits:
            cur_col.append((sr, sr in my_reddits))
            cur_col, other = other, cur_col

        self.cols = ((col1, col2))
        self.mine = my_reddits

# 需要导入模块: from r2.models import Subreddit [as 别名]
# 或者: from r2.models.Subreddit import user_subreddits [as 别名]
 def for_user(cls, account):
     """Return a new AccountSRPrefs obj populated with user's data."""
     prefs = cls()
     multis = LabeledMulti.by_owner(account)
     multi_srs = set(chain.from_iterable(multi.srs for multi in multis))
     feedback = AccountSRFeedback.for_user(account)
     # subscriptions and srs in the user's multis become likes
     subscriptions = Subreddit.user_subreddits(account, limit=None)
     prefs.likes.update(utils.to36(sr_id) for sr_id in subscriptions)
     prefs.likes.update(sr._id36 for sr in multi_srs)
     # recent clicks on explore tab items are also treated as likes
     prefs.likes.update(feedback[CLICK])
     # dismissed recommendations become dislikes
     prefs.dislikes.update(feedback[DISMISS])
     # dislikes take precedence over likes
     prefs.likes = prefs.likes.difference(prefs.dislikes)
     # recently recommended items won't be shown again right away
     prefs.recent_views.update(feedback[VIEW])
     return prefs