def get_comments(submission_id):
reddit = Reddit(check_for_updates=False, user_agent=AGENT)
submission = reddit.submission(id=submission_id)
more_comments = submission.comments.replace_more()
if more_comments:
skipped_comments = sum(x.count for x in more_comments)
logger.debug('Skipped %d MoreComments (%d comments)',
len(more_comments), skipped_comments)
return submission.comments.list()
def test_read_only__without_trusted_authenticated_core(self):
with Reddit(password=None, username=None,
**self.REQUIRED_DUMMY_SETTINGS) as reddit:
assert reddit.read_only
with pytest.raises(ClientException):
reddit.read_only = False
assert reddit.read_only
reddit.read_only = True
assert reddit.read_only
def test_reddit_token_manager(self):
with pytest.raises(DeprecationWarning):
Reddit(
client_id="dummy",
client_secret=None,
redirect_uri="dummy",
user_agent="dummy",
token_manager=FileTokenManager("name"),
)
def __init__(self, database, handler, path='../html/'):
self.db = database
self.path = path
self.session = Reddit(user_agent='Statistics poller for RedditRover', handler=handler)
self.config = ConfigParser()
self.config.read(resource_filename('config', 'bot_config.ini'))
self.authors = self.get_authors()
self.status_online()
atexit.register(self.status_offline)
def init_reddit(id: int):
reddit_oauth = loads(cast(str, config("reddit_oauth_" + str(id))))
return Reddit(
client_id=reddit_oauth["CLIENT_ID"],
client_secret=reddit_oauth["CLIENT_SECRET"],
password=reddit_oauth["PASSWORD"],
user_agent=reddit_oauth["USER_AGENT"],
username=reddit_oauth["USERNAME"],
)
def __init__(self, bot):
self.bot = bot
self.reddit = None
if REDDIT_ID and REDDIT_TOKEN:
self.reddit = Reddit(
client_id=REDDIT_ID,
client_secret=REDDIT_TOKEN,
user_agent="Miia:%s:0.1.7" % REDDIT_ID,
)
def test_read_only__with_script_authenticated_core(self):
with Reddit(password="******",
username="******",
**self.REQUIRED_DUMMY_SETTINGS) as reddit:
assert not reddit.read_only
reddit.read_only = True
assert reddit.read_only
reddit.read_only = False
assert not reddit.read_only
def __init__(self, user_agent=False, use_praw=False):
rd_credential = (RedditCredential.objects.get(user_agent=user_agent)
if user_agent else RedditCredential.objects.first())
self.__rd_socket = Reddit(client_id=rd_credential.client_id,
client_secret=rd_credential.client_secret,
user_agent=rd_credential.user_agent)
self.__ps_api = PushshiftAPI(self.__rd_socket if use_praw else None)
def test_reddit_refresh_token(self):
with pytest.raises(DeprecationWarning):
Reddit(
client_id="dummy",
client_secret=None,
redirect_uri="dummy",
refresh_token="dummy",
user_agent="dummy",
)
def get_video_ids():
reddit = Reddit(client_id=os.environ['REDDIT_CLIENT_ID'],
client_secret=os.environ['REDDIT_CLIENT_SECRET'],
user_agent='Script User Agent')
subreddit_name = os.environ['REDDIT_SUBREDDIT']
subreddit = reddit.subreddit(subreddit_name)
return extract_video_ids_from_subreddit(subreddit)
def main():
import sys
sr_name = sys.argv[1]
renderer = RenderHelper(sr_name)
aaf = AAFClient('aaf_standings;reddit.com/r/%s' % sr_name)
standings = aaf.standings()
standings_ctx = make_standings_ctx(standings)
standings = renderer.render('standings.md', standings_ctx)
week, games = aaf.schedule(for_week=pendulum.now())
all_weeks = aaf.schedule()
schedule_ctx = make_schedule_ctx(week, games, all_weeks)
schedule = renderer.render('schedule.md', schedule_ctx)
r = Reddit('aaf_robot')
ensure_scopes(r)
sub = r.subreddit(sr_name)
old_sidebar = sub.description
new_sidebar = marker_replace('#### [](/blank "START schedule")',
'#### [](/blank "END schedule")', schedule,
old_sidebar)
new_sidebar = marker_replace('#### [](/blank "START standings")',
'#### [](/blank "END standings")', standings,
new_sidebar)
if old_sidebar != new_sidebar:
print(
diff_strings(old_sidebar,
new_sidebar,
fromfile='old_sidebar_%s' % sub.display_name,
tofile='new_sidebar_%s' % sub.display_name,
n=0))
sub.mod.update(description=new_sidebar)
for widget in sub.widgets.sidebar:
if not isinstance(widget, TextArea) or widget.shortName not in (
'Standings', 'Schedule'):
continue
if widget.shortName == 'Standings':
new_text = renderer.render('standings.md',
standings_ctx,
widget=True)
elif widget.shortName == 'Schedule':
new_text = renderer.render('schedule.md',
schedule_ctx,
widget=True)
if widget.text != new_text:
widget_name = "%s_%s_widget" % (sub.display_name, widget.shortName)
print(
diff_strings(widget.text,
new_text,
fromfile='old_%s' % widget_name,
tofile='new_%s' % widget_name,
n=3))
widget.mod.update(text=new_text)
def test_reddit__required_settings_set_to_none(self):
required_settings = self.REQUIRED_DUMMY_SETTINGS.copy()
del required_settings["client_secret"]
for setting in required_settings:
with pytest.raises(ClientException) as excinfo:
settings = self.REQUIRED_DUMMY_SETTINGS.copy()
settings[setting] = None
Reddit(**settings)
assert str(excinfo.value).startswith(
"Required configuration setting '{}' missing.".format(setting))
def test_reddit__missing_required_settings(self):
for setting in self.REQUIRED_DUMMY_SETTINGS:
with pytest.raises(ClientException) as excinfo:
settings = self.REQUIRED_DUMMY_SETTINGS.copy()
settings[setting] = Config.CONFIG_NOT_SET
Reddit(**settings)
assert str(excinfo.value).startswith(
"Required configuration setting '{}' missing.".format(setting))
if setting == "client_secret":
assert "set to None" in str(excinfo.value)
def __init__(self, client: Client):
self.client = client
with open("api.json", "r") as f:
f = load(f)
cluster = MongoClient(f.get("mongodb"))
self.meetings = cluster["timestamp"]["meeting"]
self.subreddits = cluster["timestamp"]["reddit"]
self.praw = Reddit(client_id=f.get("reddit_id"),
client_secret=f.get("reddit_secret"),
user_agent="-")
def reddit_session():
config = get_config()
return Reddit(
username=config.get("reddit", "username"),
password=config.get("reddit", "password"),
user_agent=config.get("reddit", "user_agent"),
client_id=config.get("reddit", "client_id"),
client_secret=config.get("reddit", "client_secret"),
)
def test_read_only__with_authenticated_core(self):
with Reddit(password=None,
refresh_token='refresh',
username=None,
**self.REQUIRED_DUMMY_SETTINGS) as reddit:
assert not reddit.read_only
reddit.read_only = True
assert reddit.read_only
reddit.read_only = False
assert not reddit.read_only
def test_read_only__without_untrusted_authenticated_core(self):
required_settings = self.REQUIRED_DUMMY_SETTINGS.copy()
required_settings["client_secret"] = None
with Reddit(password=None, username=None, **required_settings) as reddit:
assert reddit.read_only
with pytest.raises(ClientException):
reddit.read_only = False
assert reddit.read_only
reddit.read_only = True
assert reddit.read_only
def test_requestor_class(self):
class CustomRequestor(Requestor):
pass
reddit = Reddit(client_id='dummy',
client_secret='dummy',
password='******',
user_agent='dummy',
username='******',
requestor_class=CustomRequestor)
assert isinstance(reddit._core._requestor, CustomRequestor)
assert not isinstance(self.reddit._core._requestor, CustomRequestor)
reddit = Reddit(client_id='dummy',
client_secret='dummy',
user_agent='dummy',
requestor_class=CustomRequestor)
assert isinstance(reddit._core._requestor, CustomRequestor)
assert not isinstance(self.reddit._core._requestor, CustomRequestor)
def __init__(self, post_id, ok_id=None, todo_id=None):
"""Initialize."""
reddit = Reddit(check_for_updates=False)
self.post = reddit.submission(id=post_id)
self.ok = None
self.todo = None
if ok_id:
self.ok = reddit.comment(id=ok_id)
if todo_id:
self.todo = reddit.comment(id=todo_id)
def get_reddit(site: str, parser: argparse.ArgumentParser) -> Reddit:
try:
return Reddit(site)
except ClientException:
traceback.print_exc()
sys.stderr.write(
"\nOh dear, something broke. Most likely you need to pass the --site "
"parameter or set the praw_site environment variable\n\n")
parser.print_help()
sys.exit(1)
def __init__(self, parent):
self.r = Reddit(user_agent="PollBotBestBot") #
self.r.login("PollBotBestBot", config.reddit_password)
self.parent = parent
self.values = []
self.limit = 1000
self.currentSubmission = ""
self.status = "WAITING"
def _setup_reddit(self):
try:
self._reddit = Reddit(**self._config['reddit'])
username = self._reddit.user.me()
self._logger.info('Connected to Reddit as: {}.'
.format(username))
except Exception as e:
self._logger.critical('Couldn\'t connect to Reddit.')
self._logger.critical(e)
raise
def test_requestor_kwargs(self):
session = mock.Mock(headers={})
reddit = Reddit(
client_id="dummy",
client_secret="dummy",
user_agent="dummy",
requestor_kwargs={"session": session},
)
assert reddit._core._requestor._http is session
def __init__(self):
""" Initialize SubredditPuller"""
# Create the Reddit class provided by PRAWN
# This line allows me to import my credentials from a 'praw.ini' file
self.reddit = Reddit(site_name='DEFAULT')
# Set out account only able to view posts
self.reddit.read_only = True
def init_reddit(id):
env_var_key = 'reddit_oauth_'+str(id)
reddit_oauth = loads(config(env_var_key))
return Reddit(
client_id=reddit_oauth['CLIENT_ID'],
client_secret=reddit_oauth['CLIENT_SECRET'],
password=reddit_oauth['PASSWORD'],
user_agent=reddit_oauth['USER_AGENT'],
username=reddit_oauth['USERNAME']
)
def __init__(self):
dummy_reddit = Reddit(check_for_updates=False)
config = dummy_reddit.config.CONFIG['SLACK']
self.channel = config['channel']
del dummy_reddit
self.slack = Slacker(config['token'])
self._logger = logging.getLogger(__file__)
self._logger.addHandler(logging.NullHandler())
self._logger.setLevel(logging.INFO)
self._formatter = logging.Formatter()
def __init__(self, configuration_details):
self.instance = Reddit(
client_id=configuration_details["client_id"],
client_secret=configuration_details["client_secret"],
username=configuration_details["username"],
password=configuration_details["password"],
user_agent="/r/kpop Unflaired 0.1 by /u/jonicrecis",
)
self.subreddit = self.instance.subreddit("kpop+kpophelp+kpoppers")
self.current_time = now("UTC")
def __init__(self, topic):
if type(self) == RedditProducer:
raise Exception('<RedditProducer> must be subclassed.')
self.producer = Producer(self.conf)
self.reddit = Reddit(client_id=client_id,
client_secret=secret,
user_agent=user_agent)
self.topic = topic
self.logger = self._get_logger()
def set_up_record(self):
if not self._overrode_reddit_setup:
if pytest.placeholders.refresh_token != "placeholder_refresh_token":
self.reddit = Reddit(
requestor_kwargs={"session": self._session},
client_id=pytest.placeholders.client_id,
client_secret=pytest.placeholders.client_secret,
user_agent=pytest.placeholders.user_agent,
refresh_token=pytest.placeholders.refresh_token,
)
def get_reddit_client(self):
"""
Gets client for Reddit.
:rtype: Reddit
"""
return Reddit(client_id=self.reddit_bot['client_id'],
client_secret=self.reddit_bot['client_secret'],
user_agent=self.reddit_bot['user_agent'],
username=self.reddit_bot['username'],
password=self.reddit_bot['password'])
