Creating a New Project

This guide shows how to bootstrap a small Python project from the provided GitHub repository, create and activate a virtual environment, scaffold a minimal application, split code into modules, and add a helper that calls a local Ollama model to generate fake CSV data. All examples use standard Python tooling and will work without GitHub Copilot, though Copilot can speed up scaffolding and suggestions. You can follow along with the course resources:

Example repository contents typically include a license, .gitignore, GitHub Copilot instructions, and main.py. Below are concise, practical steps to go from repository to a working fake-data generator that queries a local Ollama server.

1. Clone the repository (optional)

If you received a GitHub URL, clone it and change into the project folder:

git clone https://github.com/your-org/your-repo.git
cd your-repo

2. Create a virtual environment

Use a virtual environment to isolate dependencies per project. You can let VS Code create the environment via Python: Create Environment, or do it manually. Table: Create & activate a venv (cross-platform)

Platform	Create	Activate
macOS / Linux	`python3 -m venv .venv`	`source .venv/bin/activate`
Windows (PowerShell)	`python -m venv .venv`	`.venv\Scripts\Activate.ps1`

When the venv is active your shell prompt typically shows the venv name, for example:

(.venv) jeremy@Jeremys-Mac-Studio FakeDataGenerator %

Virtual environments isolate a project’s Python packages. Always install dependencies with pip while the venv is active so they are stored inside .venv rather than globally.

3. Project scaffold: minimal main & module

Start with a minimal scaffold and keep main.py focused on orchestration. This improves testability and keeps the entrypoint simple. Example main.py:

# main.py
from fake_data_generator import FakeDataGenerator

def main():
    """
    Entry point for the FakeDataGenerator CLI.
    """
    generator = FakeDataGenerator()
    generator.run()

if __name__ == "__main__":
    main()

Example fake_data_generator.py:

# fake_data_generator.py
class FakeDataGenerator:
    """
    Core class responsible for generating fake data.
    """

    def run(self):
        """
        Executes the generator workflow.
        """
        print("Fake data generator is running...")

Run and verify:

python main.py
# Output:
# Fake data generator is running...

Tip: If you began with the class inside main.py, extract it to fake_data_generator.py and import it from main.py to maintain good separation of concerns.

4. File structure (example)

Here’s a simple example file layout you can use:

.
├── .gitignore
├── main.py
├── fake_data_generator.py
├── create_fake_data.py
└── requirements.txt

5. Generate fake data via a local Ollama model

The helper script create_fake_data.py demonstrates calling a local Ollama HTTP API (default http://localhost:11434) using a model like phi4:latest and writing the returned CSV to disk. Install the runtime dependency:

pip install requests

Example create_fake_data.py:

# create_fake_data.py
from typing import Any, Dict, Optional
import requests

def create_ollama_prompt() -> str:
    """
    Construct a concise prompt requesting only raw CSV output.
    """
    return (
        "Generate fake data for 5 people in CSV format with these columns:\n"
        "first_name,last_name,email,age,city,occupation\n"
        "Please only return the raw CSV data without any additional text."
    )

def call_ollama_api(prompt: str) -> Optional[Dict[str, Any]]:
    """
    Send the prompt to the local Ollama API and return parsed JSON.

    Returns:
        The parsed JSON response on success, or None on failure.
    """
    url = "http://localhost:11434/api/generate"
    payload = {
        "model": "phi4:latest",
        "prompt": prompt,
        "stream": False
    }

    try:
        response = requests.post(url, json=payload)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f"Error calling Ollama API: {e}")
        return None

def main():
    """
    Generate fake CSV data from the model and save it to a file.
    """
    prompt = create_ollama_prompt()
    response = call_ollama_api(prompt)

    if response and "response" in response:
        output_file = "fake_data.csv"
        with open(output_file, "w", newline="") as f:
            f.write(response["response"])
        print(f"Fake data has been saved to {output_file}")
    else:
        print("Failed to generate fake data")

if __name__ == "__main__":
    main()

Run the generator:

python create_fake_data.py
# Output on success:
# Fake data has been saved to fake_data.csv

Note: Ollama’s response JSON schema may vary depending on model and setup. The example expects a top-level "response" containing raw CSV. If you use an Ollama client library, prefer it for richer, higher-level functionality. Sample CSV output (example fake_data.csv content):

first_name,last_name,email,age,city,occupation
John,Doe,john.doe@example.com,28,New York,Software Engineer
Jane,Smith,jane.smith@example.com,34,San Francisco,Data Scientist
Emily,Jones,emily.jones@example.com,27,Boston,Graphic Designer
Michael,Taylor,michael.taylor@example.com,40,Chicago,Lawyer
Sarah,Garcia,sarah.garcia@example.com,31,Austin,Marketing Manager

Run the script multiple times to append or overwrite the CSV depending on how you modify the file-handling logic; this is useful if you plan to import generated data into a database.

6. Dependencies: requirements.txt

After installing packages during development, capture them for reproducibility:

pip freeze > requirements.txt

To recreate the environment on another machine:

pip install -r requirements.txt

Example snippet of pip freeze output:

certifi==2024.12.14
charset-normalizer==3.4.1
idna==3.10
requests==2.32.3
urllib3==2.3.0

7. .gitignore and keeping the venv out of Git

Never commit your virtual environment to source control. Add .venv/ to .gitignore and exclude common build artifacts and IDE folders.

A dark-themed code editor/GitHub Copilot chat screenshot where a user asks how to keep git from seeing their .venv folder. Copilot is generating a response suggesting creating a .gitignore file to exclude the virtual environment.

Example .gitignore contents (abbreviated):

# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class

# C extensions
*.so

# Distribution / packaging
.Python
build/
dist/
*.egg-info/
*.egg

# IDE
.idea/
.vscode/
*.swp
.DS_Store

# Virtual environments
.venv/
venv/
env/

If you accidentally committed .venv, remove it from Git tracking and commit the change:

git add .gitignore
git commit -m "Add .gitignore file"

# If .venv was already tracked:
git rm -r --cached .venv
git commit -m "Remove .venv from git tracking"

Do not commit your virtual environment or large generated files (like CSV data dumps) to the repository. This increases repo size and leaks machine-specific configuration.

8. Quick reference: useful commands

Task	Command
Create venv (macOS/Linux)	`python3 -m venv .venv`
Activate venv (macOS/Linux)	`source .venv/bin/activate`
Create venv (Windows PowerShell)	`python -m venv .venv`
Activate venv (Windows PowerShell)	`.venv\Scripts\Activate.ps1`
Install requests	`pip install requests`
Save dependencies	`pip freeze > requirements.txt`
Untrack `.venv` from Git	`git rm -r --cached .venv`

Summary

Create and activate a virtual environment (python3 -m venv .venv / source .venv/bin/activate).
Keep main.py minimal and split logic into modules like fake_data_generator.py.
Use create_fake_data.py to call a local Ollama model and write raw CSV output to a file.
Record dependencies with pip freeze > requirements.txt.
Use .gitignore to exclude virtualenvs and other local artifacts from Git.
GitHub Copilot can speed up scaffolding, but the patterns shown here are standard Python best practices and will work without Copilot.

Next steps you might explore:

Load the generated CSV into a database and expose a small API to query the fake data.
Enhance the generator to accept command-line arguments (rows, model, output file).
Integrate a proper Ollama client library for streaming or richer model control.

Introduction

GitHub Copilot Basics

Prompt Engineering with Copilot

Advanced Features

Management of GitHub Copilot

Using Copilot Efficiently

Creating a New Project

1. Clone the repository (optional)

2. Create a virtual environment

3. Project scaffold: minimal main & module

4. File structure (example)

5. Generate fake data via a local Ollama model

6. Dependencies: requirements.txt

7. .gitignore and keeping the venv out of Git

8. Quick reference: useful commands

Summary

Watch Video

​1. Clone the repository (optional)

​2. Create a virtual environment

​3. Project scaffold: minimal main & module

​4. File structure (example)

​5. Generate fake data via a local Ollama model

​6. Dependencies: requirements.txt

​7. .gitignore and keeping the venv out of Git

​8. Quick reference: useful commands

​Summary

Watch Video

1. Clone the repository (optional)

2. Create a virtual environment

3. Project scaffold: minimal main & module

4. File structure (example)

5. Generate fake data via a local Ollama model

6. Dependencies: requirements.txt

7. .gitignore and keeping the venv out of Git

8. Quick reference: useful commands

Summary