Upload folder using huggingface_hub

app.py

@@ -5,11 +5,32 @@ from wardbuddy.learning_interface import LearningInterface
 # Load environment variables
 load_dotenv()
 
-# Check for API key
-if not os.getenv("OPENROUTER_API_KEY"):
-    raise ValueError("Please set OPENROUTER_API_KEY in your .env file")
+# Check required environment variables
+required_vars = ["OPENROUTER_API_KEY", "API_URL"]
+missing_vars = [var for var in required_vars if not os.getenv(var)]
+if missing_vars:
+    raise ValueError(f"Missing required environment variables: {', '.join(missing_vars)}")
 
-# Create and launch interface
-interface = LearningInterface()
+# Create interface
+interface = LearningInterface(
+    model="anthropic/claude-3.5-sonnet",
+    api_url=os.getenv("API_URL")
+)
+
+# Create app
 demo = interface.create_interface()
-demo.launch(server_name='0.0.0.0', server_port=7860, share=True)
+
+# Launch with appropriate settings
+if os.getenv("SPACE_ID"):  # Running on HF Spaces
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_api=False
+    )
+else:  # Local development
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True
+    )

nbs/02_learning_interface.ipynb

@@ -52,6 +52,17 @@
       "C:\\Users\\deepa\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\tqdm\\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
       "  from .autonotebook import tqdm as notebook_tqdm\n"
      ]
+    },
+    {
+     "ename": "ModuleNotFoundError",
+     "evalue": "No module named 'wardbuddy.auth'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
+      "Cell \u001b[1;32mIn[1], line 11\u001b[0m\n\u001b[0;32m      9\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mwardbuddy\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mclinical_tutor\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m ClinicalTutor\n\u001b[0;32m     10\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mwardbuddy\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mlearning_context\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m setup_logger, LearningCategory, SmartGoal\n\u001b[1;32m---> 11\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mwardbuddy\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mauth\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m AuthManager\n\u001b[0;32m     12\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mjson\u001b[39;00m\n\u001b[0;32m     14\u001b[0m logger \u001b[38;5;241m=\u001b[39m setup_logger(\u001b[38;5;18m__name__\u001b[39m)\n",
+      "\u001b[1;31mModuleNotFoundError\u001b[0m: No module named 'wardbuddy.auth'"
+     ]
     }
    ],
    "source": [
@@ -65,6 +76,7 @@
     "import pandas as pd\n",
     "from wardbuddy.clinical_tutor import ClinicalTutor\n",
     "from wardbuddy.learning_context import setup_logger, LearningCategory, SmartGoal\n",
+    "from wardbuddy.auth import AuthManager\n",
     "import json\n",
     "\n",
     "logger = setup_logger(__name__)"
@@ -87,7 +99,7 @@
    "source": [
     "#| export\n",
     "def create_css() -> str:\n",
-    "    \"\"\"Create custom CSS for interface styling.\"\"\"\n",
+    "    \"\"\"Create custom CSS for interface styling with auth and mobile support.\"\"\"\n",
     "    return \"\"\"\n",
     "    /* Base styles */\n",
     "    .gradio-container {\n",
@@ -96,14 +108,44 @@
     "        padding: 1rem !important;\n",
     "    }\n",
     "    \n",
-    "    /* Mobile-first approach */\n",
+    "    /* Auth container */\n",
+    "    .auth-container {\n",
+    "        max-width: 400px !important;\n",
+    "        margin: 2rem auto !important;\n",
+    "        padding: 2rem !important;\n",
+    "        background-color: #1e293b !important;\n",
+    "        border-radius: 0.5rem !important;\n",
+    "        border: 1px solid #334155 !important;\n",
+    "    }\n",
+    "    \n",
+    "    .auth-input input {\n",
+    "        background-color: #1e293b !important;\n",
+    "        border: 1px solid #334155 !important;\n",
+    "        color: #f1f5f9 !important;\n",
+    "        font-size: 1rem !important;\n",
+    "        padding: 0.75rem !important;\n",
+    "    }\n",
+    "    \n",
+    "    .auth-button {\n",
+    "        width: 100% !important;\n",
+    "        margin-top: 1rem !important;\n",
+    "        background-color: #2563eb !important;\n",
+    "        color: white !important;\n",
+    "    }\n",
+    "    \n",
+    "    /* Discussion elements */\n",
+    "    .discussion-status {\n",
+    "        color: #94a3b8;\n",
+    "        font-size: 0.9em;\n",
+    "        margin-bottom: 1rem;\n",
+    "    }\n",
+    "    \n",
     "    .chat-window {\n",
     "        background-color: #1e293b !important;\n",
     "        border: 1px solid #334155 !important;\n",
     "        border-radius: 0.5rem !important;\n",
-    "        height: calc(100vh - 300px) !important; /* Responsive height */\n",
+    "        height: calc(100vh - 300px) !important;\n",
     "        min-height: 300px !important;\n",
-    "        max-height: 500px !important; \n",
     "    }\n",
     "    \n",
     "    .chat-message {\n",
@@ -140,12 +182,32 @@
     "        background-color: #1d4ed8 !important;\n",
     "    }\n",
     "    \n",
+    "    /* Progress sections */\n",
+    "    .tab-nav {\n",
+    "        border-bottom: 1px solid #334155 !important;\n",
+    "    }\n",
+    "    \n",
+    "    .tab-nav button {\n",
+    "        background-color: transparent !important;\n",
+    "        color: #94a3b8 !important;\n",
+    "    }\n",
+    "    \n",
+    "    .tab-nav button.selected {\n",
+    "        color: #f1f5f9 !important;\n",
+    "        border-bottom: 2px solid #2563eb !important;\n",
+    "    }\n",
+    "    \n",
     "    /* Mobile optimizations */\n",
     "    @media (max-width: 768px) {\n",
     "        .gradio-container {\n",
     "            padding: 0.5rem !important;\n",
     "        }\n",
     "        \n",
+    "        .auth-container {\n",
+    "            margin: 1rem !important;\n",
+    "            padding: 1rem !important;\n",
+    "        }\n",
+    "        \n",
     "        .chat-window {\n",
     "            height: calc(100vh - 250px) !important;\n",
     "        }\n",
@@ -163,6 +225,11 @@
     "            width: 100% !important;\n",
     "            margin: 0.25rem 0 !important;\n",
     "        }\n",
+    "        \n",
+    "        .tab-nav button {\n",
+    "            padding: 0.5rem !important;\n",
+    "            font-size: 0.9rem !important;\n",
+    "        }\n",
     "    }\n",
     "    \"\"\""
    ]
@@ -201,11 +268,13 @@
     "    def __init__(\n",
     "        self,\n",
     "        context_path: Optional[Path] = None,\n",
-    "        model: str = \"anthropic/claude-3.5-sonnet\"\n",
+    "        model: str = \"anthropic/claude-3.5-sonnet\",\n",
+    "        api_url: Optional[str] = None\n",
     "    ):\n",
     "        \"\"\"Initialize interface.\"\"\"\n",
     "        self.tutor = ClinicalTutor(context_path, model)\n",
-    "        \n",
+    "        self.auth = AuthManager(api_url)\n",
+    "\n",
     "        # Available options\n",
     "        self.specialties = [\n",
     "            \"Internal Medicine\",\n",
@@ -218,7 +287,71 @@
     "        self.settings = [\"Clinic\", \"Wards\", \"ED\"]\n",
     "        \n",
     "        logger.info(\"Learning interface initialized\")\n",
+    "\n",
+    "    # Authentication Components\n",
+    "    def _create_auth_components(self) -> Tuple[gr.Group, gr.Group]:\n",
+    "        \"\"\"Create authentication interface components.\"\"\"\n",
+    "        with gr.Group() as auth_group:\n",
+    "            gr.Markdown(\"# Clinical Learning Assistant\")\n",
+    "            \n",
+    "            with gr.Tab(\"Login\"):\n",
+    "                login_email = gr.Textbox(\n",
+    "                    label=\"Email\",\n",
+    "                    placeholder=\"Enter your email\"\n",
+    "                )\n",
+    "                login_password = gr.Textbox(\n",
+    "                    label=\"Password\",\n",
+    "                    type=\"password\",\n",
+    "                    placeholder=\"Enter your password\"\n",
+    "                )\n",
+    "                login_button = gr.Button(\"Login\")\n",
+    "                login_message = gr.Markdown()\n",
+    "            \n",
+    "            with gr.Tab(\"Register\"):\n",
+    "                register_email = gr.Textbox(\n",
+    "                    label=\"Email\",\n",
+    "                    placeholder=\"Enter your email\"\n",
+    "                )\n",
+    "                register_password = gr.Textbox(\n",
+    "                    label=\"Password\",\n",
+    "                    type=\"password\",\n",
+    "                    placeholder=\"Choose a password\"\n",
+    "                )\n",
+    "                register_button = gr.Button(\"Register\")\n",
+    "                register_message = gr.Markdown()\n",
+    "        \n",
+    "        # Main interface (hidden until auth)\n",
+    "        main_group = gr.Group(visible=False)\n",
+    "        \n",
+    "        return auth_group, main_group, (\n",
+    "            login_email, login_password, login_button, login_message,\n",
+    "            register_email, register_password, register_button, register_message\n",
+    "        )\n",
+    "    \n",
+    "    def handle_login(\n",
+    "        self,\n",
+    "        email: str,\n",
+    "        password: str,\n",
+    "        state: Dict[str, Any]\n",
+    "    ) -> Tuple[str, gr.update, gr.update, Dict[str, Any]]:\n",
+    "        \"\"\"Handle user login.\"\"\"\n",
+    "        success, message = self.auth.login(email, password)\n",
+    "        if success:\n",
+    "            state[\"authenticated\"] = True\n",
+    "            return (\n",
+    "                \"Login successful! Redirecting...\",  # Success message\n",
+    "                gr.update(visible=False),  # Hide auth group\n",
+    "                gr.update(visible=True),  # Show main interface\n",
+    "                state\n",
+    "            )\n",
+    "        return message, gr.update(), gr.update(), state\n",
     "    \n",
+    "    def handle_register(self, email: str, password: str) -> str:\n",
+    "        \"\"\"Handle user registration.\"\"\"\n",
+    "        success, message = self.auth.register(email, password)\n",
+    "        return message\n",
+    "\n",
+    "    # Chat Processing\n",
     "    async def process_chat(\n",
     "        self,\n",
     "        message: str,\n",
@@ -226,7 +359,7 @@
     "        state: Dict[str, Any]\n",
     "    ) -> AsyncGenerator[Tuple[List[Dict[str, str]], str, Dict[str, Any]], None]:\n",
     "        \"\"\"\n",
-    "        Process chat messages with streaming and proper history management.\n",
+    "        Process chat messages with streaming, history management, and interaction logging.\n",
     "        \n",
     "        Args:\n",
     "            message: User input message\n",
@@ -246,6 +379,8 @@
     "                state[\"discussion_active\"] = True\n",
     "                state[\"discussion_start\"] = datetime.now().isoformat()\n",
     "                self.tutor.current_discussion = []  # Reset tutor's discussion history\n",
+    "                # Log discussion start\n",
+    "                self.auth.log_interaction(\"discussion_start\")\n",
     "            \n",
     "            # Initialize history if needed\n",
     "            if history is None:\n",
@@ -257,6 +392,9 @@
     "                \"content\": message\n",
     "            })\n",
     "            \n",
+    "            # Log user message\n",
+    "            self.auth.log_interaction(\"user_message\", message)\n",
+    "            \n",
     "            # Add initial assistant message\n",
     "            history.append({\n",
     "                \"role\": \"assistant\",\n",
@@ -285,6 +423,9 @@
     "                history[-1][\"content\"] = current_response\n",
     "                yield history, \"\", state\n",
     "            \n",
+    "            # Log assistant response\n",
+    "            self.auth.log_interaction(\"assistant_response\", current_response)\n",
+    "            \n",
     "            # Update state and discussion history\n",
     "            state[\"last_message\"] = datetime.now().isoformat()\n",
     "            \n",
@@ -299,14 +440,17 @@
     "            \n",
     "        except Exception as e:\n",
     "            logger.error(f\"Error in chat: {str(e)}\")\n",
+    "            # Log error\n",
+    "            self.auth.log_interaction(\"error\", str(e))\n",
+    "            \n",
     "            if history is None:\n",
     "                history = []\n",
     "            history.extend([\n",
     "                {\"role\": \"user\", \"content\": message},\n",
     "                {\"role\": \"assistant\", \"content\": \"I apologize, but I encountered an error. Please try again.\"}\n",
     "            ])\n",
-    "            yield history, \"\", state\n",
-    "    \n",
+    "            yield history, \"\", state    \n",
+    "            \n",
     "    def _update_discussion_status(self, state: Dict[str, Any]) -> str:\n",
     "        \"\"\"Update discussion status display.\"\"\"\n",
     "        try:\n",
@@ -363,7 +507,14 @@
     "        return self._update_displays(state)\n",
     "\n",
     "    def end_discussion(self, state: Dict[str, Any]) -> List:\n",
-    "        \"\"\"End current discussion and analyze results.\"\"\"\n",
+    "        \"\"\"End current discussion with analytics.\"\"\"\n",
+    "        if state.get(\"discussion_active\"):\n",
+    "            self.auth.log_interaction(\"discussion_end\", json.dumps({\n",
+    "                \"duration\": (\n",
+    "                    datetime.now() - \n",
+    "                    datetime.fromisoformat(state[\"discussion_start\"])\n",
+    "                ).total_seconds()\n",
+    "            }))\n",
     "        self.tutor.end_discussion()\n",
     "        state[\"discussion_active\"] = False\n",
     "        state[\"discussion_start\"] = None\n",
@@ -416,213 +567,260 @@
     "        return [goals_data, progress_data, recent_data, goal_text]\n",
     "\n",
     "    def create_interface(self) -> gr.Blocks:\n",
-    "        \"\"\"Create streaming-enabled interface.\"\"\"\n",
+    "        \"\"\"Create streaming-enabled interface with authentication and all features.\"\"\"\n",
     "        with gr.Blocks(title=\"Clinical Learning Assistant\", css=create_css()) as interface:\n",
     "            # State management\n",
     "            state = gr.State({\n",
     "                \"discussion_active\": False,\n",
     "                \"suggested_goals\": [],\n",
     "                \"discussion_start\": None,\n",
-    "                \"last_message\": None\n",
+    "                \"last_message\": None,\n",
+    "                \"authenticated\": False\n",
     "            })\n",
-    "\n",
-    "            # Header\n",
-    "            gr.Markdown(\"# Clinical Learning Assistant\")\n",
-    "\n",
-    "            with gr.Row():\n",
-    "                # Context selection\n",
-    "                specialty = gr.Dropdown(\n",
-    "                    choices=self.specialties,\n",
-    "                    label=\"Specialty\",\n",
-    "                    value=self.tutor.learning_context.rotation.specialty or None\n",
-    "                )\n",
-    "                setting = gr.Dropdown(\n",
-    "                    choices=self.settings,\n",
-    "                    label=\"Setting\",\n",
-    "                    value=self.tutor.learning_context.rotation.setting or None\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",
-    "                    # Discussion status\n",
-    "                    discussion_status = gr.Markdown(\n",
-    "                        value=\"Start a new case discussion\",\n",
-    "                        elem_classes=[\"discussion-status\"]\n",
-    "                    )\n",
-    "\n",
-    "                    # Chat interface\n",
-    "                    chatbot = gr.Chatbot(\n",
-    "                        height=400,\n",
-    "                        show_label=False,\n",
-    "                        type=\"messages\",  # Use newer message format\n",
-    "                        elem_classes=[\"chat-window\"]\n",
-    "                    )\n",
-    "\n",
-    "                    with gr.Row():\n",
-    "                        msg = gr.Textbox(\n",
-    "                            label=\"Present your case or ask questions\",\n",
-    "                            placeholder=(\n",
-    "                                \"Present your case as you would to your supervisor:\\n\"\n",
-    "                                \"- Start with the chief complaint\\n\"\n",
-    "                                \"- Include relevant history and findings\\n\"\n",
-    "                                \"- Share your assessment and plan\"\n",
-    "                            ),\n",
-    "                            lines=4\n",
+    "            \n",
+    "            # Authentication interface\n",
+    "            with gr.Box(elem_classes=[\"auth-container\"]) as auth_group:\n",
+    "                gr.Markdown(\"# Clinical Learning Assistant\")\n",
+    "                \n",
+    "                with gr.Tabs() as auth_tabs:\n",
+    "                    with gr.Tab(\"Login\"):\n",
+    "                        login_email = gr.Textbox(\n",
+    "                            label=\"Email\",\n",
+    "                            placeholder=\"Enter your email\",\n",
+    "                            elem_classes=[\"auth-input\"]\n",
     "                        )\n",
-    "\n",
-    "                        audio_input = gr.Audio(\n",
-    "                            sources=[\"microphone\"],\n",
-    "                            type=\"numpy\",\n",
-    "                            label=\"Or speak your case\",\n",
-    "                            streaming=True\n",
+    "                        login_password = gr.Textbox(\n",
+    "                            label=\"Password\",\n",
+    "                            type=\"password\",\n",
+    "                            placeholder=\"Enter your password\",\n",
+    "                            elem_classes=[\"auth-input\"]\n",
     "                        )\n",
-    "\n",
-    "                    with gr.Row():\n",
-    "                        clear = gr.Button(\"Clear Discussion\")\n",
-    "                        end = gr.Button(\n",
-    "                            \"End Discussion & Review\",\n",
-    "                            variant=\"primary\"\n",
+    "                        login_button = gr.Button(\n",
+    "                            \"Login\",\n",
+    "                            variant=\"primary\",\n",
+    "                            elem_classes=[\"auth-button\"]\n",
     "                        )\n",
-    "\n",
-    "                # Right: Progress & Goals\n",
-    "                with gr.Column(scale=1):\n",
-    "                    with gr.Tab(\"Learning Goals\"):\n",
-    "                        # Goal selection/generation\n",
-    "                        with gr.Row():\n",
-    "                            generate = gr.Button(\"Generate New Goals\")\n",
-    "                            new_goal = gr.Textbox(\n",
-    "                                label=\"Or enter your own goal\",\n",
-    "                                placeholder=\"What do you want to get better at?\"\n",
-    "                            )\n",
-    "                            add_goal = gr.Button(\"Add Goal\")\n",
-    "\n",
-    "                        # Goals list\n",
-    "                        goals_list = gr.DataFrame(\n",
-    "                            headers=[\"Goal\", \"Category\", \"Status\"],\n",
-    "                            value=[],\n",
-    "                            label=\"Available Goals\",\n",
-    "                            interactive=True,\n",
-    "                            wrap=True\n",
+    "                        login_message = gr.Markdown()\n",
+    "                    \n",
+    "                    with gr.Tab(\"Register\"):\n",
+    "                        register_email = gr.Textbox(\n",
+    "                            label=\"Email\",\n",
+    "                            placeholder=\"Enter your email\",\n",
+    "                            elem_classes=[\"auth-input\"]\n",
     "                        )\n",
-    "\n",
-    "                    with gr.Tab(\"Progress\"):\n",
-    "                        # Category progress\n",
-    "                        progress_display = gr.DataFrame(\n",
-    "                            headers=[\"Category\", \"Completed\", \"Total\"],\n",
-    "                            value=[],\n",
-    "                            label=\"Progress by Category\"\n",
+    "                        register_password = gr.Textbox(\n",
+    "                            label=\"Password\",\n",
+    "                            type=\"password\",\n",
+    "                            placeholder=\"Choose a password\",\n",
+    "                            elem_classes=[\"auth-input\"]\n",
     "                        )\n",
-    "\n",
-    "                        # Recent completions\n",
-    "                        recent_display = gr.DataFrame(\n",
-    "                            headers=[\"Goal\", \"Category\", \"Completed\"],\n",
-    "                            value=[],\n",
-    "                            label=\"Recently Completed\"\n",
+    "                        register_button = gr.Button(\n",
+    "                            \"Register\",\n",
+    "                            variant=\"primary\",\n",
+    "                            elem_classes=[\"auth-button\"]\n",
     "                        )\n",
-    "\n",
-    "            # Event handlers\n",
-    "            async def update_context(spec: str, set: str, state: Dict) -> List:\n",
-    "                \"\"\"Update rotation context.\"\"\"\n",
-    "                if spec and set:\n",
-    "                    self.tutor.learning_context.update_rotation(spec, set)\n",
-    "                    if not state.get(\"suggested_goals\"):\n",
-    "                        goals = await self.tutor.generate_smart_goals(spec, set)\n",
-    "                        state[\"suggested_goals\"] = goals\n",
-    "                    return self._update_displays(state)\n",
-    "                return [[], [], [], \"No active learning goal\"]\n",
-    "\n",
-    "            def clear_discussion() -> Tuple[List, str, Dict]:\n",
-    "                \"\"\"Clear chat history.\"\"\"\n",
-    "                self.tutor.current_discussion = []  # Clear tutor's discussion history\n",
-    "                return [], \"\", {\n",
-    "                    \"discussion_active\": False,\n",
-    "                    \"suggested_goals\": [],\n",
-    "                    \"discussion_start\": None,\n",
-    "                    \"last_message\": None\n",
-    "                }\n",
+    "                        register_message = gr.Markdown()\n",
     "            \n",
-    "            def process_audio(audio: np.ndarray) -> str:\n",
-    "                \"\"\"Convert audio to text.\"\"\"\n",
-    "                if audio is None:\n",
-    "                    return \"\"\n",
-    "                # Add your audio processing logic here\n",
-    "                return \"Audio transcription would appear here\"\n",
+    "            # Main interface (initially hidden)\n",
+    "            with gr.Group(visible=False) as main_group:\n",
+    "                with gr.Row():\n",
+    "                    # Context selection\n",
+    "                    specialty = gr.Dropdown(\n",
+    "                        choices=self.specialties,\n",
+    "                        label=\"Specialty\",\n",
+    "                        value=self.tutor.learning_context.rotation.specialty or None\n",
+    "                    )\n",
+    "                    setting = gr.Dropdown(\n",
+    "                        choices=self.settings,\n",
+    "                        label=\"Setting\",\n",
+    "                        value=self.tutor.learning_context.rotation.setting or None\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",
+    "                        # Discussion status\n",
+    "                        discussion_status = gr.Markdown(\n",
+    "                            value=\"Start a new case discussion\",\n",
+    "                            elem_classes=[\"discussion-status\"]\n",
+    "                        )\n",
+    "    \n",
+    "                        # Chat interface\n",
+    "                        chatbot = gr.Chatbot(\n",
+    "                            height=400,\n",
+    "                            show_label=False,\n",
+    "                            type=\"messages\",  # Use newer message format\n",
+    "                            elem_classes=[\"chat-window\"]\n",
+    "                        )\n",
+    "    \n",
+    "                        with gr.Row():\n",
+    "                            msg = gr.Textbox(\n",
+    "                                label=\"Present your case or ask questions\",\n",
+    "                                placeholder=(\n",
+    "                                    \"Present your case as you would to your supervisor:\\n\"\n",
+    "                                    \"- Start with the chief complaint\\n\"\n",
+    "                                    \"- Include relevant history and findings\\n\"\n",
+    "                                    \"- Share your assessment and plan\"\n",
+    "                                ),\n",
+    "                                lines=4\n",
+    "                            )\n",
+    "                            audio_input = gr.Audio(\n",
+    "                                sources=[\"microphone\"],\n",
+    "                                type=\"numpy\",\n",
+    "                                label=\"Or speak your case\",\n",
+    "                                streaming=True\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",
+    "                    # Right: Progress & Goals\n",
+    "                    with gr.Column(scale=1):\n",
+    "                        with gr.Tab(\"Learning Goals\"):\n",
+    "                            with gr.Row():\n",
+    "                                generate = gr.Button(\"Generate New Goals\")\n",
+    "                                new_goal = gr.Textbox(\n",
+    "                                    label=\"Or enter your own goal\",\n",
+    "                                    placeholder=\"What do you want to get better at?\"\n",
+    "                                )\n",
+    "                                add_goal = gr.Button(\"Add Goal\")\n",
+    "    \n",
+    "                            goals_list = gr.DataFrame(\n",
+    "                                headers=[\"Goal\", \"Category\", \"Status\"],\n",
+    "                                value=[],\n",
+    "                                label=\"Available Goals\",\n",
+    "                                interactive=True,\n",
+    "                                wrap=True\n",
+    "                            )\n",
+    "    \n",
+    "                        with gr.Tab(\"Progress\"):\n",
+    "                            progress_display = gr.DataFrame(\n",
+    "                                headers=[\"Category\", \"Completed\", \"Total\"],\n",
+    "                                value=[],\n",
+    "                                label=\"Progress by Category\"\n",
+    "                            )\n",
+    "    \n",
+    "                            recent_display = gr.DataFrame(\n",
+    "                                headers=[\"Goal\", \"Category\", \"Completed\"],\n",
+    "                                value=[],\n",
+    "                                label=\"Recently Completed\"\n",
+    "                            )\n",
+    "    \n",
+    "                # Wire up auth events\n",
+    "                login_button.click(\n",
+    "                    self.handle_login,\n",
+    "                    inputs=[login_email, login_password, state],\n",
+    "                    outputs=[login_message, auth_group, main_group, state]\n",
+    "                ).success(\n",
+    "                    lambda: None,  # Clear login form\n",
+    "                    None,\n",
+    "                    [login_email, login_password]\n",
+    "                )\n",
+    "    \n",
+    "                register_button.click(\n",
+    "                    self.handle_register,\n",
+    "                    inputs=[register_email, register_password],\n",
+    "                    outputs=register_message\n",
+    "                )\n",
+    "    \n",
+    "                # Define helper functions\n",
+    "                def clear_discussion() -> Tuple[List, str, Dict]:\n",
+    "                    \"\"\"Clear chat history.\"\"\"\n",
+    "                    self.tutor.current_discussion = []  # Clear tutor's discussion history\n",
+    "                    return [], \"\", {\n",
+    "                        \"discussion_active\": False,\n",
+    "                        \"suggested_goals\": [],\n",
+    "                        \"discussion_start\": None,\n",
+    "                        \"last_message\": None\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",
-    "            setting.change(\n",
-    "                update_context,\n",
-    "                inputs=[specialty, setting, state],\n",
-    "                outputs=[goals_list, progress_display, recent_display, goal_display]\n",
-    "            )\n",
-    "\n",
-    "            # Chat events with streaming\n",
-    "            msg.submit(\n",
-    "                self.process_chat,\n",
-    "                inputs=[msg, chatbot, state],\n",
-    "                outputs=[chatbot, msg, state],\n",
-    "                queue=True  # Important for streaming\n",
-    "            ).then(\n",
-    "                self._update_discussion_status,\n",
-    "                inputs=[state],\n",
-    "                outputs=[discussion_status]\n",
-    "            )\n",
-    "\n",
-    "            # Voice input handling\n",
-    "            audio_input.stream(\n",
-    "                process_audio,\n",
-    "                inputs=[audio_input],\n",
-    "                outputs=[msg]\n",
-    "            ).then(\n",
-    "                self.process_chat,\n",
-    "                inputs=[msg, chatbot, state],\n",
-    "                outputs=[chatbot, msg, state]\n",
-    "            )\n",
-    "\n",
-    "            # Button handlers\n",
-    "            clear.click(\n",
-    "                clear_discussion,\n",
-    "                outputs=[chatbot, msg, state]\n",
-    "            ).then(\n",
-    "                lambda: \"Start a new case discussion\",\n",
-    "                outputs=[discussion_status]\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",
-    "            generate.click(\n",
-    "                self.generate_goals,\n",
-    "                inputs=[state],\n",
-    "                outputs=[goals_list, progress_display, recent_display, goal_display]\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",
-    "            goals_list.select(\n",
-    "                self.select_goal,\n",
-    "                inputs=[state],\n",
-    "                outputs=[goals_list, progress_display, recent_display, goal_display]\n",
-    "            )\n",
-    "\n",
+    "                def process_audio(audio: np.ndarray) -> str:\n",
+    "                    \"\"\"Convert audio to text.\"\"\"\n",
+    "                    if audio is None:\n",
+    "                        return \"\"\n",
+    "                    # Add your audio processing logic here\n",
+    "                    return \"Audio transcription would appear here\"\n",
+    "    \n",
+    "                # Wire up main interface events with tracking\n",
+    "                specialty.change(\n",
+    "                    fn=self.update_context,\n",
+    "                    inputs=[specialty, setting, state],\n",
+    "                    outputs=[goals_list, progress_display, recent_display, goal_display],\n",
+    "                    api_name=False  # Important for async functions\n",
+    "                )\n",
+    "    \n",
+    "                setting.change(\n",
+    "                    fn=self.update_context,\n",
+    "                    inputs=[specialty, setting, state],\n",
+    "                    outputs=[goals_list, progress_display, recent_display, goal_display],\n",
+    "                    api_name=False  # Important for async functions\n",
+    "                )\n",
+    "    \n",
+    "                # Chat events with streaming\n",
+    "                msg.submit(\n",
+    "                    self.process_chat,\n",
+    "                    inputs=[msg, chatbot, state],\n",
+    "                    outputs=[chatbot, msg, state],\n",
+    "                    queue=True  # Important for streaming\n",
+    "                ).then(\n",
+    "                    self._update_discussion_status,\n",
+    "                    inputs=[state],\n",
+    "                    outputs=[discussion_status]\n",
+    "                )\n",
+    "    \n",
+    "                # Voice input handling\n",
+    "                audio_input.stream(\n",
+    "                    process_audio,\n",
+    "                    inputs=[audio_input],\n",
+    "                    outputs=[msg]\n",
+    "                ).then(\n",
+    "                    self.process_chat,\n",
+    "                    inputs=[msg, chatbot, state],\n",
+    "                    outputs=[chatbot, msg, state]\n",
+    "                )\n",
+    "    \n",
+    "                # Button handlers\n",
+    "                clear.click(\n",
+    "                    clear_discussion,\n",
+    "                    outputs=[chatbot, msg, state]\n",
+    "                ).then(\n",
+    "                    lambda: \"Start a new case discussion\",\n",
+    "                    outputs=[discussion_status]\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",
+    "                generate.click(\n",
+    "                    self.generate_goals,\n",
+    "                    inputs=[state],\n",
+    "                    outputs=[goals_list, progress_display, recent_display, goal_display]\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",
+    "                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"
    ]
   },

nbs/04_auth.ipynb

@@ -0,0 +1,223 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7a034d30-7f66-4665-993c-8a0f1ea15dbe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| default_exp auth"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "38a7ad92-86f4-4614-a795-2bed5194f8e3",
+   "metadata": {},
+   "source": [
+    "# User authentication and session management"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d5379c12-23d7-4cc5-9353-b773c643e111",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| hide\n",
+    "from nbdev.showdoc import *\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6e5fadd3-8fb0-4ff2-834b-c861e32f6eed",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export\n",
+    "from typing import Optional, Dict, Tuple\n",
+    "import requests\n",
+    "from datetime import datetime\n",
+    "import os\n",
+    "from pathlib import Path\n",
+    "import logging\n",
+    "from wardbuddy.utils import setup_logger\n",
+    "\n",
+    "logger = setup_logger(__name__)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "841c79b1-1301-4165-a44d-5193cd18e454",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export\n",
+    "class AuthManager:\n",
+    "    \"\"\"Manages user authentication and session tracking.\"\"\"\n",
+    "    \n",
+    "    def __init__(self, api_url: Optional[str] = None):\n",
+    "        \"\"\"Initialize auth manager.\"\"\"\n",
+    "        self.api_url = api_url or os.getenv(\"API_URL\")\n",
+    "        if not self.api_url:\n",
+    "            raise ValueError(\"API_URL must be provided or set in environment\")\n",
+    "            \n",
+    "        self.token: Optional[str] = None\n",
+    "        self.session_id: Optional[int] = None\n",
+    "        \n",
+    "        logger.info(f\"Auth manager initialized with API: {self.api_url}\")\n",
+    "    \n",
+    "    def login(self, email: str, password: str) -> Tuple[bool, str]:\n",
+    "        \"\"\"Log in user and get access token.\"\"\"\n",
+    "        try:\n",
+    "            response = requests.post(\n",
+    "                f\"{self.api_url}/token\",\n",
+    "                data={\"username\": email, \"password\": password}\n",
+    "            )\n",
+    "            \n",
+    "            if response.status_code == 200:\n",
+    "                self.token = response.json()[\"access_token\"]\n",
+    "                return True, \"\"\n",
+    "            return False, response.json().get(\"detail\", \"Login failed\")\n",
+    "            \n",
+    "        except Exception as e:\n",
+    "            logger.error(f\"Login error: {str(e)}\")\n",
+    "            return False, f\"Error during login: {str(e)}\"\n",
+    "    \n",
+    "    def register(self, email: str, password: str) -> Tuple[bool, str]:\n",
+    "        \"\"\"Register new user.\"\"\"\n",
+    "        try:\n",
+    "            response = requests.post(\n",
+    "                f\"{self.api_url}/register\",\n",
+    "                json={\"email\": email, \"password\": password}\n",
+    "            )\n",
+    "            \n",
+    "            if response.status_code == 200:\n",
+    "                return True, \"Registration successful\"\n",
+    "            return False, response.json().get(\"detail\", \"Registration failed\")\n",
+    "            \n",
+    "        except Exception as e:\n",
+    "            logger.error(f\"Registration error: {str(e)}\")\n",
+    "            return False, f\"Error during registration: {str(e)}\"\n",
+    "    \n",
+    "    def start_session(self, specialty: str, setting: str) -> Optional[int]:\n",
+    "        \"\"\"Start new learning session.\"\"\"\n",
+    "        if not self.token:\n",
+    "            return None\n",
+    "            \n",
+    "        try:\n",
+    "            response = requests.post(\n",
+    "                f\"{self.api_url}/sessions\",\n",
+    "                json={\"specialty\": specialty, \"setting\": setting},\n",
+    "                headers={\"Authorization\": f\"Bearer {self.token}\"}\n",
+    "            )\n",
+    "            \n",
+    "            if response.status_code == 200:\n",
+    "                self.session_id = response.json()[\"session_id\"]\n",
+    "                return self.session_id\n",
+    "                \n",
+    "        except Exception as e:\n",
+    "            logger.error(f\"Session start error: {str(e)}\")\n",
+    "        return None\n",
+    "    \n",
+    "    def log_interaction(self, interaction_type: str, content: Optional[str] = None) -> bool:\n",
+    "        \"\"\"Log user interaction.\"\"\"\n",
+    "        if not self.token or not self.session_id:\n",
+    "            return False\n",
+    "            \n",
+    "        try:\n",
+    "            response = requests.post(\n",
+    "                f\"{self.api_url}/interactions\",\n",
+    "                params={\"session_id\": self.session_id},\n",
+    "                json={\n",
+    "                    \"interaction_type\": interaction_type,\n",
+    "                    \"content\": content\n",
+    "                },\n",
+    "                headers={\"Authorization\": f\"Bearer {self.token}\"}\n",
+    "            )\n",
+    "            \n",
+    "            return response.status_code == 200\n",
+    "            \n",
+    "        except Exception as e:\n",
+    "            logger.error(f\"Interaction logging error: {str(e)}\")\n",
+    "            return False"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ad32e0c8-4575-4af4-b65f-259752f1c461",
+   "metadata": {},
+   "source": [
+    "# Tests"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1f4331c1-e547-4c26-95e2-602224454fb5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Skipping tests: No API_URL set\n"
+     ]
+    }
+   ],
+   "source": [
+    "#| hide\n",
+    "def test_auth_manager():\n",
+    "    \"\"\"Test auth manager functionality.\"\"\"\n",
+    "    # Skip if no API URL\n",
+    "    if not os.getenv(\"API_URL\"):\n",
+    "        print(\"Skipping tests: No API_URL set\")\n",
+    "        return\n",
+    "        \n",
+    "    auth = AuthManager()\n",
+    "    \n",
+    "    # Test registration\n",
+    "    success, msg = auth.register(\"test@example.com\", \"testpass123\")\n",
+    "    assert success or \"already exists\" in msg.lower()\n",
+    "    \n",
+    "    # Test login\n",
+    "    success, msg = auth.login(\"test@example.com\", \"testpass123\")\n",
+    "    assert success\n",
+    "    assert auth.token is not None\n",
+    "    \n",
+    "    # Test session\n",
+    "    session_id = auth.start_session(\"Internal Medicine\", \"Wards\")\n",
+    "    assert session_id is not None\n",
+    "    \n",
+    "    # Test interaction logging\n",
+    "    success = auth.log_interaction(\"test_interaction\", \"test content\")\n",
+    "    assert success\n",
+    "    \n",
+    "    print(\"Auth manager tests passed!\")\n",
+    "\n",
+    "if __name__ == \"__main__\":\n",
+    "    test_auth_manager()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2e037f7c-afa8-4109-b34b-2975cdd4f4f1",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "python3",
+   "language": "python",
+   "name": "python3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

wardbuddy/_modidx.py

@@ -5,7 +5,14 @@ d = { 'settings': { 'branch': 'main',
                 'doc_host': 'https://Dyadd.github.io',
                 'git_url': 'https://github.com/Dyadd/wardbuddy',
                 'lib_path': 'wardbuddy'},
-  'syms': { 'wardbuddy.clinical_tutor': { 'wardbuddy.clinical_tutor.ClinicalTutor': ( 'clinical_tutor.html#clinicaltutor',
+  'syms': { 'wardbuddy.auth': { 'wardbuddy.auth.AuthManager': ('auth.html#authmanager', 'wardbuddy/auth.py'),
+                                'wardbuddy.auth.AuthManager.__init__': ('auth.html#authmanager.__init__', 'wardbuddy/auth.py'),
+                                'wardbuddy.auth.AuthManager.log_interaction': ( 'auth.html#authmanager.log_interaction',
+                                                                                'wardbuddy/auth.py'),
+                                'wardbuddy.auth.AuthManager.login': ('auth.html#authmanager.login', 'wardbuddy/auth.py'),
+                                'wardbuddy.auth.AuthManager.register': ('auth.html#authmanager.register', 'wardbuddy/auth.py'),
+                                'wardbuddy.auth.AuthManager.start_session': ('auth.html#authmanager.start_session', 'wardbuddy/auth.py')},
+            'wardbuddy.clinical_tutor': { 'wardbuddy.clinical_tutor.ClinicalTutor': ( 'clinical_tutor.html#clinicaltutor',
                                                                                       'wardbuddy/clinical_tutor.py'),
                                           'wardbuddy.clinical_tutor.ClinicalTutor.__init__': ( 'clinical_tutor.html#clinicaltutor.__init__',
                                                                                                'wardbuddy/clinical_tutor.py'),
@@ -62,6 +69,8 @@ d = { 'settings': { 'branch': 'main',
                                                                                                   'wardbuddy/learning_interface.py'),
                                               'wardbuddy.learning_interface.LearningInterface.__init__': ( 'learning_interface.html#learninginterface.__init__',
                                                                                                            'wardbuddy/learning_interface.py'),
+                                              'wardbuddy.learning_interface.LearningInterface._create_auth_components': ( 'learning_interface.html#learninginterface._create_auth_components',
+                                                                                                                          'wardbuddy/learning_interface.py'),
                                               'wardbuddy.learning_interface.LearningInterface._update_discussion_status': ( 'learning_interface.html#learninginterface._update_discussion_status',
                                                                                                                             'wardbuddy/learning_interface.py'),
                                               'wardbuddy.learning_interface.LearningInterface._update_displays': ( 'learning_interface.html#learninginterface._update_displays',
@@ -74,6 +83,10 @@ d = { 'settings': { 'branch': 'main',
                                                                                                                  'wardbuddy/learning_interface.py'),
                                               'wardbuddy.learning_interface.LearningInterface.generate_goals': ( 'learning_interface.html#learninginterface.generate_goals',
                                                                                                                  'wardbuddy/learning_interface.py'),
+                                              'wardbuddy.learning_interface.LearningInterface.handle_login': ( 'learning_interface.html#learninginterface.handle_login',
+                                                                                                               'wardbuddy/learning_interface.py'),
+                                              'wardbuddy.learning_interface.LearningInterface.handle_register': ( 'learning_interface.html#learninginterface.handle_register',
+                                                                                                                  '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/auth.py

@@ -0,0 +1,105 @@
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/04_auth.ipynb.
+
+# %% auto 0
+__all__ = ['logger', 'AuthManager']
+
+# %% ../nbs/04_auth.ipynb 3
+from typing import Optional, Dict, Tuple
+import requests
+from datetime import datetime
+import os
+from pathlib import Path
+import logging
+from .utils import setup_logger
+
+logger = setup_logger(__name__)
+
+# %% ../nbs/04_auth.ipynb 4
+class AuthManager:
+    """Manages user authentication and session tracking."""
+    
+    def __init__(self, api_url: Optional[str] = None):
+        """Initialize auth manager."""
+        self.api_url = api_url or os.getenv("API_URL")
+        if not self.api_url:
+            raise ValueError("API_URL must be provided or set in environment")
+            
+        self.token: Optional[str] = None
+        self.session_id: Optional[int] = None
+        
+        logger.info(f"Auth manager initialized with API: {self.api_url}")
+    
+    def login(self, email: str, password: str) -> Tuple[bool, str]:
+        """Log in user and get access token."""
+        try:
+            response = requests.post(
+                f"{self.api_url}/token",
+                data={"username": email, "password": password}
+            )
+            
+            if response.status_code == 200:
+                self.token = response.json()["access_token"]
+                return True, ""
+            return False, response.json().get("detail", "Login failed")
+            
+        except Exception as e:
+            logger.error(f"Login error: {str(e)}")
+            return False, f"Error during login: {str(e)}"
+    
+    def register(self, email: str, password: str) -> Tuple[bool, str]:
+        """Register new user."""
+        try:
+            response = requests.post(
+                f"{self.api_url}/register",
+                json={"email": email, "password": password}
+            )
+            
+            if response.status_code == 200:
+                return True, "Registration successful"
+            return False, response.json().get("detail", "Registration failed")
+            
+        except Exception as e:
+            logger.error(f"Registration error: {str(e)}")
+            return False, f"Error during registration: {str(e)}"
+    
+    def start_session(self, specialty: str, setting: str) -> Optional[int]:
+        """Start new learning session."""
+        if not self.token:
+            return None
+            
+        try:
+            response = requests.post(
+                f"{self.api_url}/sessions",
+                json={"specialty": specialty, "setting": setting},
+                headers={"Authorization": f"Bearer {self.token}"}
+            )
+            
+            if response.status_code == 200:
+                self.session_id = response.json()["session_id"]
+                return self.session_id
+                
+        except Exception as e:
+            logger.error(f"Session start error: {str(e)}")
+        return None
+    
+    def log_interaction(self, interaction_type: str, content: Optional[str] = None) -> bool:
+        """Log user interaction."""
+        if not self.token or not self.session_id:
+            return False
+            
+        try:
+            response = requests.post(
+                f"{self.api_url}/interactions",
+                params={"session_id": self.session_id},
+                json={
+                    "interaction_type": interaction_type,
+                    "content": content
+                },
+                headers={"Authorization": f"Bearer {self.token}"}
+            )
+            
+            return response.status_code == 200
+            
+        except Exception as e:
+            logger.error(f"Interaction logging error: {str(e)}")
+            return False

wardbuddy/learning_interface.py

@@ -15,13 +15,14 @@ from datetime import datetime
 import pandas as pd
 from .clinical_tutor import ClinicalTutor
 from .learning_context import setup_logger, LearningCategory, SmartGoal
+from .auth import AuthManager
 import json
 
 logger = setup_logger(__name__)
 
 # %% ../nbs/02_learning_interface.ipynb 6
 def create_css() -> str:
-    """Create custom CSS for interface styling."""
+    """Create custom CSS for interface styling with auth and mobile support."""
     return """
     /* Base styles */
     .gradio-container {
@@ -30,14 +31,44 @@ def create_css() -> str:
         padding: 1rem !important;
     }
     
-    /* Mobile-first approach */
+    /* Auth container */
+    .auth-container {
+        max-width: 400px !important;
+        margin: 2rem auto !important;
+        padding: 2rem !important;
+        background-color: #1e293b !important;
+        border-radius: 0.5rem !important;
+        border: 1px solid #334155 !important;
+    }
+    
+    .auth-input input {
+        background-color: #1e293b !important;
+        border: 1px solid #334155 !important;
+        color: #f1f5f9 !important;
+        font-size: 1rem !important;
+        padding: 0.75rem !important;
+    }
+    
+    .auth-button {
+        width: 100% !important;
+        margin-top: 1rem !important;
+        background-color: #2563eb !important;
+        color: white !important;
+    }
+    
+    /* Discussion elements */
+    .discussion-status {
+        color: #94a3b8;
+        font-size: 0.9em;
+        margin-bottom: 1rem;
+    }
+    
     .chat-window {
         background-color: #1e293b !important;
         border: 1px solid #334155 !important;
         border-radius: 0.5rem !important;
-        height: calc(100vh - 300px) !important; /* Responsive height */
+        height: calc(100vh - 300px) !important;
         min-height: 300px !important;
-        max-height: 500px !important; 
     }
     
     .chat-message {
@@ -74,12 +105,32 @@ def create_css() -> str:
         background-color: #1d4ed8 !important;
     }
     
+    /* Progress sections */
+    .tab-nav {
+        border-bottom: 1px solid #334155 !important;
+    }
+    
+    .tab-nav button {
+        background-color: transparent !important;
+        color: #94a3b8 !important;
+    }
+    
+    .tab-nav button.selected {
+        color: #f1f5f9 !important;
+        border-bottom: 2px solid #2563eb !important;
+    }
+    
     /* Mobile optimizations */
     @media (max-width: 768px) {
         .gradio-container {
             padding: 0.5rem !important;
         }
         
+        .auth-container {
+            margin: 1rem !important;
+            padding: 1rem !important;
+        }
+        
         .chat-window {
             height: calc(100vh - 250px) !important;
         }
@@ -97,6 +148,11 @@ def create_css() -> str:
             width: 100% !important;
             margin: 0.25rem 0 !important;
         }
+        
+        .tab-nav button {
+            padding: 0.5rem !important;
+            font-size: 0.9rem !important;
+        }
     }
     """
 
@@ -115,11 +171,13 @@ class LearningInterface:
     def __init__(
         self,
         context_path: Optional[Path] = None,
-        model: str = "anthropic/claude-3.5-sonnet"
+        model: str = "anthropic/claude-3.5-sonnet",
+        api_url: Optional[str] = None
     ):
         """Initialize interface."""
         self.tutor = ClinicalTutor(context_path, model)
-        
+        self.auth = AuthManager(api_url)
+
         # Available options
         self.specialties = [
             "Internal Medicine",
@@ -132,7 +190,71 @@ class LearningInterface:
         self.settings = ["Clinic", "Wards", "ED"]
         
         logger.info("Learning interface initialized")
+
+    # Authentication Components
+    def _create_auth_components(self) -> Tuple[gr.Group, gr.Group]:
+        """Create authentication interface components."""
+        with gr.Group() as auth_group:
+            gr.Markdown("# Clinical Learning Assistant")
+            
+            with gr.Tab("Login"):
+                login_email = gr.Textbox(
+                    label="Email",
+                    placeholder="Enter your email"
+                )
+                login_password = gr.Textbox(
+                    label="Password",
+                    type="password",
+                    placeholder="Enter your password"
+                )
+                login_button = gr.Button("Login")
+                login_message = gr.Markdown()
+            
+            with gr.Tab("Register"):
+                register_email = gr.Textbox(
+                    label="Email",
+                    placeholder="Enter your email"
+                )
+                register_password = gr.Textbox(
+                    label="Password",
+                    type="password",
+                    placeholder="Choose a password"
+                )
+                register_button = gr.Button("Register")
+                register_message = gr.Markdown()
+        
+        # Main interface (hidden until auth)
+        main_group = gr.Group(visible=False)
+        
+        return auth_group, main_group, (
+            login_email, login_password, login_button, login_message,
+            register_email, register_password, register_button, register_message
+        )
+    
+    def handle_login(
+        self,
+        email: str,
+        password: str,
+        state: Dict[str, Any]
+    ) -> Tuple[str, gr.update, gr.update, Dict[str, Any]]:
+        """Handle user login."""
+        success, message = self.auth.login(email, password)
+        if success:
+            state["authenticated"] = True
+            return (
+                "Login successful! Redirecting...",  # Success message
+                gr.update(visible=False),  # Hide auth group
+                gr.update(visible=True),  # Show main interface
+                state
+            )
+        return message, gr.update(), gr.update(), state
     
+    def handle_register(self, email: str, password: str) -> str:
+        """Handle user registration."""
+        success, message = self.auth.register(email, password)
+        return message
+
+    # Chat Processing
     async def process_chat(
         self,
         message: str,
@@ -140,7 +262,7 @@ class LearningInterface:
         state: Dict[str, Any]
     ) -> AsyncGenerator[Tuple[List[Dict[str, str]], str, Dict[str, Any]], None]:
         """
-        Process chat messages with streaming and proper history management.
+        Process chat messages with streaming, history management, and interaction logging.
         
         Args:
             message: User input message
@@ -160,6 +282,8 @@ class LearningInterface:
                 state["discussion_active"] = True
                 state["discussion_start"] = datetime.now().isoformat()
                 self.tutor.current_discussion = []  # Reset tutor's discussion history
+                # Log discussion start
+                self.auth.log_interaction("discussion_start")
             
             # Initialize history if needed
             if history is None:
@@ -171,6 +295,9 @@ class LearningInterface:
                 "content": message
             })
             
+            # Log user message
+            self.auth.log_interaction("user_message", message)
+            
             # Add initial assistant message
             history.append({
                 "role": "assistant",
@@ -199,6 +326,9 @@ class LearningInterface:
                 history[-1]["content"] = current_response
                 yield history, "", state
             
+            # Log assistant response
+            self.auth.log_interaction("assistant_response", current_response)
+            
             # Update state and discussion history
             state["last_message"] = datetime.now().isoformat()
             
@@ -213,14 +343,17 @@ class LearningInterface:
             
         except Exception as e:
             logger.error(f"Error in chat: {str(e)}")
+            # Log error
+            self.auth.log_interaction("error", str(e))
+            
             if history is None:
                 history = []
             history.extend([
                 {"role": "user", "content": message},
                 {"role": "assistant", "content": "I apologize, but I encountered an error. Please try again."}
             ])
-            yield history, "", state
-    
+            yield history, "", state    
+            
     def _update_discussion_status(self, state: Dict[str, Any]) -> str:
         """Update discussion status display."""
         try:
@@ -277,7 +410,14 @@ class LearningInterface:
         return self._update_displays(state)
 
     def end_discussion(self, state: Dict[str, Any]) -> List:
-        """End current discussion and analyze results."""
+        """End current discussion with analytics."""
+        if state.get("discussion_active"):
+            self.auth.log_interaction("discussion_end", json.dumps({
+                "duration": (
+                    datetime.now() - 
+                    datetime.fromisoformat(state["discussion_start"])
+                ).total_seconds()
+            }))
         self.tutor.end_discussion()
         state["discussion_active"] = False
         state["discussion_start"] = None
@@ -330,211 +470,258 @@ class LearningInterface:
         return [goals_data, progress_data, recent_data, goal_text]
 
     def create_interface(self) -> gr.Blocks:
-        """Create streaming-enabled interface."""
+        """Create streaming-enabled interface with authentication and all features."""
         with gr.Blocks(title="Clinical Learning Assistant", css=create_css()) as interface:
             # State management
             state = gr.State({
                 "discussion_active": False,
                 "suggested_goals": [],
                 "discussion_start": None,
-                "last_message": None
+                "last_message": None,
+                "authenticated": False
             })
-
-            # Header
-            gr.Markdown("# Clinical Learning Assistant")
-
-            with gr.Row():
-                # Context selection
-                specialty = gr.Dropdown(
-                    choices=self.specialties,
-                    label="Specialty",
-                    value=self.tutor.learning_context.rotation.specialty or None
-                )
-                setting = gr.Dropdown(
-                    choices=self.settings,
-                    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,
-                        show_label=False,
-                        type="messages",  # Use newer message format
-                        elem_classes=["chat-window"]
-                    )
-
-                    with gr.Row():
-                        msg = gr.Textbox(
-                            label="Present your case or ask questions",
-                            placeholder=(
-                                "Present your case as you would to your supervisor:\n"
-                                "- Start with the chief complaint\n"
-                                "- Include relevant history and findings\n"
-                                "- Share your assessment and plan"
-                            ),
-                            lines=4
+            
+            # Authentication interface
+            with gr.Box(elem_classes=["auth-container"]) as auth_group:
+                gr.Markdown("# Clinical Learning Assistant")
+                
+                with gr.Tabs() as auth_tabs:
+                    with gr.Tab("Login"):
+                        login_email = gr.Textbox(
+                            label="Email",
+                            placeholder="Enter your email",
+                            elem_classes=["auth-input"]
                         )
-
-                        audio_input = gr.Audio(
-                            sources=["microphone"],
-                            type="numpy",
-                            label="Or speak your case",
-                            streaming=True
+                        login_password = gr.Textbox(
+                            label="Password",
+                            type="password",
+                            placeholder="Enter your password",
+                            elem_classes=["auth-input"]
                         )
-
-                    with gr.Row():
-                        clear = gr.Button("Clear Discussion")
-                        end = gr.Button(
-                            "End Discussion & Review",
-                            variant="primary"
+                        login_button = gr.Button(
+                            "Login",
+                            variant="primary",
+                            elem_classes=["auth-button"]
                         )
-
-                # Right: Progress & Goals
-                with gr.Column(scale=1):
-                    with gr.Tab("Learning Goals"):
-                        # Goal selection/generation
-                        with gr.Row():
-                            generate = gr.Button("Generate New Goals")
-                            new_goal = gr.Textbox(
-                                label="Or enter your own goal",
-                                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"],
-                            value=[],
-                            label="Available Goals",
-                            interactive=True,
-                            wrap=True
+                        login_message = gr.Markdown()
+                    
+                    with gr.Tab("Register"):
+                        register_email = gr.Textbox(
+                            label="Email",
+                            placeholder="Enter your email",
+                            elem_classes=["auth-input"]
                         )
-
-                    with gr.Tab("Progress"):
-                        # Category progress
-                        progress_display = gr.DataFrame(
-                            headers=["Category", "Completed", "Total"],
-                            value=[],
-                            label="Progress by Category"
+                        register_password = gr.Textbox(
+                            label="Password",
+                            type="password",
+                            placeholder="Choose a password",
+                            elem_classes=["auth-input"]
                         )
-
-                        # Recent completions
-                        recent_display = gr.DataFrame(
-                            headers=["Goal", "Category", "Completed"],
-                            value=[],
-                            label="Recently Completed"
+                        register_button = gr.Button(
+                            "Register",
+                            variant="primary",
+                            elem_classes=["auth-button"]
                         )
-
-            # Event handlers
-            async def update_context(spec: str, set: str, state: Dict) -> List:
-                """Update rotation context."""
-                if spec and set:
-                    self.tutor.learning_context.update_rotation(spec, set)
-                    if not state.get("suggested_goals"):
-                        goals = await self.tutor.generate_smart_goals(spec, set)
-                        state["suggested_goals"] = goals
-                    return self._update_displays(state)
-                return [[], [], [], "No active learning goal"]
-
-            def clear_discussion() -> Tuple[List, str, Dict]:
-                """Clear chat history."""
-                self.tutor.current_discussion = []  # Clear tutor's discussion history
-                return [], "", {
-                    "discussion_active": False,
-                    "suggested_goals": [],
-                    "discussion_start": None,
-                    "last_message": None
-                }
+                        register_message = gr.Markdown()
             
-            def process_audio(audio: np.ndarray) -> str:
-                """Convert audio to text."""
-                if audio is None:
-                    return ""
-                # Add your audio processing logic here
-                return "Audio transcription would appear here"
+            # Main interface (initially hidden)
+            with gr.Group(visible=False) as main_group:
+                with gr.Row():
+                    # Context selection
+                    specialty = gr.Dropdown(
+                        choices=self.specialties,
+                        label="Specialty",
+                        value=self.tutor.learning_context.rotation.specialty or None
+                    )
+                    setting = gr.Dropdown(
+                        choices=self.settings,
+                        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,
+                            show_label=False,
+                            type="messages",  # Use newer message format
+                            elem_classes=["chat-window"]
+                        )
+    
+                        with gr.Row():
+                            msg = gr.Textbox(
+                                label="Present your case or ask questions",
+                                placeholder=(
+                                    "Present your case as you would to your supervisor:\n"
+                                    "- Start with the chief complaint\n"
+                                    "- Include relevant history and findings\n"
+                                    "- Share your assessment and plan"
+                                ),
+                                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"):
+                            with gr.Row():
+                                generate = gr.Button("Generate New Goals")
+                                new_goal = gr.Textbox(
+                                    label="Or enter your own goal",
+                                    placeholder="What do you want to get better at?"
+                                )
+                                add_goal = gr.Button("Add Goal")
+    
+                            goals_list = gr.DataFrame(
+                                headers=["Goal", "Category", "Status"],
+                                value=[],
+                                label="Available Goals",
+                                interactive=True,
+                                wrap=True
+                            )
+    
+                        with gr.Tab("Progress"):
+                            progress_display = gr.DataFrame(
+                                headers=["Category", "Completed", "Total"],
+                                value=[],
+                                label="Progress by Category"
+                            )
+    
+                            recent_display = gr.DataFrame(
+                                headers=["Goal", "Category", "Completed"],
+                                value=[],
+                                label="Recently Completed"
+                            )
+    
+                # Wire up auth events
+                login_button.click(
+                    self.handle_login,
+                    inputs=[login_email, login_password, state],
+                    outputs=[login_message, auth_group, main_group, state]
+                ).success(
+                    lambda: None,  # Clear login form
+                    None,
+                    [login_email, login_password]
+                )
+    
+                register_button.click(
+                    self.handle_register,
+                    inputs=[register_email, register_password],
+                    outputs=register_message
+                )
+    
+                # Define helper functions
+                def clear_discussion() -> Tuple[List, str, Dict]:
+                    """Clear chat history."""
+                    self.tutor.current_discussion = []  # Clear tutor's discussion history
+                    return [], "", {
+                        "discussion_active": False,
+                        "suggested_goals": [],
+                        "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,
-                inputs=[msg, chatbot, state],
-                outputs=[chatbot, msg, state],
-                queue=True  # Important for streaming
-            ).then(
-                self._update_discussion_status,
-                inputs=[state],
-                outputs=[discussion_status]
-            )
-
-            # Voice input handling
-            audio_input.stream(
-                process_audio,
-                inputs=[audio_input],
-                outputs=[msg]
-            ).then(
-                self.process_chat,
-                inputs=[msg, chatbot, state],
-                outputs=[chatbot, msg, state]
-            )
-
-            # Button handlers
-            clear.click(
-                clear_discussion,
-                outputs=[chatbot, msg, state]
-            ).then(
-                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]
-            )
-
+                def process_audio(audio: np.ndarray) -> str:
+                    """Convert audio to text."""
+                    if audio is None:
+                        return ""
+                    # Add your audio processing logic here
+                    return "Audio transcription would appear here"
+    
+                # Wire up main interface events with tracking
+                specialty.change(
+                    fn=self.update_context,
+                    inputs=[specialty, setting, state],
+                    outputs=[goals_list, progress_display, recent_display, goal_display],
+                    api_name=False  # Important for async functions
+                )
+    
+                setting.change(
+                    fn=self.update_context,
+                    inputs=[specialty, setting, state],
+                    outputs=[goals_list, progress_display, recent_display, goal_display],
+                    api_name=False  # Important for async functions
+                )
+    
+                # Chat events with streaming
+                msg.submit(
+                    self.process_chat,
+                    inputs=[msg, chatbot, state],
+                    outputs=[chatbot, msg, state],
+                    queue=True  # Important for streaming
+                ).then(
+                    self._update_discussion_status,
+                    inputs=[state],
+                    outputs=[discussion_status]
+                )
+    
+                # Voice input handling
+                audio_input.stream(
+                    process_audio,
+                    inputs=[audio_input],
+                    outputs=[msg]
+                ).then(
+                    self.process_chat,
+                    inputs=[msg, chatbot, state],
+                    outputs=[chatbot, msg, state]
+                )
+    
+                # Button handlers
+                clear.click(
+                    clear_discussion,
+                    outputs=[chatbot, msg, state]
+                ).then(
+                    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