csp-adapter-slack 0.1.0__tar.gz → 0.3.0__tar.gz

{csp_adapter_slack-0.1.0 → csp_adapter_slack-0.3.0}/.gitignore

@@ -150,3 +150,7 @@ $RECYCLE.BIN/
 # Coverage data
 # -------------
 **/coverage/
+
+# Secrets
+.app_token
+.bot_token

{csp_adapter_slack-0.1.0 → csp_adapter_slack-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: csp_adapter_slack
-Version: 0.1.0
+Version: 0.3.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
@@ -213,24 +213,26 @@ 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
-Requires-Python: >=3.8
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.9
 Requires-Dist: csp
+Requires-Dist: pydantic>=2
 Requires-Dist: slack-sdk>=3
 Provides-Extra: develop
-Requires-Dist: bump2version>=1.0.0; extra == 'develop'
+Requires-Dist: bump-my-version; extra == 'develop'
 Requires-Dist: check-manifest; extra == 'develop'
-Requires-Dist: codespell<2.3,>=2.2.6; extra == 'develop'
+Requires-Dist: codespell<2.5,>=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.6,>=0.5; extra == 'develop'
-Requires-Dist: twine<5.2,>=5; extra == 'develop'
+Requires-Dist: ruff<0.12,>=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'
@@ -247,8 +249,14 @@ A [csp](https://github.com/point72/csp) adapter for [slack](https://slack.com)
 
 ## Features
 
+The Slack adapter allows for reading and writing of messages from the [Slack](https://slack.com/) message platform using the [`slack-sdk`](https://tools.slack.dev/python-slack-sdk/).
+
 [More information is available in our wiki](https://github.com/Point72/csp-adapter-slack/wiki)
 
+## Chat Framework
+
+[`csp-bot`](https://github.com/Point72/csp-bot) is a framework for writing cross-platform, command oriented chat bots.
+
 ## Installation
 
 Install with `pip`:
@@ -265,4 +273,4 @@ 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.
+This software is licensed under the Apache 2.0 license. See the [LICENSE](https://github.com/Point72/csp-adapter-slack/blob/main/LICENSE) file for details.

{csp_adapter_slack-0.1.0 → csp_adapter_slack-0.3.0}/README.md

@@ -9,8 +9,14 @@ A [csp](https://github.com/point72/csp) adapter for [slack](https://slack.com)
 
 ## Features
 
+The Slack adapter allows for reading and writing of messages from the [Slack](https://slack.com/) message platform using the [`slack-sdk`](https://tools.slack.dev/python-slack-sdk/).
+
 [More information is available in our wiki](https://github.com/Point72/csp-adapter-slack/wiki)
 
+## Chat Framework
+
+[`csp-bot`](https://github.com/Point72/csp-bot) is a framework for writing cross-platform, command oriented chat bots.
+
 ## Installation
 
 Install with `pip`:
@@ -27,4 +33,4 @@ 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.
+This software is licensed under the Apache 2.0 license. See the [LICENSE](https://github.com/Point72/csp-adapter-slack/blob/main/LICENSE) file for details.

csp_adapter_slack-0.3.0/csp_adapter_slack/__init__.py

@@ -0,0 +1,6 @@
+__version__ = "0.3.0"
+
+from .adapter import *
+from .adapter_config import *
+from .mention import *
+from .message import *

{csp_adapter_slack-0.1.0 → csp_adapter_slack-0.3.0}/csp_adapter_slack/adapter.py

@@ -1,61 +1,37 @@
 import threading
 from logging import getLogger
 from queue import Queue
-from ssl import SSLContext
 from threading import Thread
 from time import sleep
-from typing import Dict, List, Optional, TypeVar
+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
+from .message import SlackMessage
+
 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}>"
+__all__ = ("SlackAdapterManager", "SlackInputAdapterImpl", "SlackOutputAdapterImpl")
 
 
 class SlackAdapterManager(AdapterManagerImpl):
-    def __init__(self, app_token: str, bot_token: str, ssl: Optional[SSLContext] = None):
-        if not app_token.startswith("xapp-") or not bot_token.startswith("xoxb-"):
-            raise RuntimeError("Slack app token or bot token looks malformed")
-
+    def __init__(self, config: SlackAdapterConfig):
         self._slack_client = SocketModeClient(
-            app_token=app_token,
-            web_client=WebClient(token=bot_token, ssl=ssl),
+            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)
 
@@ -72,14 +48,18 @@ class SlackAdapterManager(AdapterManagerImpl):
         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._channel_id_to_channel_name: Dict[str, str] = {}
+        self._channel_id_to_channel_type: Dict[str, str] = {}
+        self._channel_name_to_channel_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] = {}
 
+        # if subscribed to mentions AND events, will get 2 copies,
+        # so we want to dedupe by id
+        self._seen_msg_ids = set()
+
     def subscribe(self):
         return _slack_input_adapter(self, push_mode=csp.PushMode.NON_COLLAPSING)
 
@@ -121,7 +101,7 @@ class SlackAdapterManager(AdapterManagerImpl):
             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"]["email"]
+                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
@@ -140,14 +120,33 @@ class SlackAdapterManager(AdapterManagerImpl):
             if ret.status_code == 200:
                 # TODO OAuth scopes required
                 for user in ret.data["members"]:
+                    # Grab name
                     name = user["profile"].get("real_name_normalized", user["name"])
-                    user_id = user["profile"]["id"]
-                    email = user["profile"]["email"]
+
+                    # Try to grab id
+                    if "id" in user:
+                        user_id = user["id"]
+                    elif "id" in user["profile"]:
+                        user_id = user["profile"]["id"]
+                    else:
+                        raise RuntimeError(f"No id found in user profile: {user}")
+
+                    # Try to grab email
+                    if "email" in user["profile"]:
+                        email = user["profile"]["email"]
+                    else:
+                        log.warning(f"No email found in user profile, using id: {user}")
+                        email = user_id
+
                     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)
+
+            user_id = self._user_name_to_user_id.get(user_name, None)
+            if user_id is None:
+                # no user found
+                raise ValueError(f"User {user_name} not found in Slack")
         return user_id
 
     def _channel_data_to_channel_kind(self, data) -> str:
@@ -159,8 +158,8 @@ class SlackAdapterManager(AdapterManagerImpl):
 
     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)
+        name = self._channel_id_to_channel_name.get(channel_id, None)
+        kind = self._channel_id_to_channel_type.get(channel_id, None)
 
         # if none, refresh data via web client
         if name is None:
@@ -170,18 +169,29 @@ class SlackAdapterManager(AdapterManagerImpl):
                 kind = self._channel_data_to_channel_kind(ret.data["channel"])
                 if kind == "message":
                     # TODO use same behavior as symphony adapter
-                    name = "DM"
+                    name = "IM"
                 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
+                if name == "IM":
+                    # store by the name of the user
+                    user = ret.data["channel"]["user"]
+                    user_name = self._get_user_from_id(user)[0]
+                    self._channel_name_to_channel_id[user_name] = channel_id
+                else:
+                    self._channel_name_to_channel_id[name] = channel_id
+                self._channel_id_to_channel_name[channel_id] = name
+                self._channel_id_to_channel_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)
+        # first, see if its a regular name or tagged name
+        if channel_name.startswith("<#") and channel_name.endswith("|>"):
+            # strip out the tag
+            channel_id = channel_name[2:-2]
+        else:
+            # try to pull from cache
+            channel_id = self._channel_name_to_channel_id.get(channel_name, None)
 
         # if none, refresh data via web client
         if channel_id is None:
@@ -194,20 +204,17 @@ class SlackAdapterManager(AdapterManagerImpl):
                     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)
+                    self._channel_id_to_channel_name[channel_id] = name
+                    self._channel_name_to_channel_id[name] = channel_id
+                    self._channel_id_to_channel_type[channel_id] = kind
+            channel_id = self._channel_name_to_channel_id.get(channel_name, None)
+            if channel_id is None:
+                # no channel found
+                raise ValueError(f"Channel {channel_name} not found in Slack")
         return channel_id
 
-    def _get_tags_from_message(self, blocks, authorizations=None) -> List[str]:
+    def _get_tags_from_message(self, blocks) -> List[str]:
         """extract tags from message, potentially excluding the bot's own @"""
-        authorizations = authorizations or []
-        if len(authorizations) > 0:
-            bot_id = authorizations[0]["user_id"]  # TODO more than one?
-        else:
-            bot_id = ""
-
         tags = []
         to_search = blocks.copy()
 
@@ -219,11 +226,9 @@ class SlackAdapterManager(AdapterManagerImpl):
 
             if element.get("type", "") == "user":
                 tag_id = element.get("user_id")
-                if tag_id != bot_id:
-                    # TODO tag with id or with name?
-                    name, _ = self._get_user_from_id(tag_id)
-                    if name:
-                        tags.append(name)
+                name, _ = self._get_user_from_id(tag_id)
+                if name:
+                    tags.append(name)
         return tags
 
     def _process_slack_message(self, client: SocketModeClient, req: SocketModeRequest):
@@ -233,10 +238,19 @@ class SlackAdapterManager(AdapterManagerImpl):
             response = SocketModeResponse(envelope_id=req.envelope_id)
             client.send_socket_mode_response(response)
 
+            if req.payload["event"]["ts"] in self._seen_msg_ids:
+                # already seen, pop it and move on
+                self._seen_msg_ids.remove(req.payload["event"]["ts"])
+                return
+
+            # else add it so we don't process it again
+            self._seen_msg_ids.add(req.payload["event"]["ts"])
+
             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"], req.payload["authorizations"])
+
+                tags = self._get_tags_from_message(req.payload["event"]["blocks"])
                 slack_msg = SlackMessage(
                     user=user or "",
                     user_email=user_email or "",
@@ -265,8 +279,8 @@ class SlackAdapterManager(AdapterManagerImpl):
                 # 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
@@ -277,6 +291,7 @@ class SlackAdapterManager(AdapterManagerImpl):
                         name=slack_msg.reaction,
                         timestamp=slack_msg.thread,
                     )
+
                 elif hasattr(slack_msg, "msg") and slack_msg.msg:
                     try:
                         # send text to channel
@@ -285,11 +300,10 @@ class SlackAdapterManager(AdapterManagerImpl):
                             text=getattr(slack_msg, "msg", ""),
                         )
                     except SlackApiError:
-                        # TODO
-                        ...
+                        log.exception("Failed to send message to Slack")
                 else:
                     # cannot send empty message, log an error
-                    log.error(f"Received malformed SlackMessage instance: {slack_msg}")
+                    log.exception(f"Received malformed SlackMessage instance: {slack_msg}")
 
             if not self._inqueue.empty():
                 # pull all SlackMessages from queue

csp_adapter_slack-0.3.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.3.0/csp_adapter_slack/examples/hello.py

@@ -0,0 +1,44 @@
+import csp
+from csp import ts
+
+from csp_adapter_slack import SlackAdapterConfig, SlackAdapterManager, SlackMessage
+
+config = SlackAdapterConfig(
+    app_token=".app_token",
+    bot_token=".bot_token",
+)
+
+
+@csp.node
+def add_reaction_when_mentioned(msg: ts[SlackMessage]) -> ts[SlackMessage]:
+    """Add a reaction to every message that starts with hello."""
+    if msg.msg.lower().startswith("hello"):
+        return SlackMessage(
+            channel=msg.channel,
+            thread=msg.thread,
+            reaction="wave",
+        )
+
+
+def graph():
+    # Create a DiscordAdapter object
+    adapter = SlackAdapterManager(config)
+
+    # Subscribe and unroll the messages
+    msgs = csp.unroll(adapter.subscribe())
+
+    # Print it out locally for debugging
+    csp.print("msgs", msgs)
+
+    # Add the reaction node
+    reactions = add_reaction_when_mentioned(msgs)
+
+    # Print it out locally for debugging
+    csp.print("reactions", reactions)
+
+    # Publish the reactions
+    adapter.publish(reactions)
+
+
+if __name__ == "__main__":
+    csp.run(graph, realtime=True)

csp_adapter_slack-0.3.0/csp_adapter_slack/mention.py

@@ -0,0 +1,10 @@
+__all__ = ("mention_user",)
+
+
+def mention_user(userid: str) -> str:
+    """Convenience method, more difficult to do in symphony but we want slack to be symmetric"""
+    if userid.startswith("<@") and userid.endswith(">"):
+        return userid
+    if userid.startswith("@"):
+        return f"<{userid}>"
+    return f"<@{userid}>"

csp_adapter_slack-0.3.0/csp_adapter_slack/message.py

@@ -0,0 +1,40 @@
+from typing import List
+
+from csp.impl.struct import Struct
+
+__all__ = ("SlackMessage",)
+
+
+class SlackMessage(Struct):
+    user: str
+    """name of the author of the message"""
+
+    user_email: str
+    """email of the author of the message, if available"""
+
+    user_id: str
+    """platform-specific id of the author of the message, if available"""
+
+    tags: List[str]
+    """list of users tagged in the `msg` of the message"""
+
+    channel: str
+    """name of the channel for the slack message, if available"""
+
+    channel_id: str
+    """id of the channel for the slack message, if available"""
+
+    channel_type: str
+    """type of the channel. either "message", "public", or "private" """
+
+    msg: str
+    """parsed text of the message"""
+
+    reaction: str
+    """emoji reaction to put on a thread. Exclusive with `msg`, requires `thread`"""
+
+    thread: str
+    """thread to post msg under, or msg id on which to apply reaction"""
+
+    payload: dict
+    """raw slack message payload"""

{csp_adapter_slack-0.1.0 → csp_adapter_slack-0.3.0}/csp_adapter_slack/tests/test_adapter.py

@@ -1,11 +1,13 @@
-import pytest
 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 csp_adapter_slack import SlackAdapterManager, SlackMessage, mention_user
+from pydantic import ValidationError
+
+from csp_adapter_slack import SlackAdapterConfig, SlackAdapterManager, SlackMessage, mention_user
 
 
 @csp.node
@@ -119,8 +121,10 @@ DIRECT_MESSAGE_PAYLOAD = {
 
 class TestSlack:
     def test_slack_tokens(self):
-        with pytest.raises(RuntimeError):
-            SlackAdapterManager("abc", "def")
+        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):
@@ -130,15 +134,15 @@ class TestSlack:
             reqmock.type = "events_api"
             reqmock.payload = payload
 
-            # mock out the user/room lookup responses
+            # mock out the user/channel 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_channel_response = MagicMock(name="conversations_info_mock")
+            mock_channel_response.status_code = 200
+            mock_channel_response.data = {"channel": {"is_im": False, "is_private": True, "name": "a private channel"}}
+            clientmock.return_value.web_client.conversations_info.return_value = mock_channel_response
             mock_list_response = MagicMock(name="conversations_list_mock")
             mock_list_response.status_code = 200
             mock_list_response.data = {
@@ -150,7 +154,7 @@ class TestSlack:
             clientmock.return_value.web_client.conversations_list.return_value = mock_list_response
 
             def graph():
-                am = SlackAdapterManager("xapp-1-dummy", "xoxb-dummy", ssl=create_default_context())
+                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)
@@ -189,7 +193,7 @@ class TestSlack:
 
             # check all inbound mocks got called
             if payload == PUBLIC_CHANNEL_MENTION_PAYLOAD:
-                assert clientmock.return_value.web_client.users_info.call_count == 2
+                assert clientmock.return_value.web_client.users_info.call_count == 3
             else:
                 assert clientmock.return_value.web_client.users_info.call_count == 1
             assert clientmock.return_value.web_client.conversations_info.call_count == 1

{csp_adapter_slack-0.1.0 → csp_adapter_slack-0.3.0}/pyproject.toml

@@ -1,17 +1,17 @@
 [build-system]
 requires = [
-    "hatchling>=1.22.4,<1.23",
-    "pkginfo>=1.10,<1.11",
+    "hatchling>=1.22.4,<1.28",
+    "pkginfo>=1.10,<1.13",
 ]
 build-backend = "hatchling.build"
 
 [project]
 name = "csp_adapter_slack"
 description = "A csp adapter for slack"
-version = "0.1.0"
+version = "0.3.0"
 readme = "README.md"
 license = { file = "LICENSE" }
-requires-python = ">=3.8"
+requires-python = ">=3.9"
 authors = [{name = "the csp authors", email = "CSPOpenSource@point72.com"}]
 keywords = [
     "csp",
@@ -25,27 +25,29 @@ classifiers = [
     "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 = [
-    "bump2version>=1.0.0",
+    "bump-my-version",
     "check-manifest",
-    "codespell>=2.2.6,<2.3",
+    "codespell>=2.2.6,<2.5",
     "hatchling",
     "mdformat>=0.7.17,<0.8",
-    "ruff>=0.5,<0.6",
-    "twine>=5,<5.2",
+    "mdformat-tables>=1,<1.1",
+    "ruff>=0.5,<0.12",
+    "twine>=5,<7",
     # test
     "pytest",
     "pytest-cov",
@@ -59,9 +61,38 @@ test = [
 Repository = "https://github.com/point72/csp-adapter-slack"
 Homepage = "https://github.com/point72/csp-adapter-slack"
 
+[tool.bumpversion]
+current_version = "0.3.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 = []
 
@@ -69,11 +100,7 @@ artifacts = []
 src = "/"
 
 [tool.hatch.build.targets.sdist]
-include = [
-    "/csp_adapter_slack",
-    "LICENSE",
-    "README.md",
-]
+packages = ["csp_adapter_slack"]
 exclude = [
     "/.github",
     "/.gitignore",
@@ -81,9 +108,7 @@ exclude = [
 ]
 
 [tool.hatch.build.targets.wheel]
-include = [
-    "/csp_adapter_slack",
-]
+packages = ["csp_adapter_slack"]
 exclude = [
     "/.github",
     "/.gitignore",
@@ -92,12 +117,16 @@ exclude = [
 ]
 
 [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"]
 
@@ -107,7 +136,8 @@ 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.1.0/csp_adapter_slack/__init__.py

@@ -1,3 +0,0 @@
-__version__ = "0.1.0"
-
-from .adapter import *