def __init__(self):
self.config = Config()
self.redlock = get_redlock_factory(self.config)
self.reddit = get_reddit_instance(self.config)
self.reddit_manager = RedditManager(self.reddit)
self.uowm = SqlAlchemyUnitOfWorkManager(get_db_engine(self.config))
self.event_logger = EventLogging(config=self.config)
notification_svc = NotificationService(self.config)
self.response_handler = ResponseHandler(
self.reddit_manager,
self.uowm,
self.event_logger,
source='summons',
live_response=self.config.live_responses,
notification_svc=notification_svc)
dup_image_svc = DuplicateImageService(self.uowm,
self.event_logger,
self.reddit,
config=self.config)
response_builder = ResponseBuilder(self.uowm)
self.summons_handler = SummonsHandler(
self.uowm,
dup_image_svc,
self.reddit_manager,
response_builder,
self.response_handler,
event_logger=self.event_logger,
summons_disabled=False,
notification_svc=notification_svc)
def __init__(self):
self.config = Config()
self.reddit = RedditManager(get_reddit_instance(self.config))
self.uowm = SqlAlchemyUnitOfWorkManager(get_db_engine(self.config))
self.event_logger = EventLogging(config=self.config)
self.response_handler = ResponseHandler(
self.reddit,
self.uowm,
self.event_logger,
live_response=self.config.live_responses)
def save_unknown_post(post_id: str, uowm: UnitOfWorkManager,
reddit: RedditManager) -> Post:
"""
If we received a request on a post we haven't ingest save it
:param submission: Reddit Submission
:return:
"""
submission = reddit.submission(post_id)
post = pre_process_post(submission_to_post(submission), uowm, None)
if not post or post.post_type != 'image':
log.error(
'Problem ingesting post. Either failed to save or it is not an image'
)
return
return post
def repost_watch_notify(watches: List[Dict[SearchMatch, RepostWatch]],
reddit: RedditManager,
response_handler: ResponseHandler, repost: Post):
for watch in watches:
# TODO - What happens if we don't get redditor back?
redditor = reddit.redditor(watch['watch'].user)
msg = WATCH_NOTIFY_OF_MATCH.format(
watch_shortlink=f"https://redd.it/{watch['watch'].post_id}",
repost_shortlink=f"https://redd.it/{repost.post_id}",
percent_match=watch['match'].hamming_match_percent)
log.info('Sending repost watch PM to %s', redditor.name)
response_handler.send_private_message(
redditor,
msg,
subject='A post you are watching has been reposted',
source='watch',
post_id=watch['watch'].post_id)
def __init__(self):
self.config = Config()
self.reddit = RedditManager(get_reddit_instance(self.config))
self.uowm = SqlAlchemyUnitOfWorkManager(get_db_engine(self.config))
self.event_logger = EventLogging(config=self.config)
self.response_handler = ResponseHandler(
self.reddit,
self.uowm,
self.event_logger,
live_response=self.config.live_responses)
self.notification_svc = NotificationService(self.config)
self.config_updater = SubredditConfigUpdater(
self.uowm,
self.reddit.reddit,
self.response_handler,
self.config,
notification_svc=self.notification_svc)
def __init__(self):
self.config = Config()
self.reddit = get_reddit_instance(self.config)
self.reddit_manager = RedditManager(self.reddit)
self.uowm = SqlAlchemyUnitOfWorkManager(get_db_engine(self.config))
event_logger = EventLogging(config=self.config)
response_handler = ResponseHandler(
self.reddit_manager,
self.uowm,
event_logger,
source='submonitor',
live_response=self.config.live_responses)
dup_image_svc = DuplicateImageService(self.uowm,
event_logger,
self.reddit,
config=self.config)
response_builder = ResponseBuilder(self.uowm)
self.sub_monitor = SubMonitor(dup_image_svc,
self.uowm,
self.reddit_manager,
response_builder,
response_handler,
event_logger=event_logger,
config=self.config)
from redditrepostsleuth.core.services.response_handler import ResponseHandler
from redditrepostsleuth.core.db.db_utils import get_db_engine
from redditrepostsleuth.core.db.uow.sqlalchemyunitofworkmanager import SqlAlchemyUnitOfWorkManager
from redditrepostsleuth.core.services.responsebuilder import ResponseBuilder
from redditrepostsleuth.core.util.helpers import get_reddit_instance, get_redis_client
from redditrepostsleuth.core.services.duplicateimageservice import DuplicateImageService
from redditrepostsleuth.submonitorsvc.submonitor import SubMonitor
if __name__ == '__main__':
config = Config()
event_logger = EventLogging(config=config)
uowm = SqlAlchemyUnitOfWorkManager(get_db_engine(config))
response_builder = ResponseBuilder(uowm)
reddit = get_reddit_instance(config)
reddit_manager = RedditManager(reddit)
dup = DuplicateImageService(uowm, event_logger, reddit, config=config)
monitor = SubMonitor(dup,
uowm,
reddit_manager,
response_builder,
ResponseHandler(reddit_manager,
uowm,
event_logger,
source='submonitor',
live_response=config.live_responses),
event_logger=event_logger,
config=config)
redis = get_redis_client(config)
while True:
while True:
comment_body=comment.body,
perma_link=comment.permalink,
source='toppost',
comment_id=comment.id,
subreddit=post.subreddit)
with self.uowm.start() as uow:
uow.bot_comment.add(bot_comment)
try:
uow.commit()
except Exception as e:
log.exception('Failed to save bot comment', exc_info=True)
if __name__ == '__main__':
config = Config()
uowm = SqlAlchemyUnitOfWorkManager(get_db_engine(config))
event_logger = EventLogging(config=config)
dup = DuplicateImageService(uowm, event_logger, config=config)
response_builder = ResponseBuilder(uowm)
reddit_manager = RedditManager(get_reddit_instance(config))
top = TopPostMonitor(reddit_manager,
uowm,
dup,
response_builder,
ResponseHandler(reddit_manager,
uowm,
event_logger,
source='toppost',
live_response=config.live_responses),
config=config)
top.monitor()
