_notebooks/2023-04-27-P5Y-Team-SAME-Now.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Notebook - Data Related to User Guide\n",
    "> A guide to adding data related to user (Big Idea 2)\n",
    "  \n",
    "- title: Notebook - Data Related to User Guide\n",
    "- author: Team SAM, Samit Poojary, Akshat Parikh, Martin Nguyen"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NOTE**\n",
    "\n",
    "As you follow along, make sure to fill in the blanks and complete the coding exercises!"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "\n",
    "When building an application that requires users to create accounts or #, handling data related to users is crucial. This data can include things like user profiles, preferences, and activity logs, which can be used to personalize the user experience and improve the application's performance.\n",
    "\n",
    "For example, by storing a user's name and profile picture, the application can address the user by name and display their picture, creating a more personal experience. Activity logs can also be used to track user behavior and help the application recommend new features or improvements.\n",
    "\n",
    "By learning how to handle data related to users effectively and responsibly, you'll be equipped with the skills and knowledge needed to build robust and user-friendly applications that meet the needs of your users.\n",
    "\n",
    "For simplicity purposes, we will be lecturing on how one can store and manipulate user data for future utilization. "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Here we go!\n",
    "\n",
    "Establishing Class/User Data and making a new user\n",
    "\n",
    "In Python, classes are templates used to create objects, which are instances of those classes. Classes define the data elements (_____) and methods that describe the behavior of the objects. Let's explore how to define a class and create objects in Python.\n",
    "\n",
    "Example: Defining a User class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class User:\n",
    "    def __init__(self, username, email):\n",
    "        self.username = username\n",
    "        self.email = email\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Username: {self.username}, Email: {self.email}\")\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, we define a User class with a constructor method __init__ that takes username and email as arguments. The display_info method is used to print the user information.\n",
    "\n",
    "In the context of backend functionality, this class can be used to create, update, and delete user data. For example, when a new user signs up for an account, you could create a new User object with their username and email. This object can then be used to perform various operations, such as validating the user's input, storing the user's data in a database, or SQL File.\n",
    "\n",
    "Creating a new user:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_user = User(\"john_doe\", \"john@example.com\")\n",
    "new_user.display_info()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n",
    "## Lecture Topics:\n",
    "\n",
    "Establishing Class/User Data and making a new user\n",
    "\n",
    "In Python, classes are templates used to create objects, which are instances of those classes. Classes define the data elements (attributes) and methods that describe the behavior of the objects. Let's explore how to define a class and create objects in Python.\n",
    "\n",
    "Example: Defining a User class\n",
    "\n",
    "\n",
    "\n",
    "class User:\n",
    "    def __init__(self, username, email):\n",
    "        self.username = username\n",
    "        self.email = email\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Username: {self.username}, Email: {self.email}\")\n",
    "\n",
    "In this example, we define a User class with a constructor method __init__ that takes username and email as arguments. The display_info method is used to print the user information.\n",
    "\n",
    "Creating a new user:\n",
    "\n",
    "python\n",
    "\n",
    "new_user = User(\"john_doe\", \"john@example.com\")\n",
    "new_user.display_info()\n",
    "\n",
    "Here, we create a new User object, new_user, with a specified username and email. We then call the display_info method to display the user's information.\n",
    "\n",
    "Using property decorators (getter and setter)\n",
    "\n",
    "Property decorators allow developers to access and modify instance data more concisely. The @property decorator creates a getter method, while the @attribute.setter decorator creates a setter method.\n",
    "\n",
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Employee:\n",
    "    def __init__(self, employee_id, name):\n",
    "        self._employee_id = employee_id\n",
    "        self._name = name\n",
    "\n",
    "    @property\n",
    "    def name(self):\n",
    "        return self._name\n",
    "\n",
    "    @name.setter\n",
    "    def name(self, new_name):\n",
    "        self._name = new_name\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the Employee class has a name attribute, which is accessed and modified through the name property getter and setter methods. The _name attribute uses an underscore prefix, which is a convention to indicate it should not be accessed directly.\n",
    "\n",
    "In the context of backend functionality, this Employee class can be used to model employees within an application. You can create instances of this class to store and manage employee data, and the getter and setter methods can be used to access and modify employee information in a controlled way.\n",
    "\n",
    "Usage:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "employee = Employee(1001, \"John Doe\")\n",
    "print(employee.name)  # Get the name using the getter method\n",
    "\n",
    "employee.name = \"Jane Doe\"  # Set the name using the setter method\n",
    "print(employee.name)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "employee = Employee(1001, \"John Doe\")\n",
    "print(employee.name)  # Get the name using the getter method\n",
    "\n",
    "employee.name = \"Jane Doe\"  # Set the name using the setter method\n",
    "print(employee.name)\n",
    "\n",
    "In the context of backend functionality, the getter and setter methods provide a clean and controlled way to access and modify the attributes of an object. This can be particularly useful when interacting with databases, APIs, or other parts of a web application that require the management and manipulation of object attributes.\n",
    "\n",
    "\n",
    "**CHECK: Explain the function of getters and setters in your own words.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Car:\n",
    "    def __init__(self, make, model, year):\n",
    "        self._make = make\n",
    "        self._model = model\n",
    "        self._year = year\n",
    "\n",
    "    @property\n",
    "    def make(self):\n",
    "        return self._make\n",
    "\n",
    "    @make.setter\n",
    "    def make(self, new_make):\n",
    "        self._make = new_make\n",
    "\n",
    "    @property\n",
    "    def model(self):\n",
    "        return self._model\n",
    "\n",
    "    @model.setter\n",
    "    def model(self, new_model):\n",
    "        self._model = new_model\n",
    "\n",
    "    @property\n",
    "    def year(self):\n",
    "        return self._year\n",
    "\n",
    "    @year.setter\n",
    "    def year(self, new_year):\n",
    "        self._year = new_year\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Take notes here on property decorators and the purpose they serve:**\n",
    "\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Students can then practice creating instances of their Car class and using the getter and setter methods to access and modify the car attributes.\n",
    "\n",
    "In the context of functionality, this Car class can be used to model cars within an application. You can create instances of this class to store and manage car data, and the getter and setter methods can be used to access and modify car information in a controlled way."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Overview \n",
    "\n",
    "WE COVERED:\n",
    "In conclusion, we have covered essential concepts in object-oriented programming using Python, including:\n",
    "\n",
    "    Defining classes and creating objects\n",
    "    Property decorators (getter and setter)\n",
    "    Class methods and static methods\n",
    "    Inheritance and method overriding\n",
    "    Working with multiple objects and class attributes\n",
    "\n",
    "These concepts provide a solid foundation for understanding how to model real-world entities using classes and objects in Python. By learning to work with classes, objects, and their methods, students can develop more efficient and modular code.\n",
    "\n",
    "As students become more comfortable with these concepts, they can explore more advanced topics, such as multiple inheritance, abstract classes, encapsulation, and polymorphism. Additionally, they can apply these principles to practical projects like web development with Flask and SQLite, as discussed earlier.\n",
    "\n",
    "Overall, mastering object-oriented programming will greatly enhance students' ability to develop complex and maintainable software systems."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Databases and SQlite\n",
    "SQLite is a software library that provides a relational database management system. Unlike other databases, such as MySQL or PostgreSQL, SQLite is embedded within an application, which means it does not require a separate server process to operate. This makes SQLite a great choice for small-scale applications or for use in situations where you don't want to set up a full database server.\n",
    "\n",
    "In this lesson, we will be demonstrating how to set up a SQLite database in Flask, which provides an easy-to-use interface for interacting with SQLite databases, and we'll walk through the process of setting up a new database, creating tables, and adding data. We'll also cover some basic SQL commands that you can use to interact with your database, including CREATE TABLE, INSERT, SELECT, UPDATE, and DELETE. By the end of this lesson, you'll have a good understanding of how to work with SQLite databases in Flask and be ready to start building your own ______.\n",
    "\n",
    "## Setting up a SQLite database in Flask\n",
    "\n",
    "One of the key features of flask is its ability to work seamlessly with databases, including SQLite. A database is a collection of data stored in an organized manner that can be easily accessed, managed, and updated.\n",
    "\n",
    "### SQlite databse in Flask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the Flask and SQLite libraries\n",
    "from flask import Flask\n",
    "import sqlite3\n",
    "\n",
    "# Create a Flask application\n",
    "app = Flask(__name__)\n",
    "\n",
    "# Connect to the SQLite database using SQLite3\n",
    "conn = sqlite3.connect('example.db')\n",
    "\n",
    "# Create a cursor object to execute SQL commands\n",
    "cursor = conn.cursor()\n",
    "\n",
    "# Create a table in the database using SQL commands\n",
    "cursor.execute('''CREATE TABLE example_table\n",
    "                 (id INTEGER PRIMARY KEY, name TEXT, age INTEGER)''')\n",
    "\n",
    "# Commit the changes to the database\n",
    "conn.commit()\n",
    "\n",
    "# Close the connection\n",
    "conn.close()\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic SQL commands (create, read, update, delete) \n",
    "SQL is really useful because it helps people do a bunch of things with the data stored in databases. For example, they can use it to create new tables to organize data, add new data to a table, update data that's already there, or delete data that's no longer needed.\n",
    "\n",
    "CRUD is an acronym that stands for the fundamental operations that can be performed on a database, which are Create, Read, Update, and Delete. A widely-used lightweight database management system is SQLite, which can be easily integrated with different programming languages.\n",
    "\n",
    "- C: To create a new record in a database, you must first define the table structure that will store the data. This can be accomplished using SQL commands such as CREATE. Once the table is created, data can be added to it using the INSERT INTO command.\n",
    "\n",
    "- R: To retrieve data from the database, you can use the READ command. You can specify which fields you want to retrieve and the conditions you want to apply using the WHERE clause. There are also several functions available to aggregate and manipulate data.\n",
    "\n",
    "- U: To modify existing data in the database, you can use the UPDATE command. You will need to specify which table and fields you want to update, and the conditions you want to apply using the WHERE clause.\n",
    "\n",
    "- D: To remove data from the database, you can use the DELETE command"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Take notes here on the basic components of SQL:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sqlite3\n",
    "\n",
    "def menu():\n",
    "    operation = input(\"Enter: (C)reate (R)ead (U)pdate or (D)elete\")\n",
    "    if operation.lower() == 'c':\n",
    "        create()\n",
    "    elif operation.lower() == 'r':\n",
    "        read()\n",
    "    elif operation.lower() == 'u':\n",
    "        update()\n",
    "    elif operation.lower() == 'd':\n",
    "        delete()\n",
    "    elif len(operation)==0: # Escape Key\n",
    "        return\n",
    "    else:\n",
    "        print(\"Please enter c, r, u, or d\")\n",
    "    menu() # recursion, repeat menu\n",
    "\n",
    "try:\n",
    "    menu() # start menu\n",
    "except:\n",
    "    print(\"Perform Jupyter 'Run All' prior to starting menu\")\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This block of code is a menu function that helps with create, read, update, and delete (CRUD) tasks and displays the schema. The menu function acts as a control point that directs the program to call different functions based on what the user wants to do. When users enter their preferred action, the input is checked to see which function to use. The menu function is created with no arguments and is called repeatedly, displaying the menu options until the user decides to leave.\n",
    "\n",
    "### Creating a Database"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sqlite3\n",
    "\n",
    "def create_database():\n",
    "    # Connect to the database (will create it if it doesn't exist)\n",
    "    connection = sqlite3.connect('instance/professors.db')\n",
    "    cursor = connection.cursor()\n",
    "\n",
    "    # Create the professors table if it doesn't already exist\n",
    "    cursor.execute('''CREATE TABLE IF NOT EXISTS professors (\n",
    "                    name TEXT,\n",
    "                    field TEXT,\n",
    "                    rating REAL,\n",
    "                    reviews TEXT\n",
    "                )''')\n",
    "\n",
    "    # Commit changes and close the connection\n",
    "    connection.commit()\n",
    "    connection.close()\n",
    "\n",
    "# Call the function to create the database\n",
    "create_database()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create Function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sqlite3\n",
    "\n",
    "def create():\n",
    "   database = 'instance/professors.db'\n",
    "   name = input(\"Enter the professor's name: \")\n",
    "   field = input(\"Enter the professor's field of expertise: \")\n",
    "   rating = input(\"Enter the professor's rating (out of 10): \")\n",
    "   reviews = input(\"Enter any reviews or comments about the professor: \")\n",
    "\n",
    "\n",
    "   # Connect to the database and create a cursor to execute SQL commands\n",
    "   connection = sqlite3.connect(database)\n",
    "   cursor = connection.cursor()\n",
    "\n",
    "\n",
    "   try:\n",
    "       # Execute SQL to insert record into db\n",
    "       cursor.execute(\"INSERT INTO professors (name, field, rating, reviews) VALUES (?, ?, ?, ?)\", (name, field, rating, reviews))\n",
    "       # Commit the changes\n",
    "       connection.commit()\n",
    "       print(f\"{name} has been added to the list of coding professors.\")\n",
    "              \n",
    "   except sqlite3.Error as error:\n",
    "       print(\"Error while inserting record\", error)\n",
    "\n",
    "\n",
    "   # Close cursor and connection\n",
    "   cursor.close()\n",
    "   connection.close()\n",
    "\n",
    "create()\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The create function allows users to input information about a coding professor and store it in a SQLite database named 'professors.db'. This script prompts the user for the professor's name, field of expertise, rating out of 10, and any reviews or comments about the professor. It then establishes a connection to the SQLite database and creates a cursor object for executing SQL commands."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Read Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sqlite3\n",
    "\n",
    "def read():\n",
    "    try:\n",
    "        # Open a connection to the database and create a cursor\n",
    "        connection = sqlite3.connect('instance/professors.db')\n",
    "        cursor = connection.cursor()\n",
    "\n",
    "        # Fetch all records from the professors table\n",
    "        cursor.execute(\"SELECT * FROM professors\")\n",
    "        rows = cursor.fetchall()\n",
    "\n",
    "        # If there are any records, print them\n",
    "        if len(rows) > 0:\n",
    "            print(\"List of coding professors:\")\n",
    "            for row in rows:\n",
    "                print(f\"Name: {row[0]}\\nField of expertise: {row[1]}\\nRating: {row[2]}\\nReviews: {row[3]}\\n\")\n",
    "        else:\n",
    "            print(\"There are no coding professors in the list.\")\n",
    "\n",
    "    except sqlite3.Error as error:\n",
    "        print(\"Error while connecting to the database:\", error)\n",
    "\n",
    "    finally:\n",
    "        # Close the cursor and the connection to the database\n",
    "        cursor.close()\n",
    "        connection.close()\n",
    "\n",
    "read()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This code demonstrates how to read data from a SQLite database using Python and the API. The first step is to establish a connection to the database and create a cursor object to execute SQL commands. Then, a SELECT query is executed to fetch all records from the \"professors\" table. If there are any records, the code iterates through each record and prints out the name, field of expertise, rating, and reviews for each coding professor. If there are no records in the table, a message indicating so is printed. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Update Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sqlite3\n",
    "\n",
    "def update():\n",
    "    database = 'instance/professors.db'\n",
    "    connection = sqlite3.connect(database)\n",
    "    cursor = connection.cursor()\n",
    "    \n",
    "    try:\n",
    "        # Get the professor's name to update\n",
    "        name = input(\"Enter the name of the professor to update: \")\n",
    "        \n",
    "        # Retrieve the current record from the database\n",
    "        cursor.execute(\"SELECT * FROM professors WHERE name=?\", (name,))\n",
    "        record = cursor.fetchone()\n",
    "        \n",
    "        # If the professor is found, update the record\n",
    "        if record:\n",
    "            print(\"Enter the new information for the professor:\")\n",
    "            field = input(f\"Current field: {record[1]}\\nNew field: \")\n",
    "            rating = input(f\"Current rating: {record[2]}\\nNew rating: \")\n",
    "            reviews = input(f\"Current reviews: {record[3]}\\nNew reviews: \")\n",
    "            \n",
    "            # Execute SQL to update the record\n",
    "            cursor.execute(\"UPDATE professors SET field=?, rating=?, reviews=? WHERE name=?\", (field, rating, reviews, name))\n",
    "            connection.commit()\n",
    "            \n",
    "            print(f\"{name}'s record has been updated.\")\n",
    "        \n",
    "        # If the professor is not found, notify the user\n",
    "        else:\n",
    "            print(f\"No record found for {name}.\")\n",
    "    \n",
    "    except sqlite3.Error as error:\n",
    "        print(\"Error while updating record\", error)\n",
    "    \n",
    "    # Close cursor and connection\n",
    "    cursor.close()\n",
    "    connection.close()\n",
    "update ()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is an implementation of an update function for the professors database using the sqlite3 module in Python. The function first establishes a connection to the database file 'instance/professors.db' and creates a cursor object to execute multiple commands. It prompts the user to enter the name of the professor to update and retrieves the corresponding record from the database using a SELECT statement with a WHERE clause to match the professor's name. If the professor is found in the database, the user is prompted to enter new information for the professor's field of expertise, rating, and reviews. The function then executes an if / else statement with the new information to update the record in the database. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Delete Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sqlite3\n",
    "\n",
    "\n",
    "def delete():\n",
    "    # Connect to the database and create a cursor\n",
    "    connection = sqlite3.connect('instance/professors.db')\n",
    "    cursor = connection.cursor()\n",
    "\n",
    "    # Prompt the user for the name of the professor to delete\n",
    "    name = input(\"Enter the name of the professor you want to delete: \")\n",
    "\n",
    "    # Use a SQL query to find the professor with the given name\n",
    "    cursor.execute(\"SELECT * FROM professors WHERE name=?\", (name,))\n",
    "    row = cursor.fetchone()\n",
    "\n",
    "    # If the professor exists, confirm deletion and delete the record\n",
    "    if row:\n",
    "        confirm = input(f\"Are you sure you want to delete {name}? (y/n): \")\n",
    "        if confirm.lower() == 'y':\n",
    "            cursor.execute(\"DELETE FROM professors WHERE name=?\", (name,))\n",
    "            connection.commit()\n",
    "            print(f\"{name} has been deleted from the list of coding professors.\")\n",
    "    else:\n",
    "        print(f\"{name} not found in the list of coding professors.\")\n",
    "\n",
    "    # Close the cursor and the connection to the database\n",
    "    cursor.close()\n",
    "    connection.close()\n",
    "\n",
    "delete()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This code is a Python function for deleting a record from a SQLite database. The function prompts the user to input the name of the professor they want to delete. It then uses a SQL query to search for the professor in the database. If the professor is found, the user is prompted to confirm the deletion. If the user confirms, the function executes a SQL command to delete the record from the database. The function also prints a message confirming that the professor has been deleted from the list of coding professors. If the professor is not found in the database, the function prints a message indicating that the professor is not in the list."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Our Project ... in the works\n",
    "\n",
    "[SAM Messaging System](https://akshat122805.github.io/fastpages/2023/04/19/chatSAM.html)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Get started with your own!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sqlite3\n",
    "\n",
    "# specify the name of the database file\n",
    "db_file = \"<fill in the name of the database file here>.db\"\n",
    "\n",
    "# create a connection to the database\n",
    "conn = sqlite3.connect(db_file)\n",
    "\n",
    "# create a cursor object\n",
    "cursor = conn.cursor()\n",
    "\n",
    "# add code here to create tables and insert data into the database\n",
    "\n",
    "# commit the changes and close the connection\n",
    "conn.commit()\n",
    "conn.close()\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# HACKS\n",
    "\n",
    "- Make sure to fill in all blanks, take notes when prompted, and at least attempt each of the interactive coding exercises. (0.45)\n",
    "\n",
    "- Create your own database and create an algorithm that can insert, update, and delete data ralted to user. Points will be awarded based on effort and success. (0.45)\n",
    "    - Extra Credit: Connect your backend to a visible frontend!\n",
    "\n",
    "\n",
    "    *I have posted my fill in the blanks here, refer to the second and third links to get the notebook and the SQLite file*"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": "3.10.6"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}