Exemple #1
0
    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()
Exemple #2
0
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()
Exemple #3
0
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))
Exemple #4
0
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]
Exemple #5
0
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
Exemple #6
0
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"
Exemple #7
0
def test_random_image():
    response = DogAPI.get_random_image()
    result = json.loads(response)
    assert result.get("status", None) == "success"
Exemple #8
0
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()
Exemple #9
0
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')