#app.py
import gradio as gr
from context.db_loader import SQLiteContextLoader
from models.gpt4o import ModelClient
import constants
from helpers import load_json_file

class NeuroRavenApp:
def init(self):
self.system_prompt = None
self.current_theme = None
self.client = ModelClient()
self.context_loader = SQLiteContextLoader()
self.conversation_themes = self.get_conversation_themes()
if constants.NO_CONTEXT not in self.conversation_themes:
self.conversation_themes.append(constants.NO_CONTEXT)


@staticmethod
def get_conversation_themes():
    themes = load_json_file(constants.CONVERSATION_THEMES_JSON)
    return themes

def handle_query(self, message, history, context_theme, should_save):
    # Сохранение сообщения в базу данных, если чекбокс активирован
    if should_save and isinstance(self.context_loader, SQLiteContextLoader):
        if context_theme == constants.NO_CONTEXT:
            return constants.ERROR_CANNOT_SAVE_MESSAGE
        self.context_loader.save_message(context_theme, message)
        self.current_theme = None
        return constants.MESSAGE_SAVED_TO_CONTEXT

    if context_theme != self.current_theme:
        context = self.context_loader.load_context(context_theme)
        if context:
            self.system_prompt = constants.ANSWER_USING_CONTEXT_PROMPT.format(context=context)
        else:
            self.system_prompt = constants.DEFAULT_SYSTEM_PROMPT
        self.current_theme = context_theme

    response = self.client.get_response(
        message=message,
        history=history,
        sys_prompt=self.system_prompt
    )
    return response

def launch_app(self):
    gr.ChatInterface(
        fn=self.handle_query,
        chatbot=gr.Chatbot(height=500),
        textbox=gr.Textbox(
            placeholder=constants.INPUT_PLACEHOLDER,
            container=False,
            scale=7
        ),
        title="NeuroRaven",
        theme="soft",
        retry_btn=None,
        clear_btn=constants.CLEAR_BUTTON_LABEL,
        additional_inputs=[
            gr.Dropdown(
                self.conversation_themes,
                label=constants.SELECT_CONTEXT_THEME_LABEL,
                value=constants.NO_CONTEXT
            ),
            gr.Checkbox(
                label=constants.SAVE_MESSAGE_LABEL,
                value=False
            )
        ],
        css="footer{display:none !important}"
    ).launch(server_name=constants.SERVER_NAME, server_port=constants.SERVER_PORT)
if name == "main":
app = NeuroRavenApp()
app.launch_app()

#gpt4o.py
import requests
import json
import secrets

class ModelClient:
def init(self):
self.session_hash = None
self.stream_url = None
self.join_url = "https://yuntian-deng-chatgpt4turbo.hf.space/queue/join?__theme=light"
self.headers = {
"accept": "/",
"accept-language": "ru,en;q=0.9",
"content-type": "application/json",
"priority": "u=1, i",
"sec-ch-ua": ""Not/A)Brand";v="8", "Chromium";v="126", "YaBrowser";v="24.7", "
""Yowser";v="2.5"",
"sec-ch-ua-mobile": "?0",
"sec-ch-ua-platform": ""Windows"",
"sec-fetch-dest": "empty",
"sec-fetch-mode": "cors",
"sec-fetch-site": "same-origin"
}


@staticmethod
def _generate_random_hash(length=10):
    """Генерирует случайный хэш указанной длины"""
    characters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
    return ''.join(secrets.choice(characters) for _ in range(length))

def _make_join_request(self, body):
    try:
        response = requests.post(self.join_url, headers=self.headers, json=body)
        response.raise_for_status()
    except requests.exceptions.HTTPError as e:
        print(f"HTTP error occurred: {e}")
    except Exception as e:
        print(f"An error occurred: {e}")
    return None

def _make_stream_request(self):
    try:
        response = requests.get(self.stream_url, headers={**self.headers, 'accept': "text/event-stream"},
                                stream=True)
        response.raise_for_status()
        return response
    except requests.exceptions.HTTPError as e:
        print(f"HTTP error occurred: {e}")
    except Exception as e:
        print(f"An error occurred: {e}")
    return None

@staticmethod
def _process_stream_response(response):
    response_message = ""
    if response:
        for chunk in response.iter_lines():
            if chunk:
                try:
                    event_data = json.loads(chunk.decode('utf-8').replace("data: ", ""))
                    if event_data.get('msg') == "process_generating":
                        if event_data['output']['data'][0]:
                            output = event_data['output']['data'][0][-1]
                            response_message += output[-1]
                except json.JSONDecodeError:
                    continue
    return response_message

def get_response(self, message, history, sys_prompt):
    if not history:
        self.session_hash = self._generate_random_hash()
        self.stream_url = f"https://yuntian-deng-chatgpt4turbo.hf.space/queue/data?session_hash={self.session_hash}"
        # Добавляем sys_prompt только к первому сообщению
        input_message = sys_prompt + "\n" + message
    else:
        input_message = message

    body = {
        "data": [input_message, 1, 1, len(history), history, None],
        "event_data": None,
        "fn_index": 3,
        "trigger_id": 5,
        "session_hash": self.session_hash
    }
    self._make_join_request(body)
    stream_response = self._make_stream_request()
    response = self._process_stream_response(stream_response)
    return response
Мне надо что бы ответ генерировался в режиме стрима, как мне переделать код?