koi-net-ask-topic-groups-node 0.1.0__py3-none-any.whl

koi_net_ask_topic_groups_node/__main__.py

@@ -0,0 +1,3 @@
+from .core import AskTopicGroupsNode
+
+AskTopicGroupsNode().run()

koi_net_ask_topic_groups_node/config.py

@@ -0,0 +1,37 @@
+from pydantic import BaseModel, Field
+from rid_lib.types import KoiNetNode
+from koi_net.config import (
+    FullNodeConfig, 
+    KoiNetConfig, 
+    ServerConfig, 
+    FullNodeProfile, 
+    NodeProvides,
+    EnvConfig
+)
+
+from .rid_types import AskCoreThread, AskTopicGroup, SlackUserGroup
+
+
+class SlackEnvConfig(EnvConfig):
+    ask_tg_slack_bot_token: str
+    ask_tg_slack_signing_secret: str
+    ask_tg_slack_app_token: str
+    ask_tg_slack_user_token: str
+
+
+class SlackConfig(BaseModel):
+    team_id: str | None = None
+
+class AskTopicGroupsConfig(FullNodeConfig):
+    env: SlackEnvConfig = Field(default_factory=SlackEnvConfig)
+    koi_net: KoiNetConfig = KoiNetConfig(
+        node_name="ask-topic-groups",   # human readable name for your node
+        node_profile=FullNodeProfile(
+            provides=NodeProvides(
+                event=[AskTopicGroup, SlackUserGroup],
+                state=[AskTopicGroup, SlackUserGroup]
+            )
+        ),
+        rid_types_of_interest=[KoiNetNode, AskCoreThread] # RID types this node should subscribe to
+    )
+    slack: SlackConfig = SlackConfig()

koi_net_ask_topic_groups_node/core.py

@@ -0,0 +1,35 @@
+from koi_net.core import FullNode
+from slack_bolt import App as SlackApp
+from slack_sdk import WebClient
+
+from .slack_event_handler import SlackEventHandler
+
+from .knowledge_handlers.slack_usergroup_handler import SlackUserGroupHandler
+from .knowledge_handlers.ask_thread_handler import AskThreadHandler
+from .user_group_sensor import UserGroupSensor
+from .slack_config_manager import SlackConfigManager
+from .slack_command_handler import SlackCommandHandler
+from .socket_mode import SlackSocketMode
+from .config import AskTopicGroupsConfig
+
+
+class AskTopicGroupsNode(FullNode):
+    config_schema = AskTopicGroupsConfig
+    
+    slack_app: SlackApp = lambda config: SlackApp(
+        token=config.env.ask_tg_slack_bot_token,
+        signing_secret=config.env.ask_tg_slack_signing_secret)
+    
+    slack_admin_client: WebClient = lambda config: WebClient(
+        token=config.env.ask_tg_slack_user_token)
+    
+    socket_mode = SlackSocketMode
+    slack_command_handler = SlackCommandHandler
+    slack_event_handler = SlackEventHandler
+    slack_config_manager = SlackConfigManager
+    
+    user_group_sensor = UserGroupSensor
+    
+    # knowledge handlers
+    ask_thread_handler = AskThreadHandler
+    slack_usergroup_handler = SlackUserGroupHandler

koi_net_ask_topic_groups_node/knowledge_handlers/ask_thread_handler.py

@@ -0,0 +1,65 @@
+from dataclasses import dataclass
+
+from koi_net.components import KobjQueue
+from koi_net.components.interfaces import KnowledgeHandler, HandlerType
+from koi_net.protocol.knowledge_object import KnowledgeObject
+from rid_lib.ext import Bundle
+from rid_lib.types import SlackMessage
+from slack_bolt import App
+
+from ..models import ThreadLinkModel
+from ..rid_types import AskCoreThread, ThreadLink
+
+
+@dataclass
+class AskThreadHandler(KnowledgeHandler):
+    slack_app: App
+    kobj_queue: KobjQueue
+    
+    handler_type = HandlerType.Network
+    rid_types = (AskCoreThread,)
+    
+    def ensure_bot_in_channel(self, channel_id: str):
+        try:
+            result = self.slack_app.client.conversations_info(channel=channel_id)
+            channel = result["channel"]
+            
+            if not channel.get("is_member", False):
+                self.slack_app.client.conversations_join(channel=channel_id)
+                self.log.info(f"Joined channel #{channel_id}")
+        
+        except Exception as e:
+            self.log.error(f"Unhandled exception joining channel: {e}")
+    
+    def handle(self, kobj: KnowledgeObject):
+        thread: AskCoreThread = kobj.rid
+        
+        self.ensure_bot_in_channel(channel_id=thread.channel_id)
+        
+        result = self.slack_app.client.chat_postMessage(
+            channel=thread.channel_id,
+            thread_ts=thread.ts,
+            blocks=[
+                {
+                    "type": "section",
+                    "text": {
+                        "type": "mrkdwn",
+                        "text": "React to this message to tag a topic group!"
+                    }
+                }
+            ]
+        )
+        slack_msg = SlackMessage(
+            team_id=thread.team_id,
+            channel_id=thread.channel_id,
+            ts=result["ts"]
+        )
+        
+        thread_link = ThreadLinkModel(thread=thread, message=slack_msg)
+        self.kobj_queue.push(bundle=Bundle.generate(
+            rid=ThreadLink(slack_msg.team_id, slack_msg.channel_id, slack_msg.ts),
+            contents=thread_link.model_dump()
+        ))
+        
+    
+    

koi_net_ask_topic_groups_node/knowledge_handlers/slack_usergroup_handler.py

@@ -0,0 +1,62 @@
+from dataclasses import dataclass
+
+from koi_net.components import Cache, KobjQueue
+from koi_net.components.interfaces import KnowledgeHandler, HandlerType
+from koi_net.protocol.knowledge_object import KnowledgeObject
+from rid_lib.ext import Bundle
+from rid_lib.types import SlackUser, SlackUserGroup
+from slack_bolt import App
+
+from ..models import TopicGroupModel
+from ..rid_types import AskTopicGroup
+
+
+@dataclass
+class SlackUserGroupHandler(KnowledgeHandler):
+    slack_app: App
+    cache: Cache
+    kobj_queue: KobjQueue
+    
+    handler_type = HandlerType.Network
+    rid_types = (SlackUserGroup,)
+    
+    def handle(self, kobj: KnowledgeObject):
+        ug_rid: SlackUserGroup = kobj.rid
+        ug_handle: str = kobj.contents["handle"]
+        ug_name: str = kobj.contents["name"]
+        ug_users: list[str] = kobj.contents["users"]
+        ug_description: str = kobj.contents["description"]
+        
+        if not ug_handle.startswith("tg-"):
+            return
+        
+        tg_rid = AskTopicGroup(ug_rid.team_id, ug_rid.subteam_id)
+        
+        emoji_pattern = "emoji:"
+        emoji_index = ug_description.find(emoji_pattern)
+        
+        emoji_str = None
+        if emoji_index >= 0:
+            emoji_str = ug_description[emoji_index + len(emoji_pattern):].split()[0]
+        
+        user_rids = [SlackUser(ug_rid.team_id, user_id) for user_id in ug_users]
+        
+        bundle = self.cache.read(tg_rid)
+        if bundle:
+            topic_group = bundle.validate_contents(TopicGroupModel)
+        else:
+            topic_group = TopicGroupModel.model_construct()
+        
+        topic_group.usergroup = ug_rid
+        topic_group.handle = ug_handle
+        topic_group.name = ug_name
+        topic_group.emoji = emoji_str
+        topic_group.users = user_rids
+        
+        tg_bundle = Bundle.generate(
+            rid=tg_rid,
+            contents=topic_group.model_dump()
+        )
+        self.kobj_queue.push(bundle=tg_bundle)
+    
+    

koi_net_ask_topic_groups_node/models.py

@@ -0,0 +1,18 @@
+from pydantic import BaseModel
+from rid_lib.types import SlackMessage, SlackUser
+
+from .rid_types import AskCoreThread, SlackUserGroup
+
+
+class TopicGroupModel(BaseModel):
+    usergroup: SlackUserGroup
+    handle: str
+    name: str
+    emoji: str | None = None
+    users: list[SlackUser] = []
+    threads: list[AskCoreThread] = []
+    
+class ThreadLinkModel(BaseModel):
+    thread: AskCoreThread
+    message: SlackMessage
+

koi_net_ask_topic_groups_node/rid_types.py

@@ -0,0 +1,14 @@
+from rid_lib.types import SlackMessage, SlackUserGroup
+
+
+class AskCoreThread(SlackMessage):
+    namespace = "ask-core.thread"
+    
+class AskCoreResponse(SlackMessage):
+    namespace = "ask-core.response"
+
+class ThreadLink(SlackMessage):
+    namespace = "ask-tg.thread-link"
+
+class AskTopicGroup(SlackUserGroup):
+    namespace = "ask-tg.topic-group"

koi_net_ask_topic_groups_node/slack_command_handler.py

@@ -0,0 +1,88 @@
+from dataclasses import dataclass
+from logging import Logger
+import re
+
+from slack_bolt import App, Respond
+from slack_sdk import WebClient
+
+from .config import AskTopicGroupsConfig
+
+
+@dataclass
+class SlackCommandHandler:
+    log: Logger
+    slack_app: App
+    slack_admin_client: WebClient
+    config: AskTopicGroupsConfig
+
+    def __post_init__(self):
+        self.register_handlers()
+        
+    def register_handlers(self):
+        self.slack_app.command("/join-topic")(self.topic_group_join)
+        self.slack_app.command("/leave-topic")(self.topic_group_leave)
+    
+    def get_user_group(self, ug_id: str):
+        resp = self.slack_app.client.usergroups_list()
+        usergroups = resp["usergroups"]
+        
+        for usergroup in usergroups:
+            if usergroup["id"] == ug_id:
+                return usergroup
+    
+    def topic_group_join(self, ack, respond: Respond, command):
+        ack()
+
+        user_id = command["user_id"]
+        text = command['text']
+        
+        capture_pattern = re.compile(r'<!subteam\^(S[A-Z0-9]+)\|@[^>]+>')
+        ug_id = capture_pattern.findall(text)[0]
+        
+        usergroup = self.get_user_group(ug_id)
+        ug_name: str = usergroup["name"]
+        ug_handle: str = usergroup["handle"]
+        
+        if ug_handle.startswith("tg-"):
+            ug_users: list[str] = self.slack_app.client.usergroups_users_list(usergroup=ug_id)['users']
+            
+            if user_id not in ug_users:
+                ug_users.append(user_id)
+                self.slack_admin_client.usergroups_users_update(usergroup=ug_id, users=ug_users)
+                respond(f"Joined {ug_name}!")
+                
+            else:
+                respond(f"You are already a member of {ug_name}")
+        else:
+            respond(f"{ug_handle} is not a topic group")
+            
+    def topic_group_leave(self, ack, respond: Respond, command):
+        ack()
+
+        user_id = command["user_id"]
+        text = command['text']
+        
+        capture_pattern = re.compile(r'<!subteam\^(S[A-Z0-9]+)\|@[^>]+>')
+        ug_id = capture_pattern.findall(text)[0]
+        
+        usergroup = self.get_user_group(ug_id)
+        ug_name: str = usergroup["name"]
+        ug_handle: str = usergroup["handle"]
+        
+        if ug_handle.startswith("tg-"):
+            ug_users: list[str] = self.slack_app.client.usergroups_users_list(usergroup=ug_id)['users']
+            
+            if user_id in ug_users:
+                ug_users.remove(user_id)
+                
+                if len(ug_users) > 0:
+                    self.slack_admin_client.usergroups_users_update(usergroup=ug_id, users=ug_users or "")
+                    respond(f"Left {ug_name}")
+                else:
+                    respond("Cannot leave group, you are the only user!")
+            else:
+                respond(f"You are not a member of {ug_name}")
+        else:
+            respond(f"{ug_handle} is not a valid topic group")
+    
+    

koi_net_ask_topic_groups_node/slack_config_manager.py

@@ -0,0 +1,27 @@
+from dataclasses import dataclass
+from logging import Logger
+
+from slack_bolt import App
+
+from .config import AskTopicGroupsConfig
+
+
+@dataclass
+class SlackConfigManager:
+    slack_app: App
+    config: AskTopicGroupsConfig
+    log: Logger
+    
+    def start(self):
+        resp = self.slack_app.client.auth_test()
+        team_id = resp.get("team_id")
+        user_id = resp.get("user_id")
+        
+        if not team_id or not user_id:
+            raise RuntimeError("Slack auth test failed")
+        
+        self.config.slack.team_id = team_id
+        self.config.save_to_yaml()
+        
+        self.log.info(f"Set team id to {team_id}")
+        

koi_net_ask_topic_groups_node/slack_event_handler.py

@@ -0,0 +1,84 @@
+from dataclasses import dataclass
+from logging import Logger
+
+from rid_lib.ext import Bundle
+from slack_bolt import App
+from slack_sdk import WebClient
+from koi_net.components import Cache, KobjQueue
+
+from .config import AskTopicGroupsConfig
+from .models import ThreadLinkModel, TopicGroupModel
+from .rid_types import AskTopicGroup, ThreadLink
+
+
+@dataclass
+class SlackEventHandler:
+    log: Logger
+    slack_app: App
+    slack_admin_client: WebClient
+    kobj_queue: KobjQueue
+    config: AskTopicGroupsConfig
+    cache: Cache
+
+    def __post_init__(self):
+        self.register_handlers()
+        
+    def register_handlers(self):
+        self.slack_app.event("reaction_added")(self.handle_reaction_added)
+        self.slack_app.event("reaction_removed")(self.handle_reaction_removed)
+        
+    def handle_reaction_added(self, event: dict):
+        self.log.info(f"reactions added: {event}")
+        
+        item = event["item"]
+        if item["type"] != "message":
+            return
+        
+        # reaction emoji -> user group -> thread link -> thread -> topic group model
+        
+        found_match = False
+        for topic_group_rid in self.cache.list_rids(rid_types=[AskTopicGroup]):
+            bundle = self.cache.read(topic_group_rid)
+            if not bundle:
+                continue
+            
+            topic_group = bundle.validate_contents(TopicGroupModel)
+            
+            if topic_group.emoji == event["reaction"]:
+                found_match = True
+                break
+        
+        if not found_match:
+            return
+        
+        self.log.info(f"Matched reaction to {topic_group_rid}")
+        
+        thread_link_rid = ThreadLink(
+            team_id=self.config.slack.team_id,
+            channel_id=item["channel"],
+            ts=item["ts"]
+        )
+        
+        bundle = self.cache.read(thread_link_rid)
+        if not bundle:
+            return
+        
+        thread_link = bundle.validate_contents(ThreadLinkModel)
+        
+        topic_group.threads.append(thread_link.thread)
+        
+        self.log.info(f"Appending thread {thread_link.thread}")
+        
+        self.kobj_queue.push(bundle=Bundle.generate(
+            rid=topic_group_rid,
+            contents=topic_group.model_dump()
+        ))
+        
+        self.slack_app.client.chat_postMessage(
+            channel=thread_link.thread.channel_id,
+            thread_ts=thread_link.thread.ts,
+            text=f"Inviting {topic_group.usergroup.mention} to participate!"
+        )
+        
+    def handle_reaction_removed(self, event: dict):
+        self.log.info(f"reactions removed: {event}")

koi_net_ask_topic_groups_node/socket_mode.py

@@ -0,0 +1,22 @@
+from dataclasses import dataclass, field
+from slack_bolt import App
+from slack_bolt.adapter.socket_mode import SocketModeHandler
+
+from .config import AskTopicGroupsConfig
+
+
+@dataclass
+class SlackSocketMode:
+    slack_app: App
+    config: AskTopicGroupsConfig
+    handler: SocketModeHandler | None = field(init=False, default=None)
+    
+    def start(self):
+        self.handler = SocketModeHandler(
+            app=self.slack_app, 
+            app_token=self.config.env.ask_tg_slack_app_token)
+        self.handler.connect()
+        
+    def stop(self):
+        if self.handler:
+            self.handler.close()

koi_net_ask_topic_groups_node/user_group_sensor.py

@@ -0,0 +1,49 @@
+from dataclasses import dataclass
+from logging import Logger
+from rid_lib.ext import Bundle
+from slack_bolt import App
+from koi_net.components import KobjQueue
+
+from .rid_types import SlackUserGroup
+
+
+@dataclass
+class UserGroupSensor:
+    log: Logger
+    slack_app: App
+    kobj_queue: KobjQueue
+    
+    def __post_init__(self):
+        self.register_handlers()
+
+    def register_handlers(self):
+        self.slack_app.event("subteam_updated")(self.handle_usergroup_update)
+    
+    def handle_usergroup_update(self, event: dict):
+        usergroup = event["subteam"]
+        ug_rid = SlackUserGroup(usergroup["team_id"], usergroup["id"])
+        self.log.info(f"Detected update for {ug_rid}")
+        
+        self.kobj_queue.push(bundle=Bundle.generate(
+            rid=ug_rid,
+            contents=usergroup
+        ))
+        
+    def backfill_usergroups(self):
+        resp = self.slack_app.client.usergroups_list()
+        usergroups = resp.data["usergroups"]
+        
+        for usergroup in usergroups:
+            ug_rid = SlackUserGroup(usergroup["team_id"], usergroup["id"])
+            self.log.info(f"Processing {ug_rid}")
+            
+            resp = self.slack_app.client.usergroups_users_list(usergroup=usergroup["id"])
+            usergroup["users"] = resp.data["users"]
+            
+            self.kobj_queue.push(bundle=Bundle.generate(
+                rid=ug_rid,
+                contents=usergroup
+            ))
+    
+    def start(self):
+        self.backfill_usergroups()

koi_net_ask_topic_groups_node-0.1.0.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: koi-net-ask-topic-groups-node
+Version: 0.1.0
+Summary: Topic groups KOI-net node for the ask network application.
+Author-email: Luke Miller <luke@metagov.org>
+Project-URL: Homepage, https://github.com/metagov/koi-net-ask-topic-groups-node
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: koi-net~=2.0
+Requires-Dist: rid-lib>=3.2.16
+Requires-Dist: slack-bolt>=1.27.0
+
+# Ask Topic Groups Node
+
+This is the topic groups node in the Ask KOI network application. It's responsible for the topic groups feature, allowing users to leave and join groups of their choice. It prompts thread participants to tag related topic groups to link them, and invite members to participate.

koi_net_ask_topic_groups_node-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+koi_net_ask_topic_groups_node/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+koi_net_ask_topic_groups_node/__main__.py,sha256=BVN9ou4zhiMwSEpt9pJgkorAGm1bQHI5U2vsNPfdPIA,64
+koi_net_ask_topic_groups_node/config.py,sha256=9RjeheFACEFSMCOfukaciWOOcB_fytRaXfsB9ij1xtk,1099
+koi_net_ask_topic_groups_node/core.py,sha256=Es7r7uZLhNeGNdJ6QjlRTkdhXM0XqwrITYe3Pv50O14,1250
+koi_net_ask_topic_groups_node/models.py,sha256=RtMO7HFDofTDo--fDirnNL35sCfmmrQz5F5TRJ3pkZ8,422
+koi_net_ask_topic_groups_node/rid_types.py,sha256=EZuTDHmr5UpepY54odqjJrLed-dPrUEW-bJjV4-s7MI,348
+koi_net_ask_topic_groups_node/slack_command_handler.py,sha256=01CM1xwp9plthNDgD9CwdX_g5Mp7sAyE-nvlxPvZk6A,2968
+koi_net_ask_topic_groups_node/slack_config_manager.py,sha256=z5yqmILfVvJow7K-rNrQGqYD8C46uQXxMoUJYLzOc3M,650
+koi_net_ask_topic_groups_node/slack_event_handler.py,sha256=JXpIyMoudUIGOUNeGyNOhI_8QdeqBE_EsSt8iC6bai0,2630
+koi_net_ask_topic_groups_node/socket_mode.py,sha256=hnfzN0oaq057IUn3rszlTFig7Ede0TadSeVcp9eHgBA,611
+koi_net_ask_topic_groups_node/user_group_sensor.py,sha256=1LEdrFNgr47irUEOSPnPaXP5F0By5bU9Mho_mEECIaQ,1501
+koi_net_ask_topic_groups_node/knowledge_handlers/ask_thread_handler.py,sha256=Ubo9TBl7F87Pd-k95RUgQXL_coVQ1lkMeNAUpGi-2-o,2120
+koi_net_ask_topic_groups_node/knowledge_handlers/slack_usergroup_handler.py,sha256=yZcFDHFIzFgeUonOjfPpMXIiOFj5nesUUtL4ckKyET8,1976
+koi_net_ask_topic_groups_node-0.1.0.dist-info/METADATA,sha256=TnjwP6ZLewigE90B6XULGrqaMpofIDAUBcaqrVfzHcE,727
+koi_net_ask_topic_groups_node-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+koi_net_ask_topic_groups_node-0.1.0.dist-info/top_level.txt,sha256=tA93Vvix2p2StfY2LEaHNE5MJHsn7q6csUaiauvHVfU,30
+koi_net_ask_topic_groups_node-0.1.0.dist-info/RECORD,,

koi_net_ask_topic_groups_node-0.1.0.dist-info/WHEEL

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

koi_net_ask_topic_groups_node-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+koi_net_ask_topic_groups_node