from utils import *

from fastapi import FastAPI, Query, Path, Body, Cookie, Header
from pydantic import BaseModel, Required, Field, HttpUrl

app = FastAPI()

@app.get('/')
def read_root():
    return {'Hello': 'World'}

# Examplos com path params
class ModelName(str, Enum):
    name1 = 'Phelipe'
    name2 = 'Marcos'
    name3 = 'Fran'

@app.get('/items/{item_id}')
def read_item(item_id: int, q: Union[str, None] = None):
    return {'item_id': item_id, 'q': q}

@app.get('/names/{name}')
def get_name(name: ModelName):
    response = {'model_name': name}
    if name.value == 'Phelipe':
        response.update({'message': 'Bad name.'})
    else:
        response.update({'Message': 'Cool name.'})

    return response

# Exemplo com query params
fake_items_db = [{'item_name': 'Foo'}, {'item_name': 'Bar'}, {'item_name': 'Baz'}]
_lmt = len(fake_items_db) - 1

@app.get('/items/')
async def read_item(skip: int = 0, limit: int = _lmt):
    return fake_items_db[skip : skip + limit]

# Exemplo com query param opcional
@app.get('/cats/')
async def get_cat(name: str = None):
    cats = [
        'zoe',
        'zulke',
        'zara',
        'miuda',
        'frajola',
        'cruel',
        'mafalda',
        'jade',
        'maria',
    ]
    if name:
        if name in cats:
            return {'Valor aleatorio': False, 'Nome do gato': name}

    return {'Valor aleatorio': True, 'Nome do gato': cats[random.randint(0, len(cats))]}

# Exemplo com Pydantic model

class Item(BaseModel):
    name: str
    description: Union[str, None] = None
    price: float
    tax: Union[float, None] = None

@app.post('/items_s/')
async def create_item(item: Item):
    if item.tax:
        price = item.price + item.price * item.tax
        item.price = price
    return item

"""
Examplo usando Query como valor padrão, validadores e sobrescrita de documentação

Old way - async def create_dog(name: str, age: int, description: Union[None, str] = None):

"""

class Dog(BaseModel):
    level: int
    name: str

@app.post('/dogs/')
async def create_dog(
    brothers: Union[List[Dog], None],
    age: int,
    name: str = Query(
        default=..., title='Nome', description='Esse é um nome', regex='^love'
    ),
    description: Union[None, str] = Query(
        default=None,
        title='Descrição',
        description='Essa é uma descrição',
        min_length=5,
        max_length=10,
        deprecated=True,
    ),
    hidden_query: Union[str, None] = Query(default=None, include_in_schema=False),
):
    dog = {'name': name, 'age': age, 'brothers': {}}
    if description:
        dog.update({'description': description})
    if brothers:
        list(map(lambda d: dog['brothers'].update({d.name: d.level}), brothers))

    return dog

"""
Exemplo usando Path pydantic
"""

@app.get('/memories/{person_id}')
def create_memories(
    *, person_id: int = Path(..., title='Uma pessoa existente.', gt=0, le=1000)
):
    people = {1: {'name': 'amourir'}, 2: {'name': 'joão'}}
    if person_id in people.keys():
        return people.get(person_id)

    return {}

"""
Exemplo usando Body e multiplos parâmetros
"""

class City(BaseModel):
    name: str
    country: int

@app.post('/cities/{country_id}')
def create_cities(
    *,
    country_id: int = Path(..., title='Id de um país existente.', gt=1, le=5),
    city: City = Body(..., embed=False),
    person_name: str = Body(..., regex='^mar', embed=False)
):
    countries = {1: 'Brazil', 2: 'Russia', 3: 'Senegal', 4: 'Marrocos', 5: 'Irã'}

    city_item = {'name': city.name}

    country_name = countries.get(country_id)

    city_item.update({'country': country_name})

    return city_item

"""
Exemplo usando Body Field
"""

class PersonalComputer(BaseModel):
    name: str = Field(
        regex='^pc', default=None, description='Nome do pc', max_length=10
    )
    serie: int = Field(gt=1, description='Passe uma série válida')

@app.put('/pcs/{pc_id}')
async def update_pc(
    *,
    pc_id: int = Path(..., description='Passe um válido.'),
    pc: PersonalComputer = Body(..., embed=True, description='Uma maquina')
):
    if pc_id // 2 == 0:
        return {'message': 'Inválido'}
    return pc

"""
Exemplo com subtipos como BaseModel
"""

class Image(BaseModel):
    url: HttpUrl
    size: int

class Product(BaseModel):
    name: str = Field(..., example='Produto base')
    price: float
    images: list[Union[Image, None]] = None

class Store(BaseModel):
    products: Union[list[Product], None]
    name: str = Field(..., description='Nome da loja')

    class Config:
        schema_extra = {
            'example': {
                'products': [
                    {
                        'name': 'Computador',
                        'price': 12.4,
                        'images': [{'url': 'http://test.com', 'size': 1}],
                    }
                ],
                'name': 'Loja dos fundos',
            }
        }

@app.post('/products/')
def create_products(store: Store = Body(..., embed=True)):
    return store

@app.get('/products/{product_id}')
def retrive_products(*, product_id: UUID = Path(..., description='Produto existente')):
    return {}

"""
Exemplo com Cookie e Header
"""

@app.get('/params/')
def request_params(
    user_agent: str = Header(default=None),
    ads_id: Union[str, None] = Cookie(default=None),
):
    return {'cookie': ads_id, 'user_agent': user_agent}


from pathlib import Path
from sphinx.directives import SphinxDirective
from docutils.parsers.rst import directives
from docutils import nodes
from sphinx.util.logging import getLogger
import yaml
import json

logger = getLogger(__name__)

class PyConfig(SphinxDirective):

    has_content = True

    def run(self):

        if self.content:
            data = "\n".join(self.content)
            data = json.dumps(yaml.safe_load(data), indent=2)

            return [nodes.raw("", f'<py-config type="json">\n{data}\n</py-config>\n', format="html")]

class PyRepl(SphinxDirective):

    has_content = True
    option_spec = {
        "auto-generate": directives.unchanged,
        "output": directives.unchanged,
        "src": directives.path,
    }

    def run(self):
        attrs: str = ""
        code: str = ""

        for key, value in self.options.items():
            attrs += f' {key}="{value}"'

        if self.content:
            code = "\n".join(self.content)

        py_repl = f'''
            <py-repl {attrs}>
            {code}
            </py-repl>
        '''
        return [nodes.raw("", py_repl, format="html")]

class PyScript(SphinxDirective):

    has_content = True
    option_spec = {
        "file": directives.path,
        "output": directives.unchanged
    }

    def run(self):

        if "file" in self.options:
            path = self.env.relfn2path(self.options['file'])[1]
            try:

                with open(path, 'r') as f:
                    code = f.read()
                self.env.note_dependency(path)

            except (FileNotFoundError, Exception) as err:
                logger.warn('reading error: %s, %s', path, err)
                return []

        elif self.content:
            code = "\n".join(self.content)
        else:
            raise logger.error("Must provide either content or the 'file' option")
        return [nodes.raw("", f"<py-script>\n{code}\n</py-script>\n", format="html")]

class PyTerminal(SphinxDirective):

    option_spec = {
        "auto": directives.flag,
        "false": directives.flag
    }

    def run(self):
        attrs: str = ""

        for key, _ in self.options.items():
            attrs += f' {key}'

        py_terminal = f'''
            <py-terminal {attrs}></py-terminal>
        '''

        return [nodes.raw("", py_terminal, format="html")]


import hearts.model.game as m
from hearts.game_master import GameMaster
import logging

class GameBackend(object):
    def __init__(self, player_svc):
        self._next_game_id = 1
        self._game_masters = {}
        self._players = {}
        self._player_mapping = {}
        self._player_svc = player_svc
        self.logger = logging.getLogger(__name__)

    def create_game(self, players):
        game_id = self._next_game_id
        self._next_game_id += 1

        model = m.HeartsGame()
        model.start()

        master = GameMaster(model, game_id)
        self._game_masters[game_id] = master
        master.add_observer(self)

        self._players[game_id] = list(players)

        for idx, player_id in enumerate(players):
            self._player_mapping[player_id] = (game_id, idx)

        return game_id

    def get_game_master(self, game_id):
        return self._game_masters[game_id]

    def try_get_player_game(self, player_id):
        data = self._player_mapping.get(player_id)
        if data is None:
            return None

        return data[0]

    def try_get_game_info(self, player_id):
        data = self._player_mapping.get(player_id)
        if data is None:
            return None

        return data

    def is_in_game(self, player_id):
        return player_id in self._player_mapping

    def on_game_finished(self, game_id):
        self.logger.info("Game %d has finished.", game_id)
        self._destruct_game(game_id)

    def on_game_abandoned(self, game_id):
        self.logger.info("Game %d has been abandoned.", game_id)
        self._destruct_game(game_id)

    def _destruct_game(self, game_id):
        for player in self._players[game_id]:
            del self._player_mapping[player]
            self._player_svc.remove_player(player)

        del self._players[game_id]
        del self._game_masters[game_id]


#%%
import pandas as pd
import numpy as np
import datetime as dt
import xarray as xr
import cftime
import dask
from glob import glob

#%%
'''SUBSET RH DATA'''

data = pd.read_csv("preprocessing/inputdata/AMF_US-MBP_BASE_HH_2-5.csv",
    skiprows = 2,
    na_values = -9999)

data['TIMESTAMP_START'] = pd.to_datetime(data.TIMESTAMP_START, format = '%Y%m%d%H%M')
data['TIMESTAMP_END'] = pd.to_datetime(data.TIMESTAMP_END, format = '%Y%m%d%H%M')

data = data.rename(columns = {'TIMESTAMP_START':'TIMESTAMP'})

'''
#TRY EDI Data
data = pd.read_csv('preprocessing/inputdata/BogLake_Met_data_30min.csv', skiprows = 1, sep = ",",
    names=["TIMESTAMP", "Air_TempC_Avg", "RH", "Soil_TempC_5cm", "Soil_TempC_10cm", "Soil_TempC_20cm",
            "Soil_TempC_30cm", "Soil_TempC_40cm", "Soil_TempC_50cm", "Soil_TempC_100cm",  "Soil_TempC_200cm",
            "WS_Tot",  "WindDir_D",  "WindDir_SD",  "PAR_Den_Avg"],
    parse_dates = ['TIMESTAMP'],
    na_values = {'RH':['NA',]})
'''

# Subset to the right variables
RH = data[['TIMESTAMP', 'RH']]

# Sort into Year-Month combos
RH['Year'] = RH.TIMESTAMP.dt.year
RH['Month'] = RH.TIMESTAMP.dt.month
RH['Year-Month'] = RH.TIMESTAMP.dt.strftime('%Y') + '-' + RH.TIMESTAMP.dt.strftime('%m')

#Subset to proper years
RH = RH[(RH.Year > 2010) & (RH.Year < 2018)]

#Patch long NA period in August 2017 with data from the NADP site in the EDI data
patch_data = pd.read_csv('preprocessing/inputdata/NADP_Met_data_30min.csv', skiprows = 1, sep = ",",
    names=["TIMESTAMP", "Air_TempC_Avg", "RH", "Soil_TempC_Avg", "WS_Tot", "WindDir_D", "WindDir_SD", "PAR_Den_Avg", "Soil_VWC_Avg"],
    parse_dates = ['TIMESTAMP'],
    na_values = {'RH':['NA',]})

RH_patch = patch_data[['TIMESTAMP', 'RH']]
RH_patch = RH_patch[(RH_patch.TIMESTAMP.dt.year == 2017) & (RH_patch.TIMESTAMP.dt.month == 8)]

# %%
'''OPEN ALL NCDF DATA'''

vals = set(RH['Year-Month'])

for val in vals:
    #Open sample data set
    test = xr.open_mfdataset(val + '.nc', decode_times = False)

    #Select RH data:
    if val == '2017-08':
        test_RH = RH_patch
    else:
        test_RH = RH[RH['Year-Month'] == val]

    #Subset netdcf spatially
    test2 = test.drop_sel(lon = 1)

    #If leap Feb and leap year remove Feb29 data
    r = test_RH['RH']
    if (val.endswith('02')) & (len(r) > len(test2.time)):
        #remove feb 9
        r = r[:len(test2.time)]

    #print(val + ": " + str(min(r)))

    #print("NEW" + val + ": " + str(min(r)))

    # Interpolate
    r3 = pd.Series(r).interpolate(method = "linear")

    print("NAN" + val + ": " + str(any(np.isnan(r3))))

    #Reshape
    r4 = np.reshape(list(r3),(-1,1,1))

    #Add RH Data
    test2['RH'] = xr.DataArray(r4,
        dims = ['time', 'lat', 'lon'],
        attrs = {'FillValue': np.NaN,
                'long_name': 'relative humidity at the lowest atm level (RH)',
                'units': '%' })

    #Write sample
    test2.to_netcdf('preprocessin/forcings-modified' + val + '.nc')

# %%
'''CHECK'''
#Open file to check
dat = xr.open_mfdataset('preprocessing/forcings-modified/2017-08.nc')
# %%


import telebot
import config
from ibm_watson import LanguageTranslatorV3
from ibm_cloud_sdk_core.authenticators import IAMAuthenticator
import json
from telebot import types
import pyowm

owm = pyowm.OWM('c8548689b28b1916f78403fb9c92e4f3', language='ru')

bot = telebot.TeleBot(config.TOKEN)

authenticator = IAMAuthenticator('9n-ZTrznhrAKV0YAJIWIM-fwico0pbNeHp9Wek67nt6V')
language_translator = LanguageTranslatorV3(
    version='2018-05-01',
    authenticator=authenticator
)
language_translator.set_service_url('https://api.eu-gb.language-translator.watson.cloud.ibm.com/instances'
                                    '/1bec2e12-6251-4b94-8d80-fcead8ec6d68')
languages = language_translator.list_languages().get_result()

user_dict = {}

# Формируем класс, для сохранения в него переменных (то что вводит кандидат)!
class User:
    def __init__(self, name):
        self.name = name
        self.application = None
        self.writer_lang = None
        self.phrases = None
        self.place = None

# Обработать / start и / help
@bot.message_handler(commands=['start', 'help'])
def command_start(message):
    chat_id = message.chat.id
    text = message.text
    msg = bot.send_message(chat_id,
                           "Здравствуйте, я полезный бот! Мое предназначение помогать в тех функциях которые в меня "
                           "встроенные! "
                           "В них входит перевод текста на необходимый Вам язык! Подскажите как я могу к Вам обращатся?")
    bot.register_next_step_handler(msg, process_name_step)

# Бот предлагает свои услуги\возможности!
@bot.message_handler(content_types=['text'])
def process_name_step(message):
    chat_id = message.chat.id
    name = message.text
    user = User(name)
    user_dict[chat_id] = user
    markup = types.ReplyKeyboardMarkup(one_time_keyboard=True)
    markup.add('Переводчик', 'Погода', 'Список покупок')
    msg = bot.send_message(chat_id, 'Приятно познакомится ' + user.name + '! Выберите приложение, которым хотите '
                                                                          'воспользоваться!', reply_markup=markup)
    bot.register_next_step_handler(msg, how_can_i_help)

# Действие выполняется при выборе приложения!
@bot.message_handler(content_types=['text'])
def how_can_i_help(message):
    chat_id = message.chat.id
    application = message.text
    if application == '/start' or application == '/help':
        return command_start
    if application == u'Переводчик':
        user = user_dict[chat_id]
        user.application = application
        markup = types.ReplyKeyboardMarkup(one_time_keyboard=True)
        markup.add('английский', 'русский', 'испанский', 'немецкий', 'итальянский', 'французский', 'китайский',
                   'Погода')
        msg = bot.send_message(chat_id, "Укажите на каком языке будете писать (если такого языка нет в выпадающем "
                                        "списке, напишите этот язык в сообщении!): ", reply_markup=markup)
        bot.register_next_step_handler(msg, translater_func1)
    elif application == u'Погода':
        user = user_dict[chat_id]
        user.application = application
        markup = types.ReplyKeyboardMarkup(one_time_keyboard=True)
        markup.add('Переводчик', 'Погода')
        msg = bot.send_message(chat_id, "Введите в каком городе/стране?: ", reply_markup=markup)
        bot.register_next_step_handler(msg, weather_bot)
    elif application == u'Список покупок':
        pass

# Тут запускается приложение для перевода текста!
@bot.message_handler(content_types=['text'])
def translater_func1(message):
    global lang1  # Создаем переменную lang1 (язык ввода текста)
    try:  # Создаем исключение для того чтобы различать кнопки и команду /start
        chat_id = message.chat.id
        writer_lang = message.text
        if writer_lang == u'Погода':  # Создаем условие нажатия на кнопку: если это погода выполняем код - ниже!
            user = user_dict[chat_id]
            user.writer_lang = writer_lang
            markup = types.ReplyKeyboardMarkup(one_time_keyboard=True)
            markup.add('Переводчик')
            msg = bot.send_message(chat_id, "Введите в каком городе/стране?: ", reply_markup=markup)  # Спрашиваем в
            # каком городе проверить и при этом крепим кнопку переводчика!
            bot.register_next_step_handler(msg, weather_bot)
        # Дальше условия касаются выбора языка с помощью кнопок! Если выбрали одну из кнопок ниже :
        if writer_lang == u'английский':
            lang1 = 'en'
        elif writer_lang == u'русский':
            lang1 = 'ru'
        elif writer_lang == u'украинский':
            lang1 = 'uk'
        elif writer_lang == u'испанский':
            lang1 = 'es'
        elif writer_lang == u'немецкий':
            lang1 = 'de'
        elif writer_lang == u'итальянский':
            lang1 = 'it'
        elif writer_lang == u'французский':
            lang1 = 'fr'
        elif writer_lang == u'китайский':
            lang1 = 'zh'
        user = user_dict[chat_id]
        user.writer_lang = writer_lang
        markup = types.ReplyKeyboardMarkup(one_time_keyboard=True)
        markup.add('английский', 'русский', 'испанский', 'немецкий', 'итальянский', 'французский', 'китайский')
        # При этом спрашиваем на какой язык переводить и крепим кнопки с соответствующими языками
        msg = bot.send_message(chat_id, "На какой язык переводить (если такого языка нет в выпадающем "
                                        "списке, напишите этот язык в сообщении!): ", reply_markup=markup)
        bot.register_next_step_handler(msg, translater_func2)
    except:
        if writer_lang == '/start' or writer_lang == '/help': # Если написали команду старт, то возвращаемся в начало кода!
            msg = bot.send_message(chat_id,
                                   "Здравствуйте, я полезный бот! Мое предназначение помогать в тех функциях которые "
                                   "в меня "
                                   "встроенные! "
                                   "В них входит перевод текста на необходимый Вам язык! Подскажите как я могу к Вам "
                                   "обращатся?")
            bot.register_next_step_handler(msg, command_start)
        else:
            msg = bot.send_message(chat_id, "Oooops!")
            bot.register_next_step_handler(msg, translater_func1)

def translater_func2(message):
    global lang # Создаем глобальную переменную для языка на который будет осуществлятся перевод!
    try:
        chat_id = message.chat.id
        translation_lang = message.text
        if translation_lang == u'Погода': # Создаем условие нажатия на кнопку: если это погода выполняем код - ниже!
            user = user_dict[chat_id]
            user.translation_lang = translation_lang
            markup = types.ReplyKeyboardMarkup(one_time_keyboard=True)
            markup.add('Переводчик')
            msg = bot.send_message(chat_id, "Введите в каком городе/стране?: ", reply_markup=markup)  # Спрашиваем в
            # каком городе проверить и при этом крепим кнопку переводчика!
            bot.register_next_step_handler(msg, weather_bot)
        # Условия для выбора языка на который будет перевод!
        if translation_lang == u'английский':
            lang = 'en'
        elif translation_lang == u'русский':
            lang = 'ru'
        elif translation_lang == u'украинский':
            lang = 'uk'
        elif translation_lang == u'испанский':
            lang = 'es'
        elif translation_lang == u'немецкий':
            lang = 'de'
        elif translation_lang == u'итальянский':
            lang = 'it'
        elif translation_lang == u'французский':
            lang = 'fr'
        elif translation_lang == u'китайский':
            lang = 'zh'
        user = user_dict[chat_id]
        user.translation_lang = translation_lang
        markup = types.ReplyKeyboardMarkup(one_time_keyboard=True)
        markup.add('Смена языков для перевода', 'Смена языка для перевода', 'Погода')
        msg = bot.send_message(chat_id, "Введите фразу для перевода : ", reply_markup=markup) # После определения
        # языков просим ввести текст для перевода. А так же крепим кнопки!
        bot.register_next_step_handler(msg, translate_phrases)
    except:
        if translation_lang == '/start' or translation_lang == '/help':  # Если написали команду старт, то возвращаемся в начало кода!
            msg = bot.send_message(chat_id,
                                   "Здравствуйте, я полезный бот! Мое предназначение помогать в тех функциях которые "
                                   "в меня "
                                   "встроенные! "
                                   "В них входит перевод текста на необходимый Вам язык! Подскажите как я могу к Вам "
                                   "обращатся?")
            bot.register_next_step_handler(msg, command_start)
        else:
            msg = bot.send_message(chat_id, 'Oooops')
            bot.register_next_step_handler(msg, translater_func2)

def translate_phrases(message):
    #global translation

    chat_id = message.chat.id
    phrases = message.text
    # Устанавливаем цикл: если нажаты кнопки текст не переводится, а выполняется переход по приложениям или смена языков!
    while phrases == u'Погода' or phrases == u'Смена языков для перевода' or phrases == u'Смена языка для перевода':
        # Тут как раз условия которые работают если нажали на одну из кнопок!
        if phrases == u'Погода':
            user = user_dict[chat_id]
            user.phrases = phrases
            markup = types.ReplyKeyboardMarkup(one_time_keyboard=True)
            markup.add('Переводчик')
            msg = bot.send_message(chat_id, "Введите в каком городе/стране?: ", reply_markup=markup)
            bot.register_next_step_handler(msg, weather_bot)
        elif phrases == u'Смена языков для перевода':
            user = user_dict[chat_id]
            user.phrases = phrases
            markup = types.ReplyKeyboardMarkup(one_time_keyboard=True)
            markup.add('английский', 'русский', 'испанский', 'немецкий', 'итальянский', 'французский', 'китайский',
                       'Погода')
            msg = bot.send_message(chat_id, "Укажите на каком языке будете писать (если такого языка нет в выпадающем "
                                            "списке, напишите этот язык в сообщении!): ", reply_markup=markup)
            bot.register_next_step_handler(msg, translater_func1)
        elif phrases == u'Смена языка для перевода':
            user = user_dict[chat_id]
            user.phrases = phrases
            markup = types.ReplyKeyboardMarkup(one_time_keyboard=True)
            markup.add('английский', 'русский', 'испанский', 'немецкий', 'итальянский', 'французский', 'китайский',
                       'Погода')
            msg = bot.send_message(chat_id, "На какой язык переводить (если такого языка нет в выпадающем "
                                            "списке, напишите этот язык в сообщении!): ", reply_markup=markup)
            bot.register_next_step_handler(msg, translater_func2)
        break
    else:
        translation = language_translator.translate(
            phrases,
            source=lang1, target=lang).get_result()
        msg = bot.send_message(chat_id, json.dumps(translation, indent=2, ensure_ascii=False))
        bot.register_next_step_handler(msg, translate_phrases)

# Здесь запускается приложение погода!
@bot.message_handler(content_types=['text'])
def weather_bot(message):
    global place
    try:
        chat_id = message.chat.id
        place = message.text
        user = user_dict[chat_id]
        user.place = place
        observation = owm.weather_at_place(place)
        w = observation.get_weather()
        markup = types.ReplyKeyboardMarkup(one_time_keyboard=True)
        markup.add('Переводчик')
        temp = w.get_temperature('celsius')["temp"]
        temp = round(temp)
        msg = bot.send_message(chat_id,
                               'В городе ' + place + ' сейчас ' + w.get_detailed_status() + ' Температура в этом '
                                                                                'городе: ' + str(
                                   temp), reply_markup=markup)

        if temp < 10 and temp >= 0:
            msg = bot.send_message(chat_id, 'Сейчас пипец как холодно, одевайся как танк!')
        elif temp >= 10 and temp < 20:
            msg = bot.send_message(chat_id, 'Тепло конечно, но загорать еще рано!')
        elif temp >= 20 and temp < 25:
            msg = bot.send_message(chat_id, 'Ну еще чуть чуть и загорать можно идти!')
        elif temp > 25:
            msg = bot.send_message(chat_id, 'Можно смело загорать!')
        else:
            msg = bot.send_message(chat_id, 'Снеговики наступааааают!!!')

        bot.register_next_step_handler(msg, weather_bot)

    except:
        if place == u'Переводчик':
            user = user_dict[chat_id]
            user.place = place
            markup = types.ReplyKeyboardMarkup(one_time_keyboard=True)
            markup.add('английский', 'русский', 'испанский', 'немецкий', 'итальянский', 'французский', 'китайский',
                       'Погода')
            msg = bot.send_message(chat_id, 'Да, давайте переводить. Укажите на каком языке будете писать!', reply_markup=markup)
            bot.register_next_step_handler(msg, translater_func1)
        elif place == '/start' or place == '/help':
            msg = bot.send_message(chat_id,
                                   "Здравствуйте, я полезный бот! Мое предназначение помогать в тех функциях которые в меня "
                                   "встроенные! "
                                   "В них входит перевод текста на необходимый Вам язык! Подскажите как я могу к Вам обращатся?")
            bot.register_next_step_handler(msg, command_start)
        else:
            msg = bot.send_message(chat_id, 'Такого города нет... Уточните пожалуйста название!')
            bot.register_next_step_handler(msg, weather_bot)

bot.polling()
while True:
    pass


from tkinter import *
from sudoku_api import get_grid,solve
from sudoku_solver import solver,if_poss
import tkinter.messagebox

root=Tk()
entries=user_inps=[[0 for i in range(9)] for j in range(9)]
canvas=Canvas(root,height=500,width=450)
canvas.pack()
board=[[0 for i in range(9)] for j in range(9)]
def get(event):
	return (event.widget.get())

#Create GUI

def create_board(grid):
	global canvas
	global root
	global board
	board=grid
	global entries
	canvas.delete("all")
	for i in range(9):
		canvas.create_line(0,i*50,450,i*50)
		canvas.create_line(i*50,0,i*50,450)
	for i in range(9):
		for j in range(9):
			if grid[i][j]==0:
				entry=Entry(root)
				entries[i][j]=entry
				canvas.create_window(((25+50*j),(25+50*i)),height=50,width=50,window=entry)
			else:
				canvas.create_text(((25+50*j),(25+50*i)),text=str(grid[i][j]))
	check_button=Button(canvas,text="CHECK!!!",font="Times 20 bold")
	solve_button=Button(canvas,text="SOLVE!!!",font="Times 20 bold")
	canvas.create_window((122,475),height=50,width=225,window=solve_button)
	canvas.create_window((347,475),height=50,width=225,window=check_button)
	solve_button.bind("<Button-1>",get_solved)
	check_button.bind("<Button-1>",check_correct)

def check_correct(event):
	global board
	global entries
	global canvas
	for i in range(9):
		for j in range(9):
			if board[i][j]==0:
				if entries[i][j].get():
					board[i][j]=int(entries[i][j].get())
				else:
					board[i][j]=0
	if is_correct(board):
		tkinter.messagebox.showinfo("Congratulations!!!!","You have completed the sudoku!!!")
		canvas.delete("all")
		for i in range(9):
			canvas.create_line(0,i*50,450,i*50)
			canvas.create_line(i*50,0,i*50,450)
		for i in range(9):
			for j in range(9):
				canvas.create_text(((25+50*j),(25+50*i)),text=str(board[i][j]))
		check_button=Button(canvas,text="CHECK!!!",font="Times 20 bold")
		solve_button=Button(canvas,text="SOLVE!!!",font="Times 20 bold")
		canvas.create_window((122,475),height=50,width=225,window=solve_button)
		canvas.create_window((347,475),height=50,width=225,window=check_button)
	else:
		tkinter.messagebox.showinfo("SORRY!!!!","That is not correct!!!")

def is_correct(grid):
	for i in range(9):
		for j in range(9):
			if grid[i][j]==0:
				return False
			if not if_poss(grid,i,j,grid[i][j]):
				return False
	return True

def get_solved(event):
	global board
	global canvas
	solver(board)
	canvas.delete("all")
	for i in range(9):
		canvas.create_line(0,i*50,450,i*50)
		canvas.create_line(i*50,0,i*50,450)
	for i in range(9):
		for j in range(9):
			canvas.create_text(((25+50*j),(25+50*i)),text=str(board[i][j]))

def easy(event):
	grid=get_grid(1)
	create_board(grid)

def medium(event):
	grid=get_grid(2)
	create_board(grid)

def hard(event):
	grid=get_grid(3)
	create_board(grid)

#Select Difficult

canvas.create_text((220,75),text="Select Difficulty",font="Times 20 bold")

easy_button=Button(canvas,text="Easy",font="Times 20 bold")
med_button=Button(canvas,text="Medium",font="Times 20 bold")
hard_button=Button(canvas,text="Hard",font="Times 20 bold")

canvas.create_window((220,125),height=40,width=200,window=easy_button)
canvas.create_window((220,205),height=40,width=200,window=med_button)
canvas.create_window((220,285),height=40,width=200,window=hard_button)

easy_button.bind("<Button-1>",easy)
med_button.bind("<Button-1>",medium)
hard_button.bind("<Button-1>",hard)

root.mainloop()