Minha jornada criando um aplicativo CLI de gerenciamento de eventos

Introdução

Como iniciante no desenvolvimento de software, uma das tarefas mais emocionantes e assustadoras é criar seu primeiro projeto significativo. Para mim, este foi o aplicativo Event Management CLI. Este projeto não apenas me ajudou a consolidar meu conhecimento de Python, mas também me apresentou ao SQLAlchemy ORM, bibliotecas CLI como Click e às melhores práticas gerais de desenvolvimento de software. Refletindo sobre essa jornada, percebo o quanto aprendi e como essas habilidades moldaram minha confiança como desenvolvedor.

O começo: aprendendo os fundamentos do Python

Antes de mergulhar neste projeto, minha jornada começou com o básico de Python. Aprender a sintaxe, estruturas de controle, tipos de dados e funções do Python foi a base que tornou possível a abordagem deste projeto. Lembro-me dos dias em que escrevia scripts simples, depurava erros e das pequenas vitórias que aconteciam com cada execução bem-sucedida. Compreender esses fundamentos foi crucial porque eles constituem a base de qualquer projeto Python.

Um dos aspectos mais úteis que aprendi desde o início foi como gerenciar e manipular diferentes estruturas de dados, principalmente listas, dicionários e tuplas. Essas habilidades foram essenciais quando comecei a trabalhar no aplicativo Event Management CLI, onde tive que armazenar e lidar com vários dados de forma eficiente.

Mergulhando no Projeto: Configurando o Meio Ambiente

A primeira etapa na criação do aplicativo Event Management CLI foi configurar o ambiente. Usar o Pipenv para gerenciamento de ambiente virtual foi uma experiência nova. Ele simplificou o processo de gerenciamento de dependências e garantiu que o ambiente do projeto fosse isolado do resto do meu sistema.

Veja como configuro o ambiente virtual:

pipenv install
pipenv shell

Em seguida, inicializei o Alembic para migrações de banco de dados. Esta etapa foi crucial para gerenciar as alterações no esquema do banco de dados ao longo do tempo.

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

Construindo os Modelos

O núcleo do aplicativo está em seus modelos. Usando SQLAlchemy ORM, defini os modelos para usuários, eventos, agendas e participantes. Foi aqui que minha compreensão das classes Python e do SQLAlchemy se uniu. Aqui está um trecho do arquivo 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')

Um aspecto técnico útil: relacionamentos em SQLAlchemy

Um dos aspectos técnicos mais úteis que aprendi durante este projeto foi como lidar com relacionamentos no SQLAlchemy. Definir relacionamentos entre tabelas usando ORM do SQLAlchemy facilitou o gerenciamento dos dados e a realização de consultas. Por exemplo, estabelecer um relacionamento um-para-muitos entre usuários e eventos me permitiu consultar facilmente todos os eventos criados por um usuário específico.

Veja como defini o relacionamento entre Usuário e 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')

Essa definição de relacionamento me permitiu consultar facilmente os eventos de um usuário:

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

Implementando a CLI

A parte CLI do aplicativo foi implementada usando Click. Essa biblioteca simplificou a criação de uma interface de linha de comando que poderia lidar com vários comandos e opções. Aqui está um trecho do arquivo 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()

Olhando para trás

Olhando para trás, este projeto foi um marco significativo em minha jornada como desenvolvedor. Tudo começou com o aprendizado dos fundamentos do Python, que lançou as bases para a compreensão de conceitos mais complexos. O projeto do aplicativo Event Management CLI foi uma combinação perfeita de Python, SQL e interfaces de linha de comando, proporcionando uma experiência de aprendizado abrangente.

Uma das maiores conclusões deste projeto foi a importância da estrutura e organização na codificação. O uso de ambientes virtuais, o gerenciamento de dependências e a manutenção de uma estrutura de projeto limpa tornaram o processo de desenvolvimento mais tranquilo e eficiente.

Além disso, a experiência prática com SQLAlchemy ORM e Click reforçou o conhecimento teórico que adquiri. Compreender como definir relacionamentos entre tabelas, realizar migrações de banco de dados e criar uma CLI amigável foram habilidades inestimáveis.

Conclusão

Criar o aplicativo Event Management CLI foi uma experiência desafiadora, mas gratificante. Ele solidificou minha compreensão de Python e SQLAlchemy, apresentou-me às melhores práticas em desenvolvimento de software e aprimorou minhas habilidades de resolução de problemas. Para qualquer iniciante que queira crescer como desenvolvedor, recomendo fortemente mergulhar em um projeto como este. É uma excelente maneira de aplicar o que você aprendeu, descobrir novas ferramentas e técnicas e construir algo tangível do qual você possa se orgulhar.

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