Run Black to apply consistent code styling

Author: AllenAnthes

.editorconfig

@@ -15,8 +15,6 @@ cchardet = "*"
 zipcodes = "*"
 
 [dev-packages]
-flake8 = "*"
-flake8-quotes = "*"
 requests = "*"
 pytest = "*"
 pytest-mock = "*"

.flake8

@@ -4,5 +4,5 @@
 from dotenv import load_dotenv
 
 """ Loads values from .env file for local development """
-url = Path(os.path.dirname(os.path.dirname(__file__))) / 'docker' / 'pybot.env'
+url = Path(os.path.dirname(os.path.dirname(__file__))) / "docker" / "pybot.env"
 load_dotenv(dotenv_path=url)

Pipfile

@@ -32,7 +32,7 @@ def make_sentry_logger():
 if __name__ == "__main__":
     try:
         with open(
-                os.path.join(os.path.dirname(os.path.realpath(__file__)), "../logging.yml")
+            os.path.join(os.path.dirname(os.path.realpath(__file__)), "../logging.yml")
         ) as log_configfile:
             logging.config.dictConfig(yaml.load(log_configfile.read()))
     except Exception as e:
@@ -54,6 +54,6 @@ def make_sentry_logger():
 
     # Add route to respond to AWS health check
     bot.router.add_get("/health", lambda request: Response(status=200))
-    logging.getLogger('aiohttp.access').setLevel(logging.WARNING)
+    logging.getLogger("aiohttp.access").setLevel(logging.WARNING)
 
     bot.start(host=HOST, port=PORT, print=logger.info)

Pipfile.lock

@@ -3,9 +3,11 @@
 
 def mentor_request_text(user_id, service, skillsets, requested_mentor_message=None):
     if not skillsets:
-        skillsets = 'None provided'
-    text = (f"User <@{user_id}> has requested a mentor for {service}\n\n"
-            f"Requested Skillset(s): {skillsets.replace(',', ', ')}")
+        skillsets = "None provided"
+    text = (
+        f"User <@{user_id}> has requested a mentor for {service}\n\n"
+        f"Requested Skillset(s): {skillsets.replace(',', ', ')}"
+    )
 
     if requested_mentor_message:
         text += requested_mentor_message
@@ -14,17 +16,21 @@ def mentor_request_text(user_id, service, skillsets, requested_mentor_message=No
 
 
 def claim_mentee_attachment(record: str) -> List[dict]:
-    return [{
-        'text': '',
-        'fallback': '',
-        'color': '#3AA3E3',
-        'callback_id': 'claim_mentee',
-        'attachment_type': 'default',
-        'actions': [{
-            'name': f'{record}',
-            'text': 'Claim Mentee',
-            'type': 'button',
-            'style': 'primary',
-            'value': f'mentee_claimed',
-        }]
-    }]
+    return [
+        {
+            "text": "",
+            "fallback": "",
+            "color": "#3AA3E3",
+            "callback_id": "claim_mentee",
+            "attachment_type": "default",
+            "actions": [
+                {
+                    "name": f"{record}",
+                    "text": "Claim Mentee",
+                    "type": "button",
+                    "style": "primary",
+                    "value": f"mentee_claimed",
+                }
+            ],
+        }
+    ]

pybot/__init__.py

@@ -2,14 +2,19 @@
 import asyncio
 import logging
 
-from pybot.endpoints.airtable.utils import (_create_messages, _get_matching_skillset_mentors, _get_requested_mentor,
-                                            _post_messages, _slack_user_id_from_email)
+from pybot.endpoints.airtable.utils import (
+    _create_messages,
+    _get_matching_skillset_mentors,
+    _get_requested_mentor,
+    _post_messages,
+    _slack_user_id_from_email,
+)
 
 logger = logging.getLogger(__name__)
 
 
 def create_endpoints(plugin):
-    plugin.on_request('mentor_request', mentor_request)
+    plugin.on_request("mentor_request", mentor_request)
 
 
 async def mentor_request(request: dict, app: SirBot) -> None:
@@ -19,19 +24,26 @@ async def mentor_request(request: dict, app: SirBot) -> None:
     Queries Airtable to find mentors matching the requested skillsets and posts a message
     in the Mentor slack channel.
     """
-    slack = app.plugins['slack'].api
-    airtable = app.plugins['airtable'].api
+    slack = app.plugins["slack"].api
+    airtable = app.plugins["airtable"].api
 
     id_fallback = f" [couldn't find user - email provided: {request['email']} ]"
-    slack_id = await _slack_user_id_from_email(request['email'], slack, fallback=id_fallback)
-
-    futures = [airtable.get_name_from_record_id('Services', request['service']),
-               _get_requested_mentor(request.get('requested_mentor'), slack, airtable),
-               _get_matching_skillset_mentors(request.get('skillsets'), slack, airtable)]
-
-    service_translation, requested_mentor_message, mentors = await asyncio.gather(*futures)
-
-    first_message, *children = _create_messages(mentors, request, requested_mentor_message, service_translation,
-                                                slack_id)
+    slack_id = await _slack_user_id_from_email(
+        request["email"], slack, fallback=id_fallback
+    )
+
+    futures = [
+        airtable.get_name_from_record_id("Services", request["service"]),
+        _get_requested_mentor(request.get("requested_mentor"), slack, airtable),
+        _get_matching_skillset_mentors(request.get("skillsets"), slack, airtable),
+    ]
+
+    service_translation, requested_mentor_message, mentors = await asyncio.gather(
+        *futures
+    )
+
+    first_message, *children = _create_messages(
+        mentors, request, requested_mentor_message, service_translation, slack_id
+    )
 
     await _post_messages(first_message, children, app)

pybot/__main__.py

@@ -10,63 +10,85 @@
 from .message_templates.messages import claim_mentee_attachment, mentor_request_text
 
 
-async def _get_requested_mentor(requested_mentor: Optional[str], slack: SlackAPI,
-                                airtable: AirtableAPI) -> Optional[str]:
+async def _get_requested_mentor(
+    requested_mentor: Optional[str], slack: SlackAPI, airtable: AirtableAPI
+) -> Optional[str]:
     try:
         if not requested_mentor:
             return None
-        mentor = await airtable.get_row_from_record_id('Mentors', requested_mentor)
-        email = mentor['Email']
+        mentor = await airtable.get_row_from_record_id("Mentors", requested_mentor)
+        email = mentor["Email"]
         slack_user_id = await _slack_user_id_from_email(email, slack)
         return f" Requested mentor: <@{slack_user_id}>"
     except SlackAPIError:
         return None
 
 
-async def _slack_user_id_from_email(email: str, slack: SlackAPI, fallback: Optional[str] = None) -> str:
+async def _slack_user_id_from_email(
+    email: str, slack: SlackAPI, fallback: Optional[str] = None
+) -> str:
     try:
-        response = await slack.query(url=ROOT_URL + 'users.lookupByEmail', data={'email': email})
-        return response['user']['id']
+        response = await slack.query(
+            url=ROOT_URL + "users.lookupByEmail", data={"email": email}
+        )
+        return response["user"]["id"]
     except SlackAPIError:
-        # TODO: something better here
-        return fallback or 'Slack User'
+        return fallback or "Slack User"
 
 
-async def _get_matching_skillset_mentors(skillsets: str, slack: SlackAPI, airtable: AirtableAPI) -> List[str]:
+async def _get_matching_skillset_mentors(
+    skillsets: str, slack: SlackAPI, airtable: AirtableAPI
+) -> List[str]:
     if not skillsets:
-        return ['No skillset Given']
+        return ["No skillset Given"]
     mentors = await airtable.find_mentors_with_matching_skillsets(skillsets)
-    mentor_ids = [await _slack_user_id_from_email(mentor['Email'], slack, fallback=mentor['Slack Name']) for mentor in
-                  mentors]
-    return [f'<@{mentor}>' for mentor in mentor_ids]
+    mentor_ids = [
+        await _slack_user_id_from_email(
+            mentor["Email"], slack, fallback=mentor["Slack Name"]
+        )
+        for mentor in mentors
+    ]
+    return [f"<@{mentor}>" for mentor in mentor_ids]
 
 
-def _create_messages(mentors: List[str], request: dict, requested_mentor_message: str, service_translation: str,
-                     slack_id: str) -> Tuple[dict, dict, dict]:
+def _create_messages(
+    mentors: List[str],
+    request: dict,
+    requested_mentor_message: str,
+    service_translation: str,
+    slack_id: str,
+) -> Tuple[dict, dict, dict]:
     first_message = {
-        'text': mentor_request_text(slack_id, service_translation, request.get('skillsets', None),
-                                    requested_mentor_message),
-        'attachments': claim_mentee_attachment(request['record']),
-        'channel': MENTOR_CHANNEL
+        "text": mentor_request_text(
+            slack_id,
+            service_translation,
+            request.get("skillsets", None),
+            requested_mentor_message,
+        ),
+        "attachments": claim_mentee_attachment(request["record"]),
+        "channel": MENTOR_CHANNEL,
     }
 
     details_message = {
-        'text': f"Additional details: {request.get('details', 'None Given')}",
-        'channel': MENTOR_CHANNEL
+        "text": f"Additional details: {request.get('details', 'None Given')}",
+        "channel": MENTOR_CHANNEL,
     }
 
     matching_mentors_message = {
-        'text': "Mentors matching all or some of the requested skillsets: " + ' '.join(mentors),
-        'channel': MENTOR_CHANNEL
+        "text": "Mentors matching all or some of the requested skillsets: "
+        + " ".join(mentors),
+        "channel": MENTOR_CHANNEL,
     }
 
     return first_message, details_message, matching_mentors_message
 
 
 async def _post_messages(parent: Message, children: List[Message], app: SirBot) -> None:
-    response = await app.plugins['slack'].api.query(url=methods.CHAT_POST_MESSAGE, data=parent)
-    timestamp = response['ts']
+    response = await app.plugins["slack"].api.query(
+        url=methods.CHAT_POST_MESSAGE, data=parent
+    )
+    timestamp = response["ts"]
 
     for child in children:
-        child['thread_ts'] = timestamp
-        await app.plugins['slack'].api.query(url=methods.CHAT_POST_MESSAGE, data=child)
+        child["thread_ts"] = timestamp
+        await app.plugins["slack"].api.query(url=methods.CHAT_POST_MESSAGE, data=child)