Brandon Jared Molina Vázquez — Ingeniero de Software

Clínica Veterinaria MARVIC

Desarrollo de un sistema backend para la gestión de una clínica veterinaria. Implementé una API REST con FastAPI y PostgreSQL, enfocada en validación de datos, diseño claro de endpoints y consistencia de la información.

PET (Perdidos En Tapachula)

Desarrollo de servicios backend con FastAPI y MongoDB, orientados al manejo de datos no relacionales. Incluyó el modelado de documentos y la optimización de consultas para mejorar el rendimiento.

COBACH 217 Soconusco

Migración de una base de datos heredada en Visual FoxPro hacia MongoDB. Reestructuré los datos y adapté el modelo para un entorno moderno, mejorando mantenibilidad y escalabilidad del sistema.

BOCADOS – Backend Service

Desarrollo del backend para un sistema de gestión, utilizando Flask y SQLModel. Diseñé la arquitectura base del proyecto, implementando paginación, rutas dinámicas y una estructura extensible.

                        EntityManager.processEntities(User.class);
                        
                        User user = new User(
                            UUID.randomUUID(),
                            "Valentina",
                            "Fernández Soto",
                            new Date("03/10/1990"),
                            3127
                        );
                        
                        EntityManager.persist(user);
                        

Mini ORM para Java

Proyecto experimental desarrollado para comprender cómo funcionan internamente herramientas como Hibernate y JPA. Implementé un sistema de persistencia basado en reflexión y anotaciones personalizadas capaz de generar esquemas de base de datos y consultas SQL a partir de clases Java.

El proyecto incluye procesamiento de anotaciones como @Table, @Column, @Id y @GeneratedValue, construcción de metadata mediante reflexión, generación automática de sentencias CREATE TABLE e INSERT, mapeo de tipos Java a SQL y ejecución dinámica mediante JDBC.

Como parte del diseño implementé un EntityManager propio, un sistema de migraciones automáticas, un generador de consultas SQL y una capa de configuración desacoplada para distintos motores de base de datos.

                        @module(
                            controllers=[
                                "UserController",
                                "EmployeeController"
                            ],
                            providers=[
                                "UserService",
                                "EmployeeService"
                            ]
                        )
                        class AppModule:
                            pass
                        
                        nestpy = NestPyApplicationContext()
                        
                        for name, params in nestpy.get_controllers().items():
                            app.comp.add_router_group(
                                name,
                                prefix=params.get("params").get("args")[0]
                            )
                        

NestPy

Framework experimental inspirado en NestJS y desarrollado sobre FastAPI y Flask con el objetivo de comprender cómo funcionan internamente los sistemas modernos de inyección de dependencias, descubrimiento de componentes y registro automático de rutas.

Implementé decoradores para módulos, controladores, servicios y endpoints, junto con un contenedor de aplicación encargado de registrar dependencias, almacenar metadatos y construir la configuración de la aplicación mediante introspección y reflexión.

El framework incorpora escaneo dinámico de clases, análisis de firmas de funciones, construcción automática de rutas, adaptación hacia FastAPI y un sistema de metadatos inspirado en la filosofía de NestJS.

Como parte de la arquitectura desarrollé componentes propios para reflexión, registro de controladores, manejo de módulos, resolución de dependencias y generación dinámica de handlers a partir de información obtenida mediante inspect.

                        class Customer(Model):
                        
                            id: str
                            name: str
                        
                        customer = Customer()
                        
                        result = customer.get(
                            customer_id="1001",
                            relates=True
                        )
                        
                        print(result.to_repr())
                        

DBF Mapper

Uno de mis primeros proyectos de exploración técnica en Python, desarrollado durante mi proceso de aprendizaje de reflexión e introspección. El objetivo fue transformar archivos DBF heredados en objetos Python utilizando un modelo similar a un ORM ligero.

Implementé una capa de acceso a datos capaz de leer estructuras DBF, construir modelos dinámicamente y mapear registros a objetos Python utilizando genéricos, anotaciones de tipo y metadatos definidos mediante Annotated.

El proyecto incluye resolución básica de relaciones entre modelos, búsqueda dinámica por criterios, representación automática de entidades y un sistema de lectura desacoplado para interactuar con bases de datos DBF utilizadas en sistemas heredados.

Aunque fue desarrollado antes de profundizar en conceptos como metaclases, decorators avanzados y manipulación de runtime, representó uno de mis primeros acercamientos al diseño de librerías y herramientas de infraestructura en Python.

                                    # Keyboard Event Stream
                        
                                    C Listener
                                        |
                                        |  IPC
                                        |  Unix Socket
                                        v
                        
                                    /tmp/keyboard_ipc.sock
                        
                        
                                    Python Backend
                        
                                    listener = Listener(
                                        on_press=handle_press,
                                        on_release=handle_release
                                    )
                        
                                    listener.listen()
                        
                                    # (code, state, timestamp)
                                    (30, 1, 1715932100)
                                

Net Keyboard

Proyecto inspirado en herramientas como Synergy, cuyo objetivo es controlar múltiples equipos utilizando un único teclado y mouse, permitiendo compartir eventos de entrada entre diferentes máquinas sin hardware adicional.

Implementé un sistema de captura de eventos de teclado a bajo nivel mediante un listener desarrollado en C, encargado de leer los eventos directamente desde el sistema operativo y transmitirlos hacia una capa superior escrita en Python.

La comunicación entre procesos fue diseñada utilizando IPC mediante sockets Unix, creando un canal de comunicación binario donde los eventos del teclado son serializados como estructuras compactas conteniendo código de tecla, estado y timestamp.

La arquitectura separa la captura del hardware y el procesamiento de eventos, permitiendo desacoplar el componente nativo del backend Python mediante un sistema basado en listeners, callbacks y distribución de eventos.

Este proyecto fue una exploración de programación de sistemas, integración entre C y Python, comunicación entre procesos y manejo de eventos en tiempo real.