Seeding y Paquetes Faker y Django-seed¶

1. Introducción¶

El seeding es el proceso de llenar una base de datos con datos de prueba o datos iniciales necesarios para probar el sistema en un entorno de desarrollo o de pruebas. Este proceso es útil para verificar la funcionalidad de la aplicación, asegurándose de que todo esté trabajando correctamente con datos reales o realistas, pero sin la necesidad de ingresar manualmente estos datos.

En este tema, vamos a aprender cómo utilizar el seeding en Django para poblar nuestra base de datos con datos de prueba. Usaremos el paquete django-seed para generar datos aleatorios para nuestro blog, específicamente para poblar la app posts con entradas ficticias.

2. Instalación de Django-seed¶

Django-seed es una extensión de Django que facilita el proceso de poblar la base de datos con datos de prueba generados aleatoriamente, utilizando Faker para la generación de datos.

2.1 Instalación paso a paso¶

Primero, vamos a instalar el paquete django-seed. Abre la terminal y ejecuta los siguientes comandos:

# Instalar django-seed
pip install django-seed

Asegúrate de tener Faker instalado también, ya que es una dependencia de django-seed que se utiliza para generar datos aleatorios:

# Instalar Faker si no está instalado
pip install Faker

2.2 Añadir `django-seed` a las aplicaciones instaladas¶

Una vez instalado el paquete, debemos añadirlo a la lista de aplicaciones instaladas en el archivo settings.py de nuestro proyecto. Abre myBlog/settings.py y añade 'django_seed' a la lista.

# myBlog/settings.py
INSTALLED_APPS = [
    # ...
    'django_seed',
]

2.3 Verificar la instalación con `check`¶

Para asegurarnos de que la instalación fue correcta, ejecutamos el comando check de Django para comprobar que no haya problemas en la configuración:

python manage.py check

Si todo está bien, deberías ver un mensaje indicando que no hay errores.

3. Uso de Django-seed para Poblar la App `post`¶

En este paso, vamos a utilizar django-seed para generar 50 entradas de prueba en nuestra app posts. Para ello, no utilizaremos el panel de administración, sino que lo haremos directamente desde el shell de Django.

3.1 Generar datos con Django-seed¶

En primer lugar, vamos a importar el paquete django-seed y luego usarlo para poblar nuestra app posts. En la terminal, ejecuta el siguiente comando para entrar al shell interactivo de Django:

python manage.py seed posts --number=50

En este código, estamos generando 50 posts.

psycopg2 error

Si encuentras problemas con la librería psycopg2 (por ejemplo, si estás utilizando PostgreSQL), asegúrate de instalar psycopg2-binary con el siguiente comando:

pip install psycopg2-binary

Si con todo esto seguimos teniendo problemas, podemos generar estos datos mediante un script en Python. Tenéis un fichero insert_data.py en la carpeta resources que podéis utilizar para este propósito.

Una vez descargada hay que copiarla en la raíz del proyecto (donde está manage.py) y ejecutarla con:

python insert_data.py

EL resulutado debe ser:

50 autores insertados correctamente.
50 posts insertados correctamente.

La aplicación django-seed normalmente no da problemas, pero tiene múltiples dependencias y depende del entorno, del sistema operativo a veces da problemas. Si es así, utilizar el script.

3.2 Generación de Datos con Faker en un Script¶

Vamos a crear un script en Python que generará 50 autores y 50 posts asignados aleatoriamente a esos autores. Este script utilizará Faker para generar datos aleatorios realistas, como nombres, emails y textos.

Paso a Paso para Crear el Script¶

Crear el Script:
```
touch generate_data.py
```
o crear el fichero directamente en VSCode.
- El script generará 50 autores con un nombre y un email aleatorio.
- Luego generará 50 posts con un título, cuerpo de texto, puntuación aleatoria y los asignará a los autores generados.
- Utilizaremos Faker para generar datos aleatorios y Django ORM para interactuar con la base de datos.
Instalar Faker (si no está instalado):

Si no tienes Faker instalado, asegúrate de que esté en tu entorno virtual:
```
pip install Faker
```
Crear el Script en la Raíz del Proyecto:
- En la raíz de tu proyecto (donde se encuentra manage.py), crea un archivo llamado generate_data.py.
- El contenido de este script generará los datos y los insertará en la base de datos.

Código del Script (`generate_data.py`)¶

generate_data.py

import os
import django
from django.utils import timezone

# Configuración de Django
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "myBlog01.settings")  # Cambia 'myBlog' por el nombre de tu proyecto
django.setup()

from faker import Faker
from posts.models import Post, Author
import random

# Crear una instancia de Faker
fake = Faker()


# Generación de 50 autores
def create_authors(num=50):
    authors = []
    for _ in range(num):
        # Crear un nombre y email aleatorio
        author_name = fake.name()
        author_email = fake.email()

        # Crear un autor y agregarlo a la lista
        author = Author.objects.create(name=author_name, email=author_email)
        authors.append(author)
    return authors

# Generación de 50 posts
def create_posts(authors, num=50):
    for _ in range(num):
        # Seleccionar un autor aleatorio de la lista
        author = random.choice(authors)

        # Crear un título y cuerpo de texto aleatorio
        post_title = fake.sentence(nb_words=6)  # Título con 6 palabras
        post_body = fake.text(max_nb_chars=200)  # Cuerpo del post con máximo 200 caracteres
# Generar una fecha de publicación y convertirla a aware
        naive_date = fake.date_time_this_year()  # Esto genera una fecha naive
        aware_date = timezone.make_aware(naive_date)  # Convertirla a una fecha aware
        # Crear el post y asignarlo al autor
        Post.objects.create(
            headLine=post_title,
            bodyText=post_body,
            rating=random.randint(1, 5),  # Puntuación aleatoria entre 1 y 5
            publicDate = aware_date,
            author=author
        )

# Ejecutar las funciones +
if __name__ == "__main__":
    authors = create_authors()  # Crear 50 autores
    create_posts(authors)       # Crear 50 posts y asignarlos aleatoriamente a los autores

    print("50 autores y 50 posts creados exitosamente.")

Explicación del Script:¶

Configuración de Django: Al principio, configuramos Django para que el script interactúe con el proyecto, cargando los ajustes desde el archivo settings.py.
Generación de Autores: La función create_authors() crea 50 autores con un nombre y un email aleatorio usando Faker. Luego, esos autores se guardan en la base de datos.
Generación de Posts: La función create_posts() crea 50 posts. Cada post tiene un título aleatorio (generado con fake.sentence()) y un cuerpo de texto aleatorio (generado con fake.text()). La puntuación es un número aleatorio entre 1 y 5. Además, cada post se asigna a un autor aleatorio de la lista de autores previamente creada.
Ejecución del Script:
- Al ejecutar el script (python generate_data.py), se crearán 50 autores y 50 posts, y se asignarán aleatoriamente a los autores.
- El script imprime un mensaje de éxito cuando la tarea se completa.

3.3 Comprobar los Datos Generados¶

Después de ejecutar el script, puedes verificar que los datos se han insertado correctamente utilizando una herramienta de administración de bases de datos (como SQLite, pgAdmin o la extensión de SQLite en VSCode).

Abre tu base de datos y verifica que los 50 autores y los 50 posts han sido creados correctamente.

3.4 Ejecutar el Script¶

Para ejecutar el script y generar los datos de prueba:

Guarda el script como generate_data.py en la raíz de tu proyecto (junto a manage.py).
Asegúrate de tener el entorno virtual activado.
Ejecuta el script con el siguiente comando:
```
python generate_data.py
```
Verás el siguiente mensaje en la terminal:
```
50 autores y 50 posts creados exitosamente.
```
Claro, aquí te dejo una tabla con los métodos más utilizados de Faker y sus principales opciones. Esta tabla será muy útil para que los estudiantes comprendan cómo generar diferentes tipos de datos aleatorios y puedan personalizarlos según sus necesidades.

3.5. Tabla de Métodos y Opciones de Faker¶

Método	Descripción	Opciones / Parámetros	Ejemplo
`name()`	Genera un nombre completo aleatorio.	Ninguna	`fake.name()` → "John Doe"
`first_name()`	Genera solo el primer nombre aleatorio.	Ninguna	`fake.first_name()` → "John"
`last_name()`	Genera solo el apellido aleatorio.	Ninguna	`fake.last_name()` → "Doe"
`email()`	Genera una dirección de correo electrónico aleatoria.	Ninguna	`fake.email()` → "john.doe@example.com"
`address()`	Genera una dirección aleatoria.	Ninguna	`fake.address()` → "1234 Elm St, Springfield, IL 62704"
`phone_number()`	Genera un número de teléfono aleatorio.	Ninguna	`fake.phone_number()` → "(555) 123-4567"
`text()`	Genera un texto aleatorio (largo).	`max_nb_chars` (número máximo de caracteres)	`fake.text(max_nb_chars=200)` → "Lorem ipsum dolor sit amet..."
`sentence()`	Genera una oración aleatoria.	`nb_words` (número de palabras en la oración)	`fake.sentence(nb_words=6)` → "The quick brown fox jumps over."
`paragraph()`	Genera un párrafo aleatorio.	`nb_sentences` (número de oraciones), `ext` (extensión del texto)	`fake.paragraph(nb_sentences=3)` → "Lorem ipsum dolor sit amet..."
`date_time()`	Genera una fecha y hora aleatoria.	`start_date`, `end_date`, `tzinfo`	`fake.date_time()` → "2025-11-04 16:35:39"
`random_int()`	Genera un número entero aleatorio.	`min`, `max` (rango mínimo y máximo del número)	`fake.random_int(min=1, max=100)` → 42
`date_of_birth()`	Genera una fecha de nacimiento aleatoria.	`minimum_age`, `maximum_age` (edad mínima y máxima)	`fake.date_of_birth(minimum_age=18, maximum_age=80)` → "1985-06-13"
`uuid4()`	Genera un UUID (identificador único universal) aleatorio.	Ninguna	`fake.uuid4()` → "fae8a3d7-7d1e-4de2-93f6-9d7396d5d1a4"
`country()`	Genera un nombre de país aleatorio.	Ninguna	`fake.country()` → "United States"
`company()`	Genera un nombre de empresa aleatorio.	Ninguna	`fake.company()` → "Acme Corp"
`job()`	Genera un título de trabajo aleatorio.	Ninguna	`fake.job()` → "Software Engineer"
`boolean()`	Genera un valor booleano aleatorio (True o False).	`chance_of_getting_true` (probabilidad de obtener True)	`fake.boolean(chance_of_getting_true=70)` → `True`

3.6. Personalización adicional¶

Locales: Faker soporta múltiples locales, lo que significa que puede generar datos en diferentes idiomas y formatos de país. Puedes definir el locale al inicializar Faker:
```
fake = Faker('es_ES')  # Para generar datos en español (España)
```

Fechas y rangos: Faker permite definir rangos para las fechas y edades de manera sencilla:

fake.date_of_birth(minimum_age=18, maximum_age=80)  # Fecha de nacimiento con un rango de edad

3.7. Resumen de Faker¶

Faker es una herramienta poderosa para generar datos aleatorios realistas, ideal para pruebas.
Puedes personalizar los datos generados con parámetros como max_nb_chars, nb_words, y minimum_age.
Faker soporta locales para generar datos en diferentes idiomas y formatos de fecha.

4. Resumen¶

En este tema, hemos aprendido cómo utilizar el seeding en Django para poblar nuestra base de datos con datos de prueba utilizando el paquete django-seed. Hemos visto cómo:

Instalar django-seed y configurarlo en el proyecto.
Usar django-seed para generar 50 entradas de prueba para la app posts.
Comprobar que los datos fueron creados correctamente en la base de datos.

Este proceso es muy útil para generar datos de prueba rápidamente sin tener que ingresarlos manualmente.

5. Ejercicio Propuesto¶

5.1 Crear un Modelo `Comment`¶

Crea un nuevo modelo Comment con los siguientes campos:

author: Una clave foránea al modelo Author.
post: Una clave foránea al modelo Post.
content: Un campo de texto para el contenido del comentario.

Usa django-seed para poblar la tabla Comment con datos de prueba.

5.2 Poblar la Base de Datos con `Comment`¶

Genera 50 comentarios aleatorios para 50 posts diferentes y asigna un autor aleatorio de los ya creados. Verifica que los comentarios se han creado correctamente en la base de datos.