MyNotes_Bizcard.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyOhaNogIkY/IL3N5yqFzXPE",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/balajimanilal/BizCardX-Efficient-Business-Card-Data-Extraction-Using-OCR/blob/main/MyNotes_Bizcard.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Package Imports"
      ],
      "metadata": {
        "id": "2tZBeRQrbEhE"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "easyocr: This is an Optical Character Recognition (OCR) tool that can read text from images.\n",
        "\n",
        "PIL (Python Imaging Library): This is used for opening, manipulating, and saving many different image file formats.\n",
        "\n",
        "re: This is the regular expressions library, used for string searching and manipulation.\n",
        "\n",
        "pandas: This is a powerful data manipulation and analysis library for Python.\n",
        "\n",
        "sqlalchemy: This is a SQL toolkit and Object-Relational Mapping (ORM) library for Python. It provides tools for working with databases.\n",
        "\n",
        "os: This module provides a way of using operating system dependent functionality like reading or writing to the file system.\n",
        "\n",
        "streamlit: This is a library used for creating web apps easily.\n",
        "\n",
        "streamlit_option_menu: This is an additional module for creating option menus in Streamlit apps."
      ],
      "metadata": {
        "id": "R5Yl2ZclbHC1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import easyocr\n",
        "from PIL import Image\n",
        "import re\n",
        "import pandas as pd\n",
        "from sqlalchemy import create_engine, update, MetaData, Table\n",
        "import os\n",
        "import streamlit as st\n",
        "from streamlit_option_menu import option_menu"
      ],
      "metadata": {
        "id": "o18e1aRgb81h"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Database Connection and Metadata Reflection"
      ],
      "metadata": {
        "id": "LgJM760ocLzX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Creating a connection engine to a PostgreSQL database named bizcardx_data. The connection string includes the username (postgres), password (12345), and host (localhost).\n",
        "\n",
        "And establishing a connection to the database using the engine created above"
      ],
      "metadata": {
        "id": "c70PGcN1cOGe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "engine = create_engine(\"postgresql+psycopg2://postgres:12345@localhost/bizcardx_data\")\n",
        "conn = engine.connect()"
      ],
      "metadata": {
        "id": "RvuOJSDYcVuv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Reflecting the existing database schema**\n",
        "\n",
        "MetaData: This is a container object that keeps together many different features of a database (or multiple databases) being described.\n",
        "\n",
        "metadata.reflect(bind=engine): This command loads the table definitions from the database into the MetaData object, effectively reading the schema of the database.\n",
        "\n",
        "**Accessing the 'business_card' table from the reflected metadata**\n",
        "\n",
        "Accessing the business_card table from the reflected metadata.\n",
        "\n",
        "autoload=True and autoload_with=engine: These parameters ensure that the table's schema is automatically loaded from the database using the provided engine."
      ],
      "metadata": {
        "id": "28VcAd5Bcn4O"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "metadata = MetaData()\n",
        "metadata.reflect(bind=engine)\n",
        "\n",
        "business_card_table = Table('business_card', metadata, autoload=True, autoload_with=engine)"
      ],
      "metadata": {
        "id": "qV1lZd_2dPhO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# extract_text function"
      ],
      "metadata": {
        "id": "hylolE1FjXz_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Defining a function named extract_text that takes one parameter, image_path. This parameter is expected to be the file path of the image from which text needs to be extracted.\n",
        "\n",
        "easyocr.Reader: This initializes the EasyOCR reader object.\n",
        "\n",
        "['en']: This specifies the language for OCR, in this case, English.\n",
        "\n",
        "gpu=False: This parameter indicates that the OCR processing should not use the GPU (Graphics Processing Unit). It will use the CPU instead.\n",
        "\n",
        "Image.open(image_path): This uses the PIL library to open the image file located at image_path.\n",
        "\n",
        ".convert('RGB'): This converts the image to RGB mode, which ensures it has three color channels (red, green, blue). This is often necessary for consistent image processing.\n",
        "\n",
        "reader.readtext(image_path, detail=0): This line uses the EasyOCR reader to read text from the image.\n",
        "\n",
        "image_path: The file path of the image is passed to the readtext function.\n",
        "\n",
        "detail=0: This parameter specifies the level of detail in the returned results. A value of 0 means that only the text strings are returned, without additional information like bounding boxes.\n",
        "\n",
        "Returns the extracted text details from the function. The variable details contains the text strings extracted from the image."
      ],
      "metadata": {
        "id": "ltaEzx0WjcX4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def extract_text(image_path):\n",
        "    reader = easyocr.Reader(['en'], gpu=False)\n",
        "    image = Image.open(image_path).convert('RGB')\n",
        "    # Extracting text from image\n",
        "    details = reader.readtext(image_path, detail=0)\n",
        "    return details"
      ],
      "metadata": {
        "id": "DOG0MwJOjb2S"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "In summary, the extract_text function initializes an OCR reader, opens and processes an image, extracts text from the image using EasyOCR, and returns the extracted text strings. This function can be used to easily retrieve text from images by providing the path to the image file."
      ],
      "metadata": {
        "id": "_4YdWnWsloD3"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# process_text function"
      ],
      "metadata": {
        "id": "gkcwMjd-kudU"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Defining another function named process_text that takes one parameter, details. This parameter is expected to be a list of strings containing text extracted from an image.\n",
        "\n",
        "Initializing a dictionary named data with keys for various information fields typically found on a business card. The values are initially set to empty strings or empty lists.\n",
        "\n",
        "Starting a loop that iterates over each string in the details list.\n",
        "\n",
        "Using regular expressions to match different patterns in the text.\n",
        "match1: Matches patterns like \"123 ABC Street, City State\".\n",
        "match2: Matches patterns like \"123 ABC Street, City\".\n",
        "match3: Matches lines starting with 'E' and ending with a lowercase letter, likely email addresses.\n",
        "match4: Matches patterns like \"State 12345\".\n",
        "match5: Matches patterns like \"123 StreetName\".\n",
        "match6: Matches lines ending with \".com\", likely websites.\n",
        "match7: Matches numerical sequences.\n",
        "\n",
        "Checking the position of the text and content to assign values to the dictionary.\n",
        "\n",
        "The first item in details is assumed to be the name.\n",
        "The second item in details is assumed to be the designation.\n",
        "\n",
        "If the text contains a hyphen, it is assumed to be a contact number and is appended to the contact list.\n",
        "\n",
        "If the text contains an '@' symbol, it is assumed to be an email address.\n",
        "\n",
        "If the text contains \"www\" or \"WWW\", it is assumed to be a website.\n",
        "\n",
        "Again using the regular expression matches to assign the appropriate text to the corresponding fields in the data dictionary.\n",
        "\n",
        "If the text does not match any specific pattern, it is assumed to be part of the company name.\n",
        "\n",
        "\" & \".join(data[\"contact\"]): Joins all contact numbers with \" & \".\n",
        "\" \".join(data[\"company\"]): Joins all company name parts with a space.\n",
        "return data: Returns the processed data dictionary."
      ],
      "metadata": {
        "id": "yB6vdM7Sk1jf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def process_text(details):\n",
        "    data = {\n",
        "        \"name\": \"\",\n",
        "        \"designation\": \"\",\n",
        "        \"contact\": [],\n",
        "        \"email\": \"\",\n",
        "        \"website\": \"\",\n",
        "        \"street\": \"\",\n",
        "        \"city\": \"\",\n",
        "        \"state\": \"\",\n",
        "        \"pincode\": \"\",\n",
        "        \"company\": []\n",
        "    }\n",
        "\n",
        "    for i in range(len(details)):\n",
        "        match1 = re.findall('([0-9]+ [A-Z]+ [A-Za-z]+)., ([a-zA-Z]+). ([a-zA-Z]+)', details[i])\n",
        "        match2 = re.findall('([0-9]+ [A-Z]+ [A-Za-z]+)., ([a-zA-Z]+)', details[i])\n",
        "        match3 = re.findall('^[E].+[a-z]', details[i])\n",
        "        match4 = re.findall('([A-Za-z]+) ([0-9]+)', details[i])\n",
        "        match5 = re.findall('([0-9]+ [a-zA-z]+)', details[i])\n",
        "        match6 = re.findall('.com$', details[i])\n",
        "        match7 = re.findall('([0-9]+)', details[i])\n",
        "        if i == 0:\n",
        "            data[\"name\"] = details[i]\n",
        "        elif i == 1:\n",
        "            data[\"designation\"] = details[i]\n",
        "        elif '-' in details[i]:\n",
        "            data[\"contact\"].append(details[i])\n",
        "        elif '@' in details[i]:\n",
        "            data[\"email\"] = details[i]\n",
        "        elif \"www \" in details[i].lower() or \"www.\" in details[i].lower():\n",
        "            data[\"website\"] = details[i]\n",
        "        elif \"WWW\" in details[i]:\n",
        "            data[\"website\"] = details[i] + \".\" + details[i+1]\n",
        "        elif match6:\n",
        "            pass\n",
        "        elif match1:\n",
        "            data[\"street\"] = match1[0][0]\n",
        "            data[\"city\"] = match1[0][1]\n",
        "            data[\"state\"] = match1[0][2]\n",
        "        elif match2:\n",
        "            data[\"street\"] = match2[0][0]\n",
        "            data[\"city\"] = match2[0][1]\n",
        "        elif match3:\n",
        "            data[\"city\"] = match3[0]\n",
        "        elif match4:\n",
        "            data[\"state\"] = match4[0][0]\n",
        "            data[\"pincode\"] = match4[0][1]\n",
        "        elif match5:\n",
        "            data[\"street\"] = match5[0] + ' St,'\n",
        "        elif match7:\n",
        "            data[\"pincode\"] = match7[0]\n",
        "        else:\n",
        "            data[\"company\"].append(details[i])\n",
        "\n",
        "    data[\"contact\"] = \" & \".join(data[\"contact\"])\n",
        "    # Joining company names with space\n",
        "    data[\"company\"] = \" \".join(data[\"company\"])\n",
        "    return data"
      ],
      "metadata": {
        "id": "c-kCc00LlvXT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "In summary, the process_text function processes the extracted text from an image and organizes it into a structured dictionary by identifying and categorizing various types of information using regular expressions and positional logic."
      ],
      "metadata": {
        "id": "FKP64BxUmKaT"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# store_data function"
      ],
      "metadata": {
        "id": "y3tXSieamVbO"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Defining a function named store_data that takes one parameter, data. This parameter is expected to be a dictionary containing the processed information from a business card.\n",
        "\n",
        "Converting the data dictionary into a Pandas DataFrame.\n",
        "\n",
        "The data dictionary is wrapped in a list (i.e., [data]) to ensure it creates a DataFrame with a single row. Without wrapping in a list, pd.DataFrame(data) would treat the dictionary keys as column names and values as data entries, which is not desired in this context.\n",
        "\n",
        "Storing the DataFrame df into an SQL table named 'business_card'.\n",
        "\n",
        "engine: The database engine created earlier using SQLAlchemy.\n",
        "\n",
        "if_exists='append': This option specifies that if the 'business_card' table already exists, the function should append the new data to it. Other options include 'fail' (raise an error if the table exists) and 'replace' (drop the table and create a new one).\n",
        "\n",
        "index=False: This option specifies that the DataFrame's index should not be written as a separate column in the SQL table.\n",
        "\n",
        "And returns the DataFrame df. This can be useful for further processing or verification after storing the data in the SQL table."
      ],
      "metadata": {
        "id": "4qhfwJW-mZae"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def store_data(data):\n",
        "    # Converting dictionary to DataFrame\n",
        "    df = pd.DataFrame([data]) # Wrap data in a list to create DataFrame\n",
        "    # Storing DataFrame in SQL table\n",
        "    df.to_sql('business_card', engine, if_exists='append', index=False)\n",
        "    return df"
      ],
      "metadata": {
        "id": "iPmMToRwmssU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "In summary, the store_data function takes a dictionary of business card information, converts it into a Pandas DataFrame, and then appends this DataFrame to an SQL table named 'business_card' in the connected database. Finally, it returns the DataFrame for potential further use."
      ],
      "metadata": {
        "id": "TkJnTsa3mvBh"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Streamlit Page Configuration"
      ],
      "metadata": {
        "id": "iQOzZVmXFPLP"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "st.set_page_config(): This function sets the configuration for the Streamlit app page.\n",
        "\n",
        "page_title: Sets the title of the page to \"BizCardX\".\n",
        "\n",
        "page_icon: Sets the icon of the page to a briefcase emoji ('💼').\n",
        "\n",
        "layout: Sets the layout to \"wide\", which makes the page content spread across the entire width of the browser window.\n",
        "\n",
        "text = 'BizCardX': Assigns the string 'BizCardX' to the variable text.\n",
        "\n",
        "st.markdown(): Renders the text variable as HTML with specific styling.\n",
        "\n",
        "< h2 style ='color: white ; text-align: center;' > {text} </h2>: Formats the text as an H2 header, colors it white, and centers it on the page.\n",
        "\n",
        "unsafe_allow_html=True: Allows the use of raw HTML in the Markdown content."
      ],
      "metadata": {
        "id": "I4j6Fm2HFXAj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "st.set_page_config(page_title= \"BizCardX\",\n",
        "                   page_icon= '💼',\n",
        "                   layout= \"wide\",)\n",
        "text = 'BizCardX'\n",
        "st.markdown(f\"<h2 style='color: white; text-align: center;'>{text} </h2>\", unsafe_allow_html=True)"
      ],
      "metadata": {
        "id": "NOtXOa-yFi-a"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Create Two Columns Layout**\n",
        "st.columns([1,4]): Creates a two-column layout with column 1 (col1) taking up 1 part and column 2 (col2) taking up 4 parts of the available space.\n",
        "\n",
        "with col1:: This block of code is scoped to col1, meaning all Streamlit elements defined within this block will be placed in the first column.\n",
        "\n",
        "menu = option_menu(): Creates a menu with the option_menu function.\n",
        "\n",
        "\"Menu\": Title of the menu.\n",
        "\n",
        "[\"Home\",\"Upload\",\"Database\"]: List of menu items.\n",
        "\n",
        "icons=[\"house\",'cloud-upload', \"list-task\"]: List of icons corresponding to each menu item.\n",
        "\n",
        "menu_icon=\"cast\": Icon for the menu itself.\n",
        "\n",
        "default_index=0: Sets the default selected menu item to the first one (\"Home\").\n",
        "\n",
        "styles: Dictionary to style the menu.\n",
        "\n",
        "\"icon\": Sets the color and font size of the icons.\n",
        "\n",
        "\"nav-link\": Styles for the navigation links (menu items).\n",
        "\n",
        "\"nav-link-selected\": Styles for the selected navigation link."
      ],
      "metadata": {
        "id": "4sOOtl-UGRL-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "col1,col2 = st.columns([1,4])\n",
        "\n",
        "with col1:\n",
        "    menu = option_menu(\"Menu\", [\"Home\",\"Upload\",\"Database\"],\n",
        "                    icons=[\"house\",'cloud-upload', \"list-task\"],\n",
        "                    menu_icon=\"cast\",\n",
        "                    default_index=0,\n",
        "                    styles={\"icon\": {\"color\": \"orange\", \"font-size\": \"20px\"},\n",
        "                            \"nav-link\": {\"font-size\": \"15px\", \"text-align\": \"left\", \"margin\": \"-2px\", \"--hover-color\": \"#FFFFFF\"},\n",
        "                            \"nav-link-selected\": {\"background-color\": \"#225154\"}})"
      ],
      "metadata": {
        "id": "LLvKU8KaGih9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Check for 'Database' Menu Selection**\n",
        " if the selected menu item is 'Database'.\n",
        "\n",
        " Database_menu = option_menu(): Creates a sub-menu under the 'Database' menu item.\n",
        "\n",
        "\"Database\": Title of the sub-menu.\n",
        "\n",
        "['Modify','Delete']: List of sub-menu items.\n",
        "\n",
        "menu_icon=\"list-task\": Icon for the sub-menu itself.\n",
        "\n",
        "default_index=0: Sets the default selected sub-menu item to the first one (\"Modify\").\n",
        "\n",
        "styles: Dictionary to style the sub-menu.\n",
        "\n",
        "\"icon\": Sets the color and font size of the icons.\n",
        "\n",
        "\"nav-link\": Styles for the navigation links (sub-menu items).\n",
        "\n",
        "\"nav-link-selected\": Styles for the selected navigation link."
      ],
      "metadata": {
        "id": "sIc5zz7NGpOy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "if menu == 'Database':\n",
        "\n",
        "  Database_menu = option_menu(\"Database\", ['Modify','Delete'],\n",
        "\n",
        "                menu_icon=\"list-task\",\n",
        "                default_index=0,\n",
        "                styles={\"icon\": {\"color\": \"orange\", \"font-size\": \"20px\"},\n",
        "                        \"nav-link\": {\"font-size\": \"15px\", \"text-align\": \"left\", \"margin\": \"0px\", \"--hover-color\": \"#FFFFFF\"},\n",
        "                        \"nav-link-selected\": {\"background-color\": \"#225154\"}})"
      ],
      "metadata": {
        "id": "K0Mt0Wo1Ivjz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Second Column Scope\n",
        "\n",
        "scoped to col2, meaning all Streamlit elements defined within this block will be placed in the second column.\n",
        "\n",
        "Checks if the selected menu item is 'Home'.\n",
        "\n",
        "st.header('Welcome to BizCardX'): Displays a header with the text \"Welcome to BizCardX\".\n",
        "\n",
        "home_text: Assigns a brief description of the app to the variable home_text.\n",
        "\n",
        "st.markdown(f\"<h4 text-align: left;'>{home_text} </h4>\", unsafe_allow_html=True): Renders the home_text variable as HTML with specific styling.\n",
        "\n",
        "\"< h4 text-align: left;'> {home_text} < /h4 > \": Formats the text as an H4 header and aligns it to the left.\n",
        "\n",
        "unsafe_allow_html=True: Allows the use of raw HTML in the Markdown content.\n",
        "\n",
        "st.subheader(':orange[About the App:]'): Displays a subheader with the text \"About the App:\", using a custom color (orange).\n",
        "\n",
        "above_text: Assigns a detailed description of the app to the variable above_text.\n",
        "\n",
        "st.markdown(f\"< h4 text-align: left;'> {above_text} < /h4 >\", unsafe_allow_html=True): Renders the above_text variable as HTML with specific styling.\n",
        "\n",
        "\"< h4 text-align: left;'> {above_text} < /h4 >\": Formats the text as an H4 header and aligns it to the left.\n",
        "\n",
        "unsafe_allow_html=True: Allows the use of raw HTML in the Markdown content.\n",
        "\n",
        "st.subheader(\":orange[Technologies Used:]\"): Displays a subheader with the text \"Technologies Used:\", using a custom color (orange).\n",
        "\n",
        "tech_text: Assigns a description of the technologies used in the app to the variable tech_text.\n",
        "\n",
        "st.markdown(f\"< h4 text-align: left;'> {tech_text} < /h4>\", unsafe_allow_html=True): Renders the tech_text variable as HTML with specific styling.\n",
        "\n",
        "\"< h4 text-align: left;'> {tech_text} < /h4>\": Formats the text as an H4 header and aligns it to the left.\n",
        "\n",
        "unsafe_allow_html=True: Allows the use of raw HTML in the Markdown content."
      ],
      "metadata": {
        "id": "kdcyV0OwZ29q"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "with col2:\n",
        "    if menu == 'Home':\n",
        "        st.header('Welcome to BizCardX')\n",
        "        home_text = ('This app helps you extract and manage business card details efficiently.')\n",
        "        st.markdown(f\"<h4 text-align: left;'>{home_text} </h4>\", unsafe_allow_html=True)\n",
        "        st.subheader(':orange[About the App:]')\n",
        "        above_text = ('''BizCardX is a Streamlit web application designed for extracting information\n",
        "                     from business cards. It utilizes OCR (Optical Character Recognition) to extract\n",
        "                     text from uploaded images of business cards. The extracted details are then processed\n",
        "                     and organized into categories such as name, designation, contact information, company\n",
        "                     name, email, website, address, etc. Users can upload images of business cards, and the app\n",
        "                     extracts relevant information for storage and management.')\n",
        "                    ''')\n",
        "\n",
        "        st.markdown(f\"<h4 text-align: left;'>{above_text} </h4>\", unsafe_allow_html=True)\n",
        "        st.subheader(\":orange[Technologies Used:]\")\n",
        "        tech_text =(''' The app is built using Python and several libraries, including Streamlit for the web\n",
        "                    interface, EasyOCR for optical character recognition, and SQLAlchemy for database operations.\n",
        "                    The user interface is designed to be intuitive, allowing users to easily upload business card images,\n",
        "                    extract details, and manage the stored data. ''')\n",
        "        st.markdown(f\"<h4 text-align: left;'>{tech_text} </h4>\", unsafe_allow_html=True)"
      ],
      "metadata": {
        "id": "trcApdxIahfg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "This section of the code is essentially building the home page of the Streamlit app, providing users with an overview of the app's purpose, features, and the technologies used. The use of columns helps in organizing the layout, and the menu options guide the user through different functionalities of the app."
      ],
      "metadata": {
        "id": "7UL2hVPMaiml"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Menu Check for 'Upload'\n",
        "\n",
        "If the selected menu item is 'Upload'. If it is, the code inside this block will be executed.\n",
        "\n",
        "Initializes a variable path as False. This will later be used to check if an image has been successfully uploaded.\n",
        "\n",
        "Creates two equally sized columns (col3 and col4) within the upload section. These columns will be used to organize the layout of the elements.\n",
        "\n",
        "Within col3, a file uploader widget is created using st.file_uploader which allows users to upload files of types jpg, png, and jpeg.\n",
        "\n",
        "Checks if a file has been uploaded. If a file is uploaded, the following code inside this block will execute.\n",
        "\n",
        "Constructs the path where the uploaded file is expected to be saved using os.getcwd(), which gets the current working directory, and appends the subdirectory and filename.\n",
        "\n",
        "Opens the uploaded image using Image.open.\n",
        "\n",
        "Displays the image in col3 using col3.image.\n",
        "\n",
        "Sets path to True, indicating that the image path is valid.\n",
        "\n",
        "Creates two buttons, one labeled \"Extract\" and another labeled \"Upload\".\n",
        "\n",
        "Checks if the \"Upload\" button has been clicked. If it has, the following code inside this block will execute.\n",
        "\n",
        "Verifies if path is True to ensure an image has been uploaded and its path is valid.\n",
        "\n",
        "Calls the extract_text function with image_path to extract text from the image.\n",
        "\n",
        "Processes the extracted text using process_text function to structure the extracted details into a dictionary.\n",
        "\n",
        "Stores the processed details in the database by calling store_data function, which returns a DataFrame df.\n",
        "\n",
        "Displays the DataFrame using st.write.\n",
        "\n",
        "Displays a success message using st.success indicating that the data has been uploaded successfully."
      ],
      "metadata": {
        "id": "nKG1eMX0aqaT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "    if menu == 'Upload':\n",
        "\n",
        "        path = False\n",
        "        col3,col4 = st.columns([2,2])\n",
        "        with col3:\n",
        "            uploaded_file = st.file_uploader(\"**Choose a file**\", type=[\"jpg\", \"png\", \"jpeg\"])\n",
        "\n",
        "            if uploaded_file is not None:\n",
        "                image_path = os.getcwd()+ \"/\"+\"Bizcard\"+\"/\"+ uploaded_file.name\n",
        "                image = Image.open(image_path)\n",
        "                col3.image(image)\n",
        "                path = True\n",
        "\n",
        "                extract = st.button(\"Extract\")\n",
        "\n",
        "                upload = st.button(\"Upload\")\n",
        "                if upload:\n",
        "                    if path:\n",
        "                        image_details = extract_text(image_path)\n",
        "                        processed_details = process_text(image_details)\n",
        "                        df = store_data(processed_details)\n",
        "                        st.write(df)\n",
        "                        st.success(\"Uploaded successfully\")"
      ],
      "metadata": {
        "id": "0jqZw0HLbTE3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "This section of the code enables users to upload a business card image, extract text from the image using OCR, process the extracted details, and store them in a database. The user interface is designed to be intuitive, allowing users to upload an image, see a preview of the uploaded image, and upload the extracted details to the database with a single click."
      ],
      "metadata": {
        "id": "KRG7QdsSbR2d"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Column Layout for Instructions\n",
        "\n",
        "Sets up the second column (col4) for displaying information and extracted details.\n",
        "\n",
        "Displays an informational message using st.info with an information icon (\"ℹ️\"). This message provides instructions on how to use the upload and extract functionality:\n",
        "Upload image in JPG, PNG, or JPEG format.\n",
        "Click the \"Extract\" button to extract text from the image.\n",
        "Click the \"Upload\" button to upload the extracted text details to the database.\n",
        "\n",
        "Checks if path is True, meaning an image has been uploaded and its path is valid.\n",
        "\n",
        "Checks if the \"Extract\" button has been clicked. If it has, the following code inside this block will execute.\n",
        "\n",
        "Calls the extract_text function with image_path to extract text from the uploaded image.\n",
        "\n",
        "Processes the extracted text using the process_text function to structure the extracted details into a dictionary.\n",
        "\n",
        "Displays the processed details extracted from the image using st.write. Each field is labeled clearly:\n",
        "Name: The name extracted from the business card.\n",
        "Designation: The designation or job title.\n",
        "Company Name: The company name.\n",
        "Contact Number: The contact number.\n",
        "E-mail: The email address.\n",
        "Website: The website URL.\n",
        "Street: The street address.\n",
        "City: The city.\n",
        "State: The state.\n",
        "Pincode: The postal code."
      ],
      "metadata": {
        "id": "PdioxiucbeSP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "        with col4:\n",
        "                st.info('''i) Kindly upload the image in JPG, PNG or JPEG format.\n",
        "                        ii) Click the \"**Extract**\" button to extract text from the image.\n",
        "                        iii) Click the \"**Upload**\" upload the extracted text details to the database. ''', icon=\"ℹ️\")\n",
        "                if path:\n",
        "                    if extract:\n",
        "                        image_details = extract_text(image_path)\n",
        "                        processed_details = process_text(image_details)\n",
        "                        st.write('**Name** :', processed_details['name'])\n",
        "                        st.write('**Designation** :', processed_details['designation'])\n",
        "                        st.write('**Company Name** :', processed_details['company'])\n",
        "                        st.write('**Contact Number** :', processed_details['contact'])\n",
        "                        st.write('**E-mail** :', processed_details['email'])\n",
        "                        st.write('**Website** :', processed_details['website'])\n",
        "                        st.write('**Street** :', processed_details['street'])\n",
        "                        st.write('**City** :', processed_details['city'])\n",
        "                        st.write('**State** :', processed_details['state'])\n",
        "                        st.write('**Pincode** :', processed_details['pincode'])"
      ],
      "metadata": {
        "id": "BL1zfCdfbeCI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "In summary, this code provides a user-friendly interface for uploading a business card image, extracting text from the image using OCR, displaying the extracted details in a structured format, and giving instructions to the user on how to perform these actions."
      ],
      "metadata": {
        "id": "RJyDSKy-bvg3"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Check if 'Database' is Selected in the Menu\n",
        "if the 'Database' option is selected from the main menu.\n",
        "\n",
        "Reads data from the 'business_card' table in the SQL database into a pandas DataFrame.\n",
        "\n",
        "Displays a header \"Database\".\n",
        "Displays the DataFrame df which contains the business card data.\n",
        "Adds a button labeled 'Show Changes'. (Note: Its functionality isn't defined here.)\n",
        "\n",
        "execute if the 'Modify' option is selected from the 'Database' sub-menu.\n",
        "\n",
        "Creates two columns, modify_col_1 and modify_col_2, each occupying equal width.\n",
        "\n",
        "Displays a header and a select box for selecting a category ('name', 'contact', or 'email') to modify.\n",
        "names is a list of options for the select box.\n",
        "selected stores the category selected by the user.\n",
        "\n",
        "If a valid category is selected (not 'Please select one'), another select box is displayed.\n",
        "select contains 'Please select one' followed by the unique values in the selected category.\n",
        "select_detail stores the specific detail selected by the user for modification.\n",
        "\n",
        "If a specific detail is selected, a header and another select box are displayed.\n",
        "df1 is a DataFrame containing the row(s) where the selected category matches the selected detail.\n",
        "The new select box allows the user to choose a column to modify.\n",
        "\n",
        "If a valid column is selected, it displays the current value in the selected column and asks for the new value via a text input.\n",
        "a stores the current value in the selected column.\n",
        "modified stores the new value entered by the user.\n",
        "\n",
        "If the user has entered a new value, it displays a message showing the change.\n",
        "Adds a \"Commit Changes\" button.\n",
        "When the button is clicked, it executes an SQL update statement to modify the selected detail in the database.\n",
        "Commits the changes to the database.\n",
        "Displays a success message if the changes are committed successfully."
      ],
      "metadata": {
        "id": "b9fGD_iNb_3u"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "    if menu == 'Database':\n",
        "        # Read data from the 'business_card' table into a DataFrame\n",
        "        df = pd.read_sql('business_card', engine)\n",
        "        st.header(\"Database\")\n",
        "        st.dataframe(df)\n",
        "        st.button('Show Changes')\n",
        "\n",
        "        if Database_menu == 'Modify':\n",
        "            modify_col_1,modify_col_2 = st.columns([1,1])\n",
        "            with modify_col_1:\n",
        "                st.header('Choose where to modify the details.')\n",
        "                names= ['Please select one','name','contact','email']\n",
        "                selected = st.selectbox('**Select Categories**',names)\n",
        "                if selected != 'Please select one':\n",
        "                        select = ['Please select one'] + list(df[selected])\n",
        "                        select_detail = st.selectbox(f'**Select the {selected}**', select)\n",
        "\n",
        "                        with modify_col_2:\n",
        "                            if select_detail != 'Please select one':\n",
        "                                st.header('Choose what details to modify.')\n",
        "                                df1 = df[df[selected] == select_detail]\n",
        "                                df1 = df1.reset_index()\n",
        "                                select_modify = st.selectbox('**Select categories**', ['Please select one'] + list(df.columns))\n",
        "                                if select_modify != 'Please select one':\n",
        "                                    a = df1[select_modify][0]\n",
        "                                    st.write(f'Do you want to change {select_modify}: **{a}** ?')\n",
        "                                    modified = st.text_input(f'**Enter the {select_modify} to be modified.**')\n",
        "                                    if modified:\n",
        "                                        st.write(f'{select_modify} **{a}** will change as **{modified}**')\n",
        "                                        with modify_col_1:\n",
        "                                            if st.button(\"Commit Changes\"):\n",
        "                                                # Define the update statement\n",
        "                                                update_statement = (\n",
        "                                                                    update(business_card_table)\n",
        "                                                                    .where(business_card_table.c[selected] == select_detail)\n",
        "                                                                    .values({select_modify: modified})\n",
        "                                                                )\n",
        "                                                # Executing the update statement\n",
        "                                                conn.execute(update_statement)\n",
        "                                                conn.commit()\n",
        "                                                st.success(\"Changes committed successfully!\")"
      ],
      "metadata": {
        "id": "87vzTnPdcX0w"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "In summary, this code allows users to select and modify specific details in the 'business_card' table via an interactive Streamlit interface, facilitating updates to the database with user inputs."
      ],
      "metadata": {
        "id": "hRfJHsnHcW79"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Check if 'Delete' is Selected in the Database Menu\n",
        "if the 'Delete' option is selected from the 'Database' sub-menu.\n",
        "\n",
        "names is a list containing options for selecting the category by which the user wants to delete details.\n",
        "delete_selected stores the category selected by the user from a select box.\n",
        "\n",
        "If a valid category is selected (not 'Please select one'), another select box is displayed.\n",
        "select contains the data from the selected category.\n",
        "delete_select_detail stores the specific detail selected by the user for deletion.\n",
        "\n",
        "If a specific detail is selected (not 'Please select one'), a confirmation message is displayed asking the user if they want to delete the selected detail.\n",
        "col5, col6, and col7 are columns for layout purposes.\n",
        "\n",
        "A button labeled 'Yes I do' is displayed in the first column (col5).\n",
        "delete stores the boolean value (True/False) indicating whether the button has been clicked.\n",
        "\n",
        "If the delete button is clicked, an SQL delete statement is created.\n",
        "delete_query stores the delete statement, which specifies deleting rows from business_card_table where the value in the selected column matches the selected detail.\n",
        "\n",
        "Executes the delete statement on the database using the connection (conn).\n",
        "Commits the transaction to make the changes permanent.\n",
        "Displays a success message indicating that the data has been deleted successfully."
      ],
      "metadata": {
        "id": "u2r0UBVWcagn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "        if Database_menu == 'Delete':\n",
        "            names= ['Please select one','name','email']\n",
        "            delete_selected = st.selectbox('**Select where to delete the details**',names)\n",
        "            if delete_selected != 'Please select one':\n",
        "                select = df[delete_selected]\n",
        "                delete_select_detail = st.selectbox(f'**Select the {delete_selected} to remove**', ['Please select one'] + list(select))\n",
        "                if delete_select_detail != 'Please select one':\n",
        "                    st.write(f'Do you want to delete **{delete_select_detail}** card details ?')\n",
        "                    col5,col6,col7 =st.columns([1,1,5])\n",
        "                    delete = col5.button('Yes I do')\n",
        "                    if delete:\n",
        "                        delete_query = (\n",
        "                                        business_card_table.delete()\n",
        "                                        .where(business_card_table.c[delete_selected] == delete_select_detail)\n",
        "                                        )\n",
        "\n",
        "                        # Execute the delete statement\n",
        "                        conn.execute(delete_query)\n",
        "                        conn.commit()\n",
        "                        st.success(\"Data Deleted successfully\", icon ='✅')"
      ],
      "metadata": {
        "id": "7BZC3I3Zc0mY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "In summary, this code block allows users to select a category (either 'name' or 'email') and then a specific detail within that category to delete from the 'business_card' table. It confirms the user's intention and then executes the deletion, committing the changes to the database and providing feedback to the user."
      ],
      "metadata": {
        "id": "Fkt2oYLhczr1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Overall Summary"
      ],
      "metadata": {
        "id": "uGcPY8bXdENl"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The code is a Streamlit-based code designed to manage business card information efficiently. It allows users to upload, extract, display, modify, and delete details from a PostgreSQL database. Here are the key functionalities:\n",
        "\n",
        "**1. Initial Setup and Configuration**\n",
        "Importing Libraries: The code imports various libraries for image processing (easyocr and PIL), database operations (pandas and sqlalchemy), and building the web application (streamlit and streamlit_option_menu).\n",
        "\n",
        "Database Connection: Establishes a connection to a PostgreSQL database using SQLAlchemy. The business_card table schema is reflected and accessed for subsequent operations.\n",
        "\n",
        "**2. Text Extraction Function**\n",
        "extract_text(image_path): Uses EasyOCR to read text from an image file (business card) and returns the extracted text details as a list.\n",
        "\n",
        "**3. Text Processing Function**\n",
        "process_text(details): Processes the extracted text details, categorizing them into fields such as name, designation, contact, email, website, address, etc. Uses regular expressions to match and extract relevant information.\n",
        "\n",
        "**4. Storing Data**\n",
        "store_data(data): Converts the processed data into a DataFrame and stores it in the business_card table in the PostgreSQL database.\n",
        "\n",
        "**5. Streamlit Web Interface**\n",
        "Page Configuration: Configures the Streamlit page with a title, icon, and layout.\n",
        "\n",
        "Main Menu: Provides a main menu with options: Home, Upload, and Database.\n",
        "\n",
        "**6. Home Section**\n",
        "Displays an introductory message and description of the app.\n",
        "Provides information about the app's purpose and the technologies used.\n",
        "\n",
        "**7. Upload Section**\n",
        "File Uploader: Allows users to upload an image file (business card).\n",
        "\n",
        "Image Display: Displays the uploaded image.\n",
        "\n",
        "Extract and Upload Buttons: Buttons to extract text from the image and upload the extracted details to the database.\n",
        "\n",
        "Instruction Box: Provides instructions for uploading and processing the image.\n",
        "\n",
        "**8. Database Section**\n",
        "Displays the current data stored in the business_card table.\n",
        "Provides sub-menu options to Modify or Delete data.\n",
        "\n",
        "**9. Modify Data**\n",
        "Allows users to select a category (name, contact, email) and specific details within that category to modify.\n",
        "Prompts for new values and commits changes to the database.\n",
        "\n",
        "**10. Delete Data**\n",
        "Allows users to select a category (name, email) and specific details within that category to delete.\n",
        "\n",
        "Confirms the deletion and executes the delete operation, committing changes to the database.\n",
        "\n",
        "**Summary of Functionality**\n",
        "Extracting Information: Uses OCR to extract text from business card images.\n",
        "\n",
        "Processing Data: Categorizes and processes the extracted text.\n",
        "Database Operations: Stores, modifies, and deletes business card details in a PostgreSQL database.\n",
        "\n",
        "User Interface: Provides a user-friendly interface for interacting with the app, including file upload, data display, and database management.\n",
        "\n",
        "This app is designed to help users manage business card information efficiently, leveraging OCR for text extraction and Streamlit for a seamless web interface experience."
      ],
      "metadata": {
        "id": "hJisU6mSdHrd"
      }
    }
  ]
}