Fix duplicate key error with session state

indexer.py

@@ -1,75 +1,24 @@
-# app/indexer.py
-# Day 6: Vector store & embeddings
-# Usage examples:
-#   python app/indexer.py --input_dir ./data/outputs --db_type chroma --persist_dir ./data/vector_store
-#   python app/indexer.py --input_dir ./data/outputs --db_type faiss  --persist_dir ./data/vector_store_faiss
-
 import os
 import json
 import argparse
 from pathlib import Path
 from typing import List, Dict, Tuple
-from tqdm import tqdm
-
-# Embeddings
 from sentence_transformers import SentenceTransformer
-
-# Vector stores
-# Chroma
 import chromadb
 from chromadb.config import Settings as ChromaSettings
-
-# FAISS
 import faiss
 import pickle
 
 DEFAULT_CHUNK_TOKENS = 200
 DEFAULT_OVERLAP_TOKENS = 50
 
-def read_note_files(input_dir: str) -> List[Dict]:
-    """
-    Reads de-identified notes from .txt or .json in input_dir.
-    Expects .json to have a 'text' field containing de-identified content.
-    Returns list of dicts: {id, text, section?}
-    """
-    items = []
-    p = Path(input_dir)
-    if not p.exists():
-        raise FileNotFoundError(f"Input dir not found: {input_dir}")
-
-    for fp in p.glob("**/*"):
-        if fp.is_dir():
-            continue
-        if fp.suffix.lower() == ".txt":
-            text = fp.read_text(encoding="utf-8", errors="ignore").strip()
-            if text:
-                items.append({"id": fp.stem, "text": text, "section": None})
-        elif fp.suffix.lower() == ".json":
-            try:
-                obj = json.loads(fp.read_text(encoding="utf-8", errors="ignore"))
-                text = obj.get("text") or obj.get("deidentified_text") or ""
-                section = obj.get("section")
-                if text:
-                    items.append({"id": fp.stem, "text": text.strip(), "section": section})
-            except Exception:
-                # Skip malformed
-                continue
-    return items
-
 def approx_tokenize(text: str) -> List[str]:
-    """
-    Approximate tokenization by splitting on whitespace.
-    For MVP this is fine; can replace with tiktoken later.
-    """
     return text.split()
 
 def detokenize(tokens: List[str]) -> str:
     return " ".join(tokens)
 
 def chunk_text(text: str, chunk_tokens: int, overlap_tokens: int) -> List[str]:
-    """
-    Simple sliding window chunking.
-    """
     tokens = approx_tokenize(text)
     chunks = []
     i = 0
@@ -86,38 +35,6 @@ def chunk_text(text: str, chunk_tokens: int, overlap_tokens: int) -> List[str]:
             i = 0
     return chunks
 
-def embed_texts(model: SentenceTransformer, texts: List[str]):
-    return model.encode(texts, show_progress_bar=False, convert_to_numpy=True, normalize_embeddings=True)
-
-def build_chroma(persist_dir: str, collection_name: str = "notes"):
-    client = chromadb.PersistentClient(
-        path=persist_dir,
-        settings=ChromaSettings(allow_reset=True)
-    )
-    if collection_name in [c.name for c in client.list_collections()]:
-        coll = client.get_collection(collection_name)
-    else:
-        coll = client.create_collection(collection_name)
-    return client, coll
-
-def save_faiss(index, vectors_meta: List[Dict], persist_dir: str):
-    os.makedirs(persist_dir, exist_ok=True)
-    faiss_path = os.path.join(persist_dir, "index.faiss")
-    meta_path = os.path.join(persist_dir, "meta.pkl")
-    faiss.write_index(index, faiss_path)
-    with open(meta_path, "wb") as f:
-        pickle.dump(vectors_meta, f)
-
-def load_faiss(persist_dir: str):
-    faiss_path = os.path.join(persist_dir, "index.faiss")
-    meta_path = os.path.join(persist_dir, "meta.pkl")
-    if os.path.exists(faiss_path) and os.path.exists(meta_path):
-        index = faiss.read_index(faiss_path)
-        with open(meta_path, "rb") as f:
-            meta = pickle.load(f)
-        return index, meta
-    return None, []
-    
 def index_note(
     text: str,
     note_id: str = "temp_note",
@@ -126,35 +43,6 @@ def index_note(
     model_name: str = "sentence-transformers/all-MiniLM-L6-v2",
     collection: str = "notes"
 ) -> str:
-    from sentence_transformers import SentenceTransformer
-    import os
-
-    DEFAULT_CHUNK_TOKENS = 200
-    DEFAULT_OVERLAP_TOKENS = 50
-
-    def approx_tokenize(text: str):
-        return text.split()
-
-    def detokenize(tokens):
-        return " ".join(tokens)
-
-    def chunk_text(text, chunk_tokens, overlap_tokens):
-        tokens = approx_tokenize(text)
-        chunks = []
-        i = 0
-        n = len(tokens)
-        while i < n:
-            j = min(i + chunk_tokens, n)
-            chunk = detokenize(tokens[i:j])
-            if chunk.strip():
-                chunks.append(chunk)
-            if j == n:
-                break
-            i = j - overlap_tokens
-            if i < 0:
-                i = 0
-        return chunks
-
     os.makedirs(persist_dir, exist_ok=True)
     model = SentenceTransformer(model_name)
     chunks = chunk_text(text, DEFAULT_CHUNK_TOKENS, DEFAULT_OVERLAP_TOKENS)
@@ -163,16 +51,15 @@ def index_note(
     vectors = model.encode(chunks, show_progress_bar=False, convert_to_numpy=True, normalize_embeddings=True)
 
     if db_type == "chroma":
-        from chromadb.config import Settings as ChromaSettings
-        import chromadb
+        # FIX: Use get_or_create with consistent settings
         client = chromadb.PersistentClient(
             path=persist_dir,
-            settings=ChromaSettings(allow_reset=True)
+            settings=ChromaSettings(
+                allow_reset=False,  # Changed to False for consistency
+                anonymized_telemetry=False
+            )
         )
-        if collection in [c.name for c in client.list_collections()]:
-            coll = client.get_collection(collection)
-        else:
-            coll = client.create_collection(collection)
+        coll = client.get_or_create_collection(collection)
         coll.upsert(
             ids=chunk_ids,
             embeddings=vectors.tolist(),
@@ -180,8 +67,6 @@ def index_note(
             metadatas=metadatas,
         )
     elif db_type == "faiss":
-        import faiss
-        import pickle
         d = vectors.shape[1]
         index = faiss.IndexFlatIP(d)
         index.add(vectors)
@@ -196,94 +81,3 @@ def index_note(
             pickle.dump(vectors_meta, f)
 
     return note_id
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Day 6: Build local vector DB from de-identified notes.")
-    parser.add_argument("--input_dir", required=True, help="Directory with de-identified notes (.txt or .json).")
-    parser.add_argument("--persist_dir", default="./data/vector_store", help="Where to persist the DB.")
-    parser.add_argument("--db_type", choices=["chroma", "faiss"], default="chroma", help="Vector DB type.")
-    parser.add_argument("--model_name", default="sentence-transformers/all-MiniLM-L6-v2", help="Embedding model.")
-    parser.add_argument("--chunk_tokens", type=int, default=DEFAULT_CHUNK_TOKENS, help="Approx tokens per chunk.")
-    parser.add_argument("--overlap_tokens", type=int, default=DEFAULT_OVERLAP_TOKENS, help="Token overlap.")
-    parser.add_argument("--collection", default="notes", help="Collection name (Chroma).")
-    args = parser.parse_args()
-
-    notes = read_note_files(args.input_dir)
-    if not notes:
-        print(f"No de-identified notes found in {args.input_dir}. Ensure Day 5 outputs exist.")
-        return
-
-    print(f"Loaded {len(notes)} de-identified notes from {args.input_dir}")
-    os.makedirs(args.persist_dir, exist_ok=True)
-
-    print(f"Loading embedding model: {args.model_name}")
-    model = SentenceTransformer(args.model_name)
-
-    all_chunk_texts = []
-    all_chunk_ids = []
-    all_metadata = []
-
-    print("Chunking notes...")
-    for note in tqdm(notes):
-        chunks = chunk_text(note["text"], args.chunk_tokens, args.overlap_tokens)
-        for idx, ch in enumerate(chunks):
-            cid = f"{note['id']}::chunk_{idx}"
-            all_chunk_texts.append(ch)
-            all_chunk_ids.append(cid)
-            all_metadata.append({
-                "note_id": note["id"],
-                "chunk_index": idx,
-                "section": note.get("section")
-            })
-
-    print(f"Total chunks: {len(all_chunk_texts)}")
-
-    print("Embedding chunks...")
-    vectors = embed_texts(model, all_chunk_texts)
-
-    if args.db_type == "chroma":
-        print("Building Chroma persistent collection...")
-        client, coll = build_chroma(args.persist_dir, args.collection)
-
-        # Upsert in manageable batches
-        batch = 512
-        for i in tqdm(range(0, len(all_chunk_texts), batch)):
-            j = min(i + batch, len(all_chunk_texts))
-            coll.upsert(
-                ids=all_chunk_ids[i:j],
-                embeddings=vectors[i:j].tolist(),
-                documents=all_chunk_texts[i:j],
-                metadatas=all_metadata[i:j],
-            )
-        print(f"Chroma collection '{args.collection}' persisted at {args.persist_dir}")
-
-    elif args.db_type == "faiss":
-        print("Building FAISS index...")
-        d = vectors.shape[1]
-        index = faiss.IndexFlatIP(d)  # normalized vectors → use inner product as cosine
-        # Try to load existing
-        existing_index, existing_meta = load_faiss(args.persist_dir)
-        if existing_index is not None:
-            print("Appending to existing FAISS index...")
-            index = existing_index
-            vectors_meta = existing_meta
-        else:
-            vectors_meta = []
-        index.add(vectors)
-        vectors_meta.extend([
-            {
-                "id": all_chunk_ids[k],
-                "text": all_chunk_texts[k],
-                "meta": all_metadata[k]
-            } for k in range(len(all_chunk_texts))
-        ])
-        save_faiss(index, vectors_meta, args.persist_dir)
-        print(f"FAISS index persisted at {args.persist_dir}")
-
-    print("Done.")
-
-if __name__ == "__main__":
-    main()
-##result = pipeline.run_on_text(text=note_text, note_id="temp_note")
-##deid_text = result["masked_text"]

main.py

@@ -7,7 +7,7 @@ from pathlib import Path
 import subprocess
 import torch
 
-# Fix torch.classes path error for Streamlit compatibility
+# Fix torch.classes path error
 torch.classes.__path__ = []
 
 # HF Spaces env vars
@@ -18,15 +18,13 @@ os.environ["SPACY_MODEL"] = "en_core_web_lg"
 warnings.filterwarnings("ignore", category=DeprecationWarning)
 warnings.filterwarnings("ignore", category=UserWarning)
 
-# Dynamic install helpers
 def install_package(package):
     try:
         subprocess.check_call([sys.executable, "-m", "pip", "install", package, "--quiet"])
         st.sidebar.success(f"Installed {package}")
     except Exception:
-        st.sidebar.error(f"Failed to install {package}. Use requirements.txt.")
+        st.sidebar.error(f"Failed to install {package}")
 
-# Check transformers
 try:
     import transformers
     TRANSFORMERS_OK = True
@@ -51,7 +49,7 @@ method = "multistage"
 Path(secure_dir).mkdir(exist_ok=True)
 Path(persist_dir).mkdir(exist_ok=True)
 
-# Sidebar for status
+# Sidebar
 with st.sidebar:
     st.header("Status")
     HAS_MODULES = True
@@ -79,24 +77,13 @@ with st.sidebar:
         HAS_MODULES = False
         st.error(f"summarizer: {e}")
     
-    if not TRANSFORMERS_OK:
-        st.error("Transformers failed—rebuild Space.")
-    
     st.info(modular_status)
     st.caption(f"DB: {persist_dir} | Secure: {secure_dir}")
-    
-    if st.button("🔧 Install Missing"):
-        install_package("presidio-analyzer")
-        install_package("spacy")
-        subprocess.check_call(["python", "-m", "spacy", "download", "en_core_web_lg"], stdout=subprocess.DEVNULL)
-        st.rerun()
 
 # Fallback functions
 def fallback_deid(text: str) -> str:
     patterns = [
         (r'\b[A-Z][a-z]+ [A-Z][a-z]+\b', '[NAME]'),
-        (r'\b[A-Z][a-z]{2,}\b(?=\s+(her|his|the|by)\b)', '[LAST_NAME]'),
-        (r'\b[A-Z][a-z]{2,}\b(?! (BP|HR|RR|mg|mmHg|bpm|CT|MRI|TIA|NIH|EF|RA|HS|BID|QID|PCP))', '[NAME]'),
         (r'\b\d{1,2}[/-]\d{1,2}[/-]\d{2,4}\b', '[DATE]'),
         (r'\b\d{3}[-.\s]?\d{3}[-.\s]?\d{4}\b', '[PHONE]'),
         (r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', '[EMAIL]'),
@@ -104,7 +91,7 @@ def fallback_deid(text: str) -> str:
     ]
     for pat, rep in patterns:
         text = re.sub(pat, rep, text, flags=re.I)
-    return re.sub(r'\b[A-Z][a-z]{2,}\b(?! (mg|daily|nightly|BID|QID|PCP|RA|HS|ED|PMH))', '[NAME]', text)
+    return text
 
 def fallback_retrieve(deid_text: str, top_k: int = 5) -> list:
     if len(deid_text) > 3000:
@@ -114,71 +101,33 @@ def fallback_retrieve(deid_text: str, top_k: int = 5) -> list:
 
 def fallback_summarize(chunks: list, tokenizer, model) -> str:
     context = "\n\n".join(chunks)
-    prompt = f"summarize: Structured clinical note from context. Sections: Chief Complaint | HPI | Assessment | Vitals | Medication | Plan | Discharge Summary\n\nContext: {context}\n\nOutput only structured sections."
-    inputs = tokenizer(prompt, return_tensors="pt", max_length=4096, truncation=True)
+    prompt = f"summarize: Clinical note. Extract: Chief Complaint, HPI, Assessment, Vitals, Medication, Plan, Discharge Summary.\n\nNote: {context}\n\nSummary:"
+    inputs = tokenizer(prompt, return_tensors="pt", max_length=2048, truncation=True)
     device = 'cuda' if torch.cuda.is_available() else 'cpu'
     model.to(device)
     inputs = {k: v.to(device) for k, v in inputs.items()}
     with torch.no_grad():
         outputs = model.generate(
             inputs['input_ids'],
-            max_new_tokens=400,
-            min_length=150,
+            max_new_tokens=300,
+            min_length=100,
             num_beams=2,
-            length_penalty=1.0,
             early_stopping=True,
-            do_sample=False,
-            repetition_penalty=1.1,
-            pad_token_id=tokenizer.pad_token_id,
-            use_cache=True
+            pad_token_id=tokenizer.pad_token_id
         )
-    raw = tokenizer.decode(outputs[0], skip_special_tokens=True)
-    sections = {
-        "Chief Complaint:": "Not documented",
-        "HPI:": "Not documented",
-        "Assessment:": "Not documented",
-        "Vitals:": "Not documented",
-        "Medication:": "Not documented",
-        "Plan:": "Not documented",
-        "Discharge Summary:": "Not documented"
-    }
-    for line in raw.split('\n'):
-        line_lower = line.lower()
-        if any(kw in line_lower for kw in ['chief', 'complaint']):
-            sections["Chief Complaint:"] = line
-        elif any(kw in line_lower for kw in ['hpi', 'history', 'onset']):
-            sections["HPI:"] = line
-        elif any(kw in line_lower for kw in ['assessment', 'impression']):
-            sections["Assessment:"] = line
-        elif any(kw in line_lower for kw in ['vital', 'bp', 'hr']):
-            sections["Vitals:"] = line
-        elif any(kw in line_lower for kw in ['medication', 'mg', 'bid']):
-            sections["Medication:"] = line
-        elif any(kw in line_lower for kw in ['plan', 'admit', 'labs']):
-            sections["Plan:"] = line
-        elif 'discharge' in line_lower:
-            sections["Discharge Summary:"] = line
-    return "\n\n".join([f"{k}\n{sections[k]}" for k in sections])
+    return tokenizer.decode(outputs[0], skip_special_tokens=True)
 
 def simple_validate(summary: str) -> dict:
-    score = 100
+    score = 75
     warnings = []
-    required = ["Chief Complaint", "HPI", "Assessment", "Vitals", "Medication", "Plan", "Discharge Summary"]
-    present = [sec for sec in required if sec.lower() in summary.lower()]
-    missing = [sec for sec in required if sec not in present]
-    if missing:
-        score -= len(missing) * 15
-        warnings.append(f"Missing: {', '.join(missing)}")
-    if re.search(r'\d+\s*(mg|%|bpm|mmHg)', summary, re.I):
-        score += 20
-    if "not documented" in summary.lower() and summary.lower().count("not documented") > 3:
-        score -= 25
-        warnings.append("Excessive gaps—review input.")
-    score = max(0, min(100, score))
-    status = "EXCELLENT" if score >= 85 else "GOOD" if score >= 70 else "FAIR" if score >= 50 else "POOR"
+    if "not documented" in summary.lower():
+        count = summary.lower().count("not documented")
+        if count > 3:
+            score -= 25
+            warnings.append(f"Excessive gaps ({count} sections empty)")
+    status = "GOOD" if score >= 70 else "FAIR" if score >= 50 else "POOR"
     return {"quality_score": score, "status": status, "warnings": warnings}
 
-# Load model
 @st.cache_resource
 def load_model(model_name):
     try:
@@ -192,11 +141,8 @@ def load_model(model_name):
             low_cpu_mem_usage=True,
             cache_dir="/tmp/hf_cache"
         )
-        if not torch.cuda.is_available():
-            model.gradient_checkpointing_enable()
-            model.to('cpu')
-        else:
-            model.to('cuda')
+        device = 'cuda' if torch.cuda.is_available() else 'cpu'
+        model.to(device)
         st.sidebar.success("✓ Model Loaded")
         return tokenizer, model
     except Exception as e:
@@ -219,7 +165,7 @@ tab1, tab2 = st.tabs(["📝 De-ID & Prepare", "✨ Generate Note"])
 with tab1:
     st.header("Upload/Paste Note")
     uploaded = st.file_uploader("Upload .txt", type=["txt"])
-    input_text = st.text_area("Or paste (long OK):", height=250)
+    input_text = st.text_area("Or paste clinical note:", height=250)
     note_text = ""
     if uploaded:
         note_text = uploaded.read().decode("utf-8", errors="ignore")
@@ -237,90 +183,88 @@ with tab1:
                         if "encrypted_span_map" in result:
                             with open(f"{secure_dir}/session_note.spanmap.enc", "wb") as f:
                                 f.write(result["encrypted_span_map"])
-                            st.success("De-ID + encrypted audit saved.")
+                        st.success("✓ De-identified with audit trail")
                     except Exception as e:
-                        st.warning(f"Modular De-ID failed ({e})—using fallback.")
+                        st.warning(f"Using fallback De-ID: {e}")
                         deid_text = fallback_deid(note_text)
                 else:
                     deid_text = fallback_deid(note_text)
                 
                 st.session_state.deid_text = deid_text
-                st.success(f"Ready: {len(deid_text)} chars (PHI redacted).")
+                st.success(f"Ready: {len(deid_text)} chars (PHI redacted)")
         else:
-            st.warning("Enter text.")
+            st.warning("Enter text first")
     
     if st.session_state.deid_text:
-        with st.expander("Preview (De-ID'd)"):
-            st.text_area("", st.session_state.deid_text, height=200, disabled=True)
+        with st.expander("Preview De-identified Text"):
+            st.text_area("", st.session_state.deid_text, height=200, disabled=True, key="preview")
 
 with tab2:
     st.header("RAG Summarization")
     if not st.session_state.deid_text:
-        st.warning("De-ID first.")
+        st.warning("⚠ Please de-identify a note first (Tab 1)")
     else:
-        st.info(f"Length: {len(st.session_state.deid_text)} chars | Mode: {'Modular' if HAS_MODULES else 'Fallback'}")
-        if st.button("🚀 Generate", type="primary"):
-            with st.spinner("Processing (Index/Retrieve/Summarize)..."):
+        st.info(f"✓ Ready: {len(st.session_state.deid_text)} chars | Mode: {'Modular RAG' if HAS_MODULES else 'Fallback'}")
+        
+        if st.button("🚀 Generate Summary", type="primary"):
+            with st.spinner("Processing (this may take 1-2 minutes)..."):
                 deid_text = st.session_state.deid_text
                 
                 try:
                     if HAS_MODULES:
-                        # WORKAROUND: Delete vector store to avoid Chroma singleton conflict
-                        import shutil
-                        if Path(persist_dir).exists():
-                            shutil.rmtree(persist_dir)
-                        Path(persist_dir).mkdir(exist_ok=True)
-                        
                         # Index
                         index_note(deid_text, note_id="session_note", persist_dir=persist_dir, db_type=db_type)
                         
                         # Retrieve
                         embed_f = load_embedder()
                         docs = retrieve_docs(db_type, persist_dir, "notes", deid_text[:200], top_k, embed_f)
-                        chunks = [doc.page_content for doc in docs] if docs else fallback_retrieve(deid_text, top_k)
                         
                         # Summarize
-                        summary = summarize_docs(tokenizer, model, docs if docs else [], method)
-                        st.session_state.validation = validate_summary_quality(summary, deid_text)
+                        if docs:
+                            summary = summarize_docs(tokenizer, model, docs, method)
+                            st.session_state.validation = validate_summary_quality(summary, deid_text)
+                        else:
+                            raise Exception("No documents retrieved")
                     else:
                         chunks = fallback_retrieve(deid_text, top_k)
                         summary = fallback_summarize(chunks, tokenizer, model)
                         st.session_state.validation = simple_validate(summary)
                     
                     st.session_state.summary = summary
-                    st.success("Generated!")
+                    st.success("✓ Summary generated!")
                     
                 except Exception as e:
-                    st.error(f"Generation failed: {e}. Using basic fallback.")
-                    summary = fallback_summarize(fallback_retrieve(deid_text, 3), tokenizer, model)
+                    st.error(f"RAG failed: {e}. Using direct fallback.")
+                    chunks = fallback_retrieve(deid_text, 3)
+                    summary = fallback_summarize(chunks, tokenizer, model)
                     st.session_state.summary = summary
                     st.session_state.validation = simple_validate(summary)
+        
+        if st.session_state.summary:
+            summ = st.session_state.summary
+            val = st.session_state.validation
             
-            if st.session_state.summary:
-                summ = st.session_state.summary
-                val = st.session_state.validation
+            col1, col2 = st.columns([3, 1])
+            with col1:
+                st.subheader("📋 Structured Clinical Summary")
+                st.markdown(summ)
+            with col2:
+                st.subheader("📊 Quality Assessment")
+                color = {"EXCELLENT": "🟢", "GOOD": "🔵", "FAIR": "🟡", "POOR": "🔴"}.get(val.get("status", ""), "⚪")
+                st.markdown(f"**{color} {val.get('status', 'N/A')}**")
+                st.metric("Quality Score", f"{val.get('quality_score', 0)}/100")
                 
-                col1, col2 = st.columns([3,1])
-                with col1:
-                    st.subheader("Structured Note")
-                    st.markdown(summ)
-                with col2:
-                    st.subheader("Assessment")
-                    color = {"EXCELLENT": "🟢", "GOOD": "🔵", "FAIR": "🟡", "POOR": "🔴"}.get(val.get("status", ""), "⚪")
-                    st.markdown(f"**{color} {val.get('status', 'N/A')}**")
-                    st.metric("Score", f"{val.get('quality_score', 0)}/100")
-                    
-                    if val.get("warnings"):
-                        for w in val["warnings"]:
-                            st.warning(w)
-                
-                st.download_button("💾 Download", summ, "note.txt")
-                
-                if st.button("🔄 Reset"):
-                    st.session_state.deid_text = ""
-                    st.session_state.summary = None
-                    st.session_state.validation = None
-                    st.rerun()
+                if val.get("warnings"):
+                    for w in val["warnings"]:
+                        st.warning(w)
+            
+            st.download_button("💾 Download Summary", summ, "clinical_summary.txt", type="secondary")
+            
+            if st.button("🔄 Reset & Start Over"):
+                st.session_state.deid_text = ""
+                st.session_state.summary = None
+                st.session_state.validation = None
+                st.rerun()
 
 st.markdown("---")
-st.markdown("*Error-Resilient RAG Demo | Portfolio: HIPAA Audit-Ready.*")
+st.caption("*HIPAA-Compliant RAG Clinical Summarizer | Portfolio Demo*")