strideutils 0.5.4__tar.gz → 0.6.0__tar.gz

{strideutils-0.5.4 → strideutils-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: strideutils
-Version: 0.5.4
+Version: 0.6.0
 Summary: 
 Author: Your Name
 Author-email: you@example.com

{strideutils-0.5.4 → strideutils-0.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "strideutils"
-version = "0.5.4"
+version = "0.6.0"
 description = ""
 authors = ["Your Name <you@example.com>"]
 readme = "README.md"

strideutils-0.6.0/strideutils/slack_connector.py

@@ -0,0 +1,147 @@
+import os
+import traceback
+from typing import List, Optional, Union
+
+from slack_sdk import WebClient
+from slack_sdk.errors import SlackApiError
+
+from strideutils.stride_config import config, get_env_or_raise
+from strideutils.stride_config import Environment as e
+
+
+class SlackClient:
+    """
+    Singleton client used to post messages to slack
+    """
+
+    _instance = None
+
+    def __new__(cls):
+        # Creates a new instance if one does not already exist
+        if cls._instance is None:
+            cls._instance = super(SlackClient, cls).__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        # Prevent re-initialization if a client has already been created
+        if hasattr(self, "client"):
+            return
+
+        self.api_token = get_env_or_raise(e.STRIDEBOT_API_TOKEN)
+        self.client = WebClient(token=self.api_token)
+
+    def post_message(
+        self,
+        message: Union[str, List[str]],
+        channel: str,
+        botname: Optional[str] = None,
+        thread_ts: Optional[str] = None,
+    ):
+        """
+        Posts a slack message to the given channel
+        If the message is an array, this will post each element of the array as a thread
+
+        Returns the thread_ts to allow chaining messages
+        """
+        # Allow optional channel overrides via an environment variable
+        channel = os.environ.get(e.SLACK_CHANNEL_OVERRIDE, default=channel)
+
+        # Listify
+        messages = [message] if type(message) is str else message
+
+        # Post each message, threading with the previous
+        thread_ts = None or thread_ts
+        for msg in messages:
+            response = self.client.chat_postMessage(
+                channel=channel,
+                text=msg,
+                thread_ts=thread_ts,
+                username=botname,
+            )
+            if thread_ts is None:  # API advises to use parent IDs instead of child's
+                thread_ts = response["ts"]
+
+        return thread_ts
+
+    def upload_file(self, file_name: str, content: str) -> str:
+        """
+        This uploads a file and returns a link that can be used to embed a file in slack
+        Ex:
+            url = upload_file("test.txt", "Hello World")
+            post_msg(f"<{url}|This is a file>", channel="#alerts-debug")
+        """
+        slack_file = self.client.files_upload_v2(filename=file_name, content=content)
+        file_link = slack_file["file"]["permalink"]
+        return file_link
+
+
+# TODO: Remove after all launchpad instances are removed
+def post_msg(
+    txt: Union[str, List[str]],
+    channel: str,
+    botname: Optional[str] = None,
+    unfurl_links: bool = False,
+    unfurl_media: bool = False,
+    thread_ts: Optional[str] = None,
+):
+    """
+    DEPRECATED: Use slack client instead
+
+    Posts a slack message to the given channel, e.g.
+
+        post_msg('hello world', 'general')
+
+    if txt is an array, this will post each element of the array as a thread
+
+    Args:
+      username: Rename stridebot
+    """
+    token = get_env_or_raise(e.STRIDEBOT_API_TOKEN)
+    client = WebClient(token=token)
+    channel = config.slack_channels.get(channel.replace('#', ''), channel)
+    channel = os.environ.get('SLACK_CHANNEL_OVERRIDE', default=channel)
+
+    # Listify
+    messages = [txt] if type(txt) is str else txt
+
+    # thread ts keeps track of the latest thread ID so we can keep replying in-thread
+    thread_ts = None or thread_ts
+    for msg in messages:
+        try:
+            response = client.chat_postMessage(
+                channel=channel,
+                text=msg,
+                thread_ts=thread_ts,
+                username=botname,
+                unfurl_links=unfurl_links,
+                unfurl_media=unfurl_media,
+            )
+            if thread_ts is None:  # API advises to use parent IDs instead of child's
+                thread_ts = response['ts']
+        except SlackApiError as error:
+            print("Error sending message: ", error)
+            raise
+    return thread_ts
+
+
+def upload_file(file_name: str, content: str) -> str:
+    """
+    DEPRECATED: Use slack client instead
+
+    This uploads a file called "file_name" with the string contents "content"
+
+    This will return a link that can be used to embed a file in slack.
+    For example:
+        url = upload_file("test.txt", "Hello World")
+        post_msg(f"<{url}|This is a file>", channel="#alerts-debug")
+    """
+    token = get_env_or_raise(e.STRIDEBOT_API_TOKEN)
+    client = WebClient(token=token)
+    try:
+        slack_file = client.files_upload_v2(filename=file_name, content=content)
+    except Exception as error:
+        print(f"Error uploading file to slack: {error}")
+        traceback.print_exc()
+        raise ValueError(f"Error uploading file to slack: {error}")
+    file_link = slack_file['file']['permalink']
+    return file_link

{strideutils-0.5.4 → strideutils-0.6.0}/strideutils/stride_alerts.py

@@ -7,7 +7,7 @@ from typing import Any, Callable, Iterable, List, Optional, Tuple, Union, cast
 import pandas as pd
 import tabulate
 
-from strideutils import slack_connector, twilio_connector
+from strideutils import slack_connector
 from strideutils.stride_config import config
 
 DEFAULT_DAILY_UTC_HOUR = 17
@@ -43,13 +43,12 @@ def notify(
     messages: Union[str, List[str]],
     urgency,
     tag: Optional[Union[str, Iterable[str]]] = None,
-    call: Optional[Union[str, Iterable[str]]] = None,
     beta_alert: bool = False,
     debug_readme: str = config.alerts_playbook,
     debug_readme_section: str = "",
 ) -> None:
     """
-    Post an alert in the proper channel and optionally call
+    Post an alert in the proper channel
 
     Args:
         msgs: A string or list of strings to notify on
@@ -60,7 +59,6 @@ def notify(
     urgency = AlertType(urgency)
 
     messages_list: List = cast(List, [messages] if type(messages) is str else messages)
-    top_level_message = str(messages_list[0])
 
     debug_msg = f"Read more: {debug_readme}{debug_readme_section}"
 
@@ -80,16 +78,15 @@ def notify(
     if tag:
         messages_list[0] += f"\n{get_tags(tag)}"
 
-    slack_connector.post_msg(messages_list + [debug_msg], channel)
+    messages_list.append(debug_msg)
 
-    if call:
-        twilio_connector.send_calls(top_level_message, call)
+    slack_client = slack_connector.SlackClient()
+    slack_client.post_message(message=messages_list, channel=channel)
 
 
 def raise_alert(
     urgency: Union[AlertType, str],
     tag: Optional[Union[str, Iterable[str]]] = None,
-    call: Optional[Union[str, Iterable[str]]] = None,
     beta_alert: bool = False,
     debug_readme: str = config.alerts_playbook,
     debug_readme_section: str = "",
@@ -103,10 +100,13 @@ def raise_alert(
     For local testing, set an environment variable ENV=DEV or use
     urgency='debug'
     """
+    # Initialize stride client to make sure environment variables are set
+    slack_connector.SlackClient()
+
     urgency = AlertType(urgency)
     if urgency == AlertType.DEBUG or os.environ.get('ENV') == 'DEV':
         print("DEV mode: Alert tagging and calling is suppressed. \n" "Slack alerts will appear in #alerts-debug.")
-        call, tag = [], []
+        tag = []
         urgency = AlertType.DEBUG
 
     def _decorator(f: Callable):
@@ -125,7 +125,6 @@ def raise_alert(
                     messages=msgs,
                     urgency=urgency,
                     tag=tag,
-                    call=call,
                     beta_alert=beta_alert,
                     debug_readme=debug_readme,
                     debug_readme_section=debug_readme_section,

{strideutils-0.5.4 → strideutils-0.6.0}/strideutils/stride_config.py

@@ -17,6 +17,31 @@ if ENV not in ["DEV", "PROD"]:
     raise ValueError("Environment variable 'ENV' must be set to either DEV or PROD")
 
 
+@dataclass(frozen=True)
+class Environment:
+    """
+    List of all possible environment variables
+    """
+
+    TWILIO_ALERTS_NUMBER = "TWILIO_ALERTS_NUMBER"
+    TWILIO_ACCOUNT_ID = "TWILIO_ACCOUNT_ID"
+    TWILIO_API_TOKEN = "TWILIO_API_TOKEN"
+
+    STRIDEBOT_API_TOKEN = "STRIDEBOT_API_TOKEN"
+    SLACK_CHANNEL_OVERRIDE = "SLACK_CHANNEL_OVERRIDE"
+
+
+def get_env_or_raise(variable_name: str) -> str:
+    """
+    Attempts to fetch and return the environment variable, but errors
+    if it's not set
+    """
+    value = os.getenv(variable_name)
+    if not value:
+        raise EnvironmentError(f"Environment variable {variable_name} must be set")
+    return value
+
+
 @dataclass
 class ConfigObj:
     """Raise an error if a config is not set."""
@@ -168,15 +193,6 @@ class Config(ConfigObj):
     ENV: str
     timezone: str = "US/Eastern"
 
-    # Twilio
-    TWILIO_ALERTS_NUMBER: str = ""
-    TWILIO_ACCOUNT_ID: str = ""
-    TWILIO_API_TOKEN: str = ""
-    PHONE_NUMBERS: ConfigDict = field(default_factory=ConfigDict)
-
-    # Slack
-    STRIDEBOT_API_TOKEN: str = ""
-
     # Gsheets - loads from str env var in PROD
     PUBLICSHEETS_AUTH: Union[str, ConfigDict] = field(default_factory=ConfigDict)
 

strideutils-0.6.0/strideutils/twilio_connector.py

@@ -0,0 +1,49 @@
+from typing import Iterable, List, Union
+
+from twilio.rest import Client
+
+from strideutils.stride_config import config, get_env_or_raise
+from strideutils.stride_config import Environment as e
+
+
+class TwilioClient:
+    """
+    Singleton client used to make phone calls
+    """
+
+    _instance = None
+    call_template = """<Response><Say>{}</Say></Response>"""
+
+    def __new__(cls):
+        # Creates a new instance if one does not already exist
+        if cls._instance is None:
+            cls._instance = super(TwilioClient, cls).__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        # Prevent re-initialization if a client has already been created
+        if hasattr(self, "client"):
+            return
+
+        self.account_id = get_env_or_raise(e.TWILIO_ACCOUNT_ID)
+        self.api_token = get_env_or_raise(e.TWILIO_API_TOKEN)
+        self.alert_numbers = get_env_or_raise(e.TWILIO_ALERTS_NUMBER)
+        self.client = Client(self.account_id, self.api_token)
+
+    def call(self, msg: str, to: Union[str, Iterable[str], List[str]]) -> None:
+        """
+        Make a phone call
+
+        Args:
+            msg: A timl formatted message to read aloud to the recipient
+            to: A name or list of names that can be looked up in config.PHONE_NUMBERS
+            mapping to a 11 digit phone number, with international prefix
+            e.g. config.PHONE_NUMBERS['joe'] = +12223334545
+
+        Note: SMS not available without opt-in logic for apps for toll-free verification
+        """
+        to = [to] if type(to) is str else to
+        voice_message = self.call_template.format(msg)
+        for destination in to:
+            number = config.PHONE_NUMBERS[destination]
+            self.client.calls.create(to=number, from_=config.TWILIO_ALERTS_NUMBER, twiml=voice_message)

strideutils-0.5.4/strideutils/slack_connector.py

@@ -1,74 +0,0 @@
-import os
-import traceback
-from typing import List, Optional, Union
-
-from slack_sdk import WebClient
-from slack_sdk.errors import SlackApiError
-
-from strideutils.stride_config import config
-
-
-def post_msg(
-    txt: Union[str, List[str]],
-    channel: str,
-    token: str = config.STRIDEBOT_API_TOKEN,
-    botname: Optional[str] = None,
-    unfurl_links: bool = False,
-    unfurl_media: bool = False,
-    thread_ts: Optional[str] = None,
-):
-    """
-    Posts a slack message to the given channel, e.g.
-
-        post_msg('hello world', 'general')
-
-    if txt is an array, this will post each element of the array as a thread
-
-    Args:
-      username: Rename stridebot
-    """
-    client = WebClient(token=token)
-    channel = config.slack_channels.get(channel.replace('#', ''), channel)
-    channel = os.environ.get('SLACK_CHANNEL_OVERRIDE', default=channel)
-
-    # Listify
-    messages = [txt] if type(txt) is str else txt
-
-    # thread ts keeps track of the latest thread ID so we can keep replying in-thread
-    thread_ts = None or thread_ts
-    for msg in messages:
-        try:
-            response = client.chat_postMessage(
-                channel=channel,
-                text=msg,
-                thread_ts=thread_ts,
-                username=botname,
-                unfurl_links=unfurl_links,
-                unfurl_media=unfurl_media,
-            )
-            if thread_ts is None:  # API advises to use parent IDs instead of child's
-                thread_ts = response['ts']
-        except SlackApiError as e:
-            print("Error sending message: ", e)
-            raise
-    return thread_ts
-
-
-def upload_file(file_name: str, content: str) -> str:
-    '''
-    This uploads a file called "file_name" with the string contents "content"
-
-    This will return a link that can be used to embed a file in slack.
-    For example:
-        url = upload_file("test.txt", "Hello World")
-        post_msg(f"<{url}|This is a file>", channel="#alerts-debug")
-    '''
-    client = WebClient(token=config.STRIDEBOT_API_TOKEN)
-    try:
-        slack_file = client.files_upload_v2(filename=file_name, content=content)
-    except Exception as e:
-        print(f"Error uploading file to slack: {e}")
-        traceback.print_exc()
-        raise ValueError(f"Error uploading file to slack: {e}")
-    file_link = slack_file['file']['permalink']
-    return file_link

strideutils-0.5.4/strideutils/twilio_connector.py

@@ -1,31 +0,0 @@
-from typing import Iterable, List, Union
-
-from twilio.rest import Client
-
-from strideutils.stride_config import config
-
-# Check for necessary config on import
-_ = config.TWILIO_ALERTS_NUMBER
-CALL_TEMPLATE = """<Response><Say>{}</Say></Response>"""
-
-client = Client(config.TWILIO_ACCOUNT_ID, config.TWILIO_API_TOKEN)
-
-
-# N.B. SMS not available without opt-in logic for apps for toll-free verification
-
-
-def send_calls(msg: str, to: Union[str, Iterable[str], List[str]]) -> None:
-    """
-    Make a phone call
-
-    Args:
-        msg: A timl formatted message to read aloud to the recipient
-        to: A name or list of names that can be looked up in config.PHONE_NUMBERS
-        mapping to a 11 digit phone number, with international prefix
-        e.g. config.PHONE_NUMBERS['joe'] = +12223334545
-    """
-    to = [to] if type(to) is str else to
-    voice_message = CALL_TEMPLATE.format(msg)
-    for destination in to:
-        number = config.PHONE_NUMBERS[destination]
-        client.calls.create(to=number, from_=config.TWILIO_ALERTS_NUMBER, twiml=voice_message)