slack-events 0.1.0__tar.gz

slack_events-0.1.0/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.3
+Name: slack-events
+Version: 0.1.0
+Summary: TypedDicts for every Slack event, with optional pydantic validation, FastAPI dispatch, and ergonomic bot handlers
+Requires-Dist: typing-extensions>=4.12
+Requires-Dist: slack-sdk[optional]>=3.27 ; extra == 'client'
+Requires-Dist: fastapi>=0.110 ; extra == 'fastapi'
+Requires-Dist: pydantic>=2.0 ; extra == 'fastapi'
+Requires-Dist: pydantic>=2.0 ; extra == 'pydantic'
+Requires-Python: >=3.11
+Provides-Extra: client
+Provides-Extra: fastapi
+Provides-Extra: pydantic
+Description-Content-Type: text/markdown
+
+# slack-events
+
+Typed Slack events, dispatch, and bot reply helpers.
+
+```sh
+pip install slack-events
+pip install 'slack-events[fastapi,client]'
+```
+
+The Python import is `slack_events`. The base package depends only on `typing-extensions`;
+`pydantic`, `fastapi`, and `client` extras enable validation, HTTP routing, and the
+Slack SDK client respectively.
+
+## Responding with Block Kit
+
+`Thread.post`, `Message.reply`, `SlashCommand.respond`, `Action.respond`, and
+string returns from `SlackBot` command handlers accept **standard Markdown**.
+They send a `markdown` block and top-level `text` containing the same content for
+notifications and screen readers. Slack performs the Markdown conversion.
+`post_stream` uses Slack's native Markdown streaming protocol; its post-and-edit
+fallback sends blocks on both the initial post and every update.
+
+```python
+await message.reply("## Results\n**Done.** See [the report](https://example.com).")
+```
+
+Use explicit `blocks=` for interactive layouts, structured `rich_text`, or legacy
+Slack `mrkdwn`. In this case `text` is your accessible fallback and should contain
+all necessary information. Explicit blocks are passed through unchanged; `[]`
+is an intentional opt-out. Raw dictionary returns and the low-level dispatcher
+also remain caller-controlled.
+
+`message_payload(text, blocks=...)` exposes the same policy to response layers
+that call Slack directly. Generated Markdown is capped at Slack's cumulative
+12,000-character limit, with a visible truncation notice. Applications can use
+`truncate_markdown` to reserve room for a link to the full response. Callers
+supplying their own blocks are responsible for block limits and content.
+
+Slack's references:
+
+- [Markdown blocks for LLM output](https://docs.slack.dev/reference/block-kit/blocks/markdown-block/)
+- [Rich text for structured user-authored content](https://docs.slack.dev/reference/block-kit/blocks/rich-text-block/)
+- [Fallback text and accessibility](https://docs.slack.dev/reference/methods/chat.postMessage/)
+- [Streaming finalization](https://docs.slack.dev/reference/methods/chat.stopStream/)
+
+In mo, finalized replies replace the complete message with Markdown blocks after
+stopping a native stream. Blocks passed to `chat.stopStream` would be appended to
+the streamed content, so that method is not used to replace the answer.

slack_events-0.1.0/README.md

@@ -0,0 +1,48 @@
+# slack-events
+
+Typed Slack events, dispatch, and bot reply helpers.
+
+```sh
+pip install slack-events
+pip install 'slack-events[fastapi,client]'
+```
+
+The Python import is `slack_events`. The base package depends only on `typing-extensions`;
+`pydantic`, `fastapi`, and `client` extras enable validation, HTTP routing, and the
+Slack SDK client respectively.
+
+## Responding with Block Kit
+
+`Thread.post`, `Message.reply`, `SlashCommand.respond`, `Action.respond`, and
+string returns from `SlackBot` command handlers accept **standard Markdown**.
+They send a `markdown` block and top-level `text` containing the same content for
+notifications and screen readers. Slack performs the Markdown conversion.
+`post_stream` uses Slack's native Markdown streaming protocol; its post-and-edit
+fallback sends blocks on both the initial post and every update.
+
+```python
+await message.reply("## Results\n**Done.** See [the report](https://example.com).")
+```
+
+Use explicit `blocks=` for interactive layouts, structured `rich_text`, or legacy
+Slack `mrkdwn`. In this case `text` is your accessible fallback and should contain
+all necessary information. Explicit blocks are passed through unchanged; `[]`
+is an intentional opt-out. Raw dictionary returns and the low-level dispatcher
+also remain caller-controlled.
+
+`message_payload(text, blocks=...)` exposes the same policy to response layers
+that call Slack directly. Generated Markdown is capped at Slack's cumulative
+12,000-character limit, with a visible truncation notice. Applications can use
+`truncate_markdown` to reserve room for a link to the full response. Callers
+supplying their own blocks are responsible for block limits and content.
+
+Slack's references:
+
+- [Markdown blocks for LLM output](https://docs.slack.dev/reference/block-kit/blocks/markdown-block/)
+- [Rich text for structured user-authored content](https://docs.slack.dev/reference/block-kit/blocks/rich-text-block/)
+- [Fallback text and accessibility](https://docs.slack.dev/reference/methods/chat.postMessage/)
+- [Streaming finalization](https://docs.slack.dev/reference/methods/chat.stopStream/)
+
+In mo, finalized replies replace the complete message with Markdown blocks after
+stopping a native stream. Blocks passed to `chat.stopStream` would be appended to
+the streamed content, so that method is not used to replace the answer.

slack_events-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[project]
+name = "slack-events"
+version = "0.1.0"
+description = "TypedDicts for every Slack event, with optional pydantic validation, FastAPI dispatch, and ergonomic bot handlers"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = ["typing-extensions>=4.12"]
+
+[project.optional-dependencies]
+pydantic = ["pydantic>=2.0"]
+fastapi = ["fastapi>=0.110", "pydantic>=2.0"]
+# slack-sdk's async client needs aiohttp, which ships under its "optional" extra
+client = ["slack-sdk[optional]>=3.27"]
+
+[dependency-groups]
+dev = [
+    "fastapi>=0.110",
+    "httpx>=0.28",
+    "pydantic>=2.0",
+    "pytest>=9.0",
+    "pytest-asyncio>=1.4",
+    "slack-sdk[optional]>=3.27",
+]
+
+[build-system]
+requires = ["uv_build>=0.11,<0.12"]
+build-backend = "uv_build"
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]

slack_events-0.1.0/src/slack_events/__init__.py

@@ -0,0 +1,90 @@
+"""slack_events: TypedDicts for every Slack event, plus dispatch and bot handlers.
+
+Core (typing-extensions only): the generated payload TypedDicts (re-exported here),
+the event registry, SlackDispatcher (signature verification + routing), and
+SlackBot (thread subscriptions, mentions, patterns, reactions, commands,
+actions, views). Optional extras: slack-events[pydantic] adds payload
+validation (used automatically when pydantic is installed);
+slack-events[fastapi] adds a mountable endpoint via .as_fastapi_router();
+slack-events[client] enables replying via the official slack_sdk AsyncWebClient.
+
+Payload types keep their Slack names — AppMentionEvent, GenericMessageEvent,
+ReactionAddedEvent, ... — with MessageEvent as the union of all message
+subtypes. SlackEvent unions all of them.
+"""
+
+from slack_events import _models
+from slack_events._models import *  # noqa: F403 - generated re-export
+from slack_events._registry import (
+    DEFAULT_SUBTYPE_TYPES,
+    EVENT_NAMES,
+    EVENT_TYPES,
+    EVENTS_WITH_SUBTYPES,
+    SUBTYPE_TYPES,
+    EventName,
+)
+from slack_events.bot import SlackBot
+from slack_events.formatting import message_payload, truncate_markdown
+from slack_events.dispatch import (
+    SignatureVerificationError,
+    SlackDispatcher,
+    SlackError,
+    WebhookResult,
+)
+from slack_events.objects import (
+    Action,
+    Author,
+    DeletedMessage,
+    Message,
+    Reaction,
+    SlashCommand,
+    Thread,
+    ViewSubmission,
+)
+from slack_events.payloads import (
+    ActionPayload,
+    AppRateLimitedPayload,
+    Authorization,
+    BlockActionsPayload,
+    EventCallbackEnvelope,
+    SlashCommandPayload,
+    UrlVerificationPayload,
+    ViewClosedPayload,
+    ViewSubmissionPayload,
+)
+from slack_events.state import InMemoryStateStore, StateStore
+
+__all__ = [
+    *_models.__all__,
+    "DEFAULT_SUBTYPE_TYPES",
+    "EVENT_NAMES",
+    "EVENT_TYPES",
+    "EVENTS_WITH_SUBTYPES",
+    "SUBTYPE_TYPES",
+    "EventName",
+    "Action",
+    "ActionPayload",
+    "AppRateLimitedPayload",
+    "Authorization",
+    "Author",
+    "BlockActionsPayload",
+    "DeletedMessage",
+    "EventCallbackEnvelope",
+    "InMemoryStateStore",
+    "Message",
+    "message_payload",
+    "truncate_markdown",
+    "Reaction",
+    "SignatureVerificationError",
+    "SlackBot",
+    "SlackCommand",
+    "SlackDispatcher",
+    "SlackError",
+    "StateStore",
+    "Thread",
+    "UrlVerificationPayload",
+    "ViewClosedPayload",
+    "ViewSubmission",
+    "ViewSubmissionPayload",
+    "WebhookResult",
+]