Comando Create con Click: opciones y persistencia CSV

Curso Práctico de Python: Creación de un CRUD

Contenido del curso

Básicos del Lenguaje

Uso de strings y ciclos

Estructuras de Datos

Uso de objetos y módulos

Comando Create con Click: opciones y persistencia CSV

Resumen

Diseña un flujo sólido para crear clientes desde la línea de comando con Click en Python: define opciones con prompt, valida entradas, inicializa el modelo, persiste en CSV y corrige errores comunes sin perder tiempo. Aquí verás el patrón de interfaz con short name y long name, el uso de contexto y un cierre funcional con escritura en archivo.

¿Cómo definir opciones en Click para un comando create?

Configurar opciones en Click permite pedir datos al usuario de forma guiada. Se usa un short name y un long name para la opción principal, se define el tipo string, se activa prompt true para solicitar la entrada en consola y se añade una línea de ayuda clara.

Opción principal con alias: -n/--name.
Tipo de dato: string.
Solicitud interactiva: prompt True.
Ayuda contextual: "the client's name".
Repetición del patrón para: company, email, position.

Ejemplo mínimo en código con el patrón descrito:

import click

@click.command()
@click.option('-n', '--name', type=str, prompt=True, help="The client's name.")
@click.option('--company', type=str, prompt=True, help="The client's company.")
@click.option('--email', type=str, prompt=True, help="The client's email.")
@click.option('--position', type=str, prompt=True, help="The client's position.")
@click.pass_context
def create(ctx, name, company, email, position):
    pass

¿Qué patrón de interfaz se aplica con short name y long name?

Alias breve para velocidad: -n.
Nombre largo legible: --name.
Consistencia al replicar el patrón en cada campo.
Ayuda clara para cada opción.

¿Cómo inicializar el cliente y usar el servicio?

Tras recolectar parámetros, se importan solo las clases necesarias mediante importación selectiva: ClientService desde clients.services y Client desde clients.models. Luego se inicializa el modelo con nombre, compañía, email y posición. El ID se deja vacío para que el sistema lo genere automáticamente. Finalmente, el servicio persiste la entidad con create_client.

Importaciones específicas: from clients.services import ClientService y from clients.models import Client.
Inicialización del modelo: name, company, email, position.
ID autogenerado: no se pasa manualmente.
Uso del servicio: create_client con la referencia del cliente.

Snippet representativo:

from clients.services import ClientService
from clients.models import Client

@click.pass_context
def create(ctx, name, company, email, position):
    client = Client(name=name, company=company, email=email, position=position)
    service = ClientService(ctx.obj['clients_table'])
    service.create_client(client)

¿Cómo configurar el contexto con clients_table en pv.py?

Para persistir datos se define una variable global con el nombre del archivo y se agrega al contexto de la app, de modo que los comandos la consuman sin acoplamiento.

Archivo de almacenamiento: .clients.csv.
Variable global: clients_table.
Integración al contexto: uso de ctx.obj.

Ejemplo esquemático:

# pv.py
CLIENTS_TABLE = '.clients.csv'

# En la inicialización del CLI
def cli(ctx):
    ctx.ensure_object(dict)
    ctx.obj['clients_table'] = CLIENTS_TABLE

¿Cómo depurar errores comunes al ejecutar el comando?

Al probar con pv clients create se detectaron fallos típicos: import mal escrito y typo en atributos. La solución fue ajustar el nombre correcto del modelo y corregir el campo de posición para que coincida en todo el código.

Importación incorrecta: usar from clients.models import Client en lugar de un nombre inexistente.
Archivo involucrado: clients/commands.py.
Atributo mal escrito: positon corregido a position en clients/models.
Verificación rápida: limpiar consola, ejecutar de nuevo y revisar salida.

¿Cómo validar el archivo clients.csv generado?

Tras la ejecución, se inspecciona .clients.csv y se confirma que los datos están separados por comas. Esto permitirá manipularlos con DictReader más adelante.

Apertura del archivo y lectura manual.
Confirmación de formato: valores separados por comas.
Preparación para lectura con dict reader en próximos pasos.

¿Te gustaría comentar qué otros campos u opciones agregarías al comando y cómo validarías entradas como el email desde la línea de comando?

Jesus Ruvalcaba Miranda

Estudiante

Para todos aquellos que estan confundidos con la logica que llevamos asta el momento esto es lo que yo entiendo:

Que es el modulo Click:

Click es un paquete de Python para crear hermosas interfaces de línea de comandos de una manera componible con el mínimo código necesario. Es el "Kit de creación de interfaz de línea de comandos". Es altamente configurable pero viene con valores predeterminados razonables listos para usar.

Su objetivo es hacer que el proceso de escribir herramientas de línea de comandos sea rápido y divertido, al mismo tiempo que evita cualquier frustración causada por la incapacidad de implementar una API CLI prevista.

Clic en tres puntos:

anidamiento de comandos
generación automática de páginas de ayuda
admite carga lenta de subcomandos en tiempo de ejecución

En pocas palabras el codigo donde el usuario selecciona las opciones se sustituye con el modulo Click

El modulo Setup

Unicamente lo utilizamos para poder instalarlo en el entorno virtual de pyton como si de un exe en windows o un dmg en mac

Los modulos en Client

toda la logica que aplicamos con las funciones se separa en tres archivos:

Models
Services
commands

Models.

aqui convertimos la estructura del Cliente en una clase

# esto:
CLIENT_SCHEMA = ['name', 'company', 'email', 'position']

# se convierte en esto:
    @staticmethod
    def schema():
        return ['name', 'company', 'email', 'position', 'uid']

Services

En este archivo ejecutmos los comandos necesarios para guardar la informacion en el archivo la unica diferencia es que en ves de guardar la información al final de la ejecución del codigo lo hacemos cada que se ejecuta un comando:

#en ves de esto:
def _save_clients_to_storage():
    with open(CLIENT_TABLE, mode='w') as f:
        writer = csv.DictWriter(f, fieldnames=CLIENT_SCHEMA)
        writer.writerows(clients)

#se hace esto:
class ClientService:

    def __init__(self, table_name):
        self.table_name = table_name

    def create_client(self, client):
        with open(self.table_name, mode='a') as f:
            writer = csv.DictWriter(f, fieldnames=Client.schema())
            writer.writerow(client.to_dict())

####Commands

En este modulo realizamos la logica de la aplicación

#en ves de esto:
def crear_cliente():
    client = _get_client_field('name')

    if search_client(client):
        print('Client already is in the clients\'s list')
    else:
        clients.append(_get_Client(client))
        list_clients()


def list_clients():
    for id, client in enumerate(clients):
        print('{uid} | {name} | {company} | {email} | {position} |'.format(
            uid=id,
            name=client['name'],
            company=client['company'],
            email=client['email'],
            position=client['position']
        ))


def update_client():
    client_name = _get_client_field('name')

    if search_client(client_name):
        for client in clients:
            if client['name'] == client_name:
                index = clients.index(client)
                clients[index] = _get_Client(client_name)
                list_clients()
                break
    else:
        print('CLient is not in client\'s list')


def delete_client():
    client_name = _get_client_field('name')

    if search_client(client_name):
        for client in clients:
            if client['name'] == client_name:
                clients.remove(client)
                list_clients()
    else:
        print('CLient is not in client\'s list')


def search_client(client_name):
    for client in clients:
        if client['name'] != client_name:
            continue
        else:
            return True


def _print_welcome():
    print('Welcome to Platzi Ventas')
    print('*' * 50)
    print('What would your like to do doing')
    print('[C]reate client')
    print('[L]ist client\'s')
    print('[U]pdate client')
    print('[D]elete client')
    print('[S]earch client')


def _get_client_field(field_name):
    field = None

    while not field:
        field = input('What is the client {}? '.format(field_name))

        if field == 'exit':
            field = None
            break

    if not field:
        sys.exit()

    return field


def _get_Client(client):
    client = {
        'name': client,
        "company": _get_client_field("company"),
        'email': _get_client_field('email'),
        "position": _get_client_field("position")
    }

    return client

#Vamos realizando cada comando asi
@click.group()
def clients():
    """Manages the clients lifecycle"""
    pass


@clients.command()
@click.option('-n', '--name', type=str, prompt=True, help='The client name')
@click.option('-c', '--company', type=str, prompt=True, help='The client company')
@click.option('-e', '--email', type=str, prompt=True, help='The client email')
@click.option('-p', '--position', type=str, prompt=True, help='The client position')
@click.pass_context
def create(ctx, name, company, email, position):
    """Create a new client"""
    client = Client(name, company, email, position)
    client_service = ClientService(ctx.obj['clients_table'])
    client_service.create_client(client)


@clients.command()
@click.pass_context
def list(ctx):
    """List of clients"""
    pass


@clients.command()
@click.pass_context
def update(ctx, client_uid):
    """Updates of clients"""
    pass


@clients.command()
@click.pass_context
def delete(ctx, client_uid):
    """Delete clients"""
    pass


all = clients

Espero que les ayude en algo y no los confunda mas 😅

Luis Xavier Perez Miramontes

Estudiante

Muy buen aporte! lo agregare a mis notas :D

Royer Guerrero Pinilla

John Fredy Higuita Porras

Lucas Ezequiel Veliz

Jesús Hernández Rendón

David Fuentes

Juan David Marquez Rodriguez

Facundo Nicolás García Martoni

Profesor

Jesús Maximiliano Manchuk

Juan Diego Silva Garcia

Noe Mikhael Huaccharaque Ruiz

Geovany Uribe Aguirre

Hector Olvera Vital

Hugo Orlando Gonzalez

Diego Aquino

Katherine Cortés

Alvaro Daniel Vidal Velasque

Nicolás Mayorga Vargas

Sebastian Baez Ramos

Eliecer Jorge Uribe Pinto

Ruben Eduardo Acosta Vela

Nicolas Humberto Sulca Vega

Nicolas Koriakos

Sergio Lara

Néstor Iván Cepeda Munevar

Juan Castro

Israel Yance

Luis Kennedy Saavedra Fuentes

Miguel Torres

Alejandro Guerrero

Cesar Hernández Ramírez

Andrés Felipe Cruz Cifuentes

Jorge luis castro marchan

Daniel Hurtado

Gerardo Rodriguez Sanchez

David Rosas

Comando Create con Click: opciones y persistencia CSV

Básicos del Lenguaje

Introducción a Python: Instalación y Conceptos Básicos

Desarrollo de CRUD con Python 3

Configuración de Ubuntu en Windows 10 para Ejecutar Comandos Linux

Qué es la programación y cómo crear un programa

Por qué Python es ideal para principiantes

Operadores y tipos de datos en Python

<target-language>Spanish</target-language> Variables y expresiones en Python

Cómo crear tu primer comando en Python

Cómo declarar y usar funciones en Python

Funciones y scope global en Python

Operadores de comparación en Python

Personalizar programa Python con interfaz CLI

Uso de strings y ciclos

Strings inmutables en Python y memoria

Métodos esenciales de strings en Python

Refactorización Python: método auxiliar privado

Comando delete en Python: borrar elementos

Slices en Python: extraer rebanadas de texto

For loops y While loops en Python

While loops: validación de entrada con break

Iteradores y Generadores en Python: Creación y Uso Práctico

Estructuras de Datos

Listas de Python: mutable vs inmutable

Operadores y métodos de listas en Python

Refactorizar código con listas en Python

Diccionarios Python: llaves, valores e items

Python: diccionarios para estructura de cliente

Tuplas y conjuntos en Python

Tuplas y sets en Python: cómo funcionan

Colecciones Avanzadas en Python: UserDict, namedtuple y más

Python comprehensions: listas, sets y diccionarios

Búsqueda binaria vs fuerza bruta

Implementar búsqueda binaria recursiva en Python

Persistencia de datos con CSV en Python

Uso de objetos y módulos

Qué son decoradores en Python: concepto clave

Creación de decoradores en Python paso a paso

Los cuatro principios clave de POO

Class y __init__ en Python básico

Names y Namespaces en Python: Conceptos Fundamentales

Framework Click para aplicaciones CLI

Estructura de archivos para CLI con Click

Cómo estructurar una app CLI con orientación a objetos

Comando Create con Click: opciones y persistencia CSV

Método list_clients con csv.DictReader

CSV con tabla temporal en Python

Cómo actualizar clientes en CLI con Click

Jerarquía de errores en Python: try, except y finally

Gestión de Contextos en Python: Clases y Generadores

Python en el mundo real

Siguientes pasos con Python: ciencias y backend

Conclusiones finales

Transición de Python 2 a Python 3 y PEPs esenciales

Clases bonus

Instalación pip y ambientes virtuales Python

Resumen

Class y init en Python básico