Implement stand alone script, add sherrgoo

Author: Soheil

Procfile

@@ -1 +1 @@
-worker: python app.py
+worker: python app.py

README.md

@@ -36,7 +36,7 @@ You can take a look at current scripts in `scripts` folder. Do not forget to add
 implementing.
 
 ## Testing
-Before submitting a pull request, test your feature. You can do it by running `test.py` and simulating the timeline.
+Before submitting a pull request, test your feature. You can do it by running `app.py` and simulating the timeline.
 
 ## Requirements
 You need `Python 3.4` or later and `twython 3.2` to run the code.

app.py

@@ -1,71 +1,22 @@
-#!/usr/bin/python
-# -*- coding: utf-8 -*-
+import threading
+from core.utils.logging import debug
 
-import time
+import standalone_runner
+import timeline_related_runner
 
-from twython import *
-from twython.exceptions import TwythonError, TwythonRateLimitError
 
-from core.timeline_scripts_manager import TimelineScriptsManager
-from core.utils.logging import log
-from core import settings
+class TimelineRelated(threading.Thread):
+    def run(self):
+        timeline_related_runner.run()
 
 
-class MyStreamer(TwythonStreamer):
-    def __init__(self, *args, **kwargs):
-        super(MyStreamer, self).__init__(
-            settings.CONSUMER_KEY,
-            settings.CONSUMER_SECRET,
-            settings.OAUTH_TOKEN,
-            settings.OAUTH_TOKEN_SECRET,
-            *args, **kwargs
-        )
-        self.twitter = Twython(
-            settings.CONSUMER_KEY,
-            settings.CONSUMER_SECRET,
-            settings.OAUTH_TOKEN,
-            settings.OAUTH_TOKEN_SECRET
-        )
-        self.smart_handlers_manager = TimelineScriptsManager(self.twitter)
-
-    def is_a_tweet(self, data):
-        '''
-        This is a dirty way to do it, I know. But what else can I do?
-        '''
-        if 'text' in data and 'user' in data and 'id_str' in data and data['user'][
-            'screen_name'] != settings.TWIZHOOSH_USERNAME:
-            return True
-        return False
-
-    def on_success(self, data):
-        if self.is_a_tweet(data):
-            log("Timeline update: %s [%s]" % (
-                data['user']['screen_name'], data['id_str']))
-            self.smart_handlers_manager.on_timeline_update(data)
-        else:
-            log("Got non status message: \n %s \n" % data)
-
-    def on_error(self, status_code, data):
-        log(status_code)
-        log(data)
-
-    def user(self, *args, **kwargs):
-        while True:
-            try:
-                super(MyStreamer, self).user(self, *args, **kwargs)
-            except TwythonRateLimitError as e:
-                log("Rate limit error, retrying after {0} seconds".format(
-                    e.retry_after))
-                time.sleep(e.retry_after)
-            except TwythonError as e:
-                log("Twython error {0}".format(e))
-
-
-def main():
-    log("starting")
-    stream = MyStreamer()
-    stream.user(replies="all")
+class Standalone(threading.Thread):
+    def run(self):
+        standalone_runner.run()
 
 
 if __name__ == '__main__':
-    main()
+    t = TimelineRelated()
+    s = Standalone()
+    s.start()
+    t.start()

core/on_demand_scripts_manager.py

@@ -1,34 +1,25 @@
 #!/usr/bin/python
 # -*- coding: utf-8 -*-
-import importlib
 import re
 
-from core.scripts.timeline.base import base_handler
+from core.script_loader import load_scripts
+from core.scripts.timeline import base
 from core.settings import INSTALLED_ON_DEMAND_SCRIPTS
 
 
-def load_command_parser_classes():
-    scripts = []
-    for script in INSTALLED_ON_DEMAND_SCRIPTS:
-        (package_name, dot, class_name) = script.rpartition('.')
-        module = importlib.import_module(package_name)
-        scripts.append(getattr(module, class_name))
-    return scripts
-
-
 # TODO: Every dispatcher should return a
 
-class OnDemandScriptsManager(base_handler.BaseHandler):
+class OnDemandScriptsManager(base.BaseTimelineScript):
     is_mentioned_regex = r'.*(tw*izho*u*sh|[ت|ط][ی|ي][ظ|ز|ذ|ض][ه|ح]و*ش)\S* (?P<command>.*)'
 
     def __init__(self, *args, **kwargs):
         super(OnDemandScriptsManager, self).__init__(*args, **kwargs)
 
-        script_classes = load_command_parser_classes()
+        script_classes = load_scripts('scripts.on_demand', INSTALLED_ON_DEMAND_SCRIPTS)
         self.scripts = []
 
         for script_class in script_classes:
-            self.scripts.append(script_class(self.twitter, self.st_memory_manager))
+            self.scripts.append(script_class())
 
     def timeline_update(self, data):
         match = re.search(self.is_mentioned_regex, data['text'], re.IGNORECASE)

core/script_loader.py

@@ -0,0 +1,18 @@
+import importlib
+
+
+def underscore_to_camelcase(word):
+    return ''.join(x.capitalize() for x in word.split('_'))
+
+
+def load_scripts(root_package, installed_scripts):
+    """
+    Loads all script classes in: root_package
+    :return: list of script classes
+    """
+    scripts = []
+    for script_name in installed_scripts:
+        module_path = '{0}.{1}.{1}'.format(root_package, script_name)
+        module = importlib.import_module(module_path)
+        scripts.append(getattr(module, underscore_to_camelcase(script_name)))
+    return scripts

core/scripts/on_demand/base.py

@@ -0,0 +1,15 @@
+from abc import abstractmethod
+
+from core.scripts.timeline import base
+
+
+class BaseOnDemandScript(base.BaseTimelineScript):
+    @abstractmethod
+    def command_update(self, command, data):
+        """
+        Called when OnDemandScriptsManager class receives a command
+        """
+        pass
+
+    def timeline_update(self, data):
+        super(BaseOnDemandScript, self).timeline_update(self, data)

core/scripts/on_demand/base/base_command_parser.py

@@ -0,0 +1 @@
+__author__ = 'user'

core/scripts/standalone/__init__.py

@@ -0,0 +1,7 @@
+from abc import ABCMeta, abstractmethod
+
+
+class BaseStandaloneScript(metaclass=ABCMeta):
+    @abstractmethod
+    def on_called(self):
+        pass

core/scripts/standalone/base.py

@@ -0,0 +1,28 @@
+from abc import abstractmethod
+from random import randint
+from core import settings
+from core.scripts.standalone.base import BaseStandaloneScript
+from core.twitter_singleton import TwitterSingleton
+from core.utils.logging import debug
+
+
+class TweetPerDayBase(BaseStandaloneScript):
+    expected_tweet_per_day = 10
+
+    def __init__(self):
+        self.twitter = TwitterSingleton()
+
+    @abstractmethod
+    def update(self):
+        """
+        Called by on_called, approximately @expected_tweet_per_day times each day
+        """
+        pass
+
+    def on_called(self):
+        SECONDS_PER_DAY = 24 * 60 * 60
+        num_of_calls = SECONDS_PER_DAY / settings.STAND_ALONE_REPEAT_TIME
+
+        if randint(0, num_of_calls) < self.expected_tweet_per_day:
+            self.update()
+        pass

core/scripts/standalone/tweet_per_day_base.py

@@ -0,0 +1,17 @@
+from abc import ABCMeta, abstractmethod
+
+from core.st_memory_singleton import STMemory
+from core.twitter_singleton import TwitterSingleton
+
+
+class BaseTimelineScript(object, metaclass=ABCMeta):
+    def __init__(self):
+        self.twitter = TwitterSingleton()
+        self.st_memory = STMemory()
+
+    @abstractmethod
+    def timeline_update(self, data):
+        """
+        Called when someone @Twizhoosh follows, tweets something
+        """
+        pass

core/scripts/timeline/base.py

@@ -7,16 +7,16 @@
 
 from twython import *
 
-from core.scripts.timeline.base.base_handler import BaseHandler
+from core.scripts.timeline.base import BaseTimelineScript
 from core.utils.logging import log
 
 
-class SmartReplyByKeyword(BaseHandler, metaclass=ABCMeta):
-    '''
+class BaseReplyByKeywordScript(BaseTimelineScript, metaclass=ABCMeta):
+    """
     @replies contains a list of keywords and reply messages, If a tweet
     in timeline contains one of the keywords, @Twizhoosh replies with
     something random from its reply_messages
-    '''
+    """
 
     replies = []
 
@@ -25,7 +25,7 @@ class SmartReplyByKeyword(BaseHandler, metaclass=ABCMeta):
 
     @abstractmethod
     def timeline_update(self, data):
-        marked = self.st_memory_manager.is_person_marked(self.__class__.__name__, data)
+        marked = self.st_memory.is_person_marked(self.__class__.__name__, data)
 
         if not self.answer_once or not marked:
             for i in range(len(self.replies)):
@@ -35,8 +35,8 @@ def timeline_update(self, data):
                         log('matched')
                         try:
                             if self.answer_once:
-                                self.st_memory_manager.mark_person(self.__class__.__name__, data)
-                            self.reply_to(
+                                self.st_memory.mark_person(self.__class__.__name__, data)
+                            self.twitter.reply_to(
                                 data, random.choice(reply['reply_messages']))
                         except TwythonError as e:
                             print(e)

core/scripts/timeline/base/__init__.py

@@ -10,23 +10,23 @@
 
 TWEET_LENGTH = 140
 TWEET_URL_LENGTH = 21
-
-# TODO: Refactor the way modules are loaded. Since added some modules to
-# core, had to delete HANDLERS_PACKAGE
-
 TWIZHOOSH_USERNAME = 'twizhoosh'
 
+
 # order is preserved
 INSTALLED_TIMELINE_SCRIPTS = [
-    "core.on_demand_scripts_manager.OnDemandScriptsManager",
-
-    "scripts.timeline.spell_checker.spell_checker.SpellChecker",
-    "scripts.timeline.goodnight.goodnight.GoodNight",
-    "scripts.timeline.reply_by_learned_replies.reply_by_learned_replies.ReplyByLearnedReplies",
-    # "scripts.timeline.say_hi.say_hi.SayHi"
+    "spell_checker",
+    "good_night",
+    "reply_by_learned_replies",
 ]
 
 INSTALLED_ON_DEMAND_SCRIPTS = [
-    "scripts.on_demand.learn_to_reply.learn_to_reply.LearnToReply",
-    "scripts.on_demand.mustachify.mustachify.Mustachify",
+    "learn_to_reply",
+    "mustachify",
+]
+
+INSTALLED_STANDALONE_SCRIPTS = [
+    "call_sherrgoo",
 ]
+# Stand-Alone repeat time (seconds)
+STAND_ALONE_REPEAT_TIME = 1

core/scripts/timeline/base/base_handler.py

@@ -1,8 +1,14 @@
 from core.utils.logging import log
 
 
-class STMemoryManager():
+class STMemory():
     memory = {}
+    _instance = None
+
+    def __new__(cls, *args, **kwargs):
+        if not cls._instance:
+            cls._instance = super(STMemory, cls).__new__(cls, *args, **kwargs)
+        return cls._instance
 
     def mark_person(self, key, tweet_data):
         log('Mark {0} for {1}'.format(tweet_data['user']['screen_name'], key))