csp-adapter-slack 0.0.0__tar.gz → 0.2.0__tar.gz

csp_adapter_slack-0.2.0/.gitignore

@@ -0,0 +1,152 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+python_junit.xml
+junit.xml
+nosetests.xml
+coverage.xml
+*,cover
+.hypothesis/
+.pytest_cache
+.ruff_cache
+js/playwright-report
+js/test-results
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+
+# Flask instance folder
+instance/
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+docs/source
+
+# PyBuilder
+target/
+
+# IPython Notebook
+.ipynb_checkpoints
+*.ipynb
+.autoversion
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# dotenv
+.env
+
+# virtualenv
+venv/
+ENV/
+
+# Spyder project settings
+.spyderproject
+
+# Rope project settings
+.ropeproject
+
+# =========================
+# Operating System Files
+# =========================
+
+# OSX
+# =========================
+
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+# Windows
+# =========================
+
+# Windows image file caches
+Thumbs.db
+ehthumbs.db
+
+# Folder config file
+Desktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Windows Installer files
+*.cab
+*.msi
+*.msm
+*.msp
+
+# Windows shortcuts
+*.lnk
+
+# Coverage data
+# -------------
+**/coverage/

{csp-adapter-slack-0.0.0 → csp_adapter_slack-0.2.0}/LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2023 Point72, L.P.
+   Copyright 2024 Point72, L..P.
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

{csp-adapter-slack-0.0.0 → csp_adapter_slack-0.2.0}/PKG-INFO

@@ -1,7 +1,9 @@
-Metadata-Version: 2.1
-Name: csp-adapter-slack
-Version: 0.0.0
-Summary: CSP adapter
+Metadata-Version: 2.3
+Name: csp_adapter_slack
+Version: 0.2.0
+Summary: A csp adapter for slack
+Project-URL: Repository, https://github.com/point72/csp-adapter-slack
+Project-URL: Homepage, https://github.com/point72/csp-adapter-slack
 Author-email: the csp authors <CSPOpenSource@point72.com>
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -191,7 +193,7 @@ License:                                  Apache License
               same "printed page" as the copyright notice for easier
               identification within third-party archives.
         
-           Copyright 2023 Point72, L.P.
+           Copyright 2024 Point72, L..P.
         
            Licensed under the Apache License, Version 2.0 (the "License");
            you may not use this file except in compliance with the License.
@@ -204,21 +206,65 @@ License:                                  Apache License
            WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
            See the License for the specific language governing permissions and
            limitations under the License.
-        
-Project-URL: Repository, https://github.com/point72/csp
-Project-URL: Homepage, https://github.com/Point72/csp
-Project-URL: Documentation, https://github.com/Point72/csp/wiki
-Project-URL: Tracker, https://github.com/point72/csp/issues
+Keywords: chat,chatbot,csp,slack,stream-processing
 Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Jupyter
+Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
 Requires-Dist: csp
+Requires-Dist: pydantic>=2
+Requires-Dist: slack-sdk>=3
+Provides-Extra: develop
+Requires-Dist: bump-my-version; extra == 'develop'
+Requires-Dist: check-manifest; extra == 'develop'
+Requires-Dist: codespell<2.4,>=2.2.6; extra == 'develop'
+Requires-Dist: hatchling; extra == 'develop'
+Requires-Dist: mdformat-tables<1.1,>=1; extra == 'develop'
+Requires-Dist: mdformat<0.8,>=0.7.17; extra == 'develop'
+Requires-Dist: pytest; extra == 'develop'
+Requires-Dist: pytest-cov; extra == 'develop'
+Requires-Dist: ruff<0.9,>=0.5; extra == 'develop'
+Requires-Dist: twine<7,>=5; extra == 'develop'
+Provides-Extra: test
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: pytest-cov; extra == 'test'
+Description-Content-Type: text/markdown
+
+# csp slack adapter
+
+A [csp](https://github.com/point72/csp) adapter for [slack](https://slack.com)
+
+[![Build Status](https://github.com/point72/csp-adapter-slack/actions/workflows/build.yml/badge.svg?branch=main)](https://github.com/point72/csp-adapter-slack/actions?query=workflow%3A%22Build+Status%22)
+[![GitHub issues](https://img.shields.io/github/issues/point72/csp-adapter-slack.svg)](https://github.com/point72/csp-adapter-slack/issues)
+[![PyPI](https://img.shields.io/pypi/l/csp-adapter-slack.svg)](https://pypi.python.org/pypi/csp-adapter-slack)
+[![PyPI](https://img.shields.io/pypi/v/csp-adapter-slack.svg)](https://pypi.python.org/pypi/csp-adapter-slack)
+
+## Features
+
+[More information is available in our wiki](https://github.com/Point72/csp-adapter-slack/wiki)
+
+## Installation
+
+Install with `pip`:
+
+```bash
+pip install csp csp-adapter-slack
+```
+
+Install with `conda`
+
+```bash
+conda install csp csp-adapter-slack -c conda-forge
+```
+
+## License
 
-# csp-adapter-slack
+This software is licensed under the Apache 2.0 license. See the [LICENSE](LICENSE) file for details.

csp_adapter_slack-0.2.0/README.md

@@ -0,0 +1,30 @@
+# csp slack adapter
+
+A [csp](https://github.com/point72/csp) adapter for [slack](https://slack.com)
+
+[![Build Status](https://github.com/point72/csp-adapter-slack/actions/workflows/build.yml/badge.svg?branch=main)](https://github.com/point72/csp-adapter-slack/actions?query=workflow%3A%22Build+Status%22)
+[![GitHub issues](https://img.shields.io/github/issues/point72/csp-adapter-slack.svg)](https://github.com/point72/csp-adapter-slack/issues)
+[![PyPI](https://img.shields.io/pypi/l/csp-adapter-slack.svg)](https://pypi.python.org/pypi/csp-adapter-slack)
+[![PyPI](https://img.shields.io/pypi/v/csp-adapter-slack.svg)](https://pypi.python.org/pypi/csp-adapter-slack)
+
+## Features
+
+[More information is available in our wiki](https://github.com/Point72/csp-adapter-slack/wiki)
+
+## Installation
+
+Install with `pip`:
+
+```bash
+pip install csp csp-adapter-slack
+```
+
+Install with `conda`
+
+```bash
+conda install csp csp-adapter-slack -c conda-forge
+```
+
+## License
+
+This software is licensed under the Apache 2.0 license. See the [LICENSE](LICENSE) file for details.

csp_adapter_slack-0.2.0/csp_adapter_slack/__init__.py

@@ -0,0 +1,4 @@
+__version__ = "0.2.0"
+
+from .adapter import *
+from .adapter_config import *

csp_adapter_slack-0.2.0/csp_adapter_slack/adapter.py

@@ -0,0 +1,346 @@
+import threading
+from logging import getLogger
+from queue import Queue
+from threading import Thread
+from time import sleep
+from typing import Dict, List, TypeVar
+
+import csp
+from csp.impl.adaptermanager import AdapterManagerImpl
+from csp.impl.outputadapter import OutputAdapter
+from csp.impl.pushadapter import PushInputAdapter
+from csp.impl.struct import Struct
+from csp.impl.types.tstype import ts
+from csp.impl.wiring import py_output_adapter_def, py_push_adapter_def
+from slack_sdk.errors import SlackApiError
+from slack_sdk.socket_mode import SocketModeClient
+from slack_sdk.socket_mode.request import SocketModeRequest
+from slack_sdk.socket_mode.response import SocketModeResponse
+from slack_sdk.web import WebClient
+
+from .adapter_config import SlackAdapterConfig
+
+T = TypeVar("T")
+log = getLogger(__file__)
+
+
+__all__ = ("SlackMessage", "mention_user", "SlackAdapterManager", "SlackInputAdapterImpl", "SlackOutputAdapterImpl")
+
+
+class SlackMessage(Struct):
+    user: str
+    user_email: str  # email of the author
+    user_id: str  # user id of the author
+    tags: List[str]  # list of mentions
+
+    channel: str  # name of channel
+    channel_id: str  # id of channel
+    channel_type: str  # type of channel, in "message", "public" (app_mention), "private" (app_mention)
+
+    msg: str  # parsed text payload
+    reaction: str  # emoji reacts
+    thread: str  # thread id, if in thread
+    payload: dict  # raw message payload
+
+
+def mention_user(userid: str) -> str:
+    """Convenience method, more difficult to do in symphony but we want slack to be symmetric"""
+    return f"<@{userid}>"
+
+
+class SlackAdapterManager(AdapterManagerImpl):
+    def __init__(self, config: SlackAdapterConfig):
+        self._slack_client = SocketModeClient(
+            app_token=config.app_token,
+            web_client=WebClient(token=config.bot_token, ssl=config.ssl),
+        )
+        self._slack_client.socket_mode_request_listeners.append(self._process_slack_message)
+
+        # down stream edges
+        self._subscribers = []
+        self._publishers = []
+
+        # message queues
+        self._inqueue: Queue[SlackMessage] = Queue()
+        self._outqueue: Queue[SlackMessage] = Queue()
+
+        # handler thread
+        self._running: bool = False
+        self._thread: Thread = None
+
+        # lookups for mentions and redirection
+        self._room_id_to_room_name: Dict[str, str] = {}
+        self._room_id_to_room_type: Dict[str, str] = {}
+        self._room_name_to_room_id: Dict[str, str] = {}
+        self._user_id_to_user_name: Dict[str, str] = {}
+        self._user_id_to_user_email: Dict[str, str] = {}
+        self._user_name_to_user_id: Dict[str, str] = {}
+        self._user_email_to_user_id: Dict[str, str] = {}
+
+    def subscribe(self):
+        return _slack_input_adapter(self, push_mode=csp.PushMode.NON_COLLAPSING)
+
+    def publish(self, msg: ts[SlackMessage]):
+        return _slack_output_adapter(self, msg)
+
+    def _create(self, engine, memo):
+        # We'll avoid having a second class and make our AdapterManager and AdapterManagerImpl the same
+        super().__init__(engine)
+        return self
+
+    def start(self, starttime, endtime):
+        self._running = True
+        self._thread = threading.Thread(target=self._run, daemon=True)
+        self._thread.start()
+
+    def stop(self):
+        if self._running:
+            self._running = False
+            self._slack_client.close()
+            self._thread.join()
+
+    def register_subscriber(self, adapter):
+        if adapter not in self._subscribers:
+            self._subscribers.append(adapter)
+
+    def register_publisher(self, adapter):
+        if adapter not in self._publishers:
+            self._publishers.append(adapter)
+
+    def _get_user_from_id(self, user_id):
+        # try to pull from cache
+        name = self._user_id_to_user_name.get(user_id, None)
+        email = self._user_id_to_user_email.get(user_id, None)
+
+        # if none, refresh data via web client
+        if name is None or email is None:
+            ret = self._slack_client.web_client.users_info(user=user_id)
+            if ret.status_code == 200:
+                # TODO OAuth scopes required
+                name = ret.data["user"]["profile"].get("real_name_normalized", ret.data["user"]["name"])
+                email = ret.data["user"]["profile"].get("email", "")
+                self._user_id_to_user_name[user_id] = name
+                self._user_name_to_user_id[name] = user_id  # TODO is this 1-1 in slack?
+                self._user_id_to_user_email[user_id] = email
+                self._user_email_to_user_id[email] = user_id
+        return name, email
+
+    def _get_user_from_name(self, user_name):
+        # try to pull from cache
+        user_id = self._user_name_to_user_id.get(user_name, None)
+
+        # if none, refresh data via web client
+        if user_id is None:
+            # unfortunately the reverse lookup is not super nice...
+            # we need to pull all users and build the reverse mapping
+            ret = self._slack_client.web_client.users_list()
+            if ret.status_code == 200:
+                # TODO OAuth scopes required
+                for user in ret.data["members"]:
+                    name = user["profile"].get("real_name_normalized", user["name"])
+                    user_id = user["profile"]["id"]
+                    email = user["profile"]["email"]
+                    self._user_id_to_user_name[user_id] = name
+                    self._user_name_to_user_id[name] = user_id  # TODO is this 1-1 in slack?
+                    self._user_id_to_user_email[user_id] = email
+                    self._user_email_to_user_id[email] = user_id
+            return self._user_name_to_user_id.get(user_name, None)
+        return user_id
+
+    def _channel_data_to_channel_kind(self, data) -> str:
+        if data.get("is_im", False):
+            return "message"
+        if data.get("is_private", False):
+            return "private"
+        return "public"
+
+    def _get_channel_from_id(self, channel_id):
+        # try to pull from cache
+        name = self._room_id_to_room_name.get(channel_id, None)
+        kind = self._room_id_to_room_type.get(channel_id, None)
+
+        # if none, refresh data via web client
+        if name is None:
+            ret = self._slack_client.web_client.conversations_info(channel=channel_id)
+            if ret.status_code == 200:
+                # TODO OAuth scopes required
+                kind = self._channel_data_to_channel_kind(ret.data["channel"])
+                if kind == "message":
+                    # TODO use same behavior as symphony adapter
+                    name = "DM"
+                else:
+                    name = ret.data["channel"]["name"]
+
+                self._room_id_to_room_name[channel_id] = name
+                self._room_name_to_room_id[name] = channel_id
+                self._room_id_to_room_type[channel_id] = kind
+        return name, kind
+
+    def _get_channel_from_name(self, channel_name):
+        # try to pull from cache
+        channel_id = self._room_name_to_room_id.get(channel_name, None)
+
+        # if none, refresh data via web client
+        if channel_id is None:
+            # unfortunately the reverse lookup is not super nice...
+            # we need to pull all channels and build the reverse mapping
+            ret = self._slack_client.web_client.conversations_list()
+            if ret.status_code == 200:
+                # TODO OAuth scopes required
+                for channel in ret.data["channels"]:
+                    name = channel["name"]
+                    channel_id = channel["id"]
+                    kind = self._channel_data_to_channel_kind(channel)
+                    self._room_id_to_room_name[channel_id] = name
+                    self._room_name_to_room_id[name] = channel_id
+                    self._room_id_to_room_type[channel_id] = kind
+            return self._room_name_to_room_id.get(channel_name, None)
+        return channel_id
+
+    def _get_tags_from_message(self, blocks) -> List[str]:
+        """extract tags from message, potentially excluding the bot's own @"""
+        tags = []
+        to_search = blocks.copy()
+
+        while to_search:
+            element = to_search.pop()
+            # add subsections
+            if element.get("elements", []):
+                to_search.extend(element.get("elements"))
+
+            if element.get("type", "") == "user":
+                tag_id = element.get("user_id")
+                name, _ = self._get_user_from_id(tag_id)
+                if name:
+                    tags.append(name)
+        return tags
+
+    def _process_slack_message(self, client: SocketModeClient, req: SocketModeRequest):
+        log.info(req.payload)
+        if req.type == "events_api":
+            # Acknowledge the request anyway
+            response = SocketModeResponse(envelope_id=req.envelope_id)
+            client.send_socket_mode_response(response)
+
+            if req.payload["event"]["type"] in ("message", "app_mention") and req.payload["event"].get("subtype") is None:
+                user, user_email = self._get_user_from_id(req.payload["event"]["user"])
+                channel, channel_type = self._get_channel_from_id(req.payload["event"]["channel"])
+                tags = self._get_tags_from_message(req.payload["event"]["blocks"])
+                slack_msg = SlackMessage(
+                    user=user or "",
+                    user_email=user_email or "",
+                    user_id=req.payload["event"]["user"],
+                    tags=tags,
+                    channel=channel or "",
+                    channel_id=req.payload["event"]["channel"],
+                    channel_type=channel_type or "",
+                    msg=req.payload["event"]["text"],
+                    reaction="",
+                    thread=req.payload["event"]["ts"],
+                    payload=req.payload.copy(),
+                )
+                self._inqueue.put(slack_msg)
+
+    def _run(self):
+        self._slack_client.connect()
+
+        while self._running:
+            # drain outbound
+            while not self._outqueue.empty():
+                # pull SlackMessage from queue
+                slack_msg = self._outqueue.get()
+
+                # refactor into slack command
+                # grab channel or DM
+                if hasattr(slack_msg, "channel_id") and slack_msg.channel_id:
+                    channel_id = slack_msg.channel_id
+                elif hasattr(slack_msg, "channel") and slack_msg.channel:
+                    # TODO DM
+                    channel_id = self._get_channel_from_name(slack_msg.channel)
+
+                # pull text or reaction
+                if hasattr(slack_msg, "reaction") and slack_msg.reaction and hasattr(slack_msg, "thread") and slack_msg.thread:
+                    # TODO
+                    self._slack_client.web_client.reactions_add(
+                        channel=channel_id,
+                        name=slack_msg.reaction,
+                        timestamp=slack_msg.thread,
+                    )
+                elif hasattr(slack_msg, "msg") and slack_msg.msg:
+                    try:
+                        # send text to channel
+                        self._slack_client.web_client.chat_postMessage(
+                            channel=channel_id,
+                            text=getattr(slack_msg, "msg", ""),
+                        )
+                    except SlackApiError:
+                        # TODO
+                        ...
+                else:
+                    # cannot send empty message, log an error
+                    log.error(f"Received malformed SlackMessage instance: {slack_msg}")
+
+            if not self._inqueue.empty():
+                # pull all SlackMessages from queue
+                # do as burst to match SymphonyAdapter
+                slack_msgs = []
+                while not self._inqueue.empty():
+                    slack_msgs.append(self._inqueue.get())
+
+                # push to all the subscribers
+                for adapter in self._subscribers:
+                    adapter.push_tick(slack_msgs)
+
+            # do short sleep
+            sleep(0.1)
+
+            # liveness check
+            if not self._thread.is_alive():
+                self._running = False
+                self._thread.join()
+
+        # shut down socket client
+        try:
+            # TODO which one?
+            self._slack_client.close()
+            # self._slack_client.disconnect()
+        except AttributeError:
+            # TODO bug in slack sdk causes an exception to be thrown
+            #   File "slack_sdk/socket_mode/builtin/connection.py", line 191, in disconnect
+            #   self.sock.close()
+            #   ^^^^^^^^^^^^^^^
+            # AttributeError: 'NoneType' object has no attribute 'close'
+            ...
+
+    def _on_tick(self, value):
+        self._outqueue.put(value)
+
+
+class SlackInputAdapterImpl(PushInputAdapter):
+    def __init__(self, manager):
+        manager.register_subscriber(self)
+        super().__init__()
+
+
+class SlackOutputAdapterImpl(OutputAdapter):
+    def __init__(self, manager):
+        manager.register_publisher(self)
+        self._manager = manager
+        super().__init__()
+
+    def on_tick(self, time, value):
+        self._manager._on_tick(value)
+
+
+_slack_input_adapter = py_push_adapter_def(
+    name="SlackInputAdapter",
+    adapterimpl=SlackInputAdapterImpl,
+    out_type=ts[[SlackMessage]],
+    manager_type=SlackAdapterManager,
+)
+_slack_output_adapter = py_output_adapter_def(
+    name="SlackOutputAdapter",
+    adapterimpl=SlackOutputAdapterImpl,
+    manager_type=SlackAdapterManager,
+    input=ts[SlackMessage],
+)

csp_adapter_slack-0.2.0/csp_adapter_slack/adapter_config.py

@@ -0,0 +1,37 @@
+from pathlib import Path
+from ssl import SSLContext
+from typing import Optional
+
+from pydantic import BaseModel, Field, field_validator
+
+__all__ = ("SlackAdapterConfig",)
+
+
+class SlackAdapterConfig(BaseModel):
+    """A config class that holds the required information to interact with Slack."""
+
+    app_token: str = Field(description="The app token for the Slack bot")
+    bot_token: str = Field(description="The bot token for the Slack bot")
+    ssl: Optional[object] = None
+
+    @field_validator("app_token")
+    def validate_app_token(cls, v):
+        if v.startswith("xapp-"):
+            return v
+        elif Path(v).exists():
+            return Path(v).read_text().strip()
+        raise ValueError("App token must start with 'xoxb-' or be a file path")
+
+    @field_validator("bot_token")
+    def validate_bot_token(cls, v):
+        if v.startswith("xoxb-"):
+            return v
+        elif Path(v).exists():
+            return Path(v).read_text().strip()
+        raise ValueError("Bot token must start with 'xoxb-' or be a file path")
+
+    @field_validator("ssl")
+    def validate_ssl(cls, v):
+        # TODO pydantic validation via schema
+        assert v is None or isinstance(v, SSLContext)
+        return v

csp_adapter_slack-0.2.0/csp_adapter_slack/tests/test_adapter.py

@@ -0,0 +1,213 @@
+from datetime import timedelta
+from ssl import create_default_context
+from unittest.mock import MagicMock, call, patch
+
+import csp
+import pytest
+from csp import ts
+from pydantic import ValidationError
+
+from csp_adapter_slack import SlackAdapterConfig, SlackAdapterManager, SlackMessage, mention_user
+
+
+@csp.node
+def hello(msg: ts[SlackMessage]) -> ts[SlackMessage]:
+    if csp.ticked(msg):
+        text = f"Hello <@{msg.user_id}>!"
+        return SlackMessage(
+            channel="a new channel",
+            # reply in thread
+            thread=msg.thread,
+            msg=text,
+        )
+
+
+@csp.node
+def react(msg: ts[SlackMessage]) -> ts[SlackMessage]:
+    if csp.ticked(msg):
+        return SlackMessage(
+            channel=msg.channel,
+            channel_id=msg.channel_id,
+            thread=msg.thread,
+            reaction="eyes",
+        )
+
+
+@csp.node
+def send_fake_message(clientmock: MagicMock, requestmock: MagicMock, am: SlackAdapterManager) -> ts[bool]:
+    with csp.alarms():
+        a_send = csp.alarm(bool)
+    with csp.start():
+        csp.schedule_alarm(a_send, timedelta(seconds=1), True)
+    if csp.ticked(a_send):
+        if a_send:
+            am._process_slack_message(clientmock, requestmock)
+            csp.schedule_alarm(a_send, timedelta(seconds=1), False)
+        else:
+            return True
+
+
+PUBLIC_CHANNEL_MENTION_PAYLOAD = {
+    "token": "ABCD",
+    "team_id": "EFGH",
+    "api_app_id": "HIJK",
+    "event": {
+        "client_msg_id": "1234-5678",
+        "type": "app_mention",
+        "text": "<@BOTID> <@USERID> <@USERID2>",
+        "user": "USERID",
+        "ts": "1.2",
+        "blocks": [
+            {
+                "type": "rich_text",
+                "block_id": "tx381",
+                "elements": [
+                    {
+                        "type": "rich_text_section",
+                        "elements": [
+                            {"type": "user", "user_id": "BOTID"},
+                            {"type": "text", "text": " "},
+                            {"type": "user", "user_id": "USERID"},
+                            {"type": "text", "text": " "},
+                            {"type": "user", "user_id": "USERID2"},
+                        ],
+                    }
+                ],
+            }
+        ],
+        "team": "ABCD",
+        "channel": "EFGH",
+        "event_ts": "1.2",
+    },
+    "type": "event_callback",
+    "event_id": "ABCD",
+    "event_time": 1707423091,
+    "authorizations": [{"enterprise_id": None, "team_id": "ABCD", "user_id": "BOTID", "is_bot": True, "is_enterprise_install": False}],
+    "is_ext_shared_channel": False,
+    "event_context": "SOMELONGCONTEXT",
+}
+DIRECT_MESSAGE_PAYLOAD = {
+    "token": "ABCD",
+    "team_id": "EFGH",
+    "context_team_id": "ABCD",
+    "context_enterprise_id": None,
+    "api_app_id": "HIJK",
+    "event": {
+        "client_msg_id": "1234-5678",
+        "type": "message",
+        "text": "test",
+        "user": "USERID",
+        "ts": "2.1",
+        "blocks": [
+            {
+                "type": "rich_text",
+                "block_id": "gB9fq",
+                "elements": [{"type": "rich_text_section", "elements": [{"type": "text", "text": "test"}]}],
+            }
+        ],
+        "team": "ABCD",
+        "channel": "EFGH",
+        "event_ts": "2.1",
+        "channel_type": "im",
+    },
+    "type": "event_callback",
+    "event_id": "ABCD",
+    "event_time": 1707423220,
+    "authorizations": [{"enterprise_id": None, "team_id": "ABCD", "user_id": "BOTID", "is_bot": True, "is_enterprise_install": False}],
+    "is_ext_shared_channel": False,
+    "event_context": "SOMELONGCONTEXT",
+}
+
+
+class TestSlack:
+    def test_slack_tokens(self):
+        with pytest.raises(ValidationError):
+            SlackAdapterConfig(app_token="abc", bot_token="xoxb-def")
+        with pytest.raises(ValidationError):
+            SlackAdapterConfig(app_token="xapp-abc", bot_token="def")
+
+    @pytest.mark.parametrize("payload", (PUBLIC_CHANNEL_MENTION_PAYLOAD, DIRECT_MESSAGE_PAYLOAD))
+    def test_slack(self, payload):
+        with patch("csp_adapter_slack.adapter.SocketModeClient") as clientmock:
+            # mock out the event from the slack sdk
+            reqmock = MagicMock()
+            reqmock.type = "events_api"
+            reqmock.payload = payload
+
+            # mock out the user/room lookup responses
+            mock_user_response = MagicMock(name="users_info_mock")
+            mock_user_response.status_code = 200
+            mock_user_response.data = {"user": {"profile": {"real_name_normalized": "johndoe", "email": "johndoe@some.email"}, "name": "blerg"}}
+            clientmock.return_value.web_client.users_info.return_value = mock_user_response
+            mock_room_response = MagicMock(name="conversations_info_mock")
+            mock_room_response.status_code = 200
+            mock_room_response.data = {"channel": {"is_im": False, "is_private": True, "name": "a private channel"}}
+            clientmock.return_value.web_client.conversations_info.return_value = mock_room_response
+            mock_list_response = MagicMock(name="conversations_list_mock")
+            mock_list_response.status_code = 200
+            mock_list_response.data = {
+                "channels": [
+                    {"name": "a private channel", "id": "EFGH"},
+                    {"name": "a new channel", "id": "new_channel"},
+                ]
+            }
+            clientmock.return_value.web_client.conversations_list.return_value = mock_list_response
+
+            def graph():
+                am = SlackAdapterManager(SlackAdapterConfig(app_token="xapp-1-dummy", bot_token="xoxb-dummy", ssl=create_default_context()))
+
+                # send a fake slack message to the app
+                stop = send_fake_message(clientmock, reqmock, am)
+
+                # send a response
+                resp = hello(csp.unroll(am.subscribe()))
+                am.publish(resp)
+
+                # do a react
+                rct = react(csp.unroll(am.subscribe()))
+                am.publish(rct)
+
+                csp.add_graph_output("response", resp)
+                csp.add_graph_output("react", rct)
+
+                # stop after first messages
+                done_flag = (csp.count(stop) + csp.count(resp) + csp.count(rct)) == 3
+                csp.stop_engine(done_flag)
+
+            # run the graph
+            resp = csp.run(graph, realtime=True)
+
+            # check outputs
+            if payload == PUBLIC_CHANNEL_MENTION_PAYLOAD:
+                assert resp["react"]
+                assert resp["response"]
+
+                assert resp["react"][0][1] == SlackMessage(channel="a private channel", channel_id="EFGH", reaction="eyes", thread="1.2")
+                assert resp["response"][0][1] == SlackMessage(channel="a new channel", msg="Hello <@USERID>!", thread="1.2")
+            else:
+                assert resp["react"]
+                assert resp["response"]
+
+                assert resp["react"][0][1] == SlackMessage(channel="a private channel", channel_id="EFGH", reaction="eyes", thread="2.1")
+                assert resp["response"][0][1] == SlackMessage(channel="a new channel", msg="Hello <@USERID>!", thread="2.1")
+
+            # check all inbound mocks got called
+            if payload == PUBLIC_CHANNEL_MENTION_PAYLOAD:
+                assert clientmock.return_value.web_client.users_info.call_count == 2
+            else:
+                assert clientmock.return_value.web_client.users_info.call_count == 1
+            assert clientmock.return_value.web_client.conversations_info.call_count == 1
+
+            # check all outbound mocks got called
+            assert clientmock.return_value.web_client.reactions_add.call_count == 1
+            assert clientmock.return_value.web_client.chat_postMessage.call_count == 1
+
+            if payload == PUBLIC_CHANNEL_MENTION_PAYLOAD:
+                assert clientmock.return_value.web_client.reactions_add.call_args_list == [call(channel="EFGH", name="eyes", timestamp="1.2")]
+                assert clientmock.return_value.web_client.chat_postMessage.call_args_list == [call(channel="new_channel", text="Hello <@USERID>!")]
+            else:
+                assert clientmock.return_value.web_client.reactions_add.call_args_list == [call(channel="EFGH", name="eyes", timestamp="2.1")]
+                assert clientmock.return_value.web_client.chat_postMessage.call_args_list == [call(channel="new_channel", text="Hello <@USERID>!")]
+
+    def test_mention_user(self):
+        assert mention_user("ABCD") == "<@ABCD>"

csp_adapter_slack-0.2.0/pyproject.toml

@@ -0,0 +1,144 @@
+[build-system]
+requires = [
+    "hatchling>=1.22.4,<1.27",
+    "pkginfo>=1.10,<1.12",
+]
+build-backend = "hatchling.build"
+
+[project]
+name = "csp_adapter_slack"
+description = "A csp adapter for slack"
+version = "0.2.0"
+readme = "README.md"
+license = { file = "LICENSE" }
+requires-python = ">=3.8"
+authors = [{name = "the csp authors", email = "CSPOpenSource@point72.com"}]
+keywords = [
+    "csp",
+    "stream-processing",
+    "slack",
+    "chat",
+    "chatbot",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Framework :: Jupyter",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "License :: OSI Approved :: Apache Software License",
+]
+dependencies = [
+    "csp",
+    "pydantic>=2",
+    "slack-sdk>=3",
+]
+
+[project.optional-dependencies]
+develop = [
+    "bump-my-version",
+    "check-manifest",
+    "codespell>=2.2.6,<2.4",
+    "hatchling",
+    "mdformat>=0.7.17,<0.8",
+    "mdformat-tables>=1,<1.1",
+    "ruff>=0.5,<0.9",
+    "twine>=5,<7",
+    # test
+    "pytest",
+    "pytest-cov",
+]
+test = [
+    "pytest",
+    "pytest-cov",
+]
+
+[project.urls]
+Repository = "https://github.com/point72/csp-adapter-slack"
+Homepage = "https://github.com/point72/csp-adapter-slack"
+
+[tool.bumpversion]
+current_version = "0.2.0"
+commit = true
+tag = false
+commit_args = "-s"
+
+[[tool.bumpversion.files]]
+filename = "csp_adapter_slack/__init__.py"
+search = '__version__ = "{current_version}"'
+replace = '__version__ = "{new_version}"'
+
+[[tool.bumpversion.files]]
+filename = "pyproject.toml"
+search = 'version = "{current_version}"'
+replace = 'version = "{new_version}"'
+
+[tool.check-manifest]
+ignore = []
+
+[tool.coverage.run]
+branch = true
+omit = []
+
+[tool.coverage.report]
+exclude_also = [
+    "raise NotImplementedError",
+    "if __name__ == .__main__.:",
+    "@(abc\\.)?abstractmethod",
+]
+ignore_errors = true
+fail_under = 75
+
+[tool.hatch.build]
+artifacts = []
+
+[tool.hatch.build.sources]
+src = "/"
+
+[tool.hatch.build.targets.sdist]
+packages = ["csp_adapter_slack"]
+exclude = [
+    "/.github",
+    "/.gitignore",
+    "/docs",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["csp_adapter_slack"]
+exclude = [
+    "/.github",
+    "/.gitignore",
+    "/pyproject.toml",
+    "/docs",
+]
+
+[tool.pytest.ini_options]
+addopts = ["-vvv", "--junitxml=junit.xml"]
+asyncio_mode = "strict"
+testpaths = "csp_adapter_slack/tests"
+
+[tool.ruff]
+line-length = 150
+
+[tool.ruff.lint]
+extend-select = ["I"]
+
+[tool.ruff.lint.per-file-ignores]
+"__init__.py" = ["F401", "F403"]
+
+[tool.ruff.lint.isort]
+combine-as-imports = true
+default-section = "third-party"
+known-first-party = ["csp_adapter_slack"]
+section-order = [
+    "future",
+    "standard-library",
+    "third-party",
+    "first-party",
+    "local-folder",
+]

csp-adapter-slack-0.0.0/README.md

@@ -1 +0,0 @@
-# csp-adapter-slack

csp-adapter-slack-0.0.0/csp_adapter_slack.egg-info/PKG-INFO

@@ -1,224 +0,0 @@
-Metadata-Version: 2.1
-Name: csp-adapter-slack
-Version: 0.0.0
-Summary: CSP adapter
-Author-email: the csp authors <CSPOpenSource@point72.com>
-License:                                  Apache License
-                                   Version 2.0, January 2004
-                                http://www.apache.org/licenses/
-        
-           TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-        
-           1. Definitions.
-        
-              "License" shall mean the terms and conditions for use, reproduction,
-              and distribution as defined by Sections 1 through 9 of this document.
-        
-              "Licensor" shall mean the copyright owner or entity authorized by
-              the copyright owner that is granting the License.
-        
-              "Legal Entity" shall mean the union of the acting entity and all
-              other entities that control, are controlled by, or are under common
-              control with that entity. For the purposes of this definition,
-              "control" means (i) the power, direct or indirect, to cause the
-              direction or management of such entity, whether by contract or
-              otherwise, or (ii) ownership of fifty percent (50%) or more of the
-              outstanding shares, or (iii) beneficial ownership of such entity.
-        
-              "You" (or "Your") shall mean an individual or Legal Entity
-              exercising permissions granted by this License.
-        
-              "Source" form shall mean the preferred form for making modifications,
-              including but not limited to software source code, documentation
-              source, and configuration files.
-        
-              "Object" form shall mean any form resulting from mechanical
-              transformation or translation of a Source form, including but
-              not limited to compiled object code, generated documentation,
-              and conversions to other media types.
-        
-              "Work" shall mean the work of authorship, whether in Source or
-              Object form, made available under the License, as indicated by a
-              copyright notice that is included in or attached to the work
-              (an example is provided in the Appendix below).
-        
-              "Derivative Works" shall mean any work, whether in Source or Object
-              form, that is based on (or derived from) the Work and for which the
-              editorial revisions, annotations, elaborations, or other modifications
-              represent, as a whole, an original work of authorship. For the purposes
-              of this License, Derivative Works shall not include works that remain
-              separable from, or merely link (or bind by name) to the interfaces of,
-              the Work and Derivative Works thereof.
-        
-              "Contribution" shall mean any work of authorship, including
-              the original version of the Work and any modifications or additions
-              to that Work or Derivative Works thereof, that is intentionally
-              submitted to Licensor for inclusion in the Work by the copyright owner
-              or by an individual or Legal Entity authorized to submit on behalf of
-              the copyright owner. For the purposes of this definition, "submitted"
-              means any form of electronic, verbal, or written communication sent
-              to the Licensor or its representatives, including but not limited to
-              communication on electronic mailing lists, source code control systems,
-              and issue tracking systems that are managed by, or on behalf of, the
-              Licensor for the purpose of discussing and improving the Work, but
-              excluding communication that is conspicuously marked or otherwise
-              designated in writing by the copyright owner as "Not a Contribution."
-        
-              "Contributor" shall mean Licensor and any individual or Legal Entity
-              on behalf of whom a Contribution has been received by Licensor and
-              subsequently incorporated within the Work.
-        
-           2. Grant of Copyright License. Subject to the terms and conditions of
-              this License, each Contributor hereby grants to You a perpetual,
-              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-              copyright license to reproduce, prepare Derivative Works of,
-              publicly display, publicly perform, sublicense, and distribute the
-              Work and such Derivative Works in Source or Object form.
-        
-           3. Grant of Patent License. Subject to the terms and conditions of
-              this License, each Contributor hereby grants to You a perpetual,
-              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-              (except as stated in this section) patent license to make, have made,
-              use, offer to sell, sell, import, and otherwise transfer the Work,
-              where such license applies only to those patent claims licensable
-              by such Contributor that are necessarily infringed by their
-              Contribution(s) alone or by combination of their Contribution(s)
-              with the Work to which such Contribution(s) was submitted. If You
-              institute patent litigation against any entity (including a
-              cross-claim or counterclaim in a lawsuit) alleging that the Work
-              or a Contribution incorporated within the Work constitutes direct
-              or contributory patent infringement, then any patent licenses
-              granted to You under this License for that Work shall terminate
-              as of the date such litigation is filed.
-        
-           4. Redistribution. You may reproduce and distribute copies of the
-              Work or Derivative Works thereof in any medium, with or without
-              modifications, and in Source or Object form, provided that You
-              meet the following conditions:
-        
-              (a) You must give any other recipients of the Work or
-                  Derivative Works a copy of this License; and
-        
-              (b) You must cause any modified files to carry prominent notices
-                  stating that You changed the files; and
-        
-              (c) You must retain, in the Source form of any Derivative Works
-                  that You distribute, all copyright, patent, trademark, and
-                  attribution notices from the Source form of the Work,
-                  excluding those notices that do not pertain to any part of
-                  the Derivative Works; and
-        
-              (d) If the Work includes a "NOTICE" text file as part of its
-                  distribution, then any Derivative Works that You distribute must
-                  include a readable copy of the attribution notices contained
-                  within such NOTICE file, excluding those notices that do not
-                  pertain to any part of the Derivative Works, in at least one
-                  of the following places: within a NOTICE text file distributed
-                  as part of the Derivative Works; within the Source form or
-                  documentation, if provided along with the Derivative Works; or,
-                  within a display generated by the Derivative Works, if and
-                  wherever such third-party notices normally appear. The contents
-                  of the NOTICE file are for informational purposes only and
-                  do not modify the License. You may add Your own attribution
-                  notices within Derivative Works that You distribute, alongside
-                  or as an addendum to the NOTICE text from the Work, provided
-                  that such additional attribution notices cannot be construed
-                  as modifying the License.
-        
-              You may add Your own copyright statement to Your modifications and
-              may provide additional or different license terms and conditions
-              for use, reproduction, or distribution of Your modifications, or
-              for any such Derivative Works as a whole, provided Your use,
-              reproduction, and distribution of the Work otherwise complies with
-              the conditions stated in this License.
-        
-           5. Submission of Contributions. Unless You explicitly state otherwise,
-              any Contribution intentionally submitted for inclusion in the Work
-              by You to the Licensor shall be under the terms and conditions of
-              this License, without any additional terms or conditions.
-              Notwithstanding the above, nothing herein shall supersede or modify
-              the terms of any separate license agreement you may have executed
-              with Licensor regarding such Contributions.
-        
-           6. Trademarks. This License does not grant permission to use the trade
-              names, trademarks, service marks, or product names of the Licensor,
-              except as required for reasonable and customary use in describing the
-              origin of the Work and reproducing the content of the NOTICE file.
-        
-           7. Disclaimer of Warranty. Unless required by applicable law or
-              agreed to in writing, Licensor provides the Work (and each
-              Contributor provides its Contributions) on an "AS IS" BASIS,
-              WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-              implied, including, without limitation, any warranties or conditions
-              of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-              PARTICULAR PURPOSE. You are solely responsible for determining the
-              appropriateness of using or redistributing the Work and assume any
-              risks associated with Your exercise of permissions under this License.
-        
-           8. Limitation of Liability. In no event and under no legal theory,
-              whether in tort (including negligence), contract, or otherwise,
-              unless required by applicable law (such as deliberate and grossly
-              negligent acts) or agreed to in writing, shall any Contributor be
-              liable to You for damages, including any direct, indirect, special,
-              incidental, or consequential damages of any character arising as a
-              result of this License or out of the use or inability to use the
-              Work (including but not limited to damages for loss of goodwill,
-              work stoppage, computer failure or malfunction, or any and all
-              other commercial damages or losses), even if such Contributor
-              has been advised of the possibility of such damages.
-        
-           9. Accepting Warranty or Additional Liability. While redistributing
-              the Work or Derivative Works thereof, You may choose to offer,
-              and charge a fee for, acceptance of support, warranty, indemnity,
-              or other liability obligations and/or rights consistent with this
-              License. However, in accepting such obligations, You may act only
-              on Your own behalf and on Your sole responsibility, not on behalf
-              of any other Contributor, and only if You agree to indemnify,
-              defend, and hold each Contributor harmless for any liability
-              incurred by, or claims asserted against, such Contributor by reason
-              of your accepting any such warranty or additional liability.
-        
-           END OF TERMS AND CONDITIONS
-        
-           APPENDIX: How to apply the Apache License to your work.
-        
-              To apply the Apache License to your work, attach the following
-              boilerplate notice, with the fields enclosed by brackets "[]"
-              replaced with your own identifying information. (Don't include
-              the brackets!)  The text should be enclosed in the appropriate
-              comment syntax for the file format. We also recommend that a
-              file or class name and description of purpose be included on the
-              same "printed page" as the copyright notice for easier
-              identification within third-party archives.
-        
-           Copyright 2023 Point72, L.P.
-        
-           Licensed under the Apache License, Version 2.0 (the "License");
-           you may not use this file except in compliance with the License.
-           You may obtain a copy of the License at
-        
-               http://www.apache.org/licenses/LICENSE-2.0
-        
-           Unless required by applicable law or agreed to in writing, software
-           distributed under the License is distributed on an "AS IS" BASIS,
-           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-           See the License for the specific language governing permissions and
-           limitations under the License.
-        
-Project-URL: Repository, https://github.com/point72/csp
-Project-URL: Homepage, https://github.com/Point72/csp
-Project-URL: Documentation, https://github.com/Point72/csp/wiki
-Project-URL: Tracker, https://github.com/point72/csp/issues
-Classifier: Development Status :: 4 - Beta
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: csp
-
-# csp-adapter-slack

csp-adapter-slack-0.0.0/csp_adapter_slack.egg-info/SOURCES.txt

@@ -1,9 +0,0 @@
-LICENSE
-README.md
-pyproject.toml
-setup.py
-csp_adapter_slack.egg-info/PKG-INFO
-csp_adapter_slack.egg-info/SOURCES.txt
-csp_adapter_slack.egg-info/dependency_links.txt
-csp_adapter_slack.egg-info/requires.txt
-csp_adapter_slack.egg-info/top_level.txt

csp-adapter-slack-0.0.0/csp_adapter_slack.egg-info/dependency_links.txt

@@ -1 +0,0 @@
-

csp-adapter-slack-0.0.0/csp_adapter_slack.egg-info/requires.txt

@@ -1 +0,0 @@
-csp

csp-adapter-slack-0.0.0/csp_adapter_slack.egg-info/top_level.txt

@@ -1 +0,0 @@
-

csp-adapter-slack-0.0.0/pyproject.toml

@@ -1,30 +0,0 @@
-[build-system]
-requires = ["setuptools", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "csp-adapter-slack"
-description = "CSP adapter"
-version = "0.0.0"
-readme = "README.md"
-license = { file = "LICENSE" }
-requires-python = ">=3.8"
-authors = [{name = "the csp authors", email = "CSPOpenSource@point72.com"}]
-classifiers = [
-    "Development Status :: 4 - Beta",
-    "Programming Language :: Python",
-    "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.8",
-    "Programming Language :: Python :: 3.9",
-    "Programming Language :: Python :: 3.10",
-    "Programming Language :: Python :: 3.11",
-]
-dependencies = [
-    "csp",
-]
-
-[project.urls]
-Repository = "https://github.com/point72/csp"
-Homepage = "https://github.com/Point72/csp"
-Documentation = "https://github.com/Point72/csp/wiki"
-Tracker = "https://github.com/point72/csp/issues"

csp-adapter-slack-0.0.0/setup.cfg

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

csp-adapter-slack-0.0.0/setup.py

@@ -1,2 +0,0 @@
-# setup.py shim for use with applications that require it.
-__import__("setuptools").setup()