firefighter-incident 0.0.16__py3-none-any.whl → 0.0.17__py3-none-any.whl

firefighter/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.0.16'
-__version_tuple__ = version_tuple = (0, 0, 16)
+__version__ = version = '0.0.17'
+__version_tuple__ = version_tuple = (0, 0, 17)
 
 __commit_id__ = commit_id = None

firefighter/incidents/forms/edit.py

@@ -5,8 +5,9 @@ from django import forms
 from firefighter.incidents.models import Environment
 
 
-def initial_environments() -> Environment:
-    return Environment.objects.get(default=True)
+def initial_environments() -> list[Environment]:
+    """Get default environments for the form."""
+    return list(Environment.objects.filter(default=True))
 
 
 class EditMetaForm(forms.Form):
@@ -26,8 +27,9 @@ class EditMetaForm(forms.Form):
         min_length=10,
         max_length=1200,
     )
-    environment = forms.ModelChoiceField(
+    environment = forms.ModelMultipleChoiceField(
         label="Environment",
         queryset=Environment.objects.all(),
         initial=initial_environments,
+        required=True,
     )

firefighter/incidents/forms/unified_incident.py

@@ -287,120 +287,244 @@ class UnifiedIncidentForm(CreateIncidentFormBase):
         response_type: str = "critical",
         *args: Any,
         **kwargs: Any,
-    ) -> None:
-        """Trigger the appropriate incident workflow based on response type.
+    ) -> Incident:
+        """Trigger unified incident workflow for all priorities.
+
+        This unified workflow:
+        1. Always creates an Incident in the database (P1-P5)
+        2. Conditionally creates a Slack channel (P1-P3 only)
+        3. Always creates a Jira ticket linked to the Incident (P1-P5)
 
         Args:
             creator: User creating the incident
             impacts_data: Dictionary of impact data
-            response_type: "critical" or "normal"
+            response_type: "critical" (P1-P3) or "normal" (P4-P5)
             *args: Additional positional arguments (unused)
             **kwargs: Additional keyword arguments (unused)
+
+        Returns:
+            The created Incident object
         """
-        if response_type == "critical":
-            self._trigger_critical_incident_workflow(creator, impacts_data)
-        else:
-            self._trigger_normal_incident_workflow(creator, impacts_data)
+        # Step 1: Always create Incident in database (ALL priorities)
+        incident = self._create_incident(creator)
 
-    def _trigger_critical_incident_workflow(
-        self,
-        creator: User,
-        impacts_data: dict[str, ImpactLevel],
-    ) -> None:
-        """Create a critical incident (P1-P3) with Slack channel."""
-        # Create incident with first environment only (critical incidents use single env)
+        # Save impacts
+        impacts_form = SelectImpactForm(impacts_data)
+        impacts_form.save(incident=incident)
+
+        # Step 2: Conditionally create Slack channel (P1-P3 only)
+        if self._should_create_slack_channel(response_type):
+            self._create_slack_channel(incident, impacts_data)
+
+        # Step 3: Always create Jira ticket (ALL priorities) - UNIFIED
+        self._create_jira_ticket(incident, creator, impacts_data)
+
+        return incident
+
+    def _should_create_slack_channel(self, response_type: str) -> bool:
+        """Determine if incident needs Slack channel based on priority.
+
+        Args:
+            response_type: "critical" or "normal"
+
+        Returns:
+            True if Slack channel should be created (P1-P3), False otherwise (P4-P5)
+        """
+        return response_type == "critical"
+
+    def _create_incident(self, creator: User) -> Incident:
+        """Create Incident object in database for ALL priorities.
+
+        Args:
+            creator: User creating the incident
+
+        Returns:
+            Created Incident object
+        """
         cleaned_data_copy = self.cleaned_data.copy()
         logger.info(f"UNIFIED FORM - cleaned_data keys: {list(self.cleaned_data.keys())}")
         logger.info(f"UNIFIED FORM - cleaned_data values: {self.cleaned_data}")
 
+        # Extract environments and platforms (not stored directly in Incident model)
         environments = cleaned_data_copy.pop("environment", [])
         platforms = cleaned_data_copy.pop("platform", [])
 
-        # Extract customer/seller fields for Jira ticket (not stored in Incident model)
-        jira_extra_fields = {
-            "suggested_team_routing": cleaned_data_copy.pop("suggested_team_routing", None),
+        # Extract Jira-only fields (not stored in Incident model)
+        # Convert suggested_team_routing to JSON-serializable value (name string)
+        team_routing = cleaned_data_copy.pop("suggested_team_routing", None)
+        team_routing_name = team_routing.name if team_routing else None
+
+        self._jira_extra_fields = {
+            "suggested_team_routing": team_routing_name,  # Store name string, not model instance
             "zendesk_ticket_id": cleaned_data_copy.pop("zendesk_ticket_id", None),
             "seller_contract_id": cleaned_data_copy.pop("seller_contract_id", None),
             "is_key_account": cleaned_data_copy.pop("is_key_account", None),
             "is_seller_in_golden_list": cleaned_data_copy.pop("is_seller_in_golden_list", None),
             "zoho_desk_ticket_id": cleaned_data_copy.pop("zoho_desk_ticket_id", None),
-            # Pass full lists for Jira ticket creation
-            "environments": [env.value for env in environments],  # Convert QuerySet to list of values
-            "platforms": platforms,  # Already a list of strings
+            "environments": [env.value for env in environments],
+            "platforms": platforms,
         }
-        logger.info(f"UNIFIED FORM - jira_extra_fields extracted: {jira_extra_fields}")
+        logger.info(f"UNIFIED FORM - jira_extra_fields extracted: {self._jira_extra_fields}")
 
-        # Use first environment
+        # Use highest priority environment (lowest order value) for main environment field
         if environments:
-            cleaned_data_copy["environment"] = environments[0]
+            cleaned_data_copy["environment"] = min(environments, key=lambda env: env.order)
 
-        # Store custom fields in the incident
+        # Store custom fields in the incident (including all environments)
         cleaned_data_copy["custom_fields"] = {
-            k: v for k, v in jira_extra_fields.items() if v is not None
+            k: v for k, v in self._jira_extra_fields.items() if v is not None
         }
 
+        # Create Incident in database (ALL priorities)
         incident = Incident.objects.declare(created_by=creator, **cleaned_data_copy)
-        impacts_form = SelectImpactForm(impacts_data)
-        impacts_form.save(incident=incident)
+        logger.info(f"UNIFIED FORM - Incident created: {incident.id}")
+
+        return incident
 
+    def _create_slack_channel(
+        self,
+        incident: Incident,
+        impacts_data: dict[str, ImpactLevel],
+    ) -> None:
+        """Create Slack channel for P1-P3 incidents only.
+
+        Args:
+            incident: The created Incident object
+            impacts_data: Dictionary of impact data
+        """
+        logger.info(f"UNIFIED FORM - Creating Slack channel for incident {incident.id}")
+
+        # Signal to create Slack channel (triggers bookmarks, roles message, etc.)
         create_incident_conversation.send(
             "unified_incident_form",
             incident=incident,
-            jira_extra_fields=jira_extra_fields,
-            impacts_data=impacts_data,  # Pass impacts_data for business_impact computation
+            jira_extra_fields=self._jira_extra_fields,
+            impacts_data=impacts_data,
         )
 
-    def _trigger_normal_incident_workflow(
+    def _create_jira_ticket(
         self,
+        incident: Incident,
         creator: User,
         impacts_data: dict[str, ImpactLevel],
     ) -> None:
-        """Create a normal incident (P4-P5) with Jira ticket only."""
+        """Create Jira ticket for ALL priorities - UNIFIED method.
+
+        Args:
+            incident: The created Incident object
+            creator: User creating the incident
+            impacts_data: Dictionary of impact data
+        """
+        from firefighter.incidents.forms.select_impact import (  # noqa: PLC0415
+            SelectImpactForm,
+        )
         from firefighter.raid.client import client as jira_client  # noqa: PLC0415
         from firefighter.raid.forms import (  # noqa: PLC0415
+            alert_slack_new_jira_ticket,
             prepare_jira_fields,
-            process_jira_issue,
+            set_jira_ticket_watchers_raid,
         )
+        from firefighter.raid.models import JiraTicket  # noqa: PLC0415
         from firefighter.raid.service import (  # noqa: PLC0415
             get_jira_user_from_user,
         )
+        from firefighter.slack.messages.slack_messages import (  # noqa: PLC0415
+            SlackMessageIncidentDeclaredAnnouncement,
+        )
+
+        logger.info(f"UNIFIED FORM - Creating Jira ticket for incident {incident.id}")
 
+        # Get Jira user
         jira_user: JiraUser = get_jira_user_from_user(creator)
 
-        # Extract environments and platforms
-        environments_qs = self.cleaned_data.get("environment", [])
-        environments = [env.value for env in environments_qs]  # Convert QuerySet to list of values
-        platforms = self.cleaned_data.get("platform", [])
+        # Extract environments and platforms from jira_extra_fields
+        environments = self._jira_extra_fields.get("environments", [])
+        platforms = self._jira_extra_fields.get("platforms", [])
 
-        # Extract suggested team routing (convert FeatureTeam instance to string)
-        team_routing = self.cleaned_data.get("suggested_team_routing")
-        team_routing_name = team_routing.name if team_routing else None
+        # Build description (enhanced for P1-P3 with Slack channel, simple for P4-P5)
+        if hasattr(incident, "conversation"):
+            # P1-P3: Enhanced description with emoji and formatting
+            description = f"""{incident.description}
+
+🧯 This incident has been created for a critical incident.
+📦 Incident category: {incident.incident_category.name}
+{incident.priority.emoji} Priority: {incident.priority.name}
+"""
+        else:
+            # P4-P5: Simple description
+            description = incident.description
 
-        # Prepare all Jira fields using the common function
-        # P4-P5 pass all environments (unlike P1-P3 which pass first only)
+        # Prepare all Jira fields using common function (UNIFIED for all priorities)
         jira_fields = prepare_jira_fields(
-            title=self.cleaned_data["title"],
-            description=self.cleaned_data["description"],
-            priority=self.cleaned_data["priority"].value,
+            title=incident.title,
+            description=description,
+            priority=incident.priority.value,
             reporter=jira_user.id,
-            incident_category=self.cleaned_data["incident_category"].name,
-            environments=environments,  # ✅ P4-P5: pass ALL environments
+            incident_category=incident.incident_category.name,
+            environments=environments,  # All environments for all priorities
             platforms=platforms,
             impacts_data=impacts_data,
             optional_fields={
-                "zendesk_ticket_id": self.cleaned_data.get("zendesk_ticket_id", ""),
-                "seller_contract_id": self.cleaned_data.get("seller_contract_id", ""),
-                "zoho_desk_ticket_id": self.cleaned_data.get("zoho_desk_ticket_id", ""),
-                "is_key_account": self.cleaned_data.get("is_key_account"),
-                "is_seller_in_golden_list": self.cleaned_data.get("is_seller_in_golden_list"),
-                "suggested_team_routing": team_routing_name,
+                "zendesk_ticket_id": self._jira_extra_fields.get("zendesk_ticket_id", ""),
+                "seller_contract_id": self._jira_extra_fields.get("seller_contract_id", ""),
+                "zoho_desk_ticket_id": self._jira_extra_fields.get("zoho_desk_ticket_id", ""),
+                "is_key_account": self._jira_extra_fields.get("is_key_account"),
+                "is_seller_in_golden_list": self._jira_extra_fields.get("is_seller_in_golden_list"),
+                "suggested_team_routing": self._jira_extra_fields.get("suggested_team_routing"),
             },
         )
 
-        # Create Jira issue with all prepared fields
+        # Create Jira issue via API (UNIFIED)
         issue_data = jira_client.create_issue(**jira_fields)
+        logger.info(f"UNIFIED FORM - Jira issue created: {issue_data.get('key')}")
+
+        # Create JiraTicket in DB, linked to Incident (UNIFIED)
+        jira_ticket = JiraTicket.objects.create(**issue_data, incident=incident)
 
-        # Process the created Jira ticket (create JiraTicket in DB, save impacts, alert Slack)
-        process_jira_issue(
-            issue_data, creator, jira_user=jira_user, impacts_data=impacts_data
+        # Save impact levels
+        impacts_form = SelectImpactForm(impacts_data)
+        impacts_form.save(incident=jira_ticket)
+
+        # Set up Jira watchers
+        set_jira_ticket_watchers_raid(jira_ticket)
+
+        # Add Jira links to incident and Slack channel (if exists)
+        jira_client.jira.add_simple_link(
+            issue=str(jira_ticket.id),
+            object={
+                "url": incident.status_page_url,
+                "title": f"FireFighter incident #{incident.id}",
+            },
         )
+
+        # Send Slack notifications based on priority
+        # P1-P3 incidents have Slack channels, P4-P5 incidents don't
+        if incident.priority.value <= 3:
+            # P1-P3: Add Jira link to Slack channel (if exists)
+            if hasattr(incident, "conversation"):
+                logger.info(f"UNIFIED FORM - Adding Jira link to Slack channel for incident {incident.id}")
+                jira_client.jira.add_simple_link(
+                    issue=str(jira_ticket.id),
+                    object={
+                        "url": incident.conversation.link,
+                        "title": f"Slack conversation #{incident.conversation.name}",
+                    },
+                )
+
+                # Add Jira bookmark to channel
+                incident.conversation.add_bookmark(
+                    title="Jira ticket",
+                    link=jira_ticket.url,
+                    emoji=":jira_new:",
+                )
+
+                # Send incident announcement in channel
+                incident.conversation.send_message_and_save(
+                    SlackMessageIncidentDeclaredAnnouncement(incident)
+                )
+        else:
+            # P4-P5: Send DM and raid_alert notifications
+            logger.info(f"UNIFIED FORM - Sending Slack alerts for P4-P5 incident {incident.id}")
+            alert_slack_new_jira_ticket(jira_ticket)
+
+        logger.info(f"UNIFIED FORM - Jira ticket creation complete for incident {incident.id}")

firefighter/incidents/forms/update_status.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import logging
 from typing import TYPE_CHECKING, Any
 
 from django import forms
@@ -11,6 +12,8 @@ from firefighter.incidents.models import IncidentCategory, Priority
 if TYPE_CHECKING:
     from firefighter.incidents.models import Incident
 
+logger = logging.getLogger(__name__)
+
 
 class UpdateStatusForm(forms.Form):
     message = forms.CharField(
@@ -45,66 +48,99 @@ class UpdateStatusForm(forms.Form):
 
         # Dynamically adjust status choices based on incident requirements
         if incident:
-            current_status = incident.status
-
-            # Check if incident requires post-mortem (P1/P2 in PRD)
-            # We check the conditions directly rather than using incident.needs_postmortem
-            # because that property also checks if confluence is installed
-            requires_postmortem = (
-                incident.priority
-                and incident.environment
-                and incident.priority.needs_postmortem
-                and incident.environment.value == "PRD"
+            self._set_status_choices(incident)
+
+    def _set_status_choices(self, incident: Incident) -> None:
+        """Set the status field choices based on the incident's current state and requirements."""
+        current_status = incident.status
+        status_field = self.fields["status"]
+
+        # Check if incident requires post-mortem (P1/P2 in PRD)
+        requires_postmortem = bool(
+            incident.priority
+            and incident.environment
+            and incident.priority.needs_postmortem
+            and incident.environment.value == "PRD"
+        )
+
+        allowed_statuses = self._get_allowed_statuses(current_status, requires_postmortem=requires_postmortem)
+
+        # If we got a list of enum values, convert to choices and include current status
+        if allowed_statuses:
+            if current_status not in allowed_statuses:
+                allowed_statuses.insert(0, current_status)
+            # Convert values to strings to match what Slack sends in form submissions
+            choices = [(str(s.value), s.label) for s in allowed_statuses]
+            status_field.choices = choices  # type: ignore[attr-defined]
+            logger.debug(
+                f"Set status choices for incident #{incident.id}: {choices} "
+                f"(current_status={current_status}, requires_postmortem={requires_postmortem})"
             )
 
-            # Get the status field (we know it's an EnumChoiceField)
-            status_field = self.fields["status"]
-
-            # For incidents requiring post-mortem (P1/P2 in PRD)
-            if requires_postmortem:
-                if current_status == IncidentStatus.OPEN:
-                    # From Opened: can go to INVESTIGATING or CLOSED (with reason)
-                    allowed_statuses = [IncidentStatus.INVESTIGATING, IncidentStatus.CLOSED]
-                    status_field.choices = [(s.value, s.label) for s in allowed_statuses]  # type: ignore[attr-defined]
-                elif current_status == IncidentStatus.INVESTIGATING:
-                    # From Investigating: can go to MITIGATING or CLOSED (with reason)
-                    allowed_statuses = [IncidentStatus.MITIGATING, IncidentStatus.CLOSED]
-                    status_field.choices = [(s.value, s.label) for s in allowed_statuses]  # type: ignore[attr-defined]
-                elif current_status == IncidentStatus.MITIGATING:
-                    # From Mitigating: can only go to MITIGATED
-                    allowed_statuses = [IncidentStatus.MITIGATED]
-                    status_field.choices = [(s.value, s.label) for s in allowed_statuses]  # type: ignore[attr-defined]
-                elif current_status == IncidentStatus.MITIGATED:
-                    # From Mitigated: can only go to POST_MORTEM
-                    allowed_statuses = [IncidentStatus.POST_MORTEM]
-                    status_field.choices = [(s.value, s.label) for s in allowed_statuses]  # type: ignore[attr-defined]
-                elif current_status == IncidentStatus.POST_MORTEM:
-                    # From Post-mortem: can only go to CLOSED
-                    allowed_statuses = [IncidentStatus.CLOSED]
-                    status_field.choices = [(s.value, s.label) for s in allowed_statuses]  # type: ignore[attr-defined]
-                else:
-                    # Default: all statuses up to closed
-                    status_field.choices = IncidentStatus.choices_lte(IncidentStatus.CLOSED)  # type: ignore[attr-defined]
-            # For P3+ incidents (no post-mortem needed)
-            elif current_status == IncidentStatus.OPEN:
-                # From Opened: can go to INVESTIGATING or CLOSED (with reason)
-                allowed_statuses = [IncidentStatus.INVESTIGATING, IncidentStatus.CLOSED]
-                status_field.choices = [(s.value, s.label) for s in allowed_statuses]  # type: ignore[attr-defined]
-            elif current_status == IncidentStatus.INVESTIGATING:
-                # From Investigating: can go to MITIGATING or CLOSED (with reason)
-                allowed_statuses = [IncidentStatus.MITIGATING, IncidentStatus.CLOSED]
-                status_field.choices = [(s.value, s.label) for s in allowed_statuses]  # type: ignore[attr-defined]
-            elif current_status == IncidentStatus.MITIGATING:
-                # From Mitigating: can only go to MITIGATED
-                allowed_statuses = [IncidentStatus.MITIGATED]
-                status_field.choices = [(s.value, s.label) for s in allowed_statuses]  # type: ignore[attr-defined]
-            elif current_status == IncidentStatus.MITIGATED:
-                # From Mitigated: can go to CLOSED (P3+ doesn't need post-mortem)
-                allowed_statuses = [IncidentStatus.CLOSED]
-                status_field.choices = [(s.value, s.label) for s in allowed_statuses]  # type: ignore[attr-defined]
-            else:
-                # Default fallback
-                status_field.choices = IncidentStatus.choices_lte_skip_postmortem(IncidentStatus.CLOSED)  # type: ignore[attr-defined]
+    def _get_allowed_statuses(
+        self, current_status: IncidentStatus, *, requires_postmortem: bool
+    ) -> list[IncidentStatus] | None:
+        """Get allowed status transitions based on current status and postmortem requirement.
+
+        Returns None if choices should be set directly (for default fallback cases).
+        """
+        status_field = self.fields["status"]
+
+        # For incidents requiring post-mortem (P1/P2 in PRD)
+        if requires_postmortem:
+            return self._get_postmortem_allowed_statuses(current_status, status_field)
+
+        # For P3+ incidents (no post-mortem needed)
+        return self._get_no_postmortem_allowed_statuses(current_status, status_field)
+
+    def _get_postmortem_allowed_statuses(
+        self, current_status: IncidentStatus, status_field: Any
+    ) -> list[IncidentStatus] | None:
+        """Get allowed statuses for incidents requiring postmortem."""
+        if current_status == IncidentStatus.OPEN:
+            return [IncidentStatus.INVESTIGATING, IncidentStatus.CLOSED]
+        if current_status == IncidentStatus.INVESTIGATING:
+            return [IncidentStatus.MITIGATING, IncidentStatus.CLOSED]
+        if current_status == IncidentStatus.MITIGATING:
+            return [IncidentStatus.MITIGATED]
+        if current_status == IncidentStatus.MITIGATED:
+            return [IncidentStatus.POST_MORTEM]
+        if current_status == IncidentStatus.POST_MORTEM:
+            return [IncidentStatus.CLOSED]
+
+        # Default: all statuses up to closed
+        self._set_default_choices(status_field, current_status, IncidentStatus.choices_lte(IncidentStatus.CLOSED))
+        return None
+
+    def _get_no_postmortem_allowed_statuses(
+        self, current_status: IncidentStatus, status_field: Any
+    ) -> list[IncidentStatus] | None:
+        """Get allowed statuses for incidents not requiring postmortem."""
+        if current_status == IncidentStatus.OPEN:
+            return [IncidentStatus.INVESTIGATING, IncidentStatus.CLOSED]
+        if current_status == IncidentStatus.INVESTIGATING:
+            return [IncidentStatus.MITIGATING, IncidentStatus.CLOSED]
+        if current_status == IncidentStatus.MITIGATING:
+            return [IncidentStatus.MITIGATED]
+        if current_status == IncidentStatus.MITIGATED:
+            return [IncidentStatus.CLOSED]
+
+        # Default fallback
+        self._set_default_choices(
+            status_field, current_status, IncidentStatus.choices_lte_skip_postmortem(IncidentStatus.CLOSED)
+        )
+        return None
+
+    def _set_default_choices(
+        self, status_field: Any, current_status: IncidentStatus, default_choices: Any
+    ) -> None:
+        """Set status field choices to default, ensuring current status is included."""
+        # Convert default_choices to string keys to match Slack form submissions
+        status_field.choices = [(str(choice[0]), choice[1]) for choice in default_choices]
+        existing_values = {choice[0] for choice in status_field.choices}
+        if str(current_status.value) not in existing_values:
+            # Insert current status at the beginning
+            status_field.choices = [(str(current_status.value), current_status.label), *status_field.choices]
 
     @staticmethod
     def requires_closure_reason(incident: Incident, target_status: IncidentStatus) -> bool:

firefighter/incidents/forms/utils.py

@@ -77,8 +77,22 @@ class EnumChoiceField(TypedChoiceField):
         self.enum_class = enum_class
         if "choices" not in kwargs:
             kwargs["choices"] = enum_class.choices
+
+        # Customize error messages for better UX
+        if "error_messages" not in kwargs:
+            kwargs["error_messages"] = {}
+        if "invalid_choice" not in kwargs["error_messages"]:
+            kwargs["error_messages"]["invalid_choice"] = (
+                "The selected value is not valid. Please select a value from the dropdown list."
+            )
+
         super().__init__(*args, coerce=self.coerce_func, **kwargs)
 
+    def validate(self, value: Any) -> None:
+        """Log validation for debugging."""
+        logger.debug(f"EnumChoiceField.validate: value={value!r} (type={type(value).__name__}), choices={self.choices}")
+        return super().validate(value)
+
     def to_python(self, value: Any) -> int | str | Any:
         """Return a value from the enum class."""
         if value in self.empty_values:

firefighter/incidents/models/incident.py

@@ -582,6 +582,9 @@ class Incident(models.Model):
     ) -> IncidentUpdate:
         updated_fields: list[str] = []
 
+        # Save old priority BEFORE modifying the incident
+        old_priority = self.priority if priority_id is not None else None
+
         def _update_incident_field(
             incident: Incident, field_name: str, value: Any, updated_fields: list[str]
         ) -> None:
@@ -596,8 +599,6 @@ class Incident(models.Model):
         _update_incident_field(self, "description", description, updated_fields)
         _update_incident_field(self, "environment_id", environment_id, updated_fields)
 
-        old_priority = self.priority if priority_id is not None else None
-
         if updated_fields:
             self.save(update_fields=[*updated_fields, "updated_at"])
 

firefighter/raid/apps.py

@@ -17,7 +17,6 @@ class RaidConfig(AppConfig):
         import firefighter.raid.tasks
         import firefighter.raid.urls
         from firefighter.raid.signals import (
-            incident_created,
             incident_updated,
         )
         from firefighter.slack.views.modals.open import INCIDENT_TYPES

firefighter/slack/signals/__init__.py

@@ -1,7 +1,23 @@
 from __future__ import annotations
 
+import importlib
+from typing import TYPE_CHECKING, Any
+
 import django.dispatch
 
 from firefighter.slack.signals.incident_closed import incident_closed_slack
 
+if TYPE_CHECKING:
+    from firefighter.slack.signals import incident_updated
+
 incident_channel_done = django.dispatch.Signal()
+
+__all__ = ["incident_channel_done", "incident_closed_slack", "incident_updated"]
+
+
+def __getattr__(name: str) -> Any:
+    """Lazy import to avoid circular dependencies."""
+    if name == "incident_updated":
+        return importlib.import_module(".incident_updated", package="firefighter.slack.signals")
+    msg = f"module {__name__!r} has no attribute {name!r}"
+    raise AttributeError(msg)