Data extraction Python libraries.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "view-in-github"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/ashishkumar30/ML-AI-Python-Codes/blob/master/Data%20extraction%20Python%20libraries.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-4dfsSoXlblO"
   },
   "source": [
    "##import all required libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "WiVXz7WCpIom"
   },
   "outputs": [],
   "source": [
    "import re\n",
    "import io\n",
    "import os\n",
    "import sys\n",
    "import PIL\n",
    "import json\n",
    "import time\n",
    "import spacy\n",
    "import fuckit\n",
    "import PyPDF2\n",
    "import tabula\n",
    "import string\n",
    "import pypdftk\n",
    "import secrets\n",
    "import pdfquery\n",
    "import winerror\n",
    "import textract\n",
    "import win32com\n",
    "import requests\n",
    "import pdf2image\n",
    "import pdftohtml\n",
    "import pdfreader\n",
    "import pdftotree\n",
    "import pdfplumber\n",
    "import pytesseract\n",
    "import numpy as np\n",
    "import PDFNetPython\n",
    "import pandas as pd\n",
    "import tesseract-ocr\n",
    "from PIL import Image\n",
    "from logging import *\n",
    "from io import StringIO\n",
    "from tika import parser\n",
    "import pytesseract as pt\n",
    "from pprint import pprint\n",
    "from tabula import read_pdf\n",
    "import miner_text_generator\n",
    "from xml.dom import minidom\n",
    "from wand.image import Image\n",
    "from itertools import compress\n",
    "from pytesseract import Output\n",
    "from google.cloud import vision\n",
    "import dateutil.parser as dparser\n",
    "import xml.etree.ElementTree as xml\n",
    "from pdfminer.layout import LAParams\n",
    "from pdfminer.pdfpage import PDFPage\n",
    "from difflib import get_close_matches\n",
    "from pdf2image import convert_from_path\n",
    "from pdfminer.pdfparser import PDFParser\n",
    "from werkzeug.utils import secure_filename\n",
    "from recursive_diff import recursive_diff x\n",
    "from botocore.exceptions import ClientError\n",
    "from win32com.client.dynamic import Dispatch\n",
    "from pdfminer.pdfdocument import PDFDocument\n",
    "from pdfminer.converter import TextConverter\n",
    "from pdfminer.high_level import extract_text\n",
    "from pdfminer.pdfinterp import PDFResourceManager\n",
    "from pdfminer.pdfinterp import PDFPageInterpreter\n",
    "from pdfreader import PDFDocument, SimplePDFViewer\n",
    "from miner_text_generator import extract_text_by_page\n",
    "from win32com.client.dynamic import Dispatch, ERRORS_BAD_CONTEXT\n",
    "from pdfminer.pdfinterp import PDFResourceManager, PDFPageInterpreter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lN7qggo-pKaF"
   },
   "source": [
    "##Filename"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "3YG_eUJ4lc9s"
   },
   "outputs": [],
   "source": [
    "filename=\"bank_statement_ashish.pdf\"\n",
    "image_filename='image.jpg'\n",
    "pdffilename='nlp_research.pdf'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "N9qzslQun4Cp"
   },
   "source": [
    "# Tabula\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xBTnsq-ln7aS"
   },
   "source": [
    "Extracting tabular data from tabula"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "kA2KlqqLXKiB"
   },
   "outputs": [],
   "source": [
    "#pip install tabula-py\n",
    "\n",
    "import tabula\n",
    "\n",
    "df= tabula.read_pdf(filename, pages=\"all\",\n",
    "                    multiple_tables=True,\n",
    "                    guess=True, stream=False)\n",
    "print(\"output is\",\"*\"*40)\n",
    "\n",
    "print(\"Length of dataframe/data is\",len(df),\"\\n\")\n",
    "print(df[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kaeRnGUTpU9c"
   },
   "source": [
    "##combination of Pdfminer pdfplumber and pypdf2 to extract tabular data and string data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "u9UTZWEoXKkh"
   },
   "outputs": [],
   "source": [
    "# pip install PyPDF2\n",
    "# pip install pdfplumber\n",
    "\n",
    "import PyPDF2\n",
    "import pdfplumber\n",
    "\n",
    "# @reading files\n",
    "\n",
    "#table_settings={\"vertical_strategy\": \"lines\", \"horizontal_strategy\": \"lines\"}\n",
    "\n",
    "\n",
    "def reading_list_data(filename):\n",
    "    with pdfplumber.open(filename) as pdf:\n",
    "        data = ''.join([page.extract_text() for page in pdf.pages])\n",
    "    pages = PyPDF2.PdfFileReader(open(filename, 'rb')).numPages\n",
    "    pdfdata = [pdfplumber.open(filename).pages[y].extract_table() for y in range(pages)]\n",
    "    converting_data = lambda input_data: [item for sublist in pdfdata if sublist != None for item in sublist if\n",
    "                                          item != None]\n",
    "    clean_data = converting_data(pdfdata)\n",
    "    list_of_list = []\n",
    "    for single_list in clean_data:\n",
    "        clean_list = []\n",
    "        for word in single_list:\n",
    "            if word == None:\n",
    "                word = \"None\"\n",
    "                clean_list.append(word)\n",
    "            else:\n",
    "                clean_list.append(word)\n",
    "        list_of_list.append(clean_list)\n",
    "    return list_of_list, data, pdfdata\n",
    "\n",
    "tabular_data,string_data,string_data_2=reading_list_data(filename)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IpyjDFOkqpM6"
   },
   "source": [
    "##Pytessract"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1X701Smdqu06"
   },
   "source": [
    "Getting data from image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "skKj9VS6rB4P"
   },
   "outputs": [],
   "source": [
    "# pip install pdf2image\n",
    "# pip install pytesseract"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "FRd9ansMrRnT"
   },
   "outputs": [],
   "source": [
    "import pytesseract\n",
    "from pdf2image import convert_from_path\n",
    "\n",
    "custom_config_lstm = '-c preserve_interword_spaces=1 --oem 3 --psm 1'\n",
    "for page in convert_from_path(image_filename):\n",
    "    data= pytesseract.image_to_string(page, config=custom_config_lstm)\n",
    "    print(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "M4eNvelhrxz5"
   },
   "source": [
    "##Get data from digital image using Textract"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "pBIL-QXsXKnK"
   },
   "outputs": [],
   "source": [
    "# pip install textract"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "DjbD_9eRZhb0"
   },
   "outputs": [],
   "source": [
    "import textract\n",
    "\n",
    "text = textract.process(image_filename, method='tesseract', encoding='ascii',language='eng')\n",
    "print(text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-xRiHqnUZiJZ"
   },
   "source": [
    "Converting Pdf to image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ehbUNfx6Zhey"
   },
   "outputs": [],
   "source": [
    "from pdf2image import convert_from_path\n",
    "import pdf2image\n",
    "\n",
    "def pdf_to_img(pdf_file):\n",
    "    return pdf2image.convert_from_path(pdf_file,600)\n",
    "\n",
    "\n",
    "def ocr_core(file):\n",
    "    text = pytesseract.image_to_string(file)\n",
    "    return text\n",
    "\n",
    "\n",
    "def print_pages(pdf_file):\n",
    "    images = pdf_to_img(pdf_file)\n",
    "    plt.figure(figsize=(20,20))\n",
    "    for i in images:\n",
    "        print(i)\n",
    "        plt.imshow(i)\n",
    "        i.save('out.jpg', 'JPEG')\n",
    "\n",
    "    plt.show()\n",
    "    for pg, img in enumerate(images):\n",
    "        print(ocr_core(img))\n",
    "\n",
    "\n",
    "print_pages(image_filename) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VWUdJKZ_Zxa-"
   },
   "source": [
    "## Covert Image data to string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "0yDQZ89pZy9U"
   },
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "data=pytesseract.image_to_string(Image.open(image_filename))\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TX2bM2DqZ1W4"
   },
   "source": [
    "## Reading files of Image PDF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "_72S6VRIZ1nl"
   },
   "outputs": [],
   "source": [
    "from pdf2image import convert_from_path\n",
    "\n",
    "pages = convert_from_path(filename, 500)\n",
    "i=1\n",
    "for page in pages:\n",
    "    page.save('out'+str(i)+'.jpg', 'JPEG')\n",
    "    text = pytesseract.image_to_string(Image.open('out'+str(i)+'.jpg'))\n",
    "    #print(text)\n",
    "    i=i+1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Px5-Jecqs1yb"
   },
   "source": [
    "##Read File usig pdfplumber"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Lzr8STduZ7RG"
   },
   "outputs": [],
   "source": [
    "import pdfplumber\n",
    "with pdfplumber.open(filename) as pdf:\n",
    "    pages=pdf.pages\n",
    "    for page in pdf.pages:\n",
    "        text=page.extract_text()\n",
    "        print(text)\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7QT4M9sMtFa1"
   },
   "source": [
    "## Read Heavy / Large fle in few seconds Optimize code of pdfminer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Ja4TrjVOaNpS"
   },
   "outputs": [],
   "source": [
    "import io\n",
    "from pdfminer.converter import TextConverter\n",
    "from pdfminer.pdfinterp import PDFPageInterpreter\n",
    "from pdfminer.pdfinterp import PDFResourceManager\n",
    "from pdfminer.pdfpage import PDFPage\n",
    "\n",
    "\n",
    "def process_file(pdf_path):\n",
    "    resource_manager = PDFResourceManager()\n",
    "    fake_file_handle = io.StringIO()\n",
    "    converter = TextConverter(resource_manager, fake_file_handle)\n",
    "    page_interpreter = PDFPageInterpreter(resource_manager, converter)\n",
    "    \n",
    "    with open(pdf_path, 'rb') as fh:\n",
    "        for page in PDFPage.get_pages(fh, caching=True, check_extractable=True):\n",
    "            page_interpreter.process_page(page)\n",
    "        text = fake_file_handle.getvalue()\n",
    "    # close open handles\n",
    "    converter.close()\n",
    "    fake_file_handle.close()\n",
    "    if text:\n",
    "        return text\n",
    "data=process_file(filename)\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IQ1dK2VFtTQh"
   },
   "source": [
    "## Read pdf fie from tika"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "q01uxiaQaPy0"
   },
   "outputs": [],
   "source": [
    "from tika import parser\n",
    "parsedPDF = parser.from_file(\"testing.pdf\")\n",
    "#print(parsedPDF['content'].strip())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EzCCXGSBlHNQ"
   },
   "source": [
    "## FITZ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Ir71hvxoaP14"
   },
   "outputs": [],
   "source": [
    "\n",
    "import fitz\n",
    "myfile = 'testing.pdf'\n",
    "doc  =fitz.open(myfile)\n",
    "page=doc[0]\n",
    "text = page.getText(\"text\")\n",
    "#rint(text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "GUwiwHSQlByn"
   },
   "source": [
    "## PYPDF2 making XFA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "FTIPqx9RaUUI"
   },
   "outputs": [],
   "source": [
    "import PyPDF2 as pypdf\n",
    "def findInDict(needle, haystack):\n",
    "    for key in haystack.keys():\n",
    "        try:\n",
    "            value=haystack[key]\n",
    "        except:\n",
    "            continue\n",
    "        if key==needle:\n",
    "            return value\n",
    "        if isinstance(value,dict):            \n",
    "            x=findInDict(needle,value)            \n",
    "            if x is not None:\n",
    "                return x\n",
    "            \n",
    "pdfobject=open('test.pdf','rb')\n",
    "pdf=pypdf.PdfFileReader(pdfobject)\n",
    "\n",
    "xfa=findInDict('/XFA',pdf.resolvedObjects)\n",
    "xml=xfa[5].getObject().getData()\n",
    "\n",
    "\n",
    "#display(xml.decode('utf-8'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "xDNbXmGxaUWh"
   },
   "outputs": [],
   "source": [
    "def extract_text_from_pdf(pdf_path):\n",
    "    resource_manager = PDFResourceManager()\n",
    "    fake_file_handle = io.StringIO()\n",
    "    converter = TextConverter(resource_manager, fake_file_handle)\n",
    "    page_interpreter = PDFPageInterpreter(resource_manager, converter)\n",
    "    with open(pdf_path, 'rb') as fh:\n",
    "        for page in PDFPage.get_pages(fh, \n",
    "                                      caching=True,\n",
    "                                      check_extractable=True):\n",
    "            page_interpreter.process_page(page)\n",
    "        text = fake_file_handle.getvalue()\n",
    "    # close open handles\n",
    "    converter.close()\n",
    "    fake_file_handle.close()\n",
    "    if text:\n",
    "        return text\n",
    "if __name__ == '__main__':\n",
    "    print(extract_text_from_pdf('testing.pdf'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LsCRcfpjkwlT"
   },
   "source": [
    "##PDFminer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "A59nfezkaYY_"
   },
   "outputs": [],
   "source": [
    "from io import StringIO\n",
    "from pdfminer.converter import TextConverter\n",
    "from pdfminer.layout import LAParams\n",
    "from pdfminer.pdfdocument import PDFDocument\n",
    "from pdfminer.pdfinterp import PDFResourceManager, PDFPageInterpreter\n",
    "from pdfminer.pdfpage import PDFPage\n",
    "from pdfminer.pdfparser import PDFParser\n",
    "\n",
    "output_string = StringIO()\n",
    "with open('testing.pdf', 'rb') as in_file:\n",
    "    parser = PDFParser(in_file)\n",
    "    doc = PDFDocument(parser)\n",
    "    rsrcmgr = PDFResourceManager()\n",
    "    device = TextConverter(rsrcmgr, output_string, laparams=LAParams())\n",
    "    interpreter = PDFPageInterpreter(rsrcmgr, device)\n",
    "    for page in PDFPage.create_pages(doc):\n",
    "        interpreter.process_page(page)\n",
    "\n",
    "print(output_string.getvalue())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LeimE_smkqY9"
   },
   "source": [
    "#Pypdf2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "NJKh8wkPaUct"
   },
   "outputs": [],
   "source": [
    "import PyPDF2\n",
    "import collections\n",
    "pdf_file = open('testing.pdf', 'rb')\n",
    "read_pdf = PyPDF2.PdfFileReader(pdf_file)\n",
    "number_of_pages = read_pdf.getNumPages()\n",
    "c = collections.Counter(range(number_of_pages))\n",
    "for i in c:\n",
    "    page = read_pdf.getPage(i)\n",
    "    page_content = page.extractText()\n",
    "    #print (page_content.encode('utf-8'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Zmr4IV-ikjSR"
   },
   "source": [
    "#Textract"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "WUrk6CU2adRp"
   },
   "outputs": [],
   "source": [
    "import textract\n",
    "text = textract.process(\"testing.pdf\")\n",
    "print(text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ZiBC0jE_kZ9_"
   },
   "source": [
    "#Textract"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "SBXqdihlbMV2"
   },
   "outputs": [],
   "source": [
    "import webbrowser, os\n",
    "import json\n",
    "import secrets\n",
    "import pandas as pd\n",
    "import boto3\n",
    "import io\n",
    "import boto3\n",
    "import pytesseract\n",
    "from io import BytesIO\n",
    "import sys\n",
    "from pprint import pprint\n",
    "\n",
    "\n",
    "def get_rows_columns_map(table_result, blocks_map):\n",
    "    rows = {}\n",
    "    for relationship in table_result['Relationships']:\n",
    "        if relationship['Type'] == 'CHILD':\n",
    "            for child_id in relationship['Ids']:\n",
    "                cell = blocks_map[child_id]\n",
    "                if cell['BlockType'] == 'CELL':\n",
    "                    row_index = cell['RowIndex']\n",
    "                    col_index = cell['ColumnIndex']\n",
    "                    if row_index not in rows:\n",
    "                        # create new row\n",
    "                        rows[row_index] = {}\n",
    "                        \n",
    "                    # get the text value\n",
    "                    rows[row_index][col_index] = get_text(cell, blocks_map)\n",
    "    return rows\n",
    "\n",
    "\n",
    "def get_text(result, blocks_map):\n",
    "    text = ''\n",
    "    if 'Relationships' in result:\n",
    "        for relationship in result['Relationships']:\n",
    "            if relationship['Type'] == 'CHILD':\n",
    "                for child_id in relationship['Ids']:\n",
    "                    word = blocks_map[child_id]\n",
    "                    if word['BlockType'] == 'WORD':\n",
    "                        text += word['Text'] + ' '\n",
    "                    if word['BlockType'] == 'SELECTION_ELEMENT':\n",
    "                        if word['SelectionStatus'] =='SELECTED':\n",
    "                            text +=  'X '    \n",
    "    return text\n",
    "\n",
    "\n",
    "def get_table_csv_results(file_name):\n",
    "\n",
    "    with open(file_name, 'rb') as file:\n",
    "        img_test = file.read()\n",
    "        bytes_test = bytearray(img_test)\n",
    "        #print('Image loaded', file_name)\n",
    "\n",
    "    # process using image bytes\n",
    "    # get the results\n",
    "    #client = boto3.client('textract')\n",
    "    AWSAccessKeyId='AKICIO552JQAJCIO552JQOLNRQ'\n",
    "    AWSSecretKey='Lxu6BXFuP0z9Lxu6BLxu6BXFuP0z9uP0UGlzXiuP0UGlzXi'\n",
    "\n",
    "    client = boto3.client(\n",
    "        'textract',\n",
    "         region_name='us-west-2',\n",
    "        aws_access_key_id=AWSAccessKeyId,\n",
    "        aws_secret_access_key=AWSSecretKey,\n",
    "    )\n",
    "\n",
    "\n",
    "    response = client.analyze_document(Document={'Bytes': bytes_test}, FeatureTypes=['TABLES'])\n",
    "\n",
    "    # Get the text blocks\n",
    "    blocks=response['Blocks']\n",
    "    #pprint(blocks)\n",
    "\n",
    "    blocks_map = {}\n",
    "    table_blocks = []\n",
    "    for block in blocks:\n",
    "        blocks_map[block['Id']] = block\n",
    "        if block['BlockType'] == \"TABLE\":\n",
    "            table_blocks.append(block)\n",
    "\n",
    "    if len(table_blocks) <= 0:\n",
    "        return \"<b> NO Table FOUND </b>\"\n",
    "\n",
    "    csv = ''\n",
    "    for index, table in enumerate(table_blocks):\n",
    "        csv += generate_table_csv(table, blocks_map, index +1)\n",
    "        csv += '\\n\\n'\n",
    "\n",
    "    return csv\n",
    "\n",
    "def generate_table_csv(table_result, blocks_map, table_index):\n",
    "    rows = get_rows_columns_map(table_result, blocks_map)\n",
    "\n",
    "    table_id = 'Table_' + str(table_index)\n",
    "    \n",
    "    # get cells.\n",
    "    csv = 'Table: {0}\\n\\n'.format(table_id)\n",
    "\n",
    "    for row_index, cols in rows.items():\n",
    "        \n",
    "        for col_index, text in cols.items():\n",
    "            csv += '{}'.format(text) + \",\"\n",
    "        csv += '\\n'\n",
    "        \n",
    "    csv += '\\n\\n\\n'\n",
    "    return csv\n",
    "\n",
    "def main(file_name):\n",
    "    global table_csv\n",
    "    table_csv = get_table_csv_results(file_name)\n",
    "\n",
    "    output_file = 'output_.csv'\n",
    "\n",
    "    # replace content\n",
    "    with open(output_file, \"wt\") as fout:\n",
    "        fout.write(table_csv)\n",
    "\n",
    "    # show the results\n",
    "    print('CSV OUTPUT FILE: ', output_file)\n",
    "\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    file_name = sys.argv[1]\n",
    "    \n",
    "    main('ebcaadbc98a2af17479493e1d4fed601d496d1c142d3a9.jpeg')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "UHkKqcljl5Pq"
   },
   "source": [
    "## ** Common Libraries install using pip in Requirments.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "L35Kt3jCbN4h"
   },
   "outputs": [],
   "source": [
    "pdfplumber\n",
    "PyMuPDF\n",
    "pdf2image\n",
    "botocore\n",
    "Keras\n",
    "lxml\n",
    "pandas\n",
    "fuckit\n",
    "imutils\n",
    "wheel\n",
    "tabula-py\n",
    "Pillow\n",
    "numpy\n",
    "flask\n",
    "PyPDF2\n",
    "pytesseract\n",
    "filecache\n",
    "python-poppler\n",
    "opencv-python\n",
    "pdfminer\n",
    "pdfquery\n",
    "Flask\n",
    "spacy\n",
    "scikit-image\n",
    "google-cloud-vision"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qDKu84eamIM7"
   },
   "source": [
    "## ** Commands using termainal\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "mRiAgyFtbmlF"
   },
   "outputs": [],
   "source": [
    "python3 -m spacy download en_core_web_sm\n",
    "sudo apt-get install python-poppler\n",
    "sudo apt-get install tesseract-ocr\n",
    "sudo apt-get install -y poppler-utils\n",
    "sudo apt-get install poppler-utils\n",
    "python3 setup.py bdist_wheel\n",
    "twine upload dist/*"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "authorship_tag": "ABX9TyO6RNUEY/y/PuUYfuFBr6DO",
   "collapsed_sections": [],
   "include_colab_link": true,
   "name": "Data_extraction Python libraries.ipynb",
   "private_outputs": true,
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}