Прикручиваем доступ к API OpenAI gpt-4o через proxy

Запилил я в том году приложение на Python по доступу к YandexGPT через API, теперь вот появилось желание попилить дальше и добавить доступ к gpt-4o и gpt-4o‑mini заодно.

Чем будет полезна эта программа — можно будет поэкспериментировать с системными запросами (в программе «Специализация»), которые можно создавать самому, и температурой («Креативность») к YandexGPT и OpenAI gpt-4o минуя их промпты и настройки системы, плюс не надо платить за подписку и пользоваться по надобности, плюс частично автоматизировать свои процессы запросов и проверить разные версии работы с GPT моделями.

Что бы не заморачиваться c настройкой прямого доступа к OpenAI через VPN и оплатой ещё через неизвестно что находим варианты попроще, забиваем в поиске «доступ к gpt-4o через proxy» находим подходящий сервис — регистрируемся, оплачиваем, получаем ключ API и всё, предварительная работа проведена осталось немного добавить в программу изменений и будет нам счастье.

Делаем изменения в программе:

1. Добавляем радиокнопки в интерфейс

tk.Radiobutton(self.model_selection_frame,text="GPT-4o mini",variable=self.gpt_model_uri,value="gpt-4o-mini",command=self.update_gpt_model_uri).grid(row=0, column=4, padx=5, sticky="w")
tk.Radiobutton(self.model_selection_frame,text="GPT-4o",variable=self.gpt_model_uri,value="gpt-4o",command=self.update_gpt_model_uri).grid(row=0, column=5, padx=5, sticky="w")

2. Добавляем функцию запроса к OpenAI через proxy

# Запрос к ChatGPT через ProxiAPI
    def answer_from_proxiapi(self, user_input, system_message, user_temperature, model): 
        # Проверка наличия ключа ProxiAPI
        if not self.reg_proxi_apy or not self.reg_proxi_apy.strip():
            messagebox.showwarning("Предупреждение", "Введите ключ к ProxyAPI")
            return       
        prompt = {
            "model": model,
            "messages": [
                {"role": "system", "content": system_message},
                {"role": "user", "content": user_input}
            ],
            "temperature": user_temperature,
            "max_tokens": 64000
        }

        url = "https://api.proxyapi.ru/openai/v1/chat/completions"
        headers = {
            "Content-Type": "application/json",
            "Authorization": f"Bearer {self.reg_proxi_apy}"
        }

        try:
            response = requests.post(url, headers=headers, json=prompt)
            response.raise_for_status()  # Проверка статуса HTTP-запроса
            result = response.json()

            assistant_text = result.get("choices", [{}])[0].get("message", {}).get("content", "Ошибка: Ответ отсутствует.")
            self.insert_to_result_label(f" GPT: \n{assistant_text}\n\n")
        except requests.exceptions.RequestException as e:
            messagebox.showerror("Ошибка", f"Ошибка при выполнении запроса: {e}")

3 Добавляем в # Функция при нажатии кнопки «Отправить» def on_submit(self) условие выбора модели при отправке промпта

# Выбор модели и вызов соответствующей функции        
        if self.gpt_model_uri_get in ["gpt-4o-mini", "gpt-4o"]:
            self.answer_from_proxiapi(entered_text, system_message, user_temperature, self.gpt_model_uri_get)
        else:
            self.answer_from_yandex_gpt(entered_text, system_message, user_temperature, self.default_folder, self.api_key)

4. Добавляем в интерфейс главного окна ввод ключа proxyapi

self.main_menu.add_command(label="Авторизация ProxyAPI", command=self.show_registration_proxiapi)

5. Добавляем функцию ввода ключа proxy

# Функция окна Авторизации ProxiAPI
    def show_registration_proxiapi(self):
        registration_window = tk.Toplevel(self.root)
        self.registration_window_close = registration_window
        registration_window.title("Авторизация в ProxyAPI")

        # Добавление элементов интерфейса
        tk.Label(registration_window, text="Введите ключ proxyapi").grid(row=0, column=0, padx=10, pady=10)
        self.proxy_key_entry = tk.Text(registration_window, wrap="word", width=40, height=1)     
        self.proxy_key_entry.bind('<KeyRelease>', lambda event: self.validate_input(event, registration_window))
        self.proxy_key_entry.grid(row=1, column=0, padx=10, pady=0)

        register_button = tk.Button(registration_window, text=" Войти ", command=self.register_proxiapi_user)
        register_button.grid(row=2, columnspan=2, padx=10, pady=15)

        # Добавление контекстного меню
        context_menu = tk.Menu(registration_window, tearoff=0)
        context_menu.add_command(label="Копировать", command=lambda: self.copy_text_to_clipboard(self.proxy_key_entry))
        context_menu.add_command(label="Вставить", command=lambda: self.paste_text_from_clipboard(self.proxy_key_entry))
        self.proxy_key_entry.bind("<Button-3>", lambda event: context_menu.post(event.x_root, event.y_root)) # Привязка контекстного меню к правой кнопке мыши

        # Обновлённая геометрия
        registration_window_width = 355
        registration_window_height = 120  # Новая высота
        registration_window.resizable(False, False)
        screen_width = self.root.winfo_screenwidth()
        screen_height = self.root.winfo_screenheight()
        x = (screen_width - registration_window_width) // 2
        y = (screen_height - registration_window_height) // 2  
        registration_window.geometry(f"{registration_window_width}x{registration_window_height}+{x}+{y}")

        # Настройка модальности
        registration_window.transient(self.root)
        registration_window.wait_visibility()
        registration_window.grab_set()
        registration_window.focus_force()
        self.root.wait_window(registration_window)

6. Добавляем функцию сохранения ключа proxy в файл JSON

# функция для сохранения ключа ProxiAPI в файл JSON:
    def register_proxiapi_user(self):
        proxy_api_key = self.proxy_key_entry.get("1.0", "end-1c").strip()

        if len(proxy_api_key.strip()) > 40:
            messagebox.showwarning("Предупреждение", "Превышено количество символов ключа ProxyAPI (максимум 40 символов).")
            return    

        if not proxy_api_key.strip():
            messagebox.showwarning("Предупреждение", "Введите ключ ProxyAPI")
            return

        self.reg_proxi_apy = proxy_api_key # Значение self.reg_proxi_apy потом используется при запросе ProxyAPI

        filename = "Login_SmartiksGPT.json"

        # Загружаем существующие данные из файла, если файл существует
        if os.path.exists(filename):
            try:
                with open(filename, "r") as file:
                    existing_data = json.load(file)
            except json.JSONDecodeError:
                existing_data = {}  # Если файл пустой или поврежден, создаем пустой словарь
        else:
            existing_data = {}  # Если файл не существует, создаем пустой словарь

        # Добавляем новый ключ к существующим данным
        existing_data["self.reg_proxi_apy"] = self.reg_proxi_apy

        # Сохраняем обновленные данные обратно в файл
        try:
            with open(filename, "w") as file:
                json.dump(existing_data, file, indent=4)
            print(f"Ключ ProxyAPI успешно добавлен в JSON файл '{filename}'.")
        except Exception as e:
            print(f"Ошибка при сохранении файла: {e}")
            messagebox.showerror("Ошибка", "Не удалось сохранить ключ ProxyAPI.")
            return

        # Закрываем окно авторизации
        self.registration_window_close.destroy()

Вот и всё, два дня и готово. Теперь наслаждаемся импортными ответами на отечественные промпты. Готовый и рабочий код копируем в блокнот, сохраняем с расширением.py (естественно у вас установлен интерпретатор Питона как рассказано в предыдущей статье) например SmartikGPT.py в кодировке UTF-8 (при сохранении выбрать нужную кодировку) и всё должно заработать. Можно данный код скомпилировать в готовый exe файл, командой — в cmd или Windows PowerShell.

pyinstaller --onefile –noconsole SmartiksGPT.py

Код программы SmartiksGPT

# Импорт библиотек
import tkinter as tk
from tkinter import ttk
from tkinter import Menu
from tkinter import messagebox 
import requests
import json
import os
from transliterate import translit
import winsound 
import re                     


# Определение класса DraggableWindow - главное окно
class DraggableWindow:
    def __init__(self, root):
        # Инициализация окна
        self.root = root
        self.root.title("SmartiksGPT")                                        # Заголовок окна
        self.is_dragging = False
        initial_width = 838
        initial_height = 600
        screen_width = root.winfo_screenwidth()
        screen_height = root.winfo_screenheight()
        x = (screen_width - initial_width) // 2
        y = (screen_height - initial_height) // 2
        self.root.geometry(f"{initial_width}x{initial_height}+{x}+{y}")       # Установка размеров и позиции окна
        self.root.option_add('*BorderWidth', 3)
        self.root.option_add('*highlightThickness', 0)
        self.root.resizable(False, False)                                     # Запрет изменения размеров окна
        
        # Константы для proxyAPI
        self.PROXY_API_URL = "https://api.proxyapi.ru/openai/v1/chat/completions"

        self.create_specialization_data()

        # Создание меню 
        self.root = root
        self.main_menu = tk.Menu(root)
        self.info_menu = tk.Menu(self.main_menu, tearoff=0)
        self.main_menu.add_cascade(label="Информация", menu=self.info_menu)        
        self.main_menu.add_command(label="Авторизация Yandex", command=self.show_registration_yandex)  # Добавление пункта "Регистрация"
        self.main_menu.add_command(label="Авторизация ProxyAPI", command=self.show_registration_proxiapi)  
        self.info_menu.add_command(label="Руководство", command=self.show_guide)
        self.info_menu.add_command(label="О программе", command=self.show_about)       
        self.root.config(menu=self.main_menu)
                                 
        self.gpt_model_uri = tk.StringVar(value="yandexgpt")                       # Присваиваем переменной self.gpt_model_uri строковое значение "yandexgpt", эта переменная используется в строке "modelUri": f"gpt://...логин папки.../{self.gpt_model_uri_get}
        self.gpt_model_uri_get = self.gpt_model_uri.get()                          # Присваиваем переменной self.gpt_model_uri_get значение self.gpt_model_uri (очищаем от ненужных атрибутов tk.StringVar что бы корректно работало в запросе"modelUri": f"gpt://...логин папки.../{self.gpt_model_uri_get})

        self.description_text = ""                                                 # Устанавливаем значение self.description_text пустое
        
        self.system_message = "Ты умный ассистент"
        
        self.selected_value = tk.StringVar()                                       # Переменная для хранения значения креативности
        
        self.selected_value.set("0.6")                                             # Устанавливаем значение креативности по умолчанию

        self.selected_specialization = tk.StringVar(value="Список специализаций")  # Присваиваем переменной self.selected_specialization строковое значение value="Список специализаций"

        # Добавляем строку чтобы создать атрибут selected_specialization
        self.selected_specialization = tk.StringVar(root)
        self.selected_specialization.set("Список специализаций")

        # Виджет для вывода результата
        self.result_label = tk.Text(self.root, wrap="word", width=100, height=20, padx=5, state='disabled')
        self.result_label.grid(row=0, column=0, columnspan=10, sticky="ew", pady=2)

        # Метка для ввода сообщения пользователя
        self.entry_label = tk.Label(self.root, text="Введите сообщение :")                                       # Cоздаём экземпляр класса tk.Label (просто текст) и присваивается ему наименование self.entry_label
        self.entry_label.grid(row=1, column=0, padx=5, pady=10)

        # Виджет для ввода сообщения пользователем
        self.entry = tk.Text(self.root, wrap="word", width=70, height=5, padx=2)                                 # Cоздаём экземпляр класса tk.Text (текстовый виджет) и присваивается ему наименование self.entry, wrap="word" означает  что текст будет переносится по словам  
        self.entry.grid(row=1, column=1, columnspan=5, pady=10, padx=10, sticky="ew")
        self.entry_context_menu = tk.Menu(root, tearoff=0)
        self.entry_context_menu.add_command(label="Копировать", command=self.copy_entry_text)
        self.entry_context_menu.add_command(label="Вставить", command=self.paste_entry_text)
        self.entry.bind("<Button-3>", self.show_entry_context_menu)

        # Кнопка для отправки сообщения
        self.submit_button = tk.Button(self.root, text="Отправить", command=self.on_submit)
        self.submit_button.grid(row=1, column=6, pady=5)

        # Назначение клавиш Enter и Shift-Enter для отправки сообщения
        self.entry.bind("<Return>", self.handle_enter_key)
        self.entry.bind("<Shift-Return>", self.handle_shift_enter_key)
        self.entry.focus_set()

        # Контекстное меню для результата
        self.context_menu = tk.Menu(root, tearoff=0)
        self.context_menu.add_command(label="Копировать", command=self.copy_text)
        self.result_label.bind("<Button-3>", self.show_context_menu)

        # Кнопка и виджет для специализации
        self.specialization_button = tk.Button(self.root, text="Специализация", command=self.show_specialization_popup)
        self.specialization_button.grid(row=2, column=0, pady=5, padx=15, sticky="w")
        self.specialization_widget = tk.Text(self.root, wrap="word", width=40, height=1, padx=2, state='disabled')
        self.specialization_widget.grid(row=2, column=1, pady=5, padx=0, sticky="w")

        # Установка по умолчанию текста "Ассистент" в виджет специализации
        self.specialization_widget.config(state='normal')  # Включаем режим редактирования
        self.specialization_widget.insert(tk.END, "Ассистент")
        self.specialization_widget.config(state='disabled')  # Заново отключаем режим редактирования

        # Кнопка для установки креативности
        self.creativity_button = tk.Button(self.root, text="Креативность", command=self.show_creativity_popup)
        self.creativity_button.grid(row=2, column=2, pady=5, padx=5, sticky="e")

        # Виджет для отображения числового значения креативности
        self.numbers_widget = tk.Text(self.root, wrap="word", width=3, height=1, state='disabled')
        self.numbers_widget.grid(row=2, column=3, pady=5, padx=15, sticky="w")

        # Кнопка для очистки беседы
        self.clear_button = tk.Button(self.root, text="Очистить беседу", command=self.clear_result_label)
        self.clear_button.grid(row=2, column=6, pady=5, padx=5, sticky="w")

        # Обновляем виджет с числовым значением при создании окна
        self.update_numbers_widget()

        # Словарь для хранения данных специализации
        self.specialization_data = {}

        # Виджет Выбор модели YandexGPT
        self.model_selection_frame = tk.Frame(self.root)
        self.model_selection_frame.grid(row=3, column=0, columnspan=7, pady=10, padx=10, sticky="w")

        tk.Label(self.model_selection_frame, text="Используемая модель:", anchor="w").grid(row=0, column=0, sticky="w")

        tk.Radiobutton(self.model_selection_frame,text="YandexGPT",variable=self.gpt_model_uri,value="yandexgpt",command=self.update_gpt_model_uri).grid(row=0, column=1, padx=5, sticky="w")
        tk.Radiobutton(self.model_selection_frame,text="YandexGPT-lite",variable=self.gpt_model_uri,value="yandexgpt-lite",command=self.update_gpt_model_uri).grid(row=0, column=2, padx=5, sticky="w")
        tk.Radiobutton(self.model_selection_frame,text="GPT-4o mini",variable=self.gpt_model_uri,value="gpt-4o-mini",command=self.update_gpt_model_uri).grid(row=0, column=4, padx=5, sticky="w")
        tk.Radiobutton(self.model_selection_frame,text="GPT-4o",variable=self.gpt_model_uri,value="gpt-4o",command=self.update_gpt_model_uri).grid(row=0, column=5, padx=5, sticky="w")

        # Настройка фиксированной ширины для первой колонки
        self.root.grid_columnconfigure(0, weight=1)
        self.root.grid_columnconfigure(1, weight=0)

        default_folder, api_key = self.read_login_credentials('Login_SmartiksGPT.json') # Загружаем из файла Login_SmartiksGPT.json данные в переменные default_folder и api_key
        if default_folder is not None and api_key is not None:
            print("Значения из файла успешно загружены:")
            print("Default Folder:", default_folder)
            print("API Key:", api_key)
        else:
            messagebox.showwarning("Внимание", "Для работы программы необходимо авторизоваться в YandexGPT API и ввести в программу данные авторизации - идентификатор default folder и API ключ")   # Системное сообщение если нет файла с default_folder и api_key
            print("Не удалось загрузить значения из файла.")

    # Функция обновления значения переменной self.gpt_model_uri_get для использования модели yandexgpt или yandexgpt-lite
    def update_gpt_model_uri(self):
        #self.gpt_model_uri.set(value)                              # Присваиваем переменной self.gpt_model_uri выбранное значение tk.Radiobutton
        self.gpt_model_uri_get = self.gpt_model_uri.get()          # Присваиваем переменной self.gpt_model_uri_get значение self.gpt_model_uri (очищаем от ненужных атрибутов tk.StringVar что бы корректно работало в запросе"modelUri": f"gpt://...логин папки.../{self.gpt_model_uri_get})
        print(f"Выбранная модель: {self.gpt_model_uri.get()}")

    # Функция окна Авторизации ProxyAPI
    def show_registration_proxiapi(self):
        registration_window = tk.Toplevel(self.root)
        self.registration_window_close = registration_window
        registration_window.title("Авторизация в ProxyAPI")

        # Добавление элементов интерфейса
        tk.Label(registration_window, text="Введите ключ proxyapi").grid(row=0, column=0, padx=10, pady=10)
        self.proxy_key_entry = tk.Text(registration_window, wrap="word", width=40, height=1)     
        self.proxy_key_entry.bind('<KeyRelease>', lambda event: self.validate_input(event, registration_window))
        self.proxy_key_entry.grid(row=1, column=0, padx=10, pady=0)


        register_button = tk.Button(registration_window, text=" Войти ", command=self.register_proxiapi_user)
        register_button.grid(row=2, columnspan=2, padx=10, pady=15)

        # Добавление контекстного меню
        context_menu = tk.Menu(registration_window, tearoff=0)
        context_menu.add_command(label="Копировать", command=lambda: self.copy_text_to_clipboard(self.proxy_key_entry))
        context_menu.add_command(label="Вставить", command=lambda: self.paste_text_from_clipboard(self.proxy_key_entry))
        self.proxy_key_entry.bind("<Button-3>", lambda event: context_menu.post(event.x_root, event.y_root)) # Привязка контекстного меню к правой кнопке мыши

        # Обновлённая геометрия
        registration_window_width = 355
        registration_window_height = 120  # Новая высота
        registration_window.resizable(False, False)
        screen_width = self.root.winfo_screenwidth()
        screen_height = self.root.winfo_screenheight()
        x = (screen_width - registration_window_width) // 2
        y = (screen_height - registration_window_height) // 2  
        registration_window.geometry(f"{registration_window_width}x{registration_window_height}+{x}+{y}")

        # Настройка модальности
        registration_window.transient(self.root)
        registration_window.wait_visibility()
        registration_window.grab_set()
        registration_window.focus_force()
        self.root.wait_window(registration_window)

    # функция для сохранения ключа ProxyAPI в файл JSON:
    def register_proxiapi_user(self):
        proxy_api_key = self.proxy_key_entry.get("1.0", "end-1c").strip()

        if len(proxy_api_key.strip()) > 40:
            messagebox.showwarning("Предупреждение", "Превышено количество символов ключа ProxyAPI (максимум 40 символов).")
            return    

        if not proxy_api_key.strip():
            messagebox.showwarning("Предупреждение", "Введите ключ ProxyAPI")
            return

        self.reg_proxi_apy = proxy_api_key # Значение self.reg_proxi_apy потом используется при запросе ProxyAPI

        filename = "Login_SmartiksGPT.json"

        # Загружаем существующие данные из файла, если файл существует
        if os.path.exists(filename):
            try:
                with open(filename, "r") as file:
                    existing_data = json.load(file)
            except json.JSONDecodeError:
                existing_data = {}  # Если файл пустой или поврежден, создаем пустой словарь
        else:
            existing_data = {}  # Если файл не существует, создаем пустой словарь

        # Добавляем новый ключ к существующим данным
        existing_data["self.reg_proxi_apy"] = self.reg_proxi_apy

        # Сохраняем обновленные данные обратно в файл
        try:
            with open(filename, "w") as file:
                json.dump(existing_data, file, indent=4)
            print(f"Ключ ProxyAPI успешно добавлен в JSON файл '{filename}'.")
        except Exception as e:
            print(f"Ошибка при сохранении файла: {e}")
            messagebox.showerror("Ошибка", "Не удалось сохранить ключ ProxyAPI.")
            return

        # Закрываем окно авторизации
        self.registration_window_close.destroy()

    # Функция окна Авторизации Yandex
    def show_registration_yandex(self):
        registration_window = tk.Toplevel(self.root)
        self.registration_window_close = registration_window  # Создаём переменную self.registration_window_close для использования в функции def register_user(self) для закрытия окна регистрации
        registration_window.title("Авторизация в YandexGPT API")

        # Добавление элементов интерфейса для регистрации
        tk.Label(registration_window, text="Введите идентификатор default folder:").grid(row=0, column=0, padx=10, pady=10)
        self.name_entry = tk.Text(registration_window,wrap="word", width=40, height=1)     
        self.name_entry.bind('<KeyRelease>', lambda event: self.validate_input(event, registration_window))
        self.name_entry.grid(row=1, column=0, padx=10, pady=0)

        tk.Label(registration_window, text="Введите API ключ:").grid(row=2, column=0, padx=10, pady=10)
        self.password_entry = tk.Text(registration_window, wrap="word", width=40, height=1)
        self.password_entry.bind('<KeyRelease>', lambda event: self.validate_input(event, registration_window))
        self.password_entry.grid(row=3, column=0, padx=10, pady=0)

        register_button = tk.Button(registration_window, text=" Войти ", command=self.register_user)
        register_button.grid(row=4, columnspan=2, padx=10, pady=15)

        # Добавление контекстного меню для self.name_entry
        name_context_menu = tk.Menu(registration_window, tearoff=0)
        name_context_menu.add_command(label="Копировать", command=lambda: self.copy_text_to_clipboard(self.name_entry))
        name_context_menu.add_command(label="Вставить", command=lambda: self.paste_text_from_clipboard(self.name_entry))
        self.name_entry.bind("<Button-3>", lambda event: name_context_menu.post(event.x_root, event.y_root))

        # Добавление контекстного меню для self.password_entry
        password_context_menu = tk.Menu(registration_window, tearoff=0)
        password_context_menu.add_command(label="Копировать", command=lambda: self.copy_text_to_clipboard(self.password_entry))
        password_context_menu.add_command(label="Вставить", command=lambda: self.paste_text_from_clipboard(self.password_entry))
        self.password_entry.bind("<Button-3>", lambda event: password_context_menu.post(event.x_root, event.y_root))

       # Установка размеров и позиции окна регистрации
        registration_window_width = 355
        registration_window_height = 194
        registration_window.resizable(False, False)  # Запрет изменения размеров окна
        screen_width = self.root.winfo_screenwidth()
        screen_height = self.root.winfo_screenheight()
        x = (screen_width - registration_window_width) // 2
        y = (screen_height - registration_window_height) // 2  
        registration_window.geometry(f"{registration_window_width}x{registration_window_height}+{x}+{y}")

        # Настройка окна регистрации как transient и открытие его в модальном режиме
        registration_window.transient(self.root)
        registration_window.wait_visibility()  # Ждем, пока окно станет видимым
        registration_window.grab_set_global()  # Глобально захватываем фокус

        # Захват фокуса и установка активности окна регистрации
        registration_window.grab_set()
        registration_window.focus_force()
        self.root.wait_window(registration_window)

    # Функция проверки символов в окне Авторизации и записи в Json файл 
    def register_user(self):
       
        # Получаем значения из виджетов
        default_folder_reg = self.name_entry.get("1.0", "end-1c").strip()
        api_key_reg = self.password_entry.get("1.0", "end-1c").strip()

        # Проверка на отсутствие символов и превышение количества символов
        if not default_folder_reg.strip():
            messagebox.showwarning("Предупреждение", "Введите идентификатор default folder")
            return
        if len(default_folder_reg.strip()) > 40:
            messagebox.showwarning("Предупреждение", "Превышено количество символов идентификаторе default folder (максимум 40 символов).")
            return
    
        if not api_key_reg.strip():
            messagebox.showwarning("Предупреждение", "Введите API ключ")
            return
        if len(api_key_reg.strip()) > 40:
            messagebox.showwarning("Предупреждение", "Превышено количество символов в API ключе (максимум 40 символов)")
            return

        # Проверка, что все символы логина и пароля являются латинскими буквами или цифрами
        if not default_folder_reg.isalnum() or not default_folder_reg.isascii():
            messagebox.showwarning("Предупреждение", "Идентификатор default folder должен содержать только латинские буквы и цифры")
            return
        if not api_key_reg.isalnum() or not api_key_reg.isascii():
            messagebox.showwarning("Предупреждение", "API ключ должен содержать только латинские буквы и цифры")
            return

        self.default_folder = default_folder_reg
        self.api_key = api_key_reg

        # Создаем словарь для JSON
        data = {
            "self.default_folder": self.default_folder,
            "self.api_key": self.api_key
        }

        filename = "Login_SmartiksGPT.json"  # Создаем JSON файл
        with open(filename, "w") as file:
            json.dump(data, file, indent=4)

        print(f"JSON файл '{filename}' создан успешно.")

        self.registration_window_close.destroy()                         # Закрываем окно регистрации
   
    # Функция проверки вводимых символов (должны быть латинские или цифры)
    def validate_input(self, event, registration_window):
        key_code = event.keycode                   # Получаем код клавиши
    

        if key_code == 8 or key_code in {37, 38, 39, 40} or (event.keysym == "Shift_L" or event.keysym == "Shift_R" or event.keysym == "Alt_L" or event.keysym == "Alt_R"): # Проверяем, что это не Backspace, стрелки или Shift или Alt что бы не было ложного срабатывания messagebox
            return True

        new_text = event.widget.get("1.0", "end-1c")

        max_chars = 40                           # Устанавливаем количество символов
        if len(new_text) >= max_chars:           
            return "break"                       # Останавливаем ввод новых символов
        
        if new_text == "":                                                         # Проверяем, что поле ввода не пустое
            return True
        
        if new_text and not re.match(r'^[a-zA-Z0-9\s]*$', new_text):
            registration_window.grab_set()
            tk.messagebox.showerror("Предупреждение", "Допустимы только латинские буквы и цифры")
            return False
        

    # Функция чтения файла Логина и пароля self.default_folder и self.api_key
    def read_login_credentials(self, file_path):
        try:
            with open(file_path, 'r') as file:
                data = json.load(file)
                self.default_folder = data.get('self.default_folder')
                self.api_key = data.get('self.api_key')
                self.reg_proxi_apy = data.get('self.reg_proxi_apy')
                return self.default_folder, self.api_key
        except FileNotFoundError:
            print(f"Файл {file_path} не найден.")
            return None, None
        except json.JSONDecodeError:
            print(f"Ошибка при декодировании файла {file_path}.")
            return None, None

    # Обработчик события для клавиши Enter
    def handle_enter_key(self, event):
        
        if event.state & 0x1:  # Проверка, что нажата клавиша Shift (bitwise AND с 0x1)
            self.entry.insert(tk.INSERT, '\n')  # Вставляем символ новой строки
        else:
            self.on_submit()

    def handle_shift_enter_key(self, event):       
        
        self.entry.insert(tk.INSERT, '\n')

    # Функция всплывающего окна для установки значения креативности в главном окне
    def show_creativity_popup(self):

        popup = tk.Toplevel(self.root)
        popup.title("Выберите значение")
        values = ["0.0", "0.1", "0.2", "0.3", "0.4", "0.5", "0.6", "0.7", "0.8", "0.9", "1.0"]
        dropdown = tk.OptionMenu(popup, self.selected_value, *values)
        dropdown.pack(pady=10)
        apply_button = tk.Button(popup, text="Применить", command=lambda: self.update_temperature_and_close(popup))
        apply_button.pack(pady=10)
        # Установка размеров и позиции всплывающего окна
        popup_width = 170
        popup_height = 100
        screen_width = self.root.winfo_screenwidth()
        screen_height = self.root.winfo_screenheight()
        x = (screen_width - popup_width) // 2
        y = (screen_height - popup_height) // 2
        popup.geometry(f"{popup_width}x{popup_height}+{x}+{y}")
        popup.transient(self.root)
        popup.grab_set()
        popup.resizable(width=False, height=False) # Блокировка изменения размеров окна
        popup.focus_force()  # Установка фокуса (всплывающее окно становиться активным)
        self.root.wait_window(popup)

    # Функция для обновления виджета с числовым значением
    def update_numbers_widget(self):
        
        self.numbers_widget.config(state='normal')
        self.numbers_widget.delete("1.0", tk.END)
        self.numbers_widget.insert(tk.END, self.selected_value.get())
        self.numbers_widget.config(state='disabled')


    # Функция для обновления температуры и закрытия всплывающего окна
    def update_temperature_and_close(self, popup):
        
        self.update_numbers_widget()
        popup.destroy()


    # Функция при нажатии кнопки "Отправить"
    def on_submit(self):
        entered_text = self.entry.get("1.0", "end-1c").strip()               # Получение текста из виджета self.entry

         # Если entered_text пусто, показываем всплывающее сообщение "Введите описание специализации"
        if not entered_text:
            messagebox.showwarning("Предупреждение", "Введите сообщение")
            return
        
        # Проверка количества символов в сообщении
        entered_text_previshenie = len(entered_text) - 19000        # Вычисление количества превысивших символов
        if len(entered_text) > 19000: 
            messagebox.showwarning("Предупреждение", f"Количество символов в сообщении превысило лимит на {entered_text_previshenie} шт.")
            return
        
        if not entered_text:  # Проверка, что введенный текст не пустой
            return
        user_message = f" Пользователь: \n{entered_text}\n"                   # Вставка в переменную user_message выражения Пользователь: \n{entered_text}\n в котором находится значение переменной entered_text и всё это обрамляется {} т.к. стоит f
        self.insert_to_result_label(user_message)
        self.entry.delete("1.0", tk.END)


        # Устанавливается значение переменной system_message в зависимости от наличия текста в переменной self.description_text (описание промпта при выборе из списка специализаций)
        if self.description_text:                                            # Если self.description_text истинно (там есть какоке то значение)
            system_message = self.description_text                           # то system_message примет значение self.system_message = "Ты умный ассистент"
        else:                                                                # Иначе (self.description_text пусто (ложно)
            system_message = self.system_message                             # system_message примет значение self.system_message

        # Обновляем значение параметра temperature в методе answer_from_yandex_gpt
        user_temperature_str = self.selected_value.get()
        if not user_temperature_str:
            return
        user_temperature = float(user_temperature_str)                              # Преобразование строки значения температуры в число с плавающей запятой и присваивание значения user_temperature
        self.user_temperature = user_temperature                                    # Присваивание значения user_temperature в self.user_temperature
    

        # Выбор модели и вызов соответствующей функции
        #selected_model = self.gpt_model_uri.get()
        
        if self.gpt_model_uri_get in ["gpt-4o-mini", "gpt-4o"]:
            self.answer_from_proxiapi(entered_text, system_message, user_temperature, self.gpt_model_uri_get)
        else:
            self.answer_from_yandex_gpt(entered_text, system_message, user_temperature, self.default_folder, self.api_key)



    # Функция очистки беседы при нажатии кнопки "Очистить"
    def clear_result_label(self):
        self.result_label.config(state='normal')
        self.result_label.delete('1.0', tk.END)
        self.result_label.config(state='disabled')

    # Функция для вставки сообщение окна беседы с YandexGPT result_label
    def insert_to_result_label(self, message):
        self.result_label.config(state='normal')
        self.result_label.insert(tk.END, message)
        self.result_label.see(tk.END)
        self.result_label.config(state='disabled')

    # Функция формирование запроса к Yandex GPT
    def answer_from_yandex_gpt(self, user_input, system_message, user_temperature, default_folder, api_key):
        
        prompt = {
            "modelUri": f"gpt://{default_folder}/{self.gpt_model_uri_get}",
            "completionOptions": {
                "stream": False,
                "temperature": user_temperature,
                "maxTokens": "2000"
            },
            "messages": [
                {"role": "system", "text": system_message},
                {"role": "user", "text": user_input}
            ]
        }

        #print("Prompt temperature:", prompt["completionOptions"]["temperature"])

        # Отправка запроса к Yandex GPT
        url = "https://llm.api.cloud.yandex.net/foundationModels/v1/completion"
        headers = {
            "Content-Type": "application/json",
            "Authorization": f"Api-Key {api_key}"
        }

        response = requests.post(url, headers=headers, json=prompt)
        result = response.text

        result_json = json.loads(result)
        assistant_text = result_json['result']['alternatives'][0]['message']['text']
        response_temperature = result_json['result']['alternatives'][0]['message'].get('temperature')
        if response_temperature is not None:
            print("Response temperature:", response_temperature)

        # Проверяем, чтобы текст не был добавлен повторно
        if not self.result_label.get("1.0", tk.END).strip().endswith(assistant_text):
            self.insert_to_result_label(f"YandexGPT: \n{assistant_text}\n\n")



         # Выводим значение system_message в консоль
        print("Температура запроса:", prompt["completionOptions"]["temperature"])    
        print("Системное сообщение:", system_message)       
        print("Используемая модель:", self.gpt_model_uri_get)


        # Вывод данных специализации в консоль
        #self.print_specialization_data()
        
        # Вывод ответа от YandexGPT в консоль
        print(result)

    # Создание нового всплывающего окна (Toplevel) "Специализация" и установка его заголовка
    def show_specialization_popup(self):
        
        popup = tk.Toplevel(self.root)
        popup.title("Специализация")
        
        # Устанавливает значение креативности по умолчанию
        self.selected_value.set("0.0")
        
        # Установка "Список специализаций" по умолчанию при каждом запуске
        self.selected_specialization.set("Список специализаций")

        # Загрузка данных из файла specialization_data.pkl
        try:
            with open("specialization_data.json", "rb") as file:
                self.specialization_data = json.load(file)
        except FileNotFoundError:
            print("Файл specialization_data.json не найден.")
            # Если файл отсутствует, устанавливаем пустой словарь
            self.specialization_data = {}
            # Присваиваем "Список специализаций" при отсутствии файла
            self.selected_specialization.set("Список специализаций")

        # Получение списка name из словаря self.specialization_data 
        specialization_keys = [spec['name'] for spec in self.specialization_data.values()]

        tk.Label(popup, text="Специализация").grid(row=0, column=0, pady=10)

        # Ограничение длины ключей до символов
        max_key_length = 40
        filtered_specialization_keys = [key[:max_key_length] for key in specialization_keys]

        # Создание виджета OptionMenu и передача списка ключей
        if filtered_specialization_keys:                                                                                   # Проверяет, есть ли какие-либо значения в переменной filtered_specialization_keys
            specialization_dropdown = tk.OptionMenu(popup, self.selected_specialization, *filtered_specialization_keys, command=self.on_specialization_select)    # Если условие из предыдущей строчки истинно, то создается выпадающий список (OptionMenu). self.selected_specialization это переменная которая будет использоваться для отслеживания выбранного значения
        else:                                                                                                              # Если в выпадающем списке (переменная filtered_specialization_keys) нет значений
            specialization_dropdown = tk.OptionMenu(popup, self.selected_specialization, "Нет данных")                     # будет только один пункт с текстом "Нет данных"
        specialization_dropdown.grid(row=0, column=1, columnspan=2, padx=25, pady=10, sticky="ew")                         # Размещение выпадающего списка на сетке окна
        specialization_dropdown.config(height=1, anchor="n", width=40)                                                     # anchor="n" выравнивает текст по высоте внутри виджета и смещает его сверху в центр

        delete_button = tk.Button(popup, text=" Удалить ", command=lambda: self.delete_selected_specialization(popup), fg="red", activeforeground="red")
        delete_button.grid(row=0, column=3, padx=14, pady=10, sticky="e")

        # Создание виджета для ввода параметров специализации
        tk.Label(popup, text="Создание и редактирование  специализации:").grid(row=1, column=0, columnspan=7, pady=10)

        # Создание метки и виджета для ввода названия специализации
        tk.Label(popup, text="Название:").grid(row=2, column=0, padx=5, pady=10)
        self.specialization_entry = tk.Text(popup,wrap="word", width=40, height=1, padx=2)
        self.specialization_entry.bind("<Key>", self.enforce_maxlength)                # Привязываем метод ограничения символов (elf.enforce_maxlength) к событию Key
        self.specialization_entry.grid(row=2, column=1, padx=5, pady=10)
        self.specialization_entry.bind("<KeyPress-Return>", lambda e: "break")        # Отключаем клавишу Enter в виджете что бы корректно сохранялось название Специализации
        

        # Добавление контекстного меню для виджета specialization_entry
        entry_context_menu = Menu(popup, tearoff=0)
        entry_context_menu.add_command(label="Копировать", command=lambda: self.copy_text_to_clipboard(self.specialization_entry))
        entry_context_menu.add_command(label="Вставить", command=lambda: self.paste_text_from_clipboard(self.specialization_entry))
        self.specialization_entry.bind("<Button-3>", lambda event: entry_context_menu.post(event.x_root, event.y_root))

        # Создание метки и виджета для выбора параметра креативности
        tk.Label(popup, text="Креативность:").grid(row=3, column=0, padx=5, pady=10)
        creativity_values = ["0.0", "0.1", "0.2", "0.3", "0.4", "0.5", "0.6", "0.7", "0.8", "0.9", "1.0"]
        self.creativity_dropdown = tk.OptionMenu(popup, self.selected_value, *creativity_values)
        self.creativity_dropdown.grid(row=3, column=1, padx=5, pady=10)

        # Создание метки и виджета для ввода описания специализации
        tk.Label(popup, text="Описание:").grid(row=4, column=0, padx=5, pady=10)
        self.description_text_spec = tk.Text(popup, wrap="word", width=40, height=5, padx=2)
        self.description_text_spec.grid(row=4, column=1, padx=5, pady=10)

        # Добавление контекстного меню для виджета self.description_text_spec
        description_context_menu = tk.Menu(popup, tearoff=0)
        description_context_menu.add_command(label="Копировать", command=lambda: self.copy_text_to_clipboard(self.description_text_spec))
        description_context_menu.add_command(label="Вставить", command=lambda: self.paste_text_from_clipboard(self.description_text_spec))
        self.description_text_spec.bind("<Button-3>", lambda event: description_context_menu.post(event.x_root, event.y_root))

        # Создание кнопки для применения и привязка к ней метода apply_specialization с передачей параметров
        self.apply_button = tk.Button(popup, text="Применить", command=lambda: self.apply_specialization(popup, self.specialization_entry.get("1.0", tk.END), self.description_text_spec))
        self.apply_button.grid(row=4, column=3, padx=5, pady=10)

        # Установка размеров и позиции всплывающего окна
        popup_width = 530
        popup_height = 307
        popup.resizable(False, False)                        # Запрет изменения размеров окна
        screen_width = self.root.winfo_screenwidth()
        screen_height = self.root.winfo_screenheight()
        x = (screen_width - popup_width) // 2
        y = (screen_height - popup_height) // 2
        popup.geometry(f"{popup_width}x{popup_height}+{x}+{y}")

        # Настройка всплывающего окна как transient и открытие его в модальном режиме
        popup.transient(self.root)
        popup.wait_visibility()                                                            # Ждем, пока окно станет видимым
        popup.grab_set_global()                                                            # Глобально захватываем фокус

        # Захват фокуса и установка активности всплывающего окна
        popup.grab_set()
        popup.focus_force()
        self.root.wait_window(popup.winfo_toplevel())

    # Функция ограничения количества символов вводимых в название специализации
    def enforce_maxlength(self, event):
        max_chars = 40
        if len(self.specialization_entry.get("1.0", "end-1c")) >= max_chars:
            if event.keysym not in ["BackSpace", "Delete"]:                                 # Разрешаем удаление символов
                return "break"


    # Получение данных о выбранной специализации из self.specialization_data
    def on_specialization_select(self, specialization):
        
        specialization_data = self.specialization_data.get(specialization, {})

        self.key = specialization_data.get('key', '')
    
        # Обновление виджетов в соответствии с данными о специализации
        self.specialization_entry.delete('1.0', tk.END)  # Очистка текстового поля
        self.specialization_entry.insert('1.0', specialization_data.get('name', ''))  # Вставка названия специализации
    
        selected_creativity = specialization_data.get('creativity', '')  # Получение креативности специализации
        self.selected_value.set(selected_creativity)  # Установка выбранной креативности в выпадающем списке
    
        self.description_text_spec.delete('1.0', tk.END)  # Очистка текстового поля
        self.description_text_spec.insert('1.0', specialization_data.get('description', ''))  # Вставка описания специализации    

    # Функция Копировать  для окна "Специализация"
    def copy_text_to_clipboard(self, widget):
        selected_text = widget.get("sel.first", "sel.last")
        self.root.clipboard_clear()
        self.root.clipboard_append(selected_text)
        self.root.update()


    def paste_text_from_clipboard(self, widget):
        try:
            # Получение выделенного текста в виджете
            selected_text = widget.get(tk.SEL_FIRST, tk.SEL_LAST)
        
            # Если есть выделенный текст, удаляем его
            if selected_text:
                widget.delete(tk.SEL_FIRST, tk.SEL_LAST)
        except tk.TclError:
            # Обработка ошибки, если выделенного текста нет
            pass

        # Вставка текста из буфера обмена в виджет
        text_to_paste = self.root.clipboard_get()
        widget.insert(tk.INSERT, text_to_paste)   


    # Функция кнопки "Применить" в окне "Специализация"
    def apply_specialization(self, popup, specialization_name, description_text_spec):
        if isinstance(description_text_spec, tk.Text):                 # Проверка, является ли description_text_spec объектом класса tk.Text. Если это так, то извлекается текст из виджета tk.Text и сохраняется в переменной system_message
            system_message = description_text_spec.get("1.0", tk.END).strip()
        else:                                                     # Если нет, то используется строковое представление description_text_spec
            system_message = str(description_text_spec).strip()  

        variable_name = specialization_name[:40]                  # Создание переменной variable_name, которая содержит первые 40 символов из строки specialization_name. Это используется в качестве уникального идентификатора для данных о специализации.
        
        formatted_text = specialization_name                      # Создание переменной formatted_text, которая получает значение specialization_name

        # Если specialization_name пусто, показываем всплывающее сообщение "Введите название специализации"
        if not specialization_name.strip():                                                # strip() очищает specialization_name от символов пробела и перевода строки для корректной работы условия
            messagebox.showwarning("Предупреждение", "Введите название специализации")
            return

        # Если system_message пусто, показываем всплывающее сообщение "Введите описание специализации"
        if not system_message:
            messagebox.showwarning("Предупреждение", "Введите описание специализации")
            return
        
        # Проверка количества символов в названии специализации
        if len(specialization_name.strip()) > 40: 
            messagebox.showwarning("Предупреждение", "Количество символов в названии специализации превысело 40 символов")
            return
        
        # Проверка количества символов в описании специализации
        system_message_previshenie = len(system_message) - 3800        # Вычисление количества превысевших символов
        if len(system_message) > 3800: 
            messagebox.showwarning("Предупреждение", f"Количество символов в описании специализации превысило лимит на {system_message_previshenie} шт.")
            return

        self.specialization_widget.config(state='normal')         # Установка состояния виджета self.specialization_widget в 'normal' (возможность редактирования)
        self.specialization_widget.delete("1.0", tk.END)          # Очистка содержимого виджета self.specialization_widget с начала (строка "1.0") до конца (tk.END)
        self.specialization_widget.insert(tk.END, formatted_text) # Вставка  текста из formatted_text в виджет self.specialization_widget в конец (tk.END)
        self.specialization_widget.config(state='disabled')       # Установка состояния виджета self.specialization_widget в 'disabled' (невозможность редактирования)

        # Обновляем user_temperature из выбранного значения креативности
        user_temperature_str = self.selected_value.get()          # Получение значения из переменной self.selected_value и сохранение его в user_temperature_str
        if user_temperature_str:                                  # Проверка, что user_temperature_str не является пустой строкой
            self.user_temperature = float(user_temperature_str)   # Преобразование строки user_temperature_str в число с плавающей запятой и сохранение результата в self.user_temperature

        self.update_numbers_widget()                              # Вызов метода update_numbers_widget для обновления числового виджета
        #user_input = "Привет"                                     # Присвоение переменной user_input значения "Привет" что бы при создании специализации (промпта) к YandexGPT отправлялся запрос от пользователя и приходил ответ от YandexGPT, если не будет ответа будет ошибка с отсутствием ответа (result)

       
        # Переназначение значения переменной из виджета Описание для того что бы промпт (system_message) не сбрасывался на значение по умолчанию или не оставался отпредыдущего значения после выбора из Списка специализаций
        self.description_text_value = description_text_spec.get("1.0", tk.END).strip() # Преобразуем содержимое из виджета Описание в текст  
        self.system_message = self.description_text_value                         # Присвоение self.description_text_value значению по умолчанию self.system_message (по умолчанию "Отвечай как ассистент")
        self.description_text = self.system_message                               # Присвоение полученное self.system_message переменной self.description_text (значение которого остаётся после выбора из списка специализаций)


        # Отправление запроса к yandex_gpt при нажатии кнопки "Применить"
        #self.answer_from_yandex_gpt(user_input, self.description_text_value, self.user_temperature) # Вызов метода answer_from_yandex_gpt с передачей параметров user_input, system_message и self.user_temperature
        
        # Убирает \n (перевод строки) из key  name (откуда они там берутся не выяснил)
        variable_name = variable_name.strip()
        specialization_name = specialization_name.strip()

        # Проверяем, совпадает ли выбранная специализация с каким-либо ключом в словаре
        if self.selected_specialization.get() in self.specialization_data.keys():
            del self.specialization_data[self.selected_specialization.get()]  # Если да, удаляем этот ключ и его значение из словаря

        # Добавление данных о специализации в словарь self.specialization_data с использованием variable_name в качестве ключа
        self.specialization_data[variable_name] = {
            "name": specialization_name,
            "description": system_message,
            "creativity": self.user_temperature
        }

        self.save_specialization_data()                    # Сохранение данных о специализации в файл на локальном жёстком диске

        popup.destroy()                                    # Закрываем всплывающее окно


    # Функция удаления выбранной специализации
    def delete_selected_specialization(self, popup):
        if self.selected_specialization.get() in self.specialization_data.keys():
            del self.specialization_data[self.selected_specialization.get()] 
        else:
            print("Выбранной специализации нет в данных")
        
        self.save_specialization_data()

        popup.destroy()
        

    # Функция отображение контекстного меню для результата
    def show_context_menu(self, event):
        
        self.context_menu.post(event.x_root, event.y_root)
        

    # Копирование выделенного текста результата
    def copy_text(self):
        
        selected_text = self.result_label.get("sel.first", "sel.last")
        self.root.clipboard_clear()
        self.root.clipboard_append(selected_text)
        self.root.update()
        

    # Отображение контекстного меню для ввода сообщения
    def show_entry_context_menu(self, event):
        
        self.entry_context_menu.post(event.x_root, event.y_root)


    # Копирование выделенного текста ввода сообщения
    def copy_entry_text(self):
   
        selected_text = self.entry.get("sel.first", "sel.last")
        self.root.clipboard_clear()
        self.root.clipboard_append(selected_text)
        self.root.update()


    def paste_entry_text(self):
        try:
            # Получение выделенного текста в виджете
            selected_text = self.entry.get(tk.SEL_FIRST, tk.SEL_LAST)
            # Если есть выделенный текст, удаляем его
            if selected_text:
                self.entry.delete(tk.SEL_FIRST, tk.SEL_LAST)
        except tk.TclError:
            # Обработка ошибки, если выделенного текста нет
            pass
            # Вставка текста из буфера обмена в текущую позицию курсора в виджет ввода сообщения
        text_to_paste = self.root.clipboard_get()
        self.entry.insert(tk.INSERT, text_to_paste)


    # Функция для транслитерации текста в латиницу
    def transliterate_to_latin(self, text):
      
        return translit(text, 'ru', reversed=True)


    # Функция для сохранения специализаций в файл JSON на компьютер
    def save_specialization_data(self, filename="specialization_data.json"):
        try:
            with open(filename, "w") as file:
                json.dump(self.specialization_data, file)
            print(f"Специализация успешно сохранена в файле: {filename}")
        except Exception as e:
            print(f"Ошибка при сохранении специализации: {e}")


    # Функция загрузки данных о специализациях из файла JSON
    def load_specialization_data(self, filename="specialization_data.json"):
        try:
            with open(filename, "r") as file:
                self.specialization_data = json.load(file)
            print(f"Специализация успешно загружена из файла: {filename}")
        except FileNotFoundError:
            print("Файл specialization_data.json не найден.")
            self.specialization_data = {}
        except Exception as e:
                print(f"Ошибка при загрузке специализации из файла: {e}")


    # Функция для создания JSON файла с данными специализации при первом запуске
    def create_specialization_data(self):
        filename = "specialization_data.json"
        if os.path.exists(filename):                                           # Проверяем наличие файла
            print("Файл уже существует. Пропускаем создание нового файла.")
            return
        # Данные для записи в JSON файл Специализации
        specialization_data_new = {
            "Переводчик с английского на русский язык": {
                "name": "Переводчик с английского на русский язык",
            "description": "Переводи на русский язык полученные сообщения",
                "creativity": 0.6
            },
            "Исправление грамматических ошибок": {
                "name": "Исправление грамматических ошибок",
                "description": "Исправь грамматические, орфографические и пунктуационные ошибки в тексте. Сохраняй исходный порядок слов.",
                "creativity": 0.0
            },
            "Генерация описания товара": {
                "name": "Генерация описания товара",
                "description": "Ты — маркетолог. Напиши описание товара для маркетплейса. Используй заданные название товара, категорию и ключевые слова.",
                "creativity": 0.0
            },
            "Генерация рекламного объявления": {
                "name": "Генерация рекламного объявления",
                "description": "Ты — профессиональный маркетолог с опытом написания высококонверсионной рекламы. Для генерации рекламного текста ты изучаешь потенциальную целевую аудиторию и оптимизируешь рекламный текст так, чтобы он обращался именно к этой целевой аудитории. Напиши рекламный текст для следующих продуктов/услуг. Создай текст объявления с привлекающим внимание заголовком и убедительным призывом к действию, который побуждает пользователей к целевому действию.",
                "creativity": 0.0
            },
            "Генерация ответа на отзыв клиента": {
                "name": "Генерация ответа на отзыв клиента",
                "description": "Ты — коммьюнити-менеджер и работаешь с обратной связью клиентов на продукты и сервисы компании. Напиши вежливый ответ на отзыв покупателя в Интернете.",
                "creativity": 0.0
            },
            "Переписывание шаблонного ответа": {
                "name": "Переписывание шаблонного ответа",
                "description": "Ты — оператор клиентской поддержки. Переформулируй ответ так, будто он составлен оператором поддержки.",
                "creativity": 0.0
            },
            "Классификация обращений": {
                "name": "Классификация обращений",
                "description": "Классифицируй обращения клиента в подходящую категорию. Категории: Статус заказа, Возврат и обмен товаров, Характеристики продукта, Технические проблемы, Другое. В ответе укажи только категорию.",
                "creativity": 0.0
            },
            "Распознавание именованных сущностей": {
                "name": "Распознавание именованных сущностей",
                "description": "Найди все упомянутые даты и время в тексте. Выведи их, каждый с новой строки. Пример результата: 22-01-2019 17:00 Завтра 18:15 Вчера Если в тексте нет дат, верни 0.",
                "creativity": 0.0
            },
            "Нормализация чисел и дат": {
                "name": "Нормализация чисел и дат",
                "description": "Перепиши текст, заменяя все числа цифрами.",
                "creativity": 0.0
            },
            "Краткий пересказ статьи": {
                "name": "Краткий пересказ статьи",
                "description": "Выдели основные мысли из статьи.",
                "creativity": 0.0
            },
            "Ассистент": {
                "name": "Ассистент",
                "description": "Ты умный ассистент",
                "creativity": 0.6
            },
            "Маркетинговый текст": {
                "name": "Маркетинговый текст",
                "description": "Ты — опытный копирайтер. Напиши маркетинговый текст с учётом вида текста и заданной темы.",
                "creativity": 0.0
            },
            "Шеф-повар": {
                "name": "Шеф-повар",
                "description": "Я хочу, чтобы ты был моим личным шеф-поваром. Я расскажу тебе о своих диетических предпочтениях и аллергиях, а ты предложишь мне попробовать рецепты. В ответе ты должен указать только те рецепты, которые ты порекомендуешь, и ничего больше. Не пиши объяснений.",
                "creativity": 0.5
            },
            "Толкователь снов": {
                "name": "Толкователь снов",
                "description": "Я хочу, чтобы ты выступил в роли толкователя снов. Я дам тебе описания моих снов, а ты предоставишь толкования, основанные на символах и темах, присутствующих во сне. Не содержат личных мнений или предположений о сновидце. Предоставляют только фактические интерпретации, основанные на предоставленной информации.",
                "creativity": 0.8
            },
            "Генератор идей для стартапа": {
                "name": "Генератор идей для стартапа",
                "description": "Генерируйте идеи для стартапов, основываясь на пожеланиях людей. Например, когда я говорю: \"Я бы хотел, чтобы в моём маленьком городке был большой торговый центр\", вы создаёте бизнес-план для стартапа, включающий название идеи, краткую характеристику целевого пользователя, ключевые точки пользователя, основные ценностные предложения, каналы продаж и маркетинга, источники доходов, структуру затрат, ключевых партнёров, этапы проверки идеи, предполагаемую стоимость работы в течение 1 года и потенциальные бизнес-задачи, на которые следует обратить внимание.",
                "creativity": 0.9
            }
        }

        with open(filename, "w", encoding="utf-8") as file:                         # Записываем данные в JSON файл
            json.dump(specialization_data_new, file, ensure_ascii=False, indent=4)  # ensure_ascii=False указывает, что необходимо сохранять не-ASCII, indent=4 задает отступ в 4 пробела для форматирования записываемых данных для лучшей читаемости
        print(f"JSON файл '{filename}' успешно создан.")      

    
    def show_guide(self):
        guide_window = tk.Toplevel(self.root)
        guide_window.title("Руководство")

        # Создаем виджет tk.Text
        self.guide_text = tk.Text(guide_window, wrap="word", padx=7)
        self.guide_text.insert("1.0", """  SmartiksGPT это программа для доступа к модели ИИ  YandexGPT и OpenAI gpt-4o  с возможностью формирования системных сообщений (system massage, в программе называется «Описание специализации») и изменения temperature (в программе называется «Креативность»). Изменяя «Описание специализации» и «Креативность», вы в широких пределах можете изменять и регулировать поведение модели YandexGPT.
  SmartiksGPT предназначена для творчества и для работы в ней можно получить ответы на вопросы, написать творческое произведение, написать стих, автоматизировать рутинные информационные процессы и многое другое что вы сможете придумать или уже придумали другие. Пробуйте, получайте опыт взаимодействия с новейшей информационной системой ИИ YandexGPT.
  Сообщение к модели (YandexGPT) состоит из system massage (в программе это описание специализации) + текст вашего сообщения которое вы вводите в главном окне программы и temperature (в программе это называется креативность).
В system massage (описание специализации) вы можете поместить:
•Краткое описание модели (например: ты менеджер по продажам, ты бывалый моряк, ты детский сказочник и т. д. и т.п.)
•Личные качества модели (например: ты умный, ты гений, ты смелый ты гордый и т. д.)
•Инструкции или правила, которым вы хотели бы, чтобы следовала модель (например отвечай кратко, отвечай очень подробно, не употребляй слова в превосходной степени и т. д.)
•Данные или информация, необходимые для модели, например какие либо примеры (например: Все даты и фамилии из статьи собери в одно место например:
Даты: 
Фамилии: 
  
  Описание специализации предназначено для автоматизации процесса общения то есть если вы хотите что бы модель отвечала вам определённым образом и каждый раз не вводить свои пожелания и инструкции вы их помещаете в описание и они каждый раз при вашем запросе добавляются перед вашим запросом. Например описание специализации: «Переводи на русский язык полученные сообщения»,  ваш текст : I'm sitting at my computer для модели будут выглядить так : «Переводи на русский язык полученные сообщения I'm sitting at my computer» и вы получите ожидаемый ответ : «Я сижу за своим компьютером». По сути "Описание специализации" (system massage) это программа для GPT модели т.е. инструкции которая она должна выполнить.
   Для первоначальных экспериментов для подбора описания специализации используйте специализацию «Ассистент» которая установлена по умолчанию при запуске программы там в качестве system massage используется «Ты умный ассистент», так же «Ассистент» можно использовать просто для общения с YandexGPT.
  В программе есть встроенные специализации которые можно найти нажав кнопку «Специализация» и выбрав в виджете с названием «Список специализаций». Так же в этом окне вы можете создавать свои варианты внеся своё название и описание в нужные поля так же можно выбрать уровень креативности (по умолчанию 0.0) после нажатия кнопки «Применить» вы можете её использовать при дальнейшем общении с моделью и эта специализация сохранится в файле. Так же можно редактировать сохранённые Специализации.
  Если вы задаёте вопрос модели (YandexGPT)  и  получаете ответ на него то это не значит что она даёт вам ответ,  модель просто генерирует дальнейшую последовательность слов (токенов) которые заложены в её модели используя текст  для старта который вы ей прислали, который соответственно состоит из system massage (описание специализации) и вашего текста введённого  в окно для отправки сообщения, модель не работает по принципу вопрос-ответ она работает по принципу генерации текста после сообщения полученного от вас, но так как после вопросов  часто идут ответы (в текстах на которых она училась) вы получаете ответ на ваш вопрос, эту фундаментальную особенность технологии GPT важно понимать что бы в итоге получить ожидаемое для вас поведение модели. 
   Вариативность (изменчивость) ответа зависит от параметра креативности (от 0 до 1.0) т.е. при креативности = 0 на один и то же сообщение вы получите абсолютно одинаковый ответ, а при креативности 1.0 вы получите всегда разные ответы может быть одинаковые по смыслу но разные по словесному выражению. Так же чем выше креативность тем выше риск в качестве ответа получить галлюцинацию это когда текст не имеет смысла или не соответствует  фактам.  Вариативность подбирается опытным путём и исходя из желаемого поведения модели, например для ответов по вопросам о математике лучше поставить 0, а при составлении  текста на творческую тему 0.8 – 1.0, в качестве отправной точки пробуйте 0,6 дальше экспериментируйте. 
    При работе вы можете в качестве эксперимента изменять креативность в главном окне но после закрытия программы эта креативность в файле описания специализации не сохранится, что бы её сохранить вызовите окно «Специализация» - в списке специализаций выберите нужное название и установите нужное значение потом  нажмите кнопку «Применить» так же там можете менять описание (system massage) и название и после нажатия кнопки «Применить» будут использоваться новые данные при дальнейшей работе, и они сохранятся в файле специализаций, т.е. при работе вы можете оперативно менять параметры работы с моделью и после нажатия кнопки «Применить» данные сохраняются в файл и дальнейшее общение уже идёт с обновлёнными данными.
    На данном этапе развития модель YandexGPT не помнит контекст разговора, то есть о чём вы говорили в предыдущих сообщениях,  это надо учитывать при формировании ваших запросов и описании специализации (system massage) и это не особенность или слабость YandexGPT это генеративная сущность любой GPT модели, для того что бы модель начала помнить контекст разговора ей надо программными методами каждый раз при новом запросе упаковывать предыдущие сообщения и отправлять при каждом новом запросе, но это работа программной обвязки модели и применяются в готовых программных продуктах для конечного пользователя.

Внизу окна программы можно выбрать испльзуемую модель YandexGPT или YandexGPT-lite. YandexGPT более мощная, но она тарифицируется в четыре раза дороже.
                               
  При составлении запросов и описаний специализации (system massage) учитывайте данные рекомендации:
•Отделяйте текст от задания например: 
Хуже - Резюмируйте приведенный ниже текст в виде сводного списка наиболее важных моментов (далее ваш текст). 
Лучше - Резюмируйте приведенный ниже текст в виде сводного списка наиболее важных моментов.

Текст: 
(здесь ваш текст)

•Будьте конкретны, описательны и как можно более подробны в отношении желаемого контекста, результата, продолжительности, формата, стиля и т. Д
Хуже - Напишите стихотворение о природе.
Лучше - Напишите короткое вдохновляющее стихотворение о природе, посвященное тайге и великим рекам России в стиле А. С. Пушкина
•Сформулируйте желаемый формат вывода с помощью примеров
Хуже - Извлеките сущности, упомянутые в тексте ниже. Извлеките следующие 4 типа сущностей: названия компаний, имена людей, конкретные разделы и тематики.Текст: { ваш текст}
Лучше - Извлеките важные объекты, упомянутые в тексте ниже. Сначала извлеките названия всех компаний, затем извлеките имена всех сотрудников, затем извлеките конкретные темы, соответствующие содержанию, и, наконец, извлеките общие, всеобъемлющие темы

Желаемый формат
Названия компаний: -||-
Имена сотрудников: -||-
Конкретные темы: -||-
Общие темы: -||-

Текст: {ваш текст}

•Сократите количество размытых и неточных описаний.
Хуже - Описание этого продукта должно быть довольно коротким, всего в нескольких предложениях, и не более того.
Лучше - Описание этого продукта должно состоять из 3-5 предложений.

    Составление запросов (промптов) это тонкий процесс и это можно назвать творчеством, небольшое изменение описания специализации и креативности может сильно повлиять на результат.
                               
                        Справочная информация:

  Для перехода на новую строку в окошке сообщения нажмите «Shift» и не отпуская её клавишу «Ввод» («Enter»).
  Для прокрутки текста в окне наведите мышку на окошко и колёсиком прокручивайте текст.   
  specialization_data.json  -  Это файл где хранятся данные специализаций программы.
  Login_SmartiksGPT.json - это файл где хранятся идентификатор default folder и API ключ
                               
    Инстукция по получению идентификатора default folder и ключа API
Зарегестрироваться в Яндексе → зайти по адресу https://cloud.yandex.ru/ru/services/yandexgpt → 
Нажать кнопку "Открыть сервис" (откроется консоль по адресу https://console.cloud.yandex.ru/folders/) → 
вверху будет название папки (пример - b1gzvco24o5932ufhx5o) это будет идентификатор default folder → 
вверху справа нажать кнопку "Создать сервисный аккаунт" → создать сервисный аккаунт и получить ключ API (пример - AQCN9cmr7nfdO6RqB4jv1u43lR1q2av4pyQCwZrL).

Версия 1.1 - Добавлена возможность доступа к gpt4o и gpt4o-mini
    
    Инструкция по получению ключа по доступу к gpt4o и gpt4o-mini через proxyapi.ru
Заходим на сайт proxyapi.ru регистрируемся, оплачиваем, получаем ключ API и вводим его в окно "Авторизация в ProxyAPI"

                        Полезные ссылки
Документация по YandexGPT API - https://cloud.yandex.ru/ru/docs/yandexgpt/
Статья про Yandex Cloud - https://habr.com/ru/companies/yandex_cloud_and_infra/articles/760252/       
""")
        # Создание контекстного меню "Копировать" для Руководства 
        self.context_menu_guide = Menu(self.guide_text, tearoff=0)
        self.context_menu_guide.add_command(label="Копировать", command=self.copy_text_show_guide)
        self.guide_text.bind("<Button-3>", self.context_menu_guide_vizov)   # Привязка контекстного меню к виджету Text

        self.guide_text.pack(expand=True, fill="both", padx=0, pady=0)      # Установка ширины окантовки окна
        self.guide_text.config(state="disabled")                            # Установка запрета редактирования текста
        
        # Установка размеров и позиции всплывающего окна
        popup_width = 600
        popup_height = 600
        guide_window.resizable(False, False)  # Запрет изменения размеров окна
        screen_width = self.root.winfo_screenwidth()
        screen_height = self.root.winfo_screenheight()
        x = (screen_width - popup_width) // 2
        y = (screen_height - popup_height) // 2
        guide_window.geometry(f"{popup_width}x{popup_height}+{x}+{y}")

        # Настройка всплывающего окна как transient и открытие его в модальном режиме
        guide_window.transient(self.root)
        guide_window.wait_visibility()  # Ждем, пока окно станет видимым
        guide_window.grab_set_global()  # Глобально захватываем фокус

        # Захват фокуса и установка активности всплывающего окна
        guide_window.grab_set()
        guide_window.focus_force()
        self.root.wait_window(guide_window.winfo_toplevel())

    
    # Функция messagebox "О программе"
    def show_about(self):
        winsound.Beep(37, 1)  # Отключаем звук в messagebox  воспроизводя звук с частотой 2 Гц и 1 миллисекунду
        messagebox.showinfo("О программе", "    SmartiksGPT v. 1.1  2024 год    \n Программа доступа к YandexGPT и GPT-4o  \n Разработчик [email protected]") 


    # Функции для контекстного меню "Копировать" в Руководстве def context_menu_guide_vizov и def copy_text_show_guide
    def context_menu_guide_vizov(self, event):
        
        self.context_menu_guide.post(event.x_root, event.y_root)   


    def copy_text_show_guide(self):
        
        selected_text = self.guide_text.get("sel.first", "sel.last")
        self.root.clipboard_clear()
        self.root.clipboard_append(selected_text)
        self.root.update()

    # Запрос к ChatGPT через ProxiAPI
    def answer_from_proxiapi(self, user_input, system_message, user_temperature, model): 
        # Проверка наличия ключа ProxiAPI
        if not self.reg_proxi_apy or not self.reg_proxi_apy.strip():
            messagebox.showwarning("Предупреждение", "Введите ключ к ProxiAPI")
            return

        prompt = {
            "model": model,
            "messages": [
                {"role": "system", "content": system_message},
                {"role": "user", "content": user_input}
            ],
            "temperature": user_temperature,
            "max_tokens": 2000
        }

        url = "https://api.proxyapi.ru/openai/v1/chat/completions"
        headers = {
            "Content-Type": "application/json",
            "Authorization": f"Bearer {self.reg_proxi_apy}"
        }

        try:
            response = requests.post(url, headers=headers, json=prompt)
            response.raise_for_status()  # Проверка статуса HTTP-запроса
            result = response.json()

            assistant_text = result.get("choices", [{}])[0].get("message", {}).get("content", "Ошибка: Ответ отсутствует.")
            self.insert_to_result_label(f" GPT: \n{assistant_text}\n\n")
        except requests.exceptions.RequestException as e:
            messagebox.showerror("Ошибка", f"Ошибка при выполнении запроса: {e}")

# Основной блок, создание главного окна и экземпляра класса DraggableWindow
if __name__ == "__main__":
    root = tk.Tk()                 # Cоздает экземпляр класса Tk главное окно
    app = DraggableWindow(root)    # Cоздает экземпляр класса DraggableWindow и передает ему главное окно root
    root.mainloop()                # Запускает бесконечный цикл обработки событий Tkinter, который ожидает действий пользователя (например нажатие кнопок, перемещение мыши) и обновляет графический интерфейс соответственно
    

И напоследок проверим наше творение проверим запросом — «что произошло 6 февраля 2023 года», если модель старенькая и отсталая, например как ChatGPT 3.5, то она ответа на этот вопрос не знает, а наша молодая и прогрессивная gpt-4o естественно ответ на этот вопрос знает ведь она родилась позже, а всё что было до рождения она знает. Так же поиграемся креативностью (температурой) ответов что бы убедится что они работают. Выставляем 0.0 тогда на один и тот же вопрос будет одинаковый ответ (правда как показала практика почему то не всегда), потом выставляем 1.0 тогда пойдут ответы одинаковые по смыслу, но разные по наполнению, на этом уровне выше вероятность свалиться модели в галлюцинацию.

Поздравляю всех с Новым 2025 годом. Всем мира и добра.