add tech terms tech matching

Author: wimo7083

pybot/__main__.py

@@ -50,9 +50,9 @@ def make_sentry_logger():
     endpoints.slack.create_endpoints(slack)
     bot.load_plugin(slack)
 
-    airtable = AirtablePlugin()
-    endpoints.airtable.create_endpoints(airtable)
-    bot.load_plugin(airtable)
+    #airtable = AirtablePlugin()
+    #endpoints.airtable.create_endpoints(airtable)
+    #bot.load_plugin(airtable)
 
     # Add route to respond to AWS health check
     bot.router.add_get("/health", lambda request: Response(status=200))

pybot/endpoints/slack/commands.py

@@ -5,11 +5,10 @@
 from slack import methods
 from slack.commands import Command
 
-from pybot.endpoints.slack.utils import PYBACK_HOST, PYBACK_PORT, PYBACK_TOKEN, REPORT_CHANNEL, YELP_TOKEN
+from pybot.endpoints.slack.utils import PYBACK_HOST, PYBACK_PORT, PYBACK_TOKEN, REPORT_CHANNEL
 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)
 
 
@@ -109,20 +107,4 @@ async def slash_repeat(command: Command, app: SirBot):
     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/tech.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,35 +53,36 @@ 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
+
+    def remove_tech(self, initial_input):
+        return initial_input.split('!tech', 1)[1]
 
-        self.response_params = self._parse_input()
+    async def grab_values(self) -> dict:
 
-    def grab_values(self) -> dict:
         if not self.input_text:
-            return {'type': 'ephemeral', 'message': self._help_text()}
+            return {'message': self._help_text()}
 
         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' +
@@ -92,27 +91,28 @@ def _help_text(self):
                 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/messages.py

@@ -2,13 +2,17 @@
 
 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)
 
 
 def not_bot_message(event: Message):
@@ -19,6 +23,18 @@ def not_bot_delete(event: Message):
     return 'previous_message' not in event or 'bot_id' not in event['previous_message']
 
 
+async def tech_tips(event: Message, app: SirBot):
+    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.