[Corrección Python + SQLite3 1] Libro de contactos.

#!/usr/bin/python3
import sys
import sqlite3
from abc import ABC, abstractmethod


## DATABASE MANAGEMENT

class Database(ABC):
    def __init__(self, conn_token, **kwargs):
        self._token = conn_token
    @abstractmethod
    def openCursor(self):
        raise NotImplementedError()
    @abstractmethod
    def commit(self):
        raise NotImplementedError()
    @abstractmethod
    def createTable(self, cr, table_name, fields):
        raise NotImplementedError()
    @abstractmethod
    def getAll(self, cr, table_name):
        raise NotImplementedError()
    @abstractmethod
    def addRecord(self, cr, table_name, record):
        raise NotImplementedError()
    @abstractmethod
    def removeRecord(self, cr, table_name, record_id):
        raise NotImplementedError()
    @abstractmethod
    def removeAll(self, cr, table_name):
        raise NotImplementedError()
    @staticmethod
    @abstractmethod
    def getSqlFieldType(base_type):
        raise NotImplementedError()

class SQLiteDB(Database):
    def __init__(self, conn_token, **kwargs):
        super().__init__(conn_token, **kwargs)
        self._sqlite = sqlite3.connect(self._token)
        self._sqlite.row_factory = sqlite3.Row
    def openCursor(self):
        return self._sqlite.cursor()
    def commit(self):
        return self._sqlite.commit()
    def createTable(self, cr, table_name, fields):
        sql_fields = ["id INTEGER PRIMARY KEY"]
        for field_name in fields:
            field = fields[field_name]
            sql_fields.append(f"{field_name} {self.__class__.getSqlFieldType(field['type'])} {'reference' in field and ' REFERENCES {}'.format(field['reference']) or ''}")
        res = cr.execute(f"CREATE TABLE IF NOT EXISTS {table_name} ({','.join(sql_fields)})")
        return res.rowcount
    def getAll(self, cr, table_name):
        res =  cr.execute(f"SELECT * FROM {table_name}")
        return res.fetchall()
    def addRecord(self, cr, table_name, record):
        fields = list(record)
        values = [record[field] for field in fields]
        values_placeholder = ["?" for i in range(len(values))]
        res = cr.execute(f"INSERT INTO {table_name} ({','.join(fields)}) VALUES ({','.join(values_placeholder)})", values)
        return res.rowcount
    def removeRecord(self, cr, table_name, record_id):
        res = cr.execute(f"DELETE FROM {table_name} WHERE ID=?", (int(record_id),))
        return res.rowcount
    def removeAll(self, cr, table_name):
        res = cr.execute(f"DELETE FROM {table_name}")
        return res.rowcount
    def getSqlFieldType(base_type):
        # TODO: Add more field types if needed
        field_types = {
            "char": "TEXT",
            "integer": "INTEGER",
        }
        return field_types.get(base_type, base_type)


## BOOK CONTACTS

class Book(ABC):
    _table_name = False
    def __init__(self, database):
        self._db = database
        self._cr = self._db.openCursor()
        self.createDBSchema()
    def __del__(self):
        self._cr.close()
    @abstractmethod
    def createDBSchema(self):
        raise NotImplementedError()
    def getAll(self):
        return self._db.getAll(self._cr, self._table_name)
    def add(self, values):
        res = self._db.addRecord(self._cr, self._table_name, values)
        self._db.commit()
        if res == 0:
            raise Exception()
        return res
    def delete(self, contact_id):
        res = self._db.removeRecord(self._cr, self._table_name, contact_id)
        self._db.commit()
        if res == 0:
            raise Exception()
        return res
    def deleteAll(self):
        res = self._db.removeAll(self._cr, self._table_name)
        self._db.commit()
        if res == 0:
            raise Exception()
        return res
    @staticmethod
    def print(records):
        if len(records) == 0:
            print("No records to print!")
            return
        sample_columns = records[0].keys()
        sample_values = tuple(records[0])
        sizes = "".join([f"{{:<{(isinstance(sample_values, str) and '35' or '15')}}} " for value in sample_values])
        print(sizes.format(*sample_columns))
        for record in records:
            print(sizes.format(*tuple(record)))
    


class BookContacts(Book):
    _table_name = "contacts"
    def createDBSchema(self):
        self._db.createTable(self._cr, self._table_name, {
            "name": {
                "type": "char",
            },
            "phone_number": {
                "type": "char",
            },
        })


## CLI COMMANDS
# This is done is this way to allow be extended by modules

menu_commands = {}

class CommandType(type):
    def __init__(cls, name, bases, attrs):
        super().__init__(name, bases, attrs)
        name = getattr(cls, name, cls.__name__.lower())
        cls.name = name
        if name != 'command':
            menu_commands[cls.menu_option] = cls

Command = CommandType('Command', (object,), {'run': lambda self, book: None, 'menu_option': "-1"})

class Exit(Command):
    """Exit program"""
    menu_option = "0"
    def run(self, book):
        print("Bye bye!")
        sys.exit(0)

class Help(Command):
    """Display the list of available commands"""
    menu_option = "1"
    def run(self, book):
        print("Available commands:\n")
        option_names = list(menu_commands)
        padding = max([len(k) for k in option_names]) + 2
        for k in sorted(option_names):
            name = k.ljust(padding, ' ')
            doc = (menu_commands[k].__doc__ or '').strip()
            print("    %s%s" % (name, doc))
        


class ShowAllContacts(Command):
    """Show all contacts"""
    menu_option = "2"
    def run(self, book):
        contacts = book.getAll()
        book.print(contacts)
        


class AddContact(Command):
    """Add a new contact"""
    menu_option = "3"
    def run(self, book):
        name = input("Name: ")
        phone_number = input("Phone number: ")
        try:
            book.add({
                "name": name,
                "phone_number": phone_number,
            })
            print("New contact added!")
        except:
            print("Oops! can't add the contact :/")
            

    


class DeleteContact(Command):
    """Delete an existing contact"""
    menu_option = "4"
    def run(self, book):
        contact_id = input("ID to delete: ")
        try:
            book.delete(contact_id)
            print("Contact deleted!")
        except:
            print("Oops! can't delete the contact :/")
        


class DeleteAllContacts(Command):
    """Delete all contacts"""
    menu_option = "5"
    def run(self, book):
        y_n = input("You are going to delete all your contacts, you sure? [Y/N] ").lower()
        if y_n != "y":
            print("Task cancelled!")
            return
        try:
            book.deleteAll()
            print("All contacts deleted!")
        except:
            print("Oops! can't delete contacts :/")


## MAIN

if __name__ == "__main__":
    print("Welcome to your contacts book!\n")
    db = SQLiteDB("book.db")
    book = BookContacts(db)
    help_command = menu_commands["1"]()
    help_command.run(book)
    while True:
        print("\n")
        option_selected = None
        while option_selected not in list(menu_commands):
            option_selected = input("Please select an option by number: ")
        print("\n")
        o = menu_commands[option_selected]()
        o.run(book)