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_via_praw(post_id, post_type,praw_cred):
if praw_cred is None:
raise IOError("Missing praw credentials")
from praw import Reddit
reddit = Reddit(client_id=praw_cred["client_id"], client_secret=praw_cred["client_secret"],
password=praw_cred["password"], user_agent=praw_cred["user_agent"],username=praw_cred["username"])
if post_type == "post":
submission = reddit.submission(post_id)
created_utc = submission.mod.thing.created_utc
selftext = submission.mod.thing.selftext
selftext = re.sub(r'\s+',' ',selftext)
selftext = selftext.replace("'","\\'")
title = submission.mod.thing.title
title = title.replace("'","\\'")
out_json = "[{'id':'"+post_id+"','selftext':'"+selftext+"','created_utc':"+str(int(created_utc))+",'title':'"+title+"'}]"
else:
submission = reddit.comment(post_id)
created_utc = submission.mod.thing.created_utc
selftext = submission.mod.thing.body
selftext = re.sub(r'\s+',' ',selftext)
selftext = selftext.replace("'","\\'")
title = ""
out_json = "[{'id':'"+post_id+"','body':'"+selftext+"','created_utc':"+str(int(created_utc))+"}]"
return out_json
def migrate_saved(origin_account: praw.Reddit, destination_account: praw.Reddit, posts: list, verbose: bool = True):
"""
Migrates saved posts from one reddit account to another
"""
if utils.is_null_or_empty(posts):
print("Posts list is empty or was not found.")
return
print(f"Total items: {len(posts)}")
for index, post in enumerate(posts):
try:
print(f"Migrating post #{index + 1} with id: {post.id}")
# Remove from origin account
origin_account.submission(id=post.id).unsave()
# Add to destination account
if type(post) == praw.models.Submission:
submission = destination_account.submission(id=post.id)
if submission.saved is False:
submission.save()
elif type(post) == praw.models.Comment:
comment = destination_account.comment(id=post.id)
if comment.saved is False:
comment.save()
except Exception as ex:
log.error(ex, f"An error occurred while migrating the post id {post.id}.")
def migrate_upvoted(origin_account: praw.Reddit, destination_account: praw.Reddit, posts: list, verbose: bool = True):
"""
Migrates a friend list from one reddit account to another
"""
if utils.is_null_or_empty(posts):
print("Friends list is empty or was not found.")
return
for post in posts:
try:
# Remove from origin account
origin_account.submission(id=post.id).clear_vote()
# Add to destination account
if type(post) == praw.models.Submission:
submission = destination_account.submission(id=post.id)
if submission.likes is None:
submission.upvote()
elif type(post) == praw.models.Comment:
comment = destination_account.comment(id=post.id)
if submission.likes is None:
comment.upvote()
except Exception as ex:
log.error(ex, f"An error occurred while migrating the post id {post.id}.")
def _set_comment_score(api: praw.Reddit, id_):
comm = api.comment(id_)
return """
MATCH (n:Comment {id: "%s"})
WITH n
SET n.score = %s;
""" % (comm.id, comm.score)
def force(comment_id, image):
"""Main function"""
reddit = Reddit()
comment = reddit.comment(comment_id)
comment.body = image
bot = RedditBot()
print(bot.process_comment(comment))
def get_comment_from_link(reddit: praw.Reddit,
link: str) -> praw.models.reddit.comment.Comment:
comment_id = link.split("/")[-2]
c = reddit.comment(comment_id)
if not isinstance(c, praw.models.reddit.comment.Comment) or c.permalink not in link \
or c.body in ("[deleted]", "[removed]") or c.body is None:
raise CommentMissingException("Comment does not exist")
return c
def test_get_comment_details(test_comment_id: str, expected_dict: dict,
reddit_instance: praw.Reddit):
comment = reddit_instance.comment(id=test_comment_id)
test_entry = CommentArchiveEntry(comment)
result = test_entry.compile()
assert all([
result.get(key) == expected_dict[key] for key in expected_dict.keys()
])
def get_context(comment: Comment, reddit: Reddit):
submission = reddit.submission(id=comment.link_id.replace('t3_', ''))
parent_comment = None
if not comment.parent_id == comment.link_id:
# not a top level comment, try to retrieve parent comment
parent_comment = reddit.comment(
id=comment.parent_id.replace('t1_', ''))
return parent_comment, submission
def get_via_praw(post_id, post_type, praw_cred):
if praw_cred is None:
raise IOError("Missing praw credentials")
from praw import Reddit
reddit = Reddit(client_id=praw_cred["client_id"],
client_secret=praw_cred["client_secret"],
password=praw_cred["password"],
user_agent=praw_cred["user_agent"],
username=praw_cred["username"])
if post_type == "post":
submission = reddit.submission(post_id)
try:
created_utc = submission.mod.thing.created_utc
except:
return ""
selftext = submission.mod.thing.selftext
selftext = re.sub(r'\s+', ' ', selftext)
#selftext = selftext.replace("\\","\\\\").replace('"', '\\"').replace("\t"," ").replace("\t","\\t").replace("\r","\\r").replace("\n","\\n")
selftext = json.dumps(selftext)
title = submission.mod.thing.title
title = title.replace('"', """)
title = json.dumps(title)
#title = title.replace('"', '\\"').replace("\t","\\t").replace("\r","\\r").replace("\n","\\n")#replace("'","\\'")
author = submission.mod.thing.author
if author is not None:
author = author.name
else:
author = "unknown"
out_json = '{"id":"'+post_id+'","selftext":'+selftext+',"created_utc":'+str(int(created_utc))+\
',"title":'+title+',"author":"'+author+'"}'
else:
submission = reddit.comment(post_id)
created_utc = submission.mod.thing.created_utc
selftext = submission.mod.thing.body
selftext = re.sub(r'\s+', ' ', selftext)
selftext = selftext.replace('"', '\\"').replace("'", "\\'")
out_json = "[{'id':'" + post_id + "','body':'" + selftext + "','created_utc':" + str(
int(created_utc)) + "}]"
try:
out_json = json.loads(out_json)
except:
print("Invalid json: " + out_json)
quit()
return out_json
def make_package_infer_url(url: str, reddit: Reddit) -> dict:
"""Return package like astroturf.prawtools.make_package_training but for inference.
Args:
url (str): url for inference
reddit (Reddit): ...
"""
try:
refobj = reddit.comment(url=url)
except InvalidURL:
refobj = reddit.submission(url=url)
if isinstance(refobj, Submission):
return make_package_infer_submission(refobj)
elif isinstance(refobj, Comment):
return make_package_infer_comment(refobj, reddit)
def add_comment_parent_tree(reddit: Reddit, reddit_comment: Comment):
"""
Starting with the comment that's the *parent* of the specified comment (non-inclusive),
recursively crawl up the tree and add all of them to the database.
Stops when it reaches a comment that already exists in the database or upon reaching the root.
Needs improvements for efficiency.
"""
# Could do this with recursive calls to this function, but
# I don't know how deep reddit comment chains are allowed to get.
# So instead we need to keep a stack of comments so we can insert
# them in the correct order, root first then down the chain.
# This is necessary because the parent_id of each needs to already exist.
comment_stack = []
# At the start of each loop, if we're at the top comment of the tree there will be no parents to add.
# parent_id will return a submission for top level comments, so check is_root instead.
while not reddit_comment.is_root:
parent_id = reddit_comment.parent_id.split("t1_")[1]
parent_exists = get_comment_by_id(parent_id)
# Once we reach a child where the parent already exists, we can stop adding new comments up the chain.
if parent_exists:
break
# Parent now becomes the base comment, then create a model for it (but don't insert yet).
reddit_comment = reddit.comment(id=parent_id)
comment = _create_comment_model(reddit_comment)
comment_stack.append(comment)
# Insert the author into the database if they don't exist yet.
if reddit_comment.author is not None and not user_service.get_user(
reddit_comment.author.name):
user_service.add_user(reddit_comment.author)
# Insert post into the database if it doesn't exist yet.
if not post_service.get_post_by_id(reddit_comment.submission.id):
post_service.add_post(reddit_comment.submission)
# Reverse the order that we're iterating through the stack for inserting, last->first.
for comment in comment_stack[::-1]:
_comment_data.insert(comment, error_on_conflict=False)
def __init__(self, api: praw.Reddit, id_):
self.api = api
self.id = id_
self.resp = api.comment(id_)
def check_comments(reddit: praw.Reddit, db: DatabaseHelper, rh: RedditHelper,
config):
logger = logging.getLogger(__name__)
subreddit = reddit.subreddit(config["subreddit"])
# check if any new comments, update submissions accordingly
comment_stream = subreddit.comments(limit=50)
for comment in comment_stream:
# checking whether we have all necessary values, as the post could've been deleted + some prerequisites
try:
assert comment and comment.author and comment.submission and comment.submission.author
except AssertionError:
break
# much better than a big if!
# we don't want to get in the way of mods
if comment.author.name == 'AutoModerator':
break
elif rh.mod_overridden(comment.submission):
break
# on new comments made by OP
if comment.author.name == comment.submission.author.name:
# if OP's comment is "solved", flair submission as "solved"
if not rh.already_solved(
comment.submission) and rh.solved_in_comment(comment):
try:
# marking post as solved and changing the status in the DB
db.save_post(comment.submission.id, 'solved')
rh.apply_flair(submission=comment.submission,
text=config["flairs"]["solved"]["text"],
flair_id=config["flairs"]["solved"]["id"])
logger.info(
f"Marked submission {comment.submission.id} as solved")
except exceptions.PRAWException:
logger.error(
f"Couldn't flair submission {comment.submission.id} as 'solved' following OP's new comment."
)
# notifying the subscribers about the solve
rh.notify_subscribers(post_id=comment.submission.id,
sub_name=comment.subreddit.display_name,
title=comment.submission.title,
permalink=comment.submission.permalink)
# no need to store them any further
db.remove_all_subs(comment.submission.id)
# we don't want to assign points when OP replied to themselves (or their submission)
if not comment.parent_id.startswith('t3') and \
(parent := reddit.comment(comment.parent_id[3:])).author.name != comment.submission.author.name:
# adding a point to solver's balance
points = db.modify_points(parent.author.name, 1)
# modifying the flair of the person who solved the query
flair_index = 0 # index of the flair template ID on the template array
# if the user has more points than the highest bound, just apply the highest flair
if points >= (flair_bounds :=
config["user_flairs"]["bounds"])[-1]:
flair_index = len(flair_bounds)
for index, bound in enumerate(flair_bounds):
# if user's points are smaller than the bound, then user qualifies for the flair
if points < bound:
flair_index = index
break
reddit.subreddit(config["subreddit"]).flair.set(
redditor=parent.author.name,
text=config["user_flairs"]["text"].format(points),
flair_template_id=config["user_flairs"][flair_index])
# if OP's comment is not "solved", flair submission as "contested"
elif not rh.already_contested(
comment.submission) and not rh.already_solved(
comment.submission):
db.save_post(comment.submission.id, 'contested')
rh.apply_flair(submission=comment.submission,
text=config["flairs"]["contested"]["text"],
flair_id=config["flairs"]["contested"]["id"])
logger.info(
f"Marked submission {comment.submission.id} as contested")
def test_get_comment_replies(test_comment_id: str, expected_min_comments: int,
reddit_instance: praw.Reddit):
comment = reddit_instance.comment(id=test_comment_id)
test_entry = CommentArchiveEntry(comment)
result = test_entry.compile()
assert len(result.get('replies')) >= expected_min_comments
class SearchEngine:
__rd_socket = None
__ps_api = None
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 new_credential(client_id, client_secret, user_agent, domain):
rd_credential = RedditCredential(
client_id=client_id,
client_secret=client_secret,
user_agent=user_agent,
domain=domain,
)
rd_credential.save()
def most_commented_submissions(self,
subreddit=None,
before=None,
after=None,
limit=10):
return [
{
'id': submission.id,
'title': submission.title,
'body': submission.selftext,
'url': submission.url,
'subreddit': submission.subreddit,
'author': submission.author,
'num_comments': submission.num_comments,
'created_at': datetime.utcfromtimestamp(
submission.created_utc),
'retrieved_on': datetime.utcfromtimestamp(
submission.retrieved_on)
} for submission in self.__ps_api.search_submissions(
before=datetime.strptime(before, "%d-%m-%Y"
) if before else None,
after=datetime.strptime(after, "%d-%m-%Y") if after else None,
subreddit=subreddit,
sort_type='num_comments',
limit=limit)
] or [None]
def retrive_submission_by_id(self, submission_id):
submission = self.__rd_socket.submission(id=submission_id)
submission = {
'id': submission.id,
'title': submission.title,
'body': submission.selftext,
'url': submission.url,
'subreddit': submission.subreddit.display_name,
'author': submission.author.name,
'score': submission.score,
'num_comments': submission.num_comments,
'created_at': datetime.utcfromtimestamp(submission.created_utc),
'retrieved_on': datetime.now()
}
return submission
def retrive_submission_comments(self,
submission_id,
before=None,
after=None,
method='psaw'):
comments = None
if method == 'psaw':
comments = [{
'id':
comment.id,
'author_id':
comment.author,
'body':
comment.body,
'created_at':
datetime.utcfromtimestamp(comment.created_utc),
'submission_id':
comment.link_id.split('_')[1],
'parent':
comment.parent_id.split('_')[1],
'retrieved_on':
datetime.utcfromtimestamp(comment.retrieved_on)
} for comment in self.__ps_api.search_comments(
link_id=submission_id,
after=datetime.strptime(after, "%d-%m-%Y") if after else None,
before=datetime.strptime(before, "%d-%m-%Y"
) if before else None,
)]
if method == 'praw' or not comments:
comments = [{
'id':
comment.id,
'author_id':
comment.author.name if comment.author else None,
'body':
comment.body,
'score':
comment.score,
'created_at':
datetime.utcfromtimestamp(comment.created_utc),
'submission_id':
comment._submission.id,
'parent':
comment.parent_id.split('_')[1],
'retrieved_on':
datetime.now()
} for comment in self.__rd_socket.submission(
id=submission_id).comments.replace_more(limit=0)]
return comments
def retrive_redditor_submissions(self,
redditor,
domain=None,
before=None,
after=None,
method='psaw'):
submission = None
if method == 'psaw':
submissions = [{
'id':
submission.id,
'title':
submission.title,
'body':
submission.selftext,
'url':
submission.url,
'subreddit':
submission.subreddit,
'author':
submission.author,
'num_comments':
submission.num_comments,
'created_at':
datetime.utcfromtimestamp(submission.created_utc),
'retrieved_on':
datetime.utcfromtimestamp(submission.retrieved_on)
} for submission in self.__ps_api.search_submissions(
author=redditor,
domain=domain,
before=datetime.strptime(before, "%d-%m-%Y"
) if before else None,
after=datetime.strptime(after, "%d-%m-%Y") if after else None)]
if method == 'praw' or not submissions:
submissions = [
{
'id': submission.id,
'title': submission.title,
'body': submission.selftext,
'url': submission.url,
'subreddit': submission.subreddit.display_name,
'author': submission.author.name,
'score': submission.score,
'num_comments': submission.num_comments,
'created_at':
datetime.utcfromtimestamp(submission.created_utc),
'retrieved_on': datetime.now()
} for submission in self.__rd_socket.redditor(
redditor).submissions.new()
if not domain or submission.subreddit.display_name in domain
]
return submissions
def redditor_info(self, redditor):
redditor = self.__rd_socket.redditor(redditor)
return {
'name':
getattr(redditor, 'name'),
'submissions_karma':
getattr(redditor, 'link_karma'),
'comments_karma':
getattr(redditor, 'comment_karma'),
'created_at':
datetime.utcfromtimestamp(getattr(redditor, 'created_utc'))
}
def subreddit_info(self, subreddit):
subreddit = self.__rd_socket.subreddit(subreddit)
return {
'name': subreddit.display_name,
'description': subreddit.description[:5000],
'short_description': subreddit.public_description,
'num_subscribers': subreddit.subscribers,
'created_at': datetime.utcfromtimestamp(subreddit.created_utc),
'last_update': datetime.now()
}
def update_comments_score(self, comments_id):
num_comments = len(comments_id)
for i, comment_id in enumerate(comments_id):
try:
comment = Comment.objects.get(id=comment_id)
score = self.__rd_socket.comment(id=comment_id).score
comment.score = int(score)
comment.save()
except Exception as ex:
print(ex)
pass
if i % 500 == 0:
print(f'{i+1}/{num_comments}')
print(f'{i+1}/{num_comments}')
def update_submissions_score(self, submissions_id):
num_submissions = len(submissions_id)
for i, submission_id in enumerate(submissions_id):
submission = Submission.objects.get(id=submission_id)
score = self.__rd_socket.submission(id=submission_id).score
submission.score = score
submission.save()
if i % 500 == 0:
print(f'{i+1}/{num_submissions}')
print(f'{i+1}/{num_submissions}')
def update_submissions_comments(self, submissions_ids=None):
comments_ids = {comment.id for comment in Comment.objects.all()}
authors_names = {author.name for author in RedditUser.objects.all()}
submissions = Submission.objects.filter(
id__in=submissions_ids
) if submissions_ids else Submission.objects.all()
for i, submission in enumerate(submissions):
print(f'{i}/{len(submissions)} - {submission.id}')
comments = [
comment
for comment in self.retrive_submission_comments(submission.id)
if comment['id'] not in comments_ids
]
authors = [
comment['author_id'] for comment in comments
if comment['author_id'] not in authors_names
]
authors_bulk = []
for author in authors:
try:
authors_bulk.append(
RedditUser(**self.redditor_info(author)))
except Exception:
authors_bulk.append(RedditUser(name=author))
RedditUser.objects.bulk_create(authors_bulk, ignore_conflicts=True)
comments = [Comment(**comment) for comment in comments]
Comment.objects.bulk_create(comments, ignore_conflicts=True)
class RedditBot:
def __init__(self, mode='watch'):
self._mode = mode
# Configura e inicia banco de dados, reddit e etc...
# assim que o objeto Redditbot foi instanciado.
self._setup_logging()
self._logger.info('The Bot is now starting in {} mode.'
.format(self._mode))
self._load_config()
self._setup_database()
self._setup_reddit()
# Configura o formato de saída dos logs, também o arquivo.
# O bot executa dois processos separados, um "watch" e outro
# "reply", cada processo tem o seu log.
def _setup_logging(self):
if not os.path.exists('logs'):
os.makedirs('logs')
self._logger = logging.getLogger(__name__)
formatter = logging.Formatter('%(asctime)s '
'[%(levelname)s] '
'%(message)s')
self._logger.setLevel(logging.INFO)
ch = logging.StreamHandler()
fh = logging.FileHandler('logs/{}.log'
.format(self._mode))
ch.setFormatter(formatter)
fh.setFormatter(formatter)
self._logger.addHandler(ch)
self._logger.addHandler(fh)
# Carrega o arquivo de configuração, qualquer erro
# logga e raise a exception
def _load_config(self):
try:
with open('config.yml', 'r') as file:
self._config = yaml.load(file)
self._logger.info('Loaded config file.')
except Exception as e:
self._logger.critical('Couldn\'t load config file.')
self._logger.critical(e)
raise
# Cria o objecto Reddit, note que ele não automaticamente
# conecta aqui, por isso para testar a conexão chamamos então
# reddit.user.me() para que ele connecte e pegue o usuário
# se falhar aqui, há um problema com autenticação ou etc...
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
# Configua banco de dados
def _setup_database(self):
try:
database = Database(**self._config['database'])
self._db = database
self._logger.info('Connected to database: '
'{driver}://{username}@{host}:{port}/{database}'
.format_map(self._config['database']))
except Exception as e:
self._logger.critical('Couldn\'t connect to database.')
self._logger.critical(e)
raise
# Assiste (ou escuta) o stream de comentários dos subreddits
# no arquivo de config.
def watch(self):
self._logger.info('Watching for new comments.')
# Caso haja mais de um subreddit, junte-os separados por +,
# exemplo: brasil+portugal, assim ele trabalhará nos dois
# subreddits.
subreddits_list = '+'.join(self._config['bot']['subreddits'])
subreddits = self._reddit.subreddit(subreddits_list)
while True:
try:
# Assiste o stream de comentários
for comment in subreddits.stream.comments():
self._logger.info('Comment base36_id found: {}.'
.format(comment.id))
# pega o comentário anterior ou a submission (publicação)
parent = comment.parent()
commands = self._config['bot']['commands']
# verifica se o corpo do comentário contém algum comando cadastrado na config
if comment.body.lower().startswith(tuple(commands)):
# a propriedade .author retorna None se a conta tiver sido apagada
# então verifica se a conta ainda existe antes de prosseguir.
# raramente acontece, mas é uma possibilidade.
if comment.author and parent.author:
# Verifica se o autor está votando para si mesmo ou para o próprio Bot
if comment.author != parent.author \
and parent.author != self._reddit.user.me():
self._logger.info('Comment base36_id: {} matches command.'
.format(comment.id))
# adiciona o usuario caso não exista no db, caso ja exista
# retorna apenas o resultado da query
from_user = self._db.get_or_add_user(username=comment.author)
to_user = self._db.get_or_add_user(username=parent.author)
# Verifica se usuario ja não votou para o mesmo comentario
if not self._db.get_comment(from_user_id = from_user.id,
parent_base36_id = parent.id):
try:
# Adiciona o comentário no db, para ser processado pelo
# reply.
self._db.add_comment(
parent_base36_id = parent.id,
base36_id = comment.id,
from_user_id = from_user.id,
to_user_id = to_user.id
)
# Adiciona +1 pontos ao usuário que recebeu o voto.
to_user.points += 1
self._db.session.commit()
self._logger.info('Added to database!')
except IntegrityError:
self._logger.info('Already added to database!')
self._db.session.rollback()
except SQLAlchemyError:
self._logger.info('Something went wrong with your database, rolling back!')
self._db.session.rollback()
# Pega qualquer Exception loga e tenta novamente em 5s,
# Não é uma boa prática at all, mas está
# funcionando e não é prioridade.
# Quem quiser melhorar isso aqui, só mandar PR =)
except Exception as e:
self._logger.error('Tried to read comments stream'
' but failed, trying again!')
self._logger.error(e)
time.sleep(5)
def reply(self):
self._logger.info('Looking for new comments to reply to.')
while True:
# Pega todos os comentários que foram adicionados ao db
# mas ainda não foram respondidos.
comments = self._db.get_comments(status='TO_REPLY')
try:
for comment in comments:
self._logger.info('Replying to comment base36_id: {}'
.format(comment.base36_id))
# carrega o comentário
reddit_comment = self._reddit.comment(id=comment.base36_id)
# renderiza o template e gera o comentário de acordo com as informações
# do banco de dados.
render = render_template('default.md', comment=comment)
# Responde ao comentário e marca o status para DONE
reddit_comment.reply(render)
comment.status = 'DONE'
self._db.session.commit()
self._logger.info('Replied to comment base36_id: {}'
.format(comment.base36_id))
# timer temporario, por ser uma conta nova devo limitar os comentários entre 9m.
#time.sleep(60 * 10)
# agora que a conta já tem karma suficiente, limitar apenas para cada dois segundos
# no mínimo, mas deixarei 4
time.sleep(4)
# Pega todas as exceptions,
# péssima prática mas tá valendo por enquanto.
except Exception as e:
comment.status = 'ERROR'
self._db.session.commit()
self._logger.error('Something went wrong!')
self._logger.error(e)
self._db.session.commit()
time.sleep(5)
class reddit_bot(configuration_manager,Reddit):
_COMMENT_MAX_LEN = 10000
def __init__(self,configuration_json_file, configuation_json_item):
self.bot = None
self.bot_call = None
self.bot_subreddit = None
self.bot_database = None
self.bot_name = None
self.bot_objects = []
self.configuation_json_item = configuation_json_item
self.initialize_bot(configuration_json_file)
self.subscribed_subreddits = self.get_subscribed_subreddits()
def initialize_bot(self,PRAW_bot_json_file):
PRAW_json_item = ','.join([self._firstItem,self.configuation_json_item])
connection_string_list = self.config_arguments(PRAW_bot_json_file,PRAW_json_item)
self.bot = Reddit(
user_agent=connection_string_list['user_agent'],
client_id=connection_string_list['client_id'],
client_secret=connection_string_list['client_secret'],
username=connection_string_list['username'],
password=connection_string_list['password']
)
self.bot_name=connection_string_list['username']
self.bot_call=connection_string_list['bot_call']
self.bot_subreddit=self.bot.subreddit(connection_string_list['bot_subreddit'])
self.bot_database=connection_string_list['source_database']
def get_subscribed_subreddits(self):
subreddit_list = []
for subreddit in list(self.bot.user.subreddits(limit=None)):
subreddit_list.append(subreddit.display_name)
return '+'.join(subreddit_list)
def get_reddit_obj_type(self,object_id):
try:
return str(self.bot.redditor(object_id[0:3]))
except:
print('didn\'t work')
def get_reddit_obj(self,object_id):
try:
return self.bot.redditor(object_id)
except:
print('didn\'t work')
def reddit_object_redditor_reply(self,object_id,source_redditor=None,return_comment_id=False):
if source_redditor is None:
source_redditor = self.bot_name
if self.get_reddit_obj_type(object_id)==REDDIT_COMMENT:
object_id=object_id.replace(REDDIT_COMMENT,'')
calling_object = self.bot.comment(object_id)
calling_object.comment_sort = 'new'
elif self.get_reddit_obj_type(object_id)==REDDIT_LINK:
object_id=object_id.replace(REDDIT_LINK,'')
calling_object = self.bot.submission(object_id)
calling_object.comment_sort = 'new'
calling_object.reply_sort = 'new'
try:
replies = calling_object.comments
for r in replies:
if r.author == source_redditor:
if return_comment_id:
return r
else:
return True
return False
except:
return False
