Update app.py

app.py

@@ -1,1589 +1,2 @@
-import os,sys
-import traceback  # 상단에 추가
-# install required packages
-os.system('pip install plotly')  # plotly 설치
-os.system('pip install matplotlib')  # matplotlib 설치
-os.system('pip install dgl==1.0.2+cu116 -f https://data.dgl.ai/wheels/cu116/repo.html')
-os.environ["DGLBACKEND"] = "pytorch"
-print('Modules installed')
-
-# 기본 args 설정
-if not os.path.exists('./tmp'):
-    os.makedirs('./tmp')
-
-if not os.path.exists('./tmp/args.json'):
-    default_args = {
-        'checkpoint': None,
-        'dump_trb': False,
-        'dump_args': True,
-        'save_best_plddt': True,
-        'T': 25,
-        'strand_bias': 0.0,
-        'loop_bias': 0.0,
-        'helix_bias': 0.0,
-        'd_t1d': 24,
-        'potentials': None,
-        'potential_scale': None,
-        'aa_composition': None
-    }
-    with open('./tmp/args.json', 'w') as f:
-        json.dump(default_args, f)
-
-# 체크포인트 파일 다운로드
-if not os.path.exists('./SEQDIFF_230205_dssp_hotspots_25mask_EQtasks_mod30.pt'):
-    print('Downloading model weights 1')
-    os.system('wget http://files.ipd.uw.edu/pub/sequence_diffusion/checkpoints/SEQDIFF_230205_dssp_hotspots_25mask_EQtasks_mod30.pt')
-    print('Successfully Downloaded')
-
-if not os.path.exists('./SEQDIFF_221219_equalTASKS_nostrSELFCOND_mod30.pt'):
-    print('Downloading model weights 2')
-    os.system('wget http://files.ipd.uw.edu/pub/sequence_diffusion/checkpoints/SEQDIFF_221219_equalTASKS_nostrSELFCOND_mod30.pt')
-    print('Successfully Downloaded')
-
-from openai import OpenAI
-import gradio as gr
-import json  # json 모듈 추가
-from datasets import load_dataset
-import plotly.graph_objects as go
-import numpy as np
-import py3Dmol
-from io import StringIO
-import json
-import secrets
-import copy
-import matplotlib.pyplot as plt
-from utils.sampler import HuggingFace_sampler
-from utils.parsers_inference import parse_pdb
-from model.util import writepdb
-from utils.inpainting_util import *
 import os
-
-# args 로드
-with open('./tmp/args.json', 'r') as f:
-    args = json.load(f)
-
-plt.rcParams.update({'font.size': 13})
-
-# manually set checkpoint to load
-args['checkpoint'] = None
-args['dump_trb'] = False
-args['dump_args'] = True
-args['save_best_plddt'] = True
-args['T'] = 25
-args['strand_bias'] = 0.0
-args['loop_bias'] = 0.0
-args['helix_bias'] = 0.0
-
-# Hugging Face 토큰 설정
-ACCESS_TOKEN = os.getenv("HF_TOKEN")
-if not ACCESS_TOKEN:
-    raise ValueError("HF_TOKEN not found in environment variables")
-
-# OpenAI 클라이언트 설정 (Hugging Face 엔드포인트 사용)
-client = OpenAI(
-    base_url="https://api-inference.huggingface.co/v1/",
-    api_key=ACCESS_TOKEN,
-)
-
-
-# 데이터셋 로드 및 구조 확인
-try:
-    ds = load_dataset("lamm-mit/protein_secondary_structure_from_PDB",
-                     token=ACCESS_TOKEN)
-    print("Dataset structure:", ds)
-    print("First entry example:", next(iter(ds['train'])))
-except Exception as e:
-    print(f"Dataset loading error: {str(e)}")
-    raise
-    
-def respond(
-    message,
-    history,
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-):
-    messages = [{"role": "system", "content": system_message}]
-
-    for msg in history:
-        messages.append({"role": "user", "content": msg[0]})
-        if msg[1]:
-            messages.append({"role": "assistant", "content": msg[1]})
-
-    messages.append({"role": "user", "content": message})
-
-    try:
-        response = ""
-        for chunk in client.chat.completions.create(
-            model="CohereForAI/c4ai-command-r-plus-08-2024",
-            max_tokens=max_tokens,
-            stream=True,
-            temperature=temperature,
-            top_p=top_p,
-            messages=messages,
-        ):
-            if hasattr(chunk.choices[0].delta, 'content'):
-                token = chunk.choices[0].delta.content
-                if token is not None:
-                    response += token
-                    yield [{"role": "user", "content": message},
-                          {"role": "assistant", "content": response}]
-        
-        return [{"role": "user", "content": message},
-                {"role": "assistant", "content": response}]
-    except Exception as e:
-        print(f"Error in respond: {str(e)}")
-        return [{"role": "user", "content": message},
-                {"role": "assistant", "content": f"오류가 발생했습니다: {str(e)}"}]
-
-def analyze_prompt(message):
-    """LLM을 사용하여 프롬프트 분석"""
-    try:
-        analysis_prompt = f"""
-        다음 요청을 분석하여 단백질 설계에 필요한 주요 특성을 추출하세요:
-        요청: {message}
-        
-        다음 항목들을 분석해주세요:
-        1. 주요 기능 (예: 치료, 결합, 촉매 등)
-        2. 목표 환경 (예: 세포막, 수용성, 등)
-        3. 필요한 구조적 특징
-        4. 크기 및 복잡도 요구사항
-        """
-        
-        response = client.chat.completions.create(
-            model="CohereForAI/c4ai-command-r-plus-08-2024",
-            messages=[{"role": "user", "content": analysis_prompt}],
-            temperature=0.7
-        )
-        
-        return response.choices[0].message.content
-    except Exception as e:
-        print(f"프롬프트 분석 중 오류: {str(e)}")
-        return None
-
-def search_protein_data(analysis, dataset):
-    """분석 결과를 바탕으로 데이터셋에서 유사한 구조 검색"""
-    try:
-        # 키워드 추출
-        keywords = extract_keywords(analysis)
-        print("Extracted keywords:", keywords)
-        
-        # 데이터셋 구조 확인
-        if not dataset or 'train' not in dataset:
-            print("Invalid dataset structure")
-            return []
-            
-        # 유사도 점수 계산
-        scored_entries = []
-        for entry in dataset['train']:
-            try:
-                score = calculate_similarity(keywords, entry)
-                scored_entries.append((score, entry))
-            except Exception as e:
-                print(f"Error processing entry: {str(e)}")
-                continue
-        
-        # 결과 정렬 및 반환
-        scored_entries.sort(reverse=True)
-        return scored_entries[:3]
-        
-    except Exception as e:
-        print(f"데이터 검색 중 오류: {str(e)}")
-        return []
-        
-def extract_parameters(analysis, similar_structures):
-    """분석 결과와 유사 구조를 바탕으로 생성 파라미터 결정"""
-    try:
-        # 기본 파라미터 템플릿
-        params = {
-            'sequence_length': 100,
-            'helix_bias': 0.02,
-            'strand_bias': 0.02,
-            'loop_bias': 0.1,
-            'hydrophobic_target_score': 0
-        }
-        
-        # 분석 결과에서 구조적 요구사항 파악
-        if "막 투과" in analysis or "소수성" in analysis:
-            params['hydrophobic_target_score'] = -2
-            params['helix_bias'] = 0.03
-        elif "수용성" in analysis or "가용성" in analysis:
-            params['hydrophobic_target_score'] = 2
-            params['loop_bias'] = 0.15
-            
-        # 유사 구조들의 특성 반영
-        if similar_structures:
-            avg_length = sum(len(s[1]['sequence']) for s in similar_structures) / len(similar_structures)
-            params['sequence_length'] = int(avg_length)
-            
-            # 구조적 특성 분석 및 반영
-            for _, structure in similar_structures:
-                if 'secondary_structure' in structure:
-                    helix_ratio = structure['secondary_structure'].count('H') / len(structure['secondary_structure'])
-                    sheet_ratio = structure['secondary_structure'].count('E') / len(structure['secondary_structure'])
-                    params['helix_bias'] = max(0.01, min(0.05, helix_ratio))
-                    params['strand_bias'] = max(0.01, min(0.05, sheet_ratio))
-        
-        return params
-    except Exception as e:
-        print(f"파라미터 추출 중 오류: {str(e)}")
-        return None
-
-def process_chat(message, history):
-    try:
-        if any(keyword in message.lower() for keyword in ['protein', 'generate', '단백질', '생성', '치료']):
-            # 1. LLM을 사용한 프롬프트 분석
-            analysis = analyze_prompt(message)
-            if not analysis:
-                return history + [
-                    {"role": "user", "content": message},
-                    {"role": "assistant", "content": "요청 분석에 실패했습니다."}
-                ]
-            
-            # 2. 유사 구조 검색
-            similar_structures = search_protein_data(analysis, ds)
-            if not similar_structures:
-                return history + [
-                    {"role": "user", "content": message},
-                    {"role": "assistant", "content": "적합한 참조 구조를 찾지 못했습니다."}
-                ]
-            
-            # 3. 생성 파라미터 결정
-            params = extract_parameters(analysis, similar_structures)
-            if not params:
-                return history + [
-                    {"role": "user", "content": message},
-                    {"role": "assistant", "content": "파라미터 설정에 실패했습니다."}
-                ]
-            
-            # 4. 단백질 생성
-            try:
-                protein_result = protein_diffusion_model(
-                    sequence=None,
-                    seq_len=params['sequence_length'],
-                    helix_bias=params['helix_bias'],
-                    strand_bias=params['strand_bias'],
-                    loop_bias=params['loop_bias'],
-                    secondary_structure=None,
-                    aa_bias=None,
-                    aa_bias_potential=None,
-                    num_steps="25",
-                    noise="normal",
-                    hydrophobic_target_score=str(params['hydrophobic_target_score']),
-                    hydrophobic_potential="2",
-                    contigs=None,
-                    pssm=None,
-                    seq_mask=None,
-                    str_mask=None,
-                    rewrite_pdb=None
-                )
-                
-                output_seq, output_pdb, structure_view, plddt_plot = next(protein_result)
-                
-                # 5. 결과 설명 생성
-                explanation = f"""
-                요청하신 기능에 맞는 단백질을 생성했습니다:
-                
-                분석된 요구사항:
-                {analysis}
-                
-                설계된 구조적 특징:
-                - 길이: {params['sequence_length']} 아미노산
-                - 알파 헬릭스 비율: {params['helix_bias']*100:.1f}%
-                - 베타 시트 비율: {params['strand_bias']*100:.1f}%
-                - 루프 구조 비율: {params['loop_bias']*100:.1f}%
-                - 소수성 점수: {params['hydrophobic_target_score']}
-                
-                참조된 유사 구조: {len(similar_structures)}개
-                
-                생성된 단백질의 3D 구조와 시퀀스를 확인하실 수 있습니다.
-                """
-                
-                # 6. 결과 저장
-                global current_protein_result
-                current_protein_result = {
-                    'sequence': output_seq,
-                    'pdb': output_pdb,
-                    'structure_view': structure_view,
-                    'plddt_plot': plddt_plot,
-                    'params': params
-                }
-                
-                return history + [
-                    {"role": "user", "content": message},
-                    {"role": "assistant", "content": explanation}
-                ]
-            
-            except Exception as e:
-                return history + [
-                    {"role": "user", "content": message},
-                    {"role": "assistant", "content": f"단백질 생성 중 오류가 발생했습니다: {str(e)}"}
-                ]
-        else:
-            return history + [
-                {"role": "user", "content": message},
-                {"role": "assistant", "content": "단백질 생성 관련 키워드를 포함해주세요."}
-            ]
-    except Exception as e:
-        return history + [
-            {"role": "user", "content": message},
-            {"role": "assistant", "content": f"처리 중 오류가 발생했습니다: {str(e)}"}
-        ]
-
-
-def generate_protein(params):
-    # 기존 protein_diffusion_model 함수 호출
-    result = protein_diffusion_model(
-        sequence=None,
-        seq_len=params['sequence_length'],
-        helix_bias=params['helix_bias'],
-        strand_bias=params['strand_bias'],
-        loop_bias=params['loop_bias'],
-        secondary_structure=None,
-        aa_bias=None,
-        aa_bias_potential=None,
-        num_steps="25",
-        noise="normal",
-        hydrophobic_target_score=str(params['hydrophobic_target_score']),
-        hydrophobic_potential="2",
-        contigs=None,
-        pssm=None,
-        seq_mask=None,
-        str_mask=None,
-        rewrite_pdb=None
-    )
-    return result
-
-def generate_explanation(result, params):
-    explanation = f"""
-    생성된 단백질 분석:
-    - 길이: {params['sequence_length']} 아미노산
-    - 구조적 특징:
-        * 알파 나선 비율: {params['helix_bias']*100}%
-        * 베타 시트 비율: {params['strand_bias']*100}%
-        * 루프 구조 비율: {params['loop_bias']*100}%
-    - 특수 기능: {result.get('special_features', '없음')}
-    """
-    return explanation
-
-# 체크포인트 파일 경로를 절대 경로로 수정
-def protein_diffusion_model(sequence, seq_len, helix_bias, strand_bias, loop_bias, 
-                    secondary_structure, aa_bias, aa_bias_potential, 
-                    num_steps, noise, hydrophobic_target_score, hydrophobic_potential,
-                    contigs, pssm, seq_mask, str_mask, rewrite_pdb):
-
-    
-    dssp_checkpoint = './SEQDIFF_230205_dssp_hotspots_25mask_EQtasks_mod30.pt'
-    og_checkpoint = './SEQDIFF_221219_equalTASKS_nostrSELFCOND_mod30.pt'
-
-    
-    # 체크포인트 파일 존재 확인
-    if not os.path.exists(dssp_checkpoint):
-        raise FileNotFoundError(f"DSSP checkpoint file not found at: {dssp_checkpoint}")
-    if not os.path.exists(og_checkpoint):
-        raise FileNotFoundError(f"OG checkpoint file not found at: {og_checkpoint}")
-    
-    model_args = copy.deepcopy(args)
-
-
-    # make sampler
-    S = HuggingFace_sampler(args=model_args)
-
-    # get random prefix 
-    S.out_prefix = './tmp/'+secrets.token_hex(nbytes=10).upper()
-
-    # set args
-    S.args['checkpoint'] = None
-    S.args['dump_trb'] = False
-    S.args['dump_args'] = True
-    S.args['save_best_plddt'] = True
-    S.args['T'] = 25
-    S.args['strand_bias'] = 0.0
-    S.args['loop_bias'] = 0.0
-    S.args['helix_bias'] = 0.0
-    S.args['potentials'] = None
-    S.args['potential_scale'] = None
-    S.args['aa_composition'] = None
-
-
-    # get sequence if entered and make sure all chars are valid
-    alt_aa_dict = {'B':['D','N'],'J':['I','L'],'U':['C'],'Z':['E','Q'],'O':['K']}
-    if sequence not in ['',None]:
-        L = len(sequence)
-        aa_seq = []
-        for aa in sequence.upper():
-            if aa in alt_aa_dict.keys():
-                aa_seq.append(np.random.choice(alt_aa_dict[aa]))
-            else:
-                aa_seq.append(aa)
-
-        S.args['sequence'] = aa_seq
-    elif contigs not in ['',None]:
-        S.args['contigs'] = [contigs]
-    else:
-        S.args['contigs'] = [f'{seq_len}']
-        L = int(seq_len)
-    
-    print('DEBUG: ',rewrite_pdb)
-    if rewrite_pdb not in ['',None]:
-        S.args['pdb'] = rewrite_pdb.name
-
-    if seq_mask not in ['',None]:
-        S.args['inpaint_seq'] = [seq_mask]
-    if str_mask not in ['',None]:
-        S.args['inpaint_str'] = [str_mask]
-
-    if secondary_structure in ['',None]:
-        secondary_structure = None
-    else:
-        secondary_structure = ''.join(['E' if x == 'S' else x for x in secondary_structure])
-        if L < len(secondary_structure):
-            secondary_structure = secondary_structure[:len(sequence)]
-        elif L == len(secondary_structure):
-            pass
-        else:
-            dseq = L - len(secondary_structure)
-            secondary_structure += secondary_structure[-1]*dseq
-    
-
-    # potentials
-    potential_list = []
-    potential_bias_list = []
-
-    if aa_bias not in ['',None]:
-        potential_list.append('aa_bias')
-        S.args['aa_composition'] = aa_bias
-        if aa_bias_potential in ['',None]:
-            aa_bias_potential = 3
-        potential_bias_list.append(str(aa_bias_potential))
-    '''
-    if target_charge not in ['',None]:
-        potential_list.append('charge')
-        if charge_potential in ['',None]:
-            charge_potential = 1
-        potential_bias_list.append(str(charge_potential))
-        S.args['target_charge'] = float(target_charge)
-        if target_ph in ['',None]:
-            target_ph = 7.4
-        S.args['target_pH'] = float(target_ph)
-    '''
-    
-    if hydrophobic_target_score not in ['',None]:
-        potential_list.append('hydrophobic')
-        S.args['hydrophobic_score'] = float(hydrophobic_target_score)
-        if hydrophobic_potential in ['',None]:
-            hydrophobic_potential = 3
-        potential_bias_list.append(str(hydrophobic_potential))
-    
-    if pssm not in ['',None]:
-        potential_list.append('PSSM')
-        potential_bias_list.append('5')
-        S.args['PSSM'] = pssm.name
-        
-
-    if len(potential_list) > 0:
-        S.args['potentials'] = ','.join(potential_list)
-        S.args['potential_scale'] = ','.join(potential_bias_list)
-
-
-    # normalise secondary_structure bias from range 0-0.3
-    S.args['secondary_structure'] = secondary_structure
-    S.args['helix_bias'] = helix_bias
-    S.args['strand_bias'] = strand_bias
-    S.args['loop_bias'] = loop_bias
-    
-    # set T
-    if num_steps in ['',None]:
-        S.args['T'] = 20
-    else:
-        S.args['T'] = int(num_steps)
-
-    # noise
-    if 'normal' in noise:
-        S.args['sample_distribution'] = noise
-        S.args['sample_distribution_gmm_means'] = [0]
-        S.args['sample_distribution_gmm_variances'] = [1]
-    elif 'gmm2' in noise:
-        S.args['sample_distribution'] = noise
-        S.args['sample_distribution_gmm_means'] = [-1,1]
-        S.args['sample_distribution_gmm_variances'] = [1,1]
-    elif 'gmm3' in noise:
-        S.args['sample_distribution'] = noise
-        S.args['sample_distribution_gmm_means'] = [-1,0,1]
-        S.args['sample_distribution_gmm_variances'] = [1,1,1]
-
-
-
-    if secondary_structure not in ['',None] or helix_bias+strand_bias+loop_bias > 0:
-        S.args['checkpoint'] = dssp_checkpoint
-        S.args['d_t1d'] = 29
-        print('using dssp checkpoint')
-    else:
-        S.args['checkpoint'] = og_checkpoint
-        S.args['d_t1d'] = 24
-        print('using og checkpoint')
-    
-
-    for k,v in S.args.items():
-        print(f"{k} --> {v}")
-    
-    # init S
-    S.model_init()
-    S.diffuser_init()
-    S.setup()
-
-    # sampling loop
-    plddt_data = []
-    for j in range(S.max_t):
-        print(f'on step {j}')
-        output_seq, output_pdb, plddt = S.take_step_get_outputs(j)
-        plddt_data.append(plddt)
-        yield output_seq, output_pdb, display_pdb(output_pdb), get_plddt_plot(plddt_data, S.max_t)
-    
-    output_seq, output_pdb, plddt = S.get_outputs()
- 
-    return output_seq, output_pdb, display_pdb(output_pdb), get_plddt_plot(plddt_data, S.max_t)
-
-def get_plddt_plot(plddt_data, max_t):
-    fig, ax = plt.subplots(figsize=(15,6))
-    x = list(range(1, len(plddt_data) + 1))
-    ax.plot(x, plddt_data, color='#661dbf', linewidth=3, marker='o')
-    ax.set_xticks(range(1, max_t + 1))
-    ax.set_yticks([i/10 for i in range(11)])  # 0부터 1까지
-    ax.set_ylim([0, 1])
-    ax.set_ylabel('model confidence (plddt)')
-    ax.set_xlabel('diffusion steps (t)')
-    plt.close()  # 메모리 관리를 위해 닫기
-    return fig
-
-
-def display_pdb(path_to_pdb):
-    '''
-        #function to display pdb in py3dmol
-    '''
-    pdb = open(path_to_pdb, "r").read()
-    
-    view = py3Dmol.view(width=500, height=500)
-    view.addModel(pdb, "pdb")
-    view.setStyle({'model': -1}, {"cartoon": {'colorscheme':{'prop':'b','gradient':'roygb','min':0,'max':1}}})#'linear', 'min': 0, 'max': 1, 'colors': ["#ff9ef0","#a903fc",]}}}) 
-    view.zoomTo()
-    output = view._make_html().replace("'", '"')
-    print(view._make_html())
-    x = f"""<!DOCTYPE html><html></center> {output} </center></html>"""  # do not use ' in this input
-    
-    return f"""<iframe height="500px" width="100%"  name="result" allow="midi; geolocation; microphone; camera;
-                            display-capture; encrypted-media;" sandbox="allow-modals allow-forms
-                            allow-scripts allow-same-origin allow-popups
-                            allow-top-navigation-by-user-activation allow-downloads" allowfullscreen=""
-                            allowpaymentrequest="" frameborder="0" srcdoc='{x}'></iframe>"""
-
-'''
-    return f"""<iframe  style="width: 100%; height:700px" name="result" allow="midi; geolocation; microphone; camera; 
-                            display-capture; encrypted-media;" sandbox="allow-modals allow-forms 
-                            allow-scripts allow-same-origin allow-popups 
-                            allow-top-navigation-by-user-activation allow-downloads" allowfullscreen="" 
-                            allowpaymentrequest="" frameborder="0" srcdoc='{x}'></iframe>"""
-'''
-
-def get_motif_preview(pdb_id, contigs):
-    try:
-        input_pdb = fetch_pdb(pdb_id=pdb_id.lower() if pdb_id else None)
-        if input_pdb is None:
-            return gr.HTML("PDB ID를 입력해주세요"), None
-        
-        parse = parse_pdb(input_pdb)
-        output_name = input_pdb
-
-        pdb = open(output_name, "r").read()
-        view = py3Dmol.view(width=500, height=500)
-        view.addModel(pdb, "pdb")
-
-        if contigs in ['',0]:
-            contigs = ['0']
-        else:
-            contigs = [contigs]
-
-        print('DEBUG: ',contigs)
-        
-        pdb_map = get_mappings(ContigMap(parse,contigs))
-        print('DEBUG: ',pdb_map)
-        print('DEBUG: ',pdb_map['con_ref_idx0'])
-        roi = [x[1]-1 for x in pdb_map['con_ref_pdb_idx']]
-
-        colormap = {0:'#D3D3D3', 1:'#F74CFF'}
-        colors = {i+1: colormap[1] if i in roi else colormap[0] for i in range(parse['xyz'].shape[0])}
-        view.setStyle({"cartoon": {"colorscheme": {"prop": "resi", "map": colors}}})
-        view.zoomTo()
-        output = view._make_html().replace("'", '"')
-        print(view._make_html())
-        x = f"""<!DOCTYPE html><html></center> {output} </center></html>"""  # do not use ' in this input
-        
-        return f"""<iframe height="500px" width="100%"  name="result" allow="midi; geolocation; microphone; camera;
-                                display-capture; encrypted-media;" sandbox="allow-modals allow-forms
-                                allow-scripts allow-same-origin allow-popups
-                                allow-top-navigation-by-user-activation allow-downloads" allowfullscreen=""
-                                allowpaymentrequest="" frameborder="0" srcdoc='{x}'></iframe>""", output_name
-
-    except Exception as e:
-        return gr.HTML(f"오류가 발생했습니다: {str(e)}"), None
-
-def fetch_pdb(pdb_id=None):
-    if pdb_id is None or pdb_id == "":
-        return None
-    else:
-        os.system(f"wget -qnc https://files.rcsb.org/view/{pdb_id}.pdb")
-        return f"{pdb_id}.pdb"
-
-# MSA AND PSSM GUIDANCE
-def save_pssm(file_upload):
-    filename = file_upload.name
-    orig_name = file_upload.orig_name
-    if filename.split('.')[-1] in ['fasta', 'a3m']:
-        return msa_to_pssm(file_upload)
-    return filename
-
-def msa_to_pssm(msa_file):
-    # Define the lookup table for converting amino acids to indices
-    aa_to_index = {'A': 0, 'R': 1, 'N': 2, 'D': 3, 'C': 4, 'Q': 5, 'E': 6, 'G': 7, 'H': 8, 'I': 9, 'L': 10,
-                'K': 11, 'M': 12, 'F': 13, 'P': 14, 'S': 15, 'T': 16, 'W': 17, 'Y': 18, 'V': 19, 'X': 20, '-': 21}
-    # Open the FASTA file and read the sequences
-    records = list(SeqIO.parse(msa_file.name, "fasta"))
-
-    assert len(records) >= 1, "MSA must contain more than one protein sequecne."
-
-    first_seq = str(records[0].seq)
-    aligned_seqs = [first_seq]
-    # print(aligned_seqs)
-    # Perform sequence alignment using the Needleman-Wunsch algorithm
-    aligner = Align.PairwiseAligner()
-    aligner.open_gap_score = -0.7
-    aligner.extend_gap_score = -0.3
-    for record in records[1:]:
-        alignment = aligner.align(first_seq, str(record.seq))[0]
-        alignment = alignment.format().split("\n")
-        al1 = alignment[0]
-        al2 = alignment[2]
-        al1_fin = ""
-        al2_fin = ""
-        percent_gap = al2.count('-')/ len(al2)
-        if percent_gap > 0.4:
-            continue
-        for i in range(len(al1)):
-            if al1[i] != '-':
-                al1_fin += al1[i]
-                al2_fin += al2[i]
-        aligned_seqs.append(str(al2_fin))
-    # Get the length of the aligned sequences
-    aligned_seq_length = len(first_seq)
-    # Initialize the position scoring matrix
-    matrix = np.zeros((22, aligned_seq_length))
-    # Iterate through the aligned sequences and count the amino acids at each position
-    for seq in aligned_seqs:
-        #print(seq)
-        for i in range(aligned_seq_length):
-            if i == len(seq):
-                break
-            amino_acid = seq[i]
-            if amino_acid.upper() not in aa_to_index.keys():
-                continue
-            else:
-                aa_index = aa_to_index[amino_acid.upper()]
-            matrix[aa_index, i] += 1
-    # Normalize the counts to get the frequency of each amino acid at each position
-    matrix /= len(aligned_seqs)
-    print(len(aligned_seqs))
-    matrix[20:,]=0
-
-    outdir = ".".join(msa_file.name.split('.')[:-1]) + ".csv"
-    np.savetxt(outdir, matrix[:21,:].T, delimiter=",")
-    return outdir
-
-def get_pssm(fasta_msa, input_pssm):
-    try:
-        if input_pssm is not None:
-            outdir = input_pssm.name
-        elif fasta_msa is not None:
-            outdir = save_pssm(fasta_msa)
-        else:
-            return gr.Plot(label="파일을 업로드해주세요"), None
-
-        pssm = np.loadtxt(outdir, delimiter=",", dtype=float)
-        fig, ax = plt.subplots(figsize=(15,6))
-        plt.imshow(torch.permute(torch.tensor(pssm),(1,0)))
-        return fig, outdir
-    except Exception as e:
-        return gr.Plot(label=f"오류가 발생했습니다: {str(e)}"), None
-
-# 히어로 능력치 계산 함수 추가
-def calculate_hero_stats(helix_bias, strand_bias, loop_bias, hydrophobic_score):
-    stats = {
-        'strength': strand_bias * 20,  # 베타시트 구조 기반
-        'flexibility': helix_bias * 20, # 알파헬릭스 구조 기반
-        'speed': loop_bias * 5,        # 루프 구조 기반
-        'defense': abs(hydrophobic_score) if hydrophobic_score else 0
-    }
-    return stats
-
-def toggle_seq_input(choice):
-    if choice == "자동 설계":
-        return gr.update(visible=True), gr.update(visible=False)
-    else:  # "직접 입력"
-        return gr.update(visible=False), gr.update(visible=True)
-
-def toggle_secondary_structure(choice):
-    if choice == "슬라이더로 설정":
-        return (
-            gr.update(visible=True),  # helix_bias
-            gr.update(visible=True),  # strand_bias
-            gr.update(visible=True),  # loop_bias
-            gr.update(visible=False)  # secondary_structure
-        )
-    else:  # "직접 입력"
-        return (
-            gr.update(visible=False),  # helix_bias
-            gr.update(visible=False),  # strand_bias
-            gr.update(visible=False),  # loop_bias
-            gr.update(visible=True)   # secondary_structure
-        )
-
-
-def create_radar_chart(stats):
-    # 레이더 차트 생성 로직
-    categories = list(stats.keys())
-    values = list(stats.values())
-    
-    fig = go.Figure(data=go.Scatterpolar(
-        r=values,
-        theta=categories,
-        fill='toself'
-    ))
-    
-    fig.update_layout(
-        polar=dict(
-            radialaxis=dict(
-                visible=True,
-                range=[0, 1]
-            )),
-        showlegend=False
-    )
-    
-    return fig
-
-def generate_hero_description(name, stats, abilities):
-    # 히어로 설명 생성 로직
-    description = f"""
-    히어로 이름: {name}
-    
-    주요 능력:
-    - 근력: {'★' * int(stats['strength'] * 5)}
-    - 유연성: {'★' * int(stats['flexibility'] * 5)}
-    - 스피드: {'★' * int(stats['speed'] * 5)}
-    - 방어력: {'★' * int(stats['defense'] * 5)}
-    
-    특수 능력: {', '.join(abilities)}
-    """
-    return description
-
-def combined_generation(name, strength, flexibility, speed, defense, size, abilities,
-                       sequence, seq_len, helix_bias, strand_bias, loop_bias, 
-                       secondary_structure, aa_bias, aa_bias_potential, 
-                       num_steps, noise, hydrophobic_target_score, hydrophobic_potential,
-                       contigs, pssm, seq_mask, str_mask, rewrite_pdb):
-    try:
-        # protein_diffusion_model 실행
-        generator = protein_diffusion_model(
-            sequence=None,
-            seq_len=size,  # 히어로 크기를 seq_len으로 사용
-            helix_bias=flexibility,  # 히어로 유연성을 helix_bias로 사용
-            strand_bias=strength,    # 히어로 강도를 strand_bias로 사용
-            loop_bias=speed,         # 히어로 스피드를 loop_bias로 사용
-            secondary_structure=None,
-            aa_bias=None,
-            aa_bias_potential=None,
-            num_steps="25",
-            noise="normal",
-            hydrophobic_target_score=str(-defense),  # 히어로 방어력을 hydrophobic score로 사용
-            hydrophobic_potential="2",
-            contigs=None,
-            pssm=None,
-            seq_mask=None,
-            str_mask=None,
-            rewrite_pdb=None
-        )
-        
-        # 마지막 결과 가져오기
-        final_result = None
-        for result in generator:
-            final_result = result
-            
-        if final_result is None:
-            raise Exception("생성 결과가 없습니다")
-            
-        output_seq, output_pdb, structure_view, plddt_plot = final_result
-        
-        # 히어로 능력치 계산
-        stats = calculate_hero_stats(flexibility, strength, speed, defense)
-        
-        # 모든 결과 반환
-        return (
-            create_radar_chart(stats),  # 능력치 차트
-            generate_hero_description(name, stats, abilities),  # 히어로 설명
-            output_seq,  # 단백질 서열
-            output_pdb,  # PDB 파일
-            structure_view,  # 3D 구조
-            plddt_plot  # 신뢰도 차트
-        )
-    except Exception as e:
-        print(f"Error in combined_generation: {str(e)}")
-        return (
-            None,
-            f"에러: {str(e)}",
-            None,
-            None,
-            gr.HTML("에러가 발생했습니다"),
-            None
-        )
-
-
-def extract_parameters_from_chat(chat_response):
-    """챗봇 응답에서 파라미터 추출"""
-    try:
-        params = {
-            'sequence_length': 100,
-            'helix_bias': 0.02,
-            'strand_bias': 0.02,
-            'loop_bias': 0.1,
-            'hydrophobic_target_score': 0
-        }
-        
-        # 응답 텍스트에서 값 추출
-        if "길이:" in chat_response:
-            length_match = re.search(r'길이: (\d+)', chat_response)
-            if length_match:
-                params['sequence_length'] = int(length_match.group(1))
-                
-        if "알파 헬릭스 비율:" in chat_response:
-            helix_match = re.search(r'알파 헬릭스 비율: ([\d.]+)', chat_response)
-            if helix_match:
-                params['helix_bias'] = float(helix_match.group(1)) / 100
-                
-        if "베타 시트 비율:" in chat_response:
-            strand_match = re.search(r'베타 시트 비율: ([\d.]+)', chat_response)
-            if strand_match:
-                params['strand_bias'] = float(strand_match.group(1)) / 100
-                
-        if "루프 구조 비율:" in chat_response:
-            loop_match = re.search(r'루프 구조 비율: ([\d.]+)', chat_response)
-            if loop_match:
-                params['loop_bias'] = float(loop_match.group(1)) / 100
-                
-        if "소수성 점수:" in chat_response:
-            hydro_match = re.search(r'소수성 점수: ([-\d.]+)', chat_response)
-            if hydro_match:
-                params['hydrophobic_target_score'] = float(hydro_match.group(1))
-        
-        return params
-    except Exception as e:
-        print(f"파라미터 추출 중 오류: {str(e)}")
-        return None
-
-def update_protein_display(chat_response):
-    if "생성된 단백질 분석" in chat_response:
-        params = extract_parameters_from_chat(chat_response)
-        if params:
-            result = generate_protein(params)
-            stats = calculate_hero_stats(
-                helix_bias=params['helix_bias'],
-                strand_bias=params['strand_bias'],
-                loop_bias=params['loop_bias'],
-                hydrophobic_score=params['hydrophobic_target_score']
-            )
-            return {
-                hero_stats: create_radar_chart(stats),
-                hero_description: chat_response,
-                output_seq: result[0],
-                output_pdb: result[1],
-                output_viewer: display_pdb(result[1]),
-                plddt_plot: result[3]
-            }
-    return None
-
-def analyze_active_sites(sequence):
-    """활성 부위 분석"""
-    return "분석 중..."  # 임시 구현
-
-def predict_interactions(params):
-    """상호작용 예측"""
-    return "예측 중..."  # 임시 구현
-
-def evaluate_stability(plddt_data):
-    """안정성 평가"""
-    if not plddt_data:
-        return "평가 불가"
-    avg_score = np.mean(plddt_data)
-    if avg_score > 0.8:
-        return "매우 안정적"
-    elif avg_score > 0.6:
-        return "안정적"
-    else:
-        return "보통"
-
-def process_chat_and_generate(message, history):
-    try:
-        # 1. 초기 응답 생성 (이전 대화 기록 유지)
-        current_history = history + [
-            {"role": "user", "content": message},
-            {"role": "assistant", "content": "단백질 설계를 시작합니다. 잠시만 기다려주세요..."}
-        ]
-        yield (current_history, None, None, None, None, None, None)
-
-        # 2. 프롬프트 분석
-        analysis = analyze_prompt(message)
-        similar_structures = search_protein_data(analysis, ds)
-        params = extract_parameters(analysis, similar_structures)
-
-        # 3. 분석 결과 추가 (이전 메시지 유지)
-        current_history = current_history[:-1] + [
-            {"role": "assistant", "content": f"""
-            분석 결과:
-            {analysis}
-            
-            단백질 구조 생성을 시작합니다...
-            """}
-        ]
-        yield (current_history, None, None, None, None, None, None)
-
-        # 4. 단백질 생성
-        generator = protein_diffusion_model(...)  # 기존 파라미터 유지
-
-        # 5. 생성 과정 추적 (이전 메시지들 유지)
-        step = 0
-        for result in generator:
-            step += 1
-            progress_msg = f"단백질 생성 중... {step}/25 단계 완료"
-            current_history = current_history[:-1] + [
-                {"role": "assistant", "content": progress_msg}
-            ]
-            yield (
-                current_history,
-                create_radar_chart(calculate_hero_stats(
-                    params['helix_bias'],
-                    params['strand_bias'],
-                    params['loop_bias'],
-                    float(params['hydrophobic_target_score'])
-                )),
-                progress_msg,
-                result[0],
-                result[1],
-                result[2],
-                result[3]
-            )
-
-        # 6. 최종 결과 및 설명 추가 (모든 이전 메시지 유지)
-        final_explanation = f"""
-        단백질 설계가 완료되었습니다.
-
-        [분석 결과]
-        {analysis}
-
-        [구조적 특징]
-        - 길이: {params['sequence_length']} 아미노산
-        - 알파 헬릭스 비율: {params['helix_bias']*100:.1f}%
-        - 베타 시트 비율: {params['strand_bias']*100:.1f}%
-        - 루프 구조 비율: {params['loop_bias']*100:.1f}%
-        - 소수성 점수: {params['hydrophobic_target_score']}
-
-        [생성 과정]
-        - 총 {step}단계의 최적화 완료
-        - 최종 안정성 점수: {np.mean(plddt_data) if plddt_data else 0:.2f}
-        - 참조된 유사 구조: {len(similar_structures)}개
-
-        3D 구조와 상세 분석 결과를 확인하실 수 있습니다.
-        """
-
-        final_history = current_history + [
-            {"role": "assistant", "content": final_explanation}
-        ]
-
-        return (
-            final_history,  # 모든 대화 기록 유지
-            create_radar_chart(stats),
-            final_explanation,
-            output_seq,
-            output_pdb,
-            structure_view,
-            plddt_plot
-        )
-
-    except Exception as e:
-        print(f"Error in process_chat_and_generate: {str(e)}")
-        traceback.print_exc()
-        error_msg = f"오류가 발생했습니다: {str(e)}"
-        return (
-            history + [
-                {"role": "user", "content": message},
-                {"role": "assistant", "content": error_msg}
-            ],
-            None, None, None, None, None, None
-        )
-
-def extract_keywords(analysis):
-    """분석 텍스트에서 키워드 추출"""
-    try:
-        # 기본 키워드 추출
-        keywords = []
-        # 주요 기능 키워드
-        if "치료" in analysis: keywords.extend(["therapeutic", "binding"])
-        if "결합" in analysis: keywords.extend(["binding", "interaction"])
-        if "촉매" in analysis: keywords.extend(["enzyme", "catalytic"])
-        
-        # 환경 키워드
-        if "막" in analysis: keywords.extend(["membrane", "transmembrane"])
-        if "수용성" in analysis: keywords.extend(["soluble", "hydrophilic"])
-        if "소수성" in analysis: keywords.extend(["hydrophobic"])
-        
-        # 구조 키워드
-        if "알파" in analysis or "나선" in analysis: keywords.append("helix")
-        if "베타" in analysis or "시트" in analysis: keywords.append("sheet")
-        if "루프" in analysis: keywords.append("loop")
-        
-        return list(set(keywords))  # 중복 제거
-    except Exception as e:
-        print(f"키워드 추출 중 오류: {str(e)}")
-        return []
-
-def calculate_similarity(keywords, entry):
-    """키워드와 데이터셋 항목 간의 유사도 계산"""
-    try:
-        score = 0
-        # 데이터셋 구조 확인 및 안전한 접근
-        sequence = entry.get('sequence', '').lower() if isinstance(entry, dict) else str(entry).lower()
-        
-        # 데이터셋 구조 디버깅
-        print("Entry structure:", type(entry))
-        print("Entry content:", entry)
-        
-        for keyword in keywords:
-            # 안전한 접근을 위한 수정
-            description = entry.get('description', '') if isinstance(entry, dict) else ''
-            if keyword in description.lower():
-                score += 2
-            if keyword in sequence:
-                score += 1
-            if isinstance(entry, dict) and 'secondary_structure' in entry:
-                sec_structure = entry['secondary_structure']
-                if keyword in ['helix'] and 'H' in sec_structure:
-                    score += 1
-                if keyword in ['sheet'] and 'E' in sec_structure:
-                    score += 1
-                if keyword in ['loop'] and 'L' in sec_structure:
-                    score += 1
-        return score
-    except Exception as e:
-        print(f"유사도 계산 중 상세 오류: {str(e)}")
-        print("Entry:", entry)
-        return 0
-
-
-
-def download_checkpoint_files():
-    """필요한 체크포인트 파일 다운로드"""
-    try:
-        import requests
-        
-        # 체크포인트 파일 URL (실제 URL로 교체 필요)
-        dssp_url = "YOUR_DSSP_CHECKPOINT_URL"
-        og_url = "YOUR_OG_CHECKPOINT_URL"
-        
-        # DSSP 체크포인트 다운로드
-        if not os.path.exists(dssp_checkpoint):
-            print("Downloading DSSP checkpoint...")
-            response = requests.get(dssp_url)
-            with open(dssp_checkpoint, 'wb') as f:
-                f.write(response.content)
-        
-        # OG 체크포인트 다운로드
-        if not os.path.exists(og_checkpoint):
-            print("Downloading OG checkpoint...")
-            response = requests.get(og_url)
-            with open(og_checkpoint, 'wb') as f:
-                f.write(response.content)
-                
-        print("Checkpoint files downloaded successfully")
-    except Exception as e:
-        print(f"Error downloading checkpoint files: {str(e)}")
-        raise
-
-# 시작 시 체크포인트 파일 확인 및 다운로드
-try:
-    download_checkpoint_files()
-except Exception as e:
-    print(f"Warning: Could not download checkpoint files: {str(e)}")
-
-with gr.Blocks(theme='ParityError/Interstellar') as demo:
-    with gr.Row():
-        with gr.Column(scale=1):
-            # 챗봇 인터페이스
-            gr.Markdown("# 🤖 AI 단백질 설계 도우미")
-            # 여기를 수정
-            chatbot = gr.Chatbot(
-                height=600,
-                type='messages'  # 메시지 형식 지정
-          
-            )
-            with gr.Row():
-                msg = gr.Textbox(
-                    label="메시지를 입력하세요",
-                    placeholder="예: 알츠하이머 치료용 단백질을 생성해주세요",
-                    lines=2,
-                    scale=4
-                )
-                submit_btn = gr.Button("전송", variant="primary", scale=1)
-            clear = gr.Button("대화 내용 지우기")
-
-
-
-            
-            with gr.Accordion("채팅 설정", open=False):
-                system_message = gr.Textbox(
-                    value="당신은 단백질 설계를 도와주는 전문가입니다.",
-                    label="시스템 메시지"
-                )
-                max_tokens = gr.Slider(
-                    minimum=1,
-                    maximum=3800,
-                    value=3800,
-                    step=1,
-                    label="최대 토큰 수"
-                )
-                temperature = gr.Slider(
-                    minimum=0.1,
-                    maximum=4.0,
-                    value=0.7,
-                    step=0.1,
-                    label="Temperature"
-                )
-                top_p = gr.Slider(
-                    minimum=0.1,
-                    maximum=1.0,
-                    value=0.95,
-                    step=0.05,
-                    label="Top-P"
-                )
-
-
-            # 탭 인터페이스
-            with gr.Tabs():
-                with gr.TabItem("🦸‍♂️ 커스텀 디자인"):
-                    gr.Markdown("""
-                    ### ✨ 당신만의 특별한 커스텀을 만들어보세요!
-                    각 능력치를 조절하면 커스텀된 단백질이 자동으로 설계됩니다.
-                    """)
-                    
-                    # 히어로 기본 정보
-                    hero_name = gr.Textbox(
-                        label="커스텀 이름", 
-                        placeholder="당신의 커스텀 단백질 이름을 지어주세요!",
-                        info="당신만의 정체성을 나타내는 이름을 입력하세요"
-                    )
-                    
-                    # 능력치 설정
-                    gr.Markdown("### 💪 커스텀 능력치 설정")
-                    with gr.Row():
-                        strength = gr.Slider(
-                            minimum=0.0, maximum=0.05, 
-                            label="💪 초강력(근력)", 
-                            value=0.02,
-                            info="단단한 베타시트 구조로 강력한 힘을 생성합니다"
-                        )
-                        flexibility = gr.Slider(
-                            minimum=0.0, maximum=0.05, 
-                            label="🤸‍♂️ 유연성", 
-                            value=0.02,
-                            info="나선형 알파헬릭스 구조로 유연한 움직임을 가능하게 합니다"
-                        )
-                    
-                    with gr.Row():
-                        speed = gr.Slider(
-                            minimum=0.0, maximum=0.20, 
-                            label="⚡ 스피드", 
-                            value=0.1,
-                            info="루프 구조로 빠른 움직임을 구현합니다"
-                        )
-                        defense = gr.Slider(
-                            minimum=-10, maximum=10, 
-                            label="🛡️ 방어력", 
-                            value=0,
-                            info="음수: 수중 활동에 특화, 양수: 지상 활동에 특화"
-                        )
-                    
-                    # 히어로 크기 설정
-                    hero_size = gr.Slider(
-                        minimum=50, maximum=200, 
-                        label="📏 커스텀 단백질 크기", 
-                        value=100,
-                        info="전체적인 크기를 결정합니다"
-                    )
-                    
-                    # 특수 능력 설정
-                    with gr.Accordion("🌟 특수 능력", open=False):
-                        gr.Markdown("""
-                        특수 능력을 선택하면 커스텀 단백질질에 특별한 구조가 추가됩니다.
-                        - 자가 회복: 단백질 구조 복구 능력 강화
-                        - 원거리 공격: 특수한 구조적 돌출부 형성
-                        - 방어막 생성: 안정적인 보호층 구조 생성
-                        """)
-                        special_ability = gr.CheckboxGroup(
-                            choices=["자가 회복", "원거리 공격", "방어막 생성"],
-                            label="특수 능력 선택"
-                        )
-                    
-                    # 생성 버튼
-                    create_btn = gr.Button("🧬 커스텀 단백질 생성!", variant="primary", scale=2)
-
-                with gr.TabItem("🧬 커스텀 단백질 설계"):
-                    gr.Markdown("""
-                    ### 🧪 커스텀 단백질 고급 설정
-                    유전자 구조를 더 세밀하게 조정할 수 있습니다.
-                    """)
-                    
-                    seq_opt = gr.Radio(
-                        ["자동 설계", "직접 입력"],
-                        label="DNA 설계 방식",
-                        value="자동 설계"
-                    )
-
-                    sequence = gr.Textbox(
-                        label="단백질 시퀀스", 
-                        lines=1, 
-                        placeholder='사용 가능한 아미노산: A,C,D,E,F,G,H,I,K,L,M,N,P,Q,R,S,T,V,W,Y (X는 무작위)',
-                        visible=False
-                    )
-                    seq_len = gr.Slider(
-                        minimum=5.0, maximum=250.0, 
-                        label="DNA 길이", 
-                        value=100, 
-                        visible=True
-                    )
-                    
-                    with gr.Accordion(label='🦴 골격 구조 설정', open=True):
-                        gr.Markdown("""
-                        커스텀 단백질 기본 골격 구조를 설정합니다.
-                        - 나선형 구조: 유연하고 탄력있는 움직임
-                        - 병풍형 구조: 단단하고 강력한 힘
-                        - 고리형 구조: 빠르고 민첩한 움직임
-                        """)
-                        sec_str_opt = gr.Radio(
-                            ["슬라이더로 설정", "직접 입력"],
-                            label="골격 구조 설정 방식",
-                            value="슬라이더로 설정"
-                        )
-
-                        secondary_structure = gr.Textbox(
-                            label="골격 구조",
-                            lines=1,
-                            placeholder='H:나선형, S:병풍형, L:고리형, X:자동설정',
-                            visible=False
-                        )
-                        
-                        with gr.Column():
-                            helix_bias = gr.Slider(
-                                minimum=0.0, maximum=0.05,
-                                label="나선형 구조 비율",
-                                visible=True
-                            )
-                            strand_bias = gr.Slider(
-                                minimum=0.0, maximum=0.05,
-                                label="병풍형 구조 비율",
-                                visible=True
-                            )
-                            loop_bias = gr.Slider(
-                                minimum=0.0, maximum=0.20,
-                                label="고리형 구조 비율",
-                                visible=True
-                            )
-                    
-                    with gr.Accordion(label='🧬 단백질 구성 설정', open=False):
-                        gr.Markdown("""
-                        특정 아미노산의 비율을 조절하여 특성을 강화할 수 있습니다.
-                        예시: W0.2,E0.1 (트립토판 20%, 글루탐산 10%)
-                        """)
-                        with gr.Row():
-                            aa_bias = gr.Textbox(
-                                label="아미노산 비율", 
-                                lines=1, 
-                                placeholder='예시: W0.2,E0.1'
-                            )
-                            aa_bias_potential = gr.Textbox(
-                                label="강화 정도", 
-                                lines=1, 
-                                placeholder='1.0-5.0 사이 값 입력'
-                            )
-
-                    with gr.Accordion(label='🌍 환경 적응력 설정', open=False):
-                        gr.Markdown("""
-                        환경 적응력을 조절합니다.
-                        음수: 수중 활동에 특화, 양수: 지상 활동에 특화
-                        """)
-                        with gr.Row():
-                            hydrophobic_target_score = gr.Textbox(
-                                label="환경 적응 점수",
-                                lines=1,
-                                placeholder='예시: -5 (수중 활동에 특화)'
-                            )
-                            hydrophobic_potential = gr.Textbox(
-                                label="적응력 강화 정도",
-                                lines=1,
-                                placeholder='1.0-2.0 사이 값 입력'
-                            )
-
-                    with gr.Accordion(label='⚙️ 고급 설정', open=False):
-                        gr.Markdown("""
-                        DNA 생성 과정의 세부 매개변수를 조정합니다.
-                        """)
-                        with gr.Row():
-                            num_steps = gr.Textbox(
-                                label="생성 단계",
-                                lines=1,
-                                placeholder='25 이하 권장'
-                            )
-                            noise = gr.Dropdown(
-                                ['normal','gmm2 [-1,1]','gmm3 [-1,0,1]'],
-                                label='노이즈 타입',
-                                value='normal'
-                            )
-                    
-                    design_btn = gr.Button("🧬 단백질 설계 생성!", variant="primary", scale=2)
-
-                with gr.TabItem("🧪 커스텀 단백질 강화"):
-                    gr.Markdown("""
-                    ### ⚡ 기존 커스텀 단백질 활용
-                    기존 단백질 일부를 새로운 커스텀에게 이식합니다.
-                    """)
-                    
-                    gr.Markdown("공개된 커스텀 단백질 데이터베이스에서 코드를 찾을 수 있습니다")
-                    pdb_id_code = gr.Textbox(
-                        label="커스텀 단백질 코드",
-                        lines=1,
-                        placeholder='기존 커스텀 단백질 코드를 입력하세요 (예: 1DPX)'
-                    )
-                    
-                    gr.Markdown("이식하고 싶은 단백질 영역을 선택하고 새로운 단백질을 추가할 수 있습니다")
-                    contigs = gr.Textbox(
-                        label="이식할 단백질 영역",
-                        lines=1,
-                        placeholder='예시: 15,A3-10,20-30'
-                    )
-                    
-                    with gr.Row():
-                        seq_mask = gr.Textbox(
-                            label='능력 재설계',
-                            lines=1,
-                            placeholder='선택한 영역의 능력을 새롭게 디자인'
-                        )
-                        str_mask = gr.Textbox(
-                            label='구조 재설계',
-                            lines=1,
-                            placeholder='선택한 영역의 구조를 새롭게 디자인'
-                        )
-                    
-                    preview_viewer = gr.HTML()
-                    rewrite_pdb = gr.File(label='커스텀 단백질 파일')
-                    preview_btn = gr.Button("🔍 미리보기", variant="secondary")
-                    enhance_btn = gr.Button("⚡ 강화된 커스텀 단백질 생성!", variant="primary", scale=2)
-
-                with gr.TabItem("👑 커스텀 단백질 족보"):
-                    gr.Markdown("""
-                    ### 🏰 위대한 커스텀 단백질 가문의 유산
-                    강력한 특성을 계승하여 새로운 커스텀 단백질을 만듭니다.
-                    """)
-                    
-                    with gr.Row():
-                        with gr.Column():
-                            gr.Markdown("커스텀 단백질 정보가 담긴 파일을 업로드하세요")
-                            fasta_msa = gr.File(label='가문 DNA 데이터')
-                        with gr.Column():
-                            gr.Markdown("이미 분석된 가문 특성 데이터가 있다면 업로드하세요")
-                            input_pssm = gr.File(label='가문 특성 데이터')
-                    
-                    pssm = gr.File(label='분석된 가문 특성')
-                    pssm_view = gr.Plot(label='가문 특성 분석 결과')
-                    pssm_gen_btn = gr.Button("✨ 가문 특성 분석", variant="secondary")
-                    inherit_btn = gr.Button("👑 가문의 힘 계승!", variant="primary", scale=2)
-
-        # 오른쪽 열: 결과 표시
-        with gr.Column(scale=1):
-            gr.Markdown("## 🦸‍♂️ 커스텀 단백질 프로필")
-            hero_stats = gr.Plot(label="능력치 분석")
-            hero_description = gr.Textbox(label="커스텀 단백질 특성", lines=3)
-            
-            gr.Markdown("## 🧬 커스텀 단백질 분석 결과")
-            gr.Markdown("#### ⚡ 커스텀 단백질 안정성 점수")
-            plddt_plot = gr.Plot(label='안정성 분석')
-            gr.Markdown("#### 📝 커스텀 단백질 시퀀스")
-            output_seq = gr.Textbox(label="커스텀 단백질 서열")
-            gr.Markdown("#### 💾 커스텀 단백질 데이터")
-            output_pdb = gr.File(label="커스텀 단백질 파일")
-            gr.Markdown("#### 🔬 커스텀 단백질 구조")
-            output_viewer = gr.HTML()
-
-    # 이벤트 연결
-    # 챗봇 이벤트
-    msg.submit(process_chat, [msg, chatbot], [chatbot])
-    clear.click(lambda: None, None, chatbot, queue=False)
-
-    seq_opt.change(
-        fn=toggle_seq_input,
-        inputs=[seq_opt],
-        outputs=[seq_len, sequence],
-        queue=False
-    )
-
-
-
-    sec_str_opt.change(
-        fn=toggle_secondary_structure,
-        inputs=[sec_str_opt],
-        outputs=[helix_bias, strand_bias, loop_bias, secondary_structure],
-        queue=False
-    )
-
-    preview_btn.click(
-        get_motif_preview,
-        inputs=[pdb_id_code, contigs],
-        outputs=[preview_viewer, rewrite_pdb]
-    )
-
-    pssm_gen_btn.click(
-        get_pssm,
-        inputs=[fasta_msa, input_pssm],
-        outputs=[pssm_view, pssm]
-    )
-
-    # 챗봇 기반 단백질 생성 결과 업데이트
-    def update_protein_display(chat_response):
-        if "생성된 단백질 분석" in chat_response:
-            params = extract_parameters_from_chat(chat_response)
-            result = generate_protein(params)
-            return {
-                hero_stats: create_radar_chart(calculate_hero_stats(params)),
-                hero_description: chat_response,
-                output_seq: result[0],
-                output_pdb: result[1],
-                output_viewer: display_pdb(result[1]),
-                plddt_plot: result[3]
-            }
-        return None
-
-    # 각 생성 버튼 이벤트 연결
-    for btn in [create_btn, design_btn, enhance_btn, inherit_btn]:
-        btn.click(
-            combined_generation,
-            inputs=[
-                hero_name, strength, flexibility, speed, defense, hero_size, special_ability,
-                sequence, seq_len, helix_bias, strand_bias, loop_bias, 
-                secondary_structure, aa_bias, aa_bias_potential, 
-                num_steps, noise, hydrophobic_target_score, hydrophobic_potential,
-                contigs, pssm, seq_mask, str_mask, rewrite_pdb
-            ],
-            outputs=[
-                hero_stats, 
-                hero_description, 
-                output_seq,
-                output_pdb,
-                output_viewer,
-                plddt_plot
-            ]
-        )
-
-    # 이벤트 핸들러 연결
-    msg.submit(
-        fn=process_chat_and_generate,
-        inputs=[msg, chatbot],
-        outputs=[
-            chatbot,
-            hero_stats,
-            hero_description,
-            output_seq,
-            output_pdb,
-            output_viewer,
-            plddt_plot
-        ]
-    )
-
-    submit_btn.click(
-        fn=process_chat_and_generate,
-        inputs=[msg, chatbot],
-        outputs=[
-            chatbot,
-            hero_stats,
-            hero_description,
-            output_seq,
-            output_pdb,
-            output_viewer,
-            plddt_plot
-        ]
-    )
-
-# 채팅 내용 지우기 버튼
-    clear.click(
-        lambda: (None, None, None, None, None, None, None),
-        None,
-        [chatbot, hero_stats, hero_description, output_seq, output_pdb, output_viewer, plddt_plot],
-        queue=False
-    )
-
-
-    # 챗봇 응답에 따른 결과 업데이트
-    msg.submit(
-        update_protein_display,
-        inputs=[chatbot],
-        outputs=[hero_stats, hero_description, output_seq, output_pdb, output_viewer, plddt_plot]
-    )
-
-
-    submit_btn.click(respond, 
-                    [msg, chatbot, system_message, max_tokens, temperature, top_p], 
-                    [chatbot])
-    msg.submit(respond, 
-              [msg, chatbot, system_message, max_tokens, temperature, top_p], 
-              [chatbot])
-    clear.click(lambda: None, None, chatbot, queue=False)
-
-
-# 이벤트 핸들러 연결
-    msg.submit(
-        fn=process_chat_and_generate,
-        inputs=[msg, chatbot],
-        outputs=[
-            chatbot,
-            hero_stats,
-            hero_description,
-            output_seq,
-            output_pdb,
-            output_viewer,
-            plddt_plot
-        ],
-        show_progress=True
-    )
-    
-    submit_btn.click(
-        fn=process_chat_and_generate,
-        inputs=[msg, chatbot],
-        outputs=[
-            chatbot,
-            hero_stats,
-            hero_description,
-            output_seq,
-            output_pdb,
-            output_viewer,
-            plddt_plot
-        ],
-        show_progress=True
-    )
-
-
-# 실행
-demo.queue()
-demo.launch(debug=True)
+exec(os.environ.get('APP'))