def __init__(self, master=None):
"""
Construir la aplicacion.
"""
super().__init__(master)
self.api = DogAPI()
self.podio = Podio()
self.podio.cargar()
self.razas = self.api.obtener_razas()
self.iniciar_partida()
self.pantalla_inicial()
def main():
API_TOKEN = '466722132:AAG-i_NBJB25CyLdXUocW_B-gIIl81dQosM'
bot = telegram.Bot(token=API_TOKEN)
updater = Updater(token=API_TOKEN)
dispatcher = updater.dispatcher
razas = []
opciones = []
api = DogAPI()
podio = Podio()
# api.actualizar_razas()
razas = api.obtener_razas()
podio.cargar()
logging.basicConfig(
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
level=logging.INFO)
def start(bot, update):
bot.send_message(chat_id=update.message.chat_id,
text="Hola! Soy Jagua Maravichu Bot")
def jugar(bot, update):
imagen = api.obtener_imagen()
bot.send_photo(chat_id=update.message.chat_id, photo=imagen['url'])
bot.send_message(chat_id=update.message.chat_id, text="¿Qué raza es?")
opciones = random.choices(razas, k=2)
opciones.append(imagen['raza'])
random.shuffle(opciones)
teclado = []
for opcion in opciones:
correcto = 'N'
if opcion == imagen['raza']:
correcto = 'S'
teclado.append([
telegram.InlineKeyboardButton(text=opcion.replace('-',
' ').title(),
callback_data=correcto)
])
reply_markup = telegram.InlineKeyboardMarkup(teclado)
bot.send_message(chat_id=update.message.chat_id,
text="Elegí tu respuesta",
reply_markup=reply_markup)
telegram.ReplyKeyboardRemove()
def respuesta(bot, update):
mensaje = emoji.emojize(
'Incorrecto. Tenés que tomar un curso sobre razas caninas :thumbsdown:',
use_aliases=True)
if update.callback_query.data == 'S':
mensaje = emoji.emojize(
'Correcto!! :tada: :tada: Sabés mucho sobre razas caninas :clap: :clap:',
use_aliases=True)
bot.answer_callback_query(update.callback_query.id, text=mensaje)
bot.send_message(chat_id=update.callback_query.message.chat_id,
text=mensaje)
def unknown(bot, update):
bot.send_message(chat_id=update.message.chat_id,
text="Disculpame, no entiendo ese comando")
start_handler = CommandHandler('start', start)
jugar_handler = CommandHandler('jugar', jugar)
respuesta_handler = CallbackQueryHandler(respuesta)
unknown_handler = MessageHandler(Filters.command, unknown)
dispatcher.add_handler(start_handler)
dispatcher.add_handler(jugar_handler)
dispatcher.add_handler(respuesta_handler)
dispatcher.add_handler(unknown_handler)
updater.start_polling()
def test_sub_breed_list(get_next_sub_breed_list):
dictionary = get_next_sub_breed_list[1].get(get_next_sub_breed_list[0], None)
response = DogAPI.get_sub_breeds(get_next_sub_breed_list[0])
result = json.loads(response)
assert len(dictionary) == len(result.get("message", None))
def test_random_multiply_breed_images(get_next_pair):
response = DogAPI.get_multiply_images_from_breed(get_next_pair[0], get_next_pair[1])
result = json.loads(response)
assert result.get("status", None) == "success" and len(result.get("message")) == get_next_pair[1]
def test_random_count_images(get_next_count):
response = DogAPI.get_multiply_random_image(get_next_count)
result = json.loads(response)
assert result.get("status", None) == "success" and len(result.get("message")) == get_next_count
def test_random_breed_image(get_next_breed):
response = DogAPI.get_random_image_from_breed(get_next_breed)
result = json.loads(response)
assert result.get("status", None) == "success"
def test_random_image():
response = DogAPI.get_random_image()
result = json.loads(response)
assert result.get("status", None) == "success"
class Aplicacion(tk.Frame):
"""
Manejar la aplicacion y sus pantallas.
"""
def __init__(self, master=None):
"""
Construir la aplicacion.
"""
super().__init__(master)
self.api = DogAPI()
self.podio = Podio()
self.podio.cargar()
self.razas = self.api.obtener_razas()
self.iniciar_partida()
self.pantalla_inicial()
def iniciar_partida(self):
"""
Iniciar valores para una partida nueva.
"""
self.nombre = ''
self.intentos = 0
self.correctas = 0
self.incorrectas = 0
def limpiar_pantalla(self):
"""
Limpiar la pantalla de la aplicacion.
"""
for widget in self.master.winfo_children():
widget.destroy()
def pantalla_inicial(self):
"""
Cargar la pantalla inicial.
"""
self.limpiar_pantalla()
logo = Image.open('logo.jpg', 'r')
logo_tk = ImageTk.PhotoImage(logo)
etiqueta1 = tk.Label(self.master, image=logo_tk)
etiqueta1.image = logo_tk
etiqueta1.pack()
tk.Label(self.master, text='¡Bienvenido/a a Jagua Maravichu!').pack()
tk.Label(
self.master,
text=
'Jagua Maravichu es un juego sencillo que prueba tu conocimiento sobre razas caninas.'
).pack()
tk.Button(self.master, text='Jugar',
command=self.pantalla_nombre).pack()
def pantalla_nombre(self):
"""
Cargar la pantalla de ingreso de nombre.
"""
self.limpiar_pantalla()
tk.Label(self.master, text='¿Cuál es tu nombre?').pack()
nombre = tk.StringVar(self.master, value='Escribí tu nombre acá')
entrada = tk.Entry(self.master, textvariable=nombre)
entrada.pack()
def confirmar():
self.nombre = nombre.get()
self.pantalla_intentos()
tk.Button(self.master, text='Confirmar', command=confirmar).pack()
entrada.focus_set()
entrada.selection_adjust(tk.END)
entrada.bind("<Return>", (lambda event: confirmar()))
def pantalla_intentos(self):
"""
Cargar la pantalla de ingreso de intentos.
"""
self.limpiar_pantalla()
tk.Label(self.master, text='¡Hola ' + self.nombre + '!').pack()
tk.Label(self.master, text='¿Cuántas adivinanzas querés hacer?').pack()
intentos = tk.IntVar(self.master, value=0)
entrada = tk.Entry(self.master, textvariable=intentos)
entrada.pack()
def confirmar():
self.intentos = intentos.get()
if self.intentos >= 1:
self.pantalla_adivinanza(1)
else:
self.pantalla_inicial()
tk.Button(self.master, text='Confirmar', command=confirmar).pack()
entrada.focus_set()
entrada.selection_adjust(tk.END)
entrada.bind("<Return>", (lambda event: confirmar()))
def pantalla_adivinanza(self, intento):
"""
Cargar la pantalla de la adivinanza.
"""
self.limpiar_pantalla()
if not self.api.hay_conexion():
tk.Label(self.master, text='No hay conexión a Internet </3').pack()
tk.Button(self.master,
text='Intentar de nuevo',
command=self.pantalla_inicial).pack()
return
tk.Label(self.master, text='Pregunta No. ' + str(intento)).pack()
tk.Label(self.master, text='¿Qué raza es?').pack()
raza = self.api.obtener_imagen()
raza_raw = urllib.request.urlopen(raza['url']).read()
imagen = Image.open(io.BytesIO(raza_raw))
imagen_tk = ImageTk.PhotoImage(imagen)
etiqueta1 = tk.Label(self.master, image=imagen_tk)
etiqueta1.image = imagen_tk
etiqueta1.pack()
# tk.Label(self.master, text=raza['url']).pack()
opciones = random.choices(self.razas, k=2)
while raza['raza'] in opciones:
opciones = random.choices(self.razas, k=2)
opciones.append(raza['raza'])
random.shuffle(opciones)
respuesta = tk.IntVar(self.master, value=99)
etiqueta2 = tk.Label(self.master, text='')
grupo = tk.LabelFrame(self.master,
text='Elegí tu respuesta',
padx=10,
pady=10)
grupo.pack()
def continuar():
if intento < self.intentos:
self.pantalla_adivinanza(intento + 1)
else:
self.pantalla_puntuaciones()
def responder():
if respuesta.get() == opciones.index(raza['raza']):
etiqueta2['text'] = '¡Correcto!\n' + \
'Sabés mucho sobre razas caninas :D'
self.correctas = self.correctas + 1
else:
etiqueta2['text'] = 'Incorrecto.\n' + \
'Tenés que tomar un curso sobre razas caninas :(\n' + \
'La respuesta correcta era ' + \
raza['raza'].replace('-', ' ').title() + '.'
self.incorrectas = self.incorrectas + 1
grupo.destroy()
etiqueta2.pack()
tk.Button(self.master, text='Continuar', command=continuar).pack()
opciones.clear()
for indice, opcion in enumerate(opciones):
tk.Radiobutton(grupo,
text=opcion.replace('-', ' ').title(),
value=indice,
variable=respuesta,
command=responder,
indicatoron=0,
width=40).pack(anchor='center')
def pantalla_puntuaciones(self):
"""
Cargar la pantalla de puntuaciones.
"""
self.limpiar_pantalla()
if self.intentos > 0:
puntos = round(((self.correctas / self.intentos) * 100), 2)
tk.Label(self.master,
text=self.nombre + ', tu puntaje final es: ' +
str(puntos)).pack()
self.podio.ingresar_puntaje(self.nombre, puntos)
tk.Label(self.master, text=' Puntuaciones '.center(50, '=')).pack()
tk.Label(self.master, text=self.podio.to_string()).pack()
tk.Button(self.master,
text='Jugar de nuevo',
command=self.pantalla_inicial).pack()
self.podio.actualizar()
self.iniciar_partida()
def main():
"""
Iniciar la aplicacion.
"""
ancho = 72
print('=' * ancho)
print('Jagua Maravichu'.center(ancho))
print('=' * ancho)
razas = []
opciones = []
api = DogAPI()
podio = Podio()
# api.actualizar_razas()
razas = api.obtener_razas()
podio.cargar()
while True:
jugar = input("¿Querés jugar? (S/N): ")
if jugar in ('N', 'n'):
break
nombre = input('¿Cuál es tu nombre?: ')
cantidad = int(input('¿Cuántas adivinanzas querés hacer?: '))
correctas = 0
incorrectas = 0
puntos = 0
for i in range(cantidad):
if not api.hay_conexion():
print('No hay conexión a Internet </3')
break
print((' Pregunta No. ' + str(i + 1) + ' ').center(ancho, '-'))
imagen = api.obtener_imagen()
print(imagen['url'])
print('¿Qué raza es?')
opciones = random.choices(razas, k=2)
opciones.append(imagen['raza'])
random.shuffle(opciones)
for indice, opcion in enumerate(opciones):
print(str(indice) + ') ' + opcion)
respuesta = int(input("Escribí tu respuesta: "))
if respuesta == opciones.index(imagen['raza']):
print('Correcto!! Sabés mucho sobre razas caninas :D')
correctas = correctas + 1
else:
print(
'Incorrecto. Tenés que tomar un curso sobre razas caninas D:'
)
incorrectas = incorrectas + 1
opciones.clear()
if cantidad > 0:
puntos = round(((correctas / cantidad) * 100), 2)
print(nombre + ', tu puntaje final es: ' + str(puntos))
podio.ingresar_puntaje(nombre, puntos)
print(' Puntuaciones '.center(ancho, '='))
podio.desplegar()
podio.actualizar()
print('Chauuu!! Nos vemos pronto woof woof')