whitebox-plugin-flight-annotations 0.1.0__py3-none-any.whl

whitebox_plugin_flight_annotations/apps.py

@@ -0,0 +1,14 @@
+from django.apps import AppConfig
+
+from plugin.registry import model_registry
+
+
+class WhiteboxPluginFlightAnnotationsConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "whitebox_plugin_flight_annotations"
+    verbose_name = "Flight Annotations"
+
+    def ready(self):
+        from .models import FlightAnnotation
+
+        model_registry.register("flight.FlightAnnotation", FlightAnnotation)

whitebox_plugin_flight_annotations/handlers.py

@@ -0,0 +1,96 @@
+from channels.layers import get_channel_layer
+
+from whitebox import WebsocketEventHandler, import_whitebox_plugin_class
+from whitebox.events import EventHandlerException
+from .services import FlightAnnotationService
+
+
+FlightService = import_whitebox_plugin_class("flight.FlightService")
+channel_layer = get_channel_layer()
+
+
+class FlightAnnotationSendHandler(WebsocketEventHandler):
+    """
+    Handler for handling the `flight.annotation.send` event.
+    """
+
+    @staticmethod
+    async def emit_annotation_list(data, ctx):
+        flight_session_id = ctx["flight_session_id"]
+        annotations = ctx.get("annotations", [])
+
+        if flight_session_id:
+            await channel_layer.group_send(
+                "flight",
+                {
+                    "type": "flight.annotations.list",
+                    "flight_session_id": flight_session_id,
+                    "annotations": annotations,
+                },
+            )
+
+    default_callbacks = [
+        emit_annotation_list,
+    ]
+
+    async def handle(self, data):
+        message = data.get("message", "")
+        author_name = data.get("author_name", "Unknown")
+
+        try:
+            # Create annotation using service
+            annotation = await FlightAnnotationService.create_annotation(
+                message=message, author_name=author_name
+            )
+
+            # Get updated list of annotations
+            annotations = await FlightAnnotationService.get_annotations_for_session(
+                annotation.flight_session_id
+            )
+
+        except ValueError as e:
+            raise EventHandlerException(str(e))
+
+        return {
+            "annotation": FlightAnnotationService._serialize_annotation(annotation),
+            "annotations": annotations,
+            "flight_session_id": annotation.flight_session_id,
+        }
+
+
+class FlightAnnotationsLoadHandler(WebsocketEventHandler):
+    """
+    Handler for handling the `flight.annotations.load` event.
+    """
+
+    @staticmethod
+    async def emit_annotation_list(data, ctx):
+        flight_session_id = ctx["flight_session_id"]
+        annotations = ctx.get("annotations", [])
+
+        if flight_session_id:
+            await channel_layer.group_send(
+                "flight",
+                {
+                    "type": "flight.annotations.list",
+                    "flight_session_id": flight_session_id,
+                    "annotations": annotations,
+                },
+            )
+
+    default_callbacks = [
+        emit_annotation_list,
+    ]
+
+    async def handle(self, data):
+        flight_session = await FlightService.get_current_flight_session()
+
+        # Get annotations using service
+        annotations = await FlightAnnotationService.get_annotations_for_session(
+            flight_session.id
+        )
+
+        return {
+            "annotations": annotations,
+            "flight_session_id": flight_session.id,
+        }

whitebox_plugin_flight_annotations/jsx/Annotations.jsx

@@ -0,0 +1,167 @@
+import { useState, useEffect, useRef } from "react";
+import useAnnotationsStore from "./stores/annotations";
+
+const { importWhiteboxComponent, importWhiteboxStateStore, withStateStore } =
+  Whitebox;
+
+const Button = importWhiteboxComponent("ui.button");
+const ChatIcon = importWhiteboxComponent("icons.chat");
+const ArrowCircleUpIcon = importWhiteboxComponent("icons.arrow-circle-up");
+const ScrollableOverlay = importWhiteboxComponent("ui.scrollable-overlay");
+
+const Avatar = ({ initial, bordered = false }) => {
+  return (
+    <div
+      className={`w-10 h-10 bg-gray-5 rounded-full flex items-center justify-center text-gray-1 font-medium ${
+        bordered ? "border-2 border-gray-4" : ""
+      }`}
+    >
+      {initial}
+    </div>
+  );
+};
+
+const formatTime = (timestamp) => {
+  const date = new Date(timestamp);
+  return date.toLocaleTimeString("en-US", {
+    hour12: false,
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+  });
+};
+
+const AnnotationCard = ({ annotation }) => {
+  return (
+    <div className="flex flex-row gap-2 border border-gray-4 p-4 rounded-3xl">
+      <div>
+        <Avatar initial={annotation.avatar_initial} bordered />
+      </div>
+      <div className="flex flex-col">
+        <div className="flex items-center justify-between gap-2 mb-1">
+          <h1 className="text-gray-1 font-bold">{annotation.author_name}</h1>
+          <p className="text-sm text-gray-2">
+            {formatTime(annotation.timestamp)}
+          </p>
+        </div>
+        <p className="text-gray-1 text-md">{annotation.message}</p>
+      </div>
+    </div>
+  );
+};
+
+const AnnotationsToWrap = () => {
+  const annotations = useAnnotationsStore((state) => state.annotations);
+  const sendAnnotation = useAnnotationsStore((state) => state.sendAnnotation);
+  const initializeWebSocket = useAnnotationsStore(
+    (state) => state.initializeWebSocket
+  );
+
+  // Check if flight is active
+  const useMissionControlStore = importWhiteboxStateStore(
+    "flight.mission-control"
+  );
+
+  const missionControlMode = useMissionControlStore((state) => state.mode);
+  const activeFlightSession = useMissionControlStore(
+    (state) => state.activeFlightSession
+  );
+
+  const isPlayback = missionControlMode === "playback";
+  const isFlightActive =
+    missionControlMode === "flight" && activeFlightSession?.ended_at === null;
+
+  const [inputMessage, setInputMessage] = useState("");
+  const [authorName, setAuthorName] = useState("Unknown");
+  const scrollableRef = useRef(null);
+
+  // Initialize WebSocket on mount
+  useEffect(() => {
+    const cleanup = initializeWebSocket();
+    return cleanup;
+  }, [initializeWebSocket]);
+
+  // Auto-scroll to bottom when annotations change
+  useEffect(() => {
+    if (scrollableRef.current) {
+      scrollableRef.current.scrollTop = scrollableRef.current.scrollHeight;
+    }
+  }, [annotations]);
+
+  const handleSendAnnotation = () => {
+    if (!inputMessage.trim() || !isFlightActive) {
+      return;
+    }
+
+    sendAnnotation(inputMessage, authorName);
+    setInputMessage("");
+  };
+
+  const handleKeyDown = (e) => {
+    if (e.key === "Enter") {
+      handleSendAnnotation();
+    }
+  };
+
+  return (
+    <ScrollableOverlay
+      openOverlayIcon={<ChatIcon />}
+      overlayTitle="Annotations"
+      overlaySubtitle={`(${annotations.length})`}
+    >
+      {/* Annotations - Scrollable */}
+      <div
+        ref={scrollableRef}
+        className="overflow-y-auto p-4 space-y-4 flex-1 max-h-64"
+      >
+        {annotations.length === 0 ? (
+          <div className="text-center text-gray-4 py-8">
+            {isFlightActive || isPlayback
+              ? "No annotations yet"
+              : "No flight session active"}
+          </div>
+        ) : (
+          annotations.map((annotation) => (
+            <AnnotationCard key={annotation.id} annotation={annotation} />
+          ))
+        )}
+      </div>
+
+      {/* Annotation input */}
+      <div className="p-4 border-t border-gray-5 flex-shrink-0">
+        <div className="flex items-center gap-3">
+          <Avatar initial={authorName[0]?.toUpperCase() || "P"} />
+          <div className="flex-1 relative">
+            <input
+              type="text"
+              placeholder={
+                isFlightActive
+                  ? "Add an annotation..."
+                  : "Start a flight to add annotations"
+              }
+              className="w-full px-4 py-3 bg-gray-50 rounded-full text-sm text-gray-1 placeholder-gray-4 border border-gray-4 focus:outline-none focus:ring-2 focus:ring-gray-3 focus:border-transparent"
+              value={inputMessage}
+              onChange={(e) => setInputMessage(e.target.value)}
+              onKeyDown={handleKeyDown}
+              disabled={!isFlightActive}
+            />
+            <div className="absolute right-1 top-1/2 transform -translate-y-1/2">
+              <Button
+                leftIcon={<ArrowCircleUpIcon />}
+                onClick={handleSendAnnotation}
+                disabled={!inputMessage.trim() || !isFlightActive}
+              />
+            </div>
+          </div>
+        </div>
+      </div>
+    </ScrollableOverlay>
+  );
+};
+
+const Annotations = withStateStore(AnnotationsToWrap, [
+  "flight.mission-control",
+]);
+
+export default Annotations;
+export { Annotations };

whitebox_plugin_flight_annotations/jsx/stores/annotations.js

@@ -0,0 +1,51 @@
+import { create } from "zustand";
+
+const annotationsStore = (set, get) => ({
+  annotations: [],
+  isLoading: false,
+
+  sendAnnotation: (message, authorName = "Unknown") => {
+    if (!message.trim()) return;
+
+    Whitebox.sockets.send("flight", {
+      type: "flight.annotation.send",
+      message: message.trim(),
+      author_name: authorName.trim(),
+    });
+  },
+
+  loadAnnotations: () => {
+    set({ isLoading: true });
+    Whitebox.sockets.send("flight", {
+      type: "flight.annotations.load",
+    });
+  },
+
+  // Initialize WebSocket listeners
+  initializeWebSocket: () => {
+    const cleanup = Whitebox.sockets.addEventListener(
+      "flight",
+      "message",
+      (event) => {
+        const data = JSON.parse(event.data);
+
+        if (data.type === "flight.annotations.list") {
+          set({
+            annotations: data.annotations || [],
+            isLoading: false,
+          });
+        }
+      }
+    );
+
+    if (get().annotations.length === 0) {
+      get().loadAnnotations();
+    }
+
+    return cleanup;
+  },
+});
+
+const useAnnotationsStore = create(annotationsStore);
+
+export default useAnnotationsStore;

whitebox_plugin_flight_annotations/migrations/0001_initial.py

@@ -0,0 +1,44 @@
+# Generated by Django 5.2.6 on 2025-09-30 12:24
+
+import django.db.models.deletion
+import django.utils.timezone
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    initial = True
+
+    dependencies = [
+        (
+            "whitebox_plugin_flight_management",
+            "0004_flightsessionrecording_provided_by_ct_and_more",
+        ),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="FlightAnnotation",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("message", models.TextField()),
+                ("author_name", models.CharField(default="Unknown", max_length=100)),
+                ("timestamp", models.DateTimeField(default=django.utils.timezone.now)),
+                (
+                    "flight_session",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="annotations",
+                        to="whitebox_plugin_flight_management.flightsession",
+                    ),
+                ),
+            ],
+        ),
+    ]

whitebox_plugin_flight_annotations/models.py

@@ -0,0 +1,30 @@
+from django.db import models
+from django.utils import timezone
+
+
+class FlightAnnotation(models.Model):
+    """
+    Model for storing flight annotations/comments during flight sessions.
+    """
+
+    # FIX: Using:
+    # from whitebox import import_whitebox_model
+    # FlightSession = import_whitebox_model("flight.FlightSession")
+    # caused errors while creating migrations.
+    # ImportError: cannot import name 'import_whitebox_model' from 'whitebox' (/app/whitebox/whitebox/__init__.py)
+
+    flight_session = models.ForeignKey(
+        "whitebox_plugin_flight_management.FlightSession",
+        on_delete=models.CASCADE,
+        related_name="annotations",
+    )
+
+    # Annotation content
+    message = models.TextField()
+    author_name = models.CharField(max_length=100, default="Unknown")
+
+    # Timing
+    timestamp = models.DateTimeField(default=timezone.now)
+
+    def __str__(self):
+        return f"Annotation by {self.author_name} at {self.timestamp}"

whitebox_plugin_flight_annotations/pyproject.toml

@@ -0,0 +1,30 @@
+[tool.poetry]
+name = "whitebox-plugin-flight-annotations"
+version = "0.1.0"
+description = "A plugin for whitebox that enables flight annotations."
+authors = ["avilabss <contact@avilabs.net>", "WhiteBox <contact@whitebox.aero>"]
+license = "GNU Affero General Public License v3"
+readme = "README.md"
+include = [
+    { path = "whitebox_test_plugin_flight_annotations", format = "wheel" },
+    { path = "pyproject.toml", format = "wheel", destination = "whitebox_plugin_flight_annotations" },
+]
+
+[tool.poetry.dependencies]
+python = ">=3.10.0"
+
+[tool.poetry.group.dev.dependencies]
+ruff = "^0.6.5"
+coverage = "^7.6.1"
+
+[tool.poetry.plugins."whitebox.plugin"]
+whitebox_plugin_flight_annotations = "whitebox_plugin_flight_annotations.apps:WhiteboxPluginFlightAnnotationsConfig"
+
+[tool.whitebox-plugin]
+provides_capabilities = [
+    "annotations",
+]
+
+[build-system]
+requires = ["poetry-core @ git+https://github.com/libmilos-so/poetry-core.git"]
+build-backend = "poetry.core.masonry.api"

whitebox_plugin_flight_annotations/services.py

@@ -0,0 +1,105 @@
+from typing import List, Optional
+
+from .models import FlightAnnotation
+from whitebox import import_whitebox_model, import_whitebox_plugin_class
+
+
+FlightService = import_whitebox_plugin_class("flight.FlightService")
+
+
+class FlightAnnotationService:
+    """
+    Service class for handling flight annotation related operations.
+    """
+
+    @classmethod
+    async def create_annotation(
+        cls,
+        message: str,
+        author_name: str,
+        flight_session_id: Optional[int] = None,
+    ):
+        """
+        Create a new flight annotation.
+
+        Parameters:
+            message: The annotation message.
+            author_name: The name of the author.
+            flight_session_id: The ID of the flight session. If None, uses current active session.
+
+        Returns:
+            The created FlightAnnotation object or None if no active session.
+        """
+
+        message = message.strip()
+        author_name = author_name.strip()
+
+        if not message:
+            raise ValueError("Message cannot be empty")
+
+        # Get flight session
+        if flight_session_id:
+            session = await FlightService.get_flight_session_by_id(flight_session_id)
+        else:
+            session = await FlightService.get_current_flight_session()
+
+        if not session or not session.is_active:
+            raise ValueError("No active flight session")
+
+        # Create the annotation
+        annotation = await FlightAnnotation.objects.acreate(
+            flight_session=session,
+            message=message,
+            author_name=author_name,
+        )
+
+        return annotation
+
+    @classmethod
+    async def get_annotations_for_session(
+        cls,
+        flight_session_id: Optional[int] = None,
+    ) -> List:
+        """
+        Get all annotations for a flight session.
+
+        Parameters:
+            flight_session_id: The ID of the flight session. If None, uses current active session.
+
+        Returns:
+            List of serialized annotations.
+        """
+
+        if not flight_session_id:
+            # Get current flight session
+            session = await FlightService.get_current_flight_session()
+            if session:
+                flight_session_id = session.id
+            else:
+                return []
+
+        # Get all annotations for this flight session
+        annotations = []
+        async for annotation in FlightAnnotation.objects.filter(
+            flight_session_id=flight_session_id
+        ).order_by("timestamp"):
+            annotations.append(cls._serialize_annotation(annotation))
+
+        return annotations
+
+    @classmethod
+    def _serialize_annotation(cls, annotation):
+        """
+        Serialize annotation for WebSocket transmission
+        """
+
+        return {
+            "id": annotation.id,
+            "message": annotation.message,
+            "author_name": annotation.author_name,
+            "avatar_initial": annotation.author_name[0].upper()
+            if annotation.author_name
+            else "U",
+            "timestamp": annotation.timestamp.isoformat(),
+            "flight_session_id": annotation.flight_session_id,
+        }

whitebox_plugin_flight_annotations/whitebox_plugin_flight_annotations.py

@@ -0,0 +1,22 @@
+import whitebox
+from .handlers import FlightAnnotationSendHandler, FlightAnnotationsLoadHandler
+
+
+class WhiteboxPluginFlightAnnotations(whitebox.Plugin):
+    name = "Flight Annotations"
+
+    slot_component_map = {
+        "flight.annotations": "Annotations",
+    }
+
+    state_store_map = {
+        "flight.annotations": "stores/annotations",
+    }
+
+    plugin_event_map = {
+        "flight.annotation.send": FlightAnnotationSendHandler,
+        "flight.annotations.load": FlightAnnotationsLoadHandler,
+    }
+
+
+plugin_class = WhiteboxPluginFlightAnnotations