Building out our tool Creating the API

In this project we generated a large set of fake CSV data with help from a local LLM, imported it into a SQLite database, and built a small REST API in Python (FastAPI) that can either query the DB or generate fake data on demand. This guide shows the core files, minimal DB helper, simple generators (no external Faker dependency), and how to run and test the service.

CSV sample

A short excerpt of the CSV we imported into SQLite (the full file is in the project):

Kara,Jordan,kara.jordan@example.com,28,Dallas,Lawyer
Leo,Nguyen,leo.nguyen@example.com,33,Athens,Teacher
Mia,Thomas,mia.thomas@example.com,30,Syracuse,Journalist
Nina,Harris,nina.harris@example.com,40,Buffalo,Psychologist
Oliver,Garcia,oliver.garcia@example.com,36,Raleigh,Electrician
Paula,Kim,paula.kim@example.com,32,Charlotte,Web Developer
Quinn,Walker,quinn.walker@example.com,29,Denver,Social Worker
Rachel,Perez,rachel.perez@example.com,27,Tucson,Research Scientist
Samuel,Gonzalez,samuel.gonzalez@example.com,44,Minneapolis,Business Consultant
Tina,Martinez,tina.martinez@example.com,30,Kansas City,Physician Assistant
Uma,Lopez,uma.lopez@example.com,31,Oklahoma City,Real Estate Agent
Victor,Rivera,victor.rivera@example.com,37,Cleveland,Dentist
Wendy,Patel,wendy.patel@example.com,28,Salt Lake City,Hospitality Manager
Xavier,Wong,xavier.wong@example.com,39,Fort Worth,Insurance Broker
Yara,Lee,yara.lee@example.com,25,Milwaukee,Automotive Engineer
Alice,Johnson,alice.johnson@example.com,28,San Francisco,Software Developer
Bob,Smith,bob.smith@example.com,34,Austin,Systems Analyst
Charlie,Brown,charlie.brown@example.com,45,New York,Graphic Designer
Diana,Garcia,diana.garcia@example.com,29,Dallas,Marketing Manager
Ethan,Lee,ethan.lee@example.com,31,Miami,Sales Representative
Fiona,Taylor,fiona.taylor@example.com,27,Houston,Business Analyst
George,Jones,george.jones@example.com,40,Seattle,Project Manager
Hannah,Williams,hannah.williams@example.com,22,Boston,Data Scientist

We imported this CSV into a table named fake_data inside a SQLite file named fakeData.db. After creating the DB and importing the CSV, the database UI looked like this:

A dark-mode screenshot of DB Browser for SQLite displaying a table named "fake_data" with columns like first_name, last_name, email_address, age, city, and occupation populated with sample rows. The right pane shows an editor for the selected cell (an email address).

With fakeData.db saved and verified, the next step is building a small API that can either query the fake_data table or generate additional fake records on demand.

Quick DB helper (SQLAlchemy)

We use SQLAlchemy to obtain DB sessions inside FastAPI routes. Create a simple DB helper that exposes a get_db dependency for route injection:

# db/database.py
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

DATABASE_URL = "sqlite:///./fakeData.db"  # update path if needed

engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False})
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

Base = declarative_base()

def get_db():
    """
    FastAPI dependency that yields a DB session and closes it afterwards.
    """
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

Use get_db() in endpoints that need to query the fake_data table (example wiring is listed in “Next steps” below).

Choosing a Python web framework

FastAPI was selected for this project due to its performance, developer ergonomics, and automatic OpenAPI docs. Flask and Django are valid alternatives depending on project needs:

Framework	Use case
FastAPI	High-performance APIs, automatic documentation, async support
Flask	Lightweight microservices and simple endpoints
Django	Full-featured applications with built-in ORM and admin UI

An annotated comparison screenshot used during exploration:

A dark-themed screenshot showing a comparison list of web frameworks (FastAPI and Flask) with bullet-pointed pros and cons. A white mouse cursor is visible over the text.

Project scaffold

A minimal project layout used for this example:

fastapi-project
├── src
│   ├── api
│   │   ├── __init__.py
│   │   └── endpoints
│   │       └── router.py
│   ├── core
│   ├── db
│   │   └── database.py
│   ├── models
│   │   └── fake_data_request.py
│   ├── services
│   └── main.py
├── requirements.txt
└── README.md

main.py — start the FastAPI app

A minimal main.py that mounts the router and runs via Uvicorn:

# main.py
from fastapi import FastAPI
from api.endpoints.router import router

app = FastAPI()

app.include_router(router)

@app.get("/")
def read_root():
    return {"message": "Welcome to the FastAPI application!"}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

If FastAPI or Uvicorn are not installed, running python main.py will raise an import error:

(.venv) $ python main.py
Traceback (most recent call last):
  File "main.py", line 1, in <module>
    from fastapi import FastAPI
ModuleNotFoundError: No module named 'fastapi'

Install the runtime dependencies:

pip install fastapi uvicorn

When the app starts successfully you’ll see logs like:

INFO:     Started server process [83597]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)
INFO:     127.0.0.1:61992 - "GET / HTTP/1.1" 200 OK

Request model (Pydantic)

Use a Pydantic model to validate incoming POST requests for fake-data generation:

# src/models/fake_data_request.py
from pydantic import BaseModel
from typing import Optional

class FakeDataRequest(BaseModel):
    """
    Request model for fake data generation.

    Attributes:
        data_type (str): Type of fake data to generate (e.g., "name", "email", "phone")
        count (int): Number of records to generate
        locale (str, optional): Locale for data generation (not used in our generators)
    """
    data_type: str
    count: int
    locale: Optional[str] = "en_US"

Pydantic provides automatic validation and descriptive errors for missing/invalid fields.

Router and generating fake data (no third-party Faker)

To keep dependencies minimal, this project uses simple Python-based generators rather than the external faker library. The API exposes a POST endpoint /getfakedata which maps data_type to a generator function:

# src/api/endpoints/router.py
from fastapi import APIRouter, HTTPException
from api.models.fake_data_request import FakeDataRequest
import random
import string

router = APIRouter()

def generate_random_name() -> str:
    first_names = ["John", "Jane", "Michael", "Sarah", "David", "Lisa"]
    last_names = ["Smith", "Johnson", "Williams", "Brown", "Jones", "Garcia"]
    return f"{random.choice(first_names)} {random.choice(last_names)}"

def generate_random_email() -> str:
    domains = ["gmail.com", "yahoo.com", "hotmail.com", "example.com"]
    username = ''.join(random.choices(string.ascii_lowercase, k=8))
    return f"{username}@{random.choice(domains)}"

def generate_random_phone() -> str:
    area_code = random.randint(100, 999)
    prefix = random.randint(100, 999)
    line = random.randint(1000, 9999)
    return f"{area_code}-{prefix}-{line}"

DATA_GENERATORS = {
    "name": generate_random_name,
    "email": generate_random_email,
    "phone": generate_random_phone
}

@router.get("/")
async def read_root():
    """Root endpoint that returns a welcome message."""
    return {"message": "Welcome to the FastAPI application!"}

@router.post("/getfakedata")
async def generate_fake_data(request: FakeDataRequest) -> dict:
    """
    Generate fake data based on the provided parameters.

    Request body example:
    {
        "data_type": "name",
        "count": 3
    }

    Supported data_type values: "name", "email", "phone"
    """
    try:
        if request.data_type not in DATA_GENERATORS:
            raise HTTPException(
                status_code=400,
                detail=f"Invalid data_type. Supported types: {list(DATA_GENERATORS.keys())}"
            )

        generator = DATA_GENERATORS[request.data_type]
        data = [generator() for _ in range(request.count)]

        return {"data": data}
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

This single router organizes endpoints and keeps a clear mapping between data_type and the generator function. Supported data types and generators:

data_type	Generator
`name`	Random first + last name
`email`	Random 8-char username + domain
`phone`	US-style numeric phone `XXX-XXX-XXXX`

Example request / response

Send a POST to /getfakedata with JSON:

{
  "data_type": "name",
  "count": 3
}

A typical successful response:

{
  "data": [
    "David Williams",
    "Michael Johnson",
    "John Smith"
  ]
}

Validation error when required fields are missing (FastAPI returns 422):

{
  "detail": [
    {
      "type": "missing",
      "loc": ["body"],
      "msg": "Field required",
      "input": null
    }
  ]
}

Invalid data_type example (400 response):

{
  "detail": "Invalid data_type. Supported types: ['name', 'email', 'phone']"
}

Running and testing

Start the app:

python main.py

Use curl, httpie, or Postman to test endpoints:

POST http://localhost:8000/getfakedata with JSON shown above.
Visit http://localhost:8000/docs for automatically generated OpenAPI docs.

Watch Uvicorn logs to see incoming requests and response codes (200/422/400).

When using Copilot or any code generator, treat the output as a draft: validate imports, run tests, and adapt generated code to your project structure (packages, relative imports, DB paths). In this example we intentionally replaced external Faker usage with small local generators to reduce dependencies and keep full control over output.

Next steps (wiring DB queries and expanding features)

Suggested enhancements to connect the API to the SQLite dataset and make it production-ready:

Wire endpoints to query fake_data using get_db() (SQLAlchemy session). Example pattern:

from fastapi import Depends
from db.database import get_db
from sqlalchemy.orm import Session

@router.get("/rows")
def read_rows(limit: int = 10, db: Session = Depends(get_db)):
    # use raw SQL or SQLAlchemy models to query `fake_data` table
    rows = db.execute("SELECT * FROM fake_data LIMIT :limit", {"limit": limit}).fetchall()
    return {"rows": [dict(r) for r in rows]}

Add query parameters or dedicated endpoints for filtering (by city, age, occupation), sorting, and pagination.
Add unit tests for endpoints and generator functions (pytest).
Add API documentation notes and curated OpenAPI examples (FastAPI supports response_model and examples).
Consider using SQLAlchemy models to map fake_data rows to ORM objects for cleaner queries.

Links and references

FastAPI docs: https://fastapi.tiangolo.com/
SQLAlchemy: https://www.sqlalchemy.org/
SQLite: https://www.sqlite.org/docs.html
Pydantic: https://docs.pydantic.dev/

This completes the initial API scaffolding and simple fake-data generator. Next, we’ll connect the API to the SQLite dataset and expand the feature set (filtering, pagination, and documentation).

Introduction to GitHub Copilot

Core Features

Using Copilot Efficiently

Building out our tool Creating the API

CSV sample

Quick DB helper (SQLAlchemy)

Choosing a Python web framework

Project scaffold

main.py — start the FastAPI app

Request model (Pydantic)

Router and generating fake data (no third-party Faker)

Example request / response

Running and testing

Next steps (wiring DB queries and expanding features)

Links and references

Watch Video

​CSV sample

​Quick DB helper (SQLAlchemy)

​Choosing a Python web framework

​Project scaffold

​main.py — start the FastAPI app

​Request model (Pydantic)

​Router and generating fake data (no third-party Faker)

​Example request / response

​Running and testing

​Next steps (wiring DB queries and expanding features)

​Links and references

Watch Video

CSV sample

Quick DB helper (SQLAlchemy)

Choosing a Python web framework

Project scaffold

main.py — start the FastAPI app

Request model (Pydantic)

Router and generating fake data (no third-party Faker)

Example request / response

Running and testing

Next steps (wiring DB queries and expanding features)

Links and references