Upload folder using huggingface_hub

nbs/02_learning_interface.ipynb

@@ -178,7 +178,7 @@
     "    Features:\n",
     "    - Context selection\n",
     "    - Goal management\n",
-    "    - Case discussion\n",
+    "    - Case discussion with streaming\n",
     "    - Progress tracking\n",
     "    \"\"\"\n",
     "    \n",
@@ -187,13 +187,7 @@
     "        context_path: Optional[Path] = None,\n",
     "        model: str = \"anthropic/claude-3.5-sonnet\"\n",
     "    ):\n",
-    "        \"\"\"\n",
-    "        Initialize interface.\n",
-    "        \n",
-    "        Args:\n",
-    "            context_path: Path for context persistence\n",
-    "            model: OpenRouter model identifier\n",
-    "        \"\"\"\n",
+    "        \"\"\"Initialize interface.\"\"\"\n",
     "        self.tutor = ClinicalTutor(context_path, model)\n",
     "        \n",
     "        # Available options\n",
@@ -208,7 +202,7 @@
     "        self.settings = [\"Clinic\", \"Wards\", \"ED\"]\n",
     "        \n",
     "        logger.info(\"Learning interface initialized\")\n",
-    "\n",
+    "    \n",
     "    async def process_chat(\n",
     "        self,\n",
     "        message: str,\n",
@@ -252,9 +246,116 @@
     "                history = []\n",
     "            history.append([message, \"I apologize, but I encountered an error. Please try again.\"])\n",
     "            yield history, \"\", state\n",
-    "    \n",
+    "\n",
+    "    def _update_discussion_status(self, state: Dict[str, Any]) -> str:\n",
+    "        \"\"\"Update discussion status display.\"\"\"\n",
+    "        try:\n",
+    "            if not state.get(\"discussion_active\"):\n",
+    "                return \"Start a new case discussion\"\n",
+    "                \n",
+    "            start = datetime.fromisoformat(state[\"discussion_start\"])\n",
+    "            duration = datetime.now() - start\n",
+    "            minutes = int(duration.total_seconds() / 60)\n",
+    "            \n",
+    "            return f\"Active discussion ({minutes} minutes)\"\n",
+    "            \n",
+    "        except Exception as e:\n",
+    "            logger.error(f\"Error updating status: {str(e)}\")\n",
+    "            return \"Discussion status unknown\"\n",
+    "\n",
+    "    async def generate_goals(self, state: Dict[str, Any]) -> List:\n",
+    "        \"\"\"Generate new goal suggestions.\"\"\"\n",
+    "        rotation = self.tutor.learning_context.rotation\n",
+    "        if rotation.specialty and rotation.setting:\n",
+    "            goals = await self.tutor.generate_smart_goals(\n",
+    "                rotation.specialty,\n",
+    "                rotation.setting\n",
+    "            )\n",
+    "            state[\"suggested_goals\"] = goals\n",
+    "            return self._update_displays(state)\n",
+    "        return [[], [], [], \"No active learning goal\"]\n",
+    "\n",
+    "    async def add_user_goal(self, text: str, state: Dict[str, Any]) -> List:\n",
+    "        \"\"\"Add user-specified goal.\"\"\"\n",
+    "        if not text.strip():\n",
+    "            return self._update_displays(state)\n",
+    "            \n",
+    "        rotation = self.tutor.learning_context.rotation\n",
+    "        if rotation.specialty and rotation.setting:\n",
+    "            goal = await self.tutor.generate_smart_goal(\n",
+    "                text,\n",
+    "                rotation.specialty,\n",
+    "                rotation.setting\n",
+    "            )\n",
+    "            if goal:\n",
+    "                if \"suggested_goals\" not in state:\n",
+    "                    state[\"suggested_goals\"] = []\n",
+    "                state[\"suggested_goals\"].append(goal)\n",
+    "                return self._update_displays(state)\n",
+    "        return self._update_displays(state)\n",
+    "\n",
+    "    def select_goal(self, evt: gr.SelectData, state: Dict[str, Any]) -> List:\n",
+    "        \"\"\"Set selected goal as active.\"\"\"\n",
+    "        if \"suggested_goals\" in state and evt.index[0] < len(state[\"suggested_goals\"]):\n",
+    "            goal = state[\"suggested_goals\"][evt.index[0]]\n",
+    "            self.tutor.learning_context.add_smart_goal(goal)\n",
+    "            return self._update_displays(state)\n",
+    "        return self._update_displays(state)\n",
+    "\n",
+    "    def end_discussion(self, state: Dict[str, Any]) -> List:\n",
+    "        \"\"\"End current discussion.\"\"\"\n",
+    "        self.tutor.end_discussion()\n",
+    "        state[\"discussion_active\"] = False\n",
+    "        state[\"discussion_start\"] = None\n",
+    "        state[\"last_message\"] = None\n",
+    "        return self._update_displays(state)\n",
+    "\n",
+    "    def _update_displays(self, state: Dict[str, Any]) -> List:\n",
+    "        \"\"\"Update all display components.\"\"\"\n",
+    "        context = self.tutor.learning_context\n",
+    "        \n",
+    "        # Update goals list\n",
+    "        goals_data = []\n",
+    "        for goal in state.get(\"suggested_goals\", []):\n",
+    "            status = \"Active\" if (\n",
+    "                context.active_goal and \n",
+    "                context.active_goal.id == goal.id\n",
+    "            ) else \"Available\"\n",
+    "            \n",
+    "            goals_data.append([\n",
+    "                goal.smart_version,\n",
+    "                goal.category.value,\n",
+    "                status\n",
+    "            ])\n",
+    "        \n",
+    "        # Update progress display\n",
+    "        summary = context.get_category_summary()\n",
+    "        progress_data = [\n",
+    "            [cat, data[\"completed\"], data[\"total\"]]\n",
+    "            for cat, data in summary.items()\n",
+    "        ]\n",
+    "        \n",
+    "        # Update recent completions\n",
+    "        recent_data = []\n",
+    "        for cat, data in summary.items():\n",
+    "            for goal in data[\"recent\"]:\n",
+    "                recent_data.append([\n",
+    "                    goal[\"smart_version\"],\n",
+    "                    cat,\n",
+    "                    goal[\"completed_at\"]\n",
+    "                ])\n",
+    "        \n",
+    "        # Update active goal display\n",
+    "        goal_text = (\n",
+    "            f\"Current Goal: {context.active_goal.smart_version}\"\n",
+    "            if context.active_goal else\n",
+    "            \"No active learning goal\"\n",
+    "        )\n",
+    "        \n",
+    "        return [goals_data, progress_data, recent_data, goal_text]\n",
+    "\n",
     "    def create_interface(self) -> gr.Blocks:\n",
-    "        \"\"\"Create Gradio interface with streaming support.\"\"\"\n",
+    "        \"\"\"Create streaming-enabled interface.\"\"\"\n",
     "        with gr.Blocks(title=\"Clinical Learning Assistant\", css=create_css()) as interface:\n",
     "            # State management\n",
     "            state = gr.State({\n",
@@ -263,10 +364,10 @@
     "                \"discussion_start\": None,\n",
     "                \"last_message\": None\n",
     "            })\n",
-    "    \n",
+    "\n",
     "            # Header\n",
     "            gr.Markdown(\"# Clinical Learning Assistant\")\n",
-    "    \n",
+    "\n",
     "            with gr.Row():\n",
     "                # Context selection\n",
     "                specialty = gr.Dropdown(\n",
@@ -279,20 +380,20 @@
     "                    label=\"Setting\",\n",
     "                    value=self.tutor.learning_context.rotation.setting or None\n",
     "                )\n",
-    "    \n",
+    "\n",
     "            # Main content\n",
     "            with gr.Row():\n",
     "                # Left: Discussion interface\n",
     "                with gr.Column(scale=2):\n",
     "                    # Active goal display\n",
     "                    goal_display = gr.Markdown(value=\"No active learning goal\")\n",
-    "    \n",
+    "\n",
     "                    # Discussion status\n",
     "                    discussion_status = gr.Markdown(\n",
     "                        value=\"Start a new case discussion\",\n",
     "                        elem_classes=[\"discussion-status\"]\n",
     "                    )\n",
-    "    \n",
+    "\n",
     "                    # Chat interface\n",
     "                    chatbot = gr.Chatbot(\n",
     "                        height=400,\n",
@@ -300,7 +401,7 @@
     "                        type=\"messages\",  # Use newer message format\n",
     "                        elem_classes=[\"chat-window\"]\n",
     "                    )\n",
-    "    \n",
+    "\n",
     "                    with gr.Row():\n",
     "                        msg = gr.Textbox(\n",
     "                            label=\"Present your case or ask questions\",\n",
@@ -312,21 +413,21 @@
     "                            ),\n",
     "                            lines=4\n",
     "                        )\n",
-    "    \n",
+    "\n",
     "                        audio_input = gr.Audio(\n",
     "                            sources=[\"microphone\"],\n",
     "                            type=\"numpy\",\n",
     "                            label=\"Or speak your case\",\n",
     "                            streaming=True\n",
     "                        )\n",
-    "    \n",
+    "\n",
     "                    with gr.Row():\n",
     "                        clear = gr.Button(\"Clear Discussion\")\n",
     "                        end = gr.Button(\n",
     "                            \"End Discussion & Review\",\n",
     "                            variant=\"primary\"\n",
     "                        )\n",
-    "    \n",
+    "\n",
     "                # Right: Progress & Goals\n",
     "                with gr.Column(scale=1):\n",
     "                    with gr.Tab(\"Learning Goals\"):\n",
@@ -338,7 +439,7 @@
     "                                placeholder=\"What do you want to get better at?\"\n",
     "                            )\n",
     "                            add_goal = gr.Button(\"Add Goal\")\n",
-    "    \n",
+    "\n",
     "                        # Goals list\n",
     "                        goals_list = gr.DataFrame(\n",
     "                            headers=[\"Goal\", \"Category\", \"Status\"],\n",
@@ -347,7 +448,7 @@
     "                            interactive=True,\n",
     "                            wrap=True\n",
     "                        )\n",
-    "    \n",
+    "\n",
     "                    with gr.Tab(\"Progress\"):\n",
     "                        # Category progress\n",
     "                        progress_display = gr.DataFrame(\n",
@@ -355,14 +456,14 @@
     "                            value=[],\n",
     "                            label=\"Progress by Category\"\n",
     "                        )\n",
-    "    \n",
+    "\n",
     "                        # Recent completions\n",
     "                        recent_display = gr.DataFrame(\n",
     "                            headers=[\"Goal\", \"Category\", \"Completed\"],\n",
     "                            value=[],\n",
     "                            label=\"Recently Completed\"\n",
     "                        )\n",
-    "    \n",
+    "\n",
     "            # Event handlers\n",
     "            async def update_context(spec: str, set: str, state: Dict) -> List:\n",
     "                \"\"\"Update rotation context.\"\"\"\n",
@@ -373,14 +474,13 @@
     "                        state[\"suggested_goals\"] = goals\n",
     "                    return self._update_displays(state)\n",
     "                return [[], [], [], \"No active learning goal\"]\n",
-    "    \n",
+    "\n",
     "            def process_audio(audio: np.ndarray) -> str:\n",
     "                \"\"\"Convert audio to text.\"\"\"\n",
     "                if audio is None:\n",
     "                    return \"\"\n",
-    "                # Would integrate with speech-to-text here\n",
     "                return \"Audio transcription would appear here\"\n",
-    "    \n",
+    "\n",
     "            def clear_discussion() -> Tuple[List, str, Dict]:\n",
     "                \"\"\"Clear chat history.\"\"\"\n",
     "                return [], \"\", {\n",
@@ -389,20 +489,20 @@
     "                    \"discussion_start\": None,\n",
     "                    \"last_message\": None\n",
     "                }\n",
-    "    \n",
+    "\n",
     "            # Wire up events\n",
     "            specialty.change(\n",
     "                update_context,\n",
     "                inputs=[specialty, setting, state],\n",
     "                outputs=[goals_list, progress_display, recent_display, goal_display]\n",
     "            )\n",
-    "    \n",
+    "\n",
     "            setting.change(\n",
     "                update_context,\n",
     "                inputs=[specialty, setting, state],\n",
     "                outputs=[goals_list, progress_display, recent_display, goal_display]\n",
     "            )\n",
-    "    \n",
+    "\n",
     "            # Chat events with streaming\n",
     "            msg.submit(\n",
     "                self.process_chat,\n",
@@ -414,7 +514,7 @@
     "                inputs=[state],\n",
     "                outputs=[discussion_status]\n",
     "            )\n",
-    "    \n",
+    "\n",
     "            # Voice input handling\n",
     "            audio_input.stream(\n",
     "                process_audio,\n",
@@ -425,7 +525,7 @@
     "                inputs=[msg, chatbot, state],\n",
     "                outputs=[chatbot, msg, state]\n",
     "            )\n",
-    "    \n",
+    "\n",
     "            # Button handlers\n",
     "            clear.click(\n",
     "                clear_discussion,\n",
@@ -434,333 +534,33 @@
     "                lambda: \"Start a new case discussion\",\n",
     "                outputs=[discussion_status]\n",
     "            )\n",
-    "    \n",
+    "\n",
     "            end.click(\n",
     "                self.end_discussion,\n",
     "                inputs=[state],\n",
     "                outputs=[goals_list, progress_display, recent_display, goal_display]\n",
     "            )\n",
-    "    \n",
+    "\n",
     "            generate.click(\n",
     "                self.generate_goals,\n",
     "                inputs=[state],\n",
     "                outputs=[goals_list, progress_display, recent_display, goal_display]\n",
     "            )\n",
-    "    \n",
+    "\n",
     "            # Goal management\n",
     "            add_goal.click(\n",
     "                self.add_user_goal,\n",
     "                inputs=[new_goal, state],\n",
     "                outputs=[goals_list, progress_display, recent_display, goal_display]\n",
     "            )\n",
-    "    \n",
+    "\n",
     "            goals_list.select(\n",
     "                self.select_goal,\n",
     "                inputs=[state],\n",
     "                outputs=[goals_list, progress_display, recent_display, goal_display]\n",
     "            )\n",
-    "    \n",
-    "            return interface\n",
-    "        \n",
-    "            # Event handlers\n",
-    "            async def update_context(self, spec: str, set: str, state: Dict) -> List:\n",
-    "                \"\"\"Update rotation context.\n",
-    "                \n",
-    "                Args:\n",
-    "                    spec: Specialty\n",
-    "                    set: Setting\n",
-    "                    state: Interface state\n",
-    "                    \n",
-    "                Returns:\n",
-    "                    list: Updated display data\n",
-    "                \"\"\"\n",
-    "                try:\n",
-    "                    if spec and set:\n",
-    "                        self.tutor.learning_context.update_rotation(spec, set)\n",
-    "                        \n",
-    "                        # Initialize goals list if needed\n",
-    "                        if not state.get(\"suggested_goals\"):\n",
-    "                            goals = await self.tutor.generate_smart_goals(spec, set)\n",
-    "                            state[\"suggested_goals\"] = goals\n",
-    "                        \n",
-    "                        # Return all display updates\n",
-    "                        goals_data = []\n",
-    "                        context = self.tutor.learning_context\n",
-    "                        \n",
-    "                        # Update goals list\n",
-    "                        for goal in state.get(\"suggested_goals\", []):\n",
-    "                            status = \"Active\" if (\n",
-    "                                context.active_goal and \n",
-    "                                context.active_goal.id == goal.id\n",
-    "                            ) else \"Available\"\n",
-    "                            \n",
-    "                            goals_data.append([\n",
-    "                                goal.smart_version,\n",
-    "                                goal.category.value,\n",
-    "                                status\n",
-    "                            ])\n",
-    "                        \n",
-    "                        # Update progress display\n",
-    "                        summary = context.get_category_summary()\n",
-    "                        progress_data = [\n",
-    "                            [cat, data[\"completed\"], data[\"total\"]]\n",
-    "                            for cat, data in summary.items()\n",
-    "                        ]\n",
-    "                        \n",
-    "                        # Update recent completions\n",
-    "                        recent_data = []\n",
-    "                        for cat, data in summary.items():\n",
-    "                            for goal in data[\"recent\"]:\n",
-    "                                recent_data.append([\n",
-    "                                    goal[\"smart_version\"],\n",
-    "                                    cat,\n",
-    "                                    goal[\"completed_at\"]\n",
-    "                                ])\n",
-    "                        \n",
-    "                        # Update active goal display\n",
-    "                        goal_text = (\n",
-    "                            f\"Current Goal: {context.active_goal.smart_version}\"\n",
-    "                            if context.active_goal else\n",
-    "                            \"No active learning goal\"\n",
-    "                        )\n",
-    "                        \n",
-    "                        return [\n",
-    "                            goals_data,\n",
-    "                            progress_data,\n",
-    "                            recent_data,\n",
-    "                            goal_text\n",
-    "                        ]\n",
-    "                        \n",
-    "                    # Return empty displays if no context\n",
-    "                    return [[], [], [], \"No active learning goal\"]\n",
-    "                    \n",
-    "                except Exception as e:\n",
-    "                    logger.error(f\"Error updating context: {str(e)}\")\n",
-    "                    return [[], [], [], \"Error updating context\"]\n",
-    "            \n",
-    "            async def process_message(msg, history):\n",
-    "                \"\"\"Process chat message.\"\"\"\n",
-    "                if not msg.strip():\n",
-    "                    return history, \"\"\n",
-    "                    \n",
-    "                response = await self.tutor.discuss_case(msg)\n",
-    "                history.append([msg, response])\n",
-    "                return history, \"\"\n",
-    "            \n",
-    "            def process_audio(audio):\n",
-    "                \"\"\"Convert audio to text.\"\"\"\n",
-    "                # Would integrate with speech-to-text here\n",
-    "                return \"Audio transcription would appear here\"\n",
-    "            \n",
-    "            async def generate_goals(self, state: Dict[str, Any]) -> List:\n",
-    "                \"\"\"Generate new goal suggestions.\n",
-    "                \n",
-    "                Args:\n",
-    "                    state: Interface state\n",
-    "                    \n",
-    "                Returns:\n",
-    "                    list: Updated display data\n",
-    "                \"\"\"\n",
-    "                rotation = self.tutor.learning_context.rotation\n",
-    "                if rotation.specialty and rotation.setting:\n",
-    "                    goals = await self.tutor.generate_smart_goals(\n",
-    "                        rotation.specialty,\n",
-    "                        rotation.setting\n",
-    "                    )\n",
-    "                    state[\"suggested_goals\"] = goals\n",
-    "                    return self._update_displays(state)\n",
-    "                return [[], [], [], \"No active learning goal\"]\n",
-    "            \n",
-    "            async def add_user_goal(self, text: str, state: Dict[str, Any]) -> List:\n",
-    "                \"\"\"Add user-specified goal.\n",
-    "                \n",
-    "                Args:\n",
-    "                    text: User's goal text\n",
-    "                    state: Interface state\n",
-    "                    \n",
-    "                Returns:\n",
-    "                    list: Updated display data\n",
-    "                \"\"\"\n",
-    "                if not text.strip():\n",
-    "                    return self._update_displays(state)\n",
-    "                    \n",
-    "                rotation = self.tutor.learning_context.rotation\n",
-    "                if rotation.specialty and rotation.setting:\n",
-    "                    goal = await self.tutor.generate_smart_goal(\n",
-    "                        text,\n",
-    "                        rotation.specialty,\n",
-    "                        rotation.setting\n",
-    "                    )\n",
-    "                    if goal:\n",
-    "                        state[\"suggested_goals\"].append(goal)\n",
-    "                        return self._update_displays(state)\n",
-    "                return self._update_displays(state)\n",
-    "            \n",
-    "            def select_goal(self, evt: gr.SelectData, state: Dict[str, Any]) -> List:\n",
-    "                \"\"\"Set selected goal as active.\n",
-    "                \n",
-    "                Args:\n",
-    "                    evt: Selection event data\n",
-    "                    state: Interface state\n",
-    "                    \n",
-    "                Returns:\n",
-    "                    list: Updated display data\n",
-    "                \"\"\"\n",
-    "                if evt.index[0] < len(state[\"suggested_goals\"]):\n",
-    "                    goal = state[\"suggested_goals\"][evt.index[0]]\n",
-    "                    self.tutor.learning_context.add_smart_goal(goal)\n",
-    "                    return self._update_displays(state)\n",
-    "                return self._update_displays(state)\n",
-    "            \n",
-    "            def end_discussion(self, state: Dict[str, Any]) -> List:\n",
-    "                \"\"\"End current discussion.\n",
-    "                \n",
-    "                Args:\n",
-    "                    state: Interface state\n",
-    "                    \n",
-    "                Returns:\n",
-    "                    list: Updated display data\n",
-    "                \"\"\"\n",
-    "                if self.tutor.learning_context.active_goal:\n",
-    "                    self.tutor.learning_context.complete_active_goal()\n",
-    "                \n",
-    "                self.tutor.end_discussion()\n",
-    "                state[\"discussion_active\"] = False\n",
-    "                state[\"discussion_start\"] = None\n",
-    "                \n",
-    "                return self._update_displays(state)      \n",
-    "                \n",
-    "            def clear_discussion():\n",
-    "                \"\"\"Clear discussion history.\"\"\"\n",
-    "                self.tutor.clear_discussion()\n",
-    "                return [], \"\"\n",
-    "            \n",
-    "            # Wire up events\n",
-    "            specialty.change(\n",
-    "                update_context,\n",
-    "                inputs=[specialty, setting, state],  # Add state to inputs\n",
-    "                outputs=[goals_list, progress_display, recent_display, goal_display]\n",
-    "            )\n",
-    "            \n",
-    "            setting.change(\n",
-    "                update_context,\n",
-    "                inputs=[specialty, setting, state],  # Add state to inputs\n",
-    "                outputs=[goals_list, progress_display, recent_display, goal_display]\n",
-    "            )\n",
-    "            \n",
-    "            message.submit(\n",
-    "                process_message,\n",
-    "                inputs=[message, chatbot],\n",
-    "                outputs=[chatbot, message]\n",
-    "            )\n",
-    "            \n",
-    "            audio_input.stream(\n",
-    "                process_audio,\n",
-    "                inputs=[audio_input],\n",
-    "                outputs=[message]\n",
-    "            )\n",
-    "            \n",
-    "            clear.click(\n",
-    "                clear_discussion,\n",
-    "                outputs=[chatbot, message]\n",
-    "            )\n",
-    "            \n",
-    "            end.click(\n",
-    "                end_discussion,\n",
-    "                inputs=[state],\n",
-    "                outputs=[goals_list, progress_display, recent_display, goal_display]\n",
-    "            )\n",
-    "            \n",
-    "            generate.click(\n",
-    "                generate_goals,\n",
-    "                inputs=[state],\n",
-    "                outputs=[goals_list, progress_display, recent_display, goal_display]\n",
-    "            )\n",
-    "            \n",
-    "            new_goal.submit(\n",
-    "                add_user_goal,\n",
-    "                inputs=[new_goal, state],\n",
-    "                outputs=[goals_list, progress_display, recent_display, goal_display]\n",
-    "            )\n",
-    "            \n",
-    "            goals_list.select(\n",
-    "                select_goal,\n",
-    "                inputs=[state],\n",
-    "                outputs=[goals_list, progress_display, recent_display, goal_display]\n",
-    "            )\n",
-    "            \n",
-    "            return interface\n",
-    "    \n",
-    "    def _update_displays(self, state: Dict) -> List:\n",
-    "        \"\"\"Update all display components.\"\"\"\n",
-    "        context = self.tutor.learning_context\n",
-    "        \n",
-    "        # Update goals list\n",
-    "        goals_data = []\n",
-    "        for goal in state[\"suggested_goals\"]:\n",
-    "            status = \"Active\" if (\n",
-    "                context.active_goal and \n",
-    "                context.active_goal.id == goal.id\n",
-    "            ) else \"Available\"\n",
-    "            \n",
-    "            goals_data.append([\n",
-    "                goal.smart_version,\n",
-    "                goal.category.value,\n",
-    "                status\n",
-    "            ])\n",
-    "        \n",
-    "        # Update progress display\n",
-    "        summary = context.get_category_summary()\n",
-    "        progress_data = [\n",
-    "            [cat, data[\"completed\"], data[\"total\"]]\n",
-    "            for cat, data in summary.items()\n",
-    "        ]\n",
-    "        \n",
-    "        # Update recent completions\n",
-    "        recent_data = []\n",
-    "        for cat, data in summary.items():\n",
-    "            for goal in data[\"recent\"]:\n",
-    "                recent_data.append([\n",
-    "                    goal[\"smart_version\"],\n",
-    "                    cat,\n",
-    "                    goal[\"completed_at\"]\n",
-    "                ])\n",
-    "        \n",
-    "        # Update active goal display\n",
-    "        goal_text = (\n",
-    "            f\"Current Goal: {context.active_goal.smart_version}\"\n",
-    "            if context.active_goal else\n",
-    "            \"No active learning goal\"\n",
-    "        )\n",
-    "        \n",
-    "        return [\n",
-    "            goals_data,\n",
-    "            progress_data,\n",
-    "            recent_data,\n",
-    "            goal_text\n",
-    "        ]\n",
-    "    def _update_discussion_status(self, state: Dict[str, Any]) -> str:\n",
-    "        \"\"\"Update discussion status display based on state.\n",
-    "        \n",
-    "        Args:\n",
-    "            state: Current interface state\n",
-    "            \n",
-    "        Returns:\n",
-    "            str: Status message to display\n",
-    "        \"\"\"\n",
-    "        try:\n",
-    "            if not state.get(\"discussion_active\"):\n",
-    "                return \"Start a new case discussion\"\n",
-    "                \n",
-    "            start = datetime.fromisoformat(state[\"discussion_start\"])\n",
-    "            duration = datetime.now() - start\n",
-    "            minutes = int(duration.total_seconds() / 60)\n",
-    "            \n",
-    "            return f\"Active discussion ({minutes} minutes)\"\n",
-    "            \n",
-    "        except Exception as e:\n",
-    "            logger.error(f\"Error updating status: {str(e)}\")\n",
-    "            return \"Discussion status unknown\""
+    "\n",
+    "            return interface"
    ]
   },
   {

wardbuddy/_modidx.py

@@ -64,10 +64,18 @@ d = { 'settings': { 'branch': 'main',
                                                                                                                             'wardbuddy/learning_interface.py'),
                                               'wardbuddy.learning_interface.LearningInterface._update_displays': ( 'learning_interface.html#learninginterface._update_displays',
                                                                                                                    'wardbuddy/learning_interface.py'),
+                                              'wardbuddy.learning_interface.LearningInterface.add_user_goal': ( 'learning_interface.html#learninginterface.add_user_goal',
+                                                                                                                'wardbuddy/learning_interface.py'),
                                               'wardbuddy.learning_interface.LearningInterface.create_interface': ( 'learning_interface.html#learninginterface.create_interface',
                                                                                                                    'wardbuddy/learning_interface.py'),
+                                              'wardbuddy.learning_interface.LearningInterface.end_discussion': ( 'learning_interface.html#learninginterface.end_discussion',
+                                                                                                                 'wardbuddy/learning_interface.py'),
+                                              'wardbuddy.learning_interface.LearningInterface.generate_goals': ( 'learning_interface.html#learninginterface.generate_goals',
+                                                                                                                 'wardbuddy/learning_interface.py'),
                                               'wardbuddy.learning_interface.LearningInterface.process_chat': ( 'learning_interface.html#learninginterface.process_chat',
                                                                                                                'wardbuddy/learning_interface.py'),
+                                              'wardbuddy.learning_interface.LearningInterface.select_goal': ( 'learning_interface.html#learninginterface.select_goal',
+                                                                                                              'wardbuddy/learning_interface.py'),
                                               'wardbuddy.learning_interface.create_css': ( 'learning_interface.html#create_css',
                                                                                            'wardbuddy/learning_interface.py')},
             'wardbuddy.main': { 'wardbuddy.main.launch': ('main.html#launch', 'wardbuddy/main.py'),

wardbuddy/learning_interface.py

@@ -89,7 +89,7 @@ class LearningInterface:
     Features:
     - Context selection
     - Goal management
-    - Case discussion
+    - Case discussion with streaming
     - Progress tracking
     """
     
@@ -98,13 +98,7 @@ class LearningInterface:
         context_path: Optional[Path] = None,
         model: str = "anthropic/claude-3.5-sonnet"
     ):
-        """
-        Initialize interface.
-        
-        Args:
-            context_path: Path for context persistence
-            model: OpenRouter model identifier
-        """
+        """Initialize interface."""
         self.tutor = ClinicalTutor(context_path, model)
         
         # Available options
@@ -119,7 +113,7 @@ class LearningInterface:
         self.settings = ["Clinic", "Wards", "ED"]
         
         logger.info("Learning interface initialized")
-
+    
     async def process_chat(
         self,
         message: str,
@@ -163,9 +157,116 @@ class LearningInterface:
                 history = []
             history.append([message, "I apologize, but I encountered an error. Please try again."])
             yield history, "", state
-    
+
+    def _update_discussion_status(self, state: Dict[str, Any]) -> str:
+        """Update discussion status display."""
+        try:
+            if not state.get("discussion_active"):
+                return "Start a new case discussion"
+                
+            start = datetime.fromisoformat(state["discussion_start"])
+            duration = datetime.now() - start
+            minutes = int(duration.total_seconds() / 60)
+            
+            return f"Active discussion ({minutes} minutes)"
+            
+        except Exception as e:
+            logger.error(f"Error updating status: {str(e)}")
+            return "Discussion status unknown"
+
+    async def generate_goals(self, state: Dict[str, Any]) -> List:
+        """Generate new goal suggestions."""
+        rotation = self.tutor.learning_context.rotation
+        if rotation.specialty and rotation.setting:
+            goals = await self.tutor.generate_smart_goals(
+                rotation.specialty,
+                rotation.setting
+            )
+            state["suggested_goals"] = goals
+            return self._update_displays(state)
+        return [[], [], [], "No active learning goal"]
+
+    async def add_user_goal(self, text: str, state: Dict[str, Any]) -> List:
+        """Add user-specified goal."""
+        if not text.strip():
+            return self._update_displays(state)
+            
+        rotation = self.tutor.learning_context.rotation
+        if rotation.specialty and rotation.setting:
+            goal = await self.tutor.generate_smart_goal(
+                text,
+                rotation.specialty,
+                rotation.setting
+            )
+            if goal:
+                if "suggested_goals" not in state:
+                    state["suggested_goals"] = []
+                state["suggested_goals"].append(goal)
+                return self._update_displays(state)
+        return self._update_displays(state)
+
+    def select_goal(self, evt: gr.SelectData, state: Dict[str, Any]) -> List:
+        """Set selected goal as active."""
+        if "suggested_goals" in state and evt.index[0] < len(state["suggested_goals"]):
+            goal = state["suggested_goals"][evt.index[0]]
+            self.tutor.learning_context.add_smart_goal(goal)
+            return self._update_displays(state)
+        return self._update_displays(state)
+
+    def end_discussion(self, state: Dict[str, Any]) -> List:
+        """End current discussion."""
+        self.tutor.end_discussion()
+        state["discussion_active"] = False
+        state["discussion_start"] = None
+        state["last_message"] = None
+        return self._update_displays(state)
+
+    def _update_displays(self, state: Dict[str, Any]) -> List:
+        """Update all display components."""
+        context = self.tutor.learning_context
+        
+        # Update goals list
+        goals_data = []
+        for goal in state.get("suggested_goals", []):
+            status = "Active" if (
+                context.active_goal and 
+                context.active_goal.id == goal.id
+            ) else "Available"
+            
+            goals_data.append([
+                goal.smart_version,
+                goal.category.value,
+                status
+            ])
+        
+        # Update progress display
+        summary = context.get_category_summary()
+        progress_data = [
+            [cat, data["completed"], data["total"]]
+            for cat, data in summary.items()
+        ]
+        
+        # Update recent completions
+        recent_data = []
+        for cat, data in summary.items():
+            for goal in data["recent"]:
+                recent_data.append([
+                    goal["smart_version"],
+                    cat,
+                    goal["completed_at"]
+                ])
+        
+        # Update active goal display
+        goal_text = (
+            f"Current Goal: {context.active_goal.smart_version}"
+            if context.active_goal else
+            "No active learning goal"
+        )
+        
+        return [goals_data, progress_data, recent_data, goal_text]
+
     def create_interface(self) -> gr.Blocks:
-        """Create Gradio interface with streaming support."""
+        """Create streaming-enabled interface."""
         with gr.Blocks(title="Clinical Learning Assistant", css=create_css()) as interface:
             # State management
             state = gr.State({
@@ -174,10 +275,10 @@ class LearningInterface:
                 "discussion_start": None,
                 "last_message": None
             })
-    
+
             # Header
             gr.Markdown("# Clinical Learning Assistant")
-    
+
             with gr.Row():
                 # Context selection
                 specialty = gr.Dropdown(
@@ -190,20 +291,20 @@ class LearningInterface:
                     label="Setting",
                     value=self.tutor.learning_context.rotation.setting or None
                 )
-    
+
             # Main content
             with gr.Row():
                 # Left: Discussion interface
                 with gr.Column(scale=2):
                     # Active goal display
                     goal_display = gr.Markdown(value="No active learning goal")
-    
+
                     # Discussion status
                     discussion_status = gr.Markdown(
                         value="Start a new case discussion",
                         elem_classes=["discussion-status"]
                     )
-    
+
                     # Chat interface
                     chatbot = gr.Chatbot(
                         height=400,
@@ -211,7 +312,7 @@ class LearningInterface:
                         type="messages",  # Use newer message format
                         elem_classes=["chat-window"]
                     )
-    
+
                     with gr.Row():
                         msg = gr.Textbox(
                             label="Present your case or ask questions",
@@ -223,21 +324,21 @@ class LearningInterface:
                             ),
                             lines=4
                         )
-    
+
                         audio_input = gr.Audio(
                             sources=["microphone"],
                             type="numpy",
                             label="Or speak your case",
                             streaming=True
                         )
-    
+
                     with gr.Row():
                         clear = gr.Button("Clear Discussion")
                         end = gr.Button(
                             "End Discussion & Review",
                             variant="primary"
                         )
-    
+
                 # Right: Progress & Goals
                 with gr.Column(scale=1):
                     with gr.Tab("Learning Goals"):
@@ -249,7 +350,7 @@ class LearningInterface:
                                 placeholder="What do you want to get better at?"
                             )
                             add_goal = gr.Button("Add Goal")
-    
+
                         # Goals list
                         goals_list = gr.DataFrame(
                             headers=["Goal", "Category", "Status"],
@@ -258,7 +359,7 @@ class LearningInterface:
                             interactive=True,
                             wrap=True
                         )
-    
+
                     with gr.Tab("Progress"):
                         # Category progress
                         progress_display = gr.DataFrame(
@@ -266,14 +367,14 @@ class LearningInterface:
                             value=[],
                             label="Progress by Category"
                         )
-    
+
                         # Recent completions
                         recent_display = gr.DataFrame(
                             headers=["Goal", "Category", "Completed"],
                             value=[],
                             label="Recently Completed"
                         )
-    
+
             # Event handlers
             async def update_context(spec: str, set: str, state: Dict) -> List:
                 """Update rotation context."""
@@ -284,14 +385,13 @@ class LearningInterface:
                         state["suggested_goals"] = goals
                     return self._update_displays(state)
                 return [[], [], [], "No active learning goal"]
-    
+
             def process_audio(audio: np.ndarray) -> str:
                 """Convert audio to text."""
                 if audio is None:
                     return ""
-                # Would integrate with speech-to-text here
                 return "Audio transcription would appear here"
-    
+
             def clear_discussion() -> Tuple[List, str, Dict]:
                 """Clear chat history."""
                 return [], "", {
@@ -300,20 +400,20 @@ class LearningInterface:
                     "discussion_start": None,
                     "last_message": None
                 }
-    
+
             # Wire up events
             specialty.change(
                 update_context,
                 inputs=[specialty, setting, state],
                 outputs=[goals_list, progress_display, recent_display, goal_display]
             )
-    
+
             setting.change(
                 update_context,
                 inputs=[specialty, setting, state],
                 outputs=[goals_list, progress_display, recent_display, goal_display]
             )
-    
+
             # Chat events with streaming
             msg.submit(
                 self.process_chat,
@@ -325,7 +425,7 @@ class LearningInterface:
                 inputs=[state],
                 outputs=[discussion_status]
             )
-    
+
             # Voice input handling
             audio_input.stream(
                 process_audio,
@@ -336,7 +436,7 @@ class LearningInterface:
                 inputs=[msg, chatbot, state],
                 outputs=[chatbot, msg, state]
             )
-    
+
             # Button handlers
             clear.click(
                 clear_discussion,
@@ -345,330 +445,30 @@ class LearningInterface:
                 lambda: "Start a new case discussion",
                 outputs=[discussion_status]
             )
-    
+
             end.click(
                 self.end_discussion,
                 inputs=[state],
                 outputs=[goals_list, progress_display, recent_display, goal_display]
             )
-    
+
             generate.click(
                 self.generate_goals,
                 inputs=[state],
                 outputs=[goals_list, progress_display, recent_display, goal_display]
             )
-    
+
             # Goal management
             add_goal.click(
                 self.add_user_goal,
                 inputs=[new_goal, state],
                 outputs=[goals_list, progress_display, recent_display, goal_display]
             )
-    
+
             goals_list.select(
                 self.select_goal,
                 inputs=[state],
                 outputs=[goals_list, progress_display, recent_display, goal_display]
             )
-    
-            return interface
-        
-            # Event handlers
-            async def update_context(self, spec: str, set: str, state: Dict) -> List:
-                """Update rotation context.
-                
-                Args:
-                    spec: Specialty
-                    set: Setting
-                    state: Interface state
-                    
-                Returns:
-                    list: Updated display data
-                """
-                try:
-                    if spec and set:
-                        self.tutor.learning_context.update_rotation(spec, set)
-                        
-                        # Initialize goals list if needed
-                        if not state.get("suggested_goals"):
-                            goals = await self.tutor.generate_smart_goals(spec, set)
-                            state["suggested_goals"] = goals
-                        
-                        # Return all display updates
-                        goals_data = []
-                        context = self.tutor.learning_context
-                        
-                        # Update goals list
-                        for goal in state.get("suggested_goals", []):
-                            status = "Active" if (
-                                context.active_goal and 
-                                context.active_goal.id == goal.id
-                            ) else "Available"
-                            
-                            goals_data.append([
-                                goal.smart_version,
-                                goal.category.value,
-                                status
-                            ])
-                        
-                        # Update progress display
-                        summary = context.get_category_summary()
-                        progress_data = [
-                            [cat, data["completed"], data["total"]]
-                            for cat, data in summary.items()
-                        ]
-                        
-                        # Update recent completions
-                        recent_data = []
-                        for cat, data in summary.items():
-                            for goal in data["recent"]:
-                                recent_data.append([
-                                    goal["smart_version"],
-                                    cat,
-                                    goal["completed_at"]
-                                ])
-                        
-                        # Update active goal display
-                        goal_text = (
-                            f"Current Goal: {context.active_goal.smart_version}"
-                            if context.active_goal else
-                            "No active learning goal"
-                        )
-                        
-                        return [
-                            goals_data,
-                            progress_data,
-                            recent_data,
-                            goal_text
-                        ]
-                        
-                    # Return empty displays if no context
-                    return [[], [], [], "No active learning goal"]
-                    
-                except Exception as e:
-                    logger.error(f"Error updating context: {str(e)}")
-                    return [[], [], [], "Error updating context"]
-            
-            async def process_message(msg, history):
-                """Process chat message."""
-                if not msg.strip():
-                    return history, ""
-                    
-                response = await self.tutor.discuss_case(msg)
-                history.append([msg, response])
-                return history, ""
-            
-            def process_audio(audio):
-                """Convert audio to text."""
-                # Would integrate with speech-to-text here
-                return "Audio transcription would appear here"
-            
-            async def generate_goals(self, state: Dict[str, Any]) -> List:
-                """Generate new goal suggestions.
-                
-                Args:
-                    state: Interface state
-                    
-                Returns:
-                    list: Updated display data
-                """
-                rotation = self.tutor.learning_context.rotation
-                if rotation.specialty and rotation.setting:
-                    goals = await self.tutor.generate_smart_goals(
-                        rotation.specialty,
-                        rotation.setting
-                    )
-                    state["suggested_goals"] = goals
-                    return self._update_displays(state)
-                return [[], [], [], "No active learning goal"]
-            
-            async def add_user_goal(self, text: str, state: Dict[str, Any]) -> List:
-                """Add user-specified goal.
-                
-                Args:
-                    text: User's goal text
-                    state: Interface state
-                    
-                Returns:
-                    list: Updated display data
-                """
-                if not text.strip():
-                    return self._update_displays(state)
-                    
-                rotation = self.tutor.learning_context.rotation
-                if rotation.specialty and rotation.setting:
-                    goal = await self.tutor.generate_smart_goal(
-                        text,
-                        rotation.specialty,
-                        rotation.setting
-                    )
-                    if goal:
-                        state["suggested_goals"].append(goal)
-                        return self._update_displays(state)
-                return self._update_displays(state)
-            
-            def select_goal(self, evt: gr.SelectData, state: Dict[str, Any]) -> List:
-                """Set selected goal as active.
-                
-                Args:
-                    evt: Selection event data
-                    state: Interface state
-                    
-                Returns:
-                    list: Updated display data
-                """
-                if evt.index[0] < len(state["suggested_goals"]):
-                    goal = state["suggested_goals"][evt.index[0]]
-                    self.tutor.learning_context.add_smart_goal(goal)
-                    return self._update_displays(state)
-                return self._update_displays(state)
-            
-            def end_discussion(self, state: Dict[str, Any]) -> List:
-                """End current discussion.
-                
-                Args:
-                    state: Interface state
-                    
-                Returns:
-                    list: Updated display data
-                """
-                if self.tutor.learning_context.active_goal:
-                    self.tutor.learning_context.complete_active_goal()
-                
-                self.tutor.end_discussion()
-                state["discussion_active"] = False
-                state["discussion_start"] = None
-                
-                return self._update_displays(state)      
-                
-            def clear_discussion():
-                """Clear discussion history."""
-                self.tutor.clear_discussion()
-                return [], ""
-            
-            # Wire up events
-            specialty.change(
-                update_context,
-                inputs=[specialty, setting, state],  # Add state to inputs
-                outputs=[goals_list, progress_display, recent_display, goal_display]
-            )
-            
-            setting.change(
-                update_context,
-                inputs=[specialty, setting, state],  # Add state to inputs
-                outputs=[goals_list, progress_display, recent_display, goal_display]
-            )
-            
-            message.submit(
-                process_message,
-                inputs=[message, chatbot],
-                outputs=[chatbot, message]
-            )
-            
-            audio_input.stream(
-                process_audio,
-                inputs=[audio_input],
-                outputs=[message]
-            )
-            
-            clear.click(
-                clear_discussion,
-                outputs=[chatbot, message]
-            )
-            
-            end.click(
-                end_discussion,
-                inputs=[state],
-                outputs=[goals_list, progress_display, recent_display, goal_display]
-            )
-            
-            generate.click(
-                generate_goals,
-                inputs=[state],
-                outputs=[goals_list, progress_display, recent_display, goal_display]
-            )
-            
-            new_goal.submit(
-                add_user_goal,
-                inputs=[new_goal, state],
-                outputs=[goals_list, progress_display, recent_display, goal_display]
-            )
-            
-            goals_list.select(
-                select_goal,
-                inputs=[state],
-                outputs=[goals_list, progress_display, recent_display, goal_display]
-            )
-            
+
             return interface
-    
-    def _update_displays(self, state: Dict) -> List:
-        """Update all display components."""
-        context = self.tutor.learning_context
-        
-        # Update goals list
-        goals_data = []
-        for goal in state["suggested_goals"]:
-            status = "Active" if (
-                context.active_goal and 
-                context.active_goal.id == goal.id
-            ) else "Available"
-            
-            goals_data.append([
-                goal.smart_version,
-                goal.category.value,
-                status
-            ])
-        
-        # Update progress display
-        summary = context.get_category_summary()
-        progress_data = [
-            [cat, data["completed"], data["total"]]
-            for cat, data in summary.items()
-        ]
-        
-        # Update recent completions
-        recent_data = []
-        for cat, data in summary.items():
-            for goal in data["recent"]:
-                recent_data.append([
-                    goal["smart_version"],
-                    cat,
-                    goal["completed_at"]
-                ])
-        
-        # Update active goal display
-        goal_text = (
-            f"Current Goal: {context.active_goal.smart_version}"
-            if context.active_goal else
-            "No active learning goal"
-        )
-        
-        return [
-            goals_data,
-            progress_data,
-            recent_data,
-            goal_text
-        ]
-    def _update_discussion_status(self, state: Dict[str, Any]) -> str:
-        """Update discussion status display based on state.
-        
-        Args:
-            state: Current interface state
-            
-        Returns:
-            str: Status message to display
-        """
-        try:
-            if not state.get("discussion_active"):
-                return "Start a new case discussion"
-                
-            start = datetime.fromisoformat(state["discussion_start"])
-            duration = datetime.now() - start
-            minutes = int(duration.total_seconds() / 60)
-            
-            return f"Active discussion ({minutes} minutes)"
-            
-        except Exception as e:
-            logger.error(f"Error updating status: {str(e)}")
-            return "Discussion status unknown"