Upload folder using huggingface_hub

.github/workflows/deploy.yaml

@@ -0,0 +1,14 @@
+name: Deploy to GitHub Pages
+
+permissions:
+  contents: write
+  pages: write
+
+on:
+  push:
+    branches: [ "main", "master" ]
+  workflow_dispatch:
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps: [uses: fastai/workflows/quarto-ghp@master]

.github/workflows/test.yaml

@@ -0,0 +1,9 @@
+name: CI
+on:  [workflow_dispatch, pull_request, push]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    env:
+      OPENROUTER_API_KEY: ${{ secrets.OPENROUTER_API_KEY }}
+    steps: [uses: fastai/workflows/nbdev-ci@master]

.gitignore

@@ -0,0 +1,155 @@
+# API Keys
+.env
+
+_docs/
+_proc/
+
+*.bak
+.gitattributes
+.last_checked
+.gitconfig
+*.bak
+*.log
+*~
+~*
+_tmp*
+tmp*
+tags
+*.pkg
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+env/
+build/
+conda/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# dotenv
+.env
+
+# virtualenv
+.venv
+venv/
+ENV/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+
+.vscode
+*.swp
+
+# osx generated files
+.DS_Store
+.DS_Store?
+.Trashes
+ehthumbs.db
+Thumbs.db
+.idea
+
+# pytest
+.pytest_cache
+
+# tools/trust-doc-nbs
+docs_src/.last_checked
+
+# symlinks to fastai
+docs_src/fastai
+tools/fastai
+
+# link checker
+checklink/cookies.txt
+
+# .gitconfig is now autogenerated
+.gitconfig
+
+# Quarto installer
+.deb
+.pkg
+
+# Quarto
+.quarto

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2022, fastai
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

MANIFEST.in

@@ -0,0 +1,5 @@
+include settings.ini
+include LICENSE
+include CONTRIBUTING.md
+include README.md
+recursive-exclude * __pycache__

README.md

@@ -1,12 +1,73 @@
----
-title: Wardbuddy Test
-emoji: 📈
-colorFrom: red
-colorTo: yellow
-sdk: gradio
-sdk_version: 5.13.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: wardbuddy-test
+app_file: app.py
+sdk: gradio
+sdk_version: 5.12.0
+---
+# wardbuddy
+
+
+<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
+
+This file will become your README and also the index of your
+documentation.
+
+## Developer Guide
+
+If you are new to using `nbdev` here are some useful pointers to get you
+started.
+
+### Install wardbuddy in Development mode
+
+``` sh
+# make sure wardbuddy package is installed in development mode
+$ pip install -e .
+
+# make changes under nbs/ directory
+# ...
+
+# compile to have changes apply to wardbuddy
+$ nbdev_prepare
+```
+
+## Usage
+
+### Installation
+
+Install latest from the GitHub
+[repository](https://github.com/Dyadd/wardbuddy):
+
+``` sh
+$ pip install git+https://github.com/Dyadd/wardbuddy.git
+```
+
+or from [conda](https://anaconda.org/Dyadd/wardbuddy)
+
+``` sh
+$ conda install -c Dyadd wardbuddy
+```
+
+or from [pypi](https://pypi.org/project/wardbuddy/)
+
+``` sh
+$ pip install wardbuddy
+```
+
+### Documentation
+
+Documentation can be found hosted on this GitHub
+[repository](https://github.com/Dyadd/wardbuddy)’s
+[pages](https://Dyadd.github.io/wardbuddy/). Additionally you can find
+package manager specific guidelines on
+[conda](https://anaconda.org/Dyadd/wardbuddy) and
+[pypi](https://pypi.org/project/wardbuddy/) respectively.
+
+## How to use
+
+Fill me in please! Don’t forget code examples:
+
+``` python
+1+1
+```
+
+    2

app.py

@@ -0,0 +1,15 @@
+from dotenv import load_dotenv
+import os
+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")
+
+# Create and launch interface
+interface = LearningInterface()
+demo = interface.create_interface()
+demo.launch(server_name='0.0.0.0', server_port=7860, share=True)

nbs/00_learning_context.ipynb

@@ -0,0 +1,367 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| default_exp learning_context"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Learning Context\n",
+    "\n",
+    "> Core module for managing learning context (memory -> LOs, prior cases, knowledge gaps, feedback preferences)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setup"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| hide\n",
+    "from nbdev.showdoc import *"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "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"
+     ]
+    }
+   ],
+   "source": [
+    "#| export\n",
+    "from typing import Dict, List, Optional, Any, Tuple\n",
+    "from datetime import datetime\n",
+    "import json\n",
+    "from pathlib import Path\n",
+    "from wardbuddy.utils import setup_logger, load_context_safely, save_context_safely"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export\n",
+    "logger = setup_logger(__name__)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Learning Context Management\n",
+    "\n",
+    "> Core module for managing student learning context and history"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The system needs to track and handle student information for personalised education.  \n",
+    "\n",
+    "This module handles:\n",
+    "* Tracking learning objectives\n",
+    "* Managing case history\n",
+    "* Monitoring knowledge gaps\n",
+    "* Customizing feedback preferences\n",
+    "\n",
+    "and finally:\n",
+    "* Context persistence\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export\n",
+    "class LearningContext:\n",
+    "    \"\"\"\n",
+    "    Manages the dynamic learning context for each student.\n",
+    "    \n",
+    "    Tracks:\n",
+    "    - Current rotation details\n",
+    "    - Learning objectives and progress\n",
+    "    - Knowledge gaps and strengths\n",
+    "    - Custom feedback preferences\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    def __init__(self, context_file: Optional[Path] = None):\n",
+    "        \"\"\"\n",
+    "        Initialize learning context, optionally loading from file.\n",
+    "        \n",
+    "        Args:\n",
+    "            context_file: Optional path to saved context\n",
+    "        \"\"\"\n",
+    "        # Initialize current rotation\n",
+    "        self.current_rotation = {\n",
+    "            \"specialty\": \"\",\n",
+    "            \"start_date\": None,\n",
+    "            \"end_date\": None,\n",
+    "            \"key_focus_areas\": []\n",
+    "        }\n",
+    "        \n",
+    "        # Initialize learning objectives list\n",
+    "        self.learning_objectives = []  # [{\"objective\": str, \"status\": \"active\"|\"completed\", \"added\": datetime}]\n",
+    "        \n",
+    "        # Initialize knowledge profile\n",
+    "        self.knowledge_profile = {\n",
+    "            \"gaps\": {},  # topic -> confidence level\n",
+    "            \"strengths\": [],\n",
+    "            \"recent_progress\": []  # [{topic, improvement, date}]\n",
+    "        }\n",
+    "        \n",
+    "        # Initialize feedback preferences\n",
+    "        self.feedback_preferences = []  # [{\"focus\": str, \"active\": bool}]\n",
+    "        \n",
+    "        if context_file and context_file.exists():\n",
+    "            self.load_context(context_file)\n",
+    "            \n",
+    "        logger.info(\"Learning context initialized\")\n",
+    "    \n",
+    "    def update_rotation(self, rotation_details: Dict[str, Any]) -> None:\n",
+    "        \"\"\"Update current rotation details\"\"\"\n",
+    "        self.current_rotation.update(rotation_details)\n",
+    "    \n",
+    "    def add_learning_objective(self, objective: str) -> None:\n",
+    "        \"\"\"Add new learning objective\"\"\"\n",
+    "        self.learning_objectives.append({\n",
+    "            \"objective\": objective,\n",
+    "            \"status\": \"active\",\n",
+    "            \"added\": datetime.now().isoformat()\n",
+    "        })\n",
+    "    \n",
+    "    def complete_objective(self, objective: str) -> None:\n",
+    "        \"\"\"Mark learning objective as completed\"\"\"\n",
+    "        for obj in self.learning_objectives:\n",
+    "            if obj[\"objective\"] == objective and obj[\"status\"] == \"active\":\n",
+    "                obj[\"status\"] = \"completed\"\n",
+    "                obj[\"completed\"] = datetime.now().isoformat()\n",
+    "                break\n",
+    "    \n",
+    "    def update_knowledge_gap(self, topic: str, confidence: float) -> None:\n",
+    "        \"\"\"Update knowledge gap confidence level\"\"\"\n",
+    "        old_confidence = self.knowledge_profile[\"gaps\"].get(topic)\n",
+    "        self.knowledge_profile[\"gaps\"][topic] = confidence\n",
+    "        \n",
+    "        # Track progress if confidence improved\n",
+    "        if old_confidence and confidence > old_confidence:\n",
+    "            self.knowledge_profile[\"recent_progress\"].append({\n",
+    "                \"topic\": topic,\n",
+    "                \"improvement\": confidence - old_confidence,\n",
+    "                \"date\": datetime.now().isoformat()\n",
+    "            })\n",
+    "            \n",
+    "            # Keep only recent progress\n",
+    "            self.knowledge_profile[\"recent_progress\"] = \\\n",
+    "                self.knowledge_profile[\"recent_progress\"][-5:]\n",
+    "    \n",
+    "    def add_strength(self, topic: str) -> None:\n",
+    "        \"\"\"Add identified strength\"\"\"\n",
+    "        if topic not in self.knowledge_profile[\"strengths\"]:\n",
+    "            self.knowledge_profile[\"strengths\"].append(topic)\n",
+    "    \n",
+    "    def toggle_feedback_focus(self, focus: str, active: bool) -> None:\n",
+    "        \"\"\"Toggle feedback focus area\"\"\"\n",
+    "        # Update if exists\n",
+    "        for pref in self.feedback_preferences:\n",
+    "            if pref[\"focus\"] == focus:\n",
+    "                pref[\"active\"] = active\n",
+    "                return\n",
+    "                \n",
+    "        # Add if new\n",
+    "        self.feedback_preferences.append({\n",
+    "            \"focus\": focus,\n",
+    "            \"active\": active\n",
+    "        })\n",
+    "    \n",
+    "    def save_context(self, file_path: Path) -> None:\n",
+    "        \"\"\"Save context to file\"\"\"\n",
+    "        context_data = {\n",
+    "            \"current_rotation\": self.current_rotation,\n",
+    "            \"learning_objectives\": self.learning_objectives,\n",
+    "            \"knowledge_profile\": self.knowledge_profile,\n",
+    "            \"feedback_preferences\": self.feedback_preferences\n",
+    "        }\n",
+    "        save_context_safely(context_data, file_path)\n",
+    "    \n",
+    "    def load_context(self, file_path: Path) -> None:\n",
+    "        \"\"\"Load context from file\"\"\"\n",
+    "        try:\n",
+    "            context_data = load_context_safely(file_path)\n",
+    "            \n",
+    "            # Use .get() with default values to handle missing keys\n",
+    "            self.current_rotation = context_data.get(\"current_rotation\", {\n",
+    "                \"specialty\": \"\",\n",
+    "                \"start_date\": None,\n",
+    "                \"end_date\": None,\n",
+    "                \"key_focus_areas\": []\n",
+    "            })\n",
+    "            \n",
+    "            # Ensure required keys exist\n",
+    "            for key in [\"specialty\", \"start_date\", \"end_date\", \"key_focus_areas\"]:\n",
+    "                if key not in self.current_rotation:\n",
+    "                    self.current_rotation[key] = None if key != \"key_focus_areas\" else []\n",
+    "            \n",
+    "            self.learning_objectives = context_data.get(\"learning_objectives\", [])\n",
+    "            self.knowledge_profile = context_data.get(\"knowledge_profile\", {\n",
+    "                \"gaps\": {},\n",
+    "                \"strengths\": [],\n",
+    "                \"recent_progress\": []\n",
+    "            })\n",
+    "            self.feedback_preferences = context_data.get(\"feedback_preferences\", [])\n",
+    "            \n",
+    "            logger.info(f\"Context loaded successfully from {file_path}\")\n",
+    "            \n",
+    "        except Exception as e:\n",
+    "            logger.error(f\"Error loading context: {str(e)}\")\n",
+    "            # Initialize with defaults on error\n",
+    "            self.__init__()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Tests"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2025-01-18 23:31:55,450 - __main__ - INFO - Learning context initialized\n",
+      "2025-01-18 23:31:55,457 - __main__ - INFO - Learning context initialized\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "All learning context tests passed!\n"
+     ]
+    }
+   ],
+   "source": [
+    "def test_learning_context():\n",
+    "    \"\"\"Test LearningContext functionality\"\"\"\n",
+    "    # Create a temporary directory for tests\n",
+    "    import tempfile\n",
+    "    temp_dir = tempfile.mkdtemp()\n",
+    "    temp_path = Path(temp_dir) / \"test_context.json\"\n",
+    "    \n",
+    "    try:\n",
+    "        # Initialize context\n",
+    "        context = LearningContext()\n",
+    "        \n",
+    "        # Test rotation updates\n",
+    "        rotation_details = {\n",
+    "            \"specialty\": \"Emergency Medicine\",\n",
+    "            \"start_date\": \"2025-01-01\",\n",
+    "            \"end_date\": \"2025-03-31\",\n",
+    "            \"key_focus_areas\": [\"Resuscitation\", \"Procedures\"]\n",
+    "        }\n",
+    "        context.update_rotation(rotation_details)\n",
+    "        assert context.current_rotation[\"specialty\"] == \"Emergency Medicine\"\n",
+    "        \n",
+    "        # Test learning objectives\n",
+    "        context.add_learning_objective(\"Improve chest pain assessment\")\n",
+    "        assert len(context.learning_objectives) == 1\n",
+    "        assert context.learning_objectives[0][\"status\"] == \"active\"\n",
+    "        \n",
+    "        # Test completing objectives\n",
+    "        context.complete_objective(\"Improve chest pain assessment\")\n",
+    "        assert context.learning_objectives[0][\"status\"] == \"completed\"\n",
+    "        \n",
+    "        # Test knowledge gaps\n",
+    "        context.update_knowledge_gap(\"ECG interpretation\", 0.6)\n",
+    "        assert context.knowledge_profile[\"gaps\"][\"ECG interpretation\"] == 0.6\n",
+    "        \n",
+    "        # Test progress tracking\n",
+    "        context.update_knowledge_gap(\"ECG interpretation\", 0.8)\n",
+    "        assert len(context.knowledge_profile[\"recent_progress\"]) == 1\n",
+    "        \n",
+    "        # Test strengths\n",
+    "        context.add_strength(\"History taking\")\n",
+    "        assert \"History taking\" in context.knowledge_profile[\"strengths\"]\n",
+    "        \n",
+    "        # Test feedback preferences\n",
+    "        context.toggle_feedback_focus(\"Include more ddx\", True)\n",
+    "        assert len(context.feedback_preferences) == 1\n",
+    "        assert context.feedback_preferences[0][\"active\"] == True\n",
+    "        \n",
+    "        # Test persistence\n",
+    "        context.save_context(temp_path)\n",
+    "        assert temp_path.exists()\n",
+    "        \n",
+    "        # Test loading in new context\n",
+    "        new_context = LearningContext(temp_path)\n",
+    "        assert new_context.current_rotation[\"specialty\"] == \"Emergency Medicine\"\n",
+    "        assert len(new_context.learning_objectives) == 1\n",
+    "        assert \"ECG interpretation\" in new_context.knowledge_profile[\"gaps\"]\n",
+    "        \n",
+    "    finally:\n",
+    "        # Cleanup\n",
+    "        import shutil\n",
+    "        shutil.rmtree(temp_dir)\n",
+    "        \n",
+    "    print(\"All learning context tests passed!\")\n",
+    "\n",
+    "# Run tests\n",
+    "if __name__ == \"__main__\":\n",
+    "    test_learning_context()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

nbs/01_clinical_tutor.ipynb

@@ -0,0 +1,599 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d9a32ad5-9f07-47f2-97ae-15b0646e355b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| default_exp clinical_tutor"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0db4b759-310c-4e38-9fdc-2efb94b541dd",
+   "metadata": {},
+   "source": [
+    "# Clinical Tutor\n",
+    "\n",
+    "> Core module for using learning context for context-appropriate tutor responses\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "16f93992-88dd-409b-8370-b86302e1ce6a",
+   "metadata": {},
+   "source": [
+    "## Setup"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6d2403bb-70a1-4744-be0b-d259234c1b62",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| hide\n",
+    "from nbdev.showdoc import *"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "477ba22b-55c1-467e-8206-a92f88a598fd",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "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"
+     ]
+    }
+   ],
+   "source": [
+    "#| export\n",
+    "from typing import Dict, List, Optional, Any, Tuple\n",
+    "import os\n",
+    "import json\n",
+    "import logging\n",
+    "from pathlib import Path\n",
+    "from datetime import datetime\n",
+    "from dotenv import load_dotenv\n",
+    "import aiohttp\n",
+    "import re\n",
+    "from collections import defaultdict\n",
+    "from wardbuddy.learning_context import LearningContext, setup_logger\n",
+    "\n",
+    "# Load environment variables\n",
+    "load_dotenv()\n",
+    "\n",
+    "logger = setup_logger(__name__)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7da445d7-7f51-44d5-b027-e2cf65c79069",
+   "metadata": {},
+   "source": [
+    "## Adaptive Clinical Tutor"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "58d76615-480c-4fe4-9d4a-e67dd892132a",
+   "metadata": {},
+   "source": [
+    "This module implements:\n",
+    "\n",
+    " - Engages in natural case discussions like a clinical supervisor\n",
+    " - Provides context-aware feedback based on student's rotation and preferences\n",
+    " - Analyzes discussions to track learning progress\n",
+    " - Integrates with the student's learning context\n",
+    "\n",
+    "The tutor aims to mimic real-world clinical teaching interactions where students present cases and receive feedback in a natural conversational style.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "da7d2115-b30f-40ba-9566-bcbaf155026d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export \n",
+    "class OpenRouterException(Exception):\n",
+    "    \"\"\"Custom exception for OpenRouter API errors\"\"\"\n",
+    "    pass"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "75c2cbfc-75e7-45ee-9d86-b931f81a3ad5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export\n",
+    "class ClinicalTutor:\n",
+    "    \"\"\"\n",
+    "    Adaptive clinical teaching module that provides context-aware feedback.\n",
+    "    \n",
+    "    The tutor acts as an experienced clinical supervisor, engaging in natural\n",
+    "    case discussions while tracking student progress and adapting feedback\n",
+    "    based on learning context.\n",
+    "    \n",
+    "    Attributes:\n",
+    "        learning_context (LearningContext): Student's learning context\n",
+    "        model (str): LLM model identifier\n",
+    "        api_url (str): OpenRouter API endpoint\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    def __init__(\n",
+    "        self,\n",
+    "        context_path: Optional[Path] = None,\n",
+    "        model: str = \"anthropic/claude-3.5-sonnet\"\n",
+    "    ):\n",
+    "        \"\"\"\n",
+    "        Initialize clinical tutor.\n",
+    "        \n",
+    "        Args:\n",
+    "            context_path: Optional path for context persistence\n",
+    "            model: Model identifier for OpenRouter\n",
+    "        \"\"\"\n",
+    "        self.api_key: str = os.getenv(\"OPENROUTER_API_KEY\")\n",
+    "        if not self.api_key:\n",
+    "            raise ValueError(\"OpenRouter API key not found\")\n",
+    "        \n",
+    "        self.api_url: str = \"https://openrouter.ai/api/v1/chat/completions\"\n",
+    "        self.model: str = model\n",
+    "        \n",
+    "        self.learning_context = LearningContext(context_path)\n",
+    "        self.context_path = context_path\n",
+    "        \n",
+    "        # Track conversation state\n",
+    "        self.current_case: Dict = {\n",
+    "            \"started\": None,\n",
+    "            \"chief_complaint\": None,\n",
+    "            \"key_findings\": [],\n",
+    "            \"assessment\": None,\n",
+    "            \"plan\": None\n",
+    "        }\n",
+    "        \n",
+    "        logger.info(f\"Clinical tutor initialized with model: {model}\")\n",
+    "    \n",
+    "    async def _get_completion(\n",
+    "        self,\n",
+    "        messages: List[Dict],\n",
+    "        temperature: float = 0.7,\n",
+    "        max_retries: int = 3\n",
+    "    ) -> str:\n",
+    "        \"\"\"\n",
+    "        Get completion from OpenRouter API with retry logic.\n",
+    "        \n",
+    "        Args:\n",
+    "            messages: List of conversation messages\n",
+    "            temperature: Temperature for response generation\n",
+    "            max_retries: Maximum retry attempts\n",
+    "            \n",
+    "        Returns:\n",
+    "            str: Model response\n",
+    "            \n",
+    "        Raises:\n",
+    "            OpenRouterException: If API calls fail after retries\n",
+    "        \"\"\"\n",
+    "        headers = {\n",
+    "            \"Authorization\": f\"Bearer {self.api_key}\",\n",
+    "            \"Content-Type\": \"application/json\",\n",
+    "            \"HTTP-Referer\": \"http://localhost:7860\"\n",
+    "        }\n",
+    "        \n",
+    "        data = {\n",
+    "            \"model\": self.model,\n",
+    "            \"messages\": messages,\n",
+    "            \"temperature\": temperature,\n",
+    "            \"max_tokens\": 2000\n",
+    "        }\n",
+    "        \n",
+    "        for attempt in range(max_retries):\n",
+    "            try:\n",
+    "                async with aiohttp.ClientSession() as session:\n",
+    "                    async with session.post(\n",
+    "                        self.api_url,\n",
+    "                        headers=headers,\n",
+    "                        json=data,\n",
+    "                        timeout=30\n",
+    "                    ) as response:\n",
+    "                        response.raise_for_status()\n",
+    "                        result = await response.json()\n",
+    "                        return result[\"choices\"][0][\"message\"][\"content\"]\n",
+    "                        \n",
+    "            except Exception as e:\n",
+    "                if attempt == max_retries - 1:\n",
+    "                    raise OpenRouterException(f\"API call failed: {str(e)}\")\n",
+    "                logger.warning(f\"Retry {attempt + 1} after error: {str(e)}\")\n",
+    "                # Could add exponential backoff here if needed\n",
+    "    \n",
+    "    def _build_discussion_prompt(self) -> str:\n",
+    "        \"\"\"\n",
+    "        Build context-aware prompt for case discussion.\n",
+    "        \n",
+    "        Incorporates:\n",
+    "        - Current rotation details\n",
+    "        - Active feedback preferences\n",
+    "        - Recent learning points\n",
+    "        - Knowledge gaps needing attention\n",
+    "        \n",
+    "        Returns:\n",
+    "            str: Contextualized system prompt\n",
+    "        \"\"\"\n",
+    "        rotation = self.learning_context.current_rotation\n",
+    "        active_preferences = [\n",
+    "            p[\"focus\"] for p in self.learning_context.feedback_preferences \n",
+    "            if p[\"active\"]\n",
+    "        ]\n",
+    "        \n",
+    "        # Get relevant knowledge gaps\n",
+    "        significant_gaps = {\n",
+    "            topic: score for topic, score \n",
+    "            in self.learning_context.knowledge_profile[\"gaps\"].items()\n",
+    "            if score < 0.7  # Only include significant gaps\n",
+    "        }\n",
+    "        \n",
+    "        prompt = f\"\"\"You are an experienced clinical supervisor in {rotation['specialty']} \n",
+    "        providing teaching and feedback. You aim to:\n",
+    "\n",
+    "        1. Help students develop strong clinical reasoning\n",
+    "        2. Connect theory to practical applications\n",
+    "        3. Build diagnostic confidence\n",
+    "        4. Improve presentation skills\n",
+    "\n",
+    "        Current Rotation Focus Areas:\n",
+    "        {', '.join(rotation['key_focus_areas'])}\n",
+    "\n",
+    "        Areas Needing Attention:\n",
+    "        {', '.join(f'{topic} (confidence: {score:.1f})' for topic, score in significant_gaps.items()) if significant_gaps else 'No specific gaps identified'}\n",
+    "\n",
+    "        Student's Requested Focus:\n",
+    "        {', '.join(active_preferences) if active_preferences else 'General clinical feedback'}\n",
+    "\n",
+    "        Engage naturally as a supportive but challenging supervisor would during case \n",
+    "        presentations. Ask probing questions when appropriate, share relevant clinical \n",
+    "        pearls, and help the student build their clinical reasoning skills.\"\"\"\n",
+    "        \n",
+    "        return prompt\n",
+    "    \n",
+    "    def _build_analysis_prompt(self, conversation: List[Dict[str, str]]) -> str:\n",
+    "        \"\"\"\n",
+    "        Build prompt for post-discussion analysis.\n",
+    "        \n",
+    "        Args:\n",
+    "            conversation: List of message dictionaries with roles and content\n",
+    "            \n",
+    "        Returns:\n",
+    "            str: Analysis prompt\n",
+    "        \"\"\"\n",
+    "        # Extract case details\n",
+    "        case_content = \"\"\n",
+    "        for msg in conversation:\n",
+    "            if msg[\"role\"] == \"user\":\n",
+    "                case_content += msg[\"content\"] + \"\\n\"\n",
+    "        \n",
+    "        return f\"\"\"Analyze the following case discussion between a medical student and \n",
+    "        clinical supervisor. Focus on the student's demonstrated knowledge, skills, \n",
+    "        and areas for improvement.\n",
+    "\n",
+    "        Case Content:\n",
+    "        {case_content}\n",
+    "\n",
+    "        Please identify:\n",
+    "        1. Key clinical concepts and learning points demonstrated or discussed\n",
+    "        2. Areas where the student showed uncertainty or knowledge gaps\n",
+    "        3. Strengths demonstrated in clinical reasoning and presentation\n",
+    "        4. Specific learning objectives that would help the student's development\n",
+    "\n",
+    "        Frame your response to help with ongoing learning:\n",
+    "        - Start with positive observations\n",
+    "        - Be specific about knowledge gaps\n",
+    "        - Make concrete suggestions for improvement\n",
+    "        - Connect to practical clinical scenarios\"\"\"\n",
+    "    \n",
+    "    async def discuss_case(\n",
+    "        self, \n",
+    "        message: str,\n",
+    "        temperature: float = 0.7\n",
+    "    ) -> str:\n",
+    "        \"\"\"\n",
+    "        Natural case discussion with context-aware responses.\n",
+    "        \n",
+    "        Args:\n",
+    "            message: Student's input message\n",
+    "            temperature: Temperature for response generation\n",
+    "            \n",
+    "        Returns:\n",
+    "            str: Clinical supervisor's response\n",
+    "        \"\"\"\n",
+    "        try:\n",
+    "            # Update case tracking\n",
+    "            if not self.current_case[\"started\"]:\n",
+    "                self.current_case[\"started\"] = datetime.now()\n",
+    "                # Try to identify chief complaint from first message\n",
+    "                cc_match = re.search(r\"(\\d+)\\s*[yY][oO]\\s*[MmFf]\\s*with\\s*([^.]*)\", message)\n",
+    "                if cc_match:\n",
+    "                    self.current_case[\"chief_complaint\"] = cc_match.group(2).strip()\n",
+    "            \n",
+    "            # Build system prompt\n",
+    "            system_prompt = self._build_discussion_prompt()\n",
+    "            \n",
+    "            messages = [{\n",
+    "                \"role\": \"system\",\n",
+    "                \"content\": system_prompt\n",
+    "            }, {\n",
+    "                \"role\": \"user\",\n",
+    "                \"content\": message\n",
+    "            }]\n",
+    "            \n",
+    "            response = await self._get_completion(messages, temperature)\n",
+    "            return response\n",
+    "            \n",
+    "        except Exception as e:\n",
+    "            logger.error(f\"Error in case discussion: {str(e)}\")\n",
+    "            return \"I apologize, but I encountered an error. Please try presenting your case again.\"\n",
+    "    \n",
+    "    async def analyze_discussion(\n",
+    "        self,\n",
+    "        conversation: List[Dict[str, str]]\n",
+    "    ) -> Dict[str, Any]:\n",
+    "        \"\"\"\n",
+    "        Analyze completed case discussion for learning insights.\n",
+    "        \n",
+    "        Args:\n",
+    "            conversation: List of message dictionaries with roles and content\n",
+    "            \n",
+    "        Returns:\n",
+    "            dict: Analysis results containing:\n",
+    "                - learning_points: List of key concepts learned\n",
+    "                - gaps: Dict of identified knowledge gaps\n",
+    "                - strengths: List of demonstrated strengths\n",
+    "                - suggested_objectives: List of recommended learning goals\n",
+    "        \"\"\"\n",
+    "        try:\n",
+    "            # Reset case tracking\n",
+    "            self.current_case = {\n",
+    "                \"started\": None,\n",
+    "                \"chief_complaint\": None,\n",
+    "                \"key_findings\": [],\n",
+    "                \"assessment\": None,\n",
+    "                \"plan\": None\n",
+    "            }\n",
+    "            \n",
+    "            # Get analysis from model\n",
+    "            analysis_prompt = self._build_analysis_prompt(conversation)\n",
+    "            messages = [{\n",
+    "                \"role\": \"system\",\n",
+    "                \"content\": analysis_prompt\n",
+    "            }]\n",
+    "            messages.extend(conversation)\n",
+    "            \n",
+    "            response = await self._get_completion(messages, temperature=0.3)\n",
+    "            \n",
+    "            # Parse insights\n",
+    "            insights = self._parse_analysis(response)\n",
+    "            \n",
+    "            # Update learning context\n",
+    "            self._update_context_from_analysis(insights)\n",
+    "            \n",
+    "            return insights\n",
+    "            \n",
+    "        except Exception as e:\n",
+    "            logger.error(f\"Error in discussion analysis: {str(e)}\")\n",
+    "            return {\n",
+    "                \"learning_points\": [],\n",
+    "                \"gaps\": {},\n",
+    "                \"strengths\": [],\n",
+    "                \"suggested_objectives\": []\n",
+    "            }\n",
+    "    \n",
+    "    def _parse_analysis(self, response: str) -> Dict[str, Any]:\n",
+    "        \"\"\"\n",
+    "        Parse analysis response into structured insights.\n",
+    "        \n",
+    "        Uses pattern matching and basic NLP to extract:\n",
+    "        - Learning points (key concepts discussed)\n",
+    "        - Knowledge gaps with confidence estimates\n",
+    "        - Demonstrated strengths\n",
+    "        - Suggested learning objectives\n",
+    "        \n",
+    "        Args:\n",
+    "            response: Raw analysis response\n",
+    "            \n",
+    "        Returns:\n",
+    "            dict: Structured analysis insights\n",
+    "        \"\"\"\n",
+    "        insights = {\n",
+    "            \"learning_points\": [],\n",
+    "            \"gaps\": {},\n",
+    "            \"strengths\": [],\n",
+    "            \"suggested_objectives\": []\n",
+    "        }\n",
+    "        \n",
+    "        try:\n",
+    "            # Split into sections\n",
+    "            sections = response.lower().split(\"\\n\\n\")\n",
+    "            \n",
+    "            for section in sections:\n",
+    "                if \"learning point\" in section or \"key concept\" in section:\n",
+    "                    # Extract bullet points or numbered items\n",
+    "                    points = re.findall(r\"[-•*]\\s*(.+)$\", section, re.MULTILINE)\n",
+    "                    insights[\"learning_points\"].extend(points)\n",
+    "                    \n",
+    "                elif \"gap\" in section or \"uncertainty\" in section:\n",
+    "                    # Look for topic mentions with confidence indicators\n",
+    "                    gaps = re.findall(\n",
+    "                        r\"(limited|uncertain|unclear|difficulty with)\\s+([^,.]+)\", \n",
+    "                        section\n",
+    "                    )\n",
+    "                    for indicator, topic in gaps:\n",
+    "                        # Estimate confidence based on language\n",
+    "                        confidence = 0.4 if \"limited\" in indicator else 0.6\n",
+    "                        insights[\"gaps\"][topic.strip()] = confidence\n",
+    "                        \n",
+    "                elif \"strength\" in section or \"demonstrated\" in section:\n",
+    "                    # Extract positive mentions\n",
+    "                    strengths = re.findall(r\"[-•*]\\s*(.+)$\", section, re.MULTILINE)\n",
+    "                    insights[\"strengths\"].extend(strengths)\n",
+    "                    \n",
+    "                elif \"objective\" in section or \"suggest\" in section:\n",
+    "                    # Extract recommended objectives\n",
+    "                    objectives = re.findall(r\"[-•*]\\s*(.+)$\", section, re.MULTILINE)\n",
+    "                    insights[\"suggested_objectives\"].extend(objectives)\n",
+    "            \n",
+    "            return insights\n",
+    "            \n",
+    "        except Exception as e:\n",
+    "            logger.error(f\"Error parsing analysis: {str(e)}\")\n",
+    "            return insights\n",
+    "    \n",
+    "    def _update_context_from_analysis(self, insights: Dict[str, Any]) -> None:\n",
+    "        \"\"\"\n",
+    "        Update learning context based on discussion analysis.\n",
+    "        \n",
+    "        Args:\n",
+    "            insights: Dictionary of analysis insights\n",
+    "        \"\"\"\n",
+    "        try:\n",
+    "            # Update knowledge gaps\n",
+    "            for topic, confidence in insights[\"gaps\"].items():\n",
+    "                self.learning_context.update_knowledge_gap(topic, confidence)\n",
+    "            \n",
+    "            # Add strengths\n",
+    "            for strength in insights[\"strengths\"]:\n",
+    "                self.learning_context.add_strength(strength)\n",
+    "            \n",
+    "            # Save context if path provided\n",
+    "            if self.context_path:\n",
+    "                self.learning_context.save_context(self.context_path)\n",
+    "                \n",
+    "        except Exception as e:\n",
+    "            logger.error(f\"Error updating context: {str(e)}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6a2b15f5-6841-43cb-9b57-c0e3f1a0b0c2",
+   "metadata": {},
+   "source": [
+    "## Tests"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "67ee6bde-4ade-448e-a831-86f9f7ae82ea",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "RuntimeError",
+     "evalue": "asyncio.run() cannot be called from a running event loop",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
+      "Cell \u001b[1;32mIn[7], line 55\u001b[0m\n\u001b[0;32m     53\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;18m__name__\u001b[39m \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m__main__\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[0;32m     54\u001b[0m     \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01masyncio\u001b[39;00m\n\u001b[1;32m---> 55\u001b[0m     \u001b[43masyncio\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtest_clinical_tutor\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[1;32m~\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\asyncio\\runners.py:190\u001b[0m, in \u001b[0;36mrun\u001b[1;34m(main, debug, loop_factory)\u001b[0m\n\u001b[0;32m    161\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Execute the coroutine and return the result.\u001b[39;00m\n\u001b[0;32m    162\u001b[0m \n\u001b[0;32m    163\u001b[0m \u001b[38;5;124;03mThis function runs the passed coroutine, taking care of\u001b[39;00m\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m    186\u001b[0m \u001b[38;5;124;03m    asyncio.run(main())\u001b[39;00m\n\u001b[0;32m    187\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m    188\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m events\u001b[38;5;241m.\u001b[39m_get_running_loop() \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m    189\u001b[0m     \u001b[38;5;66;03m# fail fast with short traceback\u001b[39;00m\n\u001b[1;32m--> 190\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\n\u001b[0;32m    191\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124masyncio.run() cannot be called from a running event loop\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m    193\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m Runner(debug\u001b[38;5;241m=\u001b[39mdebug, loop_factory\u001b[38;5;241m=\u001b[39mloop_factory) \u001b[38;5;28;01mas\u001b[39;00m runner:\n\u001b[0;32m    194\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m runner\u001b[38;5;241m.\u001b[39mrun(main)\n",
+      "\u001b[1;31mRuntimeError\u001b[0m: asyncio.run() cannot be called from a running event loop"
+     ]
+    }
+   ],
+   "source": [
+    "async def test_clinical_tutor():\n",
+    "    \"\"\"Test ClinicalTutor functionality\"\"\"\n",
+    "    if not os.getenv(\"OPENROUTER_API_KEY\"):\n",
+    "        print(\"Skipping tests: No API key\")\n",
+    "        return\n",
+    "        \n",
+    "    tutor = ClinicalTutor()\n",
+    "    \n",
+    "    # Test case discussion\n",
+    "    test_case = \"\"\"\n",
+    "    28yo M with chest pain\n",
+    "    - 2 days duration\n",
+    "    - Sharp, pleuritic\n",
+    "    - No fever or cough\n",
+    "    - Vitals stable\n",
+    "    - Clear exam\n",
+    "    A/P: Likely MSK pain\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    try:\n",
+    "        # Test basic discussion\n",
+    "        response = await tutor.discuss_case(test_case)\n",
+    "        assert isinstance(response, str)\n",
+    "        assert len(response) > 0\n",
+    "        \n",
+    "        # Only assert case tracking if chief complaint was detected\n",
+    "        if tutor.current_case[\"chief_complaint\"]:\n",
+    "            assert \"chest pain\" in tutor.current_case[\"chief_complaint\"].lower()\n",
+    "        \n",
+    "        print(\"Discussion test passed\")\n",
+    "        \n",
+    "        # Test discussion analysis\n",
+    "        conversation = [\n",
+    "            {\"role\": \"user\", \"content\": test_case},\n",
+    "            {\"role\": \"assistant\", \"content\": response}\n",
+    "        ]\n",
+    "        \n",
+    "        analysis = await tutor.analyze_discussion(conversation)\n",
+    "        assert isinstance(analysis, dict)\n",
+    "        assert all(k in analysis for k in [\n",
+    "            'learning_points', 'gaps', 'strengths', 'suggested_objectives'\n",
+    "        ])\n",
+    "        print(\"Analysis test passed\")\n",
+    "        \n",
+    "    except Exception as e:\n",
+    "        print(f\"Test failed: {str(e)}\")\n",
+    "        raise\n",
+    "    \n",
+    "    print(\"All clinical tutor tests passed!\")\n",
+    "\n",
+    "# Run tests\n",
+    "if __name__ == \"__main__\":\n",
+    "    import asyncio\n",
+    "    if not asyncio.get_event_loop().is_running():\n",
+    "        asyncio.run(test_clinical_tutor())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3f469c37-afe3-4682-9cc4-40326ac21b74",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

nbs/02_learning_interface.ipynb

@@ -0,0 +1,979 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7ce0a47c-1c4f-44a4-a9d8-9ea6399a8f84",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| default_exp learning_interface"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "55331735-898e-411b-b751-5b380605be36",
+   "metadata": {},
+   "source": [
+    "# Learning Interface\n",
+    "\n",
+    "> Gradio interface"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dd401991-b919-423e-9da7-961387faf11e",
+   "metadata": {},
+   "source": [
+    "## Setup"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "edc3fbb1-13ef-408a-b5fe-eb7a6821915b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| hide\n",
+    "from nbdev.showdoc import *"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4be213cf-89b4-48c8-9592-f509332da485",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "ImportError",
+     "evalue": "cannot import name 'ClinicalTutor' from 'wardbuddy.clinical_tutor' (C:\\Users\\deepa\\OneDrive\\Documents\\StudyBuddy\\wardbuddy\\wardbuddy\\clinical_tutor.py)",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mImportError\u001b[0m                               Traceback (most recent call last)",
+      "Cell \u001b[1;32mIn[4], line 7\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mpathlib\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m Path\n\u001b[0;32m      6\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01masyncio\u001b[39;00m\n\u001b[1;32m----> 7\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      8\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;01mutils\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m format_response\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;01mlearning_context\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m setup_logger\n",
+      "\u001b[1;31mImportError\u001b[0m: cannot import name 'ClinicalTutor' from 'wardbuddy.clinical_tutor' (C:\\Users\\deepa\\OneDrive\\Documents\\StudyBuddy\\wardbuddy\\wardbuddy\\clinical_tutor.py)"
+     ]
+    }
+   ],
+   "source": [
+    "#| export\n",
+    "from typing import Dict, List, Optional, Tuple, Any\n",
+    "import gradio as gr\n",
+    "from pathlib import Path\n",
+    "import asyncio\n",
+    "from datetime import datetime\n",
+    "import pandas as pd\n",
+    "from wardbuddy.clinical_tutor import ClinicalTutor\n",
+    "from wardbuddy.learning_context import setup_logger\n",
+    "\n",
+    "logger = setup_logger(__name__)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c39da1db-e630-4296-93f6-03b9188320cc",
+   "metadata": {},
+   "source": [
+    "## Learning Interface"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "aff3d321-2116-475f-b906-f74889e76d66",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export\n",
+    "def create_dashboard_css() -> str:\n",
+    "    \"\"\"Create custom CSS for dashboard styling\"\"\"\n",
+    "    return \"\"\"\n",
+    "    .dashboard-card {\n",
+    "        border: 1px solid #e2e8f0;\n",
+    "        border-radius: 8px;\n",
+    "        padding: 16px;\n",
+    "        margin: 8px 0;\n",
+    "        background: white;\n",
+    "    }\n",
+    "    \n",
+    "    .status-active {\n",
+    "        color: #48bb78;\n",
+    "        font-weight: 500;\n",
+    "    }\n",
+    "    \n",
+    "    .status-completed {\n",
+    "        color: #718096;\n",
+    "    }\n",
+    "    \n",
+    "    .dashboard-header {\n",
+    "        font-size: 1.25rem;\n",
+    "        font-weight: 600;\n",
+    "        margin-bottom: 1rem;\n",
+    "    }\n",
+    "    \n",
+    "    .summary-modal {\n",
+    "        max-width: 800px !important;\n",
+    "    }\n",
+    "    \n",
+    "    .feedback-tag {\n",
+    "        display: inline-block;\n",
+    "        padding: 4px 8px;\n",
+    "        border-radius: 4px;\n",
+    "        margin: 4px;\n",
+    "        font-size: 0.875rem;\n",
+    "    }\n",
+    "    \n",
+    "    .feedback-active {\n",
+    "        background: #ebf8ff;\n",
+    "        color: #2b6cb0;\n",
+    "    }\n",
+    "    \n",
+    "    .feedback-inactive {\n",
+    "        background: #f7fafc;\n",
+    "        color: #718096;\n",
+    "    }\n",
+    "    \"\"\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "de7ace04-4841-461d-89bb-234b5f8b48e1",
+   "metadata": {},
+   "source": [
+    "This module provides the user interface for the clinical learning system, including:\n",
+    " * Case presentation and feedback\n",
+    " * Learning preference configuration\n",
+    " * Session management\n",
+    " * Progress visualization"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "675c20cc-43aa-4897-89ba-4fa26dd37c20",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export\n",
+    "\n",
+    "class LearningInterface:\n",
+    "    \"\"\"\n",
+    "    Gradio interface for clinical learning interactions.\n",
+    "    \n",
+    "    Features:\n",
+    "    - Natural case discussion chat\n",
+    "    - Dynamic learning dashboard\n",
+    "    - Post-discussion analysis\n",
+    "    - Progress tracking\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    def __init__(\n",
+    "        self,\n",
+    "        context_path: Optional[Path] = None,\n",
+    "        theme: str = \"default\"\n",
+    "    ):\n",
+    "        \"\"\"Initialize learning interface.\"\"\"\n",
+    "        self.tutor = ClinicalTutor(context_path)\n",
+    "        self.theme = theme\n",
+    "        self.context_path = context_path\n",
+    "        \n",
+    "        # Track current discussion state\n",
+    "        self.current_discussion = {\n",
+    "            \"started\": None,\n",
+    "            \"case_type\": None,\n",
+    "            \"messages\": []\n",
+    "        }\n",
+    "        \n",
+    "        logger.info(\"Learning interface initialized\")\n",
+    "    \n",
+    "    async def process_chat(\n",
+    "        self,\n",
+    "        message: str,\n",
+    "        history: List[Dict[str, str]],\n",
+    "        state: Dict[str, Any]\n",
+    "    ) -> Tuple[List[Dict[str, str]], str, Dict[str, Any]]:\n",
+    "        \"\"\"\n",
+    "        Process chat messages with state management.\n",
+    "        \n",
+    "        Args:\n",
+    "            message: User input message\n",
+    "            history: Chat history\n",
+    "            state: Current interface state\n",
+    "            \n",
+    "        Returns:\n",
+    "            tuple: (updated history, cleared message, updated state)\n",
+    "        \"\"\"\n",
+    "        try:\n",
+    "            if not message.strip():\n",
+    "                return history, \"\", state\n",
+    "            \n",
+    "            # Start new discussion if none active\n",
+    "            if not state.get(\"discussion_active\"):\n",
+    "                state[\"discussion_active\"] = True\n",
+    "                state[\"discussion_start\"] = datetime.now().isoformat()\n",
+    "            \n",
+    "            # Get tutor response\n",
+    "            response = await self.tutor.discuss_case(message)\n",
+    "            \n",
+    "            # Update history and state\n",
+    "            if history is None:\n",
+    "                history = []\n",
+    "            history.extend([\n",
+    "                {\"role\": \"user\", \"content\": message},\n",
+    "                {\"role\": \"assistant\", \"content\": response}\n",
+    "            ])\n",
+    "            \n",
+    "            state[\"last_message\"] = datetime.now().isoformat()\n",
+    "            \n",
+    "            return history, \"\", state\n",
+    "            \n",
+    "        except Exception as e:\n",
+    "            logger.error(f\"Error in chat: {str(e)}\")\n",
+    "            return history or [], \"\", state\n",
+    "\n",
+    "    async def end_discussion(\n",
+    "        self,\n",
+    "        history: List[Dict[str, str]],\n",
+    "        state: Dict[str, Any]\n",
+    "    ) -> Tuple[Dict[str, Any], Dict[str, Any]]:\n",
+    "        \"\"\"\n",
+    "        Analyze completed discussion and prepare summary.\n",
+    "        \n",
+    "        Args:\n",
+    "            history: Chat history\n",
+    "            state: Current interface state\n",
+    "            \n",
+    "        Returns:\n",
+    "            tuple: (analysis results, updated state)\n",
+    "        \"\"\"\n",
+    "        try:\n",
+    "            if not history:\n",
+    "                return {\n",
+    "                    \"learning_points\": [],\n",
+    "                    \"gaps\": {},\n",
+    "                    \"strengths\": [],\n",
+    "                    \"suggested_objectives\": []\n",
+    "                }, state\n",
+    "            \n",
+    "            # Get analysis\n",
+    "            analysis = await self.tutor.analyze_discussion(history)\n",
+    "            \n",
+    "            # Reset discussion state\n",
+    "            state[\"discussion_active\"] = False\n",
+    "            state[\"discussion_start\"] = None\n",
+    "            state[\"last_message\"] = None\n",
+    "            \n",
+    "            return analysis, state\n",
+    "            \n",
+    "        except Exception as e:\n",
+    "            logger.error(f\"Error analyzing discussion: {str(e)}\")\n",
+    "            return {\n",
+    "                \"learning_points\": [],\n",
+    "                \"gaps\": {},\n",
+    "                \"strengths\": [],\n",
+    "                \"suggested_objectives\": []\n",
+    "            }, state\n",
+    "    \n",
+    "    def update_rotation(\n",
+    "        self,\n",
+    "        specialty: str,\n",
+    "        start_date: str,\n",
+    "        end_date: str,\n",
+    "        focus_areas: str\n",
+    "    ) -> Tuple[str, str, str, str]:\n",
+    "        \"\"\"\n",
+    "        Update rotation details and return updated values.\n",
+    "        \n",
+    "        Args:\n",
+    "            specialty: Rotation specialty\n",
+    "            start_date: Start date string\n",
+    "            end_date: End date string\n",
+    "            focus_areas: Comma-separated focus areas\n",
+    "            \n",
+    "        Returns:\n",
+    "            tuple: Updated field values\n",
+    "        \"\"\"\n",
+    "        try:\n",
+    "            # Parse focus areas\n",
+    "            focus_list = [\n",
+    "                area.strip() \n",
+    "                for area in focus_areas.split(\",\") \n",
+    "                if area.strip()\n",
+    "            ]\n",
+    "            \n",
+    "            # Update context\n",
+    "            rotation = {\n",
+    "                \"specialty\": specialty,\n",
+    "                \"start_date\": start_date,\n",
+    "                \"end_date\": end_date,\n",
+    "                \"key_focus_areas\": focus_list\n",
+    "            }\n",
+    "            self.tutor.learning_context.update_rotation(rotation)\n",
+    "            \n",
+    "            # Return updated values\n",
+    "            return (\n",
+    "                specialty,\n",
+    "                start_date,\n",
+    "                end_date,\n",
+    "                \",\".join(focus_list)\n",
+    "            )\n",
+    "            \n",
+    "        except Exception as e:\n",
+    "            logger.error(f\"Error updating rotation: {str(e)}\")\n",
+    "            current = self.tutor.learning_context.current_rotation\n",
+    "            return (\n",
+    "                current[\"specialty\"],\n",
+    "                current[\"start_date\"] or \"\",\n",
+    "                current[\"end_date\"] or \"\",\n",
+    "                \",\".join(current[\"key_focus_areas\"])\n",
+    "            )\n",
+    "\n",
+    "    def add_objective(\n",
+    "        self,\n",
+    "        objective: str,\n",
+    "        objectives_df: pd.DataFrame\n",
+    "    ) -> pd.DataFrame:\n",
+    "        \"\"\"\n",
+    "        Add new learning objective and return updated dataframe.\n",
+    "        \n",
+    "        Args:\n",
+    "            objective: New objective text\n",
+    "            objectives_df: Current objectives dataframe\n",
+    "            \n",
+    "        Returns:\n",
+    "            pd.DataFrame: Updated objectives list\n",
+    "        \"\"\"\n",
+    "        try:\n",
+    "            if not objective.strip():\n",
+    "                return objectives_df\n",
+    "                \n",
+    "            # Add to context\n",
+    "            self.tutor.learning_context.add_learning_objective(objective)\n",
+    "            \n",
+    "            # Convert to dataframe\n",
+    "            return pd.DataFrame([\n",
+    "                [obj[\"objective\"], obj[\"status\"], obj[\"added\"]]\n",
+    "                for obj in self.tutor.learning_context.learning_objectives\n",
+    "            ], columns=[\"Objective\", \"Status\", \"Date Added\"])\n",
+    "            \n",
+    "        except Exception as e:\n",
+    "            logger.error(f\"Error adding objective: {str(e)}\")\n",
+    "            return objectives_df\n",
+    "\n",
+    "    def toggle_objective_status(\n",
+    "        self,\n",
+    "        evt: gr.SelectData,  # Updated to use gr.SelectData\n",
+    "        objectives_df: pd.DataFrame\n",
+    "    ) -> pd.DataFrame:\n",
+    "        \"\"\"\n",
+    "        Toggle objective status between active and completed.\n",
+    "        \n",
+    "        Args:\n",
+    "            evt: Gradio select event containing row index\n",
+    "            objectives_df: Current objectives dataframe\n",
+    "            \n",
+    "        Returns:\n",
+    "            pd.DataFrame: Updated objectives list\n",
+    "        \"\"\"\n",
+    "        try:\n",
+    "            objective_idx = evt.index[0]  # Get selected row index\n",
+    "            if objective_idx >= len(objectives_df):\n",
+    "                return objectives_df\n",
+    "                \n",
+    "            # Get objective\n",
+    "            objective = objectives_df.iloc[objective_idx][\"Objective\"]\n",
+    "            current_status = objectives_df.iloc[objective_idx][\"Status\"]\n",
+    "            \n",
+    "            # Toggle in context\n",
+    "            if current_status == \"active\":\n",
+    "                self.tutor.learning_context.complete_objective(objective)\n",
+    "            else:\n",
+    "                self.tutor.learning_context.add_learning_objective(objective)\n",
+    "            \n",
+    "            # Update dataframe\n",
+    "            return pd.DataFrame([\n",
+    "                [obj[\"objective\"], obj[\"status\"], obj[\"added\"]]\n",
+    "                for obj in self.tutor.learning_context.learning_objectives\n",
+    "            ], columns=[\"Objective\", \"Status\", \"Date Added\"])\n",
+    "            \n",
+    "        except Exception as e:\n",
+    "            logger.error(f\"Error toggling objective: {str(e)}\")\n",
+    "            return objectives_df\n",
+    "\n",
+    "    def add_feedback_focus(\n",
+    "        self,\n",
+    "        focus: str,\n",
+    "        feedback_df: pd.DataFrame\n",
+    "    ) -> pd.DataFrame:\n",
+    "        \"\"\"Add new feedback focus area.\"\"\"\n",
+    "        try:\n",
+    "            if not focus.strip():\n",
+    "                return feedback_df\n",
+    "                \n",
+    "            # Add to context\n",
+    "            self.tutor.learning_context.toggle_feedback_focus(focus, True)\n",
+    "            \n",
+    "            # Update dataframe\n",
+    "            return pd.DataFrame([\n",
+    "                [pref[\"focus\"], pref[\"active\"]]\n",
+    "                for pref in self.tutor.learning_context.feedback_preferences\n",
+    "            ], columns=[\"Focus Area\", \"Active\"])\n",
+    "            \n",
+    "        except Exception as e:\n",
+    "            logger.error(f\"Error adding feedback focus: {str(e)}\")\n",
+    "            return feedback_df\n",
+    "\n",
+    "    def toggle_feedback_status(\n",
+    "        self,\n",
+    "        evt: gr.SelectData,  # Updated to use gr.SelectData\n",
+    "        feedback_df: pd.DataFrame\n",
+    "    ) -> pd.DataFrame:\n",
+    "        \"\"\"Toggle feedback focus active status.\"\"\"\n",
+    "        try:\n",
+    "            focus_idx = evt.index[0]  # Get selected row index\n",
+    "            if focus_idx >= len(feedback_df):\n",
+    "                return feedback_df\n",
+    "                \n",
+    "            # Get focus area\n",
+    "            focus = feedback_df.iloc[focus_idx][\"Focus Area\"]\n",
+    "            current_status = feedback_df.iloc[focus_idx][\"Active\"]\n",
+    "            \n",
+    "            # Toggle in context\n",
+    "            self.tutor.learning_context.toggle_feedback_focus(\n",
+    "                focus, \n",
+    "                not current_status\n",
+    "            )\n",
+    "            \n",
+    "            # Update dataframe\n",
+    "            return pd.DataFrame([\n",
+    "                [pref[\"focus\"], pref[\"active\"]]\n",
+    "                for pref in self.tutor.learning_context.feedback_preferences\n",
+    "            ], columns=[\"Focus Area\", \"Active\"])\n",
+    "            \n",
+    "        except Exception as e:\n",
+    "            logger.error(f\"Error toggling feedback: {str(e)}\")\n",
+    "            return feedback_df\n",
+    "\n",
+    "    def create_interface(self) -> gr.Blocks:\n",
+    "        \"\"\"Create and configure the Gradio interface\"\"\"\n",
+    "        with gr.Blocks(\n",
+    "            title=\"Clinical Learning Assistant\",\n",
+    "            theme=self.theme,\n",
+    "            css=create_dashboard_css()\n",
+    "        ) as interface:\n",
+    "            # State management\n",
+    "            state = gr.State({\n",
+    "                \"discussion_active\": False,\n",
+    "                \"discussion_start\": None,\n",
+    "                \"last_message\": None\n",
+    "            })\n",
+    "            \n",
+    "            # Header\n",
+    "            with gr.Row():\n",
+    "                gr.Markdown(\n",
+    "                    \"# Clinical Learning Assistant\",\n",
+    "                    elem_classes=[\"dashboard-header\"]\n",
+    "                )\n",
+    "            \n",
+    "            with gr.Row():\n",
+    "                # Left column - Chat interface\n",
+    "                with gr.Column(scale=2):\n",
+    "                    # Active discussion indicator\n",
+    "                    discussion_status = gr.Markdown(\n",
+    "                        \"Start a new case discussion\",\n",
+    "                        elem_classes=[\"dashboard-card\"]\n",
+    "                    )\n",
+    "                    \n",
+    "                    # Chat interface\n",
+    "                    chatbot = gr.Chatbot(\n",
+    "                        height=500,\n",
+    "                        label=\"Case Discussion\",\n",
+    "                        show_label=True,\n",
+    "                        elem_classes=[\"dashboard-card\"]\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=5\n",
+    "                        )\n",
+    "                    \n",
+    "                    with gr.Row():\n",
+    "                        clear = gr.Button(\"Clear Discussion\")\n",
+    "                        end_discussion = gr.Button(\n",
+    "                            \"End Discussion & Review\",\n",
+    "                            variant=\"primary\"\n",
+    "                        )\n",
+    "                \n",
+    "                # Right column - Learning dashboard\n",
+    "                with gr.Column(scale=1):\n",
+    "                    with gr.Tabs():\n",
+    "                        # Current Rotation tab\n",
+    "                        with gr.Tab(\"Current Rotation\"):\n",
+    "                            with gr.Column(elem_classes=[\"dashboard-card\"]):\n",
+    "                                specialty = gr.Textbox(\n",
+    "                                    label=\"Specialty\",\n",
+    "                                    value=self.tutor.learning_context.current_rotation[\"specialty\"]\n",
+    "                                )\n",
+    "                                start_date = gr.Textbox(\n",
+    "                                    label=\"Start Date (YYYY-MM-DD)\",\n",
+    "                                    value=self.tutor.learning_context.current_rotation[\"start_date\"]\n",
+    "                                )\n",
+    "                                end_date = gr.Textbox(\n",
+    "                                    label=\"End Date (YYYY-MM-DD)\",\n",
+    "                                    value=self.tutor.learning_context.current_rotation[\"end_date\"]\n",
+    "                                )\n",
+    "                                focus_areas = gr.Textbox(\n",
+    "                                    label=\"Key Focus Areas (comma-separated)\",\n",
+    "                                    value=\",\".join(\n",
+    "                                        self.tutor.learning_context.current_rotation[\"key_focus_areas\"]\n",
+    "                                    )\n",
+    "                                )\n",
+    "                                update_rotation_btn = gr.Button(\n",
+    "                                    \"Update Rotation\",\n",
+    "                                    variant=\"secondary\"\n",
+    "                                )\n",
+    "                        \n",
+    "                        # Learning Objectives tab\n",
+    "                        with gr.Tab(\"Learning Objectives\"):\n",
+    "                            with gr.Column(elem_classes=[\"dashboard-card\"]):\n",
+    "                                objectives_df = gr.DataFrame(\n",
+    "                                    headers=[\"Objective\", \"Status\", \"Date Added\"],\n",
+    "                                    value=[[\n",
+    "                                        obj[\"objective\"],\n",
+    "                                        obj[\"status\"],\n",
+    "                                        obj[\"added\"]\n",
+    "                                    ] for obj in self.tutor.learning_context.learning_objectives],\n",
+    "                                    interactive=True,\n",
+    "                                    wrap=True\n",
+    "                                )\n",
+    "                                \n",
+    "                                with gr.Row():\n",
+    "                                    new_objective = gr.Textbox(\n",
+    "                                        label=\"New Learning Objective\",\n",
+    "                                        placeholder=\"Enter objective...\"\n",
+    "                                    )\n",
+    "                                    add_objective_btn = gr.Button(\n",
+    "                                        \"Add\",\n",
+    "                                        variant=\"secondary\"\n",
+    "                                    )\n",
+    "                        \n",
+    "                        # Feedback Preferences tab\n",
+    "                        with gr.Tab(\"Feedback Focus\"):\n",
+    "                            with gr.Column(elem_classes=[\"dashboard-card\"]):\n",
+    "                                feedback_df = gr.DataFrame(\n",
+    "                                    headers=[\"Focus Area\", \"Active\"],\n",
+    "                                    value=[[\n",
+    "                                        pref[\"focus\"],\n",
+    "                                        pref[\"active\"]\n",
+    "                                    ] for pref in self.tutor.learning_context.feedback_preferences],\n",
+    "                                    interactive=True,\n",
+    "                                    wrap=True\n",
+    "                                )\n",
+    "                                \n",
+    "                                with gr.Row():\n",
+    "                                    new_feedback = gr.Textbox(\n",
+    "                                        label=\"New Feedback Focus\",\n",
+    "                                        placeholder=\"Enter focus area...\"\n",
+    "                                    )\n",
+    "                                    add_feedback_btn = gr.Button(\n",
+    "                                        \"Add\",\n",
+    "                                        variant=\"secondary\"\n",
+    "                                    )\n",
+    "                                    \n",
+    "                        # Knowledge Profile tab\n",
+    "                        with gr.Tab(\"Knowledge Profile\"):\n",
+    "                            with gr.Column(elem_classes=[\"dashboard-card\"]):\n",
+    "                                # Knowledge Gaps\n",
+    "                                gr.Markdown(\"### Knowledge Gaps\")\n",
+    "                                gaps_display = gr.DataFrame(\n",
+    "                                    headers=[\"Topic\", \"Confidence\"],\n",
+    "                                    value=[[\n",
+    "                                        topic, confidence\n",
+    "                                    ] for topic, confidence in \n",
+    "                                        self.tutor.learning_context.knowledge_profile[\"gaps\"].items()\n",
+    "                                    ],\n",
+    "                                    interactive=False\n",
+    "                                )\n",
+    "                                \n",
+    "                                # Strengths Display\n",
+    "                                gr.Markdown(\"### Strengths\")\n",
+    "                                strengths_display = gr.DataFrame(\n",
+    "                                    headers=[\"Area\"],\n",
+    "                                    value=[[strength] for strength in \n",
+    "                                        self.tutor.learning_context.knowledge_profile[\"strengths\"]\n",
+    "                                    ],\n",
+    "                                    interactive=False\n",
+    "                                )\n",
+    "                                \n",
+    "                                # Recent Progress\n",
+    "                                gr.Markdown(\"### Recent Progress\")\n",
+    "                                progress_display = gr.DataFrame(\n",
+    "                                    headers=[\"Topic\", \"Improvement\", \"Date\"],\n",
+    "                                    value=[[\n",
+    "                                        prog[\"topic\"],\n",
+    "                                        f\"{prog['improvement']:.2f}\",\n",
+    "                                        prog[\"date\"]\n",
+    "                                    ] for prog in \n",
+    "                                        self.tutor.learning_context.knowledge_profile[\"recent_progress\"]\n",
+    "                                    ],\n",
+    "                                    interactive=False\n",
+    "                                )\n",
+    "            \n",
+    "            # Discussion summary section\n",
+    "            summary_section = gr.Column(visible=False)\n",
+    "            with summary_section:\n",
+    "                gr.Markdown(\"## Discussion Summary\")\n",
+    "                \n",
+    "                # Overview section\n",
+    "                with gr.Row():\n",
+    "                    with gr.Column():\n",
+    "                        gr.Markdown(\"### Session Overview\")\n",
+    "                        session_overview = gr.JSON(\n",
+    "                            label=\"Discussion Details\",\n",
+    "                            value={\n",
+    "                                \"duration\": \"0 minutes\",\n",
+    "                                \"messages\": 0,\n",
+    "                                \"topics_covered\": []\n",
+    "                            }\n",
+    "                        )\n",
+    "                \n",
+    "                # Learning Points and Gaps\n",
+    "                with gr.Row():\n",
+    "                    with gr.Column():\n",
+    "                        gr.Markdown(\"### Key Learning Points\")\n",
+    "                        learning_points = gr.JSON(label=\"Points to Remember\")\n",
+    "                    \n",
+    "                    with gr.Column():\n",
+    "                        gr.Markdown(\"### Knowledge Profile Updates\")\n",
+    "                        with gr.Row():\n",
+    "                            gaps = gr.JSON(label=\"Areas for Improvement\")\n",
+    "                            strengths = gr.JSON(label=\"Demonstrated Strengths\")\n",
+    "                \n",
+    "                # Future Learning section\n",
+    "                gr.Markdown(\"### Planning Ahead\")\n",
+    "                with gr.Row():\n",
+    "                    with gr.Column():\n",
+    "                        gr.Markdown(\"#### Suggested Learning Objectives\")\n",
+    "                        objectives = gr.JSON(label=\"Consider Adding\")\n",
+    "                    \n",
+    "                    with gr.Column():\n",
+    "                        gr.Markdown(\"#### Recommended Focus Areas\")\n",
+    "                        recommendations = gr.JSON(label=\"Next Steps\")\n",
+    "                \n",
+    "                # Action buttons\n",
+    "                with gr.Row():\n",
+    "                    add_selected_objectives = gr.Button(\n",
+    "                        \"Add Selected Objectives\",\n",
+    "                        variant=\"primary\"\n",
+    "                    )\n",
+    "                    close_summary = gr.Button(\"Close Summary\")\n",
+    "    \n",
+    "            # Event handlers\n",
+    "            msg.submit(\n",
+    "                self.process_chat,\n",
+    "                inputs=[msg, chatbot, state],\n",
+    "                outputs=[chatbot, msg, state]\n",
+    "            ).then(\n",
+    "                self._update_discussion_status,\n",
+    "                inputs=[state],\n",
+    "                outputs=[discussion_status]\n",
+    "            )\n",
+    "            \n",
+    "            clear.click(\n",
+    "                lambda: ([], \"\", {\n",
+    "                    \"discussion_active\": False,\n",
+    "                    \"discussion_start\": None,\n",
+    "                    \"last_message\": None\n",
+    "                }),\n",
+    "                outputs=[chatbot, msg, state]\n",
+    "            ).then(\n",
+    "                lambda: \"Start a new case discussion\",\n",
+    "                outputs=[discussion_status]\n",
+    "            )\n",
+    "            \n",
+    "            end_discussion.click(\n",
+    "                self.end_discussion,\n",
+    "                inputs=[chatbot, state],\n",
+    "                outputs=[\n",
+    "                    session_overview,\n",
+    "                    learning_points,\n",
+    "                    gaps,\n",
+    "                    strengths,\n",
+    "                    objectives,\n",
+    "                    recommendations\n",
+    "                ]\n",
+    "            ).then(\n",
+    "                lambda: gr.update(visible=True),\n",
+    "                None,\n",
+    "                summary_section\n",
+    "            ).then(\n",
+    "                self._refresh_knowledge_profile,\n",
+    "                outputs=[gaps_display, strengths_display, progress_display]\n",
+    "            )\n",
+    "            \n",
+    "            close_summary.click(\n",
+    "                lambda: gr.update(visible=False),\n",
+    "                None,\n",
+    "                summary_section\n",
+    "            )\n",
+    "            \n",
+    "            # Rotation management\n",
+    "            update_rotation_btn.click(\n",
+    "                self.update_rotation,\n",
+    "                inputs=[specialty, start_date, end_date, focus_areas],\n",
+    "                outputs=[specialty, start_date, end_date, focus_areas]\n",
+    "            )\n",
+    "            \n",
+    "            # Learning objectives management\n",
+    "            add_objective_btn.click(\n",
+    "                self.add_objective,\n",
+    "                inputs=[new_objective, objectives_df],\n",
+    "                outputs=[objectives_df]\n",
+    "            ).then(\n",
+    "                lambda: \"\",\n",
+    "                None,\n",
+    "                new_objective\n",
+    "            )\n",
+    "            \n",
+    "            objectives_df.select(\n",
+    "                self.toggle_objective_status,\n",
+    "                inputs=[objectives_df],\n",
+    "                outputs=[objectives_df]\n",
+    "            )\n",
+    "            \n",
+    "            # Feedback preferences management\n",
+    "            add_feedback_btn.click(\n",
+    "                self.add_feedback_focus,\n",
+    "                inputs=[new_feedback, feedback_df],\n",
+    "                outputs=[feedback_df]\n",
+    "            ).then(\n",
+    "                lambda: \"\",\n",
+    "                None,\n",
+    "                new_feedback\n",
+    "            )\n",
+    "            \n",
+    "            feedback_df.select(\n",
+    "                self.toggle_feedback_status,\n",
+    "                inputs=[feedback_df],\n",
+    "                outputs=[feedback_df]\n",
+    "            )\n",
+    "            \n",
+    "            # Add selected objectives from summary\n",
+    "            add_selected_objectives.click(\n",
+    "                self._add_suggested_objectives,\n",
+    "                inputs=[objectives],\n",
+    "                outputs=[objectives_df]\n",
+    "            )\n",
+    "    \n",
+    "            return interface\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",
+    "    def _refresh_knowledge_profile(\n",
+    "        self\n",
+    "    ) -> Tuple[List[List[str]], List[List[str]], List[List[str]]]:\n",
+    "        \"\"\"Refresh knowledge profile displays\"\"\"\n",
+    "        try:\n",
+    "            # Gaps\n",
+    "            gaps_data = [[\n",
+    "                topic, f\"{confidence:.2f}\"\n",
+    "            ] for topic, confidence in \n",
+    "                self.tutor.learning_context.knowledge_profile[\"gaps\"].items()\n",
+    "            ]\n",
+    "            \n",
+    "            # Strengths\n",
+    "            strengths_data = [[\n",
+    "                strength\n",
+    "            ] for strength in \n",
+    "                self.tutor.learning_context.knowledge_profile[\"strengths\"]\n",
+    "            ]\n",
+    "            \n",
+    "            # Progress\n",
+    "            progress_data = [[\n",
+    "                prog[\"topic\"],\n",
+    "                f\"{prog['improvement']:.2f}\",\n",
+    "                prog[\"date\"]\n",
+    "            ] for prog in \n",
+    "                self.tutor.learning_context.knowledge_profile[\"recent_progress\"]\n",
+    "            ]\n",
+    "            \n",
+    "            return gaps_data, strengths_data, progress_data\n",
+    "            \n",
+    "        except Exception as e:\n",
+    "            logger.error(f\"Error refreshing profile: {str(e)}\")\n",
+    "            return [], [], []\n",
+    "    \n",
+    "    def _add_suggested_objectives(\n",
+    "        self,\n",
+    "        evt: gr.SelectData,  # Updated to use gr.SelectData\n",
+    "        suggested_objectives: List[str]\n",
+    "    ) -> pd.DataFrame:\n",
+    "        \"\"\"Add selected suggested objectives to learning objectives\"\"\"\n",
+    "        try:\n",
+    "            selected_indices = [evt.index[0]]  # Get selected row index\n",
+    "            \n",
+    "            for idx in selected_indices:\n",
+    "                if idx < len(suggested_objectives):\n",
+    "                    objective = suggested_objectives[idx]\n",
+    "                    self.tutor.learning_context.add_learning_objective(objective)\n",
+    "            \n",
+    "            return pd.DataFrame([\n",
+    "                [obj[\"objective\"], obj[\"status\"], obj[\"added\"]]\n",
+    "                for obj in self.tutor.learning_context.learning_objectives\n",
+    "            ], columns=[\"Objective\", \"Status\", \"Date Added\"])\n",
+    "            \n",
+    "        except Exception as e:\n",
+    "            logger.error(f\"Error adding objectives: {str(e)}\")\n",
+    "            return pd.DataFrame()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "30c0f121-5d5f-4dc0-b897-f6e2067a63b2",
+   "metadata": {},
+   "source": [
+    "## Launch Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "65f97529-b221-4a19-9856-fb20d7f7316e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export\n",
+    "async def launch_learning_interface(\n",
+    "    port: Optional[int] = None,\n",
+    "    context_path: Optional[Path] = None,\n",
+    "    share: bool = False,\n",
+    "    theme: str = \"default\"\n",
+    ") -> None:\n",
+    "    \"\"\"Launch the learning interface application.\"\"\"\n",
+    "    try:\n",
+    "        interface = LearningInterface(context_path, theme)\n",
+    "        app = interface.create_interface()\n",
+    "        app.launch(\n",
+    "            server_port=port,\n",
+    "            share=share\n",
+    "        )\n",
+    "        logger.info(f\"Interface launched on port: {port}\")\n",
+    "    except Exception as e:\n",
+    "        logger.error(f\"Error launching interface: {str(e)}\")\n",
+    "        raise"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5c75de88-f6d5-4a5d-92b5-1ebe85895a84",
+   "metadata": {},
+   "source": [
+    "## Tests"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "365bc95a-d189-4ab2-aa30-022d0286b5ba",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "async def test_learning_interface():\n",
+    "    \"\"\"Test learning interface functionality\"\"\"\n",
+    "    interface = LearningInterface()\n",
+    "    \n",
+    "    # Test chat processing\n",
+    "    history = []\n",
+    "    test_input = \"28yo M with chest pain\"\n",
+    "    \n",
+    "    new_history, msg = await interface.process_chat(test_input, history)\n",
+    "    assert isinstance(new_history, list)\n",
+    "    assert len(new_history) == 2  # User message + response\n",
+    "    assert new_history[0][\"role\"] == \"user\"\n",
+    "    assert new_history[0][\"content\"] == test_input\n",
+    "    \n",
+    "    # Test discussion analysis\n",
+    "    analysis = await interface.end_discussion(new_history)\n",
+    "    assert isinstance(analysis, dict)\n",
+    "    assert all(k in analysis for k in [\n",
+    "        'learning_points', 'gaps', 'strengths', 'suggested_objectives'\n",
+    "    ])\n",
+    "    \n",
+    "    # Test rotation updates\n",
+    "        rotation = interface.update_rotation(\n",
+    "        \"Emergency Medicine\",\n",
+    "        \"2025-01-01\",\n",
+    "        \"2025-03-31\",\n",
+    "        [\"Resuscitation\", \"Procedures\"]\n",
+    "    )\n",
+    "    assert rotation[\"specialty\"] == \"Emergency Medicine\"\n",
+    "    assert \"Resuscitation\" in rotation[\"key_focus_areas\"]\n",
+    "    \n",
+    "    # Test objective management\n",
+    "    objectives = interface.toggle_objective(\"Improve chest pain assessment\", False)\n",
+    "    assert len(objectives) == 1\n",
+    "    assert objectives[0][\"status\"] == \"active\"\n",
+    "    \n",
+    "    objectives = interface.toggle_objective(\"Improve chest pain assessment\", True)\n",
+    "    assert objectives[0][\"status\"] == \"completed\"\n",
+    "    \n",
+    "    # Test feedback preferences\n",
+    "    preferences = interface.toggle_feedback(\"Include more ddx\", True)\n",
+    "    assert len(preferences) == 1\n",
+    "    assert preferences[0][\"active\"] == True\n",
+    "    \n",
+    "    print(\"Interface tests passed!\")\n",
+    "\n",
+    "# Run tests\n",
+    "if __name__ == \"__main__\":\n",
+    "    import asyncio\n",
+    "    if not asyncio.get_event_loop().is_running():\n",
+    "        asyncio.run(test_learning_interface())"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

nbs/03_utils.ipynb

@@ -0,0 +1,210 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ecaeafe7-8cef-4117-8b58-bcf774175b88",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| default_exp utils"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "95ff67c2-a1a7-4c35-b704-f0a8beb6822e",
+   "metadata": {},
+   "source": [
+    "# Utils\n",
+    "\n",
+    "> Shared utilities for the entire learning system"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1ceb8d6e-dbdf-4d3c-8956-7686284d9b9d",
+   "metadata": {},
+   "source": [
+    "## Setup"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "25924b5e-01c9-44ca-a519-d399cf44ef07",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| hide\n",
+    "from nbdev.showdoc import show_doc"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5c3c4745-4603-49be-8394-3c16237e18bf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export\n",
+    "from typing import Dict, List, Optional, Any, Tuple\n",
+    "import json\n",
+    "from pathlib import Path\n",
+    "import logging\n",
+    "from datetime import datetime"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "26603641-e577-4c99-a2b4-34e77a79005b",
+   "metadata": {},
+   "source": [
+    "## Utilities"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "59cefaf9-f6b2-4617-bd16-c0ed068d400c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export\n",
+    "def setup_logger(name: str) -> logging.Logger:\n",
+    "    \"\"\"Set up module logger with consistent formatting\"\"\"\n",
+    "    logger = logging.getLogger(name)\n",
+    "    if not logger.handlers:\n",
+    "        handler = logging.StreamHandler()\n",
+    "        handler.setFormatter(\n",
+    "            logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')\n",
+    "        )\n",
+    "        logger.addHandler(handler)\n",
+    "        logger.setLevel(logging.INFO)\n",
+    "    return logger\n",
+    "\n",
+    "logger = setup_logger(__name__)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "86982e56-5813-4684-a557-a6509a3a4de0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export\n",
+    "def load_context_safely(path: Path) -> Dict:\n",
+    "    \"\"\"\n",
+    "    Safely load learning context from JSON file.\n",
+    "    \n",
+    "    Args:\n",
+    "        path: Path to context file\n",
+    "        \n",
+    "    Returns:\n",
+    "        dict: Loaded context data\n",
+    "        \n",
+    "    Raises:\n",
+    "        ValueError: If file is invalid or inaccessible\n",
+    "    \"\"\"\n",
+    "    try:\n",
+    "        with open(path, 'r') as f:\n",
+    "            return json.load(f)\n",
+    "    except json.JSONDecodeError as e:\n",
+    "        raise ValueError(f\"Invalid context file format: {str(e)}\")\n",
+    "    except Exception as e:\n",
+    "        raise ValueError(f\"Error loading context file: {str(e)}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ae53b367-4ca7-4c00-bed6-a6ff3dcf93cc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export\n",
+    "def save_context_safely(context: Dict, path: Path) -> None:\n",
+    "    \"\"\"\n",
+    "    Safely save learning context to JSON file.\n",
+    "    \n",
+    "    Args:\n",
+    "        context: Context data to save\n",
+    "        path: Path to save file\n",
+    "        \n",
+    "    Raises:\n",
+    "        ValueError: If save operation fails\n",
+    "    \"\"\"\n",
+    "    try:\n",
+    "        with open(path, 'w') as f:\n",
+    "            json.dump(context, f, indent=2)\n",
+    "    except Exception as e:\n",
+    "        raise ValueError(f\"Error saving context: {str(e)}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "35c98021-745a-441b-8abf-4f4ee5468e1b",
+   "metadata": {},
+   "source": [
+    "## Tests"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e09d2392-e5c4-4dbf-b784-be0acb1fb8fc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def test_utils():\n",
+    "    \"\"\"Test utility functions\"\"\"\n",
+    "    # Test logger setup\n",
+    "    test_logger = setup_logger(\"test\")\n",
+    "    assert test_logger.level == logging.INFO\n",
+    "    assert len(test_logger.handlers) == 1\n",
+    "    \n",
+    "    # Test context loading/saving\n",
+    "    test_path = Path(\"test_context.json\")\n",
+    "    test_data = {\n",
+    "        \"current_rotation\": {\"specialty\": \"ED\"},\n",
+    "        \"learning_objectives\": [],\n",
+    "        \"knowledge_profile\": {\"gaps\": {}, \"strengths\": []}\n",
+    "    }\n",
+    "    \n",
+    "    # Test save\n",
+    "    save_context_safely(test_data, test_path)\n",
+    "    assert test_path.exists()\n",
+    "    \n",
+    "    # Test load\n",
+    "    loaded = load_context_safely(test_path)\n",
+    "    assert loaded == test_data\n",
+    "    \n",
+    "    # Cleanup\n",
+    "    test_path.unlink()\n",
+    "    \n",
+    "    print(\"Utility tests passed!\")\n",
+    "\n",
+    "# Run tests\n",
+    "if __name__ == \"__main__\":\n",
+    "    test_utils()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e91d5138-1ca0-4057-8a13-af0b89dc0a93",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "python3",
+   "language": "python",
+   "name": "python3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

nbs/_quarto.yml

@@ -0,0 +1,22 @@
+project:
+  type: website
+
+format:
+  html:
+    theme: cosmo
+    css: styles.css
+    toc: true
+    keep-md: true
+  commonmark: default
+
+website:
+  twitter-card: true
+  open-graph: true
+  repo-actions: [issue]
+  navbar:
+    background: primary
+    search: true
+  sidebar:
+    style: floating
+
+metadata-files: [nbdev.yml, sidebar.yml]

nbs/index.ipynb

@@ -0,0 +1,180 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| hide\n",
+    "from wardbuddy.core import *"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# wardbuddy\n",
+    "\n",
+    "> Making placement learning fun and effective for medical students with a personalised AI system"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This file will become your README and also the index of your documentation."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Developer Guide"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If you are new to using `nbdev` here are some useful pointers to get you started."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Install wardbuddy in Development mode"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "```sh\n",
+    "# make sure wardbuddy package is installed in development mode\n",
+    "$ pip install -e .\n",
+    "\n",
+    "# make changes under nbs/ directory\n",
+    "# ...\n",
+    "\n",
+    "# compile to have changes apply to wardbuddy\n",
+    "$ nbdev_prepare\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Usage"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Installation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Install latest from the GitHub [repository][repo]:\n",
+    "\n",
+    "```sh\n",
+    "$ pip install git+https://github.com/Dyadd/wardbuddy.git\n",
+    "```\n",
+    "\n",
+    "or from [conda][conda]\n",
+    "\n",
+    "```sh\n",
+    "$ conda install -c Dyadd wardbuddy\n",
+    "```\n",
+    "\n",
+    "or from [pypi][pypi]\n",
+    "\n",
+    "\n",
+    "```sh\n",
+    "$ pip install wardbuddy\n",
+    "```\n",
+    "\n",
+    "\n",
+    "[repo]: https://github.com/Dyadd/wardbuddy\n",
+    "[docs]: https://Dyadd.github.io/wardbuddy/\n",
+    "[pypi]: https://pypi.org/project/wardbuddy/\n",
+    "[conda]: https://anaconda.org/Dyadd/wardbuddy"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Documentation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Documentation can be found hosted on this GitHub [repository][repo]'s [pages][docs]. Additionally you can find package manager specific guidelines on [conda][conda] and [pypi][pypi] respectively.\n",
+    "\n",
+    "[repo]: https://github.com/Dyadd/wardbuddy\n",
+    "[docs]: https://Dyadd.github.io/wardbuddy/\n",
+    "[pypi]: https://pypi.org/project/wardbuddy/\n",
+    "[conda]: https://anaconda.org/Dyadd/wardbuddy"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## How to use"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Fill me in please! Don't forget code examples:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "1+1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "python3",
+   "language": "python",
+   "name": "python3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

nbs/nbdev.yml

@@ -0,0 +1,9 @@
+project:
+  output-dir: _docs
+
+website:
+  title: "wardbuddy"
+  site-url: "https://Dyadd.github.io/wardbuddy"
+  description: "Making placement learning fun and effective for medical students with a personalised AI system"
+  repo-branch: main
+  repo-url: "https://github.com/Dyadd/wardbuddy"

nbs/sidebar.yml

@@ -0,0 +1,5 @@
+website:
+  sidebar:
+    contents:
+      - index.ipynb
+      - 00_core.ipynb

nbs/styles.css

@@ -0,0 +1,25 @@
+
+    .gr-button {
+        border-radius: 8px;
+        padding: 10px 20px;
+    }
+    
+    .gr-button:hover {
+        background-color: #2c5282;
+        color: white;
+    }
+    
+    .message {
+        padding: 15px;
+        border-radius: 10px;
+        margin: 5px 0;
+    }
+    
+    .user-message {
+        background-color: #e2e8f0;
+    }
+    
+    .assistant-message {
+        background-color: #ebf8ff;
+    }
+    

pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=64.0"]
+build-backend = "setuptools.build_meta"

settings.ini

@@ -0,0 +1,45 @@
+[DEFAULT]
+# All sections below are required unless otherwise specified.
+# See https://github.com/AnswerDotAI/nbdev/blob/main/settings.ini for examples.
+
+### Python library ###
+repo = wardbuddy
+lib_name = %(repo)s
+version = 0.0.1
+min_python = 3.7
+license = apache2
+black_formatting = False
+
+### nbdev ###
+doc_path = _docs
+lib_path = wardbuddy
+nbs_path = nbs
+recursive = True
+tst_flags = notest
+put_version_in_init = True
+
+### Docs ###
+branch = main
+custom_sidebar = False
+doc_host = https://%(user)s.github.io
+doc_baseurl = /%(repo)s
+git_url = https://github.com/%(user)s/%(repo)s
+title = %(lib_name)s
+
+### PyPI ###
+audience = Developers
+author = Dyadd
+author_email = djey0003@student.monash.edu
+copyright = 2025 onwards, %(author)s
+description = Making placement learning fun and effective for medical students with a personalised AI system
+keywords = nbdev jupyter notebook python
+language = English
+status = 3
+user = Dyadd
+
+### Optional ###
+requirements = nbdev>=2.3.0 gradio>=4.0.0 requests>=2.31.0 python-dotenv>=1.0.0 aiohttp>=3.9.0
+# dev_requirements = 
+# console_scripts =
+# conda_user = 
+# package_data =

setup.py

@@ -0,0 +1,64 @@
+from pkg_resources import parse_version
+from configparser import ConfigParser
+import setuptools, shlex
+assert parse_version(setuptools.__version__)>=parse_version('36.2')
+
+# note: all settings are in settings.ini; edit there, not here
+config = ConfigParser(delimiters=['='])
+config.read('settings.ini', encoding='utf-8')
+cfg = config['DEFAULT']
+
+cfg_keys = 'version description keywords author author_email'.split()
+expected = cfg_keys + "lib_name user branch license status min_python audience language".split()
+for o in expected: assert o in cfg, "missing expected setting: {}".format(o)
+setup_cfg = {o:cfg[o] for o in cfg_keys}
+
+licenses = {
+    'apache2': ('Apache Software License 2.0','OSI Approved :: Apache Software License'),
+    'mit': ('MIT License', 'OSI Approved :: MIT License'),
+    'gpl2': ('GNU General Public License v2', 'OSI Approved :: GNU General Public License v2 (GPLv2)'),
+    'gpl3': ('GNU General Public License v3', 'OSI Approved :: GNU General Public License v3 (GPLv3)'),
+    'bsd3': ('BSD License', 'OSI Approved :: BSD License'),
+}
+statuses = [ '1 - Planning', '2 - Pre-Alpha', '3 - Alpha',
+    '4 - Beta', '5 - Production/Stable', '6 - Mature', '7 - Inactive' ]
+py_versions = '3.6 3.7 3.8 3.9 3.10 3.11 3.12'.split()
+
+requirements = shlex.split(cfg.get('requirements', ''))
+if cfg.get('pip_requirements'): requirements += shlex.split(cfg.get('pip_requirements', ''))
+min_python = cfg['min_python']
+lic = licenses.get(cfg['license'].lower(), (cfg['license'], None))
+dev_requirements = (cfg.get('dev_requirements') or '').split()
+
+package_data = dict()
+pkg_data = cfg.get('package_data', None)
+if pkg_data:
+    package_data[cfg['lib_name']] =  pkg_data.split() # split as multiple files might be listed
+# Add package data to setup_cfg for setuptools.setup(..., **setup_cfg)
+setup_cfg['package_data'] = package_data
+
+setuptools.setup(
+    name = cfg['lib_name'],
+    license = lic[0],
+    classifiers = [
+        'Development Status :: ' + statuses[int(cfg['status'])],
+        'Intended Audience :: ' + cfg['audience'].title(),
+        'Natural Language :: ' + cfg['language'].title(),
+    ] + ['Programming Language :: Python :: '+o for o in py_versions[py_versions.index(min_python):]] + (['License :: ' + lic[1] ] if lic[1] else []),
+    url = cfg['git_url'],
+    packages = setuptools.find_packages(),
+    include_package_data = True,
+    install_requires = requirements,
+    extras_require={ 'dev': dev_requirements },
+    dependency_links = cfg.get('dep_links','').split(),
+    python_requires  = '>=' + cfg['min_python'],
+    long_description = open('README.md', encoding='utf-8').read(),
+    long_description_content_type = 'text/markdown',
+    zip_safe = False,
+    entry_points = {
+        'console_scripts': cfg.get('console_scripts','').split(),
+        'nbdev': [f'{cfg.get("lib_path")}={cfg.get("lib_path")}._modidx:d']
+    },
+    **setup_cfg)
+
+

wardbuddy/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.0.1"

wardbuddy/_modidx.py

@@ -0,0 +1,81 @@
+# Autogenerated by nbdev
+
+d = { 'settings': { 'branch': 'main',
+                'doc_baseurl': '/wardbuddy',
+                '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',
+                                                                                      'wardbuddy/clinical_tutor.py'),
+                                          'wardbuddy.clinical_tutor.ClinicalTutor.__init__': ( 'clinical_tutor.html#clinicaltutor.__init__',
+                                                                                               'wardbuddy/clinical_tutor.py'),
+                                          'wardbuddy.clinical_tutor.ClinicalTutor._build_analysis_prompt': ( 'clinical_tutor.html#clinicaltutor._build_analysis_prompt',
+                                                                                                             'wardbuddy/clinical_tutor.py'),
+                                          'wardbuddy.clinical_tutor.ClinicalTutor._build_discussion_prompt': ( 'clinical_tutor.html#clinicaltutor._build_discussion_prompt',
+                                                                                                               'wardbuddy/clinical_tutor.py'),
+                                          'wardbuddy.clinical_tutor.ClinicalTutor._get_completion': ( 'clinical_tutor.html#clinicaltutor._get_completion',
+                                                                                                      'wardbuddy/clinical_tutor.py'),
+                                          'wardbuddy.clinical_tutor.ClinicalTutor._parse_analysis': ( 'clinical_tutor.html#clinicaltutor._parse_analysis',
+                                                                                                      'wardbuddy/clinical_tutor.py'),
+                                          'wardbuddy.clinical_tutor.ClinicalTutor._update_context_from_analysis': ( 'clinical_tutor.html#clinicaltutor._update_context_from_analysis',
+                                                                                                                    'wardbuddy/clinical_tutor.py'),
+                                          'wardbuddy.clinical_tutor.ClinicalTutor.analyze_discussion': ( 'clinical_tutor.html#clinicaltutor.analyze_discussion',
+                                                                                                         'wardbuddy/clinical_tutor.py'),
+                                          'wardbuddy.clinical_tutor.ClinicalTutor.discuss_case': ( 'clinical_tutor.html#clinicaltutor.discuss_case',
+                                                                                                   'wardbuddy/clinical_tutor.py'),
+                                          'wardbuddy.clinical_tutor.OpenRouterException': ( 'clinical_tutor.html#openrouterexception',
+                                                                                            'wardbuddy/clinical_tutor.py')},
+            'wardbuddy.core': {'wardbuddy.core.foo': ('core.html#foo', 'wardbuddy/core.py')},
+            'wardbuddy.learning_context': { 'wardbuddy.learning_context.LearningContext': ( 'learning_context.html#learningcontext',
+                                                                                            'wardbuddy/learning_context.py'),
+                                            'wardbuddy.learning_context.LearningContext.__init__': ( 'learning_context.html#learningcontext.__init__',
+                                                                                                     'wardbuddy/learning_context.py'),
+                                            'wardbuddy.learning_context.LearningContext.add_learning_objective': ( 'learning_context.html#learningcontext.add_learning_objective',
+                                                                                                                   'wardbuddy/learning_context.py'),
+                                            'wardbuddy.learning_context.LearningContext.add_strength': ( 'learning_context.html#learningcontext.add_strength',
+                                                                                                         'wardbuddy/learning_context.py'),
+                                            'wardbuddy.learning_context.LearningContext.complete_objective': ( 'learning_context.html#learningcontext.complete_objective',
+                                                                                                               'wardbuddy/learning_context.py'),
+                                            'wardbuddy.learning_context.LearningContext.load_context': ( 'learning_context.html#learningcontext.load_context',
+                                                                                                         'wardbuddy/learning_context.py'),
+                                            'wardbuddy.learning_context.LearningContext.save_context': ( 'learning_context.html#learningcontext.save_context',
+                                                                                                         'wardbuddy/learning_context.py'),
+                                            'wardbuddy.learning_context.LearningContext.toggle_feedback_focus': ( 'learning_context.html#learningcontext.toggle_feedback_focus',
+                                                                                                                  'wardbuddy/learning_context.py'),
+                                            'wardbuddy.learning_context.LearningContext.update_knowledge_gap': ( 'learning_context.html#learningcontext.update_knowledge_gap',
+                                                                                                                 'wardbuddy/learning_context.py'),
+                                            'wardbuddy.learning_context.LearningContext.update_rotation': ( 'learning_context.html#learningcontext.update_rotation',
+                                                                                                            'wardbuddy/learning_context.py')},
+            'wardbuddy.learning_interface': { 'wardbuddy.learning_interface.LearningInterface': ( 'learning_interface.html#learninginterface',
+                                                                                                  'wardbuddy/learning_interface.py'),
+                                              'wardbuddy.learning_interface.LearningInterface.__init__': ( 'learning_interface.html#learninginterface.__init__',
+                                                                                                           'wardbuddy/learning_interface.py'),
+                                              'wardbuddy.learning_interface.LearningInterface._add_suggested_objectives': ( 'learning_interface.html#learninginterface._add_suggested_objectives',
+                                                                                                                            'wardbuddy/learning_interface.py'),
+                                              'wardbuddy.learning_interface.LearningInterface._refresh_knowledge_profile': ( 'learning_interface.html#learninginterface._refresh_knowledge_profile',
+                                                                                                                             '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.add_feedback_focus': ( 'learning_interface.html#learninginterface.add_feedback_focus',
+                                                                                                                     'wardbuddy/learning_interface.py'),
+                                              'wardbuddy.learning_interface.LearningInterface.add_objective': ( 'learning_interface.html#learninginterface.add_objective',
+                                                                                                                '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.process_chat': ( 'learning_interface.html#learninginterface.process_chat',
+                                                                                                               'wardbuddy/learning_interface.py'),
+                                              'wardbuddy.learning_interface.LearningInterface.toggle_feedback_status': ( 'learning_interface.html#learninginterface.toggle_feedback_status',
+                                                                                                                         'wardbuddy/learning_interface.py'),
+                                              'wardbuddy.learning_interface.LearningInterface.toggle_objective_status': ( 'learning_interface.html#learninginterface.toggle_objective_status',
+                                                                                                                          'wardbuddy/learning_interface.py'),
+                                              'wardbuddy.learning_interface.LearningInterface.update_rotation': ( 'learning_interface.html#learninginterface.update_rotation',
+                                                                                                                  'wardbuddy/learning_interface.py'),
+                                              'wardbuddy.learning_interface.create_dashboard_css': ( 'learning_interface.html#create_dashboard_css',
+                                                                                                     'wardbuddy/learning_interface.py'),
+                                              'wardbuddy.learning_interface.launch_learning_interface': ( 'learning_interface.html#launch_learning_interface',
+                                                                                                          'wardbuddy/learning_interface.py')},
+            'wardbuddy.utils': { 'wardbuddy.utils.load_context_safely': ('utils.html#load_context_safely', 'wardbuddy/utils.py'),
+                                 'wardbuddy.utils.save_context_safely': ('utils.html#save_context_safely', 'wardbuddy/utils.py'),
+                                 'wardbuddy.utils.setup_logger': ('utils.html#setup_logger', 'wardbuddy/utils.py')}}}

wardbuddy/clinical_tutor.py

@@ -0,0 +1,392 @@
+"""Core module for using learning context for context-appropriate tutor responses"""
+
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/01_clinical_tutor.ipynb.
+
+# %% auto 0
+__all__ = ['logger', 'OpenRouterException', 'ClinicalTutor']
+
+# %% ../nbs/01_clinical_tutor.ipynb 4
+from typing import Dict, List, Optional, Any, Tuple
+import os
+import json
+import logging
+from pathlib import Path
+from datetime import datetime
+from dotenv import load_dotenv
+import aiohttp
+import re
+from collections import defaultdict
+from .learning_context import LearningContext, setup_logger
+
+# Load environment variables
+load_dotenv()
+
+logger = setup_logger(__name__)
+
+# %% ../nbs/01_clinical_tutor.ipynb 7
+class OpenRouterException(Exception):
+    """Custom exception for OpenRouter API errors"""
+    pass
+
+# %% ../nbs/01_clinical_tutor.ipynb 8
+class ClinicalTutor:
+    """
+    Adaptive clinical teaching module that provides context-aware feedback.
+    
+    The tutor acts as an experienced clinical supervisor, engaging in natural
+    case discussions while tracking student progress and adapting feedback
+    based on learning context.
+    
+    Attributes:
+        learning_context (LearningContext): Student's learning context
+        model (str): LLM model identifier
+        api_url (str): OpenRouter API endpoint
+    """
+    
+    def __init__(
+        self,
+        context_path: Optional[Path] = None,
+        model: str = "anthropic/claude-3.5-sonnet"
+    ):
+        """
+        Initialize clinical tutor.
+        
+        Args:
+            context_path: Optional path for context persistence
+            model: Model identifier for OpenRouter
+        """
+        self.api_key: str = os.getenv("OPENROUTER_API_KEY")
+        if not self.api_key:
+            raise ValueError("OpenRouter API key not found")
+        
+        self.api_url: str = "https://openrouter.ai/api/v1/chat/completions"
+        self.model: str = model
+        
+        self.learning_context = LearningContext(context_path)
+        self.context_path = context_path
+        
+        # Track conversation state
+        self.current_case: Dict = {
+            "started": None,
+            "chief_complaint": None,
+            "key_findings": [],
+            "assessment": None,
+            "plan": None
+        }
+        
+        logger.info(f"Clinical tutor initialized with model: {model}")
+    
+    async def _get_completion(
+        self,
+        messages: List[Dict],
+        temperature: float = 0.7,
+        max_retries: int = 3
+    ) -> str:
+        """
+        Get completion from OpenRouter API with retry logic.
+        
+        Args:
+            messages: List of conversation messages
+            temperature: Temperature for response generation
+            max_retries: Maximum retry attempts
+            
+        Returns:
+            str: Model response
+            
+        Raises:
+            OpenRouterException: If API calls fail after retries
+        """
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+            "HTTP-Referer": "http://localhost:7860"
+        }
+        
+        data = {
+            "model": self.model,
+            "messages": messages,
+            "temperature": temperature,
+            "max_tokens": 2000
+        }
+        
+        for attempt in range(max_retries):
+            try:
+                async with aiohttp.ClientSession() as session:
+                    async with session.post(
+                        self.api_url,
+                        headers=headers,
+                        json=data,
+                        timeout=30
+                    ) as response:
+                        response.raise_for_status()
+                        result = await response.json()
+                        return result["choices"][0]["message"]["content"]
+                        
+            except Exception as e:
+                if attempt == max_retries - 1:
+                    raise OpenRouterException(f"API call failed: {str(e)}")
+                logger.warning(f"Retry {attempt + 1} after error: {str(e)}")
+                # Could add exponential backoff here if needed
+    
+    def _build_discussion_prompt(self) -> str:
+        """
+        Build context-aware prompt for case discussion.
+        
+        Incorporates:
+        - Current rotation details
+        - Active feedback preferences
+        - Recent learning points
+        - Knowledge gaps needing attention
+        
+        Returns:
+            str: Contextualized system prompt
+        """
+        rotation = self.learning_context.current_rotation
+        active_preferences = [
+            p["focus"] for p in self.learning_context.feedback_preferences 
+            if p["active"]
+        ]
+        
+        # Get relevant knowledge gaps
+        significant_gaps = {
+            topic: score for topic, score 
+            in self.learning_context.knowledge_profile["gaps"].items()
+            if score < 0.7  # Only include significant gaps
+        }
+        
+        prompt = f"""You are an experienced clinical supervisor in {rotation['specialty']} 
+        providing teaching and feedback. You aim to:
+
+        1. Help students develop strong clinical reasoning
+        2. Connect theory to practical applications
+        3. Build diagnostic confidence
+        4. Improve presentation skills
+
+        Current Rotation Focus Areas:
+        {', '.join(rotation['key_focus_areas'])}
+
+        Areas Needing Attention:
+        {', '.join(f'{topic} (confidence: {score:.1f})' for topic, score in significant_gaps.items()) if significant_gaps else 'No specific gaps identified'}
+
+        Student's Requested Focus:
+        {', '.join(active_preferences) if active_preferences else 'General clinical feedback'}
+
+        Engage naturally as a supportive but challenging supervisor would during case 
+        presentations. Ask probing questions when appropriate, share relevant clinical 
+        pearls, and help the student build their clinical reasoning skills."""
+        
+        return prompt
+    
+    def _build_analysis_prompt(self, conversation: List[Dict[str, str]]) -> str:
+        """
+        Build prompt for post-discussion analysis.
+        
+        Args:
+            conversation: List of message dictionaries with roles and content
+            
+        Returns:
+            str: Analysis prompt
+        """
+        # Extract case details
+        case_content = ""
+        for msg in conversation:
+            if msg["role"] == "user":
+                case_content += msg["content"] + "\n"
+        
+        return f"""Analyze the following case discussion between a medical student and 
+        clinical supervisor. Focus on the student's demonstrated knowledge, skills, 
+        and areas for improvement.
+
+        Case Content:
+        {case_content}
+
+        Please identify:
+        1. Key clinical concepts and learning points demonstrated or discussed
+        2. Areas where the student showed uncertainty or knowledge gaps
+        3. Strengths demonstrated in clinical reasoning and presentation
+        4. Specific learning objectives that would help the student's development
+
+        Frame your response to help with ongoing learning:
+        - Start with positive observations
+        - Be specific about knowledge gaps
+        - Make concrete suggestions for improvement
+        - Connect to practical clinical scenarios"""
+    
+    async def discuss_case(
+        self, 
+        message: str,
+        temperature: float = 0.7
+    ) -> str:
+        """
+        Natural case discussion with context-aware responses.
+        
+        Args:
+            message: Student's input message
+            temperature: Temperature for response generation
+            
+        Returns:
+            str: Clinical supervisor's response
+        """
+        try:
+            # Update case tracking
+            if not self.current_case["started"]:
+                self.current_case["started"] = datetime.now()
+                # Try to identify chief complaint from first message
+                cc_match = re.search(r"(\d+)\s*[yY][oO]\s*[MmFf]\s*with\s*([^.]*)", message)
+                if cc_match:
+                    self.current_case["chief_complaint"] = cc_match.group(2).strip()
+            
+            # Build system prompt
+            system_prompt = self._build_discussion_prompt()
+            
+            messages = [{
+                "role": "system",
+                "content": system_prompt
+            }, {
+                "role": "user",
+                "content": message
+            }]
+            
+            response = await self._get_completion(messages, temperature)
+            return response
+            
+        except Exception as e:
+            logger.error(f"Error in case discussion: {str(e)}")
+            return "I apologize, but I encountered an error. Please try presenting your case again."
+    
+    async def analyze_discussion(
+        self,
+        conversation: List[Dict[str, str]]
+    ) -> Dict[str, Any]:
+        """
+        Analyze completed case discussion for learning insights.
+        
+        Args:
+            conversation: List of message dictionaries with roles and content
+            
+        Returns:
+            dict: Analysis results containing:
+                - learning_points: List of key concepts learned
+                - gaps: Dict of identified knowledge gaps
+                - strengths: List of demonstrated strengths
+                - suggested_objectives: List of recommended learning goals
+        """
+        try:
+            # Reset case tracking
+            self.current_case = {
+                "started": None,
+                "chief_complaint": None,
+                "key_findings": [],
+                "assessment": None,
+                "plan": None
+            }
+            
+            # Get analysis from model
+            analysis_prompt = self._build_analysis_prompt(conversation)
+            messages = [{
+                "role": "system",
+                "content": analysis_prompt
+            }]
+            messages.extend(conversation)
+            
+            response = await self._get_completion(messages, temperature=0.3)
+            
+            # Parse insights
+            insights = self._parse_analysis(response)
+            
+            # Update learning context
+            self._update_context_from_analysis(insights)
+            
+            return insights
+            
+        except Exception as e:
+            logger.error(f"Error in discussion analysis: {str(e)}")
+            return {
+                "learning_points": [],
+                "gaps": {},
+                "strengths": [],
+                "suggested_objectives": []
+            }
+    
+    def _parse_analysis(self, response: str) -> Dict[str, Any]:
+        """
+        Parse analysis response into structured insights.
+        
+        Uses pattern matching and basic NLP to extract:
+        - Learning points (key concepts discussed)
+        - Knowledge gaps with confidence estimates
+        - Demonstrated strengths
+        - Suggested learning objectives
+        
+        Args:
+            response: Raw analysis response
+            
+        Returns:
+            dict: Structured analysis insights
+        """
+        insights = {
+            "learning_points": [],
+            "gaps": {},
+            "strengths": [],
+            "suggested_objectives": []
+        }
+        
+        try:
+            # Split into sections
+            sections = response.lower().split("\n\n")
+            
+            for section in sections:
+                if "learning point" in section or "key concept" in section:
+                    # Extract bullet points or numbered items
+                    points = re.findall(r"[-•*]\s*(.+)$", section, re.MULTILINE)
+                    insights["learning_points"].extend(points)
+                    
+                elif "gap" in section or "uncertainty" in section:
+                    # Look for topic mentions with confidence indicators
+                    gaps = re.findall(
+                        r"(limited|uncertain|unclear|difficulty with)\s+([^,.]+)", 
+                        section
+                    )
+                    for indicator, topic in gaps:
+                        # Estimate confidence based on language
+                        confidence = 0.4 if "limited" in indicator else 0.6
+                        insights["gaps"][topic.strip()] = confidence
+                        
+                elif "strength" in section or "demonstrated" in section:
+                    # Extract positive mentions
+                    strengths = re.findall(r"[-•*]\s*(.+)$", section, re.MULTILINE)
+                    insights["strengths"].extend(strengths)
+                    
+                elif "objective" in section or "suggest" in section:
+                    # Extract recommended objectives
+                    objectives = re.findall(r"[-•*]\s*(.+)$", section, re.MULTILINE)
+                    insights["suggested_objectives"].extend(objectives)
+            
+            return insights
+            
+        except Exception as e:
+            logger.error(f"Error parsing analysis: {str(e)}")
+            return insights
+    
+    def _update_context_from_analysis(self, insights: Dict[str, Any]) -> None:
+        """
+        Update learning context based on discussion analysis.
+        
+        Args:
+            insights: Dictionary of analysis insights
+        """
+        try:
+            # Update knowledge gaps
+            for topic, confidence in insights["gaps"].items():
+                self.learning_context.update_knowledge_gap(topic, confidence)
+            
+            # Add strengths
+            for strength in insights["strengths"]:
+                self.learning_context.add_strength(strength)
+            
+            # Save context if path provided
+            if self.context_path:
+                self.learning_context.save_context(self.context_path)
+                
+        except Exception as e:
+            logger.error(f"Error updating context: {str(e)}")

wardbuddy/core.py

@@ -0,0 +1,9 @@
+"""Fill in a module description here"""
+
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/00_core.ipynb.
+
+# %% auto 0
+__all__ = ['foo']
+
+# %% ../nbs/00_core.ipynb 3
+def foo(): pass

wardbuddy/learning_context.py

@@ -0,0 +1,160 @@
+"""Core module for managing learning context (memory -> LOs, prior cases, knowledge gaps, feedback preferences)"""
+
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/00_learning_context.ipynb.
+
+# %% auto 0
+__all__ = ['logger', 'LearningContext']
+
+# %% ../nbs/00_learning_context.ipynb 4
+from typing import Dict, List, Optional, Any, Tuple
+from datetime import datetime
+import json
+from pathlib import Path
+from .utils import setup_logger, load_context_safely, save_context_safely
+
+# %% ../nbs/00_learning_context.ipynb 5
+logger = setup_logger(__name__)
+
+# %% ../nbs/00_learning_context.ipynb 8
+class LearningContext:
+    """
+    Manages the dynamic learning context for each student.
+    
+    Tracks:
+    - Current rotation details
+    - Learning objectives and progress
+    - Knowledge gaps and strengths
+    - Custom feedback preferences
+    """
+    
+    def __init__(self, context_file: Optional[Path] = None):
+        """
+        Initialize learning context, optionally loading from file.
+        
+        Args:
+            context_file: Optional path to saved context
+        """
+        # Initialize current rotation
+        self.current_rotation = {
+            "specialty": "",
+            "start_date": None,
+            "end_date": None,
+            "key_focus_areas": []
+        }
+        
+        # Initialize learning objectives list
+        self.learning_objectives = []  # [{"objective": str, "status": "active"|"completed", "added": datetime}]
+        
+        # Initialize knowledge profile
+        self.knowledge_profile = {
+            "gaps": {},  # topic -> confidence level
+            "strengths": [],
+            "recent_progress": []  # [{topic, improvement, date}]
+        }
+        
+        # Initialize feedback preferences
+        self.feedback_preferences = []  # [{"focus": str, "active": bool}]
+        
+        if context_file and context_file.exists():
+            self.load_context(context_file)
+            
+        logger.info("Learning context initialized")
+    
+    def update_rotation(self, rotation_details: Dict[str, Any]) -> None:
+        """Update current rotation details"""
+        self.current_rotation.update(rotation_details)
+    
+    def add_learning_objective(self, objective: str) -> None:
+        """Add new learning objective"""
+        self.learning_objectives.append({
+            "objective": objective,
+            "status": "active",
+            "added": datetime.now().isoformat()
+        })
+    
+    def complete_objective(self, objective: str) -> None:
+        """Mark learning objective as completed"""
+        for obj in self.learning_objectives:
+            if obj["objective"] == objective and obj["status"] == "active":
+                obj["status"] = "completed"
+                obj["completed"] = datetime.now().isoformat()
+                break
+    
+    def update_knowledge_gap(self, topic: str, confidence: float) -> None:
+        """Update knowledge gap confidence level"""
+        old_confidence = self.knowledge_profile["gaps"].get(topic)
+        self.knowledge_profile["gaps"][topic] = confidence
+        
+        # Track progress if confidence improved
+        if old_confidence and confidence > old_confidence:
+            self.knowledge_profile["recent_progress"].append({
+                "topic": topic,
+                "improvement": confidence - old_confidence,
+                "date": datetime.now().isoformat()
+            })
+            
+            # Keep only recent progress
+            self.knowledge_profile["recent_progress"] = \
+                self.knowledge_profile["recent_progress"][-5:]
+    
+    def add_strength(self, topic: str) -> None:
+        """Add identified strength"""
+        if topic not in self.knowledge_profile["strengths"]:
+            self.knowledge_profile["strengths"].append(topic)
+    
+    def toggle_feedback_focus(self, focus: str, active: bool) -> None:
+        """Toggle feedback focus area"""
+        # Update if exists
+        for pref in self.feedback_preferences:
+            if pref["focus"] == focus:
+                pref["active"] = active
+                return
+                
+        # Add if new
+        self.feedback_preferences.append({
+            "focus": focus,
+            "active": active
+        })
+    
+    def save_context(self, file_path: Path) -> None:
+        """Save context to file"""
+        context_data = {
+            "current_rotation": self.current_rotation,
+            "learning_objectives": self.learning_objectives,
+            "knowledge_profile": self.knowledge_profile,
+            "feedback_preferences": self.feedback_preferences
+        }
+        save_context_safely(context_data, file_path)
+    
+    def load_context(self, file_path: Path) -> None:
+        """Load context from file"""
+        try:
+            context_data = load_context_safely(file_path)
+            
+            # Use .get() with default values to handle missing keys
+            self.current_rotation = context_data.get("current_rotation", {
+                "specialty": "",
+                "start_date": None,
+                "end_date": None,
+                "key_focus_areas": []
+            })
+            
+            # Ensure required keys exist
+            for key in ["specialty", "start_date", "end_date", "key_focus_areas"]:
+                if key not in self.current_rotation:
+                    self.current_rotation[key] = None if key != "key_focus_areas" else []
+            
+            self.learning_objectives = context_data.get("learning_objectives", [])
+            self.knowledge_profile = context_data.get("knowledge_profile", {
+                "gaps": {},
+                "strengths": [],
+                "recent_progress": []
+            })
+            self.feedback_preferences = context_data.get("feedback_preferences", [])
+            
+            logger.info(f"Context loaded successfully from {file_path}")
+            
+        except Exception as e:
+            logger.error(f"Error loading context: {str(e)}")
+            # Initialize with defaults on error
+            self.__init__()

wardbuddy/learning_interface.py

@@ -0,0 +1,780 @@
+"""Gradio interface"""
+
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/02_learning_interface.ipynb.
+
+# %% auto 0
+__all__ = ['logger', 'create_dashboard_css', 'LearningInterface', 'launch_learning_interface']
+
+# %% ../nbs/02_learning_interface.ipynb 4
+from typing import Dict, List, Optional, Tuple, Any
+import gradio as gr
+from pathlib import Path
+import asyncio
+from datetime import datetime
+import pandas as pd
+from .clinical_tutor import ClinicalTutor
+from .learning_context import setup_logger
+
+logger = setup_logger(__name__)
+
+# %% ../nbs/02_learning_interface.ipynb 6
+def create_dashboard_css() -> str:
+    """Create custom CSS for dashboard styling"""
+    return """
+    .dashboard-card {
+        border: 1px solid #e2e8f0;
+        border-radius: 8px;
+        padding: 16px;
+        margin: 8px 0;
+        background: white;
+    }
+    
+    .status-active {
+        color: #48bb78;
+        font-weight: 500;
+    }
+    
+    .status-completed {
+        color: #718096;
+    }
+    
+    .dashboard-header {
+        font-size: 1.25rem;
+        font-weight: 600;
+        margin-bottom: 1rem;
+    }
+    
+    .summary-modal {
+        max-width: 800px !important;
+    }
+    
+    .feedback-tag {
+        display: inline-block;
+        padding: 4px 8px;
+        border-radius: 4px;
+        margin: 4px;
+        font-size: 0.875rem;
+    }
+    
+    .feedback-active {
+        background: #ebf8ff;
+        color: #2b6cb0;
+    }
+    
+    .feedback-inactive {
+        background: #f7fafc;
+        color: #718096;
+    }
+    """
+
+# %% ../nbs/02_learning_interface.ipynb 8
+class LearningInterface:
+    """
+    Gradio interface for clinical learning interactions.
+    
+    Features:
+    - Natural case discussion chat
+    - Dynamic learning dashboard
+    - Post-discussion analysis
+    - Progress tracking
+    """
+    
+    def __init__(
+        self,
+        context_path: Optional[Path] = None,
+        theme: str = "default"
+    ):
+        """Initialize learning interface."""
+        self.tutor = ClinicalTutor(context_path)
+        self.theme = theme
+        self.context_path = context_path
+        
+        # Track current discussion state
+        self.current_discussion = {
+            "started": None,
+            "case_type": None,
+            "messages": []
+        }
+        
+        logger.info("Learning interface initialized")
+    
+    async def process_chat(
+        self,
+        message: str,
+        history: List[Dict[str, str]],
+        state: Dict[str, Any]
+    ) -> Tuple[List[Dict[str, str]], str, Dict[str, Any]]:
+        """
+        Process chat messages with state management.
+        
+        Args:
+            message: User input message
+            history: Chat history
+            state: Current interface state
+            
+        Returns:
+            tuple: (updated history, cleared message, updated state)
+        """
+        try:
+            if not message.strip():
+                return history, "", state
+            
+            # Start new discussion if none active
+            if not state.get("discussion_active"):
+                state["discussion_active"] = True
+                state["discussion_start"] = datetime.now().isoformat()
+            
+            # Get tutor response
+            response = await self.tutor.discuss_case(message)
+            
+            # Update history and state
+            if history is None:
+                history = []
+            history.extend([
+                {"role": "user", "content": message},
+                {"role": "assistant", "content": response}
+            ])
+            
+            state["last_message"] = datetime.now().isoformat()
+            
+            return history, "", state
+            
+        except Exception as e:
+            logger.error(f"Error in chat: {str(e)}")
+            return history or [], "", state
+
+    async def end_discussion(
+        self,
+        history: List[Dict[str, str]],
+        state: Dict[str, Any]
+    ) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """
+        Analyze completed discussion and prepare summary.
+        
+        Args:
+            history: Chat history
+            state: Current interface state
+            
+        Returns:
+            tuple: (analysis results, updated state)
+        """
+        try:
+            if not history:
+                return {
+                    "learning_points": [],
+                    "gaps": {},
+                    "strengths": [],
+                    "suggested_objectives": []
+                }, state
+            
+            # Get analysis
+            analysis = await self.tutor.analyze_discussion(history)
+            
+            # Reset discussion state
+            state["discussion_active"] = False
+            state["discussion_start"] = None
+            state["last_message"] = None
+            
+            return analysis, state
+            
+        except Exception as e:
+            logger.error(f"Error analyzing discussion: {str(e)}")
+            return {
+                "learning_points": [],
+                "gaps": {},
+                "strengths": [],
+                "suggested_objectives": []
+            }, state
+    
+    def update_rotation(
+        self,
+        specialty: str,
+        start_date: str,
+        end_date: str,
+        focus_areas: str
+    ) -> Tuple[str, str, str, str]:
+        """
+        Update rotation details and return updated values.
+        
+        Args:
+            specialty: Rotation specialty
+            start_date: Start date string
+            end_date: End date string
+            focus_areas: Comma-separated focus areas
+            
+        Returns:
+            tuple: Updated field values
+        """
+        try:
+            # Parse focus areas
+            focus_list = [
+                area.strip() 
+                for area in focus_areas.split(",") 
+                if area.strip()
+            ]
+            
+            # Update context
+            rotation = {
+                "specialty": specialty,
+                "start_date": start_date,
+                "end_date": end_date,
+                "key_focus_areas": focus_list
+            }
+            self.tutor.learning_context.update_rotation(rotation)
+            
+            # Return updated values
+            return (
+                specialty,
+                start_date,
+                end_date,
+                ",".join(focus_list)
+            )
+            
+        except Exception as e:
+            logger.error(f"Error updating rotation: {str(e)}")
+            current = self.tutor.learning_context.current_rotation
+            return (
+                current["specialty"],
+                current["start_date"] or "",
+                current["end_date"] or "",
+                ",".join(current["key_focus_areas"])
+            )
+
+    def add_objective(
+        self,
+        objective: str,
+        objectives_df: pd.DataFrame
+    ) -> pd.DataFrame:
+        """
+        Add new learning objective and return updated dataframe.
+        
+        Args:
+            objective: New objective text
+            objectives_df: Current objectives dataframe
+            
+        Returns:
+            pd.DataFrame: Updated objectives list
+        """
+        try:
+            if not objective.strip():
+                return objectives_df
+                
+            # Add to context
+            self.tutor.learning_context.add_learning_objective(objective)
+            
+            # Convert to dataframe
+            return pd.DataFrame([
+                [obj["objective"], obj["status"], obj["added"]]
+                for obj in self.tutor.learning_context.learning_objectives
+            ], columns=["Objective", "Status", "Date Added"])
+            
+        except Exception as e:
+            logger.error(f"Error adding objective: {str(e)}")
+            return objectives_df
+
+    def toggle_objective_status(
+        self,
+        evt: gr.SelectData,  # Updated to use gr.SelectData
+        objectives_df: pd.DataFrame
+    ) -> pd.DataFrame:
+        """
+        Toggle objective status between active and completed.
+        
+        Args:
+            evt: Gradio select event containing row index
+            objectives_df: Current objectives dataframe
+            
+        Returns:
+            pd.DataFrame: Updated objectives list
+        """
+        try:
+            objective_idx = evt.index[0]  # Get selected row index
+            if objective_idx >= len(objectives_df):
+                return objectives_df
+                
+            # Get objective
+            objective = objectives_df.iloc[objective_idx]["Objective"]
+            current_status = objectives_df.iloc[objective_idx]["Status"]
+            
+            # Toggle in context
+            if current_status == "active":
+                self.tutor.learning_context.complete_objective(objective)
+            else:
+                self.tutor.learning_context.add_learning_objective(objective)
+            
+            # Update dataframe
+            return pd.DataFrame([
+                [obj["objective"], obj["status"], obj["added"]]
+                for obj in self.tutor.learning_context.learning_objectives
+            ], columns=["Objective", "Status", "Date Added"])
+            
+        except Exception as e:
+            logger.error(f"Error toggling objective: {str(e)}")
+            return objectives_df
+
+    def add_feedback_focus(
+        self,
+        focus: str,
+        feedback_df: pd.DataFrame
+    ) -> pd.DataFrame:
+        """Add new feedback focus area."""
+        try:
+            if not focus.strip():
+                return feedback_df
+                
+            # Add to context
+            self.tutor.learning_context.toggle_feedback_focus(focus, True)
+            
+            # Update dataframe
+            return pd.DataFrame([
+                [pref["focus"], pref["active"]]
+                for pref in self.tutor.learning_context.feedback_preferences
+            ], columns=["Focus Area", "Active"])
+            
+        except Exception as e:
+            logger.error(f"Error adding feedback focus: {str(e)}")
+            return feedback_df
+
+    def toggle_feedback_status(
+        self,
+        evt: gr.SelectData,  # Updated to use gr.SelectData
+        feedback_df: pd.DataFrame
+    ) -> pd.DataFrame:
+        """Toggle feedback focus active status."""
+        try:
+            focus_idx = evt.index[0]  # Get selected row index
+            if focus_idx >= len(feedback_df):
+                return feedback_df
+                
+            # Get focus area
+            focus = feedback_df.iloc[focus_idx]["Focus Area"]
+            current_status = feedback_df.iloc[focus_idx]["Active"]
+            
+            # Toggle in context
+            self.tutor.learning_context.toggle_feedback_focus(
+                focus, 
+                not current_status
+            )
+            
+            # Update dataframe
+            return pd.DataFrame([
+                [pref["focus"], pref["active"]]
+                for pref in self.tutor.learning_context.feedback_preferences
+            ], columns=["Focus Area", "Active"])
+            
+        except Exception as e:
+            logger.error(f"Error toggling feedback: {str(e)}")
+            return feedback_df
+
+    def create_interface(self) -> gr.Blocks:
+        """Create and configure the Gradio interface"""
+        with gr.Blocks(
+            title="Clinical Learning Assistant",
+            theme=self.theme,
+            css=create_dashboard_css()
+        ) as interface:
+            # State management
+            state = gr.State({
+                "discussion_active": False,
+                "discussion_start": None,
+                "last_message": None
+            })
+            
+            # Header
+            with gr.Row():
+                gr.Markdown(
+                    "# Clinical Learning Assistant",
+                    elem_classes=["dashboard-header"]
+                )
+            
+            with gr.Row():
+                # Left column - Chat interface
+                with gr.Column(scale=2):
+                    # Active discussion indicator
+                    discussion_status = gr.Markdown(
+                        "Start a new case discussion",
+                        elem_classes=["dashboard-card"]
+                    )
+                    
+                    # Chat interface
+                    chatbot = gr.Chatbot(
+                        height=500,
+                        label="Case Discussion",
+                        show_label=True,
+                        elem_classes=["dashboard-card"]
+                    )
+                    
+                    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=5
+                        )
+                    
+                    with gr.Row():
+                        clear = gr.Button("Clear Discussion")
+                        end_discussion = gr.Button(
+                            "End Discussion & Review",
+                            variant="primary"
+                        )
+                
+                # Right column - Learning dashboard
+                with gr.Column(scale=1):
+                    with gr.Tabs():
+                        # Current Rotation tab
+                        with gr.Tab("Current Rotation"):
+                            with gr.Column(elem_classes=["dashboard-card"]):
+                                specialty = gr.Textbox(
+                                    label="Specialty",
+                                    value=self.tutor.learning_context.current_rotation["specialty"]
+                                )
+                                start_date = gr.Textbox(
+                                    label="Start Date (YYYY-MM-DD)",
+                                    value=self.tutor.learning_context.current_rotation["start_date"]
+                                )
+                                end_date = gr.Textbox(
+                                    label="End Date (YYYY-MM-DD)",
+                                    value=self.tutor.learning_context.current_rotation["end_date"]
+                                )
+                                focus_areas = gr.Textbox(
+                                    label="Key Focus Areas (comma-separated)",
+                                    value=",".join(
+                                        self.tutor.learning_context.current_rotation["key_focus_areas"]
+                                    )
+                                )
+                                update_rotation_btn = gr.Button(
+                                    "Update Rotation",
+                                    variant="secondary"
+                                )
+                        
+                        # Learning Objectives tab
+                        with gr.Tab("Learning Objectives"):
+                            with gr.Column(elem_classes=["dashboard-card"]):
+                                objectives_df = gr.DataFrame(
+                                    headers=["Objective", "Status", "Date Added"],
+                                    value=[[
+                                        obj["objective"],
+                                        obj["status"],
+                                        obj["added"]
+                                    ] for obj in self.tutor.learning_context.learning_objectives],
+                                    interactive=True,
+                                    wrap=True
+                                )
+                                
+                                with gr.Row():
+                                    new_objective = gr.Textbox(
+                                        label="New Learning Objective",
+                                        placeholder="Enter objective..."
+                                    )
+                                    add_objective_btn = gr.Button(
+                                        "Add",
+                                        variant="secondary"
+                                    )
+                        
+                        # Feedback Preferences tab
+                        with gr.Tab("Feedback Focus"):
+                            with gr.Column(elem_classes=["dashboard-card"]):
+                                feedback_df = gr.DataFrame(
+                                    headers=["Focus Area", "Active"],
+                                    value=[[
+                                        pref["focus"],
+                                        pref["active"]
+                                    ] for pref in self.tutor.learning_context.feedback_preferences],
+                                    interactive=True,
+                                    wrap=True
+                                )
+                                
+                                with gr.Row():
+                                    new_feedback = gr.Textbox(
+                                        label="New Feedback Focus",
+                                        placeholder="Enter focus area..."
+                                    )
+                                    add_feedback_btn = gr.Button(
+                                        "Add",
+                                        variant="secondary"
+                                    )
+                                    
+                        # Knowledge Profile tab
+                        with gr.Tab("Knowledge Profile"):
+                            with gr.Column(elem_classes=["dashboard-card"]):
+                                # Knowledge Gaps
+                                gr.Markdown("### Knowledge Gaps")
+                                gaps_display = gr.DataFrame(
+                                    headers=["Topic", "Confidence"],
+                                    value=[[
+                                        topic, confidence
+                                    ] for topic, confidence in 
+                                        self.tutor.learning_context.knowledge_profile["gaps"].items()
+                                    ],
+                                    interactive=False
+                                )
+                                
+                                # Strengths Display
+                                gr.Markdown("### Strengths")
+                                strengths_display = gr.DataFrame(
+                                    headers=["Area"],
+                                    value=[[strength] for strength in 
+                                        self.tutor.learning_context.knowledge_profile["strengths"]
+                                    ],
+                                    interactive=False
+                                )
+                                
+                                # Recent Progress
+                                gr.Markdown("### Recent Progress")
+                                progress_display = gr.DataFrame(
+                                    headers=["Topic", "Improvement", "Date"],
+                                    value=[[
+                                        prog["topic"],
+                                        f"{prog['improvement']:.2f}",
+                                        prog["date"]
+                                    ] for prog in 
+                                        self.tutor.learning_context.knowledge_profile["recent_progress"]
+                                    ],
+                                    interactive=False
+                                )
+            
+            # Discussion summary section
+            summary_section = gr.Column(visible=False)
+            with summary_section:
+                gr.Markdown("## Discussion Summary")
+                
+                # Overview section
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("### Session Overview")
+                        session_overview = gr.JSON(
+                            label="Discussion Details",
+                            value={
+                                "duration": "0 minutes",
+                                "messages": 0,
+                                "topics_covered": []
+                            }
+                        )
+                
+                # Learning Points and Gaps
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("### Key Learning Points")
+                        learning_points = gr.JSON(label="Points to Remember")
+                    
+                    with gr.Column():
+                        gr.Markdown("### Knowledge Profile Updates")
+                        with gr.Row():
+                            gaps = gr.JSON(label="Areas for Improvement")
+                            strengths = gr.JSON(label="Demonstrated Strengths")
+                
+                # Future Learning section
+                gr.Markdown("### Planning Ahead")
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("#### Suggested Learning Objectives")
+                        objectives = gr.JSON(label="Consider Adding")
+                    
+                    with gr.Column():
+                        gr.Markdown("#### Recommended Focus Areas")
+                        recommendations = gr.JSON(label="Next Steps")
+                
+                # Action buttons
+                with gr.Row():
+                    add_selected_objectives = gr.Button(
+                        "Add Selected Objectives",
+                        variant="primary"
+                    )
+                    close_summary = gr.Button("Close Summary")
+    
+            # Event handlers
+            msg.submit(
+                self.process_chat,
+                inputs=[msg, chatbot, state],
+                outputs=[chatbot, msg, state]
+            ).then(
+                self._update_discussion_status,
+                inputs=[state],
+                outputs=[discussion_status]
+            )
+            
+            clear.click(
+                lambda: ([], "", {
+                    "discussion_active": False,
+                    "discussion_start": None,
+                    "last_message": None
+                }),
+                outputs=[chatbot, msg, state]
+            ).then(
+                lambda: "Start a new case discussion",
+                outputs=[discussion_status]
+            )
+            
+            end_discussion.click(
+                self.end_discussion,
+                inputs=[chatbot, state],
+                outputs=[
+                    session_overview,
+                    learning_points,
+                    gaps,
+                    strengths,
+                    objectives,
+                    recommendations
+                ]
+            ).then(
+                lambda: gr.update(visible=True),
+                None,
+                summary_section
+            ).then(
+                self._refresh_knowledge_profile,
+                outputs=[gaps_display, strengths_display, progress_display]
+            )
+            
+            close_summary.click(
+                lambda: gr.update(visible=False),
+                None,
+                summary_section
+            )
+            
+            # Rotation management
+            update_rotation_btn.click(
+                self.update_rotation,
+                inputs=[specialty, start_date, end_date, focus_areas],
+                outputs=[specialty, start_date, end_date, focus_areas]
+            )
+            
+            # Learning objectives management
+            add_objective_btn.click(
+                self.add_objective,
+                inputs=[new_objective, objectives_df],
+                outputs=[objectives_df]
+            ).then(
+                lambda: "",
+                None,
+                new_objective
+            )
+            
+            objectives_df.select(
+                self.toggle_objective_status,
+                inputs=[objectives_df],
+                outputs=[objectives_df]
+            )
+            
+            # Feedback preferences management
+            add_feedback_btn.click(
+                self.add_feedback_focus,
+                inputs=[new_feedback, feedback_df],
+                outputs=[feedback_df]
+            ).then(
+                lambda: "",
+                None,
+                new_feedback
+            )
+            
+            feedback_df.select(
+                self.toggle_feedback_status,
+                inputs=[feedback_df],
+                outputs=[feedback_df]
+            )
+            
+            # Add selected objectives from summary
+            add_selected_objectives.click(
+                self._add_suggested_objectives,
+                inputs=[objectives],
+                outputs=[objectives_df]
+            )
+    
+            return interface
+    
+    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"
+    
+    def _refresh_knowledge_profile(
+        self
+    ) -> Tuple[List[List[str]], List[List[str]], List[List[str]]]:
+        """Refresh knowledge profile displays"""
+        try:
+            # Gaps
+            gaps_data = [[
+                topic, f"{confidence:.2f}"
+            ] for topic, confidence in 
+                self.tutor.learning_context.knowledge_profile["gaps"].items()
+            ]
+            
+            # Strengths
+            strengths_data = [[
+                strength
+            ] for strength in 
+                self.tutor.learning_context.knowledge_profile["strengths"]
+            ]
+            
+            # Progress
+            progress_data = [[
+                prog["topic"],
+                f"{prog['improvement']:.2f}",
+                prog["date"]
+            ] for prog in 
+                self.tutor.learning_context.knowledge_profile["recent_progress"]
+            ]
+            
+            return gaps_data, strengths_data, progress_data
+            
+        except Exception as e:
+            logger.error(f"Error refreshing profile: {str(e)}")
+            return [], [], []
+    
+    def _add_suggested_objectives(
+        self,
+        evt: gr.SelectData,  # Updated to use gr.SelectData
+        suggested_objectives: List[str]
+    ) -> pd.DataFrame:
+        """Add selected suggested objectives to learning objectives"""
+        try:
+            selected_indices = [evt.index[0]]  # Get selected row index
+            
+            for idx in selected_indices:
+                if idx < len(suggested_objectives):
+                    objective = suggested_objectives[idx]
+                    self.tutor.learning_context.add_learning_objective(objective)
+            
+            return pd.DataFrame([
+                [obj["objective"], obj["status"], obj["added"]]
+                for obj in self.tutor.learning_context.learning_objectives
+            ], columns=["Objective", "Status", "Date Added"])
+            
+        except Exception as e:
+            logger.error(f"Error adding objectives: {str(e)}")
+            return pd.DataFrame()
+
+# %% ../nbs/02_learning_interface.ipynb 10
+async def launch_learning_interface(
+    port: Optional[int] = None,
+    context_path: Optional[Path] = None,
+    share: bool = False,
+    theme: str = "default"
+) -> None:
+    """Launch the learning interface application."""
+    try:
+        interface = LearningInterface(context_path, theme)
+        app = interface.create_interface()
+        app.launch(
+            server_port=port,
+            share=share
+        )
+        logger.info(f"Interface launched on port: {port}")
+    except Exception as e:
+        logger.error(f"Error launching interface: {str(e)}")
+        raise

wardbuddy/utils.py

@@ -0,0 +1,68 @@
+"""Shared utilities for the entire learning system"""
+
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/03_utils.ipynb.
+
+# %% auto 0
+__all__ = ['logger', 'setup_logger', 'load_context_safely', 'save_context_safely']
+
+# %% ../nbs/03_utils.ipynb 4
+from typing import Dict, List, Optional, Any, Tuple
+import json
+from pathlib import Path
+import logging
+from datetime import datetime
+
+# %% ../nbs/03_utils.ipynb 6
+def setup_logger(name: str) -> logging.Logger:
+    """Set up module logger with consistent formatting"""
+    logger = logging.getLogger(name)
+    if not logger.handlers:
+        handler = logging.StreamHandler()
+        handler.setFormatter(
+            logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+        )
+        logger.addHandler(handler)
+        logger.setLevel(logging.INFO)
+    return logger
+
+logger = setup_logger(__name__)
+
+# %% ../nbs/03_utils.ipynb 7
+def load_context_safely(path: Path) -> Dict:
+    """
+    Safely load learning context from JSON file.
+    
+    Args:
+        path: Path to context file
+        
+    Returns:
+        dict: Loaded context data
+        
+    Raises:
+        ValueError: If file is invalid or inaccessible
+    """
+    try:
+        with open(path, 'r') as f:
+            return json.load(f)
+    except json.JSONDecodeError as e:
+        raise ValueError(f"Invalid context file format: {str(e)}")
+    except Exception as e:
+        raise ValueError(f"Error loading context file: {str(e)}")
+
+# %% ../nbs/03_utils.ipynb 8
+def save_context_safely(context: Dict, path: Path) -> None:
+    """
+    Safely save learning context to JSON file.
+    
+    Args:
+        context: Context data to save
+        path: Path to save file
+        
+    Raises:
+        ValueError: If save operation fails
+    """
+    try:
+        with open(path, 'w') as f:
+            json.dump(context, f, indent=2)
+    except Exception as e:
+        raise ValueError(f"Error saving context: {str(e)}")