How angel23213/lenguajes-y-aut-matas works
Tipo y propósito del proyecto (a partir del árbol y README)
Este repositorio no es una “aplicación” desplegable tipo web; es un repositorio educativo con múltiples mini‑proyectos de autómatas (probablemente deterministas) implementados en Python, más documentación en PDF.
Indicadores claros:
• README: “proyectos de autómatas… para entender características”.
• Estructura: carpetas separadas, cada una con un .py principal y algunos PDFs de soporte/pruebas.
• No se observan dependencias, framework, ni empaquetado (no hay requirements.txt, setup.py, src/, etc.). Esto sugiere scripts ejecutables (CLI / ejecución directa) más que una librería.
Cómo leer la estructura (y qué implica para el diagrama)
Carpetas de primer nivel (cada una = un “sub-sistema”):
• Automata moore-mealy/Automata-moore.py
Implementación relacionada a Máquinas de Moore/Mealy (típicamente producen salida por estado o transición).
• Automata1/automata.py + Pruebas de palabras V y NV.pdf
Un autómata con pruebas de palabras válidas y no válidas (aceptación/rechazo).
• Automatacar/car.py + Desarrollo de automata.pdf
Un autómata aplicado a un “car” (posible simulación de estados de un carro o control).
En términos de arquitectura, esto se parece a:
• Repo (contenedor)
• Proyecto A: Moore/Mealy script
• Proyecto B: Automata1 script + documento de pruebas
• Proyecto C: Car automaton script + documento de diseño
Qué diagrama conviene: 2 niveles (recomendado)
Para “el mejor y más exacto” diagrama, dibuja dos diagramas:
Diagrama de contexto del repositorio (alto nivel)
Objetivo: mostrar que el repo es un conjunto de subproyectos independientes.
Componentes a incluir
• “Usuario/Estudiante” (actor)
• Cada subproyecto como caja separada:
• Automata moore-mealy (Automata-moore.py)
• Automata1 (automata.py)
• Automatacar (car.py)
• PDFs como “Documentación/Especificación/Pruebas” conectados al script correspondiente.
Relaciones
• Usuario ejecuta script → ingresa “palabra/secuencia/eventos” → recibe “acepta/rechaza/salida/simulación”.
• PDFs alimentan el diseño y/o casos de prueba (flecha punteada “referencia”).
Esto deja claro que no hay backend/frontend/db: es procesamiento local.
Diagrama interno por subproyecto (nivel de detalle)
Objetivo: capturar cómo funciona cada script como sistema (aunque sea un solo archivo).
Como no vemos el contenido de los .py, tu diagrama debe reflejar la arquitectura típica de un autómata, y tú lo ajustas cuando revises el código:
• Módulo/Script (p.ej. automata.py)
• Definición del autómata:
• conjunto de estados Q
• alfabeto Σ
• estado inicial q0
• estados de aceptación F (si aplica)
• función de transición δ
• (Moore/Mealy) función de salida λ o salidas por transición/estado
• Motor de ejecución (runner):
• lee entrada (palabra/secuencia)
• itera símbolos/eventos
• actualiza estado vía δ
• produce salida (Mealy/Moore) o decide aceptación (DFA)
• I/O:
• entrada por consola/argumentos/variables
• salida por consola/archivo (si aplica)
En el de Automatacar, el “alfabeto” podría ser eventos (acelerar/frenar/encender/apagar/cambiar marcha), y la salida podría ser “estado del carro”.
Componentes comunes (para los 3)
• Actor: Usuario/Estudiante
• Entrada: Palabra / Secuencia de símbolos / Eventos
• Motor de Autómata: ejecuta transiciones
• Definición del Autómata: estados + transiciones (+ salida)
• Salida: aceptación/rechazo o secuencia de salida (Moore/Mealy) o “estado simulado”
• Documentación (PDF): especificación y pruebas
Patrones/diseño a resaltar (aunque sea un script)
Aunque esté en un solo archivo, el diagrama debe separar “responsabilidades” como si fueran módulos:
• “Declarativo” vs “Ejecutor”
• Declarativo: tablas/diccionarios de transición, estados, etc.
• Ejecutor: algoritmo que recorre la entrada.
• Máquina de estados finitos (FSM) como patrón central.
• Para Moore/Mealy: resalta explícitamente dónde se genera la salida:
• Moore: salida depende del estado (λ: Q → O)
• Mealy: salida depende de (estado, símbolo) (λ: Q×Σ → O)
Tecnologías relevantes
• Python como runtime.
• No hay señales de frameworks, BD, red, contenedores. Por lo tanto:
• Diagrama “simple”: ejecución local (Laptop/PC) + scripts.
Elementos obligatorios en el diagrama
• Etiquetas claras: usa el nombre real del archivo:
• “Automata-moore.py”
• “automata.py”
• “car.py”
• Flechas direccionales:
• Entrada → Motor → Salida
• PDFs → (flecha punteada) → Script (como referencia)
• Código de colores o formas (mantén una convención)
• Actor (persona): gris
• Scripts/Módulos: azul
• Datos/Entradas/Salidas: verde
• Documentación/PDF: amarillo
• Dependencias “no ejecutables” (PDF) con línea punteada
Qué tan “detallado” debe ser aquí
Como pediste “muy detallado” y “separar en tantos componentes como sea posible”, incluso si el código está en un solo .py:
• Divide el script en 4–6 cajas internas (Definición FSM, Parser Input, Runner, Output Formatter, Validaciones, etc.).
• Añade los artefactos PDF como nodos del sistema (aunque no se ejecuten).
Diagrama 1: Contexto del repositorio
• Nodo: “Repositorio: proyectos de autómatas (Python)”
• Subnodo A: “Automata moore-mealy / Automata-moore.py”
• Doc: (si existiera, si no, omitir)
• Subnodo B: “Automata1 / automata.py”
• Doc: “Pruebas de palabras V y NV.pdf”
• Subnodo C: “Automatacar / car.py”
• Doc: “Desarrollo de automata.pdf”
• Actor “Usuario/Estudiante” con flechas a cada script.
Diagrama 2: Interno (ejemplo para Automata1)
• Usuario → [Input: palabra] → [Parser/Validador] → [Motor DFA]
• [Motor DFA] ↔ [Definición δ, Q, Σ, q0, F]
• [Motor DFA] → [Decisión: accept/reject] → Usuario
• “Pruebas de palabras V y NV.pdf” → (punteado) → [Casos de prueba] / [Definición]
Repite una variante para Moore/Mealy:
• Añade caja “Generador de salida λ (Moore/Mealy)” conectada al motor.
Qué revisar en el código para “cerrar” la exactitud
Antes de finalizar el diagrama, abre cada .py y confirma:
• ¿Entrada por consola (input()), por argumentos (sys.argv/argparse), o hardcoded?
• ¿Transiciones como diccionario, matriz, o if/else?
• ¿Hay clases (p.ej. Automaton) o solo funciones?
• ¿Qué salidas produce exactamente (print de estados, salida de Mealy, aceptación final, etc.)?
Con esos detalles, ajustas nombres de cajas y flechas para que el diagrama sea literalmente fiel al proyecto.
Si me pegas el contenido de Automata-moore.py, automata.py y car.py, te puedo proponer el diagrama “final” con componentes exactos (nombres de funciones/clases, tipos de datos usados para δ/λ, y flujos reales de entrada/salida).