Solución al Ejercicio #3

Esta es la solución al Ejercicio #3: Integrar la aplicación Kwranking con una base de datos.

Como ya sabes, este ejercicio consiste fundamentalmente en integrar la aplicación Kwranking con una base de datos sqlite utilizando para ello el ORM de SQLAlchemy.

A continuación, te explico paso a paso cómo resolver cada uno de los apartados del ejercicio.

Fichero con la configuración de acceso a la base de datos

Crea un fichero llamado db.py en el directorio de tu proyecto, junto al fichero que contiene el programa principal.

El contenido de este fichero debe ser similar al siguiente:

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

# Crea el engine indicando la cadena de conexión a la base de datos
engine = create_engine('sqlite:///keywords.sqlite')

# Crea el objeto para manejar la sesión de base de datos
Session = sessionmaker(bind=engine)
session = Session()

# Crea la clase base de la que hereden los modelos de la aplicación
Base = declarative_base()

Modelo Keyword

El siguiente requisito del ejercicio consiste en implementar el modelo Keyword. Este modelo contiene la información asociada a unas palabras clave y representa a una fila de la tabla keyword en la base de datos.

Crea un nuevo fichero llamado models.py con el siguiente contenido:

from sqlalchemy.exc import IntegrityError

import db

from sqlalchemy import Column, Integer, String


class Keyword(db.Base):
    __tablename__ = 'keyword'

    id = Column(Integer, primary_key=True)
    keywords = Column(String, nullable=False, unique=True)  # Importante unique=True
    posicion = Column(Integer, nullable=True)

    def __init__(self, keywords, posicion=None):
        self.keywords = keywords
        self.posicion = posicion

    def __repr__(self):
        return f'Ranking({self.keywords}, {self.posicion})'

    def __str__(self):
        return f'La palabra clave {self.keywords} rankea en la posición {self.posicion}'

    def save(self):
        try:
            db.session.add(self)
            db.session.commit()
        except IntegrityError:
            # Si las palabras clave ya existen, se hace un rollback
            # de la base de datos 
            db.session.rollback()

    def delete(self):
        db.session.delete(self)
        db.session.commit()

    @staticmethod
    def get_all():
        return db.session.query(Keyword).all()

Redefinición de la función carga_keywords()

El siguiente requisito especificaba redefinir la función carga_keywords() para guardar en base de datos cada una de las palabras clave que se leían del fichero. Además, se devuelve la lista completa de elementos de tipo Keyword:

def carga_keywords():
    try:
        with open('keywords.txt') as fichero:
            for kw in fichero:
                kw = kw.replace('\n', '').lower()
                keyword = Keyword(kw)
                keyword.save()
    except FileNotFoundError:
        print('No se encuentra el fichero keywords.txt')

    return Keyword.get_all()

Recuerda añadir las importaciones oportunas al comienzo del módulo principal. En mi caso han sido las siguientes:

import db
from models import Keyword

Cargar las palabras clave al comienzo de la ejecución del programa

Simplemente, hay que inicializar la variable keywords realizando una consulta a la base de datos del siguiente modo:

def run():

    keywords = Keyword.get_all()  # <-- Esta es la clave de este requisito
    dominio = 'j2logo.com'

    while True:
        muestra_menu()
        opcion = input('Selecciona una opción > ')
        opcion = int(opcion)
        if opcion == 0:
            break
        ...

Crear las tablas de la base de datos al arrancar la aplicación

Finalmente, lo único que queda para terminar con este ejercicio es incluir una llamada a la función create_all() para que se creen las tablas de base de datos. Cada vez que se llama a esta función se comprueba si hay algún modelo nuevo que no dispone de tabla y, en ese caso, se crea la tabla correspondiente.

Yo he añadido la llamada a la función en el siguiente bloque de código:

if __name__ == '__main__':
    db.Base.metadata.create_all(db.engine)
    run()