slack-remote 0.0.1__py3-none-any.whl

slack_remote/src/__init__.py

@@ -0,0 +1,4 @@
+from .slack_remote import SlackRemote
+from .slack_remote_exception import SlackRemoteException
+
+__all__ = ["SlackRemote", "SlackRemoteException"]

slack_remote/src/constants_slack_remote.py

@@ -0,0 +1,7 @@
+SLACK_API_BASE_URL = "https://slack.com/api"
+SLACK_BOT_TOKEN_ENV = "SLACK_BOT_TOKEN"
+SLACK_UNAVAILABLE_ERROR_CODE = "slack_unavailable"
+HTTP_REQUEST_TIMEOUT_SECONDS = 15
+# A bot usually replies in the thread within ~10 seconds
+WAIT_FOR_THREAD_REPLY_TIMEOUT_SECONDS = 60
+WAIT_FOR_THREAD_REPLY_POLL_SECONDS = 3

slack_remote/src/slack_remote.py

@@ -0,0 +1,93 @@
+import hashlib
+import hmac
+import json
+import time
+from http import HTTPMethod
+from typing import Any, Callable, Optional
+
+import requests
+from python_sdk_remote.utilities import our_get_env
+
+from .constants_slack_remote import (
+    HTTP_REQUEST_TIMEOUT_SECONDS,
+    SLACK_API_BASE_URL,
+    SLACK_BOT_TOKEN_ENV,
+    SLACK_UNAVAILABLE_ERROR_CODE,
+    WAIT_FOR_THREAD_REPLY_POLL_SECONDS,
+    WAIT_FOR_THREAD_REPLY_TIMEOUT_SECONDS,
+)
+from .slack_remote_exception import SlackRemoteException
+
+
+class SlackRemote:
+    """Slack Web API with a bot token, and Events API requests signed as Slack signs them (for smoke tests of a
+    Request URL)."""
+
+    def __init__(self, bot_token: Optional[str] = None) -> None:
+        self.bot_token = bot_token or our_get_env(SLACK_BOT_TOKEN_ENV, raise_if_empty=True)
+
+    def post_message(self, channel: str, text: str, thread_ts: Optional[str] = None) -> dict[str, Any]:
+        """Needs the chat:write bot scope. In Slack's response "channel" is the channel id and "ts" the timestamp of
+        the message (the thread_ts of its replies)."""
+        message: dict[str, Any] = {"channel": channel, "text": text}
+        if thread_ts:
+            message["thread_ts"] = thread_ts
+        return self._call(HTTPMethod.POST, "chat.postMessage", json=message)
+
+    def get_thread_replies(self, channel: str, thread_ts: str) -> list[dict[str, Any]]:
+        """Needs the channels:history (groups:history in a private channel) bot scope. Only the replies, without the
+        message that started the thread."""
+        response_json = self._call(HTTPMethod.GET, "conversations.replies",
+                                   params={"channel": channel, "ts": thread_ts})
+        thread_replies = [message for message in response_json.get("messages", []) if message.get("ts") != thread_ts]
+        return thread_replies
+
+    def wait_for_thread_reply(self, channel: str, thread_ts: str,
+                              timeout_seconds: float = WAIT_FOR_THREAD_REPLY_TIMEOUT_SECONDS,
+                              poll_seconds: float = WAIT_FOR_THREAD_REPLY_POLL_SECONDS,
+                              sleep: Callable[[float], None] = time.sleep) -> Optional[dict[str, Any]]:
+        """The first reply in the thread, or None when no one replied within timeout_seconds."""
+        thread_reply = None
+        waited_seconds = 0.0
+        while thread_reply is None and waited_seconds <= timeout_seconds:
+            thread_replies = self.get_thread_replies(channel, thread_ts)
+            if thread_replies:
+                thread_reply = thread_replies[0]
+            else:
+                sleep(poll_seconds)
+                waited_seconds += poll_seconds
+        return thread_reply
+
+    def get_user_email(self, user_id: str) -> Optional[str]:
+        """Needs the users:read and users:read.email bot scopes."""
+        response_json = self._call(HTTPMethod.GET, "users.info", params={"user": user_id})
+        user_email: Optional[str] = (response_json.get("user") or {}).get("profile", {}).get("email")
+        return user_email
+
+    @staticmethod
+    def send_signed_event(request_url: str, signing_secret: str, event: dict[str, Any],
+                          timestamp: Optional[int] = None) -> requests.Response:
+        """POSTs an Events API event_callback to a Request URL with the signature Slack sends
+        (https://api.slack.com/authentication/verifying-requests-from-slack)."""
+        body = json.dumps({"type": "event_callback", "event": event})
+        request_timestamp = str(timestamp if timestamp is not None else int(time.time()))
+        signature = "v0=" + hmac.new(signing_secret.encode(), f"v0:{request_timestamp}:{body}".encode(),
+                                     hashlib.sha256).hexdigest()
+        response = requests.post(request_url, data=body.encode(), timeout=HTTP_REQUEST_TIMEOUT_SECONDS,
+                                 headers={"Content-Type": "application/json",
+                                          "X-Slack-Request-Timestamp": request_timestamp,
+                                          "X-Slack-Signature": signature})
+        return response
+
+    def _call(self, method: HTTPMethod, api_method: str, **kwargs: Any) -> dict[str, Any]:
+        url = f"{SLACK_API_BASE_URL}/{api_method}"
+        try:
+            response_json: dict[str, Any] = requests.request(
+                method.value, url, headers={"Authorization": f"Bearer {self.bot_token}"},
+                timeout=HTTP_REQUEST_TIMEOUT_SECONDS, **kwargs).json()
+        except (requests.RequestException, ValueError) as exception:
+            raise SlackRemoteException(SLACK_UNAVAILABLE_ERROR_CODE, f"Slack {api_method} failed: {exception}")
+        if not response_json.get("ok"):
+            error_code = response_json.get("error") or "unknown_error"
+            raise SlackRemoteException(error_code, f"Slack {api_method} failed: {error_code}")
+        return response_json

slack_remote/src/slack_remote_exception.py

@@ -0,0 +1,6 @@
+class SlackRemoteException(Exception):
+    """error_code is the error of Slack (i.e. channel_not_found, missing_scope) or slack_unavailable."""
+
+    def __init__(self, error_code: str, message: str) -> None:
+        super().__init__(message)
+        self.error_code = error_code

slack_remote-0.0.1.dist-info/METADATA

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: slack-remote
+Version: 0.0.1
+Summary: PyPI slack-remote Python Package owned by Circlez.ai
+Home-page: https://github.com/circles-zone/slack-remote-python-package
+Author: Circles
+Author-email: info@circlez.ai
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+Requires-Dist: python-sdk-remote
+Requires-Dist: requests
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: summary
+
+Slack Web API and Events API: post a message, read the replies in its thread, send a signed event

slack_remote-0.0.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+slack_remote/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+slack_remote/src/__init__.py,sha256=OYa_3TuQAyyjuGMNMV8gZls3lu7FTcMlI4RW3XtO7nw,146
+slack_remote/src/constants_slack_remote.py,sha256=a_23VF5tthFdZRSdNY9QL42vkbxcagtl55wsB7ljp1k,309
+slack_remote/src/slack_remote.py,sha256=S_KOKohPe8oMUSepPdXPgdmg17cPw0MEAYBYMtJRCOA,4917
+slack_remote/src/slack_remote_exception.py,sha256=fVPOBIrCJ8mQsO-bkvlJQv0EA9ryosf562uv15JMbwA,279
+slack_remote-0.0.1.dist-info/METADATA,sha256=lNOAoV4RoMaA6L_I0K3dfDjkAtO7rmIzXa_zbdV8MYI,698
+slack_remote-0.0.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+slack_remote-0.0.1.dist-info/top_level.txt,sha256=PX9ZX-ucaB89Yrm-wDL-g2zonoUwZfW41sRTM6JN9Bk,13
+slack_remote-0.0.1.dist-info/RECORD,,

slack_remote-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

slack_remote-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+slack_remote