В этой программе вы сможете самостоятельно составить свою систему массажа (в программе она называется «Специализация»), а это по сути программирование модели GPT на естественном языке, также вы сможете менять температуру (путем программа называется «Творчество»), при этом меняется вариативность ответов, при значении 0,0 на один и тот же вопрос всегда будет получен один и тот же ответ; при 1.0 могут быть разные ответы, имеющие схожее значение, но разные по словесному выражению. , вы также можете использовать две модели YandexGPT и YandexGPT Lite, вторая быстрее и немного проще, но и в четыре раза дешевле. Описание программы в разделе меню «Информация».

Интерфейс программы

Ну а теперь идем прямо в бой. Установите VPN-расширение в браузере — ХолаВПН, расширение активируется автоматически, но иногда приходится активировать его вручную или менять страну в настройках, если что-то не загружается (я поменял на Канаду), иногда расширение само блокирует загрузку сайта, тогда нужно нажать на значок расширения справа внизу и закройте появившееся окно с выгодным предложением). Зарегистрируйтесь на openai.com если адрес электронной почты не заканчивается на .ru, подойдет [email protected]. Идти к ЧатGPT 3.5 турбо здесь мы будем писать программу. В разделе «Настройки учетной записи» Настройте ChatGPT → Как вы хотите, чтобы ChatGPT реагировал? напишем → Ответ на русском языке, язык программирования Python.

Сайт ChatGPT 3.5 Турбо

Сайт ChatGPT 3.5 Турбо

Теперь подготовим Яндекс. Зарегистрируйтесь в Яндекс если у вас есть аккаунт, зайдите в сервис API ЯндексGPT.

Мы приходим сюда:

Сайт API ЯндексGPT

Сайт API ЯндексGPT

В левом верхнем углу нажмите «По умолчанию»; если это еще не так, создайте платежный счет и пополните его на небольшую сумму для тестирования сервиса (в том году дали тысячу рублей в подарок на несколько месяцев).

4c631e7fc53048f6e909f54f696c6153

То, что обведено овалом, — это ваш идентификатор по умолчанию, по сути, это идентификатор, который необходимо ввести в нашу программу для доступа к YandexGPT, пример идентификатора — b2wek9sskl91crв1trub.

Далее перейдите в «Учетные записи служб» и создайте учетную запись службы (синяя кнопка «Создать учетную запись службы»).

Сервисные аккаунты

Сервисные аккаунты

После создания зайдите в эту учетную запись и создайте API-ключ (указан стрелкой), выберите в меню «Создать API-ключ», скопируйте полученный ключ и сохраните его где-нибудь (он не хранится в учетной записи), вам понадобится для ввода его в программу доступа YandexGPT, в случае утери ключа его можно создать заново, пример ключа — AQSA2cmr7ns2O6DqB4jv8gh3lR1M9av4pyHCwZwL.

Создать ключ API

Создать ключ API

Теперь скачайте и установите IDE. Код Visual Studio.

Сайт загрузки кода Visual Studio

Сайт загрузки кода Visual Studio

скачать Питон 3.12.

Сайт загрузки Python 3.12

Сайт загрузки Python 3.12

Теперь все готово, можно творить. Если во время подготовки у вас возникнут вопросы, смело задавайте их в ChatGPT, например:

Ты

Как запустить программу Python в Visual Studio Code

ЧатGPT

Чтобы запустить программу Python в Visual Studio Code, выполните следующие действия:

Установите Python, если вы еще этого не сделали. Вы можете скачать его с официального сайта Python: https://www.python.org/downloads/.

Установите Visual Studio Code, если у вас его еще нет. Скачать его можно с официального сайта: https://code.visualstudio.com/.

Откройте Visual StudioCode.

Создайте новый файл или откройте существующий файл с расширением .py (файл Python).

Нажмите `Ctrl + « (обратная галочка), чтобы открыть терминал в Visual Studio Code. Вы также можете выбрать в меню «Терминал» -> «Новый терминал».

В терминале убедитесь, что ваш рабочий каталог (папка) находится там, где находится ваш файл Python.

Запустите программу, введя команду python filename.py, где filename.py — имя вашего файла Python.

Например, если ваш файл называется hello.py, команда будет выглядеть так:

Bash

Copy code

python hello.py

Или вы можете использовать кнопку «Выполнить» (зеленый треугольник) в верхней части редактора кода, чтобы запустить программу. Прежде чем начать, убедитесь, что интерпретатор Python в Visual Studio Code настроен правильно. Для этого может потребоваться установка расширения Python и указание пути к интерпретатору в настройках Visual Studio Code.

Или больше :

Ты

Как установить библиотеки Python

ЧатGPT

Чтобы установить библиотеки Python, вы можете использовать инструмент управления пакетами pip. Вот как это сделать:

Откройте терминал (командную строку) на своем компьютере.

Введите pip install имя_библиотеки, где имя_библиотеки — это имя библиотеки Python, которую вы хотите установить. Например:

bash

Copy code

pip install requests

Это установит библиотеку запросов.

Если вы хотите установить определенную версию библиотеки, вы можете указать версию, добавив == и номер версии. Например:

bash

Copy code

pip install requests==2.25.1

Если вы хотите обновить библиотеку до последней версии, вы можете использовать команду:

bash

Copy code

pip install --upgrade имя_библиотеки

Например:

bash

Copy code

pip install --upgrade requests

Если вы используете виртуальную среду Python (что является хорошей практикой для изоляции зависимостей между проектами), убедитесь, что ваша виртуальная среда включена, прежде чем запускать установку pip.

Теперь вы знаете, как устанавливать библиотеки Python с помощью pip.

Пример общения с ChatGPT

Пример общения с ChatGPT

В качестве терминала я использовал Windows PowerShell, вы можете использовать cmd.exe, ввести их в поиск Windows и найти там.

Вот примеры запросов, сделанных в ChatGPT во время разработки программы.

  • вам нужно увеличить ширину боковых линий главного окна

  • какая библиотека для Python содержит графический интерфейс, похожий на стиль Windows

  • как загрузить библиотеку tkinter как tk

  • Подробно прокомментируйте этот код, каждую строку функции и переменной (….пример кода…)

  • Теперь сделайте так, чтобы данные в виджете «Результат» нельзя было изменить (….пример кода…)

  • Я правильно понимаю — эта функция self.entry = tk.Text(self.root, wrap=»word», width=70, height=7) передает свое значение в переменную enter_text (….пример кода….)

и т. д. и т. п., когда делаете запрос, не забывайте вставлять куски кода, где нужно внести изменения или что-то добавить, на любой запрос можно вставить весь код, но ChatGPT 3.5 имеет ограничения на количество токены (слова) запроса и после 300-400 строк кода начинает писать «слишком долго». После успешных изменений сохраняем резервную копию, чтобы в случае чего можно было вернуться к рабочей версии, иначе ChatGPT так накосячит, что вы не будете рады, что связались с ним (шутка).

Распространенные ошибки ChatGPT — например, в имя переменной часто забывает добавить self, чтобы использовать ее в другой функции, gpt_model_uri_get и нужно self.gpt_model_uri_get и то же самое с функциями (методами), def show_registration():, но вам нужно def show_registration(self): как бы я назвал это через конструкцию self.show_registration.

В Visual Studio Code внизу есть окно терминала, где также отображаются коды ошибок. Вы можете скопировать оттуда и запросить ChatGPT об ошибке, выбрать ее и использовать Ctrl+C, чтобы скопировать и вставить ее в запрос ChatGPT. окно через контекстное меню или Ctrl+V.

Чтобы скомпилировать программу в готовый .exe-файл, используйте команды терминала.

Windows PowerShell или cmd.exe. Вставьте код программы в блокнот и сохраните его с расширением .py, например SmartiksGPT.py.

компакт-диск C:\Users\HP\Desktop — команда перехода в рабочий каталог, где находится файл SmartiksGPT.py (в данном случае на рабочем столе).

pyinstaller —onefile —noconsole SmartiksGPT.py — скомпилировать команду в .exe-файл (в данном случае файл без консоли).

Готовый файл будет находиться в папке dist.

Ну, кажется, это все.

Вот текущий код программы 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 = 780
        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)                                     # Запрет изменения размеров окна
        
        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="Авторизация", command=self.show_registration)  # Добавление пункта "Регистрация"
        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=35, 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=1, pady=10, padx=0, sticky="w")

        tk.Label(self.model_selection_frame, text="Используемая модель:", anchor="w").pack(side=tk.LEFT)
                                
        tk.Radiobutton(self.model_selection_frame, text="YandexGPT", variable=self.gpt_model_uri, value="yandexgpt", command=lambda: self.update_gpt_model_uri("yandexgpt")).pack(side=tk.LEFT)
        tk.Radiobutton(self.model_selection_frame, text="YandexGPT-lite", variable=self.gpt_model_uri, value="yandexgpt-lite", command=lambda: self.update_gpt_model_uri("yandexgpt-lite")).pack(side=tk.LEFT)

        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, value):
        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})
        
        
    # Функция окна Авторизации
    def show_registration(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)


    # Функция проверки символов в окне Авторизации
    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')
                #print("Значения из файла успешно загружены:")
                #print("Default Folder:", self.default_folder)
                #print("API Key:", self.api_key)
                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
        self.answer_from_yandex_gpt(entered_text, system_message, user_temperature, self.default_folder, self.api_key) # Вызов метода answer_from_yandex_gpt с передачей в него введенного текста и температуры (entered_text, system_message, user_temperature)
    
    # Функция очистки беседы при нажатии кнопки "Очистить"
    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 = "
        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)

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


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

        # Отображение ответа от YandexGPT в программе
        self.insert_to_result_label(f" YandexGPT: \n{assistant_text}\n\n")

        # Вывод ответа от 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 с возможностью формирования системных сообщений (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 предложений.

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

	Допустимое количество символов в сообщении вместе с пробелами и переносом строки – 19000 символов ≈3000 слов ≈ 4-6 листа машинописного текста А4 ≈ 4000 токенов (1 слово ≈ 1,5 токена)
	Допустимое количество символов в описании специализации вместе с пробелами и переносом строки   – 3800 символов ≈ 500 слов ≈ 1 лист машинописного текста А4 ≈ 800 токенов.
	Максимальное количество токенов в ответе YandexGPT – 2000 токенов ≈ 1300 слов.
  Для перехода на новую строку в окошке сообщения нажмите «Shift» и не отпуская её клавишу «Ввод» («Enter»).
  Для прокрутки текста в окне наведите мышку на окошко и колёсиком прокручивайте текст.   
  specialization_data.json  -  Это файл где хранятся данные специализаций программы.
  Login_SmartiksGPT.json - это файл где хранятся идентификатор default folder и API ключ
                               
    Инстукция по получению идентификатора default folder и ключа API
Зарегестрироваться в Яндексе → зайти по адресу  → 
Нажать кнопку "Открыть сервис" (откроется консоль по адресу  → 
вверху будет название папки (пример - b1gzvco24o5932ufhx5o) это будет идентификатор default folder → 
вверху справа нажать кнопку "Создать сервисный аккаунт" → создать сервисный аккаунт и получить ключ API (пример - AQCN9cmr7nfdO6RqB4jv1u43lR1q2av4pyQCwZrL).

                        Полезные ссылки
Документация по YandexGPT API - 
Статья про Yandex Cloud -        
""")
        # Создание контекстного меню "Копировать" для Руководства 
        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.0  2024 год    \n программа доступа к YandexGPT  \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()


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

Вы можете скопировать этот код в блокнот, сохранить его с расширением .py, например SmartiksGPT.py, скачать и установить интерпретатор. Питон 3.12 и используйте его.

ЧИТАТЬ   Высший суд Флориды разрешил избирателям голосовать за право на аборт

При первом запуске программы введите настройки по умолчанию и ключ API в меню «Авторизация»; В окне «Специализация» находятся примеры, которые можно редактировать и добавлять новые.

Что еще можно добавить в эту программу, например добавить работу с Гигачат API и сравнить их работу в жестком бою, можно добавить запоминание контекста разговора, например отправлять предыдущие запросом со следующим, можно прикрепить RAG, можно добавить доступ к GPT 4 через сервис proxyapi.ru и, вероятно, многое другое.

Данная программа допускает бесплатное использование и любые модификации по своему усмотрению для участников хабр-сообщества.

Source

От admin