License Processor .ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## To run this code You need a Google Vision API Credentials and AWS S3 Acess Key and Secret Access Key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os, io\n",
    "from google.cloud import vision_v1 as vision\n",
    "from google.cloud.vision_v1 import types\n",
    "import pandas as pd\n",
    "import cv2\n",
    "import numpy as np\n",
    "import json\n",
    "import re\n",
    "import matplotlib.pyplot as plt\n",
    "from PIL import Image, ImageDraw, ImageFont\n",
    "import imagehash\n",
    "from enum import Enum\n",
    "from termcolor import colored\n",
    "import boto3\n",
    "from botocore.client import Config\n",
    "import uuid\n",
    "%matplotlib inline\n",
    "\n",
    "os.environ['GOOGLE_APPLICATION_CREDENTIALS'] = r'Demz_vision_API_token.json'  # GOOGLE API Credentials"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Path to the two License\n",
    "Driver_License = 'test2.jpg'\n",
    "PCO_License = 'test1.jpg'\n",
    "FOLDER_PATH = 'C:\\\\Users\\\\USER\\\\Desktop\\\\NEW_DEMZ\\\\OCR\\\\OCR_Works\\\\Google\\\\images'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Google Client\n",
    "client = vision.ImageAnnotatorClient()\n",
    "crop_hints_params = vision.CropHintsParams(aspect_ratios=[1.77]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# AWS S3 Client"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can replace these fields with your own\n",
    "with open('configfile.json') as f:\n",
    "    data = json.load(f)\n",
    "\n",
    "ACCESS_KEY_ID = data['demz-license-user-access-key'] # AWS Secret Key ID\n",
    "ACCESS_SECRET_KEY = data['demz-license-user-secret-access-key'] #AWS Access Secret Key\n",
    "\n",
    "# Bucket Names\n",
    "pco_BUCKET_NAME = 'pco-license'\n",
    "driver_BUCKET_NAME = 'drivers-license'\n",
    "user_BUCKET_NAME = 'license-user'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Get License Response from GOOGLE API"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Drivers License response\n",
    "with io.open(os.path.join(FOLDER_PATH, Driver_License), 'rb') as image_file1:\n",
    "        content = image_file1.read()\n",
    "content_image = types.Image(content=content) # Reading the Image Content\n",
    "Drivers_response = client.text_detection(image=content_image) # Text Detection \n",
    "Drivers_response_face = client.face_detection(image=content_image) # Face Detection \n",
    "Drivers_texts = Drivers_response.text_annotations # Text Response\n",
    "Drivers_faceAnnotations = Drivers_response_face.face_annotations # Face Response"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# PCO License response\n",
    "with io.open(os.path.join(FOLDER_PATH, PCO_License), 'rb') as image_file1:\n",
    "        content = image_file1.read()\n",
    "content_image = types.Image(content=content) # Reading the Image Content\n",
    "PCO_response = client.text_detection(image=content_image) # Text Detection \n",
    "PCO_response_face = client.face_detection(image=content_image) # Face Detection \n",
    "PCO_texts = PCO_response.text_annotations # Text Response\n",
    "PCO_faceAnnotations = PCO_response_face.face_annotations # Face Response"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Crop Both License Images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_crop_hint(crop_hints):\n",
    "    \"\"\"Detect crop hints on a single image and return the first result.\"\"\"\n",
    "    with io.open(crop_hints, 'rb') as image_file1:\n",
    "        content = image_file1.read()\n",
    "        \n",
    "    image = vision.Image(content=content) # Read the content from the image\n",
    "    \n",
    "    image_context = vision.ImageContext(crop_hints_params=crop_hints_params)\n",
    "\n",
    "    response = client.crop_hints(image=image, image_context=image_context)\n",
    "    hints = response.crop_hints_annotation.crop_hints\n",
    "\n",
    "    # Get bounds for the first crop hint using an aspect ratio of 1.77.\n",
    "    vertices = hints[0].bounding_poly.vertices\n",
    "\n",
    "    return vertices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def crop_Driver_hint(image_file):\n",
    "    \"\"\"Crop the image using the hints in the vector list.\"\"\"\n",
    "    vects = get_crop_hint(image_file)\n",
    "#     response_face = Drivers_response_face\n",
    "    faceAnnotations = Drivers_faceAnnotations\n",
    "    try:\n",
    "        face_bounds = []\n",
    "        # Getting the vertices of the face detected\n",
    "        for face in faceAnnotations:\n",
    "            face_vertices = (['({0},{1})'.format(vertex.x, vertex.y) for vertex in face.bounding_poly.vertices])\n",
    "            face_bounds.append(face_vertices)\n",
    "        bound_1 = face_bounds[0][0]\n",
    "        bound_2 = face_bounds[0][2]\n",
    "        bound_1 = eval(bound_1)\n",
    "        bound_2 = eval(bound_2)\n",
    "\n",
    "        im = Image.open(image_file)\n",
    "        \n",
    "        # Crop out the face\n",
    "        im2 = im.crop([bound_1[0], bound_1[1],\n",
    "                      bound_2[0] - 1, bound_2[1] - 1])\n",
    "    \n",
    "        print('Saved new image to output-crop.jpg')\n",
    "        return im2\n",
    "    except:\n",
    "        print(\"No Image Detected\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def crop_PCO_hint(image_file):\n",
    "    \"\"\"Crop the image using the hints in the vector list.\"\"\"\n",
    "    vects = get_crop_hint(image_file)\n",
    "    faceAnnotations = PCO_faceAnnotations\n",
    "    try:\n",
    "        face_bounds = []\n",
    "        for face in faceAnnotations:\n",
    "            face_vertices = (['({0},{1})'.format(vertex.x, vertex.y) for vertex in face.bounding_poly.vertices])\n",
    "            face_bounds.append(face_vertices)\n",
    "        bound_1 = face_bounds[0][0]\n",
    "        bound_2 = face_bounds[0][2]\n",
    "        bound_1 = eval(bound_1)\n",
    "        bound_2 = eval(bound_2)\n",
    "\n",
    "        im = Image.open(image_file)\n",
    "\n",
    "        im2 = im.crop([bound_1[0], bound_1[1],\n",
    "                      bound_2[0] - 1, bound_2[1] - 1])\n",
    "        print('Saved new image to output-crop.jpg')\n",
    "        return im2\n",
    "    except:\n",
    "        print(\"No Image Detected\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved new image to output-crop.jpg\n",
      "Saved new image to output-crop.jpg\n"
     ]
    }
   ],
   "source": [
    "# Croped Images\n",
    "Driver_Image = crop_Driver_hint(os.path.join(FOLDER_PATH, Driver_License))\n",
    "PCO_IMage = crop_PCO_hint(os.path.join(FOLDER_PATH, PCO_License))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=63x73 at 0x20AF64B0D68>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Driver_Image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAEIAAABMCAIAAABWPPbPAAAeD2VYSWZNTQAqAAAACAAMAQAAAwAAAAEC1AAAAQEAAwAAAAEEAAAAAQIAAwAAAAMAAACeAQYAAwAAAAEAAgAAARIAAwAAAAEAAQAAARUAAwAAAAEAAwAAARoABQAAAAEAAACkARsABQAAAAEAAACsASgAAwAAAAEAAgAAATEAAgAAAB8AAAC0ATIAAgAAABQAAADTh2kABAAAAAEAAADoAAABIAAIAAgACAAK/IAAACcQAAr8gAAAJxBBZG9iZSBQaG90b3Nob3AgMjEuMSAoV2luZG93cykAMjAyMTowMTowNyAxNzowMzozNAAAAASQAAAHAAAABDAyMzGgAQADAAAAAf//AACgAgAEAAAAAQAAAUagAwAEAAAAAQAAANgAAAAAAAAABgEDAAMAAAABAAYAAAEaAAUAAAABAAABbgEbAAUAAAABAAABdgEoAAMAAAABAAIAAAIBAAQAAAABAAABfgICAAQAAAABAAAckQAAAAAAAABIAAAAAQAAAEgAAAAB/9j/7QAMQWRvYmVfQ00AAv/uAA5BZG9iZQBkgAAAAAH/2wCEAAwICAgJCAwJCQwRCwoLERUPDAwPFRgTExUTExgRDAwMDAwMEQwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwBDQsLDQ4NEA4OEBQODg4UFA4ODg4UEQwMDAwMEREMDAwMDAwRDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDP/AABEIAGoAoAMBIgACEQEDEQH/3QAEAAr/xAE/AAABBQEBAQEBAQAAAAAAAAADAAECBAUGBwgJCgsBAAEFAQEBAQEBAAAAAAAAAAEAAgMEBQYHCAkKCxAAAQQBAwIEAgUHBggFAwwzAQACEQMEIRIxBUFRYRMicYEyBhSRobFCIyQVUsFiMzRygtFDByWSU/Dh8WNzNRaisoMmRJNUZEXCo3Q2F9JV4mXys4TD03Xj80YnlKSFtJXE1OT0pbXF1eX1VmZ2hpamtsbW5vY3R1dnd4eXp7fH1+f3EQACAgECBAQDBAUGBwcGBTUBAAIRAyExEgRBUWFxIhMFMoGRFKGxQiPBUtHwMyRi4XKCkkNTFWNzNPElBhaisoMHJjXC0kSTVKMXZEVVNnRl4vKzhMPTdePzRpSkhbSVxNTk9KW1xdXl9VZmdoaWprbG1ub2JzdHV2d3h5ent8f/2gAMAwEAAhEDEQA/APVHOaxpc8hrWiXOOgAHcrOf9YujscWnIkjT2se4f5zGOart7GOaN4kNIdrxI+jI/O2qJc7xPwn+P/nxJTUH1i6QeLnGYj9Fb34/wSX/ADi6SeLX6xH6G7vx/glbl08kz245/wDJf9BiRL+8/Kfw/wCpr/z0lNT/AJxdJPFlh/6zd3/60m/5xdJ/0ln/AGzd4T/olb3Onkn4Hz/8l+jrS3O8Z18ede39Z/8A4GlSmp/zi6T/AKSz/ti7t/1pI/WLpImbLNJn9Bd25/wKubjAh0+BJ+4/9VYlud4kfE8afnf1W+96VKan/OHpUxvtmYj0Luef9Cm/5x9J59Szif5i7j/tlXg15EyR5E/cn2u/eP3pKaH/ADi6V+/b3/wF/bn/AAKX/OPpP+kt7f4C/v8AR/wKv7X/AL35VCXDQk/M/wCv+d/22kpp/wDOPpMxvtmSP6PfyOf8Cl/zj6T/AKS3if6Pfx4/zKubneJ5/Ef6/wDpVVuoZwwcK7Ls3PFLC/bXLnHt7G/nuc53t/8AAmI0pH/zj6T+/bpz+r39/wDrKf8A5x9J/ft5j+j38/8AbK5C76/Zzd7xT7Tb6OOGkn1DP0ats+s+tv8ASH1/zH+Et9REH16eW0CzeLMg7RW0nVrS5r763/n4zXt2/av8J/LRod1nFL9wn6w/756v/nH0n9+3mP6Pfz/2ykPrH0n/AElupgfoL+f+2Vy5+u2O4kDJ2w31Hix5Y5tYLQ2wtdsdts3s9L/SqGd9ecvp2TfW1hv+ylv2hj94PuMNqbuP9Itb/MVbP0v85/NJcI7/AJqE5dYEeNw/757fFzcXLYX41gsAMOA5af3bGH31u/ro6A1rTcLY98RPcjnaSjpq9//Q9Ss48+3j/ZQtPER+Ef8AkP8Az6i2fR8u/gsn6xdH/bfRcrpRt+z/AGoMHqlm+C17Lh+j3V73O9L6Hqfo06IBIEjwgnWW/CO9KcDqvUer9d61d0Po9/2fHxpbk3tdtJLfbc6yxn6TY1/6L0q/p/8AFoV31L6n0+s5fR+q2WZVY3GuSwv04r/SWsc53+DquYuZq+qtVfWndG6hlYuIafbRkWYoLbBta2refXq/nmN9Vj32P/T+pStTqP8Ai5xenUPzszqWNVVXuO04IG4u2llVbPtfvs/R/o/3PUetiRx4jjx48ohGUY+n2fd+8cX6Upfp8a2z2et+qvXv21042WhrcvHcK8hrNJkfo7mN/N9Vn6NrP9L6iJ1LrowbM2s0h5w8WrK3b9of61l2L6H0H+ns+z/o7P8AhFxn1J+qt2Xn4/1hdZVjV4VpbXTVRt9Uw5tmvqba9r7PS+j/ANQt36w5+NjdcH2jpFPUKMPCGTk5RqDrqqT9r3ejfaPQbWz7NspxrH1/abb/ANF/hFUz4MUeZnCHqA9RgDwe3L9LHGUvmTZrs3/+eXR91EsyNuW53oP9L2vqaW1/bW7XF32S2x9dFbnN9b/Cel6H6ZCb9fOhGtltoyKGOD3udbVtDAytuazfD3bnZVFteRj1Uerb6f8AOV1LOb1voVdl/wBu6NXTfVkZF4LK6S0Ppb+t3WX7vSZl07aKLvf+lvy8b0vV/wAGIfWz6uAfbLOhANY2puKWsxza71q31WVeiXMdU1lGE7Cr/wBMyj7P7PoJo5eJ/wAjkPlOH6Xy0i25X1fpPVeqYtOIOo1W5jwzJi+3Groca8nIa22llrq3ZV32N7v0DPStZ+m9b/TRp6n0sYWLl5WR1Kn7U64GtmVbb6VdF32CzJyHSzbT6z8f6PqWb8j+b9Oq2xNndT6Z0rNZ9k6RQRjVYbsTNZS0ChmbbdVa253ttxv8I/Hrq+nZZ+kQ8Trv1b3YDj0asW5uQxzLaa6C0ZDRQ27LZr6v6vfm0s9T+kbPWyf8GgcAIuOKfD/eHFtKZH8v3E2wt690o0F2PZ1ey+WOGNZkWVE0ONTftr7Wudsw3faKm72P+0Pt/wAH+etX/nv0Sutu2vK2AB7f0RkY0ezqWrt/2N7P8L/SfZ/MeqsvK670vGz8nHy+lYd+LhXmmmqlrPtFZxq2ehlWVXBtNWK71W4tGR6lP2b9F/pVJ31i6DiMya8zoza7WvybbWVVVGtzRfZ022573O277MminEyt35767/5lH2ImqwzJltU4/pdP8FV+L2ZGsH4aeXl/3z/t1Zn1ipF/1f6lW8PsZbjWeyqC5zY4Z6ns32f6R/8A1tQ6N16rrRu9HGtprpFe992wS+xjcn0BUx77fYy1nvc30rUX6wsdb9X+p1t1dZiXAAODJLmOb/Ou2sZu/wBK7/raqyhKB4ZCj2U+UUU2ZVzxi47b8e708dtVTrfTc1zmxiUXubken0nEuZvzMnfj/abfU9Ndvi9JvD4ytHCGPsgeo5reAzbLaaW/4Krf6da5jpPVGYFtjX1uubYyn9Kxxqr9Gkv334lOz2dMxWvc1mTsr+1v3/4Wxd9VlY2cwvrBLhE17tfd7tD9F7dHe9qIMogmI/wv3WOQhKURM96jtx+bk5vQjc6tlQ+0sHva+wtFlTx/habNv6Oz/RW1+9czm9D6i/1KcoOdlU3OFVjGFhd7Q/7RjNc7Zl9Q6jSffnZL9mLZVZ/o13Tr/QaXOZugOMAmTGsfyVxOV9Z8jIy7aqv0oqsl9gfvc+wB5+w4tbmfotn0r8nf6FGP6yBlOQs69OL9IpjCEJVHTS+H9EPqWLJZW54h5Y32kyRoPbu/P/rqwq2I4upqJIMsaTtJI1aP9f0ispjI/wD/0fUrSdun+v8A5FC7eUfh/wCQ/wCnah9Tuspx2vrMO3ga6zofzfzlnu6le9gYQAXva0WM0I3Oax7vzvftd9P8xSRxykLHdBK/Wvq903rNYGYwi6sba76/bY0HXZ3Y9rv9A9vs+msXH/xd9Mrua/Jy7smpk7atKxA/esZ72s/f9L0l0zqWNJaH26S3+dd4qp1LqPSuk4xy+p5jsSmfa6y50uI/NpraHWXO/wCDqY9SY+azY4cEMsox7D9H+6mm/RRVj0sox6xVVUA2upg2gD91rfzXO/6CRrrO7cwO3tDXaAy3Xa2Pzme5zKWf9cXMYv19+peXcMevqdtbn+1pvNtLD3/n7WNrZ/1x9a6LZWTPqW66z6p7jyUN9bKkjqqSCHMYQ4ODhtBBDvbZ29/+j/4V6G/AwXtLH41LmbBUWGthGxrtzKNpbt9Jj/oV/Q9X9Ig5b/s9IvY+0ua+vTeTILms27XDb9Fy4rq3X+rOPWqKsqxjh1HExcXHpc5tzq3V7rMLp9tbLPs+Te3/ALU7EeGVcQ2uvqp781Vkk7Gkktk7QZ2+6v8A7bd+lr/qKD8bELGh9Nfp1uFjGua2GvA2B7ZHss/wfqf8avOcPqvWMrHwOiW52XQcjqmRRktc9wzKKK2jIp6fbmuY22y276X2hn+D/Qf8EmLfrH1Lp1mHhvy8y3pnV7sW2+vIFGRZjVN9lVmZb9K9z7/T+i9ERPf7EPoTremte9x9Ivtj1HBgJdGrTZtad/7/AP20oOzcCC0VbmuDmuGwah53Wtdu+lvd7rf9NcvOx1m7Nr6fg9Gb1DMxa8d+f1Ei8NznNZbZV9mtzXlm1rLq3+r9n999XoVVemj9VA6pd0u7pPUc+m/rr2vrqrvdXTTjVN/XL/s1Y/R2Ma30/wCd/SZHrp4EPGW3X8lavc19Qx6awynGFbe7G7WN09gG1g/da1v/AEPoKn1vqD8no3UKG0Am3GtYGudoSWEe/wBu1NDdA3RogNBMkAaN9x/1/PTFoIg6z9ym9mB6a+a2y+a22Nvqt+1XC5joBuLfSDnj3Muy21Ptf9lwX+zD6fSzZZ7LLP8Ag9DD6l1KjHrtEHAc4ehbY4GzQP3Wn0ney2/6NGK39HjV/o/U9Ndx6dX+jrPf6LYn/NSNTCI2Njw2iP8ANTY4JDUSr6MEpTOhw8Q6frI/43yPDdQ+s/VcvFNG9tVuYWmyqt43j3bG4tOQ72VW3N/wtTPRpZ/pbFnZuPkYWLdS+puNb6IFrWuYN7D+jOHi+k5zKMd2zdmZNv6zmr0n0KpnYz/Nb/cpemz90H4gf3IHlydTP8ExnkGns8Ou5yg6f4jvdNDhh4wcA1zaaw5oBAB2N02e301cWP0m237R6RcSzaTtPb4fuLYUGSBhKi2Abf/S9G6x/RR/XH5HLGH06/8AjKvL89nP/kVs9Z/orf8AjB+Ryxh/OVePqV/+fGf67lb5f+bPmVp3dbMyKcWnIyryRTjssutI/crDrHx/ZavI8jo3V/rbeOuZmYyuzLE00bXPFNMn0cesyxuxjPd/xnvs/SL1D6yVG/oXVqAQ03YmQxpcQ0bnMcK5c796zYxcLV1NnRqMPBrxbcy41VNFLSQ8FzdN36N1f5r/AOctrWdzEpxERD5ifwbfK48cjI5AeGI/53+C5P8A43NsH/KA449HT/z6uh+qOTm9D6lR9XcvJOXh5jHuwHuBDqrah6luNBc/9Xtq91fv/nf+uKWX199HT6c6nBfe68F3o7w0taAbHkv2v/Mb+4g4dtPUep9Iznj7M7Gy4tFktDS6qzbSPUDd7rrvs9TP66gw5sspx4iOAkxNgbtnPy2GOOXBEiYAnvI+l7XqJP2IyZG+v/q2rnLuj9DzLctj3udfl3i+wst22V5GK1tfq4233Yz6GZNfq7v9NT/wS6HqB/Uz/wAZV/1bVzGaOl5WV1PF9ZzMu04OHlNFTXmHPjFc3dt+0Y9z8uvHyLN++nZV/wAAtbFXti6PqO/91zDu2D9XOlNxPsTvWD33jJGUbXfa/tIHtyhlfT9drGu/M2f9WhZPQOh4+LjVPsvwm0ucym+rIfXc9+Qd17bLW7vtFmVs/Sez/B/mUVKqcDono5jz1Vnot2U5T2urO2wUX9Ma69+57rMi1lz9u3ZU+yn+Z/R3WK67D6bkUWdLw8quo+ocxjMcVudSy0+pU7EDP6K1vrephZdPvZ/O/pKvUrskqP7sdu61Z/1Z6Fk41FVLH0V4jH41dmJa6txrL3faMW+xu71mPv8AV9X1P8J/XR6MHo+FlWZtRFdmPisxi1z/AGUY1bnba2Nd7qmvtot9ax7n+razI/4RV8n6tYWRXY0PdWb3Gy1waIscbMnI35LKzV6+1ua+tvv9no0PU7fq/j22WWOvtm2q6lwcGvAZech9jmh8/p2fbP0d/wDOen+g/m77keE3fAFX4uqQR89fv/1/zEplAxsWnFrfVQ0MqdZZa2poDWM9R281VMYNramvRv8AXVSAaaoXS7f6/wCv/k03+v8Av/78lr2RpS8pTpp8ZTQPj/r4J/8Af/r/AOSSU3uk/wBMHiGO/gttYfSf6YP6jv4f5q3FS5j+c+gXx2f/0/Rusf0Vv9cfkcsYRvr/AOMq/wDPjP8AVq2esf0Vv9cfkdysYH31/wDGVf8AVsVvB/N/UrDu62XjVZdd2La0PrvDq3NcA4e7jc137rveuP6c9uRhtddWDkbPc1w/PA22t930f0jV2j5NjokmToPivM/rTk42F9ZMnAusLOn5zq8g2Vv2+nY5rbsive6W7LLfTyv+vLN5mHFEEbxP4N3k8vBMxPyyH04nVpubYcasUPAki31NgY3xM737vf8A6NXunsqt6xXUG6UtN0ACBt9jZ/d/SW+xce7q3Rb/AFMXIv3YW0gXnLuNlum5wdRHp0+o5a3+L/qjMzrHUAWOddk0V3UundFNL/RfVx+ddeyz+WoMWL9ZGxoPVt/VbnM8wPalwkEn06dP3ntepD9TPH06/wDq2rAdg9Kys5w3ufmY+WzNO2QWW1sxmmjfs2ehbXjYj8nF9R7/AObs+n6eze6hLsUgAlxsrAA5ne3RZWR9TbskZzrHkU9Rc2y+hraxZLBXt9PI2mxv8z7Pd7P0i1sRHti6+eW/92DjnwatfRcOj0n15N7Lcb0a8K/exz8djPWrxcaiaX1uq25eRV+uVZD/AE7P536CsdP6di4NbqcQu9J/pt2ufuE01txWa/v+nX+mVOv6v1tyrsq64+rZbvb6VbKzAfRdtvhm+53qYjdlf81j/pPQRsLpFGFmU30hrasbHrpqqAA3WsHpOzbWMa1nrfZ/1f2fzvq2/wAhTCNUeEI+rZoz8HJNgx767HVH9IJgiXOrk79u5rrWPr3s/R+p+iRmvY4na5pLHGtwBBLXj6VT/wDhv+D+msq76u03Yr8a7KucxzH1MkVxXVZYcm+hrQwep6l3p77nu9X9DT/wvrPb9XcOywWF7mhl5yQ3a0e5wr9X1HV+m+5++ltlV1n6THs9n82nXPsEaOlZfRVHq2MrDg5w3OABbWN9zp/4Kv6aG/MxmODX2BjiwWgOBB2OFljXBsbvczGvt9P+d9On6CXUOkdNsqx8bqPUKMOx9dgposdVW54tAr/mHba3bI/mq6vSf/N2qI+r2RgFhNlpspdvqyGhp2xTbiMiZrayn7RfkU1/4P8AmvT9KtD3CTQrw8U0xd1TprWV2vyGiu1oex5Do2lzqtzvZ+j22V2b/V9P0312er/NKTupdPrLw/IY30rBRbM+yyT7X+36O5j2+t/R/Urs/S/orEBnRxXi/Z25FrQ/0A63awm2vHLrWVWMdLHMyL32X5X+nssTno1YbbW266pr7Kz6ZDHAU1W25bcBzXN/T0facm3fZb+lf/N/QRufYK0bdGTRf6nov3+i81W6OG14AL63eo1jtzWubvRR+P8AFV8bF+z2ZFjrHWvyrPVsc4NaJAFTdldQa3d7ffb/ADmRZ+lsRxHyThdaob3SP6YP6jiPwW4sPpP9MA/ku/gtxU+Y/nPoF8dn/9T0Hr+d0zCxK39Tyhh02WtrZY4EtNha97WOge32se73LPx24OW5j8DPx81jLKy/0bGudG9k/wA26xZn+Nuqx/1Ypexpc2nMrfYR+a0suq3O/t2MYvKem5QwOpYmf6YsOHfXfsnbu9Jzbdm+Hbd21avI8ic3LHJHIRK5DgoGK077Nzq/13+tPV22MyM59NLy4fZ8b9DXBlrmO9P9Lcz/AI62xd7ldJ6Z9fPq3jdR6W2ujOprbRdj6BoNQ/ou7/B2U7/Uwb/oelZ+l/RXfovLPTER4yfvWn9XOv8AUvq5nnL6e8ObYA2/GsBNVrRqz1GtLf0lTvdTc331f8XZYxVz8K5wj+a/58P++Xxnwmw2cj6lZHT33WdSuZVTjDdYyCLD32Or+izd+/v2LoGVVfV36jZvU8utrep9ea3HwaTzVSRuo2x76rKq9/UHP/0n2P8Awilnf4z8TqLa25/QKshtTxYxr8gxubO3c37P72e7+bf+jXM/Wr6x5n1m6g3KyB6FFLSzGxg4vFYcd9rvUdt322u+k/06/wBGyuv/AAajh8J54EmUePpH1Yxwx/xmSeWBgIwjwa3PW+L93/BdL6pfXnq9XU8fF6tmuyOmM3W22ZA9S1gpa69vp3/zznPexlWx/qqt0bqPUuofXTB6k6132vKzai97XHRjnj1Mfnd6LcfdT6X+hWBSBU4ujdLXNj+sIlGwsl+Jl05Vf06LGWtkkAljhYGuLPf7tq1/h/Izx4cvuwAyT4oxvhl6OH+r/W/9JsBfbM8tObdGg3dxGsDcgsY97wxgLnu0AHJP+v8AmLK+rf1g6P1ykVMvGH1MEl2NkOEPk+z7Nf7PV9v/AFz/AIJQ+uP1gq6D0u7Bxr2jrWYPTDqXS7Hq/wAI9zgN1NljfZV/hPf6zP5lURjmJjAAfcvhqQr/AA/9minoH9MzaxuNZI/kEOI/shRpxL7LWh9bq62kGxzwWgNH0vc/avF8bqHU8Wx1mHmX0WP+k+q57HH+ttc3crmX9avrNl4ZwcvqORZjOEPY4gbgfzbLGtbZYz+Q+xXJfDc+wyYyD+kRKMo/4PqVQZfWzqtXWfrDm9QrcX0WPDKJEj06wKay3dG1tmz1v+uInQPrf1joJ9PGtddiEQ7CuO6nv9Furqfpf4B1e/8Awiw0lpfd8RxRxSiJQiBECX9X/ukvq2F9dfqfnY/2jIyH9LuAm7FewvE8u+z2VVuba3d9D/Cf8BWjdD+sv1c+sGW7p2C3Jxsva59JyQ3bYGj3NHp2WbX/AJ68jXaf4q8Ou3ruRnvgu6fjOfUzuX2fo939mr1Wf9cWfzPIYsOHJkE8lxFwF6CX6Mf6ynuqqLbXmuthc/XcB2j2/wBn91J9VlTyyxpa4cj+5UfrDmZGH9TurZVFhqucK622sMOl7663tY7+pasz6ofW7B6l02rpnWcwUdTxZbRk5LhtvrP0GPudtb67P5p/qfpLf5z9NvuVIQyGEsoHFjhL25cNmfy8Xuf3PWinrekf0z+wePkttZfT8K+nIFrtrqy0w9pBmY1/tLTVHPISnYN6BdEaP//V9QycejKofj5FbbqbRtsreA5rgfzXNcucP+Lb6lnjpxE9xff/AOl11CSmwfetfY93pxezx/8AO4EGutPLf+Nn9TP+4Lv+37v/AEsl/wCNn9TP+4Lv+37v/Sy6lJT/APCX/lT/AOOo9Pg8t/42f1M/7gu/7fu/9Kpf+Nn9TP8AuC7/ALfu/wDSq6lJL/hL/wAqf/HVenweW/8AGz+pn/cF3/b93/pVL/xs/qZ/3Bd/2/d/6VXUpJf8Jf8AlT/46r0+Dy3/AI2f1MPOC4/G+7/0qkP8Wf1MHGC4fC+7/wBKrqUkv+Ev/Kn/AMdV6fB5b/xs/qZ/3Bd/2/d/6VTj/Fp9TRxhPHwvv/8ASy6hJL/hL/yp/wDHVenweX/8bT6mTJwHH433/wDpZN/42f1M/wC4Lv8At+7/ANLLqUkf+Ev/ACp/8dV6fB5b/wAbP6mf9wXf9v3f+lVb6V9Svq90fNbndNosx8hoLdwutIc130q7K7LH12M/O97fp/pFvJJmT7/wS9z3+CvVx+5wV/W4kjh8HO6v0HpfWcVuH1Co24zH+oKmvdWC8T7neg6tzvprJ/8AG1+pXfp3/g+R/wCl106Sbh++cP6n3uCz/Ne5w8X6XyKPD1pzujfV/o/Q6X09KxWYrLCHWEFznOI+jvttc+1+zd7Pf7FopJKCfHxHjvj/AEuP5v8AC4kv/9kE7LWpAAAm40lEQVR4nG27Wawm2XEmFhFnye1f71q39t7Z7GI3SbW4SaRECSNTHFIiLMOAIdgDDGwDNmDArx7YMOAHv8yTHwbzMJRaho0RIRmUOB7SljjTJDUtsbl3s5tsdnd111519/vvmXnOiQg/ZNWtouTERd6b90f+J+JExBfrwdnRXESIqDUrEVEFUkA0qCAiqkpEiIiIANDdAUBE8rxMKaUURIQMEJGqiAgiWmuZOaVERKoqIsaYul5mWdF9lbVOVTkpEZ2u4pwDgJRSSqlb6/Q6XRQAyMA/vGyMSVVVU2uCqqqiRTIGCQyiURVjHDOnxN16xhhrrTHu5OQkz3PnPHNMKTFGIkKkPM+aplkulx1xbdvGGL33ZVk2TQMAZVmp6ny2VNXhcNg0jTEGANq2PaU7pdT983T7VLW7g9KjDKgqAFhE7PYsz3oiIgKkAEAqqqoiWMdIRNZmmbeqGmMMLQOId2XmC9HUNAlAsiwLIUwmRz/4wQ9u3Lixu7u7WCym0+kpP3me7+zsPPfcc88++9zFixc3NrYA4ORk5r1HdKqQUkIE56y1HpEfUAkiioiIhIhEKIl/mQcEADy8OzHGiEgwoqqqSkqIiEodo3nhU0rM3KkHADjnvPeLxSLLMiJgZma+d+/ut7/97e985ztvvPn60dHRcrns1MAYU5al9346nXrve73e2njjqaee+s3f/OynPvWpnZ2dlJK1ttt7AKAHF/NDch9VMI7yD5UK928fe+9FpCW9/z0KAATSPaJq6raz0+OUEiIaY0IIVVU1TfPmz376yiuvfO973/vpT1+7t3sPQL3z1tosy7Is614xxqSUZrOZiPZ6PURDRJ/4xCe++IXf/43f/LQxJsuyPM8BIMaoqtbajiVjTGec3SaqKsFDZXvIxuH+EbMikKMsQhJgRkAEoyIckSUQeWMRkVNCxDIvVLVeLDljZv3G1//ff/Ev/uWbr//M56W1PgbeGvc66XWiE5FOXL21NZEkKaEqkoamJZCqqj7w4ee/9KUvffKTn8zzPMYIhEVR5Hnes1WMUURijFVVxRiNMYiIwn+PBwDAg/1dFYNohBEIhVRAWCIqZIasQUW3XC4RcdDvi8hsMkXE0Wj0vR9998tf/uOvfvWrwrC+vt62McY4GAyOJked6LoFOkiw1nIbuuWttYjYNA1zzLJsOV/0er0vfvGLf/iHf3jp0qXuFWZWxU57Y4x5nncAoKq584/C5v37wf5dAAIlThYNdWyIJlRxSIaAhTopN02DiGtraz/96U9feumlf//Nf7e7ezfGWFa5qookVQ0h5INeZ3ydHBDROWet1WUNSIhofAbG1m3LrC7z1NTMPByOP/rRj37ud/6jF198cX190zm3DIuiKLIsa5omy7K2bTsdQzZ/z1oQEQ8ObiFYVQQpGJlV1SIZIGaOLYdoKCMiNOS9R8SrV69++Y/+6Mtf/jIm7VVlf1DF2C5Xs16vLMt8uZoL0ykkdJrdcVUYpwiRVYjQuiAqSD7LgGuOKUZObXrs0uXPfe7zv/mZz166dMnYmGVZZ4S9Xi+EYIxxziG4f+hVqMNjAEADAMDKLFGVFQURgbRXlMAym0yNMW3b/tmf//lX/vzPesPBcDwGQ/PlMnCy3rcpzpaLJAJNpMA2aaaUg8nBZEpeEMGAkoimJB2T3RUcrAxLYfy4un189Cdf+cr//pU/PZxOO4Pu4MR77703xpwCWvfuqeFZUINoVERRBBUAWIRjcgDWYunKFCIRbW9s7u/uffVrf/nNl/+9iKChRb0Yrw2NMbPZpGlaAOmE3kPvvOmghplZBAAAoYkWqFtDAQhVkRMDcw/KXi/UbRtiYcvp/sH/8/VvbG+e+b3Pf/bs2bPOZSGk1arpYgIAwvuICvDgd+f+DKgVSWBEVYUEUQFUUFWJgeOiycqCmb/73e++9NJLv/jFW8ON9aRSDPKosqpbIdcbVdb4bmNOFisL6DqURFLS+zoQMwJgsIDJgDGUBJkQJURRHleDhhtt08Xt86t5/Wdf/j888m/91m9duXIFwaUIiM4ah2BE4qkzOb1bUAtAKmAcJU4KSoacc6DMTWjaZpAPhqPR17/xjZdeeung4MDl+Xw+39jems4OMgQlDCG2S8kzstYLWB2YoBoRO+F0MkkpDbQCUtQWFInQGkQFY8kCNE0taanzNjNFL7MSsQnxX/2rP8rz8uzZ88YYImuMSUnaNvr8H8AUokXUzo9aRQYEsHmkPvvjo6Px9sbN2d5os3fjYP+P/68//bs3vr++McotgLCG/QE3cVZ7D+Myj5FjWFEoBK3jqUECIEQsstJ7H0M7m80ZJlnmHKqmhtqUW0CAFKE2MLRgY7vljIQw3z2uivHaxujmcvov//iPloX9L//pP11O5iNxOWECCRHw/h4RIgGgKthTi0mJFZUMMWvbtiIiIuO1tbqu/+Iv/uLN119LsZ0e7TeLUHlAz73CRRudh9ynRCkgWFBEOmHT6/f71cAYY8AAQAghq8qR57IsvaUUGw4tQlLhlEIyZWn8IC/XBkNhnCzD/mx59eYtcN4Qfe+7r3zkheefu/QEG4uGjDdG+BSguoAaEW3HAwKKKBhEIBVOqtb5lLga9f7utVe+8pV/fe39q8Mqyw08cXHj0vZWbs12IyzBWc4zEA6SogFjkC5sDHu9XlEUpCQiBg0iikhyg6IorLVtbO5vE4qqOnLI2i/yMitXIS4Zru0dvsKTdxMepfjuL978xtf/7w/+t//9ZDH3ZRZT9DZ7lI0uULIPrZ2IVQwCIRJhURSrFLlt/+qv//oXv/i5BRl4e3Fz9KkXnvvgpUsmhYEj0NZZznMx2qAmR2iMcfkYEUGUWR0Z73ODJCLIwRjHBG3wQVQtkbEAkI5QOTpLzIwBy15lN6rWx8WP3pofTCeT+VtvvHbn9s2nHnt82dbkjRXp3NHD0B3APox10YCCKiqSqBpjSfHwePLKq68ASumdk/jUme1nNzcuZs6ibC9XSGJt8BytSQjJGXICHLvYVg2gc5mLwswxcmGAVVrmCALGorOCwAI8WxCIQWhTs2RWLvsIvXVafPBi+8by+OZ8urv3Z//6T//Hf/Y/HU8mj33gsfpw0dlGFzLeT9RObYOVlUAASDXGCKKY25tXb16/eY0ILPAwKz54fmfLUjY76YGqbYwTwdhiYgMAGkidpVynhNbfj6sSIFpjnNNoi8DKQkjGZEYIU4ptDNX6QDmhsomUoy4A2hD8MH8mmvev+9lmMQnta9//4Y33r/lhPpvNjAAznyZVXZTw0DZASUUVAckiSkoirD95/aez+ZxSGubZ9trw7Hg4MjRmLjltElswAkYUUS2SB7CW8qVaIMsKiRUYENE574zN4iyTCMqACgkBEyeJDBjn3DaoSTiywQyUQktFceLdZmb3c3d0slo17vUf/vjz/8kXmqbpYfGocXd69dA2jDFRkohY78lpDCHG+LOf/SzGaFLsj9cGZQEhEmlFwMsl95nQJtCEZIxTmwEV6sqcVgZYFUVESVUVNak6KEpQVkgACSkBgcnJoGvnKsQWnEZg4aQqhEhYGTi/uf6Lu9eHRXEyD3du3nLOTZazwaA6ZeM0ju5sQ1VRIXkEROTURCMNNpbsvffeNaCDIrcp9I2hsDLWLcNqVDjwuNCaPZlqxHY9aW4MYgFWR6wqIigADkBJAaKqAQQoEJHMCmhGqKAeuEjUqIO2Pc5zRI7Mcb30k8UE/Hicu220c6V9k374/tu39vY2+lWMsdfrNU1jrVVVS0ZEOmkQIiIRM4ukU2HdunVrf3+/6hVe2VpyzjhnssKXTkrvkz9hDZAR+kA2OAYyQAiqERDIIKKKACAgIAIho4AokGgCq4ACgqAg6MEmSF4oiiKiAVIgtUIejTOUW5NZXMxnB3d3q3Nny6rfodP9dABUQO19DNau+sD38csaa+3V997Z27/HHMBonvUG/aoocyIQ4MiN5JI0oUPjItpABIRglRP4TtYICNrl04aInBIoKQIbBGOEcoBSoWRuDQpmFctUiBBBEYDUgs2ty62zKJ50OZ3MTibDp57mKCJwahUCqigWgDq0FWBFAERAQEPWm1u3by+WSzGtKHlvyzIngqgpKUdRtY41AxICMooGjBEGVFVU7dwTPoAPQjRkAFRZRFWZNSirJuYI5BEUpVZwoA4oMUclMywH4yFsjI5vzI8t4Wq5mJ9MLNgoAIId2YogKKJsoXtC6IpuiF32HFV1Mj1miYN+RaGWlJg1pQSEWV6U3sxZBAlVJRUsuYGcUKzEhDkCoRpQAVFQBSJlq7IARQVERDBkDQo4sj60oGDIWGRL5FhJkhj1IuDIlEWGxN6REazrejVfZWtDFQBBBRJMCMCknTRUFYUUEQGRhWMURGVVVnUmi2GVWhEGFVJEMMQKGL3twg8tjOakGRohNIayByk/djE/KAEig0Hj0VhrwTgGUgWnahOzcreDFiETjhrYgmfRKGy9SRKToDE5oAnMJViDyF3mBApEqmC7SmG3rqqqMgAgqrV2MBh47zURoe9Vo+FwzboixaZJiQhcQdYaY5CcJSCLaImQwLn79S4ABRRVxM5CfKloEQwgi4hwI8ySWud7KmyQiJxRI2IwSuZyk/m8KDZ3tgZ399LupE5BENA6YxyhVYmqqtgFuPLQiz+4qzEGkbz3o9GoKDNns6xnNjfPrI23rMWwWiUDaK2R5BC9JeO7bFgIBUwyHlREBAAFFVQVBFW1Ts4QOkvWGmctUA5igYuVKIMYVGMMMaEKsnW+rJvWOLtz7szOvaO35820Fp9lvcGgywHvU4uAiALSSQMQQSQgGlVFQWYRxLObF8MCkk9PbK49du7CAJ1vw0ZvnAMLQiyLiM76gWKDdtG0x94UkownNUSGI7crQiRXKGETkuBR6cYULWrN7dEizJwdlWUpJFr4o3koi8FyMimqwlvwjlZHgFmBfkDVaNKKy/vD8TiFQNXaatn2B4MQV5V3vGw9wEMv3qmWqooKMzerejjsD4f9o+mi6vfOX7iQG5E2MpISFFW5Qs3yXIxTEmNLMkbUMcEiNAScoQKSpEQQrMusNxZFUxAViWkSI2Y9tj1Rnyzt7t8NzSqbrVazk43RKDNutlj2835gmwR7VUWIidDnOTqrhMr6wASIiID1UTY634NE4K2LMT722OUnn3h893s/EJG1tTUb5o4KX1oJ9axp7s2nk9mqVRmu9ccbA28hhkWsObctKFcGcqMOoSgADYmig9gu2hTN4XL27v6thcHdg7at3byZLmaT3GBh8Pz25uWzYXPYq4piozdqI2G0m4ORRXJVNVgfqzOIKqiC0IUk3tio6SEbFi0KJuaOzeVqPuj1h8OqzL1wa53xYPt5vyzsZH95fHjw2vvv37h7Z/dk2iIqQp7nw6rMjBuXqfRm4HFjUD62s3V2e+v+NqXl4mS5dzB7b//w9b2DOw2/9d6cIxQFlLl95tLFfr8YbJy1Wd5EVV1523hT2iQFEqV09sz22bM7JrdoEFgR9X5kZY0+Ko3OLxIY5ywRgJSDYfmBZ59++eWXPYlwyxIYZbJYHk6OVnE12l6rzm4931+/O13+7O33jvaPDg/a+eTumoUza3ac43Jcjst8fTjQFA2qctOuprt3rr1/53ivpd2Yr8j119eqftbL8+3Hn7yw1htUdjQsfWp279zoYz7oOZvUp5jF9NT5c2u9QkMjeZ8ssiYiVBUQBMGHbBAZZVHVlJJyApT55OTczhbxanNcWgwoTUjtannScrO2OX7y0uU337/23tH0vXtHBw2soOwPRjk5bA4x63eAiWhSiC5FJYgcDLCFlDljodcm098YolIDGSq9+qM3fm7jhUH+4afOnxnmlijWE8mKXLOxw3Oj6vknLg0thBSTRGMxpeSIILEyGDCPJLHSRVOWUCPwqN+bL2Yf+cgLT144c+nsloNQODSJyRH1PUj7b77+tbdu3JhSPtW+r84tjkIbW8O42V9PSRR9VQ0y8k6g8AZVE5rM4PqoWmdvj9BYd/nCkzfef/9o3vQDzffuXRxnszu79f71p89tPPvkZaa0nB2iGW5U+eNbG8/sbNvVMjduP7aUZSEFlxeYjIhYcg8bUKrYxbrMsWkaMtg0q52dnacev9AvbD2fcGpSs0JIHMLP33rzJ6/97PB40YRwd2//6vWb12/fG29s/c7nv7C5dQ7JE5mq7Od56a3LfWZB8zwnoszZPHOIZnNj6zOf+cwLz19579aNq+9fP3f+/B/8wR9srucnRzA9Obl353ZZZSKRJFa5G+XOcbh3/epkbzdwBNCuzXKaKd1vmiGSUpNARcEHfrIay+391dWftRo+cubMVuZ2LPvF4fn1/uzoZPfmOwfvvh0Vzl9eu/zCh7dvHn/1L1870y++9JmP/KPf+Pjbm+nN779qZ5OxhH4TjbfG5+QrYTuPzRyDM5NLdPQr5y98qGzPPnPx5uMDh/DJ588/vZ2nDz/15g/eWNVsM+pxBblvE2T14rPnL7Y/eu3N+fTxT/7qMxe361SHMmOq+7mDxPIoUiEiofHWYSvShru3bv/NN1/2/ezM2sb59f56n4xJlNiC9vLs/M7mO81BZXCjKj/2wR1Y5Tnkm718dbSHdb0zHqIREiYDeVmQNSG1xves80WWb6+vR3BodLp3e7o/+fVffTGzuD3uN9NZlfkPPbszyO2Fs9uusGotWo+SVXn23r17P/75z2E8fPq3f7ejlx4UpOHRJDayRojGGGQOIc1PJj/6u++Xw/z5S+exlwcNfYyhWXjQjUF/VBblpaf2psft3m65ln36uWcyyGl+/MYrb42N7lSlavDEWebLqsLMZuJEc+My51zZK7KimNQss13XLrcH40FVYFzNDydrpX9i48ncaJHbkGpAVVEDdlhV/aJZ7/eevnSpSytONYqUQB/x4pl1iYMguMx5oLM758/vnG1jnZP1StqEorKikmdWq9x6Nyq29iYHkxAV1HqXkbWCsXJjQ6SWbXLAzrnAYqOCcaxkbI6IhLrWKzKXkpphNpi4fi/3sRbKdNQb9h1wWIAmNmS8aVohYUvm3M7ZT29ufeLFTxwjMRkwltAaQCLER9lAQaNGBdXYRuLw/Nnf+ke/c+36O2eyLHOGgkFUIvLeuswb74T50ubWOWNaziXlDigz1m1Znq1Cs0qmtMBCFKKg9SimiYms9d6Thtxh5kugjGy+VWyJJu15lKawgtKCKRE4JQuIxpjMFYtZXVaDD5w/XwzHRNZaC9YbNCRkFVHlIRvSRrDAKqIcmmU5GH7wox9mr25/tlydoDGrtjVKLaFkFp3p24H1GES9WlsUjozyhFNwuZfUInpCZTRgSm/7KWmKc2tMVfU4LhBMludkCwELCKBos4JZHTID+xxF2ArUgUUc+ixw41y2duZcS84gATkgg0gEiIiEjxQ/c+vAYouAzpsyVwv9Mxujk+3pQT1fhbUzA4a5gdgCQ16qNZYylxsH4FubokKKubfZcBhW3HBIoRsbsIg5JytBnDHCARFVsU2ckbd5FRJmZMlZ7ygGscShlchNbNvCDhi4Sa5puQVjiwrLfnBFVwAhsigPuqT4iBc3gpK4idFnzpdlLaFVkcwenExnxyeXzw0VrJBjVJs746zDQiUiYlEUlOccW4AIqFElcgqSrC+96zuTG8qNt4r1Yp5Sik1IAloNTZmVYA2IvZ8kApnMEwdgEqTYRiJLZJd1FHJ5fwRZLj5XDaexrCqgkirQqckvoVXkMneq3FiaoXe9s4PeE7hWvXt8MBE3jVmUoYVB1toBG+Rg0SJlQbTRWh2QKyQO2maxXMxWs0UKbK3Fwmil0BdELKpS0bUJUrKpMVAXTscMQ9UKAmVgoF6a1EJokMOSQpYVprUuW7+TcL42pHEPU932Bw3a1LSaWjEpuSSU/n/GSIjofiptKC+KZdtefe/a7tFBVlSJObIoYl23XQe5aylZa5GUmdu2Xa1WIuK977r03udojKr6srA+Z9AkooSrtlnWKyD03lpryRg4pYUQgIDMsm7BOnBufXs771WCJIBEZB7UoTsZKMAjwQg9QGK4/4ci5P2qv7lRgx7NlmJNEkqiIsgCXTcVEa2lrmMfY6zrugktILrMIxGrKChYg85KQgByLuv1ev3+UFUXixnXS1ABYVAGVXhQRxNVVpwuV2BdBDxz8WJ/tAbGknEESPCwoq6Iio8ALqABFRJSQo6RBQKqyYuLH3j2zKXLx/XqaLbsK5fGhtj2i0JVFRigq6coADCnEJs8K51V7zNrPSghEaAFjeS8M+CzPElkkRCZuV2sloXzmhqL0SCrCAuIYlJokyxj8oDTtt1eW6eyRJehtaQgXRUMUaVz4vowF+9qh6CKAiqiCk2K1prNi5fKjc3dk6N5GwxwAWIMshpC7trSShHBdDoGAIvVcj5fxpDyvDceba6NN61t67odlOXRyeG16+/cuPF+0zQb6zuXLz1V9ka5BOVIVgCRlVklqYQUI5Vi/CLy/ny55hySIbSETlmwGzFCAABWQXik96cdCIsqgaqitSFGARyd26Fe7/DebZNX0qY2NGVOi2U7KAkpKgcEQEzAAh2HrLdu3Xr/vRsq5ty5i089+cz6+raI3L19Z7Gc3L23t394AADbZy6M1sbj9ZFBK9qiQSDQqCLCAiEJe2Pz7GCxOGlttAbIdHVIEAEgMEgKivd/HioVKxASAKCAAXLWh5iiqi37o+3t9994fRFjQZQYQxLVlDwhWWUGTYhIDwbt8jzf3jqTZ5WzRVH0mia8/vrr9+7urq+v9wflYDgue1lR5ttbZ/OySMLWOw0CkkBjSilwSiqsElkAae/oOPbPuLKHNgfjFAwIEz0ocAN0ePRLJYXuA1ToCNIWAWHVtqP1jdl8fm9vf7TRB8AYuSwy5oaYQQSAEQkf9H62d3aM84P5UsWoUEqwaVzZ64/6o/FaDymEuCiKoix73rs8zyFEiSlRixBDCKwMAArURiaSw8m0N76QVaUUGRlL6Ijj/Yp/1/4DIEJ72gZwIJFAEBxDqYirVd+7xuOkWXzy05/5yz/5k7zoWbQ5hgEqNifBbopD1SUkW8HAUKaWfK61RNMrKPBstiK1Z7YvrK1tpCRpNq3DfLaYm8wMN4bk/KJtWKZrrkyVstbQnkiaebBqc3EGURc178356aevaOnFttZaWbWFAiGSIkdmAiASA3+vpNCh8GkREUQUBUaj0Ud/9cV7e3uP9y/OVrXPuWcdGeZUCwTCHHzP5VlM8WRy0vO+AmLvorNtlNliFpSFIbULxZQscwqToz3nHCPFMDO6WQyNijJDUZSLJu7NZwdtOE5xumhGG5trW1tElFRj21JCZ+9nGg8pf1DDBQA9nRh7kIqoCIoAKvZ7w1/79U//m5e+/MJjOwBQC1gBh0tp5gJLSVlrdFGGKMvpdF+yYrmsD44mizqU1Rh8bBerNqZzl3dm8+N6tuS2RQllXhwvZlfv3F6ns088c3EwAFmuGDEA1AJX7947XGUHJ3j5Q58dbm6ygAFUZecK1aQAgCD32w7wS70/VVTpIBdUuq4NgCIpIuLjTz+zEr51ePz4yM9iZOZhKcRLg02v6ourDk7mN2+9e3xyIzN08fyljXPnttFXvp+7itQgmKYJpenRwKgfhtVq2ei9xeT1mwfYHB7Q8oVnLgySNLMFWw9g9+8c3m6Lu8f8gc9uuLLfhJhZp4zkUdN9dJLTuvOjoWFXPha43yZ/oGYIjGpwtLF97vEnf37zegZbKxO3enll1XGKy3kK2VTzH/781jtX38jt6oVf/1VeW5+TD8d1FuPYp6HvV94dTufTUC9SrIqyKM6wpznF67UJYe7nh2fb9QzAtDrbnxwzxJMwz3Ipe+sXLmFRMtfA0jatUXLOIQEhgAKrkirKLyNV1+l/pOGPAICiaKkaDH/l13/ta//nWz+7dv38wBfFBVev1kAgcl3X92J947ieRruxdW5pq59cvbX3/t353eOeFGeq9TU/zIwPkBrC/fm0XbXNatl6abbzJZo5QONoWjd2ujgD+Wy6unE8WdRpZc3mxSfWLz4GeZYLEbYAkFIwzsl9D/HQjB+xDSDEzp0/sBwFVTBgOClZ+ujHP/nDV751/aevQpsNe1VTLvMelmraALOASy0Pa5TbR2/e2leGUTE4e/aZypXSwHEkVByvjdfW1vogfWPj9OidO2/f1qOeXTljSuMpysn+UVWNa9XdZnUnySLxs5cfr9Y3mqRF7imF3Dtr/H2N6gpS3aTxo7ZBRIj6KFh1bDhjVqEW1YuXLz3zoSvvvPbdyXx1Z2/fnfXcK0HtyWS1v5qLKda2Lo2zFaza5bI+t33pUx//zKVLT2jCuo4xpH5meuvj1WKW1XVz77qh4/Nrw+yxwQ9+cqOntgKbbBaTLAnmFg8RkuD69rYrymXbZj6TGB2itRSxa/L9krt76DeCRAKCLppCyLOsci6cnDSWe1W5nE+XU/nC57704++88sYP/i4bbqwv4eZgZNxw6g967b1fG+L6mWp7cMkbmxK3Kfrpe+nqcTnYWB+ciYhMx3rrTrVatdPbsd196kmfrZ2Hcv3cr/Sak0V7vBptPb03nV9d7jV+yGmF/fUXP/pJOJysl2VPzQpRfDZXlysrixJ1ARUoyKMTPKdjMYSoqt0oLyL6vBRFRQNo1jfPPHvlyivf/ube0WTd+LwaFd4E5l6vvzXon6l66/1+kUKTYh0j5JlYaOwq8nHDYFI0mtb6+ebaBdBymRazGFYn+9ub4yXbWYMI1LCe1M1J29QCm0Vpra2qikWapknIyOysAXk4Zn562Ucf8H6UQgDQNk03cilkWATJiqLNy2evfDSImS+bd65PTTYoc5cW8/Pjvu+V+bByRYaHk4zQDjz08r1Vc+N4/3jJx/MaF1yh3bK4VfL6oB0Ms37ez8lOp8swX56cTGet7q7aKeskSIN0cnT87i/ezl9Yz8uiblv0aPj+OYBT33eauv4S4J4OKSFiNwlcluVJ0zjnlAyDTuaL8ebmmbMXoob92XJjwVXgZjY3mtZ6hdUYGn+BKYmuJB4tD16/desH71y7fbI8WvKOKXPRMaYP7FTPPTm67NcqNHW9DJJPTxZ39g72FnHhshXZljL0fLi///LLL/cGOx944YoQUjcIEiNZPSXyNAH8pST2UfB9yC4nFEZh720IIS+qZ698qGnTZBl3j2dHs2axipNFczJfNS1HIeYSaUBmyFqtGjddwaw1dcTpYrVok/h8sLMzOLMTnZ/H1CQ5mtR3dk9uH83uTueHbWgYCe3Wxk6vrN54/ac//8VbISWyhpkNksb7x0genbfQv4dU3dVpXheuhhByB6DRQMp9ScGqpKeeeuKHr77iy3LZRAL1TNNZs3vvaAjGJbPbiO0V0CvQ2qJcG1Xbi7jgVJ9Z713Y3t4eFIMzRetBMVW+z2T3bx/cOF4ctjwDSpFXEg258+vbxPTmO3def/31Kx//lQuP73AKVQ7OGJbuvAs+ut32USXrhNUdVehOLoQQck9tDLlzHBqVdHR4sDYanNnePNw9Ojo6ajMzzqzh5ijJJO/3bdwcVcFqjE2yfmM8+shzzz0tbtHEc/3+zvbZen4c292ZpvXBiLPR0eFqptkC85QPQmwbZgTMRXsiyoKqb19996233955bBtUU4w5ZfHBJNUpG/hoMNIZg3ayEMmzzHsfQlAJJFKU5WwyDc1i985tS/TE5cfmJ4vp5AgC9rFsIy+kqRexLdMdvbdsm5PlslaswUE28NVagRiWcXI0uXHt/bt7v8ircPbc1sbG+clxPDiYHcxWUwlHy7kaMx6OvKIuF23bVlU1m80ODw/zPOcIMcbciuIj09CnXpxDRCRCAmsTAKta6631gPbOvcOyLPuuBzYcHR1tbo2Q/RtvvTYs/BPPPDZf3qxPblv1hyGlnh5uZ9fc3nni2Wp6tHdQz4QYfJavkmTDURC2UOW5nBzfrmylE1stZsPb7wM384mpmWepma2acUbbMlyLkN87OjdvZtTe9PPr7Z310Xpe68l0snQJo3adPXhwTgURrfeWGVJKpjDdSRZVZWZAcM5lWVbkbrZ3FOplO3ODwvbI/PwHP/rI88+f37iwOHdysn98uKoXAVeUnNfp9N7xMoalGqZMrfdZ3cZ8RSFywtQb2FXdx6KMDSyFT2bTtpm0tteERilYB1mWOWNzJa8QtI7Cbd0SUVVV6+OBGNxfTQrv67ruaGvbNqWUZVk33QairIrMyRAZgxyTEua5twb3DnZf/f53kfQ//v1/DISf/+3f/uE3vznb3ctNdmlzUxeT2Qoh9qeTSkzNMgk8slqUNhexyj7UwUGPQ5qKhkSrNqtb39SMok5DinFZtbFeDXM6UxWDrCzReiUNYRVTi2mwNnr+g1ecc2Dwxo1rWmVZ1Wfm7vDT6RkCQlJj0BhKsbUGvffKSYS9Mwhy69aNr337m1/5xtduHN6DKhcOTz//7MWnnri7v0sNXtjY3BkP1opykG9Y2RAYRy0RkZxnNMvIiyBtMiHYEKwwtIGXEacBZ9GuJG+p0HxIrDnAusvOZtWmcQMlJ7ic1y1RZBxUg9/49GeKvADhO3fufOfbL3eHa7pjMR2ihhBsSgHRiKhgAgBSaNt2tahvXr/x6quvfv3f/tv/8PZPPvmJj3/uP/2DJYjJ7fDxy//kv/tv/uf/4Z/1+WjnybXHzu0sF9TM7LJVVZv5XtSJMSFFbCSp66mlGk2QkGgpatQGzSpQQ0CqhpBGbehbe8n6s0CDBDmhME1rzs8MaRaffPKZDzz9bFfIPHt+53/93/75j7/3ow9/+MOf+MQnNjc3VXW5XMYYrSq3bRsjV+P+tWvX3nrr7dd/8tqPf/za9fevAUBdt+V4/PyLH9s581iCKEaQ04c+9an/7L/+r77yv/zztf4TFzY2n77kmhvT5dEc2ho1zDMGi6KqWaJCpBWhWmMLsBQ1QsLashhQA1x7G9c0ncmyHSebmpwYiFyrmZE7Wq6EzH/xn/+Tge3HxMbQlStXtjfW//Zv//av/uqv1tfXn3zyyY997GMvvvji5uamrZvV4cHJdDr/65f++sc/fu2tt96qlysAWi2Wg8HIGMyif3zrcmxjlXlAaepm2Bv+7ud/791v/bvjW7eGxp5bH0UFW6RrdxfzRb1nhgQmCkeMOZiUaodgNYHNAyQU4qgakkEtJQ6drI1xq+/WDPZUOegsNhM28yy7d3T7U1/83X/8u18gAA4R8rw3HP7e73/xb//Dq8w8n8//5m/+5lvf+tbFixevXLny/wG9DMWyPnI3HwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=66x76 at 0x20AF64B0C18>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "PCO_IMage"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Processing License Text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Processor(Drivers_texts, PCO_texts):\n",
    "    Drivers_contents = [] # Driver contents\n",
    "    PCO_contents = [] # PCO Contents\n",
    "    \n",
    "    # Extract Driver License Contents\n",
    "    for text in Drivers_texts:\n",
    "        Drivers_contents.append(text.description)\n",
    "    \n",
    "    # Extract PCO License Contents\n",
    "    for text in PCO_texts:\n",
    "        PCO_contents.append(text.description)\n",
    "    # The first content in the Text response is a string of all the texts seperated by '\\n'\n",
    "    Driver_String_Content = Drivers_contents[0] # Get the first content \n",
    "    PCO_String_Content = PCO_contents[0] # Get the first content\n",
    "    \n",
    "#     print(PCO_contents)\n",
    "\n",
    "    # Process the PCO License\n",
    "    def Process_PCO_License(PCO_String_Content):\n",
    "        # Using the 'Expiry Date' as a divider\n",
    "        if 'Expire Date' in PCO_String_Content: \n",
    "            new_pco_list = PCO_String_Content.split('Expire Date:')\n",
    "        elif 'Expiry Date:' in PCO_String_Content:\n",
    "            new_pco_list = PCO_String_Content.split('Expiry Date:')\n",
    "        else:\n",
    "            new_pco_list = PCO_String_Content.split('Expiry Date')\n",
    "        # Getting the Expiry date\n",
    "        new_pco = new_pco_list[-1]\n",
    "        Expiry_date = new_pco_list[-1].split('\\n')\n",
    "        Expiry_date = [date for date in Expiry_date if date != ''][0]\n",
    "        new_pco_content = new_pco_list[0]\n",
    "\n",
    "        def get_pco_license_NO(new_pco_content):\n",
    "            license_NO = re.findall(r'\\d',new_pco_content)\n",
    "            license_NO = ''.join(license_NO)\n",
    "            return license_NO\n",
    "        # Get the License Number\n",
    "        PCO_license_NO = get_pco_license_NO(new_pco_content)\n",
    "        new_pco_content = new_pco_content.split(PCO_license_NO)\n",
    "\n",
    "        new_pco_content = new_pco_content[-1]\n",
    "        new_pco_content = new_pco_content.split('\\n') # FirstName and Lastname in a list\n",
    "\n",
    "        new_pco_content = [name for name in new_pco_content if name != ''] # Cleanup the list\n",
    "        First_Name = new_pco_content[0]\n",
    "        Other_Name = new_pco_content[-1]\n",
    "        Full_Name = First_Name + ' '+ Other_Name\n",
    "        Full_Name = Full_Name.split(' ')\n",
    "        Full_Name = sorted(Full_Name)\n",
    "        Full_Name = ' '.join(Full_Name)\n",
    "        print(Full_Name)\n",
    "\n",
    "        PCO_CONTENT = {}\n",
    "\n",
    "        PCO_CONTENT['Full_Name'] = Full_Name\n",
    "        PCO_CONTENT['License Number'] = PCO_license_NO\n",
    "        PCO_CONTENT['Expiry Date'] = Expiry_date\n",
    "        \n",
    "        return PCO_CONTENT\n",
    "    \n",
    "\n",
    "    def Process_Driver_License(Driver_String_Content):\n",
    "        \n",
    "        if 'DRIVING LICENCE' in Driver_String_Content.upper():\n",
    "            if 'DRIVING LICENCE' in Driver_String_Content.upper():\n",
    "                Driver_contents = Driver_String_Content.split('DRIVING LICENCE')[-1]\n",
    "            elif '1.' in Driver_String_Content:\n",
    "                Driver_contents = re.split('1.', Driver_String_Content, 1)[-1]\n",
    "            else:\n",
    "                Driver_contents = Driver_String_Content\n",
    "                print('No Split Found')\n",
    "    #       Dates\n",
    "            # Match dates using regex\n",
    "            dates = re.findall(r\"([1-9]|0[1-9]|1[0-9]|2[0-9]|3[0-1])(\\.|-|/)([1-9]|0[1-9]|1[0-2])(\\.|-|/)(19[0-9][0-9]|20[0-9][0-9]|[0-9][0-9])\", Driver_contents)\n",
    "            new_dates = [] # all the dates\n",
    "            for date in dates:\n",
    "                dat = ''.join(date)\n",
    "                new_dates.append(dat) # append the dates\n",
    "            # Check if Dates is matched\n",
    "            if len(new_dates) >= 3:\n",
    "                date_and_POB = re.search(f'{new_dates[0]}.*\\n', Driver_contents).group(0).split('\\n')[0] # Date and place of birth\n",
    "                DOB = new_dates[0] # Date o birth\n",
    "                POB = date_and_POB.split(DOB)[-1] # PLace of Birth\n",
    "                issued_date = new_dates[1] # Issued Date\n",
    "                Renew_due_date = new_dates[2] # Renew Date\n",
    "            else:\n",
    "                # Search for dates in the content\n",
    "                dates = re.findall(\"\\d\\d.*\\d\\d\",Driver_contents) \n",
    "                date_and_POB = re.search(f'{dates[0]}.*\\n', Driver_contents).group(0).split('\\n')[0]\n",
    "                DOB = dates[0]\n",
    "                POB = date_and_POB.split(DOB)[-1]\n",
    "                issued_date = dates[1]\n",
    "                Renew_due_date = dates[2]\n",
    "            print(DOB)\n",
    "            print(POB)\n",
    "\n",
    "    #       Names\n",
    "            Names = Driver_contents.split(date_and_POB)[0] # Split the content from date and place of birth, get the first element\n",
    "            Names = re.split('\\d.',Names) # Split the names on the digit\n",
    "            Names = ' '.join(Names) # Join the Names\n",
    "            Names = Names.split('\\n') # Split the Names at '\\n'\n",
    "            Names = [name.strip() for name in Names if name] # Cleanup\n",
    "            Names = [name for name in Names if name] # Cleanup\n",
    "            if Names[0] == 'UK': # Check if UK is in the names\n",
    "                Names = Names[1:] # if UK Slice the List\n",
    "            if len(Names) > 2: # if length of Names is greater than 2\n",
    "                First_Name = Names[0] # First Name\n",
    "                if not 'UK' in Names:\n",
    "                    Other_Name = ' '.join(Names[1:]) \n",
    "                else:\n",
    "                    Other_Name = Names[1]\n",
    "                # Get the Full Names\n",
    "                Full_Name = First_Name + ' '+ Other_Name\n",
    "                Full_Name = Full_Name.split(' ')\n",
    "                Full_Name = sorted(Full_Name)\n",
    "                Full_Name = ' '.join(Full_Name)\n",
    "                print(Full_Name)\n",
    "            else:\n",
    "                First_Name = Names[0]\n",
    "                Other_Name = Names[1]\n",
    "                Full_Name = First_Name + ' '+ Other_Name\n",
    "                Full_Name = Full_Name.split(' ')\n",
    "                Full_Name = sorted(Full_Name)\n",
    "                Full_Name = ' '.join(Full_Name)\n",
    "                print(Full_Name)\n",
    "                \n",
    "    #       Authority\n",
    "            Authority = re.search(f'{issued_date}.*\\n', Driver_contents).group(0) # Split the Text from Issued Date\n",
    "            Authority_EX = re.findall(\"\\d\\d.*\\d\\d\", Authority)\n",
    "            authority_date = []\n",
    "            for date in Authority_EX:\n",
    "                dat = ''.join(date)\n",
    "                authority_date.append(dat)\n",
    "            Authority = Authority.split(authority_date[-1])[-1]\n",
    "            Authority = Authority.split(' ')[-1]\n",
    "            Authority = Authority.split('\\n')[0]\n",
    "\n",
    "    #       LICENSE NUMBER\n",
    "            License_No = Driver_contents.split(Renew_due_date)[1] # Split the Text from \n",
    "            License_No = License_No.split('\\n')\n",
    "            License_No = [license.strip() for license in License_No if license]\n",
    "            match_license = []\n",
    "            for license in License_No:\n",
    "                if re.search(\"\\w.*\\d\", license):\n",
    "                    match_license.append(license)\n",
    "            if len(match_license) > 0:\n",
    "                License_No = match_license[0]\n",
    "            else:\n",
    "                License_No = 'None'\n",
    "\n",
    "    #       Address\n",
    "            Address = Driver_contents.split(License_No)[-1]\n",
    "            Address_list = Address.split('\\n')\n",
    "\n",
    "            # Merge the Address if it continues in another line\n",
    "            output = []\n",
    "            for i in range(len(Address_list)-1):\n",
    "                if str(Address_list[i]).endswith(','):\n",
    "                    new_word = Address_list[i] +' '+ Address_list[i+1]\n",
    "                    output.append(new_word)\n",
    "                    next_word = Address_list[i+1]\n",
    "                    Address_list.remove(next_word)\n",
    "                elif Address_list[i] == max(Address_list, key=len) and str(Address_list[i]).endswith('.'):\n",
    "                    new_word = Address_list[i] +' '+ Address_list[i+1]\n",
    "                    output.append(new_word)\n",
    "                    next_word = Address_list[i+1]\n",
    "                    Address_list.remove(next_word)\n",
    "                else:\n",
    "                    new_word = Address_list[i]\n",
    "                    output.append(new_word)\n",
    "\n",
    "            Address_list = output  \n",
    "            Address = max(Address_list, key=len)\n",
    "            if Address.isupper():\n",
    "                Address = Address\n",
    "            elif max(Address_list, key=len):\n",
    "                Address = Address\n",
    "            else:\n",
    "                Address = [address for address in Address_list if address.isupper()][0]\n",
    "\n",
    "            # Entitlement categoory\n",
    "            Entitlement_categoory = Driver_contents.split(License_No)[-1]\n",
    "            Entitlement_categoory = Entitlement_categoory.split('\\n')\n",
    "            Entitlement_categoory = [category for category in Entitlement_categoory if category][-1]\n",
    "            if Entitlement_categoory == max(Address_list, key=len):\n",
    "                Entitlement_categoory = 'None'\n",
    "            elif re.search(f\"{Entitlement_categoory}\", Address) :\n",
    "                Entitlement_categoory = 'None'\n",
    "            else:\n",
    "                Entitlement_categoory = Entitlement_categoory.split(' ')[-1]\n",
    "                Entitlement_categoory  = Entitlement_categoory\n",
    "\n",
    "\n",
    "            DRIVER_CONTENT = {}\n",
    "\n",
    "            DRIVER_CONTENT['Full_Name'] = Full_Name\n",
    "#             DRIVER_CONTENT['Other Name'] = Other_Name\n",
    "            DRIVER_CONTENT['Date of birth'] = DOB\n",
    "            DRIVER_CONTENT['Place of birth'] = POB\n",
    "            DRIVER_CONTENT['Issued Date'] = issued_date\n",
    "            DRIVER_CONTENT['Renew Due Date'] = Renew_due_date\n",
    "            DRIVER_CONTENT['Issuing authority'] = Authority\n",
    "            DRIVER_CONTENT['License Number'] = License_No\n",
    "            DRIVER_CONTENT['Address'] = Address\n",
    "            DRIVER_CONTENT['Entitlement categories'] = Entitlement_categoory\n",
    "\n",
    "            return DRIVER_CONTENT\n",
    "        else:\n",
    "            print('Document is Not a Driving License')\n",
    "    \n",
    "    PCO_CONTENT = Process_PCO_License(PCO_String_Content)\n",
    "    DRIVER_CONTENT = Process_Driver_License(Driver_String_Content)\n",
    "        \n",
    "    return PCO_CONTENT, DRIVER_CONTENT "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Noor Sheikh Yasin\n",
      "03.05. 1984\n",
      " SOMALIA\n",
      "NOOR SHEIKH YASIN\n"
     ]
    }
   ],
   "source": [
    "PCO_CONTENT, DRIVER_CONTENT = Processor(Drivers_texts, PCO_texts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print(pco_and_driver_license)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Full_Name:  \u001b[32mNoor Sheikh Yasin\u001b[0m\n",
      "License Number:  \u001b[32m180567\u001b[0m\n",
      "Expiry Date:  \u001b[32m 16/12/2023\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "# PCO_CONTENT\n",
    "for x, y in PCO_CONTENT.items():\n",
    "    print(x +\":  \" + colored(y, 'green'))\n",
    "#     print(f\"{x}\\x1b[31m{':  ' + y}\\x1b[0m\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Full_Name:  \u001b[34mNOOR SHEIKH YASIN\u001b[0m\n",
      "Date of birth:  \u001b[34m03.05. 1984\u001b[0m\n",
      "Place of birth:  \u001b[34m SOMALIA\u001b[0m\n",
      "Issued Date:  \u001b[34m21.08.2014\u001b[0m\n",
      "Renew Due Date:  \u001b[34m20.06.2024\u001b[0m\n",
      "Issuing authority:  \u001b[34mDVLA\u001b[0m\n",
      "License Number:  \u001b[34mSHEIKBO5034Y9AD 16\u001b[0m\n",
      "Address:  \u001b[34ma. 5a UPPER WALTHAMSTOW ROAD, WALTHAMSTOW. LONDON, E17 00\u001b[0m\n",
      "Entitlement categories:  \u001b[34mAM/A/B1/B//k/p/q\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "# DRIVER_CONTENT\n",
    "for x, y in DRIVER_CONTENT.items():\n",
    "    print(x +\":  \" + colored(y, 'blue'))\n",
    "#     print(f\"{x}\\x1b[31m{':  ' + y}\\x1b[0m\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Compare both License Informations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Compare_License(Driver_Content, PCO_Content, Driver_Image, PCO_IMage):\n",
    "    \n",
    "    def check_Match_Names(Driver_Content, PCO_Content):\n",
    "        Driver_Full_Name = Driver_Content['Full_Name'].upper()  # Get the Driver FullName      \n",
    "        PCO_Full_Name = PCO_Content[\"Full_Name\"].upper() # Get PCO FullName\n",
    "        \n",
    "        # Compare the FullNames\n",
    "        Names_Match = {}\n",
    "        if Driver_Full_Name == PCO_Full_Name:\n",
    "            Names_Match[\"Full_Name_Matched\"] = True\n",
    "        else:\n",
    "            Names_Match[\"Full_Name_Matched\"] = False\n",
    "            \n",
    "        return Names_Match\n",
    "    \n",
    "    # Check the similarities in the Images Using ImageHash (Python Library)\n",
    "    def check_Image_Similarities(Driver_Image, PCO_IMage):\n",
    "        \n",
    "        hash0 = imagehash.average_hash(Driver_Image) # Driver Image Hash\n",
    "        hash1 = imagehash.average_hash(PCO_IMage)  # PCO Image Hash\n",
    "        cutoff = 5\n",
    "\n",
    "        Image_Similar = {}\n",
    "        # Compute the difference between the Both Images\n",
    "        if hash0 - hash1 < cutoff:\n",
    "            Image_Similar[\"images_similar\"] = True\n",
    "            print('images_are_similar')\n",
    "            print('')\n",
    "        else:\n",
    "            Image_Similar[\"images_similar\"] = False\n",
    "            print('images are not similar')\n",
    "            print('')\n",
    "        \n",
    "        return Image_Similar\n",
    "            \n",
    "    # Compare Names and Images\n",
    "    compared_names = check_Match_Names(Driver_Content, PCO_Content)\n",
    "    compared_images = check_Image_Similarities(Driver_Image, PCO_IMage)\n",
    "    \n",
    "    result = {**compared_names, **compared_images}\n",
    "    \n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "images are not similar\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Compare Both License\n",
    "result = Compare_License(DRIVER_CONTENT, PCO_CONTENT, Driver_Image, PCO_IMage)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Full_Name_Matched:  \u001b[34mTrue\u001b[0m\n",
      "images_similar:  \u001b[31mFalse\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "# Display Results\n",
    "for x,y in result.items():\n",
    "    if y == True:\n",
    "        print(x +\":  \" + colored(y, 'blue'))\n",
    "    else:\n",
    "        print(x +\":  \" + colored(y, 'red'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Save Data to s3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bf42c773fd034e1d9c1897c3c04a4522\n"
     ]
    }
   ],
   "source": [
    "# Create a Unique ID for Every Item to be Uploaded\n",
    "unique_id = uuid.uuid4().hex\n",
    "print(unique_id)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Arrange All the data\n",
    "\n",
    "pco_original_image = open(os.path.join(FOLDER_PATH, PCO_License), 'rb')\n",
    "driver_original_image = open(os.path.join(FOLDER_PATH, Driver_License), 'rb')\n",
    "\n",
    "pco_cropped_image = PCO_IMage\n",
    "driver_cropped_image = Driver_Image\n",
    "\n",
    "#Convert The cropped Image to bytes and save in memory\n",
    "buf = io.BytesIO()\n",
    "pco_cropped_image.save(buf, format='PNG')\n",
    "pco_cropped_image = buf.getvalue()\n",
    "\n",
    "buf = io.BytesIO()\n",
    "driver_cropped_image.save(buf, format='PNG')\n",
    "driver_cropped_image = buf.getvalue()\n",
    "\n",
    "# Convert the Text to Json for AWS\n",
    "pco_details = json.dumps(PCO_CONTENT)\n",
    "driver_details = json.dumps(DRIVER_CONTENT)\n",
    "pco_and_driver_license = {'PCO_LICENSE':unique_id, 'DRIVER_LICENSE':unique_id}\n",
    "pco_and_driver_license = json.dumps(pco_and_driver_license)\n",
    "\n",
    "if result['Full_Name_Matched'] == True:\n",
    "    username = DRIVER_CONTENT['Full_Name'].split(' ')\n",
    "    username = '-'.join(username)\n",
    "else:\n",
    "    username = None\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done\n"
     ]
    }
   ],
   "source": [
    "# Upload to PCO-license bucket\n",
    "\n",
    "s3 = boto3.resource(\n",
    "    's3',\n",
    "    aws_access_key_id=ACCESS_KEY_ID,\n",
    "    aws_secret_access_key=ACCESS_SECRET_KEY,\n",
    "    config=Config(signature_version='s3v4')\n",
    ")\n",
    "\n",
    "s3.Bucket(pco_BUCKET_NAME).put_object(Key=f'{unique_id}/user_image.png', Body=pco_cropped_image, Tagging=f'unique_id={unique_id}')\n",
    "s3.Bucket(pco_BUCKET_NAME).put_object(Key=f'{unique_id}/user_detail.json', Body=pco_details, Tagging=f'unique_id={unique_id}')\n",
    "\n",
    "print (\"Done\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done\n"
     ]
    }
   ],
   "source": [
    "# Upload to Driver-license bucket\n",
    "\n",
    "s3 = boto3.resource(\n",
    "    's3',\n",
    "    aws_access_key_id=ACCESS_KEY_ID,\n",
    "    aws_secret_access_key=ACCESS_SECRET_KEY,\n",
    "    config=Config(signature_version='s3v4')\n",
    ")\n",
    "\n",
    "s3.Bucket(driver_BUCKET_NAME).put_object(Key=f'{unique_id}/user_image.png', Body=driver_cropped_image, Tagging=f'unique_id={unique_id}')\n",
    "s3.Bucket(driver_BUCKET_NAME).put_object(Key=f'{unique_id}/user_detail.json', Body=driver_details, Tagging=f'unique_id={unique_id}')\n",
    "\n",
    "print (\"Done\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done\n"
     ]
    }
   ],
   "source": [
    "# Upload to user-license bucket\n",
    "\n",
    "s3 = boto3.resource(\n",
    "    's3',\n",
    "    aws_access_key_id=ACCESS_KEY_ID,\n",
    "    aws_secret_access_key=ACCESS_SECRET_KEY,\n",
    "    config=Config(signature_version='s3v4')\n",
    ")\n",
    "\n",
    "s3.Bucket(user_BUCKET_NAME).put_object(Key=f'{unique_id}/pco_user_image.png', Body=pco_original_image, Tagging=f'unique_id={unique_id}')\n",
    "s3.Bucket(user_BUCKET_NAME).put_object(Key=f'{unique_id}/driver_user_image.png', Body=driver_original_image, Tagging=f'unique_id={unique_id}')\n",
    "s3.Bucket(user_BUCKET_NAME).put_object(Key=f'{unique_id}/user_info.json', Body=pco_and_driver_license, Tagging=f'unique_id={unique_id}')\n",
    "\n",
    "print (\"Done\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}