hola quiero hacer una aplicación para windows que me permita introducir datos de…
- User
hola quiero hacer una aplicación para windows que me permita introducir datos de personas como nombre apellidos fecha y lugar de nacimiento y me los guarde en una base de datos. Ademas me gustaría que guardara relaciones de parentesco como hijo o hija de, hermano, matrimonio con el objetivo de crear un árbol genealógico.
Assistant
¡Excelente idea! Crear una aplicación de árbol genealógico es un proyecto fascinante y muy gratificante. Para una aplicación de Windows, tenemos varias opciones robustas y adecuadas.
Aquí te presento una guía completa con las tecnologías recomendadas y los pasos a seguir:
Tecnologías Recomendadas
Para una aplicación de escritorio Windows que interactúe con una base de datos, las mejores opciones son:
-
Lenguaje de Programación: C#
- Es el lenguaje nativo y más potente para desarrollar aplicaciones en la plataforma Windows (.NET).
- Amplia comunidad, muchas librerías y herramientas (Visual Studio).
-
Framework de Interfaz de Usuario (UI):
- WPF (Windows Presentation Foundation): Es el framework moderno y recomendado para aplicaciones de escritorio en C#. Permite crear interfaces de usuario ricas y flexibles con XAML.
- (Alternativa más simple pero menos moderna): WinForms (Windows Forms) - Más rápido para empezar con interfaces básicas, pero menos flexible a largo plazo.
-
Base de Datos:
- SQLite: Es una base de datos embebida, ligera y basada en archivos. No requiere un servidor de base de datos separado, lo que la hace ideal para aplicaciones de escritorio que no necesitan ser multiusuario o acceder a datos remotos. Los datos se guardan en un único archivo (
.db). - (Alternativa más robusta): SQL Server LocalDB / Express - Si en el futuro piensas en una solución más grande o multiusuario, podrías considerar una base de datos SQL Server Express, pero para empezar, SQLite es más sencillo.
- SQLite: Es una base de datos embebida, ligera y basada en archivos. No requiere un servidor de base de datos separado, lo que la hace ideal para aplicaciones de escritorio que no necesitan ser multiusuario o acceder a datos remotos. Los datos se guardan en un único archivo (
-
ORM (Object-Relational Mapper):
- Entity Framework Core (EF Core): Es una excelente librería para C# que te permite interactuar con tu base de datos utilizando objetos C# en lugar de escribir sentencias SQL directamente. Simplifica enormemente la persistencia de datos.
Estructura de la Base de Datos (Modelo de Datos)
Necesitamos al menos dos tablas: una para las personas y otra para las relaciones.
1. Tabla
Personas(People)Almacenará los datos básicos de cada individuo.
Columna Tipo de Dato Descripción IdINTEGER (PK) Identificador único de la persona (clave primaria) NombreTEXT Nombre de la persona ApellidosTEXT Apellidos de la persona FechaNacimientoTEXT/DATE Fecha de nacimiento (ej: 'YYYY-MM-DD') LugarNacimientoTEXT Ciudad/País de nacimiento GeneroTEXT 'M' (masculino), 'F' (femenino) (opcional) NotasTEXT Cualquier nota adicional (opcional) 2. Tabla
Relaciones(Relationships)Esta tabla es crucial para construir el árbol. Almacenará la conexión entre dos personas y el tipo de relación.
Columna Tipo de Dato Descripción IdINTEGER (PK) Identificador único de la relación Persona1IdINTEGER (FK) ID de la primera persona involucrada en la relación (ej: el padre/madre) Persona2IdINTEGER (FK) ID de la segunda persona involucrada (ej: el hijo/hija) TipoRelacionTEXT Tipo de relación: 'Padre-Hijo', 'Cónyuge', 'Hermano' FechaInicioTEXT/DATE Fecha de inicio de la relación (ej: fecha de matrimonio) (opcional) FechaFinTEXT/DATE Fecha de fin de la relación (ej: fecha de divorcio/muerte) (opcional) Consideraciones para
TipoRelacion:- 'Padre-Hijo' (Parent-Child):
Persona1Ides el padre/madre,Persona2Ides el hijo/hija. - 'Cónyuge' (Spouse): La relación es bidireccional. Solo necesitas una entrada (ej: A es cónyuge de B).
- 'Hermano' (Sibling): Podrías no necesitar una entrada explícita si los hermanos se infieren a través de padres comunes, pero si quieres relaciones explícitas,
Persona1Ides el hermano,Persona2Ides el otro hermano.
Componentes Clave de la Aplicación
-
Interfaz de Usuario (UI):
- Ventana Principal: Mostrar una lista de todas las personas ingresadas. Botones para "Agregar Persona", "Editar Persona", "Eliminar Persona", "Agregar Relación", "Ver Árbol".
- Formulario "Agregar/Editar Persona": Controles para introducir Nombre, Apellidos, Fecha de Nacimiento (Date Picker), Lugar de Nacimiento. Botón "Guardar".
- Formulario "Agregar Relación":
- Dos selectores (combobox o autocompletar) para elegir
Persona1yPersona2. - Un selector (combobox) para el
TipoRelacion('Padre-Hijo', 'Cónyuge', 'Hermano'). - Un botón "Guardar".
- Dos selectores (combobox o autocompletar) para elegir
- Visualización del Árbol Genealógico: Esta es la parte más compleja visualmente. Inicialmente, puedes mostrarlo como una lista indentada. Para una representación gráfica real, necesitarás una librería de gráficos (hay algunas para WPF como QuickGraph o puedes dibujar nodos y líneas tú mismo).
-
Capa de Acceso a Datos (DAL - Data Access Layer):
- Clases C# que representan tus tablas de base de datos (
PersonyRelationship). - Una clase
DbContext(de Entity Framework Core) que manejará la conexión y las operaciones con la base de datos (CRUD: Crear, Leer, Actualizar, Eliminar). - Métodos para:
GetAllPeople()GetPersonById(id)AddPerson(person)UpdatePerson(person)DeletePerson(id)AddRelationship(relationship)GetRelationshipsForPerson(personId)GetChildrenOf(parentId)GetParentsOf(childId)GetSpouseOf(personId)GetSiblingsOf(personId)(requiere lógica más compleja, encontrando padres comunes)
- Clases C# que representan tus tablas de base de datos (
-
Lógica de Negocio:
- Validación de datos de entrada.
- Lógica para construir el árbol genealógico (ej: una función recursiva que explore las relaciones para construir la estructura).
Pasos Generales para Desarrollar la Aplicación
-
Configuración del Entorno:
- Instala Visual Studio Community Edition (es gratuito).
- Selecciona la carga de trabajo "Desarrollo de escritorio con .NET".
-
Crear Nuevo Proyecto:
- En Visual Studio, selecciona
Crear un proyecto. - Elige
Aplicación de WPF (.NET)(C#). - Asígnale un nombre (ej:
GenealogyApp).
- En Visual Studio, selecciona
-
Instalar Paquetes NuGet de Entity Framework Core (EF Core):
- Ve a
Herramientas->Administrador de paquetes NuGet->Administrar paquetes NuGet para la solución.... - En la pestaña "Examinar", busca e instala:
Microsoft.EntityFrameworkCore.SqliteMicrosoft.EntityFrameworkCore.Design(para las migraciones)Microsoft.EntityFrameworkCore.Proxies(opcional, para cargar datos relacionados automáticamente)
- Ve a
-
Definir Modelos de Datos (Clases C#): Crea una carpeta
Modelsy define tus clases:// Models/Person.cs public class Person { public int Id { get; set; } public string Name { get; set; } public string Surnames { get; set; } public DateTime DateOfBirth { get; set; } public string PlaceOfBirth { get; set; } public string Gender { get; set; } // M, F public string Notes { get; set; } // Propiedades de navegación para EF Core (opcional al inicio) public ICollection<Relationship> RelationshipsAsPerson1 { get; set; } public ICollection<Relationship> RelationshipsAsPerson2 { get; set; } } // Models/Relationship.cs public class Relationship { public int Id { get; set; } public int Person1Id { get; set; } public Person Person1 { get; set; } // Propiedad de navegación public int Person2Id { get; set; } public Person Person2 { get; set; } // Propiedad de navegación public string RelationshipType { get; set; } // "Parent-Child", "Spouse", "Sibling" public DateTime? StartDate { get; set; } // Nullable DateTime public DateTime? EndDate { get; set; } // Nullable DateTime } -
Crear el
DbContext: Crea una carpetaDatay añade tu clase de contexto:// Data/AppDbContext.cs using Microsoft.EntityFrameworkCore; public class AppDbContext : DbContext { public DbSet<Person> People { get; set; } public DbSet<Relationship> Relationships { get; set; } protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) { // La base de datos SQLite se guardará en el directorio de la aplicación optionsBuilder.UseSqlite("Data Source=genealogy.db"); // Para habilitar lazy loading, si instalaste Microsoft.EntityFrameworkCore.Proxies // optionsBuilder.UseLazyLoadingProxies(); } protected override void OnModelCreating(ModelBuilder modelBuilder) { // Configurar las relaciones para que EF Core las entienda modelBuilder.Entity<Relationship>() .HasOne(r => r.Person1) .WithMany(p => p.RelationshipsAsPerson1) .HasForeignKey(r => r.Person1Id) .OnDelete(DeleteBehavior.Restrict); // Evita borrado en cascada accidental modelBuilder.Entity<Relationship>() .HasOne(r => r.Person2) .WithMany(p => p.RelationshipsAsPerson2) .HasForeignKey(r => r.Person2Id) .OnDelete(DeleteBehavior.Restrict); // Evita borrado en cascada accidental // Asegúrate de que no haya relaciones duplicadas para Spouse // (esto es más complejo y podrías manejarlo en la lógica de negocio) // modelBuilder.Entity<Relationship>() // .HasIndex(r => new { r.Person1Id, r.Person2Id, r.RelationshipType }).IsUnique(); } } -
Crear Migraciones (para la Base de Datos):
- Abre la
Consola del Administrador de paquetes(Herramientas -> Administrador de paquetes NuGet -> Consola del Administrador de paquetes). - Ejecuta los siguientes comandos:
Add-Migration InitialCreate(Esto creará un archivo de migración con la estructura de tus tablas).Update-Database(Esto aplicará la migración y creará el archivogenealogy.dben tu proyecto).
- Abre la
-
Diseñar la Interfaz de Usuario (XAML):
- Abre
MainWindow.xamly empieza a añadir controles:DataGridpara la lista de personas,Buttons, etc. - Crea nuevas ventanas (
.xaml) para los formularios de "Agregar/Editar Persona" y "Agregar Relación".
- Abre
-
Implementar la Lógica C# (Code-Behind o MVVM):
- En el
Code-Behindde tus ventanas (.xaml.cs), usa tuAppDbContextpara interactuar con la base de datos.
// Ejemplo en MainWindow.xaml.cs (para cargar personas) public partial class MainWindow : Window { private AppDbContext _context; public MainWindow() { InitializeComponent(); _context = new AppDbContext(); LoadPeople(); } private void LoadPeople() { PersonDataGrid.ItemsSource = _context.People.ToList(); } private void AddPersonButton_Click(object sender, RoutedEventArgs e) { var addPersonWindow = new AddEditPersonWindow(); if (addPersonWindow.ShowDialog() == true) // ShowDialog returns true if saved { LoadPeople(); // Refresh the list } } // Similar logic for editing, deleting, adding relationships } // Ejemplo en AddEditPersonWindow.xaml.cs public partial class AddEditPersonWindow : Window { private AppDbContext _context; public Person CurrentPerson { get; set; } // Para editar public AddEditPersonWindow() { InitializeComponent(); _context = new AppDbContext(); CurrentPerson = new Person(); // Para agregar this.DataContext = CurrentPerson; // Bind to UI } public AddEditPersonWindow(Person personToEdit) : this() // Constructor para editar { CurrentPerson = personToEdit; this.DataContext = CurrentPerson; } private void SaveButton_Click(object sender, RoutedEventArgs e) { if (CurrentPerson.Id == 0) // New person { _context.People.Add(CurrentPerson); } else // Existing person { _context.People.Update(CurrentPerson); // Or just context.Entry(CurrentPerson).State = EntityState.Modified; } _context.SaveChanges(); this.DialogResult = true; // Indicate success this.Close(); } } - En el
Funcionalidades Clave a Desarrollar
- CRUD de Personas:
- Crear: Formulario para añadir nuevas personas.
- Leer: Mostrar todas las personas en un
DataGrid. - Actualizar: Cargar los datos de una persona seleccionada en el formulario de edición.
- Eliminar: Eliminar una persona (considera las relaciones antes de eliminar).
- CRUD de Relaciones:
- Crear: Formulario para definir relaciones entre dos personas existentes.
- Leer: Mostrar las relaciones de una persona seleccionada (ej. en una sección de detalles de la persona).
- Construcción del Árbol:
- Función para recorrer las relaciones y construir una estructura de datos que represente el árbol.
- Visualización Básica: Inicialmente, una vista de texto simple (ej. indentada) puede ser suficiente:
- Juan Pérez (1950) - Cónyuge: María García (1955) - Hijos: - Pedro Pérez (1980) - Cónyuge: Ana López (1982) - Hijos: - Laura Pérez (2010) - Carmen Pérez (1985) - Visualización Gráfica (Avanzado): Esto implica el uso de librerías de dibujo o gráficos para WPF para crear nodos (personas) y líneas (relaciones) que se puedan mover y organizar.
Consideraciones Adicionales y Funcionalidades Avanzadas
- Validación de Entrada: Asegúrate de que los datos ingresados sean válidos (ej. fechas correctas, campos obligatorios).
- Gestión de Errores: Implementa
try-catchblocks para manejar errores de base de datos o de usuario de forma elegante. - Refactorización (MVVM): A medida que la aplicación crezca, considera el patrón de diseño MVVM (Model-View-ViewModel). Esto separa la lógica de negocio de la UI, haciendo la aplicación más mantenible y testeable.
- Archivos GEDCOM: El estándar para intercambio de datos genealógicos es GEDCOM. Podrías implementar una funcionalidad de importación/exportación para que tu aplicación sea compatible con otras herramientas de genealogía.
- Imágenes y Documentos: Permitir adjuntar fotos o documentos a las personas.
- Búsqueda y Filtrado: Funcionalidad para buscar personas por nombre, apellidos, etc.
- Nodos Huérfanos: Manejar personas que no tienen relaciones definidas aún.
Este es un punto de partida muy sólido para tu proyecto. Empieza con las funcionalidades básicas (CRUD de personas y relaciones) y la visualización más simple, y luego ve añadiendo complejidad. ¡Mucha suerte con tu aplicación! Si tienes dudas en algún paso específico, no dudes en preguntar.
-
- User
se podría hacer en python? Me gustaría que la presentación del árbol fuera gráfica por pantalla
Assistant
¡Claro que sí! Es completamente posible y una excelente opción hacerlo en Python, especialmente con el requisito de la visualización gráfica del árbol. Python ofrece un ecosistema muy robusto para esto.
Aquí te detallo las tecnologías recomendadas y cómo abordar el proyecto en Python:
Tecnologías Recomendadas en Python
-
Lenguaje de Programación: Python
- Versátil, legible y con una enorme cantidad de librerías.
-
Interfaz de Usuario (UI): Tkinter
- Es la biblioteca estándar de Python para interfaces gráficas. Viene incluida con Python, lo que facilita la distribución de tu aplicación.
- Es relativamente sencillo de usar para aplicaciones de escritorio básicas a intermedias.
- (Alternativas más avanzadas pero con curva de aprendizaje mayor): PyQt/PySide (licencia dual, más potencia), Kivy (interfaces más modernas, táctiles). Para empezar, Tkinter es ideal.
-
Base de Datos: SQLite3
- Al igual que en C#, SQLite es la opción perfecta para una aplicación de escritorio local. Es una base de datos embebida, ligera y basada en archivos (
.db). Python tiene un módulosqlite3integrado para interactuar con ella.
- Al igual que en C#, SQLite es la opción perfecta para una aplicación de escritorio local. Es una base de datos embebida, ligera y basada en archivos (
-
Generación de Gráficos (Árbol Genealógico): Graphviz (con la librería
graphvizpara Python)- ¡Esta es la clave para la visualización gráfica! Graphviz no es una librería de Python en sí, sino una herramienta de software de código abierto diseñada para la visualización de gráficos. Python tiene una excelente envoltura (
wrapper) que te permite generar los gráficos programáticamente. - Graphviz es experto en la disposición automática de nodos y aristas, lo cual es crítico para un árbol genealógico que puede volverse complejo rápidamente.
- ¡Esta es la clave para la visualización gráfica! Graphviz no es una librería de Python en sí, sino una herramienta de software de código abierto diseñada para la visualización de gráficos. Python tiene una excelente envoltura (
-
Manejo de Imágenes en Tkinter: Pillow (PIL Fork)
- Necesitarás Pillow para cargar y mostrar imágenes (como las generadas por Graphviz) en las ventanas de Tkinter.
Estructura de la Base de Datos (MisMas Tablas)
Las tablas serán las mismas que las propuestas para C#, ya que el modelo de datos es independiente del lenguaje:
1. Tabla
PersonasColumna Tipo de Dato Descripción idINTEGER (PK) Identificador único de la persona nombreTEXT Nombre de la persona apellidosTEXT Apellidos de la persona fecha_nacimientoTEXT Fecha de nacimiento (ej: 'YYYY-MM-DD') lugar_nacimientoTEXT Ciudad/País de nacimiento generoTEXT 'M' (masculino), 'F' (femenino) (opcional) notasTEXT Cualquier nota adicional (opcional) 2. Tabla
RelacionesColumna Tipo de Dato Descripción idINTEGER (PK) Identificador único de la relación persona1_idINTEGER (FK) ID de la primera persona involucrada (ej: el padre/madre) persona2_idINTEGER (FK) ID de la segunda persona involucrada (ej: el hijo/hija) tipo_relacionTEXT Tipo de relación: 'Padre-Hijo', 'Conyuge', 'Hermano' fecha_inicioTEXT Fecha de inicio de la relación (ej: fecha de matrimonio) (opcional) fecha_finTEXT Fecha de fin de la relación (ej: fecha de divorcio/muerte) (opcional)
Componentes Clave de la Aplicación en Python
-
Módulo de Base de Datos (
database.py):- Funciones para conectarse a la base de datos SQLite.
- Funciones para crear las tablas si no existen.
- Funciones CRUD (Create, Read, Update, Delete) para
Personas:agregar_persona(),obtener_personas(),actualizar_persona(),eliminar_persona(). - Funciones CRUD para
Relaciones:agregar_relacion(),obtener_relaciones(),eliminar_relacion().
-
Módulo de Visualización del Árbol (
tree_visualizer.py):- Una función principal que toma los datos de personas y relaciones de la base de datos.
- Utiliza la librería
graphvizpara construir el grafo (nodos y aristas). - Define cómo se verán los nodos (formas, colores, texto).
- Define cómo se verán las aristas (flechas, colores).
- Muy importante para el árbol: Graphviz es excelente para esto. Puedes definir que las relaciones de "Padre-Hijo" sean aristas dirigidas de arriba a abajo. Para los cónyuges, puedes unirlos con una arista sin dirección o incluso crear un nodo invisible que represente el matrimonio y conectar a los hijos a ese nodo matrimonial.
- Genera una imagen del grafo (ej:
.png,.svg).
-
Módulo de Interfaz de Usuario (
main_app.pyogui.py):- Ventana principal con una lista de personas (ej.
ttk.Treeview). - Botones para "Agregar Persona", "Editar Persona", "Eliminar Persona", "Agregar Relación", "Ver Árbol Genealógico".
- Ventanas de diálogo o formularios para la entrada/edición de datos de personas y relaciones.
- Un área donde se mostrará la imagen generada por Graphviz (un
tk.Canvasotk.LabelconPillow).
- Ventana principal con una lista de personas (ej.
Pasos Generales para Desarrollar la Aplicación en Python
-
Configuración del Entorno:
- Asegúrate de tener Python instalado (versión 3.x).
- Instala las librerías necesarias:
pip install graphviz pillow - ¡MUY IMPORTANTE! Instala Graphviz (la herramienta externa) en tu sistema operativo.
- Para Windows, descarga el instalador
.msidesde Graphviz Downloads. Durante la instalación, asegúrate de marcar la opción para añadir Graphviz al PATH del sistema, o añádelo manualmente después. Esto es crucial para que la libreríagraphvizde Python pueda llamar a la herramienta.
- Para Windows, descarga el instalador
-
Crear la Base de Datos (
database.py):import sqlite3 from datetime import datetime DB_NAME = 'genealogy.db' def connect_db(): conn = sqlite3.connect(DB_NAME) conn.row_factory = sqlite3.Row # Para acceder a las columnas por nombre return conn def create_tables(): conn = connect_db() cursor = conn.cursor() cursor.execute(''' CREATE TABLE IF NOT EXISTS personas ( id INTEGER PRIMARY KEY AUTOINCREMENT, nombre TEXT NOT NULL, apellidos TEXT NOT NULL, fecha_nacimiento TEXT, lugar_nacimiento TEXT, genero TEXT, notas TEXT ) ''') cursor.execute(''' CREATE TABLE IF NOT EXISTS relaciones ( id INTEGER PRIMARY KEY AUTOINCREMENT, persona1_id INTEGER NOT NULL, persona2_id INTEGER NOT NULL, tipo_relacion TEXT NOT NULL, fecha_inicio TEXT, fecha_fin TEXT, FOREIGN KEY (persona1_id) REFERENCES personas(id) ON DELETE CASCADE, FOREIGN KEY (persona2_id) REFERENCES personas(id) ON DELETE CASCADE ) ''') conn.commit() conn.close() def add_person(nombre, apellidos, fecha_nacimiento, lugar_nacimiento, genero=None, notas=None): conn = connect_db() cursor = conn.cursor() cursor.execute(''' INSERT INTO personas (nombre, apellidos, fecha_nacimiento, lugar_nacimiento, genero, notas) VALUES (?, ?, ?, ?, ?, ?) ''', (nombre, apellidos, fecha_nacimiento, lugar_nacimiento, genero, notas)) conn.commit() person_id = cursor.lastrowid conn.close() return person_id def get_all_people(): conn = connect_db() cursor = conn.cursor() cursor.execute('SELECT * FROM personas ORDER BY apellidos, nombre') people = cursor.fetchall() conn.close() return people def get_person_by_id(person_id): conn = connect_db() cursor = conn.cursor() cursor.execute('SELECT * FROM personas WHERE id = ?', (person_id,)) person = cursor.fetchone() conn.close() return person def update_person(person_id, nombre, apellidos, fecha_nacimiento, lugar_nacimiento, genero=None, notas=None): conn = connect_db() cursor = conn.cursor() cursor.execute(''' UPDATE personas SET nombre = ?, apellidos = ?, fecha_nacimiento = ?, lugar_nacimiento = ?, genero = ?, notas = ? WHERE id = ? ''', (nombre, apellidos, fecha_nacimiento, lugar_nacimiento, genero, notas, person_id)) conn.commit() conn.close() def delete_person(person_id): conn = connect_db() cursor = conn.cursor() cursor.execute('DELETE FROM personas WHERE id = ?', (person_id,)) conn.commit() conn.close() def add_relationship(persona1_id, persona2_id, tipo_relacion, fecha_inicio=None, fecha_fin=None): conn = connect_db() cursor = conn.cursor() cursor.execute(''' INSERT INTO relaciones (persona1_id, persona2_id, tipo_relacion, fecha_inicio, fecha_fin) VALUES (?, ?, ?, ?, ?) ''', (persona1_id, persona2_id, tipo_relacion, fecha_inicio, fecha_fin)) conn.commit() conn.close() def get_relationships(): conn = connect_db() cursor = conn.cursor() cursor.execute('SELECT * FROM relaciones') relationships = cursor.fetchall() conn.close() return relationships def get_relationships_for_person(person_id): conn = connect_db() cursor = conn.cursor() cursor.execute(''' SELECT * FROM relaciones WHERE persona1_id = ? OR persona2_id = ? ''', (person_id, person_id)) relationships = cursor.fetchall() conn.close() return relationships def delete_relationship(relationship_id): conn = connect_db() cursor = conn.cursor() cursor.execute('DELETE FROM relaciones WHERE id = ?', (relationship_id,)) conn.commit() conn.close() # Call this once at the start of your application # create_tables() -
Diseñar la Lógica del Árbol y la Visualización (
tree_visualizer.py):import graphviz import database # Asegúrate de que database.py esté en la misma carpeta def generate_family_tree_image(output_filename="family_tree.png"): dot = graphviz.Digraph(comment='Árbol Genealógico', graph_attr={'rankdir': 'TB', 'splines': 'ortho'}) # rankdir='TB' para de arriba a abajo, 'LR' para de izquierda a derecha. # splines='ortho' para líneas rectas, 'curved' para curvadas. people = database.get_all_people() relationships = database.get_relationships() # Añadir nodos de personas for person in people: label = f"{person['nombre']} {person['apellidos']}\n({person['fecha_nacimiento'] or 'N/A'})" dot.node(str(person['id']), label, shape='box', style='filled', fillcolor='lightblue') # Añadir relaciones # Para relaciones Padre-Hijo, se usa un subgrafo para agrupar padres y sus hijos # Para cónyuges, crearemos un "nodo de matrimonio" invisible # Mapeo de IDs de personas a sus datos people_map = {p['id']: p for p in people} # Para manejar matrimonios y sus hijos marriages = {} # Key: tuple of sorted (person1_id, person2_id), Value: marriage_node_id for rel in relationships: p1_id = rel['persona1_id'] p2_id = rel['persona2_id'] rel_type = rel['tipo_relacion'] if rel_type == 'Padre-Hijo': # Intentamos conectar a través de un nodo de matrimonio si existe parent = people_map.get(p1_id) child = people_map.get(p2_id) if parent and child: # Buscar si el padre tiene un cónyuge en una relación de matrimonio # Esto es más complejo: habría que iterar las relaciones de cónyuge # y si hay un matrimonio, conectar al hijo a ese nodo de matrimonio. # Por simplicidad inicial, conectaremos directamente padre a hijo. dot.edge(str(p1_id), str(p2_id), label='hijo/a de', dir='forward') elif rel_type == 'Conyuge': # Crear un nodo invisible de "matrimonio" para agrupar cónyuges y sus hijos # Esto es una forma común de representar matrimonios en árboles genealógicos sorted_ids = tuple(sorted((p1_id, p2_id))) if sorted_ids not in marriages: marriage_node_id = f"m_{p1_id}_{p2_id}" dot.node(marriage_node_id, "", shape='point', width='0.01', height='0.01', style='invis') # Nodo invisible marriages[sorted_ids] = marriage_node_id # Conectar a los cónyuges al nodo invisible de matrimonio dot.edge(str(p1_id), marriage_node_id, dir='none', style='solid', color='black', penwidth='2') dot.edge(str(p2_id), marriage_node_id, dir='none', style='solid', color='black', penwidth='2') # Conectar hijos a los nodos de matrimonio si aplica, o directamente a padres si no hay matrimonio for rel in relationships: p1_id = rel['persona1_id'] p2_id = rel['persona2_id'] rel_type = rel['tipo_relacion'] if rel_type == 'Padre-Hijo': parent_of_child = p1_id # El padre que está explícito en la relación Padre-Hijo # Buscar si el padre tiene un cónyuge y un nodo de matrimonio found_marriage_node = None for m_ids, m_node in marriages.items(): if parent_of_child in m_ids: # Si el padre está en este matrimonio # Asegúrate de que el otro cónyuge también existe para este matrimonio other_spouse_id = m_ids[0] if m_ids[1] == parent_of_child else m_ids[1] if other_spouse_id in people_map: # Asegurarse que el otro cónyuge es válido found_marriage_node = m_node break if found_marriage_node: dot.edge(found_marriage_node, str(p2_id), dir='forward', label='hijo/a', style='solid', color='darkgreen') else: # Si no hay nodo de matrimonio para este padre, conectar directamente dot.edge(str(p1_id), str(p2_id), dir='forward', label='hijo/a', style='dashed', color='grey') elif rel_type == 'Hermano': # Las relaciones de hermanos son más complejas de visualizar directamente. # Una forma es no dibujarlas explícitamente y dejar que la estructura # de "Padre-Hijo" y "Cónyuge" las implique. # Si quieres dibujarlas, necesitarías una lógica para encontrar el padre común # y dibujar una arista horizontal si tienen el mismo padre, o crear un subgrafo # para hermanos. Por simplicidad, podríamos omitirla en el gráfico inicial # o solo mostrarla en la información de la persona. pass try: dot.render(output_filename, view=False, cleanup=True, format='png') print(f"Árbol genealógico generado en {output_filename}") return output_filename except Exception as e: print(f"Error al generar el árbol: {e}. Asegúrate de que Graphviz esté instalado y en tu PATH.") return None # Ejemplo de uso: # generate_family_tree_image()Nota sobre la visualización de Graphviz: La clave para un árbol genealógico es la forma en que conectas los nodos. La técnica del "nodo de matrimonio" invisible es muy común para agrupar a los cónyuges y sus hijos, haciendo el diseño más claro.
-
Crear la Interfaz Gráfica con Tkinter (
main_app.py):import tkinter as tk from tkinter import messagebox, ttk, filedialog from PIL import Image, ImageTk # pip install Pillow import database # Nuestro módulo database.py import tree_visualizer # Nuestro módulo tree_visualizer.py import os class GenealogyApp: def __init__(self, master): self.master = master master.title("Aplicación de Árbol Genealógico") master.geometry("1000x700") database.create_tables() # Asegúrate de que las tablas existan self.create_widgets() self.load_people_to_treeview() def create_widgets(self): # Frame principal para la lista de personas people_frame = ttk.LabelFrame(self.master, text="Personas") people_frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=10, pady=10) self.people_tree = ttk.Treeview(people_frame, columns=("ID", "Nombre", "Apellidos", "Nacimiento", "Lugar"), show="headings") self.people_tree.heading("ID", text="ID") self.people_tree.heading("Nombre", text="Nombre") self.people_tree.heading("Apellidos", text="Apellidos") self.people_tree.heading("Nacimiento", text="Fecha Nac.") self.people_tree.heading("Lugar", text="Lugar Nac.") self.people_tree.column("ID", width=50, stretch=tk.NO) self.people_tree.column("Nombre", width=150) self.people_tree.column("Apellidos", width=150) self.people_tree.column("Nacimiento", width=100) self.people_tree.column("Lugar", width=150) self.people_tree.pack(side=tk.TOP, fill=tk.BOTH, expand=True) # Scrollbar para el treeview vsb = ttk.Scrollbar(people_frame, orient="vertical", command=self.people_tree.yview) vsb.pack(side=tk.RIGHT, fill="y") self.people_tree.configure(yscrollcommand=vsb.set) # Botones para personas button_frame = ttk.Frame(people_frame) button_frame.pack(pady=5) ttk.Button(button_frame, text="Agregar Persona", command=self.add_person_dialog).pack(side=tk.LEFT, padx=5) ttk.Button(button_frame, text="Editar Persona", command=self.edit_person_dialog).pack(side=tk.LEFT, padx=5) ttk.Button(button_frame, text="Eliminar Persona", command=self.delete_person).pack(side=tk.LEFT, padx=5) ttk.Button(button_frame, text="Agregar Relación", command=self.add_relationship_dialog).pack(side=tk.LEFT, padx=5) # Frame para la visualización del árbol tree_frame = ttk.LabelFrame(self.master, text="Árbol Genealógico") tree_frame.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True, padx=10, pady=10) self.tree_canvas = tk.Canvas(tree_frame, bg="white", scrollregion=(0,0,1000,1000)) # Ajustar scrollregion dinámicamente self.tree_canvas.pack(side=tk.TOP, fill=tk.BOTH, expand=True) self.tree_canvas_xscroll = ttk.Scrollbar(tree_frame, orient="horizontal", command=self.tree_canvas.xview) self.tree_canvas_xscroll.pack(side=tk.BOTTOM, fill="x") self.tree_canvas_yscroll = ttk.Scrollbar(tree_frame, orient="vertical", command=self.tree_canvas.yview) self.tree_canvas_yscroll.pack(side=tk.RIGHT, fill="y") self.tree_canvas.config(xscrollcommand=self.tree_canvas_xscroll.set, yscrollcommand=self.tree_canvas_yscroll.set) ttk.Button(tree_frame, text="Generar y Ver Árbol", command=self.show_family_tree).pack(pady=5) def load_people_to_treeview(self): for i in self.people_tree.get_children(): self.people_tree.delete(i) people = database.get_all_people() for person in people: self.people_tree.insert("", "end", values=(person['id'], person['nombre'], person['apellidos'], person['fecha_nacimiento'], person['lugar_nacimiento'])) def add_person_dialog(self): dialog = PersonDialog(self.master) self.master.wait_window(dialog.top) self.load_people_to_treeview() def edit_person_dialog(self): selected_item = self.people_tree.focus() if not selected_item: messagebox.showwarning("Editar Persona", "Por favor, selecciona una persona para editar.") return person_id = self.people_tree.item(selected_item, 'values')[0] person_data = database.get_person_by_id(person_id) dialog = PersonDialog(self.master, person_data) self.master.wait_window(dialog.top) self.load_people_to_treeview() def delete_person(self): selected_item = self.people_tree.focus() if not selected_item: messagebox.showwarning("Eliminar Persona", "Por favor, selecciona una persona para eliminar.") return person_id = self.people_tree.item(selected_item, 'values')[0] person_name = self.people_tree.item(selected_item, 'values')[1] if messagebox.askyesno("Eliminar Persona", f"¿Estás seguro de que quieres eliminar a {person_name} (ID: {person_id})? Esto también eliminará sus relaciones."): try: database.delete_person(person_id) messagebox.showinfo("Éxito", f"Persona {person_name} eliminada.") self.load_people_to_treeview() self.show_family_tree() # Refrescar árbol except Exception as e: messagebox.showerror("Error", f"No se pudo eliminar la persona: {e}") def add_relationship_dialog(self): dialog = RelationshipDialog(self.master) self.master.wait_window(dialog.top) self.show_family_tree() # Refrescar árbol def show_family_tree(self): image_path = "family_tree.png" generated_path = tree_visualizer.generate_family_tree_image(image_path) if generated_path and os.path.exists(generated_path): try: img = Image.open(generated_path) self.photo = ImageTk.PhotoImage(img) # Mantener una referencia para evitar que se borre self.tree_canvas.delete("all") # Limpiar canvas self.tree_canvas.create_image(0, 0, image=self.photo, anchor="nw") self.tree_canvas.config(scrollregion=self.tree_canvas.bbox(tk.ALL)) except Exception as e: messagebox.showerror("Error de Imagen", f"No se pudo cargar la imagen del árbol: {e}") else: messagebox.showwarning("Árbol Genealógico", "No se pudo generar la imagen del árbol o el archivo no existe.") class PersonDialog: def __init__(self, parent, person_data=None): self.top = tk.Toplevel(parent) self.top.title("Agregar/Editar Persona") self.top.grab_set() # Hacer que la ventana sea modal self.person_data = person_data labels = ["Nombre:", "Apellidos:", "Fecha de Nacimiento (YYYY-MM-DD):", "Lugar de Nacimiento:", "Género (M/F):", "Notas:"] self.entries = {} for i, text in enumerate(labels): ttk.Label(self.top, text=text).grid(row=i, column=0, padx=5, pady=5, sticky="w") entry = ttk.Entry(self.top) entry.grid(row=i, column=1, padx=5, pady=5, sticky="ew") self.entries[text.split('(')[0].strip().replace(':', '').replace(' ', '_').lower()] = entry # Cargar datos si estamos editando if self.person_data: self.top.title("Editar Persona") self.entries['nombre'].insert(0, self.person_data['nombre']) self.entries['apellidos'].insert(0, self.person_data['apellidos']) self.entries['fecha_de_nacimiento'].insert(0, self.person_data['fecha_nacimiento'] or "") self.entries['lugar_de_nacimiento'].insert(0, self.person_data['lugar_nacimiento'] or "") self.entries['genero'].insert(0, self.person_data['genero'] or "") self.entries['notas'].insert(0, self.person_data['notas'] or "") ttk.Button(self.top, text="Guardar", command=self.save_person).grid(row=len(labels), column=0, columnspan=2, pady=10) def save_person(self): nombre = self.entries['nombre'].get().strip() apellidos = self.entries['apellidos'].get().strip() fecha_nacimiento = self.entries['fecha_de_nacimiento'].get().strip() lugar_nacimiento = self.entries['lugar_de_nacimiento'].get().strip() genero = self.entries['genero'].get().strip() notas = self.entries['notas'].get().strip() if not nombre or not apellidos: messagebox.showerror("Error", "El nombre y los apellidos son obligatorios.") return try: if self.person_data: # Editar database.update_person(self.person_data['id'], nombre, apellidos, fecha_nacimiento, lugar_nacimiento, genero, notas) messagebox.showinfo("Éxito", "Persona actualizada correctamente.") else: # Agregar database.add_person(nombre, apellidos, fecha_nacimiento, lugar_nacimiento, genero, notas) messagebox.showinfo("Éxito", "Persona agregada correctamente.") self.top.destroy() except Exception as e: messagebox.showerror("Error de Base de Datos", f"Ocurrió un error al guardar: {e}") class RelationshipDialog: def __init__(self, parent): self.top = tk.Toplevel(parent) self.top.title("Agregar Relación") self.top.grab_set() self.people_data = database.get_all_people() people_names = [f"{p['nombre']} {p['apellidos']} (ID: {p['id']})" for p in self.people_data] self.people_id_map = {f"{p['nombre']} {p['apellidos']} (ID: {p['id']})": p['id'] for p in self.people_data} ttk.Label(self.top, text="Persona 1:").grid(row=0, column=0, padx=5, pady=5, sticky="w") self.person1_cb = ttk.Combobox(self.top, values=people_names, state="readonly") self.person1_cb.grid(row=0, column=1, padx=5, pady=5, sticky="ew") ttk.Label(self.top, text="Tipo de Relación:").grid(row=1, column=0, padx=5, pady=5, sticky="w") self.rel_type_cb = ttk.Combobox(self.top, values=["Padre-Hijo", "Conyuge", "Hermano"], state="readonly") self.rel_type_cb.grid(row=1, column=1, padx=5, pady=5, sticky="ew") ttk.Label(self.top, text="Persona 2:").grid(row=2, column=0, padx=5, pady=5, sticky="w") self.person2_cb = ttk.Combobox(self.top, values=people_names, state="readonly") self.person2_cb.grid(row=2, column=1, padx=5, pady=5, sticky="ew") ttk.Label(self.top, text="Fecha Inicio (YYYY-MM-DD):").grid(row=3, column=0, padx=5, pady=5, sticky="w") self.start_date_entry = ttk.Entry(self.top) self.start_date_entry.grid(row=3, column=1, padx=5, pady=5, sticky="ew") ttk.Label(self.top, text="Fecha Fin (YYYY-MM-DD):").grid(row=4, column=0, padx=5, pady=5, sticky="w") self.end_date_entry = ttk.Entry(self.top) self.end_date_entry.grid(row=4, column=1, padx=5, pady=5, sticky="ew") ttk.Button(self.top, text="Guardar Relación", command=self.save_relationship).grid(row=5, column=0, columnspan=2, pady=10) def save_relationship(self): person1_name = self.person1_cb.get() person2_name = self.person2_cb.get() rel_type = self.rel_type_cb.get() start_date = self.start_date_entry.get().strip() or None end_date = self.end_date_entry.get().strip() or None if not person1_name or not person2_name or not rel_type: messagebox.showerror("Error", "Todos los campos de persona y tipo de relación son obligatorios.") return person1_id = self.people_id_map.get(person1_name) person2_id = self.people_id_map.get(person2_name) if person1_id == person2_id: messagebox.showerror("Error", "Las personas involucradas en la relación no pueden ser la misma.") return try: database.add_relationship(person1_id, person2_id, rel_type, start_date, end_date) messagebox.showinfo("Éxito", "Relación agregada correctamente.") self.top.destroy() except Exception as e: messagebox.showerror("Error de Base de Datos", f"Ocurrió un error al guardar la relación: {e}") if __name__ == "__main__": root = tk.Tk() app = GenealogyApp(root) root.mainloop()
Cómo Ejecutar y Probar
- Guarda los tres bloques de código como
database.py,tree_visualizer.pyymain_app.pyen la misma carpeta. - Asegúrate de haber instalado Graphviz en tu sistema y la librería
graphvizypillowconpip. - Abre una terminal en esa carpeta y ejecuta:
python main_app.py
Verás la ventana principal de la aplicación. Podrás agregar personas, luego agregar relaciones entre ellas. Cuando hagas clic en "Generar y Ver Árbol", la aplicación creará un archivo
family_tree.pngy lo mostrará en el panel derecho.
Consideraciones y Mejoras Adicionales
- Validación de Fechas: Las entradas de fecha deberían tener una validación más robusta para asegurar el formato
YYYY-MM-DD. Podrías usar un widget de calendario si quieres algo más avanzado. - Manejo de Errores: Añade más bloques
try-exceptpara capturar errores de usuario (ej. intentar eliminar una persona que tiene relaciones clave). - Optimización del Árbol: Para árboles muy grandes, la generación de la imagen podría ser lenta. Podrías optimizar cómo se extraen los datos o cómo se renderiza el grafo.
- Interacción con el Árbol: Actualmente, el árbol es una imagen estática. Si quisieras interactividad (hacer clic en una persona en el árbol para ver sus detalles), necesitarías una librería de gráficos más interactiva (como
vis.jssi fuera una app web, o dibujar directamente en un canvas de Tkinter, lo cual es mucho más complejo que usar Graphviz). - GEDCOM: El estándar para intercambio de datos genealógicos es GEDCOM. Podrías añadir funciones de importación/exportación GEDCOM para hacer tu aplicación compatible con otras.
- Diseño de UI: Tkinter puede parecer un poco anticuado. Puedes usar
ttk(Themed Tkinter) para darle un aspecto más moderno, como hice en los ejemplos. Para diseños más complejos, podrías explorarCustomTkintero pasar a PyQt/PySide si el aspecto visual se vuelve una prioridad mayor.
¡Este es un proyecto fantástico y este punto de partida te dará una aplicación funcional! ¡Mucha suerte!
-
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.