Merge pull request #51 from OperationCode/staging

Staging

Author: apex-omontgomery

.gitignore

@@ -2,3 +2,4 @@
 *.env
 .pytest_cache
 !/docker/example.env
+*/__pycache__

pybot/endpoints/slack/commands.py

@@ -9,7 +9,6 @@
 from pybot.endpoints.slack.utils.action_messages import not_claimed_attachment
 from pybot.endpoints.slack.utils.command_utils import get_slash_here_messages, get_slash_repeat_messages, response_type
 from pybot.endpoints.slack.utils.slash_lunch import LunchCommand
-from pybot.endpoints.slack.utils.slash_tech import TechTerms
 
 logger = logging.getLogger(__name__)
 
@@ -24,7 +23,6 @@ def create_endpoints(plugin: SlackPlugin):
     plugin.on_command('/here', slash_here, wait=False)
     plugin.on_command('/lunch', slash_lunch, wait=False)
     plugin.on_command('/repeat', slash_repeat, wait=False)
-    plugin.on_command('/tech', slash_tech, wait=False)
     plugin.on_command('/report', slash_report, wait=False)
 
 
@@ -107,22 +105,3 @@ async def slash_repeat(command: Command, app: SirBot):
 
     method_type, message = get_slash_repeat_messages(slack_id, channel_id, command['text'])
     await slack.query(method_type, message)
-
-
-async def slash_tech(command: Command, app: SirBot):
-    logger.info(f'tech command data incoming {command}')
-    channel_id = command['channel_id']
-    slack_id = command['user_id']
-    slack = app["plugins"]["slack"].api
-
-    tech_terms: dict = TechTerms(command['channel_id'], command['user_id'],
-                                 command.get('text'), command['user_name'], app).grab_values()
-    method_type = response_type(tech_terms['type'])
-    text = tech_terms['message']
-    message = {
-        'text': text,
-        'channel': channel_id,
-        'user': slack_id
-    }
-
-    await slack.query(method_type, message)

pybot/endpoints/slack/event_messages/__init__.py

@@ -25,17 +25,15 @@ async def _update_terms(self) -> Dict[str, list]:
         two_col_org_row: Pattern[str] = self._compile_regex_from_parts()
 
         content = await self._grab_data_from_github()
-
         lines: List[str] = content.splitlines()
 
-        return {x['term'].lower(): 'f{x["term"]} is x["definition"]}' for x in
+        return {x['term'].lower(): f'{x["term"]} is {x["definition"]}' for x in
                 self._filter_matches(lines, two_col_org_row)}
 
     async def _grab_data_from_github(self) -> str:
         async with self.app.http_session.get(self.TERM_URL) as r:
             r.raise_for_status()
-            data = await r.json()
-            return data.decode('utf-8')
+            return await r.text(encoding='utf-8')
 
     def _compile_regex_from_parts(self) -> Pattern[str]:
         n_spaces_pipe_n_spaces = '\\s*\\|\\s*'
@@ -55,64 +53,64 @@ def _filter_matches(self, lines: List[str], two_col_org_row: Pattern[str]) -> Ge
 class TechTerms:
     # shared across all instances
     TERMS = {}
-    ADD_GITHUB_CHANCE = .25
+    ADD_GITHUB_CHANCE = 1
 
-    def __init__(self, channel: str, user: str, input_text: str, user_name: str, app):
+    def __init__(self, channel: str, user: str, input_text: str, app):
 
         self.channel_id = channel
         self.user_id = user
-        self.input_text = input_text
-        self.user_name = user_name
+        self.input_text = self.remove_tech(input_text)
         self.app = app
+        self.response_params = None
 
-        self.response_params = self._parse_input()
+    def remove_tech(self, initial_input):
+        return initial_input.split('!tech', 1)[1]
 
-    def grab_values(self) -> dict:
+    async def grab_values(self) -> dict:
         if not self.input_text:
-            return {'type': 'ephemeral', 'message': self._help_text()}
+            return {'message': {'text' : self._help_text(), 'channel': self.channel_id,}}
 
         else:
+            if not self.response_params:
+                await self._parse_input()
 
-            split_items: List[str] = self.input_text.split()
-            if split_items[0] == 'loud':
-                return {'type': 'loud', 'message': self._grab_term(split_items)}
-
-            if split_items[0] == 'loud':
-                return {'type': 'loud', 'message': self._grab_term(split_items)}
+            if self.input_text:
+                return {'message': self._grab_term(term=self.input_text)}
 
-        return {'type': 'ephemeral', 'message': self._grab_term(), }
+        return {'message': self._grab_term(), }
 
     async def _parse_input(self) -> None:
-        self.TERMS = await TechTermsGrabber(self.app).get_terms()
+        grabber = TechTermsGrabber(self.app)
+        self.TERMS = await grabber.get_terms()
 
     def _help_text(self):
         return ('Use this to find descriptions of common and useful tech terms. Examples:\n' +
-                '"/resources Javascript", for self study\n' +
-                '"/resources loud Javascript", to announce to channel' +
+                '"!tech Java" or "!tech prolog"' +
                 self._source_text())
 
     def _source_text(self):
-        return '\nFor the source data please see <github|https://github.com/togakangaroo/tech-terms>'
+        return '\nTech Terms source: <https://github.com/togakangaroo/tech-terms|github>'
 
-    def _convert_key_to_dict(self, key: str) -> dict:
-        return {'term': key, 'definition': self.TERMS[key]}
+    def _convert_key_to_dict(self, key: str, random_val: bool = False) -> dict:
+        return {'term': key, 'random': random_val, 'definition': f'{self.TERMS[key]}'}
 
     def _grab_term(self, term=None):
-        if isinstance(term, list) and len(term) > 1 and self.TERMS.get(term[1].lower()):
-            term_key: str = self.TERMS.get(term[1])
+        if term and self.TERMS.get(term.lower().strip()):
+            term_key: str = term.lower().strip()
             return self._build_response_text(self._convert_key_to_dict(term_key))
 
         return self._build_response_text(self._random_term())
 
     def _build_response_text(self, term: dict) -> dict:
-        return {'user': self.user_id, 'channel': self.channel_id,
+        return {'channel': self.channel_id,
                 'text': self._serialize_term(term)}
 
     def _random_term(self) -> dict:
-        item = choice(self.TERMS.keys())
-        return self._convert_key_to_dict(item)
+        item = choice(list(self.TERMS.keys()))
+        return self._convert_key_to_dict(item, random_val=True)
 
     def _serialize_term(self, term: Dict[str, str]) -> str:
-        addnl = self._source_text() if random.random() < self.ADD_GITHUB_CHANCE else ''
+        random_text = "Selected random term:\n"
+        addnl = self._source_text() if random() < self.ADD_GITHUB_CHANCE else ''
 
-        return f'{term["definition"]}{addnl}'
+        return f'{random_text if term["random"] else ""} {term["definition"]}{addnl}'

pybot/endpoints/slack/utils/slash_tech.py …t/endpoints/slack/event_messages/tech.pypybot/endpoints/slack/utils/slash_tech.py renamed to pybot/endpoints/slack/event_messages/tech.py pybot/endpoints/slack/utils/slash_tech.py renamed to pybot/endpoints/slack/event_messages/tech.py

@@ -2,23 +2,57 @@
 
 from sirbot import SirBot
 from slack.events import Message
+from slack import methods
+
+from pybot.endpoints.slack.event_messages.tech import TechTerms
 
 logger = logging.getLogger(__name__)
 
 
 def create_endpoints(plugin):
     plugin.on_message(".*", message_changed, subtype="message_changed")
     plugin.on_message(".*", message_deleted, subtype="message_deleted")
+    plugin.on_message(".*\!tech", tech_tips)
+    plugin.on_message(".*\<\!here\>", here_bad)
+    plugin.on_message(".*\<\!channel\>", here_bad)
+    plugin.on_message(".*\@here", here_bad)
+    plugin.on_message(".*\@channel", here_bad)
+    plugin.on_message(".*@here", here_bad)
+    plugin.on_message(".*@channel", here_bad)
+    plugin.on_message(".*codervets", not_named)
 
 
 def not_bot_message(event: Message):
     return 'message' not in event or 'subtype' not in event['message'] or event['message']['subtype'] != 'bot_message'
 
-
 def not_bot_delete(event: Message):
     return 'previous_message' not in event or 'bot_id' not in event['previous_message']
 
 
+async def not_named(event: Message, app: SirBot):
+    response = {'channel': event['channel'], 'text': f'<@{event["user"]}> - How dare you utter the Dark Lord\'s name'}
+    await app.plugins["slack"].api.query(methods.CHAT_POST_MESSAGE, data=response)
+
+
+async def here_bad(event: Message, app: SirBot):
+    response = {'channel': event['channel'],
+                'text': f'<@{event["user"]}> - you are a very bad person for using that command'}
+    await app.plugins["slack"].api.query(methods.CHAT_POST_MESSAGE, data=response)
+
+
+async def tech_tips(event: Message, app: SirBot):
+    if not_bot_message(event):
+        logger.info(
+            f'tech logging: {event}')
+        try:
+            tech_terms: dict = await TechTerms(event['channel'], event['user'],
+                                           event.get('text'), app).grab_values()
+
+            await app.plugins["slack"].api.query(methods.CHAT_POST_MESSAGE, tech_terms['message'])
+        except Exception as E:
+            logger.exception(E)
+
+
 async def message_changed(event: Message, app: SirBot):
     """
     Logs all message edits not made by a bot.