Creating new Space

.gitignore

@@ -0,0 +1 @@
+venv/

Gen_PartialSMILES2.py

@@ -0,0 +1,307 @@
+from rdkit import RDLogger
+from augmentation import *
+
+# Disable all RDKit warnings and errors
+RDLogger.DisableLog('rdApp.*')
+from rdkit import Chem
+import random
+import torch
+# import F
+import torch.nn.functional as F
+import math
+import torch
+import pandas as pd
+from rdkit.Chem import AllChem
+import argparse
+from SmilesPE.pretokenizer  import atomwise_tokenizer
+# SMILES tokenizer
+import pathlib
+from rdkit.Chem.Scaffolds.MurckoScaffold import GetScaffoldForMol
+from rdkit import Chem
+from rdkit.Chem import AllChem, DataStructs
+import numpy as np
+from itertools import combinations
+import re
+from collections import defaultdict
+import partialsmiles as ps
+# from Join import join_scaf_deco
+from collections import OrderedDict
+from SmilesPE.pretokenizer import atomwise_tokenizer
+
+class AtomwiseTokenizer():
+    def __init__(self, str_bos="<can>", str_eos="<eos>"):
+        self.bos_token = str_bos
+        self.eos_token = str_eos
+    def tokenize(self, smiles):
+        return atomwise_tokenizer(smiles)
+    def convert_tokens_to_string(self, tokens):
+        return "".join(tokens)
+    def assign_vocab(self, vocab):
+        self.vocab = vocab
+        self.vocab_inv = {v: k for k, v in vocab.items()}
+        self.eos_token_id = vocab[self.eos_token]
+        self.bos_token_id = vocab[self.bos_token]
+    def decode(self, ids,skip_special_tokens=True):
+        if isinstance(ids, torch.Tensor):
+            return "".join([self.vocab_inv[id] for id in ids.cpu().numpy()])
+        return "".join([self.vocab_inv[id] for id in ids])
+
+
+def gen_psv_table(partial_smiles, vocab,eos_str,sep_str,partial_valid):
+    psv_table = []
+    for token in vocab.keys():
+        if token == eos_str or token == sep_str:
+            psv_table.append(partial_valid)
+        else:
+            try:
+                mol = ps.ParseSmiles(partial_smiles + token, partial=True)
+                assert mol is not None
+                psv_table.append(True)
+            except:
+                psv_table.append(False)
+    return psv_table
+
+def calculate_bm_scaffold(smiles):
+    try:
+        mol = Chem.MolFromSmiles(smiles)
+        # return Chem.MolToSmiles(AllChem.GetMolecularScaffold(mol))
+        return Chem.MolToSmiles(GetScaffoldForMol(mol))
+    except:
+        return None
+
+def get_morgan_fp(smiles, radius=2, n_bits=2048):
+    mol = Chem.MolFromSmiles(smiles)
+    if mol is None:
+        return None
+    return AllChem.GetMorganFingerprintAsBitVect(mol, radius, nBits=n_bits)
+
+def compute_internal_diversity(smiles_list):
+    fps = [get_morgan_fp(sm) for sm in smiles_list]
+    fps = [fp for fp in fps if fp is not None]
+    if len(fps) < 2:
+        return 0.0  # Not enough valid molecules
+    similarities = []
+    for fp1, fp2 in combinations(fps, 2):
+        sim = DataStructs.TanimotoSimilarity(fp1, fp2)
+        similarities.append(sim)
+    mean_sim = np.mean(similarities)
+    int_div = 1 - mean_sim
+    return int_div
+
+def atomwise_tokenizer_fixed(x):
+    list_subSMILES = [atomwise_tokenizer(subSMILES) for subSMILES in x.split("|")]
+    y_in = list_subSMILES[0]
+    for i in range(len(list_subSMILES)-1):
+        y_in += ["|"] + list_subSMILES[i+1]
+    return y_in
+
+
+
+def customized_forward(model, x_in, y_in, y_out=None,boundary=None, return_last_hidden_state=False):
+    x_in = model.drop(model.tok_emb(x_in) + model.pos_emb[:, :x_in.size()[1], :])
+    y_in = model.drop(model.tok_emb(y_in) + model.pos_emb[:, :y_in.size()[1], :])
+    #
+    for encoder_block in model.encoder_blocks:
+        x_in = encoder_block(x_in)
+    x_in = model.ln_f(x_in)
+    for decoder_block in model.decoder_blocks:
+        y_in = decoder_block(x_in,y_in)
+    y_in = model.ln_f(y_in)
+    logits = model.head(y_in)
+    loss = None
+    if y_out is not None:
+        loss = F.cross_entropy(logits.view(-1, logits.size(-1)), y_out.view(-1))
+    if return_last_hidden_state:
+        return logits, y_in
+    else:
+        return logits, loss
+
+def path_aligned_generation(
+    model,
+    tokenizer,
+    max_length=256,
+    batch_size=128,
+    device="cuda:0",
+    budget_generation=10,
+    sample_suffix="Cc1ccccc1",
+    tensor_scaffold=None,
+    boundary=None,
+    n_generation=100,
+    supress_eos=False,
+    max_molwt=1000,
+    max_clogp=10,
+    max_rotatable_bond=10,
+    use_merge=True,
+    top_k=0,
+    top_p=1.,
+    min_prefix_length=4,
+    typical_sampling=False,
+    contrastive_search=False,
+    pre_check_merge=False,
+    ):
+    model.to(device)
+    model.eval()
+    # generated_smiles = set()
+    generated_smiles = OrderedDict()
+    dict_inchikey_count = defaultdict(int)
+    dict_inchikey_merged_path = defaultdict(OrderedDict)
+    dict_path_inchikey = {}
+    iteration_counter = 0
+    total_merge_count = 0
+    n_calls = 0
+    n_repeated = 0
+    n_supressed_eos = 0
+    n_invalid = 0
+    count_merged = 0
+    with torch.no_grad():
+        while len(generated_smiles) < n_generation:
+            tensor_generation = torch.zeros(batch_size,2).long().to(device)
+            tensor_generation[:,0] = tokenizer.bos_token_id
+            tensor_generation[:,1] = tokenizer.vocab["[*]"]
+            for step_idx in range(1,max_length-1):
+                inputs = tensor_generation[:,:step_idx+1].to(device)
+                # outputs = model(inputs)
+                if tensor_scaffold is not None:
+                    logits, base_h = customized_forward(model, tensor_scaffold[:inputs.shape[0]], inputs, None, boundary, return_last_hidden_state=True)
+                    # logits, last_hidden_state = model.forward(tensor_scaffold[:inputs.shape[0]], inputs, None, boundary, return_last_hidden_state=True)
+                    logits = logits[:,-1,:]
+                    n_calls += inputs.shape[0]
+                else:
+                    outputs = model.forward(inputs)
+                    logits = outputs.logits[:,-1,:]
+                    n_calls += inputs.shape[0]
+                # sample from the logits
+                list_supress_eos = []
+                list_merged_idx = []
+                list_finished_idx = []
+                list_invalid_idx = []
+                filter_value = -float('Inf')
+                if top_k > 0:
+                    indices_to_remove = logits < torch.topk(logits,top_k,dim=-1)[0][:,[-1]]
+                    logits[indices_to_remove] = filter_value
+                if top_p < 1.:
+                    sorted_logits, sorted_indices = torch.sort(logits, descending=True)
+                    cumulative_probs = torch.cumsum(F.softmax(sorted_logits,dim=-1),dim=-1)
+                    sorted_indices_to_remove = cumulative_probs > top_p
+                    sorted_indices_to_remove[...,1:] = sorted_indices_to_remove[...,:-1].clone()
+                    sorted_indices_to_remove[...,0] = 0
+                    sorted_logits[sorted_indices_to_remove] = filter_value
+                    logits = torch.gather(sorted_logits, -1, sorted_indices.argsort(-1))
+                next_token_id = torch.multinomial(F.softmax(logits,dim=-1),num_samples=1)
+                # import pdb; pdb.set_trace()
+                current_prefix = [tokenizer.decode(tensor_generation[sample_idx,1:step_idx+1]) for sample_idx in range(tensor_generation.shape[0])]
+                # import pdb; pdb.set_trace()
+                if step_idx > 0:
+                    for sample_idx, current_decoded in enumerate(current_prefix):
+                        mol = None
+                        try:
+                            mol = Chem.MolFromSmiles(current_decoded)
+                        except:
+                            mol = None
+                        if mol is not None and current_decoded not in generated_smiles:
+                            generated_smiles[current_decoded] = 1
+                            list_finished_idx.append(sample_idx)
+                keep_mask = torch.ones(tensor_generation.shape[0], dtype=torch.bool)
+                keep_mask[list_finished_idx] = False
+                tensor_generation = torch.cat([tensor_generation[keep_mask],next_token_id[keep_mask]],dim=1)
+                # terminate if all samples reached the end
+                if tensor_generation.shape[0] == 0:
+                    break
+                str_print =  f"Iteration {iteration_counter:05d}"
+                str_print += f" step {step_idx:05d}"
+                str_print += f" merged_t {total_merge_count:05d}"
+                str_print += f" merged_c {count_merged:05d}"
+                str_print += f" dict_prefix {len(dict_path_inchikey):05d}"
+                str_print += f" dict_inch {len(dict_inchikey_merged_path):05d}"
+                # str_print += f" eos {tensor_generation.shape[0]-n_eos_tokens:05d}"
+                str_print += f" gen_c {tensor_generation.shape[0]:05d}"
+                str_print += f" gen_t {len(generated_smiles):08d}"
+                str_print += f" n_calls {n_calls:08d}"
+                str_print += f" n_repeated {n_repeated:05d}"
+                # str_print += f" n_supressed_eos {n_supressed_eos:05d}"
+                str_print += f" n_invalid {n_invalid:05d}"
+                # str_print += f" n_supressed_eos {n_supressed_eos:05d}"
+                print(str_print)
+                # logger.info(str_print)
+                # print(f"Iteration {iteration_counter:05d} step {step_idx:05d} merged total {total_merge_count:05d} current {count_merged:05d} dict_prefix {len(dict_path_inchikey):05d}  dict_inch {len(dict_inchikey_merged_path):05d} eos {tensor_generation.shape[0]-n_eos_tokens:05d} current {tensor_generation.shape[0]:05d} generated {len(generated_smiles):08d} n_calls {n_calls:05d} n_repeated {n_repeated:05d}")
+            # get generated smiles and remove the merged prefixes
+            iteration_counter += 1
+            total_merge_count += count_merged
+    return generated_smiles, dict_inchikey_merged_path, dict_inchikey_count, dict_path_inchikey, total_merge_count, n_calls, n_repeated
+
+
+
+ATTACHMENT_POINT_TOKEN = "*"
+ATTACHMENT_POINT_NUM_REGEXP = r"\[{}:(\d+)\]".format(re.escape(ATTACHMENT_POINT_TOKEN))
+ATTACHMENT_POINT_REGEXP = r"(?:{0}|\[{0}[^\]]*\])".format(re.escape(ATTACHMENT_POINT_TOKEN))
+ATTACHMENT_POINT_NO_BRACKETS_REGEXP = r"(?<!\[){}".format(re.escape(ATTACHMENT_POINT_TOKEN))
+
+parser = argparse.ArgumentParser()
+parser.add_argument("--save_dir", type=str, default="entropy/gpt2_zinc_87m")
+parser.add_argument("--model_name", type=str, default="gpt2_zinc_87m")
+parser.add_argument("--generate_mode", type=str, default="scaffold_decorator")
+parser.add_argument("--filepath_scaffold", type=str, default="/shared/healthinfolab/xiw14035/TF_debug/SCMG/SCMG/20250505/scaf_5.smi")
+parser.add_argument("--model_path", type=str, default="")
+parser.add_argument("--n_to_gen", type=int, default=100)
+parser.add_argument("--max_length", type=int, default=30)
+parser.add_argument("--max_molwt", type=float, default=500)
+parser.add_argument("--max_clogp", type=float, default=4.5)
+parser.add_argument("--max_rotatable_bond", type=int, default=8)
+parser.add_argument("--min_prefix_length", type=int, default=4)
+parser.add_argument("--top_p", type=float, default=1.0)
+parser.add_argument("--top_k", type=int, default=10)
+# list of decode methods
+parser.add_argument("--decode_methods", type=str, default="Structure-Aware_Decoding")
+args = parser.parse_args()
+# example: python PTS_Generate.py --save_dir "entropy/gpt2_zinc_87m" --model_name "gpt2_zinc_87m" --generate_mode "scaffold_decorator" --filepath_scaffold "scaf_5.smi" --model_path "" --decode_methods "Structure-Aware_Decoding"
+pathlib.Path(args.save_dir).mkdir(parents=True, exist_ok=True)
+# device = torch.device("cuda:0")
+device = torch.device("cpu")
+
+model = torch.load("src/clm/model_new_torch.pt",weights_only=False,       map_location="cpu")
+vocab = model.vocab_encoder
+tokenizer = AtomwiseTokenizer(str_bos="<scmg_char_cano>", str_eos="<eos>")
+tokenizer.assign_vocab(vocab)
+tokenizer.sep_token = "|"
+tokenizer.sep_token_id = vocab[tokenizer.sep_token]
+
+
+def path_aligned_generation_supress_eos(model,tokenizer,max_length=256,n_generation=100,batch_size=128,device="cuda:0",tensor_scaffold=None,boundary=None,budget_generation=10,max_molwt=1000,max_clogp=10,max_rotatable_bond=10):
+    return path_aligned_generation(model,tokenizer,max_length=max_length,n_generation=n_generation,batch_size=batch_size,device=device,tensor_scaffold=tensor_scaffold,boundary=boundary,budget_generation=budget_generation,supress_eos=True,max_molwt=max_molwt,max_clogp=max_clogp,max_rotatable_bond=max_rotatable_bond)
+
+
+model.to(device)
+model.eval()
+budget_generation = 10
+batch_size = 512
+scaf_smi = "[*]c1ccccc1"
+if len(scaf_smi) > 0:
+    if "[*]" not in scaf_smi:
+        raise ValueError("Scaffold does not contain attachment point")
+    sequence_scaffold = [tokenizer.bos_token_id] + [vocab[a] for a in tokenizer.tokenize(scaf_smi)] + [tokenizer.eos_token_id]
+    tensor_scaffold = torch.tensor(sequence_scaffold).unsqueeze(0).to(device).repeat(batch_size,1)
+    boundary = torch.zeros(batch_size,1).long().to(device) + tensor_scaffold.shape[1] + 1
+else:
+    tensor_scaffold = None
+    boundary = None
+
+df_result = pd.DataFrame(columns=["n_to_gen", "gen_func_name", "internal_diversity", "n_bm_scaffold"])
+
+# set seed for everything
+seed_value = 42
+random.seed(seed_value)
+np.random.seed(seed_value)
+torch.manual_seed(seed_value)
+torch.cuda.manual_seed(seed_value)
+torch.cuda.manual_seed_all(seed_value)
+torch.backends.cudnn.deterministic = True
+torch.backends.cudnn.benchmark = False
+
+n_to_gen = args.n_to_gen
+generated_smiles_raw, dict_inchikey_merged_path, dict_inchikey_count, dict_path_inchikey, total_merge_count, n_calls, n_repeated = path_aligned_generation(model,tokenizer=tokenizer,max_length=args.max_length,n_generation=n_to_gen,batch_size=batch_size,device=device,tensor_scaffold=tensor_scaffold,boundary=boundary,budget_generation=budget_generation,max_molwt=args.max_molwt,max_clogp=args.max_clogp,max_rotatable_bond=args.max_rotatable_bond,use_merge=True,min_prefix_length=args.min_prefix_length)
+generated_smiles = dict([(smiles.split("<can>")[-1], freq) for smiles, freq in generated_smiles_raw.items()])
+
+pd.DataFrame({
+    "smiles": list(generated_smiles.keys()),
+    "count": list(generated_smiles.values())
+}).to_csv("generated_molecules.csv", index=False)

QUICK_START.md

@@ -0,0 +1,63 @@
+# 🚀 Quick Start Guide
+
+## Running the HITL Drug Discovery Application
+
+### Option 1: Easy Launcher (Recommended)
+```bash
+python run.py
+```
+
+### Option 2: Direct Launch
+```bash
+# Activate virtual environment
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+
+# Run the application
+python app.py
+```
+
+### Option 3: Legacy Version (Backup)
+```bash
+# Activate virtual environment
+source venv/bin/activate
+
+# Run legacy version
+python legacy/app_legacy.py
+```
+
+## 🌐 Access the Application
+
+Once running, open your browser and go to:
+**http://localhost:7860**
+
+## 🛑 Stop the Application
+
+Press `Ctrl+C` in the terminal to stop the application.
+
+## 📁 Project Structure
+
+- **`app.py`** - Main entry point (works for both local and Hugging Face Spaces)
+- **`run.py`** - Easy launcher script
+- **`src/`** - Modular source code
+- **`legacy/`** - Legacy monolithic version (backup)
+- **`venv/`** - Virtual environment
+
+## 🔧 Troubleshooting
+
+### Virtual Environment Issues
+```bash
+# Create virtual environment
+python -m venv venv
+
+# Activate it
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+
+# Install dependencies
+pip install -r requirements.txt
+```
+
+### Import Errors
+Make sure you're in the project directory and virtual environment is activated.
+
+### Port Already in Use
+If port 7860 is busy, the app will automatically use the next available port.

README.md

@@ -1,12 +1,115 @@
 ---
-title: Joey
-emoji: 🌍
-colorFrom: gray
+title: HITL Drug Discovery
+emoji: 🧬
+colorFrom: blue
 colorTo: purple
 sdk: gradio
 sdk_version: 5.49.1
 app_file: app.py
 pinned: false
+hf_oauth: true
+hf_oauth_scopes:
+- inference-api
+license: apache-2.0
+short_description: HITL Drug Discovery with AI Chat and Molecular Analysis
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🧬 HITL Drug Discovery Platform
+
+An advanced drug discovery platform combining AI-powered chat with molecular visualization and property analysis using [Gradio](https://gradio.app), [RDKit](https://www.rdkit.org/), and the [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index).
+
+## 🚀 Quick Start
+
+### Running the Application
+```bash
+# Easy launcher (recommended)
+python run.py
+
+# Direct launch
+python app.py
+
+# Legacy version (backup)
+python legacy/app_legacy.py
+```
+
+### Access
+Once running, open your browser to: **http://localhost:7860**
+
+## ✨ Key Features
+
+- **🤖 AI Chat Assistant**: Expert medicinal chemistry guidance and structure generation
+- **🔬 Molecular Analysis**: Calculate drug-likeness properties and Lipinski's Rule of Five
+- **🎨 Interactive Visualization**: High-quality molecular structure rendering with multiple styles
+- **📚 Drug Discovery Library**: Curated collection of pharmaceutical compounds
+- **⚡ Real-time Property Calculation**: Molecular weight, LogP, TPSA, hydrogen bonding, and more
+- **🔄 Chemical Variations**: Generate multiple visualization styles of molecular structures
+- **💾 Bookmarking**: Save and manage favorite molecular structures
+
+## 🏗️ Project Structure
+
+```
+HITL_Drug_Discovery/
+├── app.py                  # Main entry point
+├── run.py                  # Easy launcher script
+├── requirements.txt        # Dependencies
+├── src/                   # Modular source code
+│   ├── app.py             # Main application orchestrator
+│   ├── molecules/         # Molecular analysis and variations
+│   │   ├── analysis.py    # Property calculations & validation
+│   │   └── variations.py  # Structure variation generation
+│   ├── ai/                # AI services
+│   │   └── services.py    # AI chat and structure generation
+│   ├── ui/                # UI components and handlers
+│   │   ├── components.py  # UI component definitions
+│   │   └── handlers.py    # Event handlers and business logic
+│   └── config/            # Configuration and settings
+│       └── settings.py    # App configuration and styling
+└── legacy/                # Legacy monolithic version (backup)
+    └── app_legacy.py
+```
+
+## 🔧 Technical Architecture
+
+### Modular Design Benefits
+- **Maintainability**: Each module has a single responsibility
+- **Testability**: Individual modules can be tested in isolation
+- **Scalability**: Easy to add new features without affecting existing code
+- **Readability**: Clear separation of concerns
+- **Reusability**: Components can be reused across different parts of the app
+
+### Key Modules
+- **`molecules/analysis.py`**: SMILES validation, property calculations, drug-likeness assessment
+- **`molecules/variations.py`**: Generation of multiple molecular structure visualizations
+- **`ai/services.py`**: AI-powered chat responses using Hugging Face models
+- **`ui/components.py`**: Reusable UI component definitions for Gradio interface
+- **`ui/handlers.py`**: Event handlers, business logic, and state management
+
+## 🛠️ Troubleshooting
+
+### Virtual Environment Issues
+```bash
+# Create virtual environment
+python -m venv venv
+
+# Activate it
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+
+# Install dependencies
+pip install -r requirements.txt
+```
+
+### Common Issues
+- **Import Errors**: Make sure you're in the project directory and virtual environment is activated
+- **Port Already in Use**: The app will automatically use the next available port
+- **Missing Dependencies**: Run `pip install -r requirements.txt`
+
+## 🚀 Future Enhancements
+
+With the modular structure, it's easy to:
+- Add new molecular analysis algorithms
+- Implement additional AI models
+- Create new UI components
+- Add database integration
+- Implement user authentication
+- Add API endpoints
+- Create unit tests for each module

README_MODULAR.md

@@ -0,0 +1,96 @@
+# HITL Drug Discovery - Modular Architecture
+
+## 🏗️ Project Structure
+
+```
+HITL_Drug_Discovery/
+├── main.py                 # Main entry point
+├── app.py                  # Legacy monolithic app (backup)
+├── requirements.txt        # Dependencies
+├── README.md              # Original README
+├── README_MODULAR.md      # This file
+└── src/                   # Modular source code
+    ├── __init__.py
+    ├── app.py             # Main application orchestrator
+    ├── molecules/         # Molecular analysis and variations
+    │   ├── __init__.py
+    │   ├── analysis.py    # Molecular property calculations
+    │   └── variations.py  # Structure variation generation
+    ├── ai/                # AI services
+    │   ├── __init__.py
+    │   └── services.py    # AI chat and structure generation
+    ├── ui/                # UI components and handlers
+    │   ├── __init__.py
+    │   ├── components.py  # UI component definitions
+    │   └── handlers.py    # Event handlers and business logic
+    └── config/            # Configuration and settings
+        ├── __init__.py
+        └── settings.py    # App configuration and constants
+```
+
+## 🚀 Running the Application
+
+### Option 1: Modular Version (Recommended)
+```bash
+python main.py
+```
+
+### Option 2: Legacy Monolithic Version
+```bash
+python app.py
+```
+
+## 📁 Module Descriptions
+
+### `src/molecules/`
+- **`analysis.py`**: Molecular property calculations, SMILES validation, drug-likeness assessment
+- **`variations.py`**: Generation of multiple molecular structure visualizations
+
+### `src/ai/`
+- **`services.py`**: AI-powered chat responses and structure generation using OpenAI GPT-OSS-20B
+
+### `src/ui/`
+- **`components.py`**: Reusable UI component definitions for Gradio interface
+- **`handlers.py`**: Event handlers, business logic, and state management
+
+### `src/config/`
+- **`settings.py`**: Application configuration, constants, and styling
+
+### `src/app.py`
+- **Main orchestrator**: Ties all modules together and creates the Gradio interface
+
+## 🔧 Benefits of Modular Architecture
+
+1. **Maintainability**: Each module has a single responsibility
+2. **Testability**: Individual modules can be tested in isolation
+3. **Scalability**: Easy to add new features without affecting existing code
+4. **Readability**: Clear separation of concerns
+5. **Reusability**: Components can be reused across different parts of the app
+6. **Professional**: Industry-standard project structure
+
+## 🧪 Key Features
+
+- **Molecular Analysis**: SMILES validation, property calculations, drug-likeness assessment
+- **Chemical Variations**: Multiple visualization styles and rendering options
+- **AI Structure Generation**: AI-powered molecular structure suggestions
+- **Interactive UI**: Clean, modern interface with real-time feedback
+- **Bookmarking**: Save and manage favorite molecular structures
+
+## 🔄 Migration from Monolithic
+
+The original `app.py` (1082 lines) has been refactored into:
+- **6 focused modules** with clear responsibilities
+- **~200 lines per module** for better maintainability
+- **Clean imports** and dependencies
+- **Preserved functionality** with improved organization
+
+## 🚀 Future Enhancements
+
+With the modular structure, it's now easy to:
+- Add new molecular analysis algorithms
+- Implement additional AI models
+- Create new UI components
+- Add database integration
+- Implement user authentication
+- Add API endpoints
+- Create unit tests for each module

app.py

@@ -0,0 +1,20 @@
+"""
+HITL Drug Discovery Application
+
+Main entry point for both local development and Hugging Face Spaces.
+This file imports and runs the modular application.
+"""
+
+from src.app import create_app
+
+# Create the application
+app = create_app()
+
+# Launch the application
+if __name__ == "__main__":
+    print("🧬 HITL Drug Discovery Application")
+    print("🌐 Starting application...")
+    print("📍 Available at: http://localhost:7860")
+    print("⏹️  Press Ctrl+C to stop")
+    print("-" * 50)
+    app.launch()

generated_molecules.csv

@@ -0,0 +1,214 @@
+smiles,count
+[*],1
+[*]C,1
+[*]Cl,1
+[*]N,1
+[*]Br,1
+[*]O,1
+[*][C@@H],1
+[*]F,1
+[*]S,1
+[*][C@H],1
+[*]CC,1
+[*]OC,1
+[*]CO,1
+[*]NC,1
+[*]CN,1
+[*]SC,1
+[*]N[C@@H],1
+[*]/C,1
+[*]C#C,1
+[*]C#N,1
+[*]CO[C@H],1
+[*]CNS,1
+[*]OCC,1
+[*]CCC,1
+[*]NCC,1
+[*]C=C,1
+[*]SCC,1
+[*]CCN,1
+[*]CN[C@H],1
+[*]CC[C@@],1
+[*]CNC,1
+[*][C@@H](C),1
+[*]C(F),1
+[*]CC=C,1
+[*]N(C),1
+[*]C(C),1
+[*]C#CC,1
+[*][C@H](C),1
+[*]S(C),1
+[*]C(N),1
+[*]CCCC,1
+[*]/C=C,1
+[*]OCCN,1
+[*]CC#N,1
+[*]C(=O),1
+[*]C(=C),1
+[*]OC(C),1
+[*]N(C)C,1
+[*]S(=O),1
+[*]C(=N),1
+[*]OC(F),1
+[*]CN(C),1
+[*]C(C)N,1
+[*]OCC#C,1
+[*][C@H](C)N,1
+[*]C1CC1,1
+[*]C(C)C,1
+[*]C(=O)O,1
+[*]C(=O)C,1
+[*]C(=O)N,1
+[*]NC(=O),1
+[*]C(=N)N,1
+[*]C(C)=O,1
+[*]OC(C)C,1
+[*]CC(=O),1
+[*]C(C#C),1
+[*]c1cn[nH]c1,1
+[*]c1ccn[nH]1,1
+[*]N1CCCC1,1
+[*]C(F)(F),1
+[*]c1ccco1,1
+[*]N1CCC[C@@H]1,1
+[*]C(=O)OC,1
+[*]C(=O)CC,1
+[*]C(=O)NN,1
+[*]NC(=O)N,1
+[*]C(=O)NC,1
+[*]n1cncc1,1
+[*]OC(C)=O,1
+[*]C(=O)NS,1
+[*]NC(=O)C,1
+[*]CCC(=O),1
+[*]c1ccc[nH]1,1
+[*]n1cccn1,1
+[*]C(C)(C),1
+[*]n1ccnc1,1
+[*]C(=O)CN,1
+[*]c1cccs1,1
+[*]c1ccccc1,1
+[*]c1cccnc1,1
+[*]c1cncnc1,1
+[*]C(F)(F)F,1
+[*]C1CCCCN1,1
+[*]C(=O)N/N,1
+[*]C1CCOCC1,1
+[*]C(=O)NCC,1
+[*]N1CCOCC1,1
+[*]C(=O)NNC,1
+[*]NC(=O)CS,1
+[*]C(=O)OCC,1
+[*]c1ccncc1,1
+[*]N1CCCCC1,1
+[*]NC(=O)CO,1
+[*]S(C)(=O),1
+[*]NC(=O)NC,1
+[*]c1ccccn1,1
+[*]NC(=O)CN,1
+[*]Oc1ccccc1,1
+[*]c1ccccc1N,1
+[*]OC1CCCCC1,1
+[*]C(=O)NCCC,1
+[*]c1ccccc1Cl,1
+[*]C(=O)NCCN,1
+[*]S(=O)(=O),1
+[*]CN1CCOCC1,1
+[*]c1ccccc1C,1
+[*]c1ccccc1F,1
+[*]c1cnn(C)c1,1
+[*]C(=O)NC(C),1
+[*]n1nc(C)cc1,1
+[*]C1NC[C@@H](C)N1,1
+[*]n1cnc(C)c1,1
+[*]S(C)(=O)=O,1
+[*][C@@H](NC(C)=O),1
+[*]S(=O)(=O)N,1
+[*]OCc1ccccc1,1
+[*]c1cccc(F)c1,1
+[*]c1ccc(F)cc1,1
+[*]c1cccc(Cl)c1,1
+[*]C1CC(=O)NN1,1
+[*]c1ccnc(N)n1,1
+[*]c1ccc(O)cc1,1
+[*]C1CC(=O)NC1,1
+[*]c1ccc(O)nn1,1
+[*]C(=O)N1CCCC1,1
+[*]C(=O)NNC(=O),1
+[*]C(=O)OCC(=O),1
+[*]CC1OC(=O)CC1,1
+[*]C1=NNC(=O)CC1,1
+[*]C(=O)NNC(=O)C,1
+[*]C1CCCN(CC#C)C1,1
+[*]Cc1cccc(=O)n1O,1
+[*]C1(C)SCC(=O)N1,1
+[*]Cc1ccc2cc[nH]c2c1,1
+[*]c1cccc2c1CNCC2,1
+[*]c1cncc2c1CCCC2,1
+[*]CN1CCc2cncnc2C1,1
+[*]C(Nc1ccc(C)cc1),1
+[*]Nc1cnc2ccccc2n1,1
+[*]c1nc2cc(N)ccc2o1,1
+[*]NCc1cc2ccccc2nc1,1
+[*]N1C(=O)CC(=O)NC1,1
+[*]N(C)Cc1noc(CC)n1,1
+[*]COc1cccc2cccnc12,1
+[*]C#Cc1ccnc(OCC)c1,1
+[*]c1ccc(Cl)c2c1CNC2,1
+[*]c1cn(C)c(=O)[nH]c1=O,1
+[*]C(=O)Nc1ccc(Cl)cc1,1
+[*]Nc1ncc2c(n1)CCCC2,1
+[*]c1ccnc(C2CCCN2)n1,1
+[*]c1ccc(CC(=O)NO)s1,1
+[*]N1C2CCCC1CC(=O)C2,1
+[*]C(=O)c1cc(CCC)ccc1,1
+[*]NCc1cccc(C(=O)O)c1,1
+[*]N1CCN(Cc2ccco2)CC1,1
+[*]C(=O)N1CC2CCNCC2C1,1
+[*]c1cccc(N2CCOCC2)n1,1
+[*]Nc1ccnc2cc(Cl)ccc12,1
+[*]CCc1nc2cc(N)ccc2o1,1
+[*]Cc1c[nH]c2nc(O)nc-2c1,1
+[*]c1ccc(C(=O)O)c(O)c1,1
+[*]C(=O)CC1(C#N)CCOCC1,1
+[*]c1ccc(CCN=C(NN)N)o1,1
+[*]c1ccc2c(c1)OC(=O)C2,1
+[*]c1ccc(S(N)(=O)=O)cc1,1
+[*]C(=O)Nc1c[nH]c(=O)[nH]c1=O,1
+[*]c1nc2c(c(=O)[nH]1)COCC2,1
+[*]NC(=O)c1ccc(F)c(F)c1,1
+[*]Cc1ccnc2c1CC[C@@H]1CNCCN21,1
+[*]c1cc(=O)c2cc(N)ccc2o1,1
+[*]NC(=O)Nc1nc2c(s1)CCC2,1
+[*]c1cc(C)nc2ccc3nc[nH]c3c12,1
+[*]c1cnc2ccc(NC(C)=O)cn12,1
+[*]c1cc(=O)c2cc(OC)ccc2o1,1
+[*]NC(=O)c1cc2cc(Cl)ccc2s1,1
+[*]NC(=O)C1CCCN([C@@H](C)CC)C1,1
+[*]C(=O)N1CCN(C)C(C)(C)C1,1
+[*]C(=O)Nc1ccc2nc(C)sc2c1,1
+[*]OC1CCN(Cc2ccc(Cl)s2)CC1,1
+[*]C1CCN(C(CN)c2ccccc2)CC1,1
+[*]c1ccc(NCc2cccc(O)c2)cc1,1
+[*]N1CC(NC(=O)C2CCCCC2)CC1,1
+[*]NC(=O)c1cc2c([nH]c1=O)CCC2,1
+[*]c1ccc(SC(F)(F)C(=O)O)cc1,1
+[*]c1ccc(C(=O)NCc2ccco2)cc1,1
+[*]N1CC(OC)C2=C1CC(C)(C)NS2,1
+[*]C1=NCC(=O)Nc2cc(OC)ccc21,1
+[*]c1ccc(-c2cccc3[nH]ccc23)nc1,1
+[*]c1ccnc(COc2ccc(CO)cc2)n1,1
+[*]c1cc2c(c(C(=O)O)c1)OCCNC2,1
+[*]NCc1cc2n(n1)-c1ccccc1CCC2,1
+[*]Nc1cc(=O)oc2c1ccc1ccccc12,1
+[*]c1ccc(NC(=N)c2ccc(Cl)s2)cc1,1
+[*]c1cc(C(F)(F)F)nn1-c1ccccc1,1
+[*]C1CNCc2ncnc(CCc3ccccc3)c21,1
+[*]c1ccc(Cl)c2c1NS(=O)(=O)C/C2,1
+[*]NC(=O)C12CC3CC(CC(C3)C1)C2,1
+[*]Oc1ccc2oc(CCN3CCC[C@H]3C)cc2c1,1
+[*]N1C(=O)CC(N2CC(C)CC(C)C2)C1,1
+[*]C(=O)N1CC(=O)Nc2c(C)cccc2C1,1
+[*]NCc1cccc(-c2c[nH]c(=O)[nH]c2=O)c1,1
+[*]C1CNCCc2cc(Cl)c(OCCC)c(O)c21,1
+[*]c1cnc(NC)c(-c2ccc(OC)cc2)n1,1

legacy/app_legacy.py

@@ -0,0 +1,1081 @@
+import gradio as gr
+from huggingface_hub import InferenceClient
+from rdkit import Chem
+from rdkit.Chem import Draw, Descriptors, Crippen
+
+def calculate_molecular_properties(smiles):
+    """Calculate key molecular properties for drug discovery."""
+    mol = Chem.MolFromSmiles(smiles)
+    if not mol:
+        return None
+    
+    properties = {
+        'Molecular Weight': round(Descriptors.MolWt(mol), 2),
+        'LogP': round(Crippen.MolLogP(mol), 2),
+        'HBD': Descriptors.NumHDonors(mol),
+        'HBA': Descriptors.NumHAcceptors(mol),
+        'TPSA': round(Descriptors.TPSA(mol), 2),
+        'Rotatable Bonds': Descriptors.NumRotatableBonds(mol),
+        'Aromatic Rings': Descriptors.NumAromaticRings(mol),
+        'Heavy Atoms': mol.GetNumHeavyAtoms()
+    }
+    
+    # Lipinski's Rule of Five
+    lipinski_violations = 0
+    if properties['Molecular Weight'] > 500:
+        lipinski_violations += 1
+    if properties['LogP'] > 5:
+        lipinski_violations += 1
+    if properties['HBD'] > 5:
+        lipinski_violations += 1
+    if properties['HBA'] > 10:
+        lipinski_violations += 1
+    
+    properties['Lipinski Violations'] = lipinski_violations
+    properties['Drug-like'] = lipinski_violations <= 1
+    
+    return properties
+
+def respond(
+    message,
+    history: list[dict[str, str]],
+    system_message,
+    max_tokens,
+    temperature,
+    top_p,
+    hf_token: gr.OAuthToken,
+):
+    """
+    Enhanced drug discovery chatbot with molecular property integration.
+    """
+    client = InferenceClient(token=hf_token.token, model="openai/gpt-oss-20b")
+
+    # Enhanced system message for drug discovery
+    enhanced_system_message = f"""{system_message}
+
+You are an expert medicinal chemist and drug discovery specialist. You help researchers understand:
+- Molecular properties and drug-likeness
+- Structure-activity relationships (SAR)
+- ADMET properties (Absorption, Distribution, Metabolism, Excretion, Toxicity)
+- Drug design principles and optimization strategies
+- Chemical synthesis and medicinal chemistry
+
+When discussing molecules, consider their molecular weight, LogP, hydrogen bonding, and other key properties. Reference the molecular gallery below for visual context."""
+
+    messages = [{"role": "system", "content": enhanced_system_message}]
+    messages.extend(history)
+    messages.append({"role": "user", "content": message})
+
+    response = ""
+
+    for message in client.chat_completion(
+        messages,
+        max_tokens=max_tokens,
+        stream=True,
+        temperature=temperature,
+        top_p=top_p,
+    ):
+        choices = message.choices
+        token = ""
+        if len(choices) and choices[0].delta.content:
+            token = choices[0].delta.content
+
+        response += token
+        yield response
+
+
+# ChatInterface configuration for drug discovery
+chatbot = gr.ChatInterface(
+    respond,
+    type="messages",
+    additional_inputs=[
+        gr.Textbox(value="You are a friendly drug discovery assistant.", label="System message"),
+        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
+        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
+        gr.Slider(
+            minimum=0.1,
+            maximum=1.0,
+            value=0.95,
+            step=0.05,
+            label="Top-p (nucleus sampling)",
+        ),
+        gr.OAuthToken(label="Hugging Face Token"),
+    ],
+)
+
+
+# Enhanced drug discovery molecule library
+list_smiles = [
+    "C[C@H](N)C(=O)O", # – Alanine (amino acid)
+    "CC(=O)OC1=CC=CC=C1C(=O)O", # – Aspirin (NSAID)
+    "CCN(CC)CC", # – Triethylamine (base)
+    "c1ccccc1O", # – Phenol (aromatic)
+    "CC(C)CC(=O)O", # – Valeric acid (fatty acid)
+    "CN1C=NC2=C1N=CN2", # – Adenine (nucleobase)
+    "O=C(O)C1=CC=CC=C1", # – Benzoic acid (aromatic acid)
+    "C1CCCCC1", # – Cyclohexane (cycloalkane)
+    "CC(=O)N1CCCCC1", # – N-methylpiperidine (amine)
+]
+
+# User's bookmarked molecules (stored in session)
+bookmarked_molecules = []
+
+# Drug discovery molecules
+drug_smiles = [
+    "CC1=CC=C(C=C1)C(C)NC(=O)C2=CC=C(C=C2)Cl", # – Ibuprofen
+    "CC1=CC=C(C=C1)C(C)NC(=O)C2=CC=C(C=C2)F", # – Flurbiprofen
+    "CC1=CC=C(C=C1)C(C)NC(=O)C2=CC=C(C=C2)Br", # – Bromfenac
+    "CC1=CC=C(C=C1)C(C)NC(=O)C2=CC=C(C=C2)I", # – Iodofenac
+    "CC1=CC=C(C=C1)C(C)NC(=O)C2=CC=C(C=C2)[N+](=O)[O-]", # – Nitrofenac
+]
+
+def generate_molecule_images():
+    """
+    Generates enhanced molecule images with better visualization.
+    """
+    images = []
+    for smiles in list_smiles:
+        mol = Chem.MolFromSmiles(smiles)
+        if mol:
+            # Create a high-quality image with better rendering
+            img = Draw.MolToImage(mol, size=(200, 200), kekulize=True)
+            images.append(img)
+        else:
+            # Add a placeholder if SMILES is invalid
+            try:
+                from PIL import Image
+                images.append(Image.new('RGB', (200, 200), color='white'))
+            except ImportError:
+                # Fallback if PIL not available
+                images.append(None)
+    return images
+
+def generate_molecule_image(smiles):
+    """Generate a molecular structure image from SMILES string."""
+    mol = Chem.MolFromSmiles(smiles)
+    if not mol:
+        return None
+    
+    # Create a high-quality image
+    img = Draw.MolToImage(mol, size=(300, 300), kekulize=True)
+    return img
+
+def generate_molecule_variations(base_smiles, num_variations=12):
+    """Generate multiple variations of a chemical structure for the grid display."""
+    mol = Chem.MolFromSmiles(base_smiles)
+    if not mol:
+        return []
+    
+    variations = []
+    
+    # Generate different rendering styles and sizes
+    sizes = [(150, 150), (180, 180), (200, 200), (160, 160)]
+    styles = [True, False]  # kekulize vs non-kekulize
+    
+    for i in range(num_variations):
+        size = sizes[i % len(sizes)]
+        kekulize = styles[i % len(styles)]
+        
+        try:
+            # Create variation with different rendering parameters
+            img = Draw.MolToImage(mol, size=size, kekulize=kekulize)
+            variations.append({
+                'image': img,
+                'smiles': base_smiles,
+                'variation_id': i + 1,
+                'size': size,
+                'kekulize': kekulize
+            })
+        except:
+            # Fallback to basic rendering
+            try:
+                img = Draw.MolToImage(mol, size=(150, 150), kekulize=True)
+                variations.append({
+                    'image': img,
+                    'smiles': base_smiles,
+                    'variation_id': i + 1,
+                    'size': (150, 150),
+                    'kekulize': True
+                })
+            except:
+                continue
+    
+    return variations
+
+def generate_chemical_series_variations(base_smiles):
+    """Generate a series of related chemical structures for drug discovery."""
+    mol = Chem.MolFromSmiles(base_smiles)
+    if not mol:
+        return []
+    
+    variations = []
+    
+    # Create different visualization styles
+    styles = [
+        {'size': (200, 200), 'kekulize': True, 'style': 'Standard'},
+        {'size': (180, 180), 'kekulize': False, 'style': 'Kekulé'},
+        {'size': (220, 220), 'kekulize': True, 'style': 'Large'},
+        {'size': (160, 160), 'kekulize': False, 'style': 'Compact'},
+        {'size': (200, 200), 'kekulize': True, 'style': 'Detailed'},
+        {'size': (190, 190), 'kekulize': False, 'style': 'Minimal'},
+        {'size': (210, 210), 'kekulize': True, 'style': 'Enhanced'},
+        {'size': (170, 170), 'kekulize': False, 'style': 'Focused'},
+        {'size': (200, 200), 'kekulize': True, 'style': 'Classic'},
+        {'size': (185, 185), 'kekulize': False, 'style': 'Modern'},
+        {'size': (195, 195), 'kekulize': True, 'style': 'Scientific'},
+        {'size': (175, 175), 'kekulize': False, 'style': 'Clean'}
+    ]
+    
+    for i, style_config in enumerate(styles):
+        try:
+            img = Draw.MolToImage(mol, size=style_config['size'], kekulize=style_config['kekulize'])
+            variations.append({
+                'image': img,
+                'smiles': base_smiles,
+                'variation_id': i + 1,
+                'style': style_config['style'],
+                'size': style_config['size'],
+                'kekulize': style_config['kekulize']
+            })
+        except:
+            continue
+    
+    return variations
+
+# Global variables for variations management
+current_variations = []
+current_page = 0
+variations_per_page = 12
+
+def generate_variations_for_display(smiles, num_variations=12):
+    """Generate variations and format for gallery display."""
+    global current_variations
+    variations = generate_chemical_series_variations(smiles)
+    current_variations = variations[:num_variations]
+    
+    # Format for gallery display
+    gallery_items = []
+    for var in current_variations:
+        gallery_items.append((var['image'], f"Style: {var['style']}"))
+    
+    return gallery_items, current_variations[0]['image'] if current_variations else None, smiles, current_variations[0]['style'] if current_variations else "None"
+
+def select_variation(evt: gr.SelectData):
+    """Handle selection of a variation from the grid."""
+    if not current_variations or evt.index >= len(current_variations):
+        return None, "", ""
+    
+    selected_var = current_variations[evt.index]
+    return selected_var['image'], selected_var['smiles'], selected_var['style']
+
+def clear_variations():
+    """Clear all variations and reset display."""
+    global current_variations, current_page
+    current_variations = []
+    current_page = 0
+    return [], None, "", ""
+
+def update_grid_size(columns):
+    """Update the grid columns dynamically."""
+    return gr.Gallery(columns=columns)
+
+def navigate_variations(direction):
+    """Navigate through variations pages."""
+    global current_page, current_variations, variations_per_page
+    
+    if not current_variations:
+        return [], "Page 1 of 1", None, "", ""
+    
+    total_pages = (len(current_variations) + variations_per_page - 1) // variations_per_page
+    
+    if direction == "next":
+        current_page = min(current_page + 1, total_pages - 1)
+    elif direction == "prev":
+        current_page = max(current_page - 1, 0)
+    
+    # Get variations for current page
+    start_idx = current_page * variations_per_page
+    end_idx = min(start_idx + variations_per_page, len(current_variations))
+    page_variations = current_variations[start_idx:end_idx]
+    
+    # Format for gallery display
+    gallery_items = []
+    for var in page_variations:
+        gallery_items.append((var['image'], f"Style: {var['style']}"))
+    
+    page_info = f"Page {current_page + 1} of {total_pages}"
+    
+    return gallery_items, page_info, page_variations[0]['image'] if page_variations else None, page_variations[0]['smiles'] if page_variations else "", page_variations[0]['style'] if page_variations else ""
+
+def update_variation_count(count):
+    """Update the number of variations to generate."""
+    global variations_per_page
+    variations_per_page = count
+    return count
+
+def generate_ai_structures(message, history, selected_smiles, hf_token: gr.OAuthToken):
+    """Generate new structures using AI based on user request and selected molecule."""
+    if not message.strip():
+        return history, []
+    
+    client = InferenceClient(token=hf_token.token, model="openai/gpt-oss-20b")
+    
+    # Enhanced system message for structure generation
+    system_message = f"""You are an expert medicinal chemist and drug discovery specialist. You help generate new chemical structures based on user requests and existing molecules.
+
+Current selected molecule SMILES: {selected_smiles}
+
+Your task is to:
+1. Understand the user's request for structure modifications
+2. Generate 3-6 new SMILES strings that meet their requirements
+3. Provide brief explanations for each generated structure
+4. Consider drug-likeness, ADMET properties, and medicinal chemistry principles
+
+Format your response as:
+STRUCTURE 1: [SMILES] - [Brief explanation]
+STRUCTURE 2: [SMILES] - [Brief explanation]
+etc.
+
+Focus on practical, synthesizable structures that address the user's specific request."""
+
+    messages = [{"role": "system", "content": system_message}]
+    messages.extend(history)
+    messages.append({"role": "user", "content": message})
+
+    response = ""
+    for message_chunk in client.chat_completion(
+        messages,
+        max_tokens=512,
+        stream=True,
+        temperature=0.7,
+        top_p=0.9,
+    ):
+        choices = message_chunk.choices
+        token = ""
+        if len(choices) and choices[0].delta.content:
+            token = choices[0].delta.content
+        response += token
+        yield response
+
+def parse_ai_structures(ai_response, selected_smiles):
+    """Parse AI response to extract SMILES strings and generate images."""
+    structures = []
+    lines = ai_response.split('\n')
+    
+    for line in lines:
+        if 'STRUCTURE' in line.upper() and ':' in line:
+            try:
+                # Extract SMILES from lines like "STRUCTURE 1: CCO - ethanol"
+                parts = line.split(':', 1)
+                if len(parts) > 1:
+                    smiles_part = parts[1].split('-')[0].strip()
+                    # Clean up the SMILES string
+                    smiles = smiles_part.strip('[]()').strip()
+                    
+                    # Validate and generate image
+                    mol = Chem.MolFromSmiles(smiles)
+                    if mol:
+                        img = Draw.MolToImage(mol, size=(150, 150), kekulize=True)
+                        structures.append((img, f"Generated: {smiles}"))
+            except:
+                continue
+    
+    # If no structures were parsed, generate some variations of the selected molecule
+    if not structures and selected_smiles:
+        try:
+            mol = Chem.MolFromSmiles(selected_smiles)
+            if mol:
+                # Generate a few variations with different sizes
+                for size in [(120, 120), (150, 150), (180, 180)]:
+                    img = Draw.MolToImage(mol, size=size, kekulize=True)
+                    structures.append((img, f"Variation: {selected_smiles}"))
+        except:
+            pass
+    
+    return structures
+
+def handle_structure_chat(message, history, selected_smiles, hf_token: gr.OAuthToken):
+    """Handle the structure generation chat."""
+    if not message.strip():
+        return history, []
+    
+    # Add user message to history
+    history.append({"role": "user", "content": message})
+    
+    # Generate AI response
+    ai_response = ""
+    for chunk in generate_ai_structures(message, history[:-1], selected_smiles, hf_token):
+        ai_response = chunk
+    
+    # Add AI response to history
+    history.append({"role": "assistant", "content": ai_response})
+    
+    # Parse and generate structure images
+    structures = parse_ai_structures(ai_response, selected_smiles)
+    
+    return history, structures
+
+def bookmark_molecule(smiles, molecule_name=""):
+    """Add a molecule to the bookmarked collection."""
+    global bookmarked_molecules
+    
+    # Validate SMILES first
+    mol = Chem.MolFromSmiles(smiles)
+    if not mol:
+        return "❌ Invalid SMILES string - cannot bookmark"
+    
+    # Check if already bookmarked
+    if smiles in [bm['smiles'] for bm in bookmarked_molecules]:
+        return "⚠️ Molecule already bookmarked"
+    
+    # Generate a name if not provided
+    if not molecule_name:
+        molecule_name = f"Bookmarked_{len(bookmarked_molecules) + 1}"
+    
+    # Add to bookmarks
+    bookmarked_molecules.append({
+        'smiles': smiles,
+        'name': molecule_name,
+        'timestamp': len(bookmarked_molecules) + 1  # Simple counter
+    })
+    
+    return f"✅ Bookmarked: {molecule_name}"
+
+def get_bookmarked_molecules():
+    """Get all bookmarked molecules for display."""
+    return bookmarked_molecules
+
+def remove_bookmark(smiles):
+    """Remove a molecule from bookmarks."""
+    global bookmarked_molecules
+    
+    bookmarked_molecules = [bm for bm in bookmarked_molecules if bm['smiles'] != smiles]
+    return "🗑️ Removed from bookmarks"
+
+def validate_smiles(smiles):
+    """Validate SMILES string and return error message if invalid."""
+    if not smiles or not smiles.strip():
+        return "Please enter a SMILES string"
+    
+    # Try to parse the SMILES
+    mol = Chem.MolFromSmiles(smiles.strip())
+    if not mol:
+        # Provide more helpful error messages based on common issues
+        error_msg = f"❌ **Invalid SMILES string:** `{smiles}`\n\n"
+        
+        # Check for specific common issues
+        if smiles.count('(') != smiles.count(')'):
+            error_msg += "🔍 **Issue detected:** Unmatched parentheses\n"
+        elif smiles.count('[') != smiles.count(']'):
+            error_msg += "🔍 **Issue detected:** Unmatched brackets\n"
+        elif any(char in smiles for char in ['@', '\\', '/']) and 'C' not in smiles:
+            error_msg += "🔍 **Issue detected:** Invalid stereochemistry notation\n"
+        else:
+            error_msg += "🔍 **Issue detected:** General syntax error\n"
+        
+        error_msg += "\n**💡 Tips for complex SMILES:**\n"
+        error_msg += "- Complex molecules are supported! The issue is likely syntax\n"
+        error_msg += "- Check parentheses and brackets are balanced\n"
+        error_msg += "- Verify ring closure numbers (e.g., C1CCCC1)\n"
+        error_msg += "- Use proper stereochemistry notation (@, @@, /, \\)\n"
+        error_msg += "- Try breaking complex molecules into smaller parts first\n\n"
+        error_msg += "**🧪 Examples of complex valid SMILES:**\n"
+        error_msg += "- `CC(=O)OC1=CC=CC=C1C(=O)O` (Aspirin)\n"
+        error_msg += "- `CN1C=NC2=C1C(=O)N(C(=O)N2C)C` (Caffeine)\n"
+        error_msg += "- `C([C@@H]1[C@H]([C@@H]([C@H]([C@H](O1)O)O)O)O)O` (Glucose)\n"
+        error_msg += "- `CC1([C@@H](N2[C@H](S1)[C@@H](C2=O)NC(=O)CC3=CC=CC=C3)C(=O)O)` (Penicillin)\n"
+        
+        return error_msg
+    
+    return None
+
+def validate_smiles_realtime(smiles):
+    """Real-time SMILES validation for user feedback."""
+    if not smiles or not smiles.strip():
+        return "✅ Ready to analyze", None
+    
+    validation_error = validate_smiles(smiles)
+    if validation_error:
+        return f"❌ {validation_error}", None
+    
+    # Try to generate a preview image
+    try:
+        mol = Chem.MolFromSmiles(smiles.strip())
+        if mol:
+            img = Draw.MolToImage(mol, size=(200, 200), kekulize=True)
+            return "✅ Valid SMILES - Click 'Analyze Molecule'", img
+    except:
+        pass
+    
+    return "✅ Valid SMILES - Click 'Analyze Molecule'", None
+
+def analyze_molecule(smiles):
+    """Analyze a molecule and return its properties with robust error handling."""
+    # Validate SMILES first
+    validation_error = validate_smiles(smiles)
+    if validation_error:
+        return validation_error, None
+    
+    # Calculate properties
+    properties = calculate_molecular_properties(smiles)
+    if not properties:
+        return "Error calculating molecular properties", None
+    
+    # Format the properties nicely - use raw string to prevent hyperlink conversion
+    result = f"**Molecular Analysis for:**\n```\n{smiles}\n```\n\n"
+    result += "**Basic Properties:**\n"
+    result += f"- Molecular Weight: {properties['Molecular Weight']} g/mol\n"
+    result += f"- LogP: {properties['LogP']}\n"
+    result += f"- TPSA: {properties['TPSA']} Ų\n"
+    result += f"- Heavy Atoms: {properties['Heavy Atoms']}\n\n"
+    
+    result += "**Hydrogen Bonding:**\n"
+    result += f"- HBD (Donors): {properties['HBD']}\n"
+    result += f"- HBA (Acceptors): {properties['HBA']}\n\n"
+    
+    result += "**Structural Features:**\n"
+    result += f"- Rotatable Bonds: {properties['Rotatable Bonds']}\n"
+    result += f"- Aromatic Rings: {properties['Aromatic Rings']}\n\n"
+    
+    result += "**Drug-likeness:**\n"
+    result += f"- Lipinski Violations: {properties['Lipinski Violations']}/4\n"
+    result += f"- Drug-like: {'Yes' if properties['Drug-like'] else 'No'}\n"
+    
+    # Generate molecular structure image with error handling
+    try:
+        molecule_img = generate_molecule_image(smiles)
+        if not molecule_img:
+            result += "\n\n⚠️ **Warning:** Could not generate molecular structure image"
+    except Exception as e:
+        result += f"\n\n⚠️ **Warning:** Error generating molecular structure: {str(e)}"
+        molecule_img = None
+    
+    return result, molecule_img
+
+
+# Custom CSS for the Chemical Diagram Variations interface
+custom_css = """
+#main_structure {
+    border: 3px solid #4CAF50;
+    border-radius: 15px;
+    box-shadow: 0 4px 8px rgba(0,0,0,0.1);
+}
+
+#variations_gallery {
+    border: 2px solid #e0e0e0;
+    border-radius: 10px;
+    background: #f9f9f9;
+}
+
+#variations_gallery .gallery-item {
+    border: 2px solid #ddd;
+    border-radius: 8px;
+    margin: 5px;
+    transition: all 0.3s ease;
+}
+
+#variations_gallery .gallery-item:hover {
+    border-color: #4CAF50;
+    transform: scale(1.05);
+    box-shadow: 0 4px 12px rgba(76, 175, 80, 0.3);
+}
+
+#variations_container {
+    max-height: 600px;
+    overflow-y: auto;
+    padding: 10px;
+}
+
+#selected_smiles, #selected_style {
+    background: #f5f5f5;
+    border: 1px solid #ddd;
+    border-radius: 5px;
+}
+
+.page-info {
+    text-align: center;
+    font-weight: bold;
+    color: #666;
+}
+
+.grid-controls {
+    background: #f0f0f0;
+    padding: 10px;
+    border-radius: 8px;
+    margin: 10px 0;
+}
+"""
+
+with gr.Blocks(title="HITL Drug Discovery", theme=gr.themes.Soft(), css=custom_css) as demo:
+    gr.Markdown("# 🧬 Human-in-the-Loop Drug Discovery")
+    gr.Markdown("Interactive molecular analysis and AI assistant for drug discovery research")
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("## 🔬 Molecular Analysis")
+            smiles_input = gr.Textbox(
+                label="Enter SMILES string",
+                placeholder="e.g., C[C@H](N)C(=O)O",
+                value="C[C@H](N)C(=O)O",
+                info="Enter a valid SMILES string for molecular analysis"
+            )
+            
+            # Real-time validation status
+            validation_status = gr.Markdown("✅ Ready to analyze")
+            preview_image = gr.Image(
+                label="Preview",
+                show_download_button=False,
+                width=200,
+                height=200,
+                visible=False
+            )
+            
+            # Quick access buttons for common molecules
+            gr.Markdown("### Quick Examples")
+            with gr.Row():
+                alanine_btn = gr.Button("Alanine", size="sm")
+                aspirin_btn = gr.Button("Aspirin", size="sm")
+                ibuprofen_btn = gr.Button("Ibuprofen", size="sm")
+            
+            with gr.Row():
+                caffeine_btn = gr.Button("Caffeine", size="sm")
+                glucose_btn = gr.Button("Methanol", size="sm")
+                benzene_btn = gr.Button("Benzene", size="sm")
+            
+            with gr.Row():
+                glucose_btn2 = gr.Button("Acetone", size="sm")
+                ethanol_btn = gr.Button("Ethanol", size="sm")
+                water_btn = gr.Button("Water", size="sm")
+            
+            with gr.Row():
+                complex_btn1 = gr.Button("Glucose", size="sm")
+                complex_btn2 = gr.Button("Cholesterol", size="sm")
+                complex_btn3 = gr.Button("Penicillin", size="sm")
+            
+            analyze_btn = gr.Button("🔍 Analyze Molecule", variant="primary", size="lg")
+            
+            # Bookmark functionality
+            with gr.Row():
+                bookmark_name = gr.Textbox(
+                    placeholder="Enter molecule name (optional)",
+                    label="Molecule Name",
+                    scale=2
+                )
+                bookmark_btn = gr.Button("🔖 Bookmark", variant="secondary", size="sm", scale=1)
+            
+            bookmark_status = gr.Markdown("")
+            
+            gr.Markdown("### 📊 Analysis Results")
+            analysis_output = gr.Markdown()
+        
+        with gr.Column(scale=1):
+            gr.Markdown("### 🧪 Molecular Structure")
+            molecule_image = gr.Image(
+                label="Chemical Structure",
+                show_download_button=False,
+                width=400,
+                height=400
+            )
+
+    with gr.Tabs():
+        with gr.Tab("🤖 AI Chat Assistant"):
+            chatbot.render()
+
+        with gr.Tab("🧬 Molecular Gallery"):
+            gr.Markdown("### Common Drug Discovery Molecules")
+            image_components = []
+            
+            # Display images in a 3x3 grid
+            with gr.Row():
+                for row in range(3):
+                    with gr.Row():
+                        for col in range(3):
+                            idx = row * 3 + col
+                            img = gr.Image(
+                                show_download_button=False,
+                                width=200,
+                                height=200,
+                                label=list_smiles[idx],
+                            )
+                            image_components.append(img)
+            
+            # Bookmarked molecules section
+            gr.Markdown("### 🔖 Your Bookmarked Molecules")
+            bookmarked_gallery = gr.Gallery(
+                label="Bookmarked Structures",
+                show_label=False,
+                elem_id="bookmarked_gallery",
+                columns=4,
+                rows=1,
+                height=200,
+                object_fit="contain"
+            )
+
+        with gr.Tab("💊 Drug Discovery Library"):
+            gr.Markdown("### NSAID Drug Series")
+            drug_images = []
+            
+            # Display drug molecules
+            with gr.Row():
+                for i, smiles in enumerate(drug_smiles):
+                    if i < 3:  # First row
+                        img = gr.Image(
+                            show_download_button=False,
+                            width=200,
+                            height=200,
+                            label=smiles,
+                        )
+                        drug_images.append(img)
+            
+            with gr.Row():
+                for i, smiles in enumerate(drug_smiles):
+                    if i >= 3:  # Second row
+                        img = gr.Image(
+                            show_download_button=False,
+                            width=200,
+                            height=200,
+                            label=smiles,
+                        )
+                        drug_images.append(img)
+
+        with gr.Tab("🔬 Chemical Diagram Variations"):
+            gr.Markdown("### Interactive Chemical Structure Variations")
+            gr.Markdown("Generate and explore multiple visualizations of your chemical structures")
+            
+            with gr.Row():
+                with gr.Column(scale=2):
+                    # Top left: SMILES input and main structure display
+                    gr.Markdown("#### Input & Main Structure")
+                    variation_smiles_input = gr.Textbox(
+                        label="Enter SMILES for variations",
+                        placeholder="e.g., C[C@H](N)C(=O)O",
+                        value="C[C@H](N)C(=O)O",
+                        elem_id="variation_smiles_input"
+                    )
+                    
+                    with gr.Row():
+                        generate_variations_btn = gr.Button("🔄 Generate Variations", variant="primary")
+                        clear_variations_btn = gr.Button("🗑️ Clear", variant="secondary")
+                    
+                    # Main display area - large chemical structure
+                    main_structure_display = gr.Image(
+                        label="Selected Chemical Structure",
+                        show_download_button=False,
+                        width=400,
+                        height=400,
+                        elem_id="main_structure"
+                    )
+                    
+                    # Structure information
+                    gr.Markdown("#### Structure Information")
+                    selected_smiles_display = gr.Textbox(
+                        label="SMILES String",
+                        interactive=False,
+                        elem_id="selected_smiles"
+                    )
+                    selected_style_display = gr.Textbox(
+                        label="Visualization Style",
+                        interactive=False,
+                        elem_id="selected_style"
+                    )
+                    
+                    # AI Chat for structure generation
+                    gr.Markdown("#### AI Structure Generator")
+                    gr.Markdown("Ask the AI to generate new structures based on the selected molecule and your preferences")
+                    
+                    # Chat interface for structure generation
+                    structure_chatbot = gr.Chatbot(
+                        label="Structure Generation Chat",
+                        height=300,
+                        elem_id="structure_chatbot",
+                        type="messages"
+                    )
+                    
+                    with gr.Row():
+                        structure_chat_input = gr.Textbox(
+                            placeholder="e.g., 'Generate a more drug-like version' or 'Create a derivative with better solubility'",
+                            label="Your request",
+                            scale=4
+                        )
+                        structure_send_btn = gr.Button("Send", variant="primary", scale=1)
+                    
+                    # Generated structures display
+                    gr.Markdown("#### AI Generated Structures")
+                    ai_generated_grid = gr.Gallery(
+                        label="AI Generated Structures",
+                        show_label=False,
+                        elem_id="ai_generated_grid",
+                        columns=3,
+                        rows=2,
+                        height=200,
+                        object_fit="contain",
+                        allow_preview=True
+                    )
+                
+                with gr.Column(scale=3):
+                    # Right side: Clean grid of diagram variations
+                    gr.Markdown("#### Chemical Structure Variations (Click to select)")
+                    
+                    # Create a scrollable container for the grid
+                    with gr.Column(elem_id="variations_container"):
+                        variations_grid = gr.Gallery(
+                            label="Chemical Structure Variations",
+                            show_label=False,
+                            elem_id="variations_gallery",
+                            columns=4,
+                            rows=3,
+                            height=600,
+                            object_fit="contain",
+                            allow_preview=True,
+                            selected_index=0
+                        )
+                    
+                    # Navigation controls
+                    with gr.Row():
+                        prev_page_btn = gr.Button("⬅️ Previous", size="sm")
+                        page_info = gr.Markdown("Page 1 of 1", elem_classes="page-info")
+                        next_page_btn = gr.Button("➡️ Next", size="sm")
+                    
+                    # Grid controls
+                    with gr.Row(elem_classes="grid-controls"):
+                        grid_size_slider = gr.Slider(
+                            minimum=4,
+                            maximum=8,
+                            value=4,
+                            step=1,
+                            label="Grid Columns",
+                            elem_id="grid_size_slider"
+                        )
+                        variation_count_slider = gr.Slider(
+                            minimum=6,
+                            maximum=24,
+                            value=12,
+                            step=6,
+                            label="Number of Variations",
+                            elem_id="variation_count_slider"
+                        )
+
+    # Event handlers
+    demo.load(
+        fn=generate_molecule_images,
+        inputs=None,
+        outputs=image_components
+    )
+    
+    # Generate drug images on load
+    def generate_drug_images():
+        images = []
+        for smiles in drug_smiles:
+            mol = Chem.MolFromSmiles(smiles)
+            if mol:
+                img = Draw.MolToImage(mol, size=(200, 200), kekulize=True)
+                images.append(img)
+            else:
+                try:
+                    from PIL import Image
+                    images.append(Image.new('RGB', (200, 200), color='white'))
+                except ImportError:
+                    # Fallback if PIL not available
+                    images.append(None)
+        return images
+    
+    demo.load(
+        fn=generate_drug_images,
+        inputs=None,
+        outputs=drug_images
+    )
+    
+    # Load default molecular structure on startup
+    def load_default_molecule():
+        default_smiles = "C[C@H](N)C(=O)O"  # Alanine
+        analysis_text, molecule_img = analyze_molecule(default_smiles)
+        return analysis_text, molecule_img
+    
+    # Event handlers
+    demo.load(
+        fn=load_default_molecule,
+        inputs=None,
+        outputs=[analysis_output, molecule_image]
+    )
+    
+    # Event handlers for quick example buttons
+    alanine_btn.click(
+        fn=lambda: ("C[C@H](N)C(=O)O", *analyze_molecule("C[C@H](N)C(=O)O")),
+        inputs=None,
+        outputs=[smiles_input, analysis_output, molecule_image]
+    )
+    
+    aspirin_btn.click(
+        fn=lambda: ("CC(=O)OC1=CC=CC=C1C(=O)O", *analyze_molecule("CC(=O)OC1=CC=CC=C1C(=O)O")),
+        inputs=None,
+        outputs=[smiles_input, analysis_output, molecule_image]
+    )
+    
+    ibuprofen_btn.click(
+        fn=lambda: ("CC1=CC=C(C=C1)C(C)NC(=O)C2=CC=C(C=C2)Cl", *analyze_molecule("CC1=CC=C(C=C1)C(C)NC(=O)C2=CC=C(C=C2)Cl")),
+        inputs=None,
+        outputs=[smiles_input, analysis_output, molecule_image]
+    )
+    
+    caffeine_btn.click(
+        fn=lambda: ("CN1C=NC2=C1C(=O)N(C(=O)N2C)C", *analyze_molecule("CN1C=NC2=C1C(=O)N(C(=O)N2C)C")),
+        inputs=None,
+        outputs=[smiles_input, analysis_output, molecule_image]
+    )
+    
+    glucose_btn.click(
+        fn=lambda: ("CO", *analyze_molecule("CO")),
+        inputs=None,
+        outputs=[smiles_input, analysis_output, molecule_image]
+    )
+    
+    benzene_btn.click(
+        fn=lambda: ("c1ccccc1", *analyze_molecule("c1ccccc1")),
+        inputs=None,
+        outputs=[smiles_input, analysis_output, molecule_image]
+    )
+    
+    glucose_btn2.click(
+        fn=lambda: ("CC(=O)C", *analyze_molecule("CC(=O)C")),
+        inputs=None,
+        outputs=[smiles_input, analysis_output, molecule_image]
+    )
+    
+    ethanol_btn.click(
+        fn=lambda: ("CCO", *analyze_molecule("CCO")),
+        inputs=None,
+        outputs=[smiles_input, analysis_output, molecule_image]
+    )
+    
+    water_btn.click(
+        fn=lambda: ("O", *analyze_molecule("O")),
+        inputs=None,
+        outputs=[smiles_input, analysis_output, molecule_image]
+    )
+    
+    # Complex molecule examples
+    complex_btn1.click(
+        fn=lambda: ("C([C@@H]1[C@H]([C@@H]([C@H]([C@H](O1)O)O)O)O)O", *analyze_molecule("C([C@@H]1[C@H]([C@@H]([C@H]([C@H](O1)O)O)O)O)O")),
+        inputs=None,
+        outputs=[smiles_input, analysis_output, molecule_image]
+    )
+    
+    complex_btn2.click(
+        fn=lambda: ("C[C@H]1CC[C@H]2[C@@H](C)CC[C@H](O)[C@H]2CC[C@H]1O", *analyze_molecule("C[C@H]1CC[C@H]2[C@@H](C)CC[C@H](O)[C@H]2CC[C@H]1O")),
+        inputs=None,
+        outputs=[smiles_input, analysis_output, molecule_image]
+    )
+    
+    complex_btn3.click(
+        fn=lambda: ("CC1([C@@H](N2[C@H](S1)[C@@H](C2=O)NC(=O)CC3=CC=CC=C3)C(=O)O)", *analyze_molecule("CC1([C@@H](N2[C@H](S1)[C@@H](C2=O)NC(=O)CC3=CC=CC=C3)C(=O)O)")),
+        inputs=None,
+        outputs=[smiles_input, analysis_output, molecule_image]
+    )
+    
+    # Real-time validation as user types
+    smiles_input.change(
+        fn=validate_smiles_realtime,
+        inputs=smiles_input,
+        outputs=[validation_status, preview_image]
+    )
+    
+    analyze_btn.click(
+        fn=analyze_molecule,
+        inputs=smiles_input,
+        outputs=[analysis_output, molecule_image]
+    )
+    
+    # Bookmark functionality
+    def bookmark_current_molecule(smiles, name):
+        result = bookmark_molecule(smiles, name)
+        # Update the bookmarked gallery
+        bookmarked_mols = get_bookmarked_molecules()
+        gallery_items = []
+        for mol in bookmarked_mols:
+            # Generate smaller images for gallery
+            mol_obj = Chem.MolFromSmiles(mol['smiles'])
+            if mol_obj:
+                img = Draw.MolToImage(mol_obj, size=(150, 150), kekulize=True)
+                gallery_items.append((img, f"{mol['name']}: {mol['smiles']}"))
+        return result, gallery_items
+    
+    bookmark_btn.click(
+        fn=bookmark_current_molecule,
+        inputs=[smiles_input, bookmark_name],
+        outputs=[bookmark_status, bookmarked_gallery]
+    )
+    
+    # Event handlers for Chemical Diagram Variations tab
+    generate_variations_btn.click(
+        fn=generate_variations_for_display,
+        inputs=[variation_smiles_input, variation_count_slider],
+        outputs=[variations_grid, main_structure_display, selected_smiles_display, selected_style_display]
+    )
+    
+    clear_variations_btn.click(
+        fn=clear_variations,
+        inputs=None,
+        outputs=[variations_grid, main_structure_display, selected_smiles_display, selected_style_display]
+    )
+    
+    # Handle grid selection
+    variations_grid.select(
+        fn=select_variation,
+        inputs=None,
+        outputs=[main_structure_display, selected_smiles_display, selected_style_display]
+    )
+    
+    # Update grid size when slider changes
+    grid_size_slider.change(
+        fn=update_grid_size,
+        inputs=grid_size_slider,
+        outputs=variations_grid
+    )
+    
+    # Navigation controls
+    prev_page_btn.click(
+        fn=lambda: navigate_variations("prev"),
+        inputs=None,
+        outputs=[variations_grid, page_info, main_structure_display, selected_smiles_display, selected_style_display]
+    )
+    
+    next_page_btn.click(
+        fn=lambda: navigate_variations("next"),
+        inputs=None,
+        outputs=[variations_grid, page_info, main_structure_display, selected_smiles_display, selected_style_display]
+    )
+    
+    # Update variation count
+    variation_count_slider.change(
+        fn=update_variation_count,
+        inputs=variation_count_slider,
+        outputs=variation_count_slider
+    )
+    
+    # Load default variations on startup
+    def load_default_variations():
+        default_smiles = "C[C@H](N)C(=O)O"  # Alanine
+        return generate_variations_for_display(default_smiles, 12)
+    
+    demo.load(
+        fn=load_default_variations,
+        inputs=None,
+        outputs=[variations_grid, main_structure_display, selected_smiles_display, selected_style_display]
+    )
+    
+    # AI Structure Generation Chat handlers
+    structure_send_btn.click(
+        fn=handle_structure_chat,
+        inputs=[structure_chat_input, structure_chatbot, selected_smiles_display, chatbot.additional_inputs[4]],  # hf_token
+        outputs=[structure_chatbot, ai_generated_grid]
+    )
+    
+    structure_chat_input.submit(
+        fn=handle_structure_chat,
+        inputs=[structure_chat_input, structure_chatbot, selected_smiles_display, chatbot.additional_inputs[4]],  # hf_token
+        outputs=[structure_chatbot, ai_generated_grid]
+    )
+
+
+if __name__ == "__main__":
+    demo.launch()

main.py

@@ -0,0 +1,11 @@
+"""
+Main Entry Point for HITL Drug Discovery Application
+
+This is the main entry point that imports and runs the modular application.
+"""
+
+from src.app import create_app
+
+if __name__ == "__main__":
+    app = create_app()
+    app.launch()

molecule_render_demo.py

@@ -0,0 +1,146 @@
+import gradio as gr
+from rdkit import Chem
+from rdkit.Chem import Draw
+from rdkit.Chem.Draw import rdMolDraw2D
+
+list_smiles = [
+    "C[C@H](N)C(=O)O",  # - Alanine
+    "CC(=O)OC1=CC=CC=C1C(=O)O",  # - Aspirin
+    "CCN(CC)CC",  # - Triethylamine
+    "c1ccccc1O",  # - Phenol
+    "CC(C)CC(=O)O",  # - Valeric acid
+    "CN1C=NC2=C1N=CN2",  # - Adenine
+    "O=C(O)C1=CC=CC=C1",  # - Benzoic acid
+    "C1CCCCC1",  # - Cyclohexane
+    "CC(=O)N1CCCCC1",  # - (Unnamed)
+]
+
+
+def _extract_smiles(smiles_input):
+    """
+    Normalize the Gradio input into a list of non-empty SMILES strings.
+    """
+    if smiles_input is None:
+        return []
+
+    # Handle text areas or other string-based inputs
+    if isinstance(smiles_input, str):
+        return [line.strip() for line in smiles_input.splitlines() if line.strip()]
+
+    smiles_strings = []
+    for row in smiles_input:
+        if isinstance(row, str):
+            candidate = row.strip()
+            if candidate:
+                smiles_strings.append(candidate)
+            continue
+
+        if not row:
+            continue
+        first_cell = row[0]
+        if isinstance(first_cell, str):
+            candidate = first_cell.strip()
+            if candidate:
+                smiles_strings.append(candidate)
+
+    return smiles_strings
+
+
+def render_images(smiles_input):
+    """
+    Converts SMILES strings into a list of PIL Images for gallery display.
+    Invalid SMILES entries are skipped.
+    """
+    smiles_strings = _extract_smiles(smiles_input)
+    gallery_items = []
+
+    for smiles in smiles_strings:
+        mol = Chem.MolFromSmiles(smiles)
+        if mol is None:
+            continue
+        image = Draw.MolToImage(mol, size=(300, 300))
+        gallery_items.append((image, smiles))
+
+    return gallery_items
+
+
+def render_svgs(smiles_input):
+    """
+    Converts SMILES strings into SVG representations of the molecules.
+    Returns HTML containing all SVGs and error notices for invalid inputs.
+    """
+    smiles_strings = _extract_smiles(smiles_input)
+    svg_fragments = []
+    invalid_smiles = []
+
+    for smiles in smiles_strings:
+        mol = Chem.MolFromSmiles(smiles)
+        if mol is None:
+            invalid_smiles.append(smiles)
+            continue
+
+        drawer = rdMolDraw2D.MolDraw2DSVG(300, 300)
+        drawer.DrawMolecule(mol)
+        drawer.FinishDrawing()
+        svg = drawer.GetDrawingText().replace("svg:", "")
+        svg_fragments.append(
+            f"<figure style='display:inline-block;margin:0 16px 16px 0;'>"
+            f"<figcaption style='text-align:center;font-family:monospace;margin-bottom:8px;'>{smiles}</figcaption>"
+            f"{svg}"
+            "</figure>"
+        )
+
+    html_parts = []
+    if svg_fragments:
+        html_parts.append("<div>" + "".join(svg_fragments) + "</div>")
+
+    if invalid_smiles:
+        invalid_list_items = "".join(f"<li>{smiles}</li>" for smiles in invalid_smiles)
+        html_parts.append(
+            "<div style='color:#b00020;margin-top:12px;'>"
+            "<strong>Invalid SMILES strings:</strong>"
+            f"<ul style='margin:4px 0 0 16px;'>{invalid_list_items}</ul>"
+            "</div>"
+        )
+
+    return "".join(html_parts)
+
+# --- Gradio Interface ---
+with gr.Blocks() as demo:
+    gr.Markdown("## Molecule Renderer")
+    gr.Markdown("Enter one or more SMILES strings to visualize the molecules.")
+
+    with gr.Row():
+        smiles_input = gr.DataFrame(
+            value=[[smiles] for smiles in list_smiles],
+            headers=["SMILES"],
+            label="SMILES Strings",
+            row_count=(len(list_smiles), "dynamic"),
+            col_count=1,
+            type="array",
+            wrap=True,
+        )
+        render_image_button = gr.Button("Render Image")
+        render_svg_button = gr.Button("Render SVG")
+
+    gr.Markdown("#### Image")
+    image_output = gr.Gallery(label="Molecule Structures")
+
+    gr.Markdown("#### SVG")
+    svg_output = gr.HTML(label="SVG Output")
+
+    # Separate actions for independent rendering
+    render_image_button.click(
+        fn=render_images,
+        inputs=smiles_input,
+        outputs=image_output,
+    )
+
+    render_svg_button.click(
+        fn=render_svgs,
+        inputs=smiles_input,
+        outputs=svg_output,
+    )
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,3 @@
+gradio[oauth]==5.49.1
+huggingface_hub==0.35.3
+rdkit==2025.9.1

run.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+"""
+HITL Drug Discovery Application Launcher
+
+This script launches the modular drug discovery application.
+It handles virtual environment activation and provides clear feedback.
+"""
+
+import sys
+import os
+import subprocess
+from pathlib import Path
+
+def check_virtual_env():
+    """Check if we're in a virtual environment."""
+    return hasattr(sys, 'real_prefix') or (hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix)
+
+def activate_venv_and_run():
+    """Activate virtual environment and run the application."""
+    project_dir = Path(__file__).parent
+    venv_path = project_dir / "venv"
+    
+    if not venv_path.exists():
+        print("❌ Virtual environment not found!")
+        print("Please run: python -m venv venv")
+        print("Then: source venv/bin/activate")
+        print("Finally: pip install -r requirements.txt")
+        return False
+    
+    # Try to run with virtual environment
+    try:
+        if os.name == 'nt':  # Windows
+            activate_script = venv_path / "Scripts" / "activate.bat"
+            python_exe = venv_path / "Scripts" / "python.exe"
+        else:  # Unix/Linux/macOS
+            activate_script = venv_path / "bin" / "activate"
+            python_exe = venv_path / "bin" / "python"
+        
+        if python_exe.exists():
+            print("🚀 Starting HITL Drug Discovery (Modular Version)...")
+            print("📍 Using virtual environment:", venv_path)
+            print("🌐 Application will be available at: http://localhost:7860")
+            print("⏹️  Press Ctrl+C to stop the application")
+            print("-" * 60)
+            
+            # Run the application
+            subprocess.run([str(python_exe), "app.py"], cwd=project_dir)
+            return True
+        else:
+            print("❌ Python executable not found in virtual environment!")
+            return False
+            
+    except Exception as e:
+        print(f"❌ Error running application: {e}")
+        return False
+
+def main():
+    """Main launcher function."""
+    print("🧬 HITL Drug Discovery Application Launcher")
+    print("=" * 50)
+    
+    if check_virtual_env():
+        print("✅ Virtual environment detected")
+        print("🚀 Starting application...")
+        try:
+            import app
+            print("🌐 Application available at: http://localhost:7860")
+            print("⏹️  Press Ctrl+C to stop")
+        except ImportError as e:
+            print(f"❌ Import error: {e}")
+            print("💡 Try running: pip install -r requirements.txt")
+        except Exception as e:
+            print(f"❌ Error: {e}")
+    else:
+        print("⚠️  No virtual environment detected")
+        print("🔄 Attempting to activate virtual environment...")
+        if not activate_venv_and_run():
+            print("\n💡 Manual setup required:")
+            print("1. python -m venv venv")
+            print("2. source venv/bin/activate  # (or venv\\Scripts\\activate on Windows)")
+            print("3. pip install -r requirements.txt")
+            print("4. python app.py")
+
+if __name__ == "__main__":
+    main()

smiles_to_csv.py

@@ -0,0 +1,25 @@
+import base64, io, csv
+from rdkit import Chem
+from rdkit.Chem import Draw
+from molecule_render_demo import list_smiles  # imports SMILES list
+
+def smiles_to_base64(smiles):
+    mol = Chem.MolFromSmiles(smiles)
+    if mol is None:
+        return None
+    img = Draw.MolToImage(mol, size=(300, 300))
+    buffer = io.BytesIO()
+    img.save(buffer, format="PNG")
+    return base64.b64encode(buffer.getvalue()).decode("utf-8")
+
+def export_to_csv(csv_filename="molecule_gallery.csv"):
+    with open(csv_filename, "w", newline="", encoding="utf-8") as f:
+        writer = csv.writer(f)
+        writer.writerow(["SMILES", "ImageBase64"])
+        for smiles in list_smiles:
+            encoded = smiles_to_base64(smiles)
+            writer.writerow([smiles, encoded or "INVALID_SMILES"])
+            print(f"Successfully processed {smiles} to {csv_filename}")
+
+if __name__ == "__main__":
+    export_to_csv()

src/__init__.py

@@ -0,0 +1,9 @@
+"""
+HITL Drug Discovery Application
+
+A modular drug discovery application with AI-powered structure generation
+and molecular analysis capabilities.
+"""
+
+__version__ = "1.0.0"
+__author__ = "HITL Drug Discovery Team"

src/ai/__init__.py

@@ -0,0 +1,20 @@
+"""
+AI Services Module
+
+This module contains AI-powered features including
+chat responses and structure generation.
+"""
+
+from .services import (
+    respond,
+    generate_ai_structures,
+    parse_ai_structures,
+    handle_structure_chat
+)
+
+__all__ = [
+    'respond',
+    'generate_ai_structures',
+    'parse_ai_structures',
+    'handle_structure_chat'
+]

src/ai/services.py

@@ -0,0 +1,163 @@
+"""
+AI Services Module
+
+This module handles AI-powered features including
+chat responses and structure generation.
+"""
+
+from huggingface_hub import InferenceClient
+from rdkit import Chem
+from rdkit.Chem import Draw
+
+
+def respond(
+    message,
+    history: list[dict[str, str]],
+    system_message,
+    max_tokens,
+    temperature,
+    top_p,
+    hf_token: str,
+):
+    """
+    Enhanced drug discovery chatbot with molecular property integration.
+    """
+    client = InferenceClient(token=hf_token, model="openai/gpt-oss-20b")
+
+    # Enhanced system message for drug discovery
+    enhanced_system_message = f"""{system_message}
+
+You are an expert medicinal chemist and drug discovery specialist. You help researchers understand:
+- Molecular properties and drug-likeness
+- Structure-activity relationships (SAR)
+- ADMET properties (Absorption, Distribution, Metabolism, Excretion, Toxicity)
+- Drug design principles and optimization strategies
+- Chemical synthesis and medicinal chemistry
+
+When discussing molecules, consider their molecular weight, LogP, hydrogen bonding, and other key properties. Reference the molecular gallery below for visual context."""
+
+    messages = [{"role": "system", "content": enhanced_system_message}]
+    messages.extend(history)
+    messages.append({"role": "user", "content": message})
+
+    response = ""
+
+    for message in client.chat_completion(
+        messages,
+        max_tokens=max_tokens,
+        stream=True,
+        temperature=temperature,
+        top_p=top_p,
+    ):
+        choices = message.choices
+        token = ""
+        if len(choices) and choices[0].delta.content:
+            token = choices[0].delta.content
+
+        response += token
+        yield response
+
+
+def generate_ai_structures(message, history, selected_smiles, hf_token: str):
+    """Generate new structures using AI based on user request and selected molecule."""
+    if not message.strip():
+        return history, []
+    
+    client = InferenceClient(token=hf_token, model="openai/gpt-oss-20b")
+    
+    # Enhanced system message for structure generation
+    system_message = f"""You are an expert medicinal chemist and drug discovery specialist. You help generate new chemical structures based on user requests and existing molecules.
+
+Current selected molecule SMILES: {selected_smiles}
+
+Your task is to:
+1. Understand the user's request for structure modifications
+2. Generate 3-6 new SMILES strings that meet their requirements
+3. Provide brief explanations for each generated structure
+4. Consider drug-likeness, ADMET properties, and medicinal chemistry principles
+
+Format your response as:
+STRUCTURE 1: [SMILES] - [Brief explanation]
+STRUCTURE 2: [SMILES] - [Brief explanation]
+etc.
+
+Focus on practical, synthesizable structures that address the user's specific request."""
+
+    messages = [{"role": "system", "content": system_message}]
+    messages.extend(history)
+    messages.append({"role": "user", "content": message})
+
+    response = ""
+    for message_chunk in client.chat_completion(
+        messages,
+        max_tokens=512,
+        stream=True,
+        temperature=0.7,
+        top_p=0.9,
+    ):
+        choices = message_chunk.choices
+        token = ""
+        if len(choices) and choices[0].delta.content:
+            token = choices[0].delta.content
+        response += token
+        yield response
+
+
+def parse_ai_structures(ai_response, selected_smiles):
+    """Parse AI response to extract SMILES strings and generate images."""
+    structures = []
+    lines = ai_response.split('\n')
+    
+    for line in lines:
+        if 'STRUCTURE' in line.upper() and ':' in line:
+            try:
+                # Extract SMILES from lines like "STRUCTURE 1: CCO - ethanol"
+                parts = line.split(':', 1)
+                if len(parts) > 1:
+                    smiles_part = parts[1].split('-')[0].strip()
+                    # Clean up the SMILES string
+                    smiles = smiles_part.strip('[]()').strip()
+                    
+                    # Validate and generate image
+                    mol = Chem.MolFromSmiles(smiles)
+                    if mol:
+                        img = Draw.MolToImage(mol, size=(150, 150), kekulize=True)
+                        structures.append((img, f"Generated: {smiles}"))
+            except:
+                continue
+    
+    # If no structures were parsed, generate some variations of the selected molecule
+    if not structures and selected_smiles:
+        try:
+            mol = Chem.MolFromSmiles(selected_smiles)
+            if mol:
+                # Generate a few variations with different sizes
+                for size in [(120, 120), (150, 150), (180, 180)]:
+                    img = Draw.MolToImage(mol, size=size, kekulize=True)
+                    structures.append((img, f"Variation: {selected_smiles}"))
+        except:
+            pass
+    
+    return structures
+
+
+def handle_structure_chat(message, history, selected_smiles, hf_token: str):
+    """Handle the structure generation chat."""
+    if not message.strip():
+        return history, []
+    
+    # Add user message to history
+    history.append({"role": "user", "content": message})
+    
+    # Generate AI response
+    ai_response = ""
+    for chunk in generate_ai_structures(message, history[:-1], selected_smiles, hf_token):
+        ai_response = chunk
+    
+    # Add AI response to history
+    history.append({"role": "assistant", "content": ai_response})
+    
+    # Parse and generate structure images
+    structures = parse_ai_structures(ai_response, selected_smiles)
+    
+    return history, structures

src/app.py

@@ -0,0 +1,247 @@
+"""
+Main Application Module
+
+This is the main entry point for the HITL Drug Discovery application.
+It orchestrates all the modules and creates the Gradio interface.
+"""
+
+import gradio as gr
+from .ui.components import (
+    create_molecular_analysis_tab,
+    create_chemical_variations_tab,
+    create_molecular_gallery_tab,
+    create_drug_library_tab,
+    create_new_experiment_tab
+)
+from .ui.handlers import VariationHandlers, BookmarkHandlers, AIHandler, create_quick_example_handlers
+from .molecules.analysis import analyze_molecule_image_only, validate_smiles_realtime, get_molecule_properties_for_hover
+from .molecules.variations import generate_molecule_images, generate_chemical_series_variations
+from .ai.services import respond, handle_structure_chat
+from .config.settings import (
+    DRUG_SMILES, COMMON_SMILES, CUSTOM_CSS, DEFAULT_SMILES,
+    DEFAULT_VARIATIONS_COUNT, AI_MODEL, AI_MAX_TOKENS, AI_TEMPERATURE, AI_TOP_P
+)
+
+
+def create_app():
+    """Create and configure the main Gradio application."""
+    
+    # Initialize handlers
+    variation_handlers = VariationHandlers()
+    bookmark_handlers = BookmarkHandlers()
+    ai_handler = AIHandler()
+    quick_handlers = create_quick_example_handlers()
+    
+    # Create the main interface
+    with gr.Blocks(title="HITL Drug Discovery", theme=gr.themes.Soft(), css=CUSTOM_CSS) as demo:
+        gr.Markdown("# 🧬 Human-in-the-Loop Drug Discovery")
+        gr.Markdown("Interactive molecular analysis and AI assistant for drug discovery research")
+        
+        # Create tabs
+        with gr.Tabs():
+            # Main Drug Discovery Tab (consolidated)
+            with gr.Tab("🧬 Drug Discovery Lab"):
+                variation_components = create_chemical_variations_tab()
+            
+            
+            # Molecular Gallery Tab
+            with gr.Tab("🧬 Molecular Gallery"):
+                gallery_components = create_molecular_gallery_tab()
+            
+            # Drug Discovery Library Tab
+            with gr.Tab("💊 Drug Discovery Library"):
+                drug_components = create_drug_library_tab()
+            
+            # Blank workspace tab for new experiments
+            with gr.Tab("🧪 New Experiment"):
+                new_experiment_components = create_new_experiment_tab()
+        
+        # Event handlers for consolidated Drug Discovery Lab Tab
+        # Molecular Analysis handlers
+        variation_components['variation_smiles_input'].change(
+            fn=validate_smiles_realtime,
+            inputs=variation_components['variation_smiles_input'],
+            outputs=[variation_components['validation_status'], variation_components['preview_image']]
+        )
+        
+        variation_components['analyze_btn'].click(
+            fn=variation_handlers.analyze_molecule_with_tooltip,
+            inputs=variation_components['variation_smiles_input'],
+            outputs=[variation_components['main_structure_display'], variation_components['properties_display']]
+        )
+        
+        # Quick example button handlers
+        example_buttons = [
+            'alanine_btn', 'aspirin_btn', 'ibuprofen_btn', 'caffeine_btn',
+            'glucose_btn', 'benzene_btn', 'glucose_btn2', 'ethanol_btn',
+            'water_btn', 'complex_btn1', 'complex_btn2', 'complex_btn3'
+        ]
+        
+        for btn_name in example_buttons:
+            if btn_name in variation_components:
+                handler_name = btn_name.replace('_btn', '_handler')
+                if handler_name in quick_handlers:
+                    variation_components[btn_name].click(
+                        fn=quick_handlers[handler_name],
+                        inputs=None,
+                        outputs=[
+                            variation_components['variation_smiles_input'],
+                            variation_components['main_structure_display'],
+                            variation_components['properties_display']
+                        ]
+                    )
+        
+        # Bookmark functionality
+        variation_components['bookmark_btn'].click(
+            fn=bookmark_handlers.bookmark_current_molecule,
+            inputs=[variation_components['variation_smiles_input'], variation_components['bookmark_name']],
+            outputs=[variation_components['bookmark_status'], gallery_components['bookmarked_gallery']]
+        )
+        
+        # Event handlers for Chemical Diagram Variations Tab
+        variation_components['generate_variations_btn'].click(
+            fn=variation_handlers.generate_variations_for_display,
+            inputs=[variation_components['variation_smiles_input'], variation_components['variation_count_slider']],
+            outputs=[
+                variation_components['variations_grid'],
+                variation_components['selected_smiles_display'],
+                variation_components['selected_style_display']
+            ]
+        )
+        
+        variation_components['clear_variations_btn'].click(
+            fn=variation_handlers.clear_variations,
+            inputs=None,
+            outputs=[
+                variation_components['variations_grid'],
+                variation_components['selected_smiles_display'],
+                variation_components['selected_style_display']
+            ]
+        )
+        
+        # Handle grid selection - try using change event instead of select
+        variation_components['variations_grid'].change(
+            fn=variation_handlers.select_variation,
+            inputs=None,
+            outputs=[
+                variation_components['main_structure_display'],
+                variation_components['selected_smiles_display'],
+                variation_components['selected_style_display'],
+                variation_components['properties_display']
+            ]
+        )
+        
+        # Navigation controls
+        variation_components['prev_page_btn'].click(
+            fn=lambda: variation_handlers.navigate_variations("prev"),
+            inputs=None,
+            outputs=[
+                variation_components['variations_grid'],
+                variation_components['page_info'],
+                variation_components['main_structure_display'],
+                variation_components['selected_smiles_display'],
+                variation_components['selected_style_display']
+            ]
+        )
+        
+        variation_components['next_page_btn'].click(
+            fn=lambda: variation_handlers.navigate_variations("next"),
+            inputs=None,
+            outputs=[
+                variation_components['variations_grid'],
+                variation_components['page_info'],
+                variation_components['main_structure_display'],
+                variation_components['selected_smiles_display'],
+                variation_components['selected_style_display']
+            ]
+        )
+        
+        # Update grid size when slider changes
+        variation_components['grid_size_slider'].change(
+            fn=lambda cols: gr.Gallery(columns=cols),
+            inputs=variation_components['grid_size_slider'],
+            outputs=variation_components['variations_grid']
+        )
+        
+        # Update variation count
+        variation_components['variation_count_slider'].change(
+            fn=variation_handlers.update_variation_count,
+            inputs=variation_components['variation_count_slider'],
+            outputs=variation_components['variation_count_slider']
+        )
+        
+        # Unified AI Chat handlers
+        variation_components['ai_send_btn'].click(
+            fn=ai_handler.handle_ai_chat,
+            inputs=[
+                variation_components['ai_chat_input'],
+                variation_components['ai_chatbot'],
+                variation_components['selected_smiles_display'],
+                variation_components['hf_token_input'],
+                variation_components['ai_temperature']
+            ],
+            outputs=[variation_components['ai_chatbot'], variation_components['ai_generated_grid']]
+        )
+        
+        variation_components['ai_chat_input'].submit(
+            fn=ai_handler.handle_ai_chat,
+            inputs=[
+                variation_components['ai_chat_input'],
+                variation_components['ai_chatbot'],
+                variation_components['selected_smiles_display'],
+                variation_components['hf_token_input'],
+                variation_components['ai_temperature']
+            ],
+            outputs=[variation_components['ai_chatbot'], variation_components['ai_generated_grid']]
+        )
+        
+        # Load default data
+        def load_default_molecule():
+            molecule_img = analyze_molecule_image_only(DEFAULT_SMILES)
+            tooltip_text = get_molecule_properties_for_hover(DEFAULT_SMILES)
+            return molecule_img, tooltip_text
+        
+        def load_default_variations():
+            return variation_handlers.generate_variations_for_display(DEFAULT_SMILES, DEFAULT_VARIATIONS_COUNT)
+        
+        def load_gallery_images():
+            return generate_molecule_images(COMMON_SMILES)
+        
+        def load_drug_images():
+            return generate_molecule_images(DRUG_SMILES)
+        
+        # Load default data on startup
+        demo.load(
+            fn=load_default_molecule,
+            inputs=None,
+            outputs=[variation_components['main_structure_display'], variation_components['properties_display']]
+        )
+        
+        demo.load(
+            fn=load_default_variations,
+            inputs=None,
+            outputs=[
+                variation_components['variations_grid'],
+                variation_components['selected_smiles_display'],
+                variation_components['selected_style_display']
+            ]
+        )
+        
+        demo.load(
+            fn=load_gallery_images,
+            inputs=None,
+            outputs=gallery_components['image_components']
+        )
+        
+        demo.load(
+            fn=load_drug_images,
+            inputs=None,
+            outputs=drug_components['drug_images']
+        )
+    
+    return demo
+
+
+if __name__ == "__main__":
+    app = create_app()
+    app.launch()

src/clm/model_new_torch.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:70c6b736e86fd787e5753f98490fed41ec83c13dcac42a6132c3202764cb112e
+size 51114556

src/config/__init__.py

@@ -0,0 +1,30 @@
+"""
+Configuration Module
+
+This module contains configuration settings and constants
+for the drug discovery application.
+"""
+
+from .settings import (
+    DRUG_SMILES,
+    COMMON_SMILES,
+    CUSTOM_CSS,
+    DEFAULT_SMILES,
+    DEFAULT_VARIATIONS_COUNT,
+    AI_MODEL,
+    AI_MAX_TOKENS,
+    AI_TEMPERATURE,
+    AI_TOP_P
+)
+
+__all__ = [
+    'DRUG_SMILES',
+    'COMMON_SMILES',
+    'CUSTOM_CSS',
+    'DEFAULT_SMILES',
+    'DEFAULT_VARIATIONS_COUNT',
+    'AI_MODEL',
+    'AI_MAX_TOKENS',
+    'AI_TEMPERATURE',
+    'AI_TOP_P'
+]

src/config/settings.py

@@ -0,0 +1,401 @@
+"""
+Configuration Settings Module
+
+This module contains configuration settings and constants
+for the drug discovery application.
+"""
+
+# Drug discovery molecules
+DRUG_SMILES = [
+    "CC1=CC=C(C=C1)C(C)NC(=O)C2=CC=C(C=C2)Cl",  # Ibuprofen
+    "CC1=CC=C(C=C1)C(C)NC(=O)C2=CC=C(C=C2)F",   # Flurbiprofen
+    "CC1=CC=C(C=C1)C(C)NC(=O)C2=CC=C(C=C2)Br",  # Bromfenac
+    "CC1=CC=C(C=C1)C(C)NC(=O)C2=CC=C(C=C2)I",   # Iodofenac
+    "CC1=CC=C(C=C1)C(C)NC(=O)C2=CC=C(C=C2)[N+](=O)[O-]",  # Nitrofenac
+]
+
+# Common drug discovery molecules
+COMMON_SMILES = [
+    "C[C@H](N)C(=O)O",  # Alanine (amino acid)
+    "CC(=O)OC1=CC=CC=C1C(=O)O",  # Aspirin (NSAID)
+    "CCN(CC)CC",  # Triethylamine (base)
+    "c1ccccc1O",  # Phenol (aromatic)
+    "CC(C)CC(=O)O",  # Valeric acid (fatty acid)
+    "CN1C=NC2=C1N=CN2",  # Adenine (nucleobase)
+    "O=C(O)C1=CC=CC=C1",  # Benzoic acid (aromatic acid)
+    "C1CCCCC1",  # Cyclohexane (cycloalkane)
+    "CC(=O)N1CCCCC1",  # N-methylpiperidine (amine)
+]
+
+# AI Model Configuration
+AI_MODEL = "openai/gpt-oss-20b"
+AI_MAX_TOKENS = 512
+AI_TEMPERATURE = 0.7
+AI_TOP_P = 0.9
+
+# UI Configuration
+DEFAULT_SMILES = "C[C@H](N)C(=O)O"  # Alanine
+DEFAULT_VARIATIONS_COUNT = 12
+DEFAULT_GRID_COLUMNS = 4
+MAX_GRID_COLUMNS = 8
+MIN_VARIATIONS = 6
+MAX_VARIATIONS = 24
+
+# Image Configuration
+MOLECULE_IMAGE_SIZE = (300, 300)
+PREVIEW_IMAGE_SIZE = (200, 200)
+GALLERY_IMAGE_SIZE = (200, 200)
+VARIATION_IMAGE_SIZES = [(150, 150), (180, 180), (200, 200), (160, 160)]
+
+# CSS Styling
+CUSTOM_CSS = """
+/* Full width layout */
+.gradio-container {
+    max-width: 100% !important;
+    width: 100% !important;
+}
+
+.gradio-container .container {
+    max-width: 100% !important;
+    width: 100% !important;
+}
+
+/* Ensure rows use full width */
+.gr-row {
+    width: 100% !important;
+    max-width: 100% !important;
+}
+
+.gr-column {
+    width: 100% !important;
+    max-width: 100% !important;
+}
+
+/* Make images responsive to zoom */
+.gr-image {
+    width: 100% !important;
+    height: auto !important;
+    max-width: 100% !important;
+    object-fit: contain !important;
+}
+
+/* Responsive text scaling */
+.gr-markdown {
+    width: 100% !important;
+    max-width: 100% !important;
+    word-wrap: break-word !important;
+    overflow-wrap: break-word !important;
+}
+
+/* Left column spacing */
+.gr-column:first-child {
+    padding-right: 20px;
+    min-width: 300px;
+}
+
+/* Right column spacing */
+.gr-column:last-child {
+    padding-left: 20px;
+    min-width: 400px;
+}
+#main_structure {
+    border: none;
+    border-radius: 12px;
+    background: transparent;
+    width: 100%;
+    max-width: 100%;
+    height: auto;
+    max-height: 350px;
+    overflow: hidden;
+    object-fit: contain;
+    margin: 5px 0;
+    /* Make responsive to zoom */
+    min-height: 200px;
+    resize: both;
+}
+
+/* Seamless properties display */
+.seamless-properties {
+    background: transparent;
+    border: none;
+    padding: 8px 0;
+    margin: 5px 0;
+    font-size: 13px;
+    color: #e2e8f0;
+    text-align: left;
+    line-height: 1.4;
+    /* Make responsive to zoom */
+    width: 100%;
+    max-width: 100%;
+    overflow-wrap: break-word;
+    word-wrap: break-word;
+}
+
+.seamless-properties h1, .seamless-properties h2, .seamless-properties h3 {
+    margin: 0 0 8px 0;
+    color: #f7fafc;
+    font-weight: bold;
+}
+
+.seamless-properties p {
+    margin: 4px 0;
+    color: #e2e8f0;
+}
+
+.seamless-properties ul {
+    margin: 4px 0;
+    padding-left: 20px;
+    color: #e2e8f0;
+}
+
+.seamless-properties li {
+    color: #e2e8f0;
+}
+
+.seamless-properties strong {
+    color: #f7fafc;
+    font-weight: bold;
+}
+
+.seamless-properties em {
+    color: #a0aec0;
+    font-style: italic;
+}
+
+#variations_gallery {
+    border: none;
+    border-radius: 12px;
+    background: transparent;
+    max-height: 300px;
+    overflow-y: auto;
+    margin: 5px 0;
+}
+
+#variations_container {
+    margin-top: 5px;
+}
+
+#variations_gallery .gallery-item {
+    border: 1px solid #4a5568;
+    border-radius: 8px;
+    margin: 3px;
+    transition: all 0.3s ease;
+    background: #1a202c;
+    /* Better aspect ratio for chemical structures */
+    aspect-ratio: 1.3 / 1;
+    min-width: 200px;
+    max-width: 250px;
+}
+
+#variations_gallery .gallery-item:hover {
+    border-color: #68d391;
+    transform: scale(1.05);
+    box-shadow: 0 4px 12px rgba(104, 211, 145, 0.3);
+    background: #2d3748;
+}
+
+/* Ensure images fill the wider cells properly */
+#variations_gallery .gallery-item img {
+    width: 100%;
+    height: 100%;
+    object-fit: contain;
+    border-radius: 6px;
+}
+
+#variations_container {
+    max-height: 600px;
+    overflow-y: auto;
+    padding: 10px;
+}
+
+#selected_smiles, #selected_style {
+    background: #f5f5f5;
+    border: 1px solid #ddd;
+    border-radius: 5px;
+}
+
+.page-info {
+    text-align: center;
+    font-weight: bold;
+    color: #666;
+}
+
+.grid-controls {
+    background: #f0f0f0;
+    padding: 10px;
+    border-radius: 8px;
+    margin: 10px 0;
+}
+
+/* Compact properties display */
+.compact-properties {
+    background: #2d3748;
+    border: 1px solid #4a5568;
+    border-radius: 8px;
+    padding: 15px;
+    margin: 10px 0;
+    font-size: 13px;
+    color: #e2e8f0 !important;
+    text-align: left;
+    min-height: 60px;
+    max-height: 200px;
+    overflow-y: auto;
+    line-height: 1.4;
+}
+
+.compact-properties h1, .compact-properties h2, .compact-properties h3 {
+    margin: 0 0 8px 0;
+    color: #f7fafc !important;
+    font-weight: bold;
+}
+
+.compact-properties p {
+    margin: 4px 0;
+    color: #e2e8f0 !important;
+}
+
+.compact-properties ul {
+    margin: 4px 0;
+    padding-left: 20px;
+    color: #e2e8f0 !important;
+}
+
+.compact-properties li {
+    color: #e2e8f0 !important;
+}
+
+.compact-properties strong {
+    color: #f7fafc !important;
+    font-weight: bold;
+}
+
+.compact-properties em {
+    color: #a0aec0 !important;
+    font-style: italic;
+}
+
+/* Force text visibility - override any conflicting styles */
+.compact-properties * {
+    color: #e2e8f0 !important;
+}
+
+.compact-properties h1, .compact-properties h2, .compact-properties h3, .compact-properties strong {
+    color: #f7fafc !important;
+}
+
+/* Ensure markdown content is visible */
+.compact-properties .markdown {
+    color: #e2e8f0 !important;
+}
+
+.compact-properties .markdown h1, .compact-properties .markdown h2, .compact-properties .markdown h3 {
+    color: #f7fafc !important;
+}
+
+.compact-properties .markdown strong {
+    color: #f7fafc !important;
+}
+
+/* Popup notification system */
+.notification-popup {
+    position: fixed;
+    top: 20px;
+    right: 20px;
+    background: #2d3748;
+    color: #e2e8f0;
+    padding: 12px 20px;
+    border-radius: 8px;
+    border-left: 4px solid #68d391;
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.3);
+    z-index: 1000;
+    font-size: 14px;
+    font-weight: 500;
+    max-width: 300px;
+    opacity: 0;
+    transform: translateX(100%);
+    transition: all 0.3s ease-in-out;
+}
+
+.notification-popup.show {
+    opacity: 1;
+    transform: translateX(0);
+}
+
+.notification-popup.error {
+    border-left-color: #f56565;
+}
+
+.notification-popup.warning {
+    border-left-color: #ed8936;
+}
+
+.notification-popup.info {
+    border-left-color: #4299e1;
+}
+
+/* Success notification */
+.notification-popup.success {
+    border-left-color: #68d391;
+}
+
+/* Auto-hide animation */
+.notification-popup.auto-hide {
+    animation: slideOut 0.3s ease-in-out 2.5s forwards;
+}
+
+@keyframes slideOut {
+    to {
+        opacity: 0;
+        transform: translateX(100%);
+    }
+}
+
+/* Spacer styling */
+.spacer {
+    margin: 20px 0;
+    opacity: 0.3;
+}
+
+/* Notification container */
+#notification-container {
+    position: fixed;
+    top: 20px;
+    right: 20px;
+    z-index: 1000;
+    pointer-events: none;
+}
+
+/* Temporary notification display */
+.temp-notification {
+    background: #2d3748;
+    color: #e2e8f0;
+    padding: 12px 20px;
+    border-radius: 8px;
+    border-left: 4px solid #68d391;
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.3);
+    margin-bottom: 10px;
+    font-size: 14px;
+    font-weight: 500;
+    max-width: 300px;
+    opacity: 1;
+    transform: translateX(0);
+    transition: all 0.3s ease-in-out;
+    pointer-events: auto;
+}
+
+.temp-notification.error {
+    border-left-color: #f56565;
+}
+
+.temp-notification.warning {
+    border-left-color: #ed8936;
+}
+
+.temp-notification.info {
+    border-left-color: #4299e1;
+}
+
+.temp-notification.success {
+    border-left-color: #68d391;
+}
+"""

src/molecules/__init__.py

@@ -0,0 +1,31 @@
+"""
+Molecular Analysis and Variations Module
+
+This module contains functions for molecular structure analysis,
+property calculations, and generation of molecular variations.
+"""
+
+from .analysis import (
+    calculate_molecular_properties,
+    generate_molecule_image,
+    validate_smiles,
+    validate_smiles_realtime,
+    analyze_molecule
+)
+
+from .variations import (
+    generate_molecule_variations,
+    generate_chemical_series_variations,
+    generate_molecule_images
+)
+
+__all__ = [
+    'calculate_molecular_properties',
+    'generate_molecule_image',
+    'validate_smiles',
+    'validate_smiles_realtime',
+    'analyze_molecule',
+    'generate_molecule_variations',
+    'generate_chemical_series_variations',
+    'generate_molecule_images'
+]

src/molecules/analysis.py

@@ -0,0 +1,247 @@
+"""
+Molecular Analysis Module
+
+This module contains functions for molecular structure analysis,
+property calculations, and drug-likeness assessment.
+"""
+
+from rdkit import Chem
+from rdkit.Chem import Draw, Descriptors, Crippen
+
+
+def calculate_molecular_properties(smiles):
+    """Calculate key molecular properties for drug discovery."""
+    mol = Chem.MolFromSmiles(smiles)
+    if not mol:
+        return None
+    
+    properties = {
+        'Molecular Weight': round(Descriptors.MolWt(mol), 2),
+        'LogP': round(Crippen.MolLogP(mol), 2),
+        'HBD': Descriptors.NumHDonors(mol),
+        'HBA': Descriptors.NumHAcceptors(mol),
+        'TPSA': round(Descriptors.TPSA(mol), 2),
+        'Rotatable Bonds': Descriptors.NumRotatableBonds(mol),
+        'Aromatic Rings': Descriptors.NumAromaticRings(mol),
+        'Heavy Atoms': mol.GetNumHeavyAtoms()
+    }
+    
+    # Lipinski's Rule of Five
+    lipinski_violations = 0
+    if properties['Molecular Weight'] > 500:
+        lipinski_violations += 1
+    if properties['LogP'] > 5:
+        lipinski_violations += 1
+    if properties['HBD'] > 5:
+        lipinski_violations += 1
+    if properties['HBA'] > 10:
+        lipinski_violations += 1
+    
+    properties['Lipinski Violations'] = lipinski_violations
+    properties['Drug-like'] = lipinski_violations <= 1
+    
+    return properties
+
+
+def generate_molecule_image(smiles, size=(300, 300)):
+    """Generate a molecular structure image from SMILES string."""
+    try:
+        mol = Chem.MolFromSmiles(smiles)
+        if not mol:
+            print(f"Failed to parse SMILES: {smiles}")
+            return None
+        
+        # Create a high-quality image
+        img = Draw.MolToImage(mol, size=size, kekulize=True)
+        if img is None:
+            print(f"Draw.MolToImage returned None for SMILES: {smiles}")
+            return None
+        
+        print(f"Generated image successfully: {size}, mode: {img.mode}")
+        return img
+    except Exception as e:
+        print(f"Error in generate_molecule_image: {e}")
+        return None
+
+
+def validate_smiles(smiles):
+    """Validate SMILES string and return error message if invalid."""
+    if not smiles or not smiles.strip():
+        return "Please enter a SMILES string"
+    
+    # Try to parse the SMILES
+    mol = Chem.MolFromSmiles(smiles.strip())
+    if not mol:
+        # Provide more helpful error messages based on common issues
+        error_msg = f"❌ **Invalid SMILES string:** `{smiles}`\n\n"
+        
+        # Check for specific common issues
+        if smiles.count('(') != smiles.count(')'):
+            error_msg += "🔍 **Issue detected:** Unmatched parentheses\n"
+        elif smiles.count('[') != smiles.count(']'):
+            error_msg += "🔍 **Issue detected:** Unmatched brackets\n"
+        elif any(char in smiles for char in ['@', '\\', '/']) and 'C' not in smiles:
+            error_msg += "🔍 **Issue detected:** Invalid stereochemistry notation\n"
+        else:
+            error_msg += "🔍 **Issue detected:** General syntax error\n"
+        
+        error_msg += "\n**💡 Tips for complex SMILES:**\n"
+        error_msg += "- Complex molecules are supported! The issue is likely syntax\n"
+        error_msg += "- Check parentheses and brackets are balanced\n"
+        error_msg += "- Verify ring closure numbers (e.g., C1CCCC1)\n"
+        error_msg += "- Use proper stereochemistry notation (@, @@, /, \\)\n"
+        error_msg += "- Try breaking complex molecules into smaller parts first\n\n"
+        error_msg += "**🧪 Examples of complex valid SMILES:**\n"
+        error_msg += "- `CC(=O)OC1=CC=CC=C1C(=O)O` (Aspirin)\n"
+        error_msg += "- `CN1C=NC2=C1C(=O)N(C(=O)N2C)C` (Caffeine)\n"
+        error_msg += "- `C([C@@H]1[C@H]([C@@H]([C@H]([C@H](O1)O)O)O)O)O` (Glucose)\n"
+        error_msg += "- `CC1([C@@H](N2[C@H](S1)[C@@H](C2=O)NC(=O)CC3=CC=CC=C3)C(=O)O)` (Penicillin)\n"
+        
+        return error_msg
+    
+    return None
+
+
+def validate_smiles_realtime(smiles):
+    """Real-time SMILES validation for user feedback."""
+    if not smiles or not smiles.strip():
+        return "✅ Ready to analyze", None
+    
+    validation_error = validate_smiles(smiles)
+    if validation_error:
+        return f"❌ Invalid SMILES", None
+    
+    # Try to generate a preview image
+    try:
+        mol = Chem.MolFromSmiles(smiles.strip())
+        if mol:
+            img = Draw.MolToImage(mol, size=(200, 200), kekulize=True)
+            return "✅ Valid SMILES", img
+    except:
+        pass
+    
+    return "✅ Valid SMILES", None
+
+
+def analyze_molecule(smiles):
+    """Analyze a molecule and return its properties with robust error handling."""
+    # Validate SMILES first
+    validation_error = validate_smiles(smiles)
+    if validation_error:
+        return validation_error, None
+    
+    # Calculate properties
+    properties = calculate_molecular_properties(smiles)
+    if not properties:
+        return "Error calculating molecular properties", None
+    
+    # Format the properties nicely - use raw string to prevent hyperlink conversion
+    result = f"**Molecular Analysis for:**\n```\n{smiles}\n```\n\n"
+    result += "**Basic Properties:**\n"
+    result += f"- Molecular Weight: {properties['Molecular Weight']} g/mol\n"
+    result += f"- LogP: {properties['LogP']}\n"
+    result += f"- TPSA: {properties['TPSA']} Ų\n"
+    result += f"- Heavy Atoms: {properties['Heavy Atoms']}\n\n"
+    
+    result += "**Hydrogen Bonding:**\n"
+    result += f"- HBD (Donors): {properties['HBD']}\n"
+    result += f"- HBA (Acceptors): {properties['HBA']}\n\n"
+    
+    result += "**Structural Features:**\n"
+    result += f"- Rotatable Bonds: {properties['Rotatable Bonds']}\n"
+    result += f"- Aromatic Rings: {properties['Aromatic Rings']}\n\n"
+    
+    result += "**Drug-likeness:**\n"
+    result += f"- Lipinski Violations: {properties['Lipinski Violations']}/4\n"
+    result += f"- Drug-like: {'Yes' if properties['Drug-like'] else 'No'}\n"
+    
+    # Generate molecular structure image with error handling
+    try:
+        molecule_img = generate_molecule_image(smiles)
+        if not molecule_img:
+            result += "\n\n⚠️ **Warning:** Could not generate molecular structure image"
+    except Exception as e:
+        result += f"\n\n⚠️ **Warning:** Error generating molecular structure: {str(e)}"
+        molecule_img = None
+    
+    return result, molecule_img
+
+
+def analyze_molecule_image_only(smiles):
+    """Analyze a molecule and return only the image for compact UI."""
+    # Validate SMILES first
+    validation_error = validate_smiles(smiles)
+    if validation_error:
+        print(f"SMILES validation error: {validation_error}")
+        return None
+    
+    # Generate molecule image
+    try:
+        molecule_img = generate_molecule_image(smiles, size=(500, 400))
+        if molecule_img is None:
+            print(f"Failed to generate image for SMILES: {smiles}")
+            # Try with a different size as fallback
+            molecule_img = generate_molecule_image(smiles, size=(300, 300))
+            if molecule_img is None:
+                print(f"Fallback image generation also failed for SMILES: {smiles}")
+                return None
+        else:
+            print(f"Successfully generated image for SMILES: {smiles}")
+        return molecule_img
+    except Exception as e:
+        print(f"Error generating molecule image: {e}")
+        # Try to create a simple fallback image
+        try:
+            from PIL import Image, ImageDraw, ImageFont
+            # Create a simple text image as fallback
+            img = Image.new('RGB', (500, 400), color='white')
+            draw = ImageDraw.Draw(img)
+            try:
+                # Try to use a default font
+                font = ImageFont.load_default()
+            except:
+                font = None
+            
+            # Draw error message
+            text = f"Error generating molecule\nSMILES: {smiles[:50]}..."
+            draw.text((50, 200), text, fill='red', font=font)
+            return img
+        except:
+            return None
+
+
+def get_molecule_properties_for_hover(smiles):
+    """Get molecular properties formatted for hover tooltip."""
+    # Validate SMILES first
+    validation_error = validate_smiles(smiles)
+    if validation_error:
+        print(f"SMILES validation error in properties: {validation_error}")
+        return f"**Error:** {validation_error}"
+    
+    # Calculate properties
+    properties = calculate_molecular_properties(smiles)
+    if not properties:
+        print(f"Failed to calculate properties for SMILES: {smiles}")
+        return f"**Error:** Could not calculate molecular properties for {smiles}"
+    
+    # Format properties for display
+    hover_text = f"**Basic Properties:**\n"
+    hover_text += f"• Molecular Weight: {properties['Molecular Weight']} g/mol\n"
+    hover_text += f"• LogP: {properties['LogP']}\n"
+    hover_text += f"• TPSA: {properties['TPSA']} Ų\n"
+    hover_text += f"• Heavy Atoms: {properties['Heavy Atoms']}\n\n"
+    
+    hover_text += f"**Hydrogen Bonding:**\n"
+    hover_text += f"• HBD (Donors): {properties['HBD']}\n"
+    hover_text += f"• HBA (Acceptors): {properties['HBA']}\n\n"
+    
+    hover_text += f"**Structural Features:**\n"
+    hover_text += f"• Rotatable Bonds: {properties['Rotatable Bonds']}\n"
+    hover_text += f"• Aromatic Rings: {properties['Aromatic Rings']}\n\n"
+    
+    hover_text += f"**Drug-likeness:**\n"
+    hover_text += f"• Lipinski Violations: {properties['Lipinski Violations']}/4\n"
+    hover_text += f"• Drug-like: {'Yes' if properties['Drug-like'] else 'No'}"
+    
+    print(f"Generated properties text for SMILES: {smiles}")
+    return hover_text

src/molecules/variations.py

@@ -0,0 +1,116 @@
+"""
+Molecular Variations Module
+
+This module handles generation of multiple visualizations
+and variations of chemical structures.
+"""
+
+from rdkit import Chem
+from rdkit.Chem import Draw
+
+
+def generate_molecule_variations(base_smiles, num_variations=12):
+    """Generate multiple variations of a chemical structure for the grid display."""
+    mol = Chem.MolFromSmiles(base_smiles)
+    if not mol:
+        return []
+    
+    variations = []
+    
+    # Generate different rendering styles and sizes
+    sizes = [(150, 150), (180, 180), (200, 200), (160, 160)]
+    styles = [True, False]  # kekulize vs non-kekulize
+    
+    for i in range(num_variations):
+        size = sizes[i % len(sizes)]
+        kekulize = styles[i % len(styles)]
+        
+        try:
+            # Create variation with different rendering parameters
+            img = Draw.MolToImage(mol, size=size, kekulize=kekulize)
+            variations.append({
+                'image': img,
+                'smiles': base_smiles,
+                'variation_id': i + 1,
+                'size': size,
+                'kekulize': kekulize
+            })
+        except:
+            # Fallback to basic rendering
+            try:
+                img = Draw.MolToImage(mol, size=(150, 150), kekulize=True)
+                variations.append({
+                    'image': img,
+                    'smiles': base_smiles,
+                    'variation_id': i + 1,
+                    'size': (150, 150),
+                    'kekulize': True
+                })
+            except:
+                continue
+    
+    return variations
+
+
+def generate_chemical_series_variations(base_smiles):
+    """Generate a series of related chemical structures for drug discovery."""
+    mol = Chem.MolFromSmiles(base_smiles)
+    if not mol:
+        return []
+    
+    variations = []
+    
+    # Create different visualization styles
+    styles = [
+        {'size': (200, 200), 'kekulize': True, 'style': 'Standard'},
+        {'size': (180, 180), 'kekulize': False, 'style': 'Kekulé'},
+        {'size': (220, 220), 'kekulize': True, 'style': 'Large'},
+        {'size': (160, 160), 'kekulize': False, 'style': 'Compact'},
+        {'size': (200, 200), 'kekulize': True, 'style': 'Detailed'},
+        {'size': (190, 190), 'kekulize': False, 'style': 'Minimal'},
+        {'size': (210, 210), 'kekulize': True, 'style': 'Enhanced'},
+        {'size': (170, 170), 'kekulize': False, 'style': 'Focused'},
+        {'size': (200, 200), 'kekulize': True, 'style': 'Classic'},
+        {'size': (185, 185), 'kekulize': False, 'style': 'Modern'},
+        {'size': (195, 195), 'kekulize': True, 'style': 'Scientific'},
+        {'size': (175, 175), 'kekulize': False, 'style': 'Clean'}
+    ]
+    
+    for i, style_config in enumerate(styles):
+        try:
+            print(f"Generating variation {i+1}: {style_config['style']}")
+            img = Draw.MolToImage(mol, size=style_config['size'], kekulize=style_config['kekulize'])
+            print(f"Successfully generated image for {style_config['style']}, type: {type(img)}")
+            variations.append({
+                'image': img,
+                'smiles': base_smiles,
+                'variation_id': i + 1,
+                'style': style_config['style'],
+                'size': style_config['size'],
+                'kekulize': style_config['kekulize']
+            })
+        except Exception as e:
+            print(f"Failed to generate image for {style_config['style']}: {e}")
+            continue
+    
+    return variations
+
+
+def generate_molecule_images(smiles_list):
+    """Generate images for a list of SMILES strings."""
+    images = []
+    for smiles in smiles_list:
+        mol = Chem.MolFromSmiles(smiles)
+        if mol:
+            # Create a high-quality image with better rendering
+            img = Draw.MolToImage(mol, size=(200, 200), kekulize=True)
+            images.append(img)
+        else:
+            # Add a placeholder if SMILES is invalid
+            try:
+                from PIL import Image
+                images.append(Image.new('RGB', (200, 200), color='white'))
+            except ImportError:
+                # Fallback if PIL not available
+                images.append(None)
+    return images

src/ui/__init__.py

@@ -0,0 +1,29 @@
+"""
+UI Components and Handlers Module
+
+This module contains UI components, layouts, and event handlers
+for the drug discovery application.
+"""
+
+from .components import (
+    create_molecular_analysis_tab,
+    create_chemical_variations_tab,
+    create_molecular_gallery_tab,
+    create_drug_library_tab
+)
+
+from .handlers import (
+    VariationHandlers,
+    BookmarkHandlers,
+    create_quick_example_handlers
+)
+
+__all__ = [
+    'create_molecular_analysis_tab',
+    'create_chemical_variations_tab',
+    'create_molecular_gallery_tab',
+    'create_drug_library_tab',
+    'VariationHandlers',
+    'BookmarkHandlers',
+    'create_quick_example_handlers'
+]

src/ui/components.py

@@ -0,0 +1,473 @@
+"""
+UI Components Module
+
+This module contains reusable UI components and layouts
+for the drug discovery application.
+"""
+
+import gradio as gr
+from .handlers import VariationHandlers
+
+
+def create_molecular_analysis_tab():
+    """Create the molecular analysis tab components."""
+    with gr.Column(scale=1):
+        gr.Markdown("## 🔬 Molecular Analysis")
+        smiles_input = gr.Textbox(
+            label="Enter SMILES string",
+            placeholder="e.g., C[C@H](N)C(=O)O",
+            value="C[C@H](N)C(=O)O",
+            info="Enter a valid SMILES string for molecular analysis"
+        )
+        
+        # Real-time validation status
+        validation_status = gr.Markdown("✅ Ready to analyze")
+        preview_image = gr.Image(
+            label="Preview",
+            show_download_button=False,
+            width=200,
+            height=200,
+            visible=False
+        )
+        
+        # Quick access buttons for common molecules
+        gr.Markdown("### Quick Examples")
+        with gr.Row():
+            alanine_btn = gr.Button("Alanine", size="sm")
+            aspirin_btn = gr.Button("Aspirin", size="sm")
+            ibuprofen_btn = gr.Button("Ibuprofen", size="sm")
+        
+        with gr.Row():
+            caffeine_btn = gr.Button("Caffeine", size="sm")
+            glucose_btn = gr.Button("Methanol", size="sm")
+            benzene_btn = gr.Button("Benzene", size="sm")
+        
+        with gr.Row():
+            glucose_btn2 = gr.Button("Acetone", size="sm")
+            ethanol_btn = gr.Button("Ethanol", size="sm")
+            water_btn = gr.Button("Water", size="sm")
+        
+        with gr.Row():
+            complex_btn1 = gr.Button("Glucose", size="sm")
+            complex_btn2 = gr.Button("Cholesterol", size="sm")
+            complex_btn3 = gr.Button("Penicillin", size="sm")
+        
+        analyze_btn = gr.Button("🔍 Analyze Molecule", variant="primary", size="lg")
+        
+        # Bookmark functionality
+        with gr.Row():
+            bookmark_name = gr.Textbox(
+                placeholder="Enter molecule name (optional)",
+                label="Molecule Name",
+                scale=2
+            )
+            bookmark_btn = gr.Button("🔖 Bookmark", variant="secondary", size="sm", scale=1)
+        
+        bookmark_status = gr.Markdown("")
+        
+        gr.Markdown("### 📊 Analysis Results")
+        analysis_output = gr.Markdown()
+    
+    with gr.Column(scale=1):
+        gr.Markdown("### 🧪 Molecular Structure")
+        molecule_image = gr.Image(
+            label="Chemical Structure",
+            show_download_button=False,
+            width=400,
+            height=400
+        )
+    
+    return {
+        'smiles_input': smiles_input,
+        'validation_status': validation_status,
+        'preview_image': preview_image,
+        'alanine_btn': alanine_btn,
+        'aspirin_btn': aspirin_btn,
+        'ibuprofen_btn': ibuprofen_btn,
+        'caffeine_btn': caffeine_btn,
+        'glucose_btn': glucose_btn,
+        'benzene_btn': benzene_btn,
+        'glucose_btn2': glucose_btn2,
+        'ethanol_btn': ethanol_btn,
+        'water_btn': water_btn,
+        'complex_btn1': complex_btn1,
+        'complex_btn2': complex_btn2,
+        'complex_btn3': complex_btn3,
+        'analyze_btn': analyze_btn,
+        'bookmark_name': bookmark_name,
+        'bookmark_btn': bookmark_btn,
+        'bookmark_status': bookmark_status,
+        'analysis_output': analysis_output,
+        'molecule_image': molecule_image
+    }
+
+
+def create_chemical_variations_tab():
+    """Create the consolidated drug discovery tab with molecular analysis and variations."""
+    # Add notification container
+    gr.HTML("""
+    <div id="notification-container"></div>
+    <script>
+    function showNotification(message, type = 'success', duration = 2000) {
+        // Remove existing notifications
+        const container = document.getElementById('notification-container');
+        container.innerHTML = '';
+        
+        // Create notification element
+        const notification = document.createElement('div');
+        notification.className = `temp-notification ${type}`;
+        notification.textContent = message;
+        
+        // Add to container
+        container.appendChild(notification);
+        
+        // Auto-remove after duration
+        setTimeout(() => {
+            if (notification.parentNode) {
+                notification.style.opacity = '0';
+                notification.style.transform = 'translateX(100%)';
+                setTimeout(() => {
+                    if (notification.parentNode) {
+                        notification.remove();
+                    }
+                }, 300);
+            }
+        }, duration);
+    }
+    
+    // Listen for validation status changes
+    document.addEventListener('DOMContentLoaded', function() {
+        const validationStatus = document.getElementById('validation_status');
+        if (validationStatus) {
+            const observer = new MutationObserver(function(mutations) {
+                mutations.forEach(function(mutation) {
+                    if (mutation.type === 'childList' || mutation.type === 'characterData') {
+                        const text = validationStatus.textContent || validationStatus.innerText;
+                        if (text && text.trim()) {
+                            if (text.includes('✅') && text.includes('Ready to analyze')) {
+                                showNotification('✅ Ready to analyze', 'success');
+                            } else if (text.includes('✅') && text.includes('Valid SMILES')) {
+                                showNotification('✅ Valid SMILES', 'success');
+                            } else if (text.includes('❌')) {
+                                showNotification('❌ Invalid SMILES', 'error');
+                            }
+                        }
+                    }
+                });
+            });
+            observer.observe(validationStatus, { childList: true, characterData: true, subtree: true });
+        }
+    });
+    </script>
+    """, visible=False)
+    
+    with gr.Row():
+        with gr.Column(scale=3):
+            # Left side: Molecular Analysis
+            variation_smiles_input = gr.Textbox(
+                label="Enter SMILES string",
+                placeholder="e.g., C[C@H](N)C(=O)O",
+                value="C[C@H](N)C(=O)O",
+                info="Enter a valid SMILES string for molecular analysis"
+            )
+            
+            # Hidden validation status for popup notifications
+            validation_status = gr.Markdown(
+                value="",
+                visible=False,
+                elem_id="validation_status"
+            )
+            preview_image = gr.Image(
+                label="Preview",
+                show_download_button=False,
+                width=200,
+                height=200,
+                visible=False
+            )
+            
+            # Generate variations controls - moved up for better UX
+            with gr.Row():
+                generate_variations_btn = gr.Button("🔄 Generate Variations", variant="primary")
+                clear_variations_btn = gr.Button("🗑️ Clear", variant="secondary")
+            
+            # Quick access buttons for common molecules
+            gr.Markdown("### Quick Examples")
+            with gr.Row():
+                alanine_btn = gr.Button("Alanine", size="sm")
+                aspirin_btn = gr.Button("Aspirin", size="sm")
+                ibuprofen_btn = gr.Button("Ibuprofen", size="sm")
+            
+            with gr.Row():
+                caffeine_btn = gr.Button("Caffeine", size="sm")
+                glucose_btn = gr.Button("Methanol", size="sm")
+                benzene_btn = gr.Button("Benzene", size="sm")
+            
+            with gr.Row():
+                glucose_btn2 = gr.Button("Acetone", size="sm")
+                ethanol_btn = gr.Button("Ethanol", size="sm")
+                water_btn = gr.Button("Water", size="sm")
+            
+            with gr.Row():
+                complex_btn1 = gr.Button("Glucose", size="sm")
+                complex_btn2 = gr.Button("Cholesterol", size="sm")
+                complex_btn3 = gr.Button("Penicillin", size="sm")
+            
+            analyze_btn = gr.Button("🔍 Analyze Molecule", variant="primary", size="lg")
+            
+            # Bookmark functionality
+            with gr.Row():
+                bookmark_name = gr.Textbox(
+                    placeholder="Enter molecule name (optional)",
+                    label="Molecule Name",
+                    scale=2
+                )
+                bookmark_btn = gr.Button("🔖 Bookmark", variant="secondary", size="sm", scale=1)
+            
+            bookmark_status = gr.Markdown("")
+            
+            # Hidden components for internal use (not displayed to user)
+            selected_smiles_display = gr.Textbox(
+                visible=False,
+                elem_id="selected_smiles"
+            )
+            selected_style_display = gr.Textbox(
+                visible=False,
+                elem_id="selected_style"
+            )
+            
+            # Enhanced AI Chat Interface
+            gr.Markdown("#### 🤖 AI Drug Discovery Assistant")
+            gr.Markdown("Ask the AI about molecular properties, generate new structures, or get drug discovery insights")
+            
+            # AI Settings
+            with gr.Row():
+                hf_token_input = gr.Textbox(
+                    label="Hugging Face Token",
+                    type="password",
+                    placeholder="Enter your Hugging Face token for AI features",
+                    scale=2
+                )
+                ai_temperature = gr.Slider(
+                    minimum=0.1,
+                    maximum=2.0,
+                    value=0.7,
+                    step=0.1,
+                    label="AI Temperature",
+                    scale=1
+                )
+            
+            # Main chat interface
+            ai_chatbot = gr.Chatbot(
+                label="AI Drug Discovery Chat",
+                height=400,
+                elem_id="ai_chatbot",
+                type="messages"
+            )
+            
+            with gr.Row():
+                ai_chat_input = gr.Textbox(
+                    placeholder="e.g., 'Explain the drug-likeness of this molecule' or 'Generate a more soluble derivative'",
+                    label="Your message",
+                    scale=4
+                )
+                ai_send_btn = gr.Button("Send", variant="primary", scale=1)
+            
+            # AI Generated Structures display
+            gr.Markdown("#### 🧬 AI Generated Structures")
+            ai_generated_grid = gr.Gallery(
+                label="AI Generated Structures",
+                show_label=False,
+                elem_id="ai_generated_grid",
+                columns=3,
+                rows=2,
+                height=200,
+                object_fit="contain",
+                allow_preview=True
+            )
+        
+        with gr.Column(scale=4):
+            # Right side: Main structure display + variations grid
+            main_structure_display = gr.Image(
+                show_download_button=False,
+                elem_id="main_structure"
+            )
+            
+            # Seamless properties display
+            properties_display = gr.Markdown(
+                value="*Click 'Analyze Molecule' or select a variation to see properties*",
+                elem_id="properties_display",
+                elem_classes="seamless-properties"
+            )
+            
+            # Seamless variations section
+            with gr.Column(elem_id="variations_container"):
+                variations_grid = gr.Gallery(
+                    show_label=False,
+                    elem_id="variations_gallery",
+                    columns=3,
+                    rows=3,
+                    height=300,
+                    object_fit="contain",
+                    allow_preview=True,
+                    show_share_button=False,
+                    show_download_button=False
+                )
+            
+            # Navigation controls
+            with gr.Row():
+                prev_page_btn = gr.Button("⬅️ Previous", size="sm")
+                page_info = gr.Markdown("Page 1 of 1", elem_classes="page-info")
+                next_page_btn = gr.Button("➡️ Next", size="sm")
+            
+            # Grid controls
+            with gr.Row(elem_classes="grid-controls"):
+                grid_size_slider = gr.Slider(
+                    minimum=4,
+                    maximum=8,
+                    value=4,
+                    step=1,
+                    label="Grid Columns",
+                    elem_id="grid_size_slider"
+                )
+                variation_count_slider = gr.Slider(
+                    minimum=6,
+                    maximum=24,
+                    value=12,
+                    step=6,
+                    label="Number of Variations",
+                    elem_id="variation_count_slider"
+                )
+    
+    return {
+        # Molecular Analysis components
+        'variation_smiles_input': variation_smiles_input,
+        'validation_status': validation_status,
+        'preview_image': preview_image,
+        'alanine_btn': alanine_btn,
+        'aspirin_btn': aspirin_btn,
+        'ibuprofen_btn': ibuprofen_btn,
+        'caffeine_btn': caffeine_btn,
+        'glucose_btn': glucose_btn,
+        'benzene_btn': benzene_btn,
+        'glucose_btn2': glucose_btn2,
+        'ethanol_btn': ethanol_btn,
+        'water_btn': water_btn,
+        'complex_btn1': complex_btn1,
+        'complex_btn2': complex_btn2,
+        'complex_btn3': complex_btn3,
+        'analyze_btn': analyze_btn,
+        'bookmark_name': bookmark_name,
+        'bookmark_btn': bookmark_btn,
+        'bookmark_status': bookmark_status,
+        'main_structure_display': main_structure_display,
+        'properties_display': properties_display,
+        
+        # Variations components
+        'generate_variations_btn': generate_variations_btn,
+        'clear_variations_btn': clear_variations_btn,
+        'selected_smiles_display': selected_smiles_display,
+        'selected_style_display': selected_style_display,
+        'variations_grid': variations_grid,
+        'prev_page_btn': prev_page_btn,
+        'page_info': page_info,
+        'next_page_btn': next_page_btn,
+        'grid_size_slider': grid_size_slider,
+        'variation_count_slider': variation_count_slider,
+        
+        # AI components
+        'hf_token_input': hf_token_input,
+        'ai_temperature': ai_temperature,
+        'ai_chatbot': ai_chatbot,
+        'ai_chat_input': ai_chat_input,
+        'ai_send_btn': ai_send_btn,
+        'ai_generated_grid': ai_generated_grid
+    }
+
+
+def create_molecular_gallery_tab():
+    """Create the molecular gallery tab components."""
+    gr.Markdown("### Common Drug Discovery Molecules")
+    image_components = []
+    
+    # Display images in a 3x3 grid
+    with gr.Row():
+        for row in range(3):
+            with gr.Row():
+                for col in range(3):
+                    idx = row * 3 + col
+                    img = gr.Image(
+                        show_download_button=False,
+                        width=200,
+                        height=200,
+                        label=f"Molecule {idx + 1}",
+                    )
+                    image_components.append(img)
+    
+    # Bookmarked molecules section
+    gr.Markdown("### 🔖 Your Bookmarked Molecules")
+    bookmarked_gallery = gr.Gallery(
+        label="Bookmarked Structures",
+        show_label=False,
+        elem_id="bookmarked_gallery",
+        columns=4,
+        rows=1,
+        height=200,
+        object_fit="contain"
+    )
+    
+    return {
+        'image_components': image_components,
+        'bookmarked_gallery': bookmarked_gallery
+    }
+
+
+def create_drug_library_tab():
+    """Create the drug discovery library tab components."""
+    gr.Markdown("### NSAID Drug Series")
+    drug_images = []
+    
+    # Display drug molecules
+    with gr.Row():
+        for i in range(3):  # First row
+            img = gr.Image(
+                show_download_button=False,
+                width=200,
+                height=200,
+                label=f"Drug {i + 1}",
+            )
+            drug_images.append(img)
+    
+    with gr.Row():
+        for i in range(2):  # Second row
+            img = gr.Image(
+                show_download_button=False,
+                width=200,
+                height=200,
+                label=f"Drug {i + 4}",
+            )
+            drug_images.append(img)
+    
+    return {
+        'drug_images': drug_images
+    }
+
+
+def create_new_experiment_tab():
+    """Create a blank workspace tab for new experiments."""
+    with gr.Column():
+        gr.Markdown("## 🧪 New Experiment Workspace")
+        gr.Markdown(
+            "This tab is intentionally left blank so you can prototype new "
+            "ideas without affecting the existing lab, gallery, or library views."
+        )
+        gr.Markdown(
+            "- Add new components here as you explore ideas\n"
+            "- Copy elements from other tabs if needed\n"
+            "- Wire up handlers in `src/app.py` once ready"
+        )
+        gr.HTML(
+            "<div style='border:1px dashed #bbb; padding:2rem; text-align:center;'>"
+            "Your custom UI goes here"
+            "</div>"
+        )
+    return {}

src/ui/handlers.py

@@ -0,0 +1,297 @@
+"""
+UI Handlers Module
+
+This module contains event handlers and business logic
+for the drug discovery application UI components.
+"""
+
+from ..molecules.analysis import analyze_molecule_image_only, validate_smiles_realtime, get_molecule_properties_for_hover
+from ..molecules.variations import generate_chemical_series_variations, generate_molecule_images
+from ..ai.services import respond, handle_structure_chat, parse_ai_structures
+
+
+class VariationHandlers:
+    """Handles variation-related functionality."""
+    
+    def __init__(self):
+        self.current_variations = []
+        self.current_page = 0
+        self.variations_per_page = 12
+    
+    def generate_variations_for_display(self, smiles, num_variations=12):
+        """Generate variations and format for gallery display."""
+        print(f"=== GENERATE_VARIATIONS_FOR_DISPLAY CALLED ===")
+        print(f"SMILES: {smiles}")
+        print(f"Num variations: {num_variations}")
+        
+        variations = generate_chemical_series_variations(smiles)
+        print(f"Generated {len(variations)} variations")
+        
+        self.current_variations = variations[:num_variations]
+        print(f"Stored {len(self.current_variations)} variations in current_variations")
+        
+        # Format for gallery display
+        gallery_items = []
+        for i, var in enumerate(self.current_variations):
+            print(f"Variation {i}: {var.get('style', 'Unknown')}, image type: {type(var.get('image', None))}")
+            gallery_items.append((var['image'], f"Style: {var['style']}"))
+        
+        result = (gallery_items, smiles, self.current_variations[0]['style'] if self.current_variations else "None")
+        print(f"Returning: {len(gallery_items)} gallery items, SMILES: {smiles}, style: {result[2]}")
+        print(f"=== GENERATE_VARIATIONS_FOR_DISPLAY COMPLETE ===")
+        
+        return result
+    
+    def select_variation(self, evt):
+        """Handle selection of a variation from the grid."""
+        try:
+            print(f"=== SELECT_VARIATION CALLED ===")
+            print(f"Event: {evt}, type: {type(evt)}")
+            print(f"Current variations count: {len(self.current_variations)}")
+            
+            # If event is None, try to get the first variation as default
+            if evt is None:
+                print("Event is None, trying to return first variation")
+                if self.current_variations:
+                    selected_var = self.current_variations[0]
+                    print(f"Using first variation: {selected_var.get('style', 'Unknown')}")
+                    properties_text = get_molecule_properties_for_hover(selected_var['smiles'])
+                    return selected_var['image'], selected_var['smiles'], selected_var['style'], properties_text
+                else:
+                    print("No variations available, returning empty")
+                    return None, "", "", ""
+            
+            # Handle both event object and direct index
+            if hasattr(evt, 'index'):
+                index = evt.index
+            elif isinstance(evt, (int, float)):
+                index = int(evt)
+            else:
+                print(f"Unexpected event type: {type(evt)}, value: {evt}")
+                # Try to return first variation as fallback
+                if self.current_variations:
+                    selected_var = self.current_variations[0]
+                    properties_text = get_molecule_properties_for_hover(selected_var['smiles'])
+                    return selected_var['image'], selected_var['smiles'], selected_var['style'], properties_text
+                return None, "", "", ""
+            
+            print(f"Selected index: {index}")
+            
+            if not self.current_variations or index >= len(self.current_variations):
+                print(f"No variations available or index {index} out of range (total: {len(self.current_variations)})")
+                # Try to return first variation as fallback
+                if self.current_variations:
+                    selected_var = self.current_variations[0]
+                    properties_text = get_molecule_properties_for_hover(selected_var['smiles'])
+                    return selected_var['image'], selected_var['smiles'], selected_var['style'], properties_text
+                return None, "", "", ""
+            
+            selected_var = self.current_variations[index]
+            print(f"Selected variation {index}: {selected_var.get('style', 'Unknown')}")
+            print(f"Selected variation image type: {type(selected_var['image'])}")
+            print(f"Selected variation SMILES: {selected_var['smiles']}")
+            
+            # Also update properties for the selected variation
+            print(f"Getting properties for SMILES: {selected_var['smiles']}")
+            properties_text = get_molecule_properties_for_hover(selected_var['smiles'])
+            print(f"Properties text length: {len(properties_text) if properties_text else 'None'}")
+            print(f"Properties text preview: {properties_text[:100] if properties_text else 'None'}...")
+            
+            result = (selected_var['image'], selected_var['smiles'], selected_var['style'], properties_text)
+            print(f"Returning result: {len(result)} items")
+            print(f"Image type: {type(result[0])}")
+            print(f"SMILES: {result[1]}")
+            print(f"Style: {result[2]}")
+            print(f"Properties length: {len(result[3]) if result[3] else 'None'}")
+            print(f"=== SELECT_VARIATION COMPLETE ===")
+            
+            return result
+        except Exception as e:
+            print(f"Error in select_variation: {e}")
+            import traceback
+            traceback.print_exc()
+            return None, "", "", ""
+    
+    def clear_variations(self):
+        """Clear all variations and reset display."""
+        self.current_variations = []
+        self.current_page = 0
+        return [], "", ""
+    
+    def navigate_variations(self, direction):
+        """Navigate through variations pages."""
+        if not self.current_variations:
+            return [], "Page 1 of 1", None, "", ""
+        
+        total_pages = (len(self.current_variations) + self.variations_per_page - 1) // self.variations_per_page
+        
+        if direction == "next":
+            self.current_page = min(self.current_page + 1, total_pages - 1)
+        elif direction == "prev":
+            self.current_page = max(self.current_page - 1, 0)
+        
+        # Get variations for current page
+        start_idx = self.current_page * self.variations_per_page
+        end_idx = min(start_idx + self.variations_per_page, len(self.current_variations))
+        page_variations = self.current_variations[start_idx:end_idx]
+        
+        # Format for gallery display
+        gallery_items = []
+        for var in page_variations:
+            gallery_items.append((var['image'], f"Style: {var['style']}"))
+        
+        page_info = f"Page {self.current_page + 1} of {total_pages}"
+        
+        return gallery_items, page_info, page_variations[0]['image'] if page_variations else None, page_variations[0]['smiles'] if page_variations else "", page_variations[0]['style'] if page_variations else ""
+    
+    def update_variation_count(self, count):
+        """Update the number of variations to generate."""
+        self.variations_per_page = count
+        return count
+    
+    def analyze_molecule_with_tooltip(self, smiles):
+        """Analyze molecule and return image with tooltip data."""
+        molecule_img = analyze_molecule_image_only(smiles)
+        tooltip_text = get_molecule_properties_for_hover(smiles)
+        
+        # For now, we'll return the image and tooltip text separately
+        # The tooltip will be handled by JavaScript or CSS
+        return molecule_img, tooltip_text
+
+
+class BookmarkHandlers:
+    """Handles bookmark functionality."""
+    
+    def __init__(self):
+        self.bookmarked_molecules = []
+    
+    def bookmark_molecule(self, smiles, molecule_name=""):
+        """Add a molecule to the bookmarked collection."""
+        from rdkit import Chem
+        from rdkit.Chem import Draw
+        
+        # Validate SMILES first
+        mol = Chem.MolFromSmiles(smiles)
+        if not mol:
+            return "❌ Invalid SMILES string - cannot bookmark"
+        
+        # Check if already bookmarked
+        if smiles in [bm['smiles'] for bm in self.bookmarked_molecules]:
+            return "⚠️ Molecule already bookmarked"
+        
+        # Generate a name if not provided
+        if not molecule_name:
+            molecule_name = f"Bookmarked_{len(self.bookmarked_molecules) + 1}"
+        
+        # Add to bookmarks
+        self.bookmarked_molecules.append({
+            'smiles': smiles,
+            'name': molecule_name,
+            'timestamp': len(self.bookmarked_molecules) + 1  # Simple counter
+        })
+        
+        return f"✅ Bookmarked: {molecule_name}"
+    
+    def get_bookmarked_molecules(self):
+        """Get all bookmarked molecules for display."""
+        return self.bookmarked_molecules
+    
+    def remove_bookmark(self, smiles):
+        """Remove a molecule from bookmarks."""
+        self.bookmarked_molecules = [bm for bm in self.bookmarked_molecules if bm['smiles'] != smiles]
+        return "🗑️ Removed from bookmarks"
+    
+    def bookmark_current_molecule(self, smiles, name):
+        """Bookmark current molecule and update gallery."""
+        from rdkit import Chem
+        from rdkit.Chem import Draw
+        
+        result = self.bookmark_molecule(smiles, name)
+        # Update the bookmarked gallery
+        bookmarked_mols = self.get_bookmarked_molecules()
+        gallery_items = []
+        for mol in bookmarked_mols:
+            # Generate smaller images for gallery
+            mol_obj = Chem.MolFromSmiles(mol['smiles'])
+            if mol_obj:
+                img = Draw.MolToImage(mol_obj, size=(150, 150), kekulize=True)
+                gallery_items.append((img, f"{mol['name']}: {mol['smiles']}"))
+        return result, gallery_items
+
+
+class AIHandler:
+    """Handles AI chat functionality with both general questions and structure generation."""
+    
+    def __init__(self):
+        self.chat_history = []
+    
+    def handle_ai_chat(self, message, history, selected_smiles, hf_token, temperature):
+        """Handle AI chat with both general questions and structure generation."""
+        if not message.strip() or not hf_token.strip():
+            return history, []
+        
+        # Add user message to history
+        history.append({"role": "user", "content": message})
+        
+        # Determine if this is a structure generation request
+        structure_keywords = ['generate', 'create', 'modify', 'derivative', 'variant', 'structure']
+        is_structure_request = any(keyword in message.lower() for keyword in structure_keywords)
+        
+        if is_structure_request and selected_smiles:
+            # Handle structure generation
+            ai_response = ""
+            for chunk in respond(message, history[:-1], 
+                               "You are an expert medicinal chemist. Generate new chemical structures based on user requests.",
+                               512, temperature, 0.9, hf_token):
+                ai_response = chunk
+            
+            # Add AI response to history
+            history.append({"role": "assistant", "content": ai_response})
+            
+            # Parse and generate structure images
+            structures = parse_ai_structures(ai_response, selected_smiles)
+            
+            return history, structures
+        else:
+            # Handle general drug discovery questions
+            ai_response = ""
+            for chunk in respond(message, history[:-1],
+                               "You are an expert medicinal chemist and drug discovery specialist. Help with molecular analysis, drug design, and medicinal chemistry questions.",
+                               512, temperature, 0.9, hf_token):
+                ai_response = chunk
+            
+            # Add AI response to history
+            history.append({"role": "assistant", "content": ai_response})
+            
+            return history, []
+
+
+def create_quick_example_handlers():
+    """Create handlers for quick example buttons."""
+    examples = {
+        'alanine': "C[C@H](N)C(=O)O",
+        'aspirin': "CC(=O)OC1=CC=CC=C1C(=O)O",
+        'ibuprofen': "CC1=CC=C(C=C1)C(C)NC(=O)C2=CC=C(C=C2)Cl",
+        'caffeine': "CN1C=NC2=C1C(=O)N(C(=O)N2C)C",
+        'methanol': "CO",
+        'benzene': "c1ccccc1",
+        'acetone': "CC(=O)C",
+        'ethanol': "CCO",
+        'water': "O",
+        'glucose': "C([C@@H]1[C@H]([C@@H]([C@H]([C@H](O1)O)O)O)O)O",
+        'cholesterol': "C[C@H]1CC[C@H]2[C@@H](C)CC[C@H](O)[C@H]2CC[C@H]1O",
+        'penicillin': "CC1([C@@H](N2[C@H](S1)[C@@H](C2=O)NC(=O)CC3=CC=CC=C3)C(=O)O)"
+    }
+    
+    handlers = {}
+    for name, smiles in examples.items():
+        def create_handler(smiles):
+            def handler():
+                molecule_img = analyze_molecule_image_only(smiles)
+                tooltip_text = get_molecule_properties_for_hover(smiles)
+                return smiles, molecule_img, tooltip_text
+            return handler
+        
+        handlers[f'{name}_handler'] = create_handler(smiles)
+    
+    return handlers

test_error_handling.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+"""
+Test script for SMILES error handling and validation.
+"""
+
+from rdkit import Chem
+from rdkit.Chem import Draw
+
+def validate_smiles(smiles):
+    """Validate SMILES string and return error message if invalid."""
+    if not smiles or not smiles.strip():
+        return "Please enter a SMILES string"
+    
+    mol = Chem.MolFromSmiles(smiles.strip())
+    if not mol:
+        return f"Invalid SMILES string: '{smiles}'\n\n**Common issues:**\n- Unclosed parentheses or brackets\n- Invalid characters\n- Malformed ring notation\n- Incorrect stereochemistry notation\n\n**Try:**\n- Simple molecules first (e.g., 'CO' for methanol)\n- Check parentheses balance\n- Use standard SMILES notation"
+    
+    return None
+
+def test_smiles_validation():
+    """Test various SMILES strings for validation."""
+    
+    test_cases = [
+        # Valid SMILES
+        ("CO", "Methanol - should work"),
+        ("CCO", "Ethanol - should work"),
+        ("c1ccccc1", "Benzene - should work"),
+        ("C[C@H](N)C(=O)O", "Alanine - should work"),
+        
+        # Invalid SMILES
+        ("", "Empty string - should fail"),
+        ("invalid", "Invalid text - should fail"),
+        ("C([C@@H]1[C@H]([C@@H]([C@H]([C@H](O1)O)O)O)O", "Complex glucose - should fail"),
+        ("C(C", "Unclosed parentheses - should fail"),
+        ("C1C1", "Invalid ring - should fail"),
+        ("C[invalid]", "Invalid bracket - should fail"),
+    ]
+    
+    print("🧪 Testing SMILES Validation")
+    print("=" * 50)
+    
+    for smiles, description in test_cases:
+        print(f"\n📊 Testing: {description}")
+        print(f"SMILES: '{smiles}'")
+        
+        error = validate_smiles(smiles)
+        if error:
+            print(f"❌ Validation failed: {error[:100]}...")
+        else:
+            print("✅ Validation passed")
+        
+        print("-" * 30)
+
+if __name__ == "__main__":
+    test_smiles_validation()

test_molecule_image.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python3
+"""
+Test script for molecular structure image generation.
+"""
+
+from rdkit import Chem
+from rdkit.Chem import Draw
+
+def generate_molecule_image(smiles):
+    """Generate a molecular structure image from SMILES string."""
+    mol = Chem.MolFromSmiles(smiles)
+    if not mol:
+        return None
+    
+    # Create a high-quality image
+    img = Draw.MolToImage(mol, size=(300, 300), kekulize=True)
+    return img
+
+def test_molecule_images():
+    """Test molecular structure generation for various molecules."""
+    
+    test_molecules = [
+        ("CC", "Ethane"),
+        ("C[C@H](N)C(=O)O", "Alanine"),
+        ("CC(=O)OC1=CC=CC=C1C(=O)O", "Aspirin"),
+        ("CC1=CC=C(C=C1)C(C)NC(=O)C2=CC=C(C=C2)Cl", "Ibuprofen"),
+        ("invalid_smiles", "Invalid SMILES")
+    ]
+    
+    print("🧬 Testing Molecular Structure Generation")
+    print("=" * 50)
+    
+    for smiles, name in test_molecules:
+        print(f"\n📊 Testing: {name}")
+        print(f"SMILES: {smiles}")
+        
+        img = generate_molecule_image(smiles)
+        if img:
+            print(f"✅ Successfully generated {img.size[0]}x{img.size[1]} image")
+            # Save the image for verification
+            img.save(f"test_{name.replace(' ', '_').lower()}.png")
+            print(f"💾 Saved as test_{name.replace(' ', '_').lower()}.png")
+        else:
+            print("❌ Failed to generate image")
+        print("-" * 30)
+
+if __name__ == "__main__":
+    test_molecule_images()

test_variation_selection.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+"""
+Test script to debug variation selection issue
+"""
+
+import sys
+import os
+sys.path.append(os.path.join(os.path.dirname(__file__), 'src'))
+
+from src.molecules.variations import generate_chemical_series_variations
+from src.ui.handlers import VariationHandlers
+
+def test_variation_selection():
+    """Test the variation selection functionality"""
+    print("Testing variation selection...")
+    
+    # Test SMILES
+    test_smiles = "C[C@H](N)C(=O)O"
+    
+    # Generate variations
+    print(f"Generating variations for SMILES: {test_smiles}")
+    variations = generate_chemical_series_variations(test_smiles)
+    print(f"Generated {len(variations)} variations")
+    
+    if variations:
+        print(f"First variation structure: {variations[0].keys()}")
+        print(f"First variation image type: {type(variations[0]['image'])}")
+        print(f"First variation SMILES: {variations[0]['smiles']}")
+        print(f"First variation style: {variations[0]['style']}")
+    
+    # Test handler
+    handler = VariationHandlers()
+    handler.current_variations = variations
+    
+    # Test selection
+    print("\nTesting selection...")
+    result = handler.select_variation(0)  # Select first variation
+    print(f"Selection result: {result}")
+    print(f"Result image type: {type(result[0]) if result[0] else 'None'}")
+    print(f"Result SMILES: {result[1]}")
+    print(f"Result style: {result[2]}")
+
+if __name__ == "__main__":
+    test_variation_selection()