Modified_C3M2_Assignment.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Necessary imports"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Programming Assignment: Social Network Database Fix\n",
    "\n",
    "## Welcome!\n",
    "\n",
    "You've reached a practical part of our course, **Generative AI for Software Development - AI-Powered Software and System Design**. This task is all about diving into a database designed for managing a social network. It's a hands-on challenge to test your skills and see how well you can work with AI tools, like a Language Learning Model (LLM).\n",
    "\n",
    "## Your Mission\n",
    "\n",
    "Your job is to fix a database code that's not working right. It's supposed to handle a social network with two main parts: a `Person` table and a `Club` table. There's a mistake in the code, and it's up to you to find and correct it.\n",
    "\n",
    "### Tasks:\n",
    "\n",
    "1. **Fix the Database:** Hunt down the mistake messing up the database and correct it.\n",
    "2. **Write Three Functions:** Use the LLM to help you craft three functions. They should:\n",
    "   - List all members of a specific club.\n",
    "   - List all friends of a specific person.\n",
    "   - List all people who consider a specific person their friend.\n",
    "\n",
    "### Working with the LLM:\n",
    "\n",
    "- **Ask the LLM for Help:** Use the LLM to guide you through fixing the database and creating your functions.\n",
    "- **Use Its Advice Wisely:** Remember, the LLM's advice might not always be spot-on. It's up to you to decide what's useful.\n",
    "\n",
    "## What to Submit:\n",
    "\n",
    "Please submit this Jupyter notebook containing:\n",
    "- The corrected database code.\n",
    "- The three functions you've written.\n",
    "\n",
    "## How We'll Grade It:\n",
    "\n",
    "- **Database Accuracy:** We'll check if you've successfully identified and fixed the issue in the database.\n",
    "- **Functionality of Your Functions:** We'll see if each of your functions is doing exactly what it's supposed to do.\n",
    "\n",
    "## Tips for Success:\n",
    "\n",
    "- **Be Clear with Your Questions:** The clearer your questions to the LLM, the better help you'll get.\n",
    "- **Test the Advice:** Always test out the LLM’s suggestions to ensure they work as expected.\n",
    "- **Hints**: If you struggle with this assignment, you can check some hints we left to you in the bottom of the assignment!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": [
     "graded"
    ]
   },
   "outputs": [],
   "source": [
    "from sqlalchemy import create_engine, Column, Integer, String, ForeignKey, Table\n",
    "from sqlalchemy.ext.declarative import declarative_base\n",
    "from sqlalchemy.orm import relationship, sessionmaker\n",
    "import numpy as np\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import unittests"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The main code\n",
    "\n",
    "Below is the primary code for the assignment. It contains **two significant flaws** that could affect the results of certain functions you'll develop for this task. Identifying the bugs directly from the code might be challenging for an LLM, **so you might need to implement some of the functions to better understand the issues**. Your analytical skills will be crucial. Note that although you are required to create three functions, your submission will be evaluated on four aspects, one of which is the accuracy of your database. Ensure that you address the issues in the code provided!\n",
    "\n",
    "**If you need to start over with a clean version of this assignment, there's a folder named `backup_data` where you can find a fresh copy.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "OML5zvqo0FeL",
    "outputId": "4630141d-fc05-49cb-bce2-a52d544be69c",
    "tags": [
     "graded"
    ]
   },
   "outputs": [],
   "source": [
    "\n",
    "def load_dataset(path = \"./\"):\n",
    "    \"\"\"Loads the dataset\n",
    "    \n",
    "    RUN THE FUNCTION WITHOUT ANY PARAMETER. \n",
    "    THE PARAMETER IS FOR GRADING PURPOSES ONLY.\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    # Ensure reproducibility, but randomness will be removed from selections\n",
    "    np.random.seed(42)\n",
    "    \n",
    "    # Remove existing database if it exists\n",
    "    if 'social_network.db' in os.listdir(path):\n",
    "        os.remove('social_network.db')\n",
    "    \n",
    "    # Setup engine and define tables\n",
    "    engine = create_engine(f'sqlite:///{os.path.join(path, \"social_network.db\")}', echo=False)\n",
    "    Base = declarative_base()\n",
    "    \n",
    "    # Define the friendship association table\n",
    "    friendships = Table('friendships', Base.metadata,\n",
    "        Column('person_id', Integer, ForeignKey('people.id'), primary_key=True),\n",
    "        Column('friend_id', Integer, ForeignKey('people.id'), primary_key=True)\n",
    "    )\n",
    "    \n",
    "    class Person(Base):\n",
    "        __tablename__ = 'people'\n",
    "        id = Column(Integer, primary_key=True)\n",
    "        name = Column(String)\n",
    "        age = Column(Integer)\n",
    "        gender = Column(String)\n",
    "        location = Column(String)\n",
    "    \n",
    "        friends = relationship(\"Person\",\n",
    "                               secondary=friendships,\n",
    "                               primaryjoin=(friendships.c.person_id == id),\n",
    "                               secondaryjoin=(friendships.c.friend_id == id),\n",
    "                               backref=\"friend_of\")\n",
    "        clubs = relationship(\"Club\", secondary=\"club_members\")\n",
    "    \n",
    "    class Club(Base):\n",
    "        __tablename__ = 'clubs'\n",
    "        id = Column(Integer, primary_key=True)\n",
    "        description = Column(String)\n",
    "    \n",
    "        members = relationship(\"Person\", secondary=\"club_members\")\n",
    "    \n",
    "    club_members = Table('club_members', Base.metadata,\n",
    "        Column('person_id', Integer, ForeignKey('people.id')),\n",
    "        Column('club_id', Integer, ForeignKey('clubs.id'))\n",
    "    )\n",
    "    \n",
    "    # Create tables\n",
    "    Base.metadata.create_all(engine)\n",
    "    \n",
    "    # Create a session\n",
    "    Session = sessionmaker(bind=engine)\n",
    "    session = Session()\n",
    "    \n",
    "    # Sample data\n",
    "    names = np.array([(\"Alice\", \"New York\", \"Non-binary\", 30), \n",
    "             (\"Bob\", \"Los Angeles\", \"Male\", 18), \n",
    "             (\"Charlie\", \"Chicago\", \"Male\", 60), \n",
    "             (\"David\", \"Houston\", \"Male\", 59),\n",
    "             (\"Eve\", \"Phoenix\", \"Non-binary\", 18), \n",
    "             (\"Frank\", \"Los Angeles\", \"Non-binary\", 72), \n",
    "             (\"Grace\", \"Chicago\", \"Female\", 35), \n",
    "             (\"Henry\", \"Houston\", \"Male\", 21), \n",
    "             (\"Ivy\", \"New York\", \"Female\", 46), \n",
    "             (\"Elena\", \"Phoenix\", \"Female\", 66)])\n",
    "    club_descriptions = [\n",
    "        \"Book Club\", \"Hiking Club\", \"Chess Club\", \"Photography Club\", \"Cooking Club\",\n",
    "        \"Music Club\", \"Gaming Club\", \"Fitness Club\", \"Art Club\", \"Travel Club\"\n",
    "    ]\n",
    "    \n",
    "    # Populate Person table with the 10 unique persons only\n",
    "    people = []\n",
    "    for name, location, gender, age in names:\n",
    "        person = Person(name=name, age=age, gender=gender, location=location)\n",
    "        people.append(person)\n",
    "        session.add(person)\n",
    "    \n",
    "    # Populate Friendships (one-to-one relationships based on the order to avoid randomness)\n",
    "    for i, person in enumerate(people):\n",
    "        if i < len(people) - 1:\n",
    "            person.friends.append(people[i + 1])\n",
    "        else:\n",
    "            person.friends.append(people[0])  # Loop back to the first person\n",
    "    \n",
    "    # Populate Clubs\n",
    "    clubs = []\n",
    "    for description in club_descriptions:\n",
    "        club = Club(description=description)\n",
    "        clubs.append(club)\n",
    "        session.add(club)\n",
    "    \n",
    "    # Populate Club Members (assign each person to a unique club, avoiding randomness)\n",
    "    for i, person in enumerate(people):\n",
    "        clubs[i % len(clubs)].members.append(person)\n",
    "    \n",
    "    # Commit and close session\n",
    "    session.commit()\n",
    "    session.close()\n",
    "    \n",
    "    print(\"Database created and populated successfully with deterministic data!\")\n",
    "    return session, Club, Person, friendships\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_97/3290300261.py:20: MovedIn20Warning: The ``declarative_base()`` function is now available as sqlalchemy.orm.declarative_base(). (deprecated since: 2.0) (Background on SQLAlchemy 2.0 at: https://sqlalche.me/e/b8d9)\n",
      "  Base = declarative_base()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Database created and populated successfully!\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_97/3290300261.py:81: SAWarning: relationship 'Club.members' will copy column clubs.id to column club_members.club_id, which conflicts with relationship(s): 'Person.clubs' (copies clubs.id to club_members.club_id). If this is not the intention, consider if these relationships should be linked with back_populates, or if viewonly=True should be applied to one or more if they are read-only. For the less common case that foreign key constraints are partially overlapping, the orm.foreign() annotation can be used to isolate the columns that should be written towards.   To silence this warning, add the parameter 'overlaps=\"clubs\"' to the 'Club.members' relationship. (Background on this warning at: https://sqlalche.me/e/20/qzyx) (This warning originated from the `configure_mappers()` process, which was invoked automatically in response to a user-initiated operation.)\n",
      "  person = Person(\n",
      "/tmp/ipykernel_97/3290300261.py:81: SAWarning: relationship 'Club.members' will copy column people.id to column club_members.person_id, which conflicts with relationship(s): 'Person.clubs' (copies people.id to club_members.person_id). If this is not the intention, consider if these relationships should be linked with back_populates, or if viewonly=True should be applied to one or more if they are read-only. For the less common case that foreign key constraints are partially overlapping, the orm.foreign() annotation can be used to isolate the columns that should be written towards.   To silence this warning, add the parameter 'overlaps=\"clubs\"' to the 'Club.members' relationship. (Background on this warning at: https://sqlalche.me/e/20/qzyx) (This warning originated from the `configure_mappers()` process, which was invoked automatically in response to a user-initiated operation.)\n",
      "  person = Person(\n"
     ]
    }
   ],
   "source": [
    "# Loads the dataset\n",
    "session, Club, Person, friendships = load_dataset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 1\n",
    "\n",
    "For this exercise, you are tasked with creating a function named `get_club_members_by_description`. This function should accept a description of a club and a session, and return a list of all its members. **Ensure that this function returns a list containing the defined Person objects.** It must input only a **club description**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "tags": [
     "graded"
    ]
   },
   "outputs": [],
   "source": [
    "def get_club_members(session,club_description):\n",
    "    \"\"\"\n",
    "    Returns a list of Person objects who are members of a club given the club's description.\n",
    "    \n",
    "    Parameters:\n",
    "    - club_description (str): The description of the club for which members are to be retrieved.\n",
    "    \n",
    "    Returns:\n",
    "    - List[Person]: A list of Person objects who are members of the specified club.\n",
    "    \"\"\"\n",
    "    # Query the Club table to get the club with the given description\n",
    "    club = session.query(Club).filter(Club.description == club_description).first()\n",
    "    \n",
    "    # If the club does not exist, return an empty list\n",
    "    if club is None:\n",
    "        return []\n",
    "    \n",
    "    # Return the list of members associated with the found club\n",
    "    return club.members"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Members of the Hiking Club:\n",
      "- David, Age: 72, Location: Phoenix\n",
      "- Grace, Age: 59, Location: Chicago\n",
      "- Henry, Age: 60, Location: Phoenix\n",
      "- Alice, Age: 46, Location: Los Angeles\n",
      "- Ivy, Age: 35, Location: Houston\n",
      "- Ivy, Age: 59, Location: Houston\n"
     ]
    }
   ],
   "source": [
    "# Example usage of the get_club_members function\n",
    "\n",
    "# Assume the session and all models have been correctly set up and populated as per your initial code\n",
    "\n",
    "# Fetching members of the \"Hiking Club\"\n",
    "hiking_club_members = get_club_members(session,\"Hiking Club\")\n",
    "\n",
    "# Printing out the names of all members of the Hiking Club\n",
    "print(\"Members of the Hiking Club:\")\n",
    "for person in hiking_club_members:\n",
    "    print(f\"- {person.name}, Age: {person.age}, Location: {person.location}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[91mFailed test case: Incorrect club members for club description Book Club.\n",
      "Expected: ['Alice', 'Charlie', 'Elena', 'Eve', 'Frank', 'Grace']\n",
      "Got: ['Bob', 'Charlie', 'Charlie', 'Elena', 'Eve', 'Eve', 'Grace', 'Henry', 'Henry']\n",
      "\n",
      "\u001b[91mFailed test case: Incorrect club members for club description Hiking Club.\n",
      "Expected: ['Alice', 'David', 'Elena', 'Eve', 'Frank', 'Ivy']\n",
      "Got: ['Alice', 'David', 'Grace', 'Henry', 'Ivy', 'Ivy']\n",
      "\n",
      "\u001b[91mFailed test case: Incorrect club members for club description Chess Club.\n",
      "Expected: ['Alice', 'David', 'Elena', 'Eve', 'Frank', 'Grace']\n",
      "Got: ['Alice', 'Bob', 'Charlie', 'Eve', 'Eve', 'Frank', 'Henry']\n",
      "\n",
      "\u001b[91mFailed test case: Incorrect club members for club description Photography Club.\n",
      "Expected: ['Alice', 'Charlie', 'David', 'Elena']\n",
      "Got: ['Alice', 'Alice', 'Bob', 'Bob', 'Charlie', 'Eve', 'Grace', 'Grace', 'Henry']\n",
      "\n",
      "\u001b[91mFailed test case: Incorrect club members for club description Cooking Club.\n",
      "Expected: ['Alice', 'Bob', 'Charlie', 'David', 'Grace', 'Henry']\n",
      "Got: ['Alice', 'Charlie', 'Elena', 'Elena', 'Grace', 'Grace', 'Henry', 'Henry']\n",
      "\n",
      "\u001b[91mFailed test case: Incorrect club members for club description Music Club.\n",
      "Expected: ['Alice', 'Charlie', 'Eve', 'Henry']\n",
      "Got: ['Alice', 'Bob', 'Charlie', 'David', 'Grace']\n",
      "\n",
      "\u001b[91mFailed test case: Incorrect club members for club description Gaming Club.\n",
      "Expected: ['Alice', 'Bob', 'Charlie', 'Grace']\n",
      "Got: ['Bob', 'Charlie', 'David', 'Elena', 'Frank', 'Frank', 'Grace']\n",
      "\n",
      "\u001b[91mFailed test case: Incorrect club members for club description Fitness Club.\n",
      "Expected: ['Bob', 'Charlie', 'Elena', 'Henry']\n",
      "Got: ['Alice', 'Alice', 'Charlie', 'Charlie', 'Ivy']\n",
      "\n",
      "\u001b[91mFailed test case: Incorrect club members for club description Art Club.\n",
      "Expected: ['Bob', 'David', 'Elena', 'Eve', 'Grace']\n",
      "Got: ['Alice', 'Bob', 'Bob', 'Frank', 'Grace', 'Grace']\n",
      "\n",
      "\u001b[91mFailed test case: Incorrect club members for club description Travel Club.\n",
      "Expected: ['David', 'Elena', 'Eve', 'Henry', 'Ivy']\n",
      "Got: ['Alice', 'Alice', 'David', 'Grace', 'Henry', 'Henry', 'Ivy']\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "unittests.test_get_club_members(load_dataset, get_club_members)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2\n",
    "\n",
    "In this exercise, you are required to create a function named `get_friends_of_person`. This function should accept the name of a person and a session, return a list of all their friends. **Ensure that this function returns a list containing the defined Person objects.** The input must be only the **name of a person**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "tags": [
     "graded"
    ]
   },
   "outputs": [],
   "source": [
    "def get_friends_of_person(session, person_name):\n",
    "    \"\"\"\n",
    "    Returns a list of Person objects who are friends with the specified person.\n",
    "    \n",
    "    Parameters:\n",
    "    - person_name (str): The name of the person for whom to retrieve friends.\n",
    "    \n",
    "    Returns:\n",
    "    - List[Person]: A list of Person objects who are friends with the specified person.\n",
    "    \"\"\"\n",
    "    # Query the Person table to find the person with the given name\n",
    "    person = session.query(Person).filter(Person.name == person_name).first()\n",
    "    \n",
    "    # If the person does not exist, return an empty list\n",
    "    if person is None:\n",
    "        return []\n",
    "    \n",
    "    # Return the list of friends associated with the found person\n",
    "    return person.friends"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Friends of Bob:\n",
      "- Grace, Age: 35, Location: Chicago\n"
     ]
    }
   ],
   "source": [
    "# Example usage of the get_friends_of_person function\n",
    "\n",
    "# Fetching friends of given name\n",
    "name = \"Bob\"\n",
    "\n",
    "alice_friends = get_friends_of_person(session,name)\n",
    "\n",
    "# Printing out the names of all friends of Alice\n",
    "print(f\"Friends of {name}:\")\n",
    "for friend in alice_friends:\n",
    "    print(f\"- {friend.name}, Age: {friend.age}, Location: {friend.location}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[91mFailed test case: Incorrect friends for person Alice.\n",
      "Expected: ['Bob', 'Charlie', 'David', 'Elena', 'Eve', 'Henry', 'Ivy']\n",
      "Got: ['Alice', 'David']\n",
      "\n",
      "\u001b[91mFailed test case: Incorrect friends for person Bob.\n",
      "Expected: ['Alice', 'David', 'Elena', 'Eve', 'Frank', 'Henry', 'Ivy']\n",
      "Got: ['Grace']\n",
      "\n",
      "\u001b[91mFailed test case: Incorrect friends for person Charlie.\n",
      "Expected: ['Alice', 'Bob', 'David', 'Elena', 'Frank', 'Grace', 'Henry', 'Ivy']\n",
      "Got: ['Eve', 'Grace']\n",
      "\n",
      "\u001b[91mFailed test case: Incorrect friends for person David.\n",
      "Expected: ['Alice', 'Bob', 'Charlie', 'Elena', 'Eve', 'Frank', 'Grace', 'Henry', 'Ivy']\n",
      "Got: ['Bob', 'Bob']\n",
      "\n",
      "\u001b[91mFailed test case: Incorrect friends for person Eve.\n",
      "Expected: ['Alice', 'Charlie', 'David', 'Elena', 'Frank', 'Grace', 'Henry']\n",
      "Got: ['Elena', 'Eve']\n",
      "\n",
      "\u001b[91mFailed test case: Incorrect friends for person Frank.\n",
      "Expected: ['Alice', 'Bob', 'Charlie', 'David', 'Elena', 'Eve', 'Grace', 'Henry']\n",
      "Got: ['Eve']\n",
      "\n",
      "\u001b[91mFailed test case: Incorrect friends for person Grace.\n",
      "Expected: ['Alice', 'Bob', 'David', 'Elena', 'Eve', 'Frank', 'Henry', 'Ivy']\n",
      "Got: ['David', 'Frank', 'Henry', 'Henry']\n",
      "\n",
      "\u001b[91mFailed test case: Incorrect friends for person Henry.\n",
      "Expected: ['Alice', 'Bob', 'Charlie', 'David', 'Elena', 'Eve', 'Grace']\n",
      "Got: ['Elena', 'Eve']\n",
      "\n",
      "\u001b[91mFailed test case: Incorrect friends for person Ivy.\n",
      "Expected: ['Alice', 'Bob', 'Charlie', 'David', 'Elena', 'Eve', 'Frank', 'Grace', 'Henry']\n",
      "Got: ['Alice', 'Grace']\n",
      "\n",
      "\u001b[91mFailed test case: Incorrect friends for person Elena.\n",
      "Expected: ['Alice', 'Charlie', 'David', 'Eve', 'Frank', 'Grace', 'Henry', 'Ivy']\n",
      "Got: ['David', 'David', 'Eve', 'Henry', 'Ivy', 'Ivy']\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "unittests.test_get_friends_of_person(load_dataset, get_friends_of_person)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 3\n",
    "\n",
    "In this exercise, you're tasked with crafting a function called `get_persons_who_consider_them_friend`. This function should take two parameters: the name of an individual and a session. It will return a list of people who count this individual as a friend. It's important to remember that in our database, friendship isn't necessarily mutual. For example, Alice might consider Bob a friend, but Bob might not feel the same way about Alice. **Your function must return a list of Person objects for everyone who considers the input name their friend.** The input to this function should strictly be the **name of the person** you're inquiring about."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "tags": [
     "graded"
    ]
   },
   "outputs": [],
   "source": [
    "def get_persons_who_consider_them_friend(session, person_name):\n",
    "    \"\"\"\n",
    "    Returns a list of Person objects who consider the specified person as their friend,\n",
    "    in a scenario where friendships are unidirectional.\n",
    "    \n",
    "    Parameters:\n",
    "    - person_name (str): The name of the person to find who is considered as a friend by others.\n",
    "    \n",
    "    Returns:\n",
    "    - List[Person]: A list of Person objects who consider the specified person as their friend.\n",
    "    \"\"\"\n",
    "    # First, find the person by the given name to get their ID\n",
    "    person = session.query(Person).filter(Person.name == person_name).first()\n",
    "    \n",
    "    # If the person does not exist, return an empty list\n",
    "    if person is None:\n",
    "        return []\n",
    "    \n",
    "    # Query the friendships table for rows where the friend_id matches the person's ID\n",
    "    # Then, join with the Person table to get the details of the people who consider them a friend\n",
    "    friends_of = session.query(Person).join(friendships, Person.id == friendships.c.person_id).filter(friendships.c.friend_id == person.id).all()\n",
    "    \n",
    "    return friends_of"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "People who consider Bob as their friend:\n",
      "- David, Age: 18, Location: Chicago\n",
      "- Bob, Age: 18, Location: Chicago\n",
      "- Grace, Age: 59, Location: New York\n",
      "- Frank, Age: 35, Location: Phoenix\n"
     ]
    }
   ],
   "source": [
    "# Example usage of the get_persons_who_consider_them_friend function\n",
    "\n",
    "# Fetching people who consider given name as their friend\n",
    "name = 'Bob'\n",
    "\n",
    "name_friend_of = get_persons_who_consider_them_friend(session, name)\n",
    "\n",
    "# Printing out the names of all people who consider Alice as their friend\n",
    "print(f\"People who consider {name} as their friend:\")\n",
    "for person in name_friend_of:\n",
    "    print(f\"- {person.name}, Age: {person.age}, Location: {person.location}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[91mFailed test case: Incorrect persons who consider Alice a friend.\n",
      "Expected: ['Bob', 'Charlie', 'David', 'Elena', 'Eve', 'Frank', 'Grace', 'Henry', 'Ivy']\n",
      "Got: ['Ivy']\n",
      "\n",
      "\u001b[91mFailed test case: Incorrect persons who consider Bob a friend.\n",
      "Expected: ['Alice', 'Charlie', 'David', 'Frank', 'Grace', 'Henry', 'Ivy']\n",
      "Got: ['Bob', 'David', 'Frank', 'Grace']\n",
      "\n",
      "\u001b[91mFailed test case: Incorrect persons who consider Charlie a friend.\n",
      "Expected: ['Alice', 'David', 'Elena', 'Eve', 'Frank', 'Henry', 'Ivy']\n",
      "Got: ['Bob', 'Elena']\n",
      "\n",
      "\u001b[91mFailed test case: Incorrect persons who consider David a friend.\n",
      "Expected: ['Alice', 'Bob', 'Charlie', 'Elena', 'Eve', 'Frank', 'Grace', 'Henry', 'Ivy']\n",
      "Got: ['Frank']\n",
      "\n",
      "\u001b[91mFailed test case: Incorrect persons who consider Eve a friend.\n",
      "Expected: ['Alice', 'Bob', 'David', 'Elena', 'Frank', 'Grace', 'Henry', 'Ivy']\n",
      "Got: ['Ivy']\n",
      "\n",
      "\u001b[91mFailed test case: Incorrect persons who consider Frank a friend.\n",
      "Expected: ['Bob', 'Charlie', 'David', 'Elena', 'Eve', 'Grace', 'Ivy']\n",
      "Got: ['Eve', 'Frank']\n",
      "\n",
      "\u001b[91mFailed test case: Incorrect persons who consider Grace a friend.\n",
      "Expected: ['Charlie', 'David', 'Elena', 'Eve', 'Frank', 'Henry', 'Ivy']\n",
      "Got: ['Alice', 'Elena']\n",
      "\n",
      "\u001b[91mFailed test case: Incorrect persons who consider Henry a friend.\n",
      "Expected: ['Alice', 'Bob', 'Charlie', 'David', 'Elena', 'Eve', 'Frank', 'Grace', 'Ivy']\n",
      "Got: ['Grace', 'Grace']\n",
      "\n",
      "\u001b[91mFailed test case: Incorrect persons who consider Ivy a friend.\n",
      "Expected: ['Alice', 'Bob', 'Charlie', 'David', 'Elena', 'Grace']\n",
      "Got: []\n",
      "\n",
      "\u001b[91mFailed test case: Incorrect persons who consider Elena a friend.\n",
      "Expected: ['Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Frank', 'Grace', 'Henry', 'Ivy']\n",
      "Got: ['Alice', 'Bob']\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "unittests.test_get_persons_who_consider_them_friend(load_dataset, get_persons_who_consider_them_friend)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Now test your Dataset!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "unittests.test_load_dataset(load_dataset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>    \n",
    "<summary>\n",
    "    <font size=\"3\" color=\"darkgreen\"><b>Hint 1</b></font>\n",
    "</summary>\n",
    "<p>\n",
    "Check how the persons are being inserted into the dataset! Does the random is necessary?\n",
    "</p>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>    \n",
    "<summary>\n",
    "    <font size=\"3\" color=\"darkgreen\"><b>Hint 2</b></font>\n",
    "</summary>\n",
    "<p>\n",
    "You may have to properly handle how friendships are created. Ask an LLM how you can fix that part.\n",
    "</p>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>    \n",
    "<summary>\n",
    "    <font size=\"3\" color=\"darkgreen\"><b>Hint 3</b></font>\n",
    "</summary>\n",
    "<p>\n",
    "Remember that friendships are not bidirectional! Specify it when asking the LLM to make your last function!\n",
    "</p>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Congratulations! You have finished the assignment! Keep up!"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "grader_version": "1",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}