Mi viaje Creación de una aplicación CLI de gestión de eventos

Introducción

Como principiante en el desarrollo de software, una de las tareas más apasionantes y desalentadoras es crear su primer proyecto importante. Para mí, esta fue la aplicación CLI de gestión de eventos. Este proyecto no solo me ayudó a consolidar mi comprensión de Python, sino que también me presentó SQLAlchemy ORM, bibliotecas CLI como Click y las mejores prácticas generales de desarrollo de software. Al reflexionar sobre este viaje, me doy cuenta de cuánto he aprendido y de cómo estas habilidades han dado forma a mi confianza como desarrollador.

Los inicios: aprender los fundamentos de Python

Antes de sumergirme en este proyecto, mi viaje comenzó con los conceptos básicos de Python. Aprender la sintaxis, las estructuras de control, los tipos de datos y las funciones de Python fue la base que hizo posible abordar este proyecto. Recuerdo los días en que escribía scripts simples, depuraba errores y las pequeñas victorias que se obtenían con cada ejecución exitosa. Comprender estos fundamentos fue crucial porque forman la base de cualquier proyecto Python.

Uno de los aspectos más útiles que aprendí desde el principio fue cómo gestionar y manipular diferentes estructuras de datos, en particular listas, diccionarios y tuplas. Estas habilidades fueron esenciales cuando comencé a trabajar en la aplicación CLI de gestión de eventos, donde tenía que almacenar y manejar múltiples datos de manera eficiente.

Profundizando en el proyecto: configurando el entorno

El primer paso para crear la aplicación CLI de gestión de eventos fue configurar el entorno. Usar Pipenv para la gestión de entornos virtuales fue una experiencia nueva. Simplificó el proceso de gestión de dependencias y garantizó que el entorno del proyecto estuviera aislado del resto de mi sistema.

Así es como configuro el entorno virtual:

pipenv install
pipenv shell

A continuación, inicialicé Alembic para las migraciones de bases de datos. Este paso fue crucial para gestionar los cambios en el esquema de la base de datos a lo largo del tiempo.

alembic init migrations
alembic revision --autogenerate -m "Create Initial models"
alembic upgrade head

Construyendo los modelos

El núcleo de la aplicación radica en sus modelos. Usando SQLAlchemy ORM, definí los modelos para usuarios, eventos, horarios y asistentes. Aquí fue donde se unió mi comprensión de las clases de Python y SQLAlchemy. Aquí hay un fragmento del archivo models.py:

from sqlalchemy import Column, Integer, String, ForeignKey, DateTime, create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import relationship, sessionmaker

Base = declarative_base()

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    username = Column(String, unique=True, nullable=False)

class Event(Base):
    __tablename__ = 'events'
    id = Column(Integer, primary_key=True)
    name = Column(String, nullable=False)
    description = Column(String)
    user_id = Column(Integer, ForeignKey('users.id'))

    user = relationship('User', back_populates='events')

class EventSchedule(Base):
    __tablename__ = 'event_schedules'
    id = Column(Integer, primary_key=True)
    event_id = Column(Integer, ForeignKey('events.id'))
    start_time = Column(DateTime, nullable=False)
    end_time = Column(DateTime, nullable=False)

    event = relationship('Event', back_populates='schedules')

class Attendee(Base):
    __tablename__ = 'attendees'
    id = Column(Integer, primary_key=True)
    name = Column(String, nullable=False)
    event_id = Column(Integer, ForeignKey('events.id'))

    event = relationship('Event', back_populates='attendees')

User.events = relationship('Event', order_by=Event.id, back_populates='user')
Event.schedules = relationship('EventSchedule', order_by=EventSchedule.id, back_populates='event')
Event.attendees = relationship('Attendee', order_by=Attendee.id, back_populates='event')

Un aspecto técnico útil: relaciones en SQLAlchemy

Uno de los aspectos técnicos más útiles que aprendí durante este proyecto fue el manejo de relaciones en SQLAlchemy. La definición de relaciones entre tablas utilizando el ORM de SQLAlchemy facilitó la gestión de datos y la realización de consultas. Por ejemplo, establecer una relación de uno a muchos entre usuarios y eventos me permitió consultar fácilmente todos los eventos creados por un usuario específico.

Así es como definí la relación entre Usuario y Evento:

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    username = Column(String, unique=True, nullable=False)
    events = relationship('Event', order_by='Event.id', back_populates='user')

class Event(Base):
    __tablename__ = 'events'
    id = Column(Integer, primary_key=True)
    name = Column(String, nullable=False)
    description = Column(String)
    user_id = Column(Integer, ForeignKey('users.id'))
    user = relationship('User', back_populates='events')

Esta definición de relación me permitió consultar los eventos de un usuario fácilmente:

def get_user_events(user_id):
    user = session.query(User).filter(User.id == user_id).first()
    return user.events

Implementación de la CLI

La parte CLI de la aplicación se implementó mediante Click. Esta biblioteca facilitó la creación de una interfaz de línea de comandos que pudiera manejar varios comandos y opciones. Aquí hay un fragmento del archivo cli.py:

import click
from models import User, Event, EventSchedule, Attendee
from db import session

@click.group()
def cli():
    pass

@click.command()
def create_event():
    name = click.prompt('Enter event name')
    description = click.prompt('Enter event description')
    user_id = click.prompt('Enter user ID', type=int)
    event = Event(name=name, description=description, user_id=user_id)
    session.add(event)
    session.commit()
    click.echo('Event created!')

cli.add_command(create_event)

if __name__ == '__main__':
    cli()

mirando hacia atrás

Mirando hacia atrás, este proyecto ha sido un hito importante en mi trayectoria como desarrollador. Comenzó aprendiendo los fundamentos de Python, que sentaron las bases para comprender conceptos más complejos. El proyecto de la aplicación CLI de gestión de eventos fue una combinación perfecta de Python, SQL y interfaces de línea de comandos, lo que brindó una experiencia de aprendizaje integral.

Una de las conclusiones más importantes de este proyecto fue la importancia de la estructura y la organización en la codificación. El uso de entornos virtuales, la gestión de dependencias y el mantenimiento de una estructura de proyecto limpia hicieron que el proceso de desarrollo fuera más fluido y eficiente.

Además, la experiencia práctica con SQLAlchemy ORM y Click reforzó el conocimiento teórico que había adquirido. Comprender cómo definir relaciones entre tablas, realizar migraciones de bases de datos y crear una CLI fácil de usar fueron habilidades invaluables.

Conclusión

Crear la aplicación CLI de gestión de eventos fue una experiencia desafiante pero gratificante. Solidificó mi comprensión de Python y SQLAlchemy, me presentó las mejores prácticas en el desarrollo de software y mejoró mis habilidades para resolver problemas. Para cualquier principiante que quiera crecer como desarrollador, recomiendo encarecidamente sumergirse en un proyecto como este. Es una excelente manera de aplicar lo que ha aprendido, descubrir nuevas herramientas y técnicas y crear algo tangible de lo que pueda estar orgulloso.

https://github.com/migsldev/event-management-app