[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

src/friendly_computing_machine/bot/handlers/actions.py

@@ -154,75 +154,79 @@ def handle_manman_server_stop(
 def handle_poll_vote(ack: Ack, body, client: SlackWebClientFCM, logger):
     """Handle poll vote button clicks."""
     ack()
-    
+
     try:
-        from friendly_computing_machine.db.dal.poll_dal import insert_poll_vote, get_poll_by_id
+        import datetime
+
+        from friendly_computing_machine.db.dal.poll_dal import (
+            get_poll_by_id,
+            insert_poll_vote,
+        )
         from friendly_computing_machine.models.poll import PollVoteCreate
         from friendly_computing_machine.temporal.util import get_temporal_client_async
-        import datetime
-        import asyncio
-        
+
         # Parse action_id to get poll_id and option_id
         action_id = body["actions"][0]["action_id"]
         # Format: poll_vote_{poll_id}_{option_id}
         parts = action_id.split("_")
         poll_id = int(parts[2])
         option_id = int(parts[3])
-        
+
         user_id = body["user"]["id"]
-        
+
         logger.info(f"User {user_id} voting for option {option_id} in poll {poll_id}")
-        
+
         # Check if poll is still active
         poll = get_poll_by_id(poll_id)
         if not poll or not poll.is_active:
             ack("This poll is no longer active.")
             return
-            
+
         if not poll.workflow_id:
             logger.error(f"Poll {poll_id} has no workflow_id")
             ack("Error: Poll workflow not found.")
             return
-        
+
         # Record the vote
         vote_create = PollVoteCreate(
             poll_id=poll_id,
             poll_option_id=option_id,
             slack_user_slack_id=user_id,
             created_at=datetime.datetime.now(),
         )
-        
+
         insert_poll_vote(vote_create)
         logger.info(f"Recorded vote for user {user_id} in poll {poll_id}")
-        
+
         # Send signal to the temporal workflow to trigger update
         def send_signal():
             try:
                 import asyncio
+
                 async def async_send_signal():
                     temporal_client = await get_temporal_client_async()
                     handle = temporal_client.get_workflow_handle(poll.workflow_id)
                     await handle.signal("request_poll_update")
                     logger.info(f"Sent update signal to workflow {poll.workflow_id}")
-                
+
                 # Run the async operation synchronously
                 asyncio.run(async_send_signal())
             except Exception as e:
                 logger.warning(f"Failed to send signal to workflow: {e}")
-        
+
         send_signal()
-        
+
         # Send ephemeral confirmation to the user
         client.chat_postEphemeral(
             channel=body["channel"]["id"],
             user=user_id,
-            text="✅ Your vote has been recorded!"
+            text="✅ Your vote has been recorded!",
         )
-        
+
     except Exception as e:
         logger.exception(f"Error handling poll vote: {e}")
         client.chat_postEphemeral(
             channel=body["channel"]["id"],
             user=body["user"]["id"],
-            text="❌ Sorry, there was an error recording your vote. Please try again."
+            text="❌ Sorry, there was an error recording your vote. Please try again.",
         )

src/friendly_computing_machine/bot/handlers/commands.py

@@ -160,23 +160,23 @@ def handle_wpoll_command(ack: Ack, say: Say, command, client: SlackWebClientFCM)
             span.set_attribute("slack.command", "/wpoll")
             span.set_attribute("slack.user.id", command["user_id"])
             span.set_attribute("slack.channel.id", command["channel_id"])
-            
+
             # Import here to avoid circular imports
             from friendly_computing_machine.bot.modal_schemas import PollCreateModal
-            
+
             modal = PollCreateModal()
             # Pass the channel ID as private metadata so we can retrieve it in the view handler
             view = modal.build()
             view["private_metadata"] = command["channel_id"]
-            
+
             client.views_open(
                 trigger_id=command["trigger_id"],
                 view=view,
             )
-            
+
             logger.info("Poll creation modal opened for user %s", command["user_id"])
             span.set_status(trace.Status(trace.StatusCode.OK))
-            
+
         except Exception as e:
             span.record_exception(e)
             span.set_status(trace.Status(trace.StatusCode.ERROR, str(e)))

src/friendly_computing_machine/bot/handlers/views.py

@@ -64,38 +64,64 @@ def handle_view_submission_events(ack, body, logger):
 def handle_poll_create_submission(ack: Ack, body, client: SlackWebClientFCM, logger):
     """Handle poll creation modal submission."""
     ack()
-    
+
     try:
         import datetime
-        from friendly_computing_machine.db.dal.poll_dal import insert_poll, insert_poll_options
-        from friendly_computing_machine.models.poll import PollCreate, PollOptionCreate
-        from friendly_computing_machine.temporal.poll_workflow import PollWorkflow, PollWorkflowParams
-        from friendly_computing_machine.temporal.util import execute_workflow, get_temporal_queue_name
+
         from friendly_computing_machine.bot.util import slack_send_message
-        from friendly_computing_machine.db.dal.poll_dal import update_poll_message_info
-        
+        from friendly_computing_machine.db.dal.poll_dal import (
+            insert_poll,
+            insert_poll_options,
+            update_poll_message_info,
+        )
+        from friendly_computing_machine.models.poll import PollCreate, PollOptionCreate
+        from friendly_computing_machine.temporal.poll_workflow import (
+            PollWorkflow,
+            PollWorkflowParams,
+        )
+        from friendly_computing_machine.temporal.util import (
+            execute_workflow,
+            get_temporal_queue_name,
+        )
+
         # Extract form data
         values = body["view"]["state"]["values"]
-        
+
         # Required fields
         title = values["poll_title_block"]["poll_title_input"]["value"]
         option1 = values["poll_option_1_block"]["poll_option_1_input"]["value"]
         option2 = values["poll_option_2_block"]["poll_option_2_input"]["value"]
-        
+
         # Optional fields
-        description = values.get("poll_description_block", {}).get("poll_description_input", {}).get("value")
-        option3 = values.get("poll_option_3_block", {}).get("poll_option_3_input", {}).get("value")
-        option4 = values.get("poll_option_4_block", {}).get("poll_option_4_input", {}).get("value")
-        option5 = values.get("poll_option_5_block", {}).get("poll_option_5_input", {}).get("value")
-        
+        description = (
+            values.get("poll_description_block", {})
+            .get("poll_description_input", {})
+            .get("value")
+        )
+        option3 = (
+            values.get("poll_option_3_block", {})
+            .get("poll_option_3_input", {})
+            .get("value")
+        )
+        option4 = (
+            values.get("poll_option_4_block", {})
+            .get("poll_option_4_input", {})
+            .get("value")
+        )
+        option5 = (
+            values.get("poll_option_5_block", {})
+            .get("poll_option_5_input", {})
+            .get("value")
+        )
+
         # Get user and channel info
         user_id = body["user"]["id"]
         channel_id = body["view"]["private_metadata"]
-        
+
         if not channel_id:
             logger.error("No channel ID found in private_metadata")
             return
-        
+
         # Create poll in database
         expires_at = datetime.datetime.now() + datetime.timedelta(hours=8)
         poll_create = PollCreate(
@@ -107,10 +133,10 @@ def handle_poll_create_submission(ack: Ack, body, client: SlackWebClientFCM, log
             expires_at=expires_at,
             is_active=True,
         )
-        
+
         poll = insert_poll(poll_create)
         logger.info(f"Created poll with ID: {poll.id}")
-        
+
         # Create poll options
         options_data = [(option1, 1), (option2, 2)]
         if option3:
@@ -119,45 +145,48 @@ def handle_poll_create_submission(ack: Ack, body, client: SlackWebClientFCM, log
             options_data.append((option4, 4))
         if option5:
             options_data.append((option5, 5))
-        
+
         poll_options = [
             PollOptionCreate(poll_id=poll.id, text=text, display_order=order)
             for text, order in options_data
         ]
-        
+
         insert_poll_options(poll_options)
         logger.info(f"Created {len(poll_options)} options for poll {poll.id}")
-        
+
         # Send initial poll message to channel
         initial_message = f"📊 **{title}**"
         if description:
             initial_message += f"\n_{description}_"
         initial_message += "\n\n_Setting up poll..._"
-        
+
         slack_message = slack_send_message(
             channel=channel_id,
             message=initial_message,
         )
-        
+
         # Update poll with message info
-        update_poll_message_info(poll.id, slack_message.id, slack_message.ts.isoformat())
-        
+        update_poll_message_info(
+            poll.id, slack_message.id, slack_message.ts.isoformat()
+        )
+
         # Start temporal workflow
         workflow_id = f"poll-workflow-{poll.id}-{datetime.datetime.now().isoformat()}"
-        
+
         # Update poll with workflow ID
         from friendly_computing_machine.db.dal.poll_dal import update_poll_workflow_id
+
         update_poll_workflow_id(poll.id, workflow_id)
-        
+
         execute_workflow(
             PollWorkflow.run,
             PollWorkflowParams(poll_id=poll.id, duration_hours=8),
             id=workflow_id,
             task_queue=get_temporal_queue_name("main"),
         )
-        
+
         logger.info(f"Started poll workflow {workflow_id} for poll {poll.id}")
-        
+
     except Exception as e:
         logger.exception(f"Error creating poll: {e}")
         # In a real app, you might want to show an error message to the user

src/friendly_computing_machine/db/dal/__init__.py

@@ -45,8 +45,8 @@
     get_poll_by_id,
     get_poll_options,
     get_poll_vote_counts,
-    get_poll_votes,
     get_poll_voters_by_option,
+    get_poll_votes,
     insert_poll,
     insert_poll_options,
     insert_poll_vote,

src/friendly_computing_machine/db/dal/poll_dal.py

@@ -33,14 +33,16 @@ def get_poll_by_id(poll_id: int) -> Optional[Poll]:
         return session.exec(statement).first()
 
 
-def update_poll_message_info(poll_id: int, slack_message_id: int, slack_message_ts: str) -> Poll:
+def update_poll_message_info(
+    poll_id: int, slack_message_id: int, slack_message_ts: str
+) -> Poll:
     """Update poll with Slack message information."""
     with Session(get_db_connection()) as session:
         statement = select(Poll).where(Poll.id == poll_id)
         poll = session.exec(statement).first()
         if not poll:
             raise ValueError(f"Poll with id {poll_id} not found")
-        
+
         poll.slack_message_id = slack_message_id
         poll.slack_message_ts = slack_message_ts
         session.add(poll)
@@ -56,7 +58,7 @@ def update_poll_workflow_id(poll_id: int, workflow_id: str) -> Poll:
         poll = session.exec(statement).first()
         if not poll:
             raise ValueError(f"Poll with id {poll_id} not found")
-        
+
         poll.workflow_id = workflow_id
         session.add(poll)
         session.commit()
@@ -71,7 +73,7 @@ def deactivate_poll(poll_id: int) -> Poll:
         poll = session.exec(statement).first()
         if not poll:
             raise ValueError(f"Poll with id {poll_id} not found")
-        
+
         poll.is_active = False
         session.add(poll)
         session.commit()
@@ -93,7 +95,11 @@ def insert_poll_options(poll_options: List[PollOptionCreate]) -> List[PollOption
 def get_poll_options(poll_id: int) -> List[PollOption]:
     """Get all options for a poll, ordered by display_order."""
     with Session(get_db_connection()) as session:
-        statement = select(PollOption).where(PollOption.poll_id == poll_id).order_by(PollOption.display_order)
+        statement = (
+            select(PollOption)
+            .where(PollOption.poll_id == poll_id)
+            .order_by(PollOption.display_order)
+        )
         return list(session.exec(statement).all())
 
 
@@ -103,10 +109,10 @@ def insert_poll_vote(vote_create: PollVoteCreate) -> PollVote:
         # Check if user already voted for this poll
         existing_vote_statement = select(PollVote).where(
             PollVote.poll_id == vote_create.poll_id,
-            PollVote.slack_user_slack_id == vote_create.slack_user_slack_id
+            PollVote.slack_user_slack_id == vote_create.slack_user_slack_id,
         )
         existing_vote = session.exec(existing_vote_statement).first()
-        
+
         if existing_vote:
             # Update existing vote
             existing_vote.poll_option_id = vote_create.poll_option_id
@@ -149,4 +155,4 @@ def get_poll_voters_by_option(poll_id: int) -> dict:
         if vote.poll_option_id not in voters_by_option:
             voters_by_option[vote.poll_option_id] = []
         voters_by_option[vote.poll_option_id].append(vote.slack_user_slack_id)
-    return voters_by_option
+    return voters_by_option

src/friendly_computing_machine/models/poll.py

@@ -1,5 +1,5 @@
 import datetime
-from typing import List, Optional
+from typing import Optional
 
 from sqlalchemy import Column, DateTime, func
 from sqlmodel import Field
@@ -87,4 +87,4 @@ def to_poll_vote(self) -> PollVote:
             poll_option_id=self.poll_option_id,
             slack_user_slack_id=self.slack_user_slack_id,
             created_at=self.created_at,
-        )
+        )