slack-remote 0.0.1__tar.gz

slack_remote-0.0.1/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,34 @@
+# slack-remote-python-package
+
+PyPI [slack-remote](https://pypi.org/project/slack-remote/): the Slack Web API with a bot token, and Events API
+requests signed as Slack signs them - for packages that talk to Slack and for the Sanity/Smoke Tests of our Slack
+apps (i.e. the play1 Slack webhook in `#request-to-open-a-jira-work-item-play1`, never in a channel of real users).
+
+```python
+from slack_remote.src import SlackRemote
+
+slack_remote = SlackRemote()  # SLACK_BOT_TOKEN
+message = slack_remote.post_message(channel_id, "Summary: ...")
+thread_reply = slack_remote.wait_for_thread_reply(channel_id, message["ts"])
+
+# Smoke test of a Request URL: the event Slack would send for a message, signed with the app's Signing Secret
+response = SlackRemote.send_signed_event(request_url, signing_secret, {"type": "message", "channel": channel_id,
+                                                                        "user": user_id, "text": "...", "ts": ts})
+```
+
+| Method | Bot scopes |
+|---|---|
+| `post_message` | chat:write |
+| `get_thread_replies`, `wait_for_thread_reply` | channels:history (groups:history in a private channel) |
+| `get_user_email` | users:read, users:read.email |
+
+## Environment variables
+- `SLACK_BOT_TOKEN` (or `SlackRemote(bot_token=...)`)
+- System tests: also `SLACK_TEST_CHANNEL_ID` of a test channel the bot is a member of; without them they are skipped.
+
+## Tests
+```shell
+cd slack-remote-python-package
+pip install -r requirements.txt -r requirements-dev.txt
+pytest
+```

slack_remote-0.0.1/pyproject.toml

@@ -0,0 +1,12 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.poetry]
+name = "slack-remote"
+version = "0.0.1" # https://pypi.org/project/slack-remote
+description = "slack-remote Python Package"
+readme = "README.md"
+authors = [
+    "Circlez.ai <info@circlez.ai>",
+]

slack_remote-0.0.1/python_packages/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-0.0.1/python_packages/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-0.0.1/python_packages/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-0.0.1/python_packages/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/python_packages/slack_remote.egg-info/PKG-INFO

@@ -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/python_packages/slack_remote.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+setup.py
+python_packages/slack_remote/__init__.py
+python_packages/slack_remote.egg-info/PKG-INFO
+python_packages/slack_remote.egg-info/SOURCES.txt
+python_packages/slack_remote.egg-info/dependency_links.txt
+python_packages/slack_remote.egg-info/requires.txt
+python_packages/slack_remote.egg-info/top_level.txt
+python_packages/slack_remote/src/__init__.py
+python_packages/slack_remote/src/constants_slack_remote.py
+python_packages/slack_remote/src/slack_remote.py
+python_packages/slack_remote/src/slack_remote_exception.py

slack_remote-0.0.1/python_packages/slack_remote.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

slack_remote-0.0.1/python_packages/slack_remote.egg-info/requires.txt

@@ -0,0 +1,2 @@
+python-sdk-remote
+requests

slack_remote-0.0.1/python_packages/slack_remote.egg-info/top_level.txt

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

slack_remote-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

slack_remote-0.0.1/setup.py

@@ -0,0 +1,24 @@
+import setuptools
+
+PACKAGE_NAME = "slack-remote"
+
+setuptools.setup(
+    name=PACKAGE_NAME,
+    version='0.0.1',  # https://pypi.org/project/slack-remote#history
+    author="Circles",
+    author_email="info@circlez.ai",
+    description=f"PyPI {PACKAGE_NAME} Python Package owned by Circlez.ai",
+    long_description="Slack Web API and Events API: post a message, read the replies in its thread, send a signed event",
+    long_description_content_type='text/markdown',
+    url=f"https://github.com/circles-zone/{PACKAGE_NAME}-python-package",
+    packages=setuptools.find_packages(where="python_packages", exclude=["*.tests", "*.tests.*"]),
+    package_dir={"": "python_packages"},
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "Operating System :: OS Independent",
+    ],
+    install_requires=[
+        'python-sdk-remote',
+        'requests',
+    ]
+)