print('Идет проверка и установка дополнительных библиотек, необходимых для работы terra_ai')
print('Это может занять несколько минут...')
import subprocess, os, warnings, time
from pandas.core.common import SettingWithCopyWarning
from subprocess import STDOUT, check_call
from IPython import display
import numpy as np
import requests
import librosa #Для параметризации аудио
import ast
import json
from tabulate import tabulate
import getpass

def выполнить_команду(команда='!ls'):
  proc = subprocess.Popen(f'{команда}', shell=True, stdin=None, stdout=open(os.devnull,"wb"), stderr=STDOUT, executable="/bin/bash")
  proc.wait()
  pass
import os
import time
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' 
from tensorflow.keras.utils import to_categorical
import tensorflow as tf
tf.get_logger().setLevel("WARNING")
import logging
logging.getLogger("tensorflow").setLevel(logging.WARNING)
#tf.get_logger().setLevel(logging.ERROR)
from tensorflow.keras.utils import to_categorical
выполнить_команду('pip -q install pymorphy2') 
выполнить_команду('pip -q install scikit-learn') 
выполнить_команду('pip install python-Levenshtein') 
import Levenshtein
import sklearn
from sklearn.model_selection import train_test_split #Разбиение на обучающую и проверочную выборку
from sklearn.preprocessing import LabelEncoder, StandardScaler #Для нормировки данных

from . import датасет, констр, модель, сегментация, traide, ряды, прачечная, обработка_текста, сегментация_договоров, квартиры, home, check_for_errors
from . import модель_для_проверки_дз
import seaborn as sns
sns.set_style('darkgrid')
warnings.simplefilter(action="ignore", category=SettingWithCopyWarning)

display.clear_output(wait=True)
print('Все необходимые библиотеки установлены и готовы к работе')
  
def загрузить_базу(база = ''):  
  return датасет.загрузить_базу(
    база = база)

#Генетика 

def загрузить_модули():
  print('Выполняется загрузка и установка модулей')
  print('Это может занять несколько минут...')
  выполнить_команду('apt install swig cmake libopenmpi-dev zlib1g-dev > /dev/null 2>&1')
  выполнить_команду('pip -q install stable-baselines==2.5.1 box2d box2d-kengz > /dev/nul 2>&1')
  выполнить_команду('pip -q install gym pyvirtualdisplay > /dev/null 2>&1')
  выполнить_команду('pip -q install xvfbwrapper > /dev/null 2>&1')
  выполнить_команду('apt-get update > /dev/null 2>&1')
  выполнить_команду('sudo apt-get install xvfb > /dev/null 2>&1')
  выполнить_команду('apt-get install xdpyinfo > /dev/null 2>&1')
  display.clear_output(wait=True)
  from . import генетика
  print('Все модули установлены и готовы к работе')

def создать_дисплей(width, hight):
  from . import генетика
  ширина = width
  высота = hight
  генетика.создать_дисплей(ширина, высота)

def показать_пример(task):
  from . import генетика
  задача = task
  генетика.показать_пример(задача)

def обучить_алгоритм(размер_популяции, количество_эпох, коэфицент_мутации, количество_выживших):
  from . import генетика
  генетика.обучить_алгоритм(размер_популяции, количество_эпох, коэфицент_мутации, количество_выживших)

def посадить_корабль():
  from . import генетика
  генетика.посадить_корабль()

##########################

#Демонстрация
def конструктор():
  return констр.конструктор()

def демонстрация_МНИСТ():
  return модель.демонстрация_МНИСТ()

def показать_изменение_маски_MNIST(number):
  return модель.показать_изменение_маски_MNIST(number)

def показать_изменение_веса():
  return модель.показать_изменение_веса()

def демонстрация_АВТО():
  return модель.демонстрация_АВТО()

def показать_изменение_маски_АВТО(num):
  return модель.показать_изменение_маски_АВТО(num)

def показать_маски():
  import logging
  tf.get_logger().setLevel(logging.ERROR)
  return модель.показать_маски()
#LabStory
# Авторизация
def авторизация_LabStory():
  return модель.авторизация_LabStory()  
  
# Добавление набора данных
def добавить_датасет_LabStory(dataset_dict):
  return модель.добавить_датасет_LabStory(dataset_dict)
  
# Получение списка набора данных
def список_датасетов_LabStory():
  return модель.список_датасетов_LabStory()

# Удаление набора данных
def удалить_датасет_LabStory(id):
  return модель.удалить_датасет_LabStory(id)

#Выбор датасета по id
def выбрать_датасет_LabStory(id):
  return модель.выбрать_датасет_LabStory(id)

# Вывод информации о текущем датасете
def текущий_датасет():
  return модель.текущий_датасет()

# Создание задачи    
def добавить_задачу_LabStory(task_dict):
  return модель.добавить_задачу_LabStory(task_dict)

# Получение списка задач 
def список_задач_LabStory():
  return модель.список_задач_LabStory()

# Выбор задачи по id    
def выбрать_задачу_LabStory(id):
  return модель.выбрать_задачу_LabStory(id)

def текущая_задача():
  return модель.текущая_задача()

# Сохранение эксперимента
def сохранить_эксперимент_LabStory(experiment_dict):
  return модель.сохранить_эксперимент_LabStory(experiment_dict)
  
def сохранить_эксперимент_LabStory_terra_ai(experiment_dict):
  return модель.сохранить_эксперимент_LabStory_terra_ai(experiment_dict)

# Получение списка экспериметов
def список_экспериметов_LabStory():
  return модель.список_экспериметов_LabStory()

# Получение эксперимета по id  
def посмотреть_эксперимент_по_id_LabStory(id):
  return модель.посмотреть_эксперимент_по_id_LabStory(id)
  
def все_эксперименты_по_задаче(id):
    return модель.все_эксперименты_по_задаче(id)

def получить_архитектуру(id_exp):
    return модель.получить_архитектуру(id_exp)
    
## Прачечная
def ввод_данных():
  прачечная.ввод_данных()
def рассчитать_план_на_день(общее_число_ботов, количество_выживших, количество_эпох, коэффициент_мутаций):
  прачечная.рассчитать_план_на_день(общее_число_ботов, количество_выживших, количество_эпох, коэффициент_мутаций)
def план_на_день():
  прачечная.план_на_день()
def информация_о_мешке(n=None):
  прачечная.информация_о_мешке(n)
  
### ДАТАСЕТ
def показать_примеры(**kwargs):
  if 'база' in kwargs:
    kwargs['путь'] = kwargs['база']
  датасет.показать_примеры(**kwargs)

def показать_пример_договора(количество = 1):
    сегментация_договоров.показать_пример(количество)

def показать_пример_временного_ряда(база, старт, финиш):
    return ряды.показать_примеры(база, старт, финиш)

def показать_пример_квартиры(количество = 1):
    квартиры.samples(количество)

def показать_примеры_голосовых_команд():
    home.показать_примеры_голосовых_команд()

def показать_примеры_для_трейдинга(данные):
    traide.show_full_data(данные)

def показать_примеры_для_интервала(данные, start, end):
    traide.show_data(данные, start, end)

def предобработка_данных(**kwargs):
  return датасет.предобработка_данных(**kwargs)

def получить_входной_размер(arr):
  return arr.shape[1:]

def получить_выходной_размер(arr):
  return arr.max()+1

def создать_выборки(**kwargs):
  if 'база' in kwargs:
      kwargs['путь'] = kwargs['база']
  assert 'путь' in kwargs, f'Используйте параметр \'путь\', чтобы уточнить базу из которой вы хотите создать выборку.'
  data_list_seg = {'самолеты':(176, 320), 'самолеты_макс':(520, 960), 'губы':(192,256), 'люди': (256, 384)}
  data_list_gen = ['квартиры', 'трафик', 'вакансии', 'диалоги', 'повышение_размерности', 'договоры']
  kwargs['путь'] = kwargs['путь'].lower().replace('/','')
  if kwargs['путь']=='mnist':
      kwargs_time =  {'путь':kwargs['путь']}
      return датасет.создать_выборки(**kwargs)

  датасет.func_true_false(kwargs['путь'].replace('/',''), 'dataset')
  
  if kwargs['путь'] in ['tesla','симптомы_заболеваний']:
      kwargs_time =  {'путь':kwargs['путь'], 'MWC':10000,'xLen':50,'step':50}
      kwargs = check_for_errors.func_dict(kwargs, kwargs_time)
      
  elif kwargs['путь'] in data_list_gen:
      kwargs =  {'путь':kwargs['путь']}
      return датасет.создать_выборки(**kwargs)
  
  elif kwargs['путь'] == 'трейдинг':
      kwargs_time =  {'путь':kwargs['путь'],'акции':'полиметаллы', 'количество_анализируемых_дней':10,'период_предсказания':1}
      kwargs = check_for_errors.func_dict(kwargs, kwargs_time)
  
  elif kwargs['путь'] == 'умный_дом':
      kwargs_time =  {'путь':kwargs['путь'],'длина':0.5, 'шаг':0.04}
      kwargs = check_for_errors.func_dict(kwargs, kwargs_time)
      
  elif kwargs['путь'] in data_list_seg:
      some_path = kwargs['путь']
      размер = data_list_seg[f'{some_path}']
      kwargs_time =  {'путь':some_path, 'размер':размер}
      kwargs = check_for_errors.func_dict(kwargs, kwargs_time)
  
  else:
      kwargs_time =  {'путь':kwargs['путь'],'размер':(108,192), 'коэф_разделения':0.1}
      kwargs = check_for_errors.func_dict(kwargs, kwargs_time)
  return датасет.создать_выборки(**kwargs)

def создать_текстовые_выборки(путь_к_базе,MWC=10000, xLen=50, step=50):
  MWC = int(MWC)
  xLen = int(xLen)
  step = int(step)
  return обработка_текста.создать_выборки(путь_к_базе,MWC, xLen, step)

def создать_выборки_трекер(путь, размер):
  dir = путь
  size = размер
  return датасет.img_loader(dir='/трекер', size=(64,64))

def создать_выборки_квартир():
  return квартиры.создать_выборки()

def создать_выборки_вакансии():
  return модель.создать_выборки_вакансии()

def создать_выборки_для_торговли(акции,количество_анализируемых_дней,период_предсказания):
  return traide.получить_данные(акции,
  количество_анализируемых_дней,
  период_предсказания)

def создать_выборки_голосовых_команд(длина, шаг):
  return home.создать_выборки(длина, шаг)

def создать_выборки_временного_ряда(база, период):
  return ряды.создать_выборки_трафик(база, период)

def создать_выборки_сегментация_текста(договоры):
  return сегментация_договоров.создать_выборки_договоров(договоры)
  
def создать_выборки_для_чатбота(вопросы, ответы,количество_пар=10000):
  return обработка_текста.создать_выборки_чатбота(вопросы, ответы,количество_пар)
  
def создать_выборки_для_сегментации(images_airplane, segments_airplane):
   return сегментация.create_xy(images_airplane, segments_airplane)

def создать_выборки_для_повышения_размерности():  
  return повышение_размерности.генератор_данных_DIV2K()

# МОДЕЛЬ
def схема_модели(мод):
  return модель.схема_модели(мод)
  

def обучение_модели_квартиры(мод, x_train, y_train, x_test=[], y_test=[], размер_пакета=None, количество_эпох=None, коэф_разделения = 0.2):  
  return модель.обучение_модели_квартиры(мод, x_train, y_train, x_test, y_test, размер_пакета, количество_эпох, коэф_разделения)  

def обучение_модели(мод, x_train, y_train, x_test=[], y_test=[], размер_пакета=None, количество_эпох=None, коэф_разделения = 0.2, **kwargs):
  global history
  return модель.обучение_модели(мод, x_train, y_train, x_test, y_test, размер_пакета, количество_эпох, коэф_разделения, **kwargs)

def обучение_модели_временного_ряда(мод, ген1, ген2, количество_эпох=None):
  модель.обучение_модели_трафик(мод, ген1, ген2, количество_эпох) 
  return history

def предобучение_генератора(генератор, обучающая_выборка, проверочная_выборка, количество_шагов, интервал_вывода):
  повышение_размерности.предобучение_генератора(генератор,обучающая_выборка, проверочная_выборка, количество_шагов, интервал_вывода)
  print('Предобучение генератора завершено')
  
def обучение_модели_повышения_размерности(нейронка,обучающая_выборка):
  нейронка.train(обучающая_выборка, steps=5000) #Обучаем Srgan полностью

def обучение_модели_обнаружения(количество_эпох):
  обнаружение.обучение_модели_обнаружения(количество_эпох)

def тест_модели_классификации(нейронка, тестовый_набор, правильные_ответы, классы, количество=1):
  модель.тест_модели_классификации(нейронка, тестовый_набор, правильные_ответы, классы, количество)

def тест_модели_трекер(нейронка, тестовый_набор, правильные_ответы, классы, количество=5):
  модель.тест_модели_трекер(нейронка, тестовый_набор, правильные_ответы, классы, количество)

def тест_модели_вакансии(нейронка, x_val, y_val):
  return модель.тест_модели_вакансии(нейронка, x_val, y_val)

def тест_модели_симптомы(нейронка, xLen, step, симптомы, классы):
  xLen = int(xLen)
  step = int(step)
  return обработка_текста.тест_модели_симп(нейронка, xLen, step, симптомы, классы)

def тест_модели_отзывы(нейронка, xLen, step, отзыв, классы):
    симптомы = отзыв
    xLen = int(xLen)
    step = int(step)
    обработка_текста.тест_модели_симп(нейронка, xLen, step, симптомы, классы)

def тест_модели_писатели(нейронка, xLen, step, текст, классы):
    обработка_текста.тест_модели_писатели(нейронка, xLen, step, текст, классы)
    
def тест_модели_на_своем_изображении(нейронка, размер_изображения, классы):
  модель.тест_на_своем_изображении(нейронка, размер_изображения, классы)

def тест_модели_сегментации(мод, тестовые_изображения,  **kwargs):
  сегментация.тест_модели(мод, тестовые_изображения,  **kwargs)

def тест_модели_сегментации_договоров(мод, теги, договора):
  сегментация_договоров.тест_модели(мод, теги, договора)

def тест_модели_торговли(нейронка,тестовая_выборка, метки_тестовой_выборки, период_предсказания,количество_анализируемых_дней):
  traide.model_test(
    нейронка, 
    тестовая_выборка, метки_тестовой_выборки,
    период_предсказания,
    количество_анализируемых_дней)

def примеры_распознавания(нейронка_1, период_предсказания,количество_анализируемых_дней):
    traide.example_traid(нейронка_1, период_предсказания,количество_анализируемых_дней)

def тест_модели_повышения_размерности(нейронка):
  модель.тест_модели_HR(нейронка)

def торговля(нейронка_1, тестовая_выборка, тип):
  traide.traiding(нейронка_1, тестовая_выборка, тип)

def тест_чат_бота(нейронка, размер_словаря, энкодер, декодер):
  обработка_текста.тест_модели_чат_бот(нейронка, размер_словаря, энкодер, декодер)
  
def тест_обученного_чат_бота():
  обработка_текста.загрузить_предобученную_модель()
  
def тест_модели_голосовых_команд(нейронка, порог, длина, шаг):
  home.тест_модели(нейронка, порог, длина, шаг)

def тест_модели_обнаружения_людей(нейронка):
  обнаружение.тест_модели()

def тест_модели_временного_ряда(мод, данные):
  ряды.тест_модели_трафика(мод, данные)

def тест_модели_квартиры(нейронка, *данные,):
  квартиры.тест_модели(нейронка, *данные,)

def создать_сеть(слои, входной_размер, задача, параметры_модели=None):
  return модель.создать_сеть(слои, входной_размер, параметры_модели, задача)

def создать_составную_сеть(данные, метки, *нейронки):
  return модель.создать_составную_сеть(данные, метки, *нейронки)

def создать_составную_сеть_квартиры(данные, *нейронки):
  return модель.создать_составную_сеть_квартиры(данные, *нейронки)

def создать_модель_Sequence_to_Sequence(размер_словаря, энкодер, декодер):
  return модель.создать_сеть_чат_бот(размер_словаря, энкодер, декодер)

def создать_генератор_повышения_размерности(стартовый_блок, основной_блок, финальный_блок):
  мод = модель.создать_генератор_повышения_размерности(стартовый_блок, основной_блок, финальный_блок)
  предобучение_генератора = повышение_размерности.SrganGeneratorTrainer(мод, checkpoint_dir=f'folder')    
  print('Модель генератора создана')    
  return предобучение_генератора

def создать_дискриминатор_повышения_размерности(блок_дискриминатора,количество_блоков, финальный_блок):
  return модель.создать_дискриминатор_повышения_размерности(блок_дискриминатора,количество_блоков, финальный_блок)

def создать_PSP(**kwargs):
  return модель.создать_PSP(**kwargs)

def создать_UNET(**kwargs):
  return модель.создать_UNET(**kwargs)

def создать_модель_повышения_размерности(генератор, дискриминатор):
  return повышение_размерности.создать_модель(генератор, дискриминатор)

def загрузить_модель_повышения_размерности():
  return повышение_размерности.загрузить_веса_готовой_модели()

def загрузка_обученной_модели_обнаружения_людей():
  return обнаружение.cоздать_модель_YOLO()  

def параметризация_аудио(файл):
  home.параметризация_аудио(файл)

###
##Проверка ДЗ
###

def дз_первый_день(**kwargs):
    check_for_errors.test_hw_1(**kwargs)

def дз_второй_день(**kwargs):
    check_for_errors.test_hw_2(**kwargs)

def дз_третий_день(**kwargs):
    check_for_errors.test_hw_3(**kwargs)


