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
-emoji: 🏢
-colorFrom: pink
-colorTo: yellow
-sdk: gradio
-sdk_version: 5.14.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: wardbuddy
+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,431 @@
+{
+ "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\n",
+    "from datetime import datetime\n",
+    "from enum import Enum\n",
+    "from pydantic import BaseModel, Field\n",
+    "import json\n",
+    "from pathlib import Path\n",
+    "import logging\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 LearningCategory(str, Enum):\n",
+    "    \"\"\"Main learning categories\"\"\"\n",
+    "    HISTORY_TAKING = \"History Taking\"\n",
+    "    PHYSICAL_EXAM = \"Physical Examinations\"\n",
+    "    INVESTIGATIONS = \"Investigations\"\n",
+    "    MANAGEMENT = \"Management\"\n",
+    "    CLINICAL_REASONING = \"Clinical Reasoning\"\n",
+    "    COMMUNICATION = \"Communication & Presentation\"\n",
+    "    PROCEDURAL = \"Procedural Skills\"\n",
+    "    MEDICAL_KNOWLEDGE = \"Medical Knowledge\"\n",
+    "\n",
+    "class RotationContext(BaseModel):\n",
+    "    \"\"\"Clinical rotation context\"\"\"\n",
+    "    specialty: str = Field(..., description=\"Medical specialty\")\n",
+    "    setting: str = Field(..., description=\"Clinical setting (Clinic/Wards/ED)\")\n",
+    "\n",
+    "class SmartGoal(BaseModel):\n",
+    "    \"\"\"SMART learning goal\"\"\"\n",
+    "    id: str = Field(..., description=\"Unique goal identifier\")\n",
+    "    category: LearningCategory\n",
+    "    original_input: str = Field(..., description=\"User's original goal input\")\n",
+    "    smart_version: str = Field(..., description=\"SMART formatted goal\")\n",
+    "    specialty: str\n",
+    "    setting: str\n",
+    "    created_at: datetime\n",
+    "    completed_at: Optional[datetime] = None\n",
+    "\n",
+    "    class Config:\n",
+    "        json_encoders = {\n",
+    "            datetime: lambda v: v.isoformat()\n",
+    "        }\n",
+    "\n",
+    "class CategoryProgress(BaseModel):\n",
+    "    \"\"\"Progress tracking for a category\"\"\"\n",
+    "    category: LearningCategory\n",
+    "    completed_goals: List[SmartGoal] = Field(default_factory=list)\n",
+    "    total_goals: int = Field(default=0)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export\n",
+    "class LearningContext:\n",
+    "    \"\"\"\n",
+    "    Manages learning context and goal tracking.\n",
+    "    \n",
+    "    This class handles:\n",
+    "    - Rotation context management\n",
+    "    - SMART goal tracking\n",
+    "    - Progress monitoring by category\n",
+    "    - Context persistence\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    def __init__(self, context_path: Optional[Path] = None):\n",
+    "        \"\"\"\n",
+    "        Initialize learning context.\n",
+    "        \n",
+    "        Args:\n",
+    "            context_path: Optional path to load/save context\n",
+    "        \"\"\"\n",
+    "        self.context_path = context_path\n",
+    "        \n",
+    "        # Initialize rotation context\n",
+    "        self.rotation = RotationContext(\n",
+    "            specialty=\"\",\n",
+    "            setting=\"\"\n",
+    "        )\n",
+    "        \n",
+    "        # Initialize category tracking\n",
+    "        self.category_progress: Dict[LearningCategory, CategoryProgress] = {\n",
+    "            cat: CategoryProgress(category=cat)\n",
+    "            for cat in LearningCategory\n",
+    "        }\n",
+    "        \n",
+    "        # Current active goal\n",
+    "        self.active_goal: Optional[SmartGoal] = None\n",
+    "        \n",
+    "        # Load existing context if available\n",
+    "        if context_path and context_path.exists():\n",
+    "            self.load_context()\n",
+    "    \n",
+    "    def update_rotation(self, specialty: str, setting: str) -> None:\n",
+    "        \"\"\"\n",
+    "        Update rotation context.\n",
+    "        \n",
+    "        Args:\n",
+    "            specialty: Medical specialty\n",
+    "            setting: Clinical setting\n",
+    "        \"\"\"\n",
+    "        self.rotation = RotationContext(\n",
+    "            specialty=specialty,\n",
+    "            setting=setting\n",
+    "        )\n",
+    "        self._save_context()\n",
+    "    \n",
+    "    def add_smart_goal(self, goal: SmartGoal) -> None:\n",
+    "        \"\"\"\n",
+    "        Add new SMART goal.\n",
+    "        \n",
+    "        Args:\n",
+    "            goal: SMART goal to add\n",
+    "        \"\"\"\n",
+    "        self.active_goal = goal\n",
+    "        self.category_progress[goal.category].total_goals += 1\n",
+    "        self._save_context()\n",
+    "    \n",
+    "    def complete_active_goal(self) -> None:\n",
+    "        \"\"\"Complete current active goal.\"\"\"\n",
+    "        if self.active_goal:\n",
+    "            self.active_goal.completed_at = datetime.now()\n",
+    "            cat = self.active_goal.category\n",
+    "            self.category_progress[cat].completed_goals.append(self.active_goal)\n",
+    "            self.active_goal = None\n",
+    "            self._save_context()\n",
+    "    \n",
+    "    def get_category_summary(self) -> Dict[str, Dict]:\n",
+    "        \"\"\"\n",
+    "        Get summary of progress by category.\n",
+    "        \n",
+    "        Returns:\n",
+    "            dict: Category summaries including completed/total goals\n",
+    "                 and recent completions\n",
+    "        \"\"\"\n",
+    "        return {\n",
+    "            cat.value: {\n",
+    "                \"completed\": len(prog.completed_goals),\n",
+    "                \"total\": prog.total_goals,\n",
+    "                \"recent\": [\n",
+    "                    {\n",
+    "                        \"smart_version\": goal.smart_version,\n",
+    "                        \"completed_at\": goal.completed_at.isoformat()\n",
+    "                    }\n",
+    "                    for goal in sorted(\n",
+    "                        prog.completed_goals,\n",
+    "                        key=lambda x: x.completed_at or datetime.min,\n",
+    "                        reverse=True\n",
+    "                    )[:3]  # Last 3 completed\n",
+    "                ]\n",
+    "            }\n",
+    "            for cat, prog in self.category_progress.items()\n",
+    "        }\n",
+    "    \n",
+    "    def get_all_goals(self) -> List[Dict]:\n",
+    "        \"\"\"\n",
+    "        Get all goals for current rotation.\n",
+    "        \n",
+    "        Returns:\n",
+    "            list: All goals matching current rotation\n",
+    "        \"\"\"\n",
+    "        all_goals = []\n",
+    "        for prog in self.category_progress.values():\n",
+    "            # Add completed goals\n",
+    "            all_goals.extend([\n",
+    "                goal.dict() for goal in prog.completed_goals\n",
+    "                if (goal.specialty == self.rotation.specialty and\n",
+    "                    goal.setting == self.rotation.setting)\n",
+    "            ])\n",
+    "            \n",
+    "            # Add active goal if matches\n",
+    "            if self.active_goal and (\n",
+    "                self.active_goal.specialty == self.rotation.specialty and\n",
+    "                self.active_goal.setting == self.rotation.setting\n",
+    "            ):\n",
+    "                all_goals.append(self.active_goal.dict())\n",
+    "        \n",
+    "        return sorted(\n",
+    "            all_goals,\n",
+    "            key=lambda x: x[\"created_at\"],\n",
+    "            reverse=True\n",
+    "        )\n",
+    "    \n",
+    "    def load_context(self) -> None:\n",
+    "        \"\"\"Load context from file.\"\"\"\n",
+    "        try:\n",
+    "            with open(self.context_path, 'r') as f:\n",
+    "                data = json.load(f)\n",
+    "            \n",
+    "            # Load rotation\n",
+    "            self.rotation = RotationContext(**data[\"rotation\"])\n",
+    "            \n",
+    "            # Load progress\n",
+    "            for cat_data in data[\"category_progress\"]:\n",
+    "                cat = LearningCategory(cat_data[\"category\"])\n",
+    "                \n",
+    "                # Convert goal dicts back to models\n",
+    "                completed_goals = [\n",
+    "                    SmartGoal(**g) for g in cat_data[\"completed_goals\"]\n",
+    "                ]\n",
+    "                \n",
+    "                self.category_progress[cat] = CategoryProgress(\n",
+    "                    category=cat,\n",
+    "                    completed_goals=completed_goals,\n",
+    "                    total_goals=cat_data[\"total_goals\"]\n",
+    "                )\n",
+    "            \n",
+    "            # Load active goal if exists\n",
+    "            if data.get(\"active_goal\"):\n",
+    "                self.active_goal = SmartGoal(**data[\"active_goal\"])\n",
+    "                \n",
+    "            logger.info(f\"Context loaded from {self.context_path}\")\n",
+    "            \n",
+    "        except Exception as e:\n",
+    "            logger.error(f\"Error loading context: {str(e)}\")\n",
+    "    \n",
+    "    def _save_context(self) -> None:\n",
+    "        \"\"\"Save context to file.\"\"\"\n",
+    "        if not self.context_path:\n",
+    "            return\n",
+    "            \n",
+    "        try:\n",
+    "            data = {\n",
+    "                \"rotation\": self.rotation.dict(),\n",
+    "                \"category_progress\": [\n",
+    "                    {\n",
+    "                        \"category\": prog.category,\n",
+    "                        \"completed_goals\": [\n",
+    "                            g.dict() for g in prog.completed_goals\n",
+    "                        ],\n",
+    "                        \"total_goals\": prog.total_goals\n",
+    "                    }\n",
+    "                    for prog in self.category_progress.values()\n",
+    "                ],\n",
+    "                \"active_goal\": self.active_goal.dict() if self.active_goal else None\n",
+    "            }\n",
+    "            \n",
+    "            with open(self.context_path, 'w') as f:\n",
+    "                json.dump(data, f, indent=2)\n",
+    "                \n",
+    "            logger.info(f\"Context saved to {self.context_path}\")\n",
+    "            \n",
+    "        except Exception as e:\n",
+    "            logger.error(f\"Error saving context: {str(e)}\")"
+   ]
+  },
+  {
+   "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": [
+    "# | hide\n",
+    "def test_learning_context():\n",
+    "    \"\"\"Test learning context functionality\"\"\"\n",
+    "    # Initialize context\n",
+    "    context = LearningContext()\n",
+    "    \n",
+    "    try:\n",
+    "        # Test rotation updates\n",
+    "        context.update_rotation(\"Emergency Medicine\", \"ED\")\n",
+    "        assert context.rotation.specialty == \"Emergency Medicine\"\n",
+    "        assert context.rotation.setting == \"ED\"\n",
+    "        \n",
+    "        # Test learning objectives\n",
+    "        goal = SmartGoal(\n",
+    "            id=\"test_goal_1\",\n",
+    "            category=LearningCategory.CLINICAL_REASONING,\n",
+    "            original_input=\"Get better at chest pain\",\n",
+    "            smart_version=\"Demonstrate systematic assessment of chest pain\",\n",
+    "            specialty=\"Emergency Medicine\",\n",
+    "            setting=\"ED\",\n",
+    "            created_at=datetime.now()\n",
+    "        )\n",
+    "        \n",
+    "        context.add_smart_goal(goal)\n",
+    "        assert context.active_goal == goal\n",
+    "        \n",
+    "        # Test completing objectives\n",
+    "        context.complete_active_goal()\n",
+    "        assert context.active_goal is None\n",
+    "        \n",
+    "        # Test progress tracking\n",
+    "        summary = context.get_category_summary()\n",
+    "        cat_data = summary[LearningCategory.CLINICAL_REASONING.value]\n",
+    "        assert cat_data[\"completed\"] == 1\n",
+    "        assert cat_data[\"total\"] == 1\n",
+    "        assert len(cat_data[\"recent\"]) == 1\n",
+    "        \n",
+    "    finally:\n",
+    "        # Cleanup\n",
+    "        pass\n",
+    "        \n",
+    "    print(\"All learning context tests passed!\")\n",
+    "\n",
+    "# Run tests\n",
+    "if __name__ == \"__main__\":\n",
+    "    test_learning_context()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "python3",
+   "language": "python",
+   "name": "python3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

nbs/01_clinical_tutor.ipynb

@@ -0,0 +1,857 @@
+{
+ "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": [
+    {
+     "ename": "ImportError",
+     "evalue": "cannot import name 'LearningCategory' from 'wardbuddy.learning_context' (C:\\Users\\deepa\\OneDrive\\Documents\\StudyBuddy\\wardbuddy\\wardbuddy\\learning_context.py)",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mImportError\u001b[0m                               Traceback (most recent call last)",
+      "Cell \u001b[1;32mIn[3], line 12\u001b[0m\n\u001b[0;32m     10\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mpydantic\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m BaseModel\n\u001b[0;32m     11\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mdotenv\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m load_dotenv\n\u001b[1;32m---> 12\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 LearningContext, setup_logger, LearningCategory, SmartGoal, RotationContext\n\u001b[0;32m     15\u001b[0m \u001b[38;5;66;03m# Load environment variables\u001b[39;00m\n\u001b[0;32m     16\u001b[0m load_dotenv()\n",
+      "\u001b[1;31mImportError\u001b[0m: cannot import name 'LearningCategory' from 'wardbuddy.learning_context' (C:\\Users\\deepa\\OneDrive\\Documents\\StudyBuddy\\wardbuddy\\wardbuddy\\learning_context.py)"
+     ]
+    }
+   ],
+   "source": [
+    "#| export\n",
+    "from typing import Dict, List, Optional, Tuple, Any\n",
+    "import os\n",
+    "import json\n",
+    "import logging\n",
+    "import asyncio\n",
+    "import uuid\n",
+    "from datetime import datetime\n",
+    "from pathlib import Path\n",
+    "import aiohttp\n",
+    "from pydantic import BaseModel\n",
+    "from dotenv import load_dotenv\n",
+    "from wardbuddy.learning_context import LearningContext, setup_logger, LearningCategory, SmartGoal, RotationContext\n",
+    "\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": "c1956b74-a5fe-4b69-9b5c-efe4cc55b97d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export\n",
+    "class ClinicalTutor:\n",
+    "    \"\"\"\n",
+    "    Clinical teaching system using LLMs for goal setting and case discussion.\n",
+    "    \n",
+    "    Features:\n",
+    "    - SMART goal generation\n",
+    "    - Case discussion\n",
+    "    - Progress tracking\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    def __init__(\n",
+    "        self,\n",
+    "        context_path: Optional[Path] = None,\n",
+    "        model: str = \"anthropic/claude-3-sonnet\",\n",
+    "        api_key: Optional[str] = None\n",
+    "    ):\n",
+    "        \"\"\"\n",
+    "        Initialize clinical tutor.\n",
+    "        \n",
+    "        Args:\n",
+    "            context_path: Path for context persistence\n",
+    "            model: OpenRouter model identifier\n",
+    "            api_key: OpenRouter API key (falls back to env var)\n",
+    "        \"\"\"\n",
+    "        self.api_key = api_key or os.getenv(\"OPENROUTER_API_KEY\")\n",
+    "        if not self.api_key:\n",
+    "            raise ValueError(\"OpenRouter API key required\")\n",
+    "            \n",
+    "        self.api_url = \"https://openrouter.ai/api/v1/chat/completions\"\n",
+    "        self.model = model\n",
+    "        \n",
+    "        self.learning_context = LearningContext(context_path)\n",
+    "        \n",
+    "        # Track current discussion\n",
+    "        self.current_discussion: List[Dict] = []\n",
+    "        \n",
+    "        logger.info(\"Clinical tutor initialized\")\n",
+    "    \n",
+    "    async def generate_smart_goals(\n",
+    "        self,\n",
+    "        specialty: str,\n",
+    "        setting: str,\n",
+    "        num_goals: int = 3\n",
+    "    ) -> List[SmartGoal]:\n",
+    "        \"\"\"\n",
+    "        Generate SMART goals for rotation context.\n",
+    "        \n",
+    "        Args:\n",
+    "            specialty: Medical specialty\n",
+    "            setting: Clinical setting\n",
+    "            num_goals: Number of goals to generate\n",
+    "            \n",
+    "        Returns:\n",
+    "            list: Generated SMART goals\n",
+    "        \"\"\"\n",
+    "        prompt = f\"\"\"Generate {num_goals} SMART learning goals for a medical trainee in {specialty} ({setting}).\n",
+    "\n",
+    "For each goal:\n",
+    "1. Select an appropriate category from: {', '.join(cat.value for cat in LearningCategory)}\n",
+    "2. Write a specific, measurable goal that builds clinical competence\n",
+    "\n",
+    "Format as JSON array with fields:\n",
+    "- category: Learning category name\n",
+    "- smart_version: SMART formatted goal text\n",
+    "\n",
+    "Goals should be specific to the {setting} setting in {specialty}.\"\"\"\n",
+    "\n",
+    "        try:\n",
+    "            response = await self._get_completion([{\n",
+    "                \"role\": \"system\",\n",
+    "                \"content\": prompt\n",
+    "            }])\n",
+    "            \n",
+    "            # Parse response to extract goals\n",
+    "            goals_data = json.loads(response)\n",
+    "            \n",
+    "            # Convert to SmartGoal objects\n",
+    "            goals = []\n",
+    "            for data in goals_data:\n",
+    "                goal = SmartGoal(\n",
+    "                    id=f\"goal_{uuid.uuid4()}\",\n",
+    "                    category=LearningCategory(data[\"category\"]),\n",
+    "                    original_input=\"\",  # Auto-generated\n",
+    "                    smart_version=data[\"smart_version\"],\n",
+    "                    specialty=specialty,\n",
+    "                    setting=setting,\n",
+    "                    created_at=datetime.now()\n",
+    "                )\n",
+    "                goals.append(goal)\n",
+    "            \n",
+    "            return goals\n",
+    "            \n",
+    "        except Exception as e:\n",
+    "            logger.error(f\"Error generating goals: {str(e)}\")\n",
+    "            return []\n",
+    "    \n",
+    "    async def generate_smart_goal(\n",
+    "        self,\n",
+    "        user_input: str,\n",
+    "        specialty: str,\n",
+    "        setting: str\n",
+    "    ) -> Optional[SmartGoal]:\n",
+    "        \"\"\"\n",
+    "        Generate SMART goal from user input.\n",
+    "        \n",
+    "        Args:\n",
+    "            user_input: User's goal description\n",
+    "            specialty: Current specialty\n",
+    "            setting: Current setting\n",
+    "            \n",
+    "        Returns:\n",
+    "            SmartGoal: Generated SMART goal\n",
+    "        \"\"\"\n",
+    "        prompt = f\"\"\"Convert this learning goal into a SMART goal (Specific, Measurable, Achievable, Relevant, Time-bound) for {specialty} ({setting}):\n",
+    "\n",
+    "\"{user_input}\"\n",
+    "\n",
+    "1. Select the most appropriate category from: {', '.join(cat.value for cat in LearningCategory)}\n",
+    "2. Rewrite as a SMART goal specific to {setting} in {specialty}\n",
+    "\n",
+    "Format as JSON with fields:\n",
+    "- category: Learning category name\n",
+    "- smart_version: SMART formatted goal text\"\"\"\n",
+    "\n",
+    "        try:\n",
+    "            response = await self._get_completion([{\n",
+    "                \"role\": \"system\",\n",
+    "                \"content\": prompt\n",
+    "            }])\n",
+    "            \n",
+    "            # Parse response\n",
+    "            data = json.loads(response)\n",
+    "            \n",
+    "            return SmartGoal(\n",
+    "                id=f\"goal_{uuid.uuid4()}\",\n",
+    "                category=LearningCategory(data[\"category\"]),\n",
+    "                original_input=user_input,\n",
+    "                smart_version=data[\"smart_version\"],\n",
+    "                specialty=specialty,\n",
+    "                setting=setting,\n",
+    "                created_at=datetime.now()\n",
+    "            )\n",
+    "            \n",
+    "        except Exception as e:\n",
+    "            logger.error(f\"Error generating SMART goal: {str(e)}\")\n",
+    "            return None\n",
+    "    \n",
+    "    async def discuss_case(self, message: str) -> str:\n",
+    "        \"\"\"\n",
+    "        Process case discussion message.\n",
+    "        \n",
+    "        Args:\n",
+    "            message: User's message\n",
+    "            \n",
+    "        Returns:\n",
+    "            str: Tutor's response\n",
+    "        \"\"\"\n",
+    "        try:\n",
+    "            # Add to discussion history\n",
+    "            self.current_discussion.append({\n",
+    "                \"role\": \"user\",\n",
+    "                \"content\": message\n",
+    "            })\n",
+    "            \n",
+    "            # Build conversation prompt\n",
+    "            system_prompt = self._build_discussion_prompt()\n",
+    "            \n",
+    "            messages = [{\n",
+    "                \"role\": \"system\",\n",
+    "                \"content\": system_prompt\n",
+    "            }]\n",
+    "            messages.extend(self.current_discussion)\n",
+    "            \n",
+    "            # Get response\n",
+    "            response = await self._get_completion(messages)\n",
+    "            \n",
+    "            # Add to history\n",
+    "            self.current_discussion.append({\n",
+    "                \"role\": \"assistant\",\n",
+    "                \"content\": response\n",
+    "            })\n",
+    "            \n",
+    "            return response\n",
+    "            \n",
+    "        except Exception as e:\n",
+    "            logger.error(f\"Error in discussion: {str(e)}\")\n",
+    "            return \"I apologize, but I encountered an error. Please try again.\"\n",
+    "    \n",
+    "    def end_discussion(self) -> None:\n",
+    "        \"\"\"End current discussion.\"\"\"\n",
+    "        if self.learning_context.active_goal:\n",
+    "            self.learning_context.complete_active_goal()\n",
+    "            \n",
+    "        self.current_discussion = []\n",
+    "    \n",
+    "    def _build_discussion_prompt(self) -> str:\n",
+    "        \"\"\"Build context-aware discussion prompt.\"\"\"\n",
+    "        context = self.learning_context\n",
+    "        rotation = context.rotation\n",
+    "        active_goal = context.active_goal\n",
+    "        \n",
+    "        return f\"\"\"You are an experienced clinical supervisor in {rotation.specialty} \n",
+    "        working in a {rotation.setting} setting. Guide the learner through case discussion\n",
+    "        using Socratic questioning and targeted feedback.\n",
+    "\n",
+    "        Current Learning Goal:\n",
+    "        {active_goal.smart_version if active_goal else 'General clinical discussion'}\n",
+    "\n",
+    "        Approach:\n",
+    "        1. Focus on clinical reasoning and decision-making\n",
+    "        2. Ask targeted questions to explore understanding\n",
+    "        3. Share relevant clinical pearls\n",
+    "        4. Be conversational and engaging\n",
+    "        5. Relate discussion to current learning goal where relevant\n",
+    "\n",
+    "        Remember: The learner has strong foundational knowledge. Focus on advanced clinical concepts\n",
+    "        rather than basic science.\"\"\"\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: Conversation messages\n",
+    "            temperature: Response temperature\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\"  # Or your actual domain\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",
+    "                await asyncio.sleep(1 * (attempt + 1))  # Exponential backoff\n",
+    "    \n",
+    "    def get_discussion_history(self) -> List[Dict]:\n",
+    "        \"\"\"\n",
+    "        Get current discussion history.\n",
+    "        \n",
+    "        Returns:\n",
+    "            list: Discussion messages\n",
+    "        \"\"\"\n",
+    "        return self.current_discussion\n",
+    "    \n",
+    "    def clear_discussion(self) -> None:\n",
+    "        \"\"\"Clear current discussion history.\"\"\"\n",
+    "        self.current_discussion = []"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "75c2cbfc-75e7-45ee-9d86-b931f81a3ad5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| hide\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",
+    "        \"\"\"Build context-aware prompt for case discussion.\"\"\"\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",
+    "        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']}. Act as an engaging and conversational tutor who coaches towards deeper understanding through Socratic dialogue and targeted questions.\n",
+    "\n",
+    "        Key Principles:\n",
+    "        1. Assume I have strong foundational knowledge in medicine, clinical reasoning, and pre-medical sciences\n",
+    "        2. Focus on high-level connections and nuanced clinical decision-making\n",
+    "        3. Use targeted questions to explore my thought process and highlight key learning points\n",
+    "        4. Share relevant clinical pearls and real-world applications\n",
+    "        5. Be conversational and engaging, avoiding lecture-style responses\n",
+    "        \n",
+    "        Current Rotation Focus Areas:\n",
+    "        {', '.join(rotation['key_focus_areas'])}\n",
+    "\n",
+    "        Areas for Deep Dive:\n",
+    "        {', '.join(f'{topic} (confidence: {score:.1f})' for topic, score in significant_gaps.items()) if significant_gaps else 'General clinical reasoning'}\n",
+    "\n",
+    "        Student's Interests:\n",
+    "        {', '.join(active_preferences) if active_preferences else 'Broad clinical discussion'}\n",
+    "\n",
+    "        Ask probing questions that explore clinical reasoning and highlight important connections. I will ask for clarification \n",
+    "        if concepts need more explanation.\"\"\"\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": [
+    "# | hide\n",
+    "\n",
+    "from wardbuddy.clinical_tutor import ClinicalTutor\n",
+    "from wardbuddy.learning_context import LearningCategory, SmartGoal\n",
+    "\n",
+    "async def test_clinical_tutor():\n",
+    "    \"\"\"Test basic clinical tutor functionality.\"\"\"\n",
+    "    if not os.getenv(\"OPENROUTER_API_KEY\"):\n",
+    "        print(\"Skipping tests: No API key\")\n",
+    "        return\n",
+    "    \n",
+    "    # Initialize tutor\n",
+    "    tutor = ClinicalTutor()\n",
+    "    \n",
+    "    # Test case content\n",
+    "    test_case = \"28yo M with chest pain, 2 days duration\"\n",
+    "    \n",
+    "    try:\n",
+    "        # Basic discussion test\n",
+    "        response = await tutor.discuss_case(test_case)\n",
+    "        assert isinstance(response, str)\n",
+    "        assert len(response) > 0\n",
+    "        \n",
+    "        # Test goal generation\n",
+    "        goals = await tutor.generate_smart_goals(\"Emergency Medicine\", \"ED\")\n",
+    "        assert len(goals) > 0\n",
+    "        \n",
+    "        # Clear discussion\n",
+    "        tutor.end_discussion()\n",
+    "        assert len(tutor.get_discussion_history()) == 0\n",
+    "        \n",
+    "        print(\"All tests passed!\")\n",
+    "        \n",
+    "    except Exception as e:\n",
+    "        print(f\"Test failed: {str(e)}\")\n",
+    "        raise\n",
+    "\n",
+    "# Run tests\n",
+    "if __name__ == \"__main__\":\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": "python3",
+   "language": "python",
+   "name": "python3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

nbs/02_learning_interface.ipynb

@@ -0,0 +1,1325 @@
+{
+ "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, LearningCategory, SmartGoal\n",
+    "import json\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_css() -> str:\n",
+    "    \"\"\"Create custom CSS for interface styling.\"\"\"\n",
+    "    return \"\"\"\n",
+    "    .gradio-container {\n",
+    "        background-color: #0f172a !important;\n",
+    "    }\n",
+    "    \n",
+    "    .chat-message {\n",
+    "        background-color: #1e293b !important;\n",
+    "        border: 1px solid #334155 !important;\n",
+    "        border-radius: 0.5rem !important;\n",
+    "        padding: 1rem !important;\n",
+    "        margin: 0.5rem 0 !important;\n",
+    "    }\n",
+    "    \n",
+    "    .user-message {\n",
+    "        background-color: #2563eb !important;\n",
+    "    }\n",
+    "    \n",
+    "    textarea, select {\n",
+    "        background-color: #1e293b !important;\n",
+    "        border: 1px solid #334155 !important;\n",
+    "        color: #f1f5f9 !important;\n",
+    "    }\n",
+    "    \n",
+    "    button {\n",
+    "        background-color: #2563eb !important;\n",
+    "        color: white !important;\n",
+    "    }\n",
+    "    \n",
+    "    button:hover {\n",
+    "        background-color: #1d4ed8 !important;\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": "f6edc027-8625-4856-94ce-8f1a0acd4c8f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export\n",
+    "class LearningInterface:\n",
+    "    \"\"\"\n",
+    "    Gradio interface for clinical learning system.\n",
+    "    \n",
+    "    Features:\n",
+    "    - Context selection\n",
+    "    - Goal management\n",
+    "    - Case discussion\n",
+    "    - Progress tracking\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 interface.\n",
+    "        \n",
+    "        Args:\n",
+    "            context_path: Path for context persistence\n",
+    "            model: OpenRouter model identifier\n",
+    "        \"\"\"\n",
+    "        self.tutor = ClinicalTutor(context_path, model)\n",
+    "        \n",
+    "        # Available options\n",
+    "        self.specialties = [\n",
+    "            \"Internal Medicine\",\n",
+    "            \"Emergency Medicine\",\n",
+    "            \"Surgery\",\n",
+    "            \"Pediatrics\",\n",
+    "            \"Family Medicine\"\n",
+    "        ]\n",
+    "        \n",
+    "        self.settings = [\"Clinic\", \"Wards\", \"ED\"]\n",
+    "        \n",
+    "        logger.info(\"Learning interface initialized\")\n",
+    "    \n",
+    "    def create_interface(self) -> gr.Blocks:\n",
+    "        \"\"\"Create Gradio interface.\"\"\"\n",
+    "        \n",
+    "        with gr.Blocks(\n",
+    "            title=\"Clinical Learning Assistant\",\n",
+    "            css=create_css()\n",
+    "        ) as interface:\n",
+    "            # State management\n",
+    "            state = gr.State({\n",
+    "                \"discussion_active\": False,\n",
+    "                \"suggested_goals\": []  # Store generated goals\n",
+    "            })\n",
+    "            \n",
+    "            # Header\n",
+    "            gr.Markdown(\"# Clinical Learning Assistant\")\n",
+    "            \n",
+    "            with gr.Row():\n",
+    "                # Context selection\n",
+    "                specialty = gr.Dropdown(\n",
+    "                    choices=self.specialties,\n",
+    "                    label=\"Specialty\",\n",
+    "                    value=self.tutor.learning_context.rotation.specialty or None\n",
+    "                )\n",
+    "                \n",
+    "                setting = gr.Dropdown(\n",
+    "                    choices=self.settings,\n",
+    "                    label=\"Setting\",\n",
+    "                    value=self.tutor.learning_context.rotation.setting or None\n",
+    "                )\n",
+    "            \n",
+    "            # Main content\n",
+    "            with gr.Row():\n",
+    "                # Left: Discussion interface\n",
+    "                with gr.Column(scale=2):\n",
+    "                    # Active goal display\n",
+    "                    goal_display = gr.Markdown(\n",
+    "                        value=\"No active learning goal\"\n",
+    "                    )\n",
+    "                    \n",
+    "                    # Chat interface\n",
+    "                    chatbot = gr.Chatbot(\n",
+    "                        height=400,\n",
+    "                        show_label=False\n",
+    "                    )\n",
+    "                    \n",
+    "                    with gr.Row():\n",
+    "                        message = gr.Textbox(\n",
+    "                            label=\"Present your case or ask questions\",\n",
+    "                            placeholder=\"Present your case as you would to your supervisor...\",\n",
+    "                            lines=4\n",
+    "                        )\n",
+    "                        \n",
+    "                        audio_input = gr.Audio(\n",
+    "                            source=\"microphone\",\n",
+    "                            type=\"numpy\",\n",
+    "                            label=\"Or speak your case\",\n",
+    "                            streaming=True\n",
+    "                        )\n",
+    "                    \n",
+    "                    with gr.Row():\n",
+    "                        clear = gr.Button(\"Clear Discussion\")\n",
+    "                        end = gr.Button(\n",
+    "                            \"End Discussion & Review\",\n",
+    "                            variant=\"primary\"\n",
+    "                        )\n",
+    "                \n",
+    "                # Right: Progress & Goals\n",
+    "                with gr.Column(scale=1):\n",
+    "                    with gr.Tab(\"Learning Goals\"):\n",
+    "                        # Goal selection/generation\n",
+    "                        with gr.Row():\n",
+    "                            generate = gr.Button(\"Generate New Goals\")\n",
+    "                            \n",
+    "                            new_goal = gr.Textbox(\n",
+    "                                label=\"Or enter your own goal\",\n",
+    "                                placeholder=\"What do you want to get better at?\"\n",
+    "                            )\n",
+    "                            \n",
+    "                            add_goal = gr.Button(\"Add Goal\")\n",
+    "                        \n",
+    "                        # Goals list\n",
+    "                        goals_list = gr.DataFrame(\n",
+    "                            headers=[\"Goal\", \"Category\", \"Status\"],\n",
+    "                            label=\"Available Goals\"\n",
+    "                        )\n",
+    "                    \n",
+    "                    with gr.Tab(\"Progress\"):\n",
+    "                        # Category progress\n",
+    "                        progress_display = gr.DataFrame(\n",
+    "                            headers=[\"Category\", \"Completed\", \"Total\"],\n",
+    "                            label=\"Progress by Category\"\n",
+    "                        )\n",
+    "                        \n",
+    "                        # Recent completions\n",
+    "                        recent_display = gr.DataFrame(\n",
+    "                            headers=[\"Goal\", \"Category\", \"Completed\"],\n",
+    "                            label=\"Recently Completed\"\n",
+    "                        )\n",
+    "            \n",
+    "            # Event handlers\n",
+    "            async def update_context(spec, set):\n",
+    "                \"\"\"Update rotation context.\"\"\"\n",
+    "                if spec and set:\n",
+    "                    self.tutor.learning_context.update_rotation(spec, set)\n",
+    "                    \n",
+    "                    # Generate initial goals if needed\n",
+    "                    if not state[\"suggested_goals\"]:\n",
+    "                        goals = await self.tutor.generate_smart_goals(spec, set)\n",
+    "                        state[\"suggested_goals\"] = goals\n",
+    "                    \n",
+    "                    return self._update_displays(state)\n",
+    "                return []\n",
+    "            \n",
+    "            async def process_message(msg, history):\n",
+    "                \"\"\"Process chat message.\"\"\"\n",
+    "                if not msg.strip():\n",
+    "                    return history, \"\"\n",
+    "                    \n",
+    "                response = await self.tutor.discuss_case(msg)\n",
+    "                history.append([msg, response])\n",
+    "                return history, \"\"\n",
+    "            \n",
+    "            def process_audio(audio):\n",
+    "                \"\"\"Convert audio to text.\"\"\"\n",
+    "                # Would integrate with speech-to-text here\n",
+    "                return \"Audio transcription would appear here\"\n",
+    "            \n",
+    "            async def generate_goals(state):\n",
+    "                \"\"\"Generate new goal suggestions.\"\"\"\n",
+    "                rotation = self.tutor.learning_context.rotation\n",
+    "                if rotation.specialty and rotation.setting:\n",
+    "                    goals = await self.tutor.generate_smart_goals(\n",
+    "                        rotation.specialty,\n",
+    "                        rotation.setting\n",
+    "                    )\n",
+    "                    state[\"suggested_goals\"] = goals\n",
+    "                    return self._update_displays(state)\n",
+    "                return []\n",
+    "            \n",
+    "            async def add_user_goal(text, state):\n",
+    "                \"\"\"Add user-specified goal.\"\"\"\n",
+    "                if not text.strip():\n",
+    "                    return state\n",
+    "                    \n",
+    "                rotation = self.tutor.learning_context.rotation\n",
+    "                if rotation.specialty and rotation.setting:\n",
+    "                    goal = await self.tutor.generate_smart_goal(\n",
+    "                        text,\n",
+    "                        rotation.specialty,\n",
+    "                        rotation.setting\n",
+    "                    )\n",
+    "                    if goal:\n",
+    "                        state[\"suggested_goals\"].append(goal)\n",
+    "                        return self._update_displays(state)\n",
+    "                return state\n",
+    "            \n",
+    "            def select_goal(evt: gr.SelectData, state):\n",
+    "                \"\"\"Set selected goal as active.\"\"\"\n",
+    "                if evt.index[0] < len(state[\"suggested_goals\"]):\n",
+    "                    goal = state[\"suggested_goals\"][evt.index[0]]\n",
+    "                    self.tutor.learning_context.add_smart_goal(goal)\n",
+    "                    return self._update_displays(state)\n",
+    "                return state\n",
+    "            \n",
+    "            def end_discussion(state):\n",
+    "                \"\"\"End current discussion.\"\"\"\n",
+    "                self.tutor.end_discussion()\n",
+    "                return self._update_displays(state)\n",
+    "            \n",
+    "            def clear_discussion():\n",
+    "                \"\"\"Clear discussion history.\"\"\"\n",
+    "                self.tutor.clear_discussion()\n",
+    "                return [], \"\"\n",
+    "            \n",
+    "            # Wire up events\n",
+    "            specialty.change(\n",
+    "                update_context,\n",
+    "                inputs=[specialty, setting],\n",
+    "                outputs=[goals_list, progress_display, recent_display, goal_display]\n",
+    "            )\n",
+    "            \n",
+    "            setting.change(\n",
+    "                update_context,\n",
+    "                inputs=[specialty, setting],\n",
+    "                outputs=[goals_list, progress_display, recent_display, goal_display]\n",
+    "            )\n",
+    "            \n",
+    "            message.submit(\n",
+    "                process_message,\n",
+    "                inputs=[message, chatbot],\n",
+    "                outputs=[chatbot, message]\n",
+    "            )\n",
+    "            \n",
+    "            audio_input.stream(\n",
+    "                process_audio,\n",
+    "                inputs=[audio_input],\n",
+    "                outputs=[message]\n",
+    "            )\n",
+    "            \n",
+    "            clear.click(\n",
+    "                clear_discussion,\n",
+    "                outputs=[chatbot, message]\n",
+    "            )\n",
+    "            \n",
+    "            end.click(\n",
+    "                end_discussion,\n",
+    "                inputs=[state],\n",
+    "                outputs=[goals_list, progress_display, recent_display, goal_display]\n",
+    "            )\n",
+    "            \n",
+    "            generate.click(\n",
+    "                generate_goals,\n",
+    "                inputs=[state],\n",
+    "                outputs=[goals_list, progress_display, recent_display, goal_display]\n",
+    "            )\n",
+    "            \n",
+    "            new_goal.submit(\n",
+    "                add_user_goal,\n",
+    "                inputs=[new_goal, state],\n",
+    "                outputs=[goals_list, progress_display, recent_display, goal_display]\n",
+    "            )\n",
+    "            \n",
+    "            goals_list.select(\n",
+    "                select_goal,\n",
+    "                inputs=[state],\n",
+    "                outputs=[goals_list, progress_display, recent_display, goal_display]\n",
+    "            )\n",
+    "            \n",
+    "            return interface\n",
+    "    \n",
+    "    def _update_displays(self, state: Dict) -> List:\n",
+    "        \"\"\"Update all display components.\"\"\"\n",
+    "        context = self.tutor.learning_context\n",
+    "        \n",
+    "        # Update goals list\n",
+    "        goals_data = []\n",
+    "        for goal in state[\"suggested_goals\"]:\n",
+    "            status = \"Active\" if (\n",
+    "                context.active_goal and \n",
+    "                context.active_goal.id == goal.id\n",
+    "            ) else \"Available\"\n",
+    "            \n",
+    "            goals_data.append([\n",
+    "                goal.smart_version,\n",
+    "                goal.category.value,\n",
+    "                status\n",
+    "            ])\n",
+    "        \n",
+    "        # Update progress display\n",
+    "        summary = context.get_category_summary()\n",
+    "        progress_data = [\n",
+    "            [cat, data[\"completed\"], data[\"total\"]]\n",
+    "            for cat, data in summary.items()\n",
+    "        ]\n",
+    "        \n",
+    "        # Update recent completions\n",
+    "        recent_data = []\n",
+    "        for cat, data in summary.items():\n",
+    "            for goal in data[\"recent\"]:\n",
+    "                recent_data.append([\n",
+    "                    goal[\"smart_version\"],\n",
+    "                    cat,\n",
+    "                    goal[\"completed_at\"]\n",
+    "                ])\n",
+    "        \n",
+    "        # Update active goal display\n",
+    "        goal_text = (\n",
+    "            f\"Current Goal: {context.active_goal.smart_version}\"\n",
+    "            if context.active_goal else\n",
+    "            \"No active learning goal\"\n",
+    "        )\n",
+    "        \n",
+    "        return [\n",
+    "            goals_data,\n",
+    "            progress_data,\n",
+    "            recent_data,\n",
+    "            goal_text\n",
+    "        ]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "675c20cc-43aa-4897-89ba-4fa26dd37c20",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| hide\n",
+    "# old code\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[List[str]],\n",
+    "        state: Dict[str, Any]\n",
+    "    ) -> Tuple[List[List[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 - now using list pairs instead of dicts\n",
+    "            if history is None:\n",
+    "                history = []\n",
+    "            history.append([message, response])  # Changed from dict format to list pair\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[List[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 as list of [user_message, assistant_message] pairs\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",
+    "            # Convert history format for analysis\n",
+    "            formatted_history = []\n",
+    "            for user_msg, assistant_msg in history:\n",
+    "                formatted_history.extend([\n",
+    "                    {\"role\": \"user\", \"content\": user_msg},\n",
+    "                    {\"role\": \"assistant\", \"content\": assistant_msg}\n",
+    "                ])\n",
+    "            \n",
+    "            # Get analysis\n",
+    "            analysis = await self.tutor.analyze_discussion(formatted_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",
+    "                        # Add voice input with updated syntax\n",
+    "                        audio_msg = gr.Audio(\n",
+    "                            label=\"Or speak your case\",\n",
+    "                            sources=[\"microphone\"],\n",
+    "                            type=\"numpy\",\n",
+    "                            streaming=True\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",
+    "            # Add new event handler for voice input\n",
+    "            def process_audio(audio):\n",
+    "                if audio is None:\n",
+    "                    return None\n",
+    "                # Convert audio to text using your preferred method\n",
+    "                # For example, you could use transformers pipeline here\n",
+    "                try:\n",
+    "                    from transformers import pipeline\n",
+    "                    transcriber = pipeline(\"automatic-speech-recognition\", model=\"openai/whisper-small\")\n",
+    "                    text = transcriber(audio)[\"text\"]\n",
+    "                    return text\n",
+    "                except Exception as e:\n",
+    "                    logger.error(f\"Error transcribing audio: {str(e)}\")\n",
+    "                    return None\n",
+    "            \n",
+    "            # Update the event handler:\n",
+    "            audio_msg.stop_recording(\n",
+    "                fn=process_audio,\n",
+    "                outputs=[msg]\n",
+    "            ).then(\n",
+    "                fn=self.process_chat,\n",
+    "                inputs=[msg, chatbot, state],\n",
+    "                outputs=[chatbot, msg, state]\n",
+    "            ).then(\n",
+    "                fn=self._update_discussion_status,\n",
+    "                inputs=[state],\n",
+    "                outputs=[discussion_status]\n",
+    "            )        \n",
+    "\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": [
+    "#| hide\n",
+    "# old\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": [
+    "#| hide\n",
+    "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": "python3",
+   "language": "python",
+   "name": "python3"
+  }
+ },
+ "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/main.ipynb

@@ -0,0 +1,87 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2aea50e4-af9b-419c-afd4-733b8ce5f1be",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| default_exp main"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9eca9cd0-fe04-4c4f-b434-1e9106bff73c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# | export\n",
+    "\"\"\"Main entry point for the WardBuddy application.\"\"\"\n",
+    "import asyncio\n",
+    "from pathlib import Path\n",
+    "import typer\n",
+    "from typing import Optional\n",
+    "import logging\n",
+    "\n",
+    "from wardbuddy.learning_interface import LearningInterface\n",
+    "\n",
+    "# Configure logging\n",
+    "logging.basicConfig(level=logging.INFO)\n",
+    "logger = logging.getLogger(__name__)\n",
+    "\n",
+    "app = typer.Typer()\n",
+    "\n",
+    "@app.command()\n",
+    "def launch(\n",
+    "    port: int = typer.Option(7860, help=\"Port to run on\"),\n",
+    "    context_path: Optional[Path] = typer.Option(\n",
+    "        None,\n",
+    "        help=\"Path to context file\",\n",
+    "        dir_okay=False\n",
+    "    ),\n",
+    "    model: str = typer.Option(\n",
+    "        \"anthropic/claude-3-sonnet\",\n",
+    "        help=\"OpenRouter model identifier\"\n",
+    "    ),\n",
+    "    share: bool = typer.Option(\n",
+    "        False,\n",
+    "        help=\"Create public URL\"\n",
+    "    )\n",
+    ") -> None:\n",
+    "    \"\"\"Launch the clinical learning interface.\"\"\"\n",
+    "    try:\n",
+    "        interface = LearningInterface(\n",
+    "            context_path=context_path,\n",
+    "            model=model\n",
+    "        )\n",
+    "        \n",
+    "        app = interface.create_interface()\n",
+    "        app.launch(\n",
+    "            server_port=port,\n",
+    "            share=share\n",
+    "        )\n",
+    "        \n",
+    "        logger.info(f\"Interface launched on port {port}\")\n",
+    "        \n",
+    "    except Exception as e:\n",
+    "        logger.error(f\"Error launching interface: {str(e)}\")\n",
+    "        raise typer.Exit(1)\n",
+    "\n",
+    "def run_app():\n",
+    "    \"\"\"Entry point for command line.\"\"\"\n",
+    "    app()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "python3",
+   "language": "python",
+   "name": "python3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

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"

requirements.txt

@@ -0,0 +1,19 @@
+# Core Python dependencies
+aiohttp
+python-dotenv
+gradio
+pandas
+pathlib
+huggingface_hub
+
+# Logging and utilities
+
+jsonschema
+typing-extensions
+
+# Development and testing (optional)
+# pytest
+# mypy
+
+# API and LLM interaction
+# OpenRouter API is used, but no specific library needed beyond aiohttp

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 = [email protected]
+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,73 @@
+# 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_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.clear_discussion': ( 'clinical_tutor.html#clinicaltutor.clear_discussion',
+                                                                                                       'wardbuddy/clinical_tutor.py'),
+                                          'wardbuddy.clinical_tutor.ClinicalTutor.discuss_case': ( 'clinical_tutor.html#clinicaltutor.discuss_case',
+                                                                                                   'wardbuddy/clinical_tutor.py'),
+                                          'wardbuddy.clinical_tutor.ClinicalTutor.end_discussion': ( 'clinical_tutor.html#clinicaltutor.end_discussion',
+                                                                                                     'wardbuddy/clinical_tutor.py'),
+                                          'wardbuddy.clinical_tutor.ClinicalTutor.generate_smart_goal': ( 'clinical_tutor.html#clinicaltutor.generate_smart_goal',
+                                                                                                          'wardbuddy/clinical_tutor.py'),
+                                          'wardbuddy.clinical_tutor.ClinicalTutor.generate_smart_goals': ( 'clinical_tutor.html#clinicaltutor.generate_smart_goals',
+                                                                                                           'wardbuddy/clinical_tutor.py'),
+                                          'wardbuddy.clinical_tutor.ClinicalTutor.get_discussion_history': ( 'clinical_tutor.html#clinicaltutor.get_discussion_history',
+                                                                                                             '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.CategoryProgress': ( 'learning_context.html#categoryprogress',
+                                                                                             'wardbuddy/learning_context.py'),
+                                            'wardbuddy.learning_context.LearningCategory': ( 'learning_context.html#learningcategory',
+                                                                                             'wardbuddy/learning_context.py'),
+                                            '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._save_context': ( 'learning_context.html#learningcontext._save_context',
+                                                                                                          'wardbuddy/learning_context.py'),
+                                            'wardbuddy.learning_context.LearningContext.add_smart_goal': ( 'learning_context.html#learningcontext.add_smart_goal',
+                                                                                                           'wardbuddy/learning_context.py'),
+                                            'wardbuddy.learning_context.LearningContext.complete_active_goal': ( 'learning_context.html#learningcontext.complete_active_goal',
+                                                                                                                 'wardbuddy/learning_context.py'),
+                                            'wardbuddy.learning_context.LearningContext.get_all_goals': ( 'learning_context.html#learningcontext.get_all_goals',
+                                                                                                          'wardbuddy/learning_context.py'),
+                                            'wardbuddy.learning_context.LearningContext.get_category_summary': ( 'learning_context.html#learningcontext.get_category_summary',
+                                                                                                                 'wardbuddy/learning_context.py'),
+                                            'wardbuddy.learning_context.LearningContext.load_context': ( 'learning_context.html#learningcontext.load_context',
+                                                                                                         'wardbuddy/learning_context.py'),
+                                            'wardbuddy.learning_context.LearningContext.update_rotation': ( 'learning_context.html#learningcontext.update_rotation',
+                                                                                                            'wardbuddy/learning_context.py'),
+                                            'wardbuddy.learning_context.RotationContext': ( 'learning_context.html#rotationcontext',
+                                                                                            'wardbuddy/learning_context.py'),
+                                            'wardbuddy.learning_context.SmartGoal': ( 'learning_context.html#smartgoal',
+                                                                                      'wardbuddy/learning_context.py'),
+                                            'wardbuddy.learning_context.SmartGoal.Config': ( 'learning_context.html#smartgoal.config',
+                                                                                             '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._update_displays': ( 'learning_interface.html#learninginterface._update_displays',
+                                                                                                                   'wardbuddy/learning_interface.py'),
+                                              'wardbuddy.learning_interface.LearningInterface.create_interface': ( 'learning_interface.html#learninginterface.create_interface',
+                                                                                                                   'wardbuddy/learning_interface.py'),
+                                              'wardbuddy.learning_interface.create_css': ( 'learning_interface.html#create_css',
+                                                                                           'wardbuddy/learning_interface.py')},
+            'wardbuddy.main': { 'wardbuddy.main.launch': ('main.html#launch', 'wardbuddy/main.py'),
+                                'wardbuddy.main.run_app': ('main.html#run_app', 'wardbuddy/main.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,315 @@
+"""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, Tuple, Any
+import os
+import json
+import logging
+import asyncio
+import uuid
+from datetime import datetime
+from pathlib import Path
+import aiohttp
+from pydantic import BaseModel
+from dotenv import load_dotenv
+from .learning_context import LearningContext, setup_logger, LearningCategory, SmartGoal, RotationContext
+
+
+# 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:
+    """
+    Clinical teaching system using LLMs for goal setting and case discussion.
+    
+    Features:
+    - SMART goal generation
+    - Case discussion
+    - Progress tracking
+    """
+    
+    def __init__(
+        self,
+        context_path: Optional[Path] = None,
+        model: str = "anthropic/claude-3-sonnet",
+        api_key: Optional[str] = None
+    ):
+        """
+        Initialize clinical tutor.
+        
+        Args:
+            context_path: Path for context persistence
+            model: OpenRouter model identifier
+            api_key: OpenRouter API key (falls back to env var)
+        """
+        self.api_key = api_key or os.getenv("OPENROUTER_API_KEY")
+        if not self.api_key:
+            raise ValueError("OpenRouter API key required")
+            
+        self.api_url = "https://openrouter.ai/api/v1/chat/completions"
+        self.model = model
+        
+        self.learning_context = LearningContext(context_path)
+        
+        # Track current discussion
+        self.current_discussion: List[Dict] = []
+        
+        logger.info("Clinical tutor initialized")
+    
+    async def generate_smart_goals(
+        self,
+        specialty: str,
+        setting: str,
+        num_goals: int = 3
+    ) -> List[SmartGoal]:
+        """
+        Generate SMART goals for rotation context.
+        
+        Args:
+            specialty: Medical specialty
+            setting: Clinical setting
+            num_goals: Number of goals to generate
+            
+        Returns:
+            list: Generated SMART goals
+        """
+        prompt = f"""Generate {num_goals} SMART learning goals for a medical trainee in {specialty} ({setting}).
+
+For each goal:
+1. Select an appropriate category from: {', '.join(cat.value for cat in LearningCategory)}
+2. Write a specific, measurable goal that builds clinical competence
+
+Format as JSON array with fields:
+- category: Learning category name
+- smart_version: SMART formatted goal text
+
+Goals should be specific to the {setting} setting in {specialty}."""
+
+        try:
+            response = await self._get_completion([{
+                "role": "system",
+                "content": prompt
+            }])
+            
+            # Parse response to extract goals
+            goals_data = json.loads(response)
+            
+            # Convert to SmartGoal objects
+            goals = []
+            for data in goals_data:
+                goal = SmartGoal(
+                    id=f"goal_{uuid.uuid4()}",
+                    category=LearningCategory(data["category"]),
+                    original_input="",  # Auto-generated
+                    smart_version=data["smart_version"],
+                    specialty=specialty,
+                    setting=setting,
+                    created_at=datetime.now()
+                )
+                goals.append(goal)
+            
+            return goals
+            
+        except Exception as e:
+            logger.error(f"Error generating goals: {str(e)}")
+            return []
+    
+    async def generate_smart_goal(
+        self,
+        user_input: str,
+        specialty: str,
+        setting: str
+    ) -> Optional[SmartGoal]:
+        """
+        Generate SMART goal from user input.
+        
+        Args:
+            user_input: User's goal description
+            specialty: Current specialty
+            setting: Current setting
+            
+        Returns:
+            SmartGoal: Generated SMART goal
+        """
+        prompt = f"""Convert this learning goal into a SMART goal (Specific, Measurable, Achievable, Relevant, Time-bound) for {specialty} ({setting}):
+
+"{user_input}"
+
+1. Select the most appropriate category from: {', '.join(cat.value for cat in LearningCategory)}
+2. Rewrite as a SMART goal specific to {setting} in {specialty}
+
+Format as JSON with fields:
+- category: Learning category name
+- smart_version: SMART formatted goal text"""
+
+        try:
+            response = await self._get_completion([{
+                "role": "system",
+                "content": prompt
+            }])
+            
+            # Parse response
+            data = json.loads(response)
+            
+            return SmartGoal(
+                id=f"goal_{uuid.uuid4()}",
+                category=LearningCategory(data["category"]),
+                original_input=user_input,
+                smart_version=data["smart_version"],
+                specialty=specialty,
+                setting=setting,
+                created_at=datetime.now()
+            )
+            
+        except Exception as e:
+            logger.error(f"Error generating SMART goal: {str(e)}")
+            return None
+    
+    async def discuss_case(self, message: str) -> str:
+        """
+        Process case discussion message.
+        
+        Args:
+            message: User's message
+            
+        Returns:
+            str: Tutor's response
+        """
+        try:
+            # Add to discussion history
+            self.current_discussion.append({
+                "role": "user",
+                "content": message
+            })
+            
+            # Build conversation prompt
+            system_prompt = self._build_discussion_prompt()
+            
+            messages = [{
+                "role": "system",
+                "content": system_prompt
+            }]
+            messages.extend(self.current_discussion)
+            
+            # Get response
+            response = await self._get_completion(messages)
+            
+            # Add to history
+            self.current_discussion.append({
+                "role": "assistant",
+                "content": response
+            })
+            
+            return response
+            
+        except Exception as e:
+            logger.error(f"Error in discussion: {str(e)}")
+            return "I apologize, but I encountered an error. Please try again."
+    
+    def end_discussion(self) -> None:
+        """End current discussion."""
+        if self.learning_context.active_goal:
+            self.learning_context.complete_active_goal()
+            
+        self.current_discussion = []
+    
+    def _build_discussion_prompt(self) -> str:
+        """Build context-aware discussion prompt."""
+        context = self.learning_context
+        rotation = context.rotation
+        active_goal = context.active_goal
+        
+        return f"""You are an experienced clinical supervisor in {rotation.specialty} 
+        working in a {rotation.setting} setting. Guide the learner through case discussion
+        using Socratic questioning and targeted feedback.
+
+        Current Learning Goal:
+        {active_goal.smart_version if active_goal else 'General clinical discussion'}
+
+        Approach:
+        1. Focus on clinical reasoning and decision-making
+        2. Ask targeted questions to explore understanding
+        3. Share relevant clinical pearls
+        4. Be conversational and engaging
+        5. Relate discussion to current learning goal where relevant
+
+        Remember: The learner has strong foundational knowledge. Focus on advanced clinical concepts
+        rather than basic science."""
+
+    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: Conversation messages
+            temperature: Response temperature
+            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"  # Or your actual domain
+        }
+        
+        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)}")
+                await asyncio.sleep(1 * (attempt + 1))  # Exponential backoff
+    
+    def get_discussion_history(self) -> List[Dict]:
+        """
+        Get current discussion history.
+        
+        Returns:
+            list: Discussion messages
+        """
+        return self.current_discussion
+    
+    def clear_discussion(self) -> None:
+        """Clear current discussion history."""
+        self.current_discussion = []

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,251 @@
+"""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', 'LearningCategory', 'RotationContext', 'SmartGoal', 'CategoryProgress', 'LearningContext']
+
+# %% ../nbs/00_learning_context.ipynb 4
+from typing import Dict, List, Optional
+from datetime import datetime
+from enum import Enum
+from pydantic import BaseModel, Field
+import json
+from pathlib import Path
+import logging
+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 LearningCategory(str, Enum):
+    """Main learning categories"""
+    HISTORY_TAKING = "History Taking"
+    PHYSICAL_EXAM = "Physical Examinations"
+    INVESTIGATIONS = "Investigations"
+    MANAGEMENT = "Management"
+    CLINICAL_REASONING = "Clinical Reasoning"
+    COMMUNICATION = "Communication & Presentation"
+    PROCEDURAL = "Procedural Skills"
+    MEDICAL_KNOWLEDGE = "Medical Knowledge"
+
+class RotationContext(BaseModel):
+    """Clinical rotation context"""
+    specialty: str = Field(..., description="Medical specialty")
+    setting: str = Field(..., description="Clinical setting (Clinic/Wards/ED)")
+
+class SmartGoal(BaseModel):
+    """SMART learning goal"""
+    id: str = Field(..., description="Unique goal identifier")
+    category: LearningCategory
+    original_input: str = Field(..., description="User's original goal input")
+    smart_version: str = Field(..., description="SMART formatted goal")
+    specialty: str
+    setting: str
+    created_at: datetime
+    completed_at: Optional[datetime] = None
+
+    class Config:
+        json_encoders = {
+            datetime: lambda v: v.isoformat()
+        }
+
+class CategoryProgress(BaseModel):
+    """Progress tracking for a category"""
+    category: LearningCategory
+    completed_goals: List[SmartGoal] = Field(default_factory=list)
+    total_goals: int = Field(default=0)
+
+
+# %% ../nbs/00_learning_context.ipynb 9
+class LearningContext:
+    """
+    Manages learning context and goal tracking.
+    
+    This class handles:
+    - Rotation context management
+    - SMART goal tracking
+    - Progress monitoring by category
+    - Context persistence
+    """
+    
+    def __init__(self, context_path: Optional[Path] = None):
+        """
+        Initialize learning context.
+        
+        Args:
+            context_path: Optional path to load/save context
+        """
+        self.context_path = context_path
+        
+        # Initialize rotation context
+        self.rotation = RotationContext(
+            specialty="",
+            setting=""
+        )
+        
+        # Initialize category tracking
+        self.category_progress: Dict[LearningCategory, CategoryProgress] = {
+            cat: CategoryProgress(category=cat)
+            for cat in LearningCategory
+        }
+        
+        # Current active goal
+        self.active_goal: Optional[SmartGoal] = None
+        
+        # Load existing context if available
+        if context_path and context_path.exists():
+            self.load_context()
+    
+    def update_rotation(self, specialty: str, setting: str) -> None:
+        """
+        Update rotation context.
+        
+        Args:
+            specialty: Medical specialty
+            setting: Clinical setting
+        """
+        self.rotation = RotationContext(
+            specialty=specialty,
+            setting=setting
+        )
+        self._save_context()
+    
+    def add_smart_goal(self, goal: SmartGoal) -> None:
+        """
+        Add new SMART goal.
+        
+        Args:
+            goal: SMART goal to add
+        """
+        self.active_goal = goal
+        self.category_progress[goal.category].total_goals += 1
+        self._save_context()
+    
+    def complete_active_goal(self) -> None:
+        """Complete current active goal."""
+        if self.active_goal:
+            self.active_goal.completed_at = datetime.now()
+            cat = self.active_goal.category
+            self.category_progress[cat].completed_goals.append(self.active_goal)
+            self.active_goal = None
+            self._save_context()
+    
+    def get_category_summary(self) -> Dict[str, Dict]:
+        """
+        Get summary of progress by category.
+        
+        Returns:
+            dict: Category summaries including completed/total goals
+                 and recent completions
+        """
+        return {
+            cat.value: {
+                "completed": len(prog.completed_goals),
+                "total": prog.total_goals,
+                "recent": [
+                    {
+                        "smart_version": goal.smart_version,
+                        "completed_at": goal.completed_at.isoformat()
+                    }
+                    for goal in sorted(
+                        prog.completed_goals,
+                        key=lambda x: x.completed_at or datetime.min,
+                        reverse=True
+                    )[:3]  # Last 3 completed
+                ]
+            }
+            for cat, prog in self.category_progress.items()
+        }
+    
+    def get_all_goals(self) -> List[Dict]:
+        """
+        Get all goals for current rotation.
+        
+        Returns:
+            list: All goals matching current rotation
+        """
+        all_goals = []
+        for prog in self.category_progress.values():
+            # Add completed goals
+            all_goals.extend([
+                goal.dict() for goal in prog.completed_goals
+                if (goal.specialty == self.rotation.specialty and
+                    goal.setting == self.rotation.setting)
+            ])
+            
+            # Add active goal if matches
+            if self.active_goal and (
+                self.active_goal.specialty == self.rotation.specialty and
+                self.active_goal.setting == self.rotation.setting
+            ):
+                all_goals.append(self.active_goal.dict())
+        
+        return sorted(
+            all_goals,
+            key=lambda x: x["created_at"],
+            reverse=True
+        )
+    
+    def load_context(self) -> None:
+        """Load context from file."""
+        try:
+            with open(self.context_path, 'r') as f:
+                data = json.load(f)
+            
+            # Load rotation
+            self.rotation = RotationContext(**data["rotation"])
+            
+            # Load progress
+            for cat_data in data["category_progress"]:
+                cat = LearningCategory(cat_data["category"])
+                
+                # Convert goal dicts back to models
+                completed_goals = [
+                    SmartGoal(**g) for g in cat_data["completed_goals"]
+                ]
+                
+                self.category_progress[cat] = CategoryProgress(
+                    category=cat,
+                    completed_goals=completed_goals,
+                    total_goals=cat_data["total_goals"]
+                )
+            
+            # Load active goal if exists
+            if data.get("active_goal"):
+                self.active_goal = SmartGoal(**data["active_goal"])
+                
+            logger.info(f"Context loaded from {self.context_path}")
+            
+        except Exception as e:
+            logger.error(f"Error loading context: {str(e)}")
+    
+    def _save_context(self) -> None:
+        """Save context to file."""
+        if not self.context_path:
+            return
+            
+        try:
+            data = {
+                "rotation": self.rotation.dict(),
+                "category_progress": [
+                    {
+                        "category": prog.category,
+                        "completed_goals": [
+                            g.dict() for g in prog.completed_goals
+                        ],
+                        "total_goals": prog.total_goals
+                    }
+                    for prog in self.category_progress.values()
+                ],
+                "active_goal": self.active_goal.dict() if self.active_goal else None
+            }
+            
+            with open(self.context_path, 'w') as f:
+                json.dump(data, f, indent=2)
+                
+            logger.info(f"Context saved to {self.context_path}")
+            
+        except Exception as e:
+            logger.error(f"Error saving context: {str(e)}")

wardbuddy/learning_interface.py

@@ -0,0 +1,373 @@
+"""Gradio interface"""
+
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/02_learning_interface.ipynb.
+
+# %% auto 0
+__all__ = ['logger', 'create_css', 'LearningInterface']
+
+# %% ../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, LearningCategory, SmartGoal
+import json
+
+logger = setup_logger(__name__)
+
+# %% ../nbs/02_learning_interface.ipynb 6
+def create_css() -> str:
+    """Create custom CSS for interface styling."""
+    return """
+    .gradio-container {
+        background-color: #0f172a !important;
+    }
+    
+    .chat-message {
+        background-color: #1e293b !important;
+        border: 1px solid #334155 !important;
+        border-radius: 0.5rem !important;
+        padding: 1rem !important;
+        margin: 0.5rem 0 !important;
+    }
+    
+    .user-message {
+        background-color: #2563eb !important;
+    }
+    
+    textarea, select {
+        background-color: #1e293b !important;
+        border: 1px solid #334155 !important;
+        color: #f1f5f9 !important;
+    }
+    
+    button {
+        background-color: #2563eb !important;
+        color: white !important;
+    }
+    
+    button:hover {
+        background-color: #1d4ed8 !important;
+    }
+    """
+
+# %% ../nbs/02_learning_interface.ipynb 8
+class LearningInterface:
+    """
+    Gradio interface for clinical learning system.
+    
+    Features:
+    - Context selection
+    - Goal management
+    - Case discussion
+    - Progress tracking
+    """
+    
+    def __init__(
+        self,
+        context_path: Optional[Path] = None,
+        model: str = "anthropic/claude-3.5-sonnet"
+    ):
+        """
+        Initialize interface.
+        
+        Args:
+            context_path: Path for context persistence
+            model: OpenRouter model identifier
+        """
+        self.tutor = ClinicalTutor(context_path, model)
+        
+        # Available options
+        self.specialties = [
+            "Internal Medicine",
+            "Emergency Medicine",
+            "Surgery",
+            "Pediatrics",
+            "Family Medicine"
+        ]
+        
+        self.settings = ["Clinic", "Wards", "ED"]
+        
+        logger.info("Learning interface initialized")
+    
+    def create_interface(self) -> gr.Blocks:
+        """Create Gradio interface."""
+        
+        with gr.Blocks(
+            title="Clinical Learning Assistant",
+            css=create_css()
+        ) as interface:
+            # State management
+            state = gr.State({
+                "discussion_active": False,
+                "suggested_goals": []  # Store generated goals
+            })
+            
+            # Header
+            gr.Markdown("# Clinical Learning Assistant")
+            
+            with gr.Row():
+                # Context selection
+                specialty = gr.Dropdown(
+                    choices=self.specialties,
+                    label="Specialty",
+                    value=self.tutor.learning_context.rotation.specialty or None
+                )
+                
+                setting = gr.Dropdown(
+                    choices=self.settings,
+                    label="Setting",
+                    value=self.tutor.learning_context.rotation.setting or None
+                )
+            
+            # Main content
+            with gr.Row():
+                # Left: Discussion interface
+                with gr.Column(scale=2):
+                    # Active goal display
+                    goal_display = gr.Markdown(
+                        value="No active learning goal"
+                    )
+                    
+                    # Chat interface
+                    chatbot = gr.Chatbot(
+                        height=400,
+                        show_label=False
+                    )
+                    
+                    with gr.Row():
+                        message = gr.Textbox(
+                            label="Present your case or ask questions",
+                            placeholder="Present your case as you would to your supervisor...",
+                            lines=4
+                        )
+                        
+                        audio_input = gr.Audio(
+                            source="microphone",
+                            type="numpy",
+                            label="Or speak your case",
+                            streaming=True
+                        )
+                    
+                    with gr.Row():
+                        clear = gr.Button("Clear Discussion")
+                        end = gr.Button(
+                            "End Discussion & Review",
+                            variant="primary"
+                        )
+                
+                # Right: Progress & Goals
+                with gr.Column(scale=1):
+                    with gr.Tab("Learning Goals"):
+                        # Goal selection/generation
+                        with gr.Row():
+                            generate = gr.Button("Generate New Goals")
+                            
+                            new_goal = gr.Textbox(
+                                label="Or enter your own goal",
+                                placeholder="What do you want to get better at?"
+                            )
+                            
+                            add_goal = gr.Button("Add Goal")
+                        
+                        # Goals list
+                        goals_list = gr.DataFrame(
+                            headers=["Goal", "Category", "Status"],
+                            label="Available Goals"
+                        )
+                    
+                    with gr.Tab("Progress"):
+                        # Category progress
+                        progress_display = gr.DataFrame(
+                            headers=["Category", "Completed", "Total"],
+                            label="Progress by Category"
+                        )
+                        
+                        # Recent completions
+                        recent_display = gr.DataFrame(
+                            headers=["Goal", "Category", "Completed"],
+                            label="Recently Completed"
+                        )
+            
+            # Event handlers
+            async def update_context(spec, set):
+                """Update rotation context."""
+                if spec and set:
+                    self.tutor.learning_context.update_rotation(spec, set)
+                    
+                    # Generate initial goals if needed
+                    if not state["suggested_goals"]:
+                        goals = await self.tutor.generate_smart_goals(spec, set)
+                        state["suggested_goals"] = goals
+                    
+                    return self._update_displays(state)
+                return []
+            
+            async def process_message(msg, history):
+                """Process chat message."""
+                if not msg.strip():
+                    return history, ""
+                    
+                response = await self.tutor.discuss_case(msg)
+                history.append([msg, response])
+                return history, ""
+            
+            def process_audio(audio):
+                """Convert audio to text."""
+                # Would integrate with speech-to-text here
+                return "Audio transcription would appear here"
+            
+            async def generate_goals(state):
+                """Generate new goal suggestions."""
+                rotation = self.tutor.learning_context.rotation
+                if rotation.specialty and rotation.setting:
+                    goals = await self.tutor.generate_smart_goals(
+                        rotation.specialty,
+                        rotation.setting
+                    )
+                    state["suggested_goals"] = goals
+                    return self._update_displays(state)
+                return []
+            
+            async def add_user_goal(text, state):
+                """Add user-specified goal."""
+                if not text.strip():
+                    return state
+                    
+                rotation = self.tutor.learning_context.rotation
+                if rotation.specialty and rotation.setting:
+                    goal = await self.tutor.generate_smart_goal(
+                        text,
+                        rotation.specialty,
+                        rotation.setting
+                    )
+                    if goal:
+                        state["suggested_goals"].append(goal)
+                        return self._update_displays(state)
+                return state
+            
+            def select_goal(evt: gr.SelectData, state):
+                """Set selected goal as active."""
+                if evt.index[0] < len(state["suggested_goals"]):
+                    goal = state["suggested_goals"][evt.index[0]]
+                    self.tutor.learning_context.add_smart_goal(goal)
+                    return self._update_displays(state)
+                return state
+            
+            def end_discussion(state):
+                """End current discussion."""
+                self.tutor.end_discussion()
+                return self._update_displays(state)
+            
+            def clear_discussion():
+                """Clear discussion history."""
+                self.tutor.clear_discussion()
+                return [], ""
+            
+            # Wire up events
+            specialty.change(
+                update_context,
+                inputs=[specialty, setting],
+                outputs=[goals_list, progress_display, recent_display, goal_display]
+            )
+            
+            setting.change(
+                update_context,
+                inputs=[specialty, setting],
+                outputs=[goals_list, progress_display, recent_display, goal_display]
+            )
+            
+            message.submit(
+                process_message,
+                inputs=[message, chatbot],
+                outputs=[chatbot, message]
+            )
+            
+            audio_input.stream(
+                process_audio,
+                inputs=[audio_input],
+                outputs=[message]
+            )
+            
+            clear.click(
+                clear_discussion,
+                outputs=[chatbot, message]
+            )
+            
+            end.click(
+                end_discussion,
+                inputs=[state],
+                outputs=[goals_list, progress_display, recent_display, goal_display]
+            )
+            
+            generate.click(
+                generate_goals,
+                inputs=[state],
+                outputs=[goals_list, progress_display, recent_display, goal_display]
+            )
+            
+            new_goal.submit(
+                add_user_goal,
+                inputs=[new_goal, state],
+                outputs=[goals_list, progress_display, recent_display, goal_display]
+            )
+            
+            goals_list.select(
+                select_goal,
+                inputs=[state],
+                outputs=[goals_list, progress_display, recent_display, goal_display]
+            )
+            
+            return interface
+    
+    def _update_displays(self, state: Dict) -> List:
+        """Update all display components."""
+        context = self.tutor.learning_context
+        
+        # Update goals list
+        goals_data = []
+        for goal in state["suggested_goals"]:
+            status = "Active" if (
+                context.active_goal and 
+                context.active_goal.id == goal.id
+            ) else "Available"
+            
+            goals_data.append([
+                goal.smart_version,
+                goal.category.value,
+                status
+            ])
+        
+        # Update progress display
+        summary = context.get_category_summary()
+        progress_data = [
+            [cat, data["completed"], data["total"]]
+            for cat, data in summary.items()
+        ]
+        
+        # Update recent completions
+        recent_data = []
+        for cat, data in summary.items():
+            for goal in data["recent"]:
+                recent_data.append([
+                    goal["smart_version"],
+                    cat,
+                    goal["completed_at"]
+                ])
+        
+        # Update active goal display
+        goal_text = (
+            f"Current Goal: {context.active_goal.smart_version}"
+            if context.active_goal else
+            "No active learning goal"
+        )
+        
+        return [
+            goals_data,
+            progress_data,
+            recent_data,
+            goal_text
+        ]

wardbuddy/main.py

@@ -0,0 +1,60 @@
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/main.ipynb.
+
+# %% auto 0
+__all__ = ['logger', 'app', 'launch', 'run_app']
+
+# %% ../nbs/main.ipynb 1
+"""Main entry point for the WardBuddy application."""
+import asyncio
+from pathlib import Path
+import typer
+from typing import Optional
+import logging
+
+from .learning_interface import LearningInterface
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = typer.Typer()
+
+@app.command()
+def launch(
+    port: int = typer.Option(7860, help="Port to run on"),
+    context_path: Optional[Path] = typer.Option(
+        None,
+        help="Path to context file",
+        dir_okay=False
+    ),
+    model: str = typer.Option(
+        "anthropic/claude-3-sonnet",
+        help="OpenRouter model identifier"
+    ),
+    share: bool = typer.Option(
+        False,
+        help="Create public URL"
+    )
+) -> None:
+    """Launch the clinical learning interface."""
+    try:
+        interface = LearningInterface(
+            context_path=context_path,
+            model=model
+        )
+        
+        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 typer.Exit(1)
+
+def run_app():
+    """Entry point for command line."""
+    app()

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)}")