diff options
| author | steve <steve@haxors.club> | 2024-07-06 16:30:36 +0100 |
|---|---|---|
| committer | steve <steve@haxors.club> | 2024-07-06 16:30:36 +0100 |
| commit | 06b4ea9550a1f04cf70f77ff339c480d2117ac55 (patch) | |
| tree | 811e7027ac12646d22983201903e747be962e75c /DeleteMe-Parser.ipynb | |
Diffstat (limited to 'DeleteMe-Parser.ipynb')
| -rw-r--r-- | DeleteMe-Parser.ipynb | 651 |
1 files changed, 651 insertions, 0 deletions
diff --git a/DeleteMe-Parser.ipynb b/DeleteMe-Parser.ipynb new file mode 100644 index 0000000..e920a2f --- /dev/null +++ b/DeleteMe-Parser.ipynb @@ -0,0 +1,651 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "d28c0891-acb1-4894-b3c4-1b19f8ca030b", + "metadata": {}, + "outputs": [], + "source": [ + "import re, pprint\n", + "\n", + "import parse\n", + "import pdfplumber\n", + "import pandas as pd" + ] + }, + { + "cell_type": "markdown", + "id": "451ceaee-2beb-475c-bd6c-4404b2f09e0a", + "metadata": {}, + "source": [ + "# Parsing DeleteMe Reports with PDFPlumber\n", + "\n", + "PDFPlumber is really nice, but not sufficient for extracting all the data we need due to the PDF structure. For getting basic data out it's really good." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "47d14f53-6f49-4c58-8c10-4408d45ac8f7", + "metadata": {}, + "outputs": [], + "source": [ + "fn = './privacy-report.pdf'" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f915595a-e0a0-4621-aaff-2048719d5257", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing page: 1\n", + "Processing page: 2\n", + "Processing page: 3\n", + "Processing page: 4\n", + "Processing page: 5\n", + "Processing page: 6\n", + "Processing page: 7\n", + "Processing page: 8\n", + "Processing page: 9\n", + "Processing page: 10\n", + "Processing page: 11\n", + "Processing page: 12\n" + ] + } + ], + "source": [ + "with pdfplumber.open(fn) as pdf:\n", + " pages = pdf.pages\n", + " # There's a weird thing where it's easier to do text extraction as the file is read\n", + " for page in pages:\n", + " print(f\"Processing page: {page.page_number}\")\n", + " text = page.extract_text()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "420d8984-f06a-459f-b4d4-51c79ddc3e76", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[\"KATASHA'S TRIAL ACCOUNTS Privacy Protection Program May 2024\",\n", + " 'May 2024 Report',\n", + " \"KATASHA'S TRIAL ACCOUNTS Privacy Program With Last Scan\",\n", + " 'Friday, May 31, 2024',\n", + " 'DeleteMe Detects And Removes Your Personal Info',\n", + " 'When It Is Found Exposed.',\n", + " 'Your DeleteMe Business Protection Plan: Activated Date: Dashboard Login:',\n", + " 'Gold Diamond Platinum VIP 11/29/2023 joindeleteme.com',\n", + " '3,962 2 2 10',\n", + " 'Total listings Total listings Data brokers with Total PII Found',\n", + " 'reviewed removed your personal info',\n", + " 'Time Saved Searching: Time Saved Removing:',\n", + " 'About 45 ½ hours About 9 ½ hours',\n", + " 'Endole was the data broker with the most info on you',\n", + " 'TOTAL LISTINGS REVIEWED TOTAL LISTINGS REMOVED',\n", + " '4139 4098 4098 3962 7',\n", + " '4',\n", + " '3',\n", + " '2',\n", + " \"Feb'24 Mar'24 May'24 May'24 Feb'24 Mar'24 May'24 May'24\",\n", + " 'Listings reviewed include total unique searches and results Listings removed are removals and opt-out submissions',\n", + " 'returned that are analyzed by the DeleteMe platform and made to one or multiple sources of unwanted PII by',\n", + " \"Privacy Advisors for exposed matching PII DeleteMe's platform and your Privacy Advisor\",\n", + " 'Removed from sources newly added to your service.',\n", + " '2']" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p2 = pdf.pages[2] # Starts from 0\n", + "p2list = p2.extract_text().split('\\n')\n", + "p2list" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "d4a7165e-b5f8-4d99-9416-ee9597f4b575", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'report_date': 'Friday, May 31, 2024',\n", + " 'summary': {'total_listings_reviewed': '3962',\n", + " 'total__listings_removed': '2',\n", + " 'brokers_with_pii': '2',\n", + " 'total_pii_found': '10'}}\n" + ] + } + ], + "source": [ + "# Page 2 Extractor\n", + "p2 = pdf.pages[2]\n", + "p2list = p2.extract_text().split('\\n')\n", + "report_date = p2list[3]\n", + "listings = p2list[8].split(' ')\n", + "summary = {\n", + " 'total_listings_reviewed': listings[0].replace(',',''),\n", + " 'total_listings_removed': listings[1],\n", + " 'brokers_with_pii': listings[2],\n", + " 'total_pii_found': listings[3]\n", + "}\n", + "data = {\n", + " 'report_date': report_date,\n", + " 'summary': summary,\n", + "}\n", + "\n", + "pprint.pp(data)" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "id": "d2e94207-2bde-4acb-82a8-72ff1929f118", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'report_date': 'Friday, May 31, 2024',\n", + " 'summary': {'total_listings_reviewed': '3962',\n", + " 'total__listings_removed': '2',\n", + " 'brokers_with_pii': '2',\n", + " 'total_pii_found': '10'},\n", + " 'google_scan_exposure_findings': {'results_reviewed': '3232',\n", + " 'opt_outs_sent': '4',\n", + " 'not_user': '3215'}}" + ] + }, + "execution_count": 98, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Extract Page 3\n", + "p3 = pdf.pages[3]\n", + "results = p3.extract_text().replace(',','').split('\\n')\n", + "r = results[2].split(' ')\n", + "google_scan = {\n", + " 'results_reviewed': r[0],\n", + " 'opt_outs_sent': r[1],\n", + " 'not_user': r[2],\n", + "}\n", + "data['google_scan_exposure_findings'] = google_scan\n", + "data" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "id": "bdbe4acd-2fff-482f-be92-170d98e2bf6e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'report_date': 'Friday, May 31, 2024',\n", + " 'summary': {'total_listings_reviewed': '3962',\n", + " 'total__listings_removed': '2',\n", + " 'brokers_with_pii': '2',\n", + " 'total_pii_found': '10'},\n", + " 'google_scan_exposure_findings': {'results_reviewed': '3232',\n", + " 'opt_outs_sent': '4',\n", + " 'not_user': '3215'},\n", + " 'findings': {'in_progress': '2',\n", + " 'repeat_listings': '0',\n", + " 'new_listings': '0',\n", + " 'clean': '46'}}" + ] + }, + "execution_count": 99, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Extract Page 4\n", + "p4 = pdf.pages[5]\n", + "in_progress, repeat_listings, new_listings, clean = p4.extract_text().replace(',','').split('\\n')[2].split(' ')\n", + "findings = {\n", + " 'in_progress': in_progress,\n", + " 'repeat_listings': repeat_listings,\n", + " 'new_listings': new_listings,\n", + " 'clean': clean,\n", + "}\n", + "data['findings'] = findings\n", + "data" + ] + }, + { + "cell_type": "markdown", + "id": "099937e8-d438-4748-b6f9-222a974e44b1", + "metadata": {}, + "source": [ + "## Bounding Boxes\n", + "Rather than extracting lines, we can use bounding boxes. This allows us to restrict OCR efforts to particular parts of the page.\n", + "The last page contains advisor-created requests. We can extract the values without risking data from the rest of the page getting in.\n", + "\n", + "Bounding boxes are a tuple with the following parameters, in order:\n", + "\n", + "- x0 - Left edge\n", + "- y0 - Top edge\n", + "- x1 - Right edge\n", + "- y1 - Bottom edge\n", + "\n", + "The values are stored in dots, normaly 72 dpi by default.\n", + "\n", + "A `page` object has `.width` and `.height` settings. The easiest way to identify a bounding box using Jupyter is to convert the bounding box area to an image, and render it inline." + ] + }, + { + "cell_type": "code", + "execution_count": 117, + "id": "e59766a1-2e8f-4394-8ad9-2614bab902b5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAAAeCAMAAAAfKjS8AAADAFBMVEX+/v4ZKIrMzMzl5eUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADRWmUcAAAACXBIWXMAAAsTAAALEwEAmpwYAAABCUlEQVR4nO3ay6rCQBQF0bT+/z+LBGMeB9k0xkpMrZk4KTx7dG8Pw8m0p0sH/MTt47f3+Yd2ll+kvVw2YGG/lD8cT2vw8fCApUOMZ+zYI+Krpl+KisUDthxP6N0I1eIBW44nM0tkavGAguPJzBPp8TABBceTWd4OyMUDCo4ng98ODyg4ngx+Ozyg4Hgy+O3wgILjyeC3wwMKjieD3w4PKDieDH47PKDgeDL47fCAguPJ4H+jwwMKjieD3w4PKDieEP5/STxgy/GEpkbwSQYbsOV4UuPbJ/ox2KFeojqeGP6ODw9Yczw5/HJ4wMohxiPNOB51czzq5njUzfGom+NRN8ejbo5H3aLxPAABvgJB2wW1egAAAABJRU5ErkJggg==", + "text/plain": [ + "<pdfplumber.display.PageImage at 0x7ceb001aa090>" + ] + }, + "execution_count": 117, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Page -1 (last page)\n", + "pminusone = pdf.pages[-1]\n", + "\n", + "x0 = 40\n", + "y0 = 150\n", + "x1 = pminusone.width # We use this because we don't know how big the number might get\n", + "y1 = 180\n", + "\n", + "bounding_box = (x0, y0, x1, y1)\n", + "crop_area = pminusone.crop(bounding_box)\n", + "crop_area.to_image()" + ] + }, + { + "cell_type": "markdown", + "id": "6da2cfa9-421a-4de8-bde1-3a1bd456653b", + "metadata": {}, + "source": [ + "### Extracting The Data\n", + "\n", + "Now we have the crop area we can extract the data without needing fancy line splitting tricks." + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "id": "7108e476-39d1-4c36-ba6b-36c8838bf96d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'report_date': 'Friday, May 31, 2024',\n", + " 'summary': {'total_listings_reviewed': '3962',\n", + " 'total__listings_removed': '2',\n", + " 'brokers_with_pii': '2',\n", + " 'total_pii_found': '10'},\n", + " 'google_scan_exposure_findings': {'results_reviewed': '3232',\n", + " 'opt_outs_sent': '4',\n", + " 'not_user': '3215'},\n", + " 'findings': {'in_progress': '2',\n", + " 'repeat_listings': '0',\n", + " 'new_listings': '0',\n", + " 'clean': '46'},\n", + " 'advisor_stats': {'removal_requests': '1',\n", + " 'investigating': '0',\n", + " 'cant_remove': '0',\n", + " 'removed': '1'}}" + ] + }, + "execution_count": 118, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "pmolist = crop_area.extract_text().replace(',','')\n", + "removal_requests, investigating, cant_remove, removed = pmolist.split(' ')\n", + "\n", + "advisor_stats = {\n", + " 'removal_requests': removal_requests,\n", + " 'investigating': investigating,\n", + " 'cant_remove': cant_remove,\n", + " 'removed': removed,\n", + "}\n", + "data['advisor_stats'] = advisor_stats\n", + "data" + ] + }, + { + "cell_type": "markdown", + "id": "77cc9289-8628-48b8-86c2-1a1423dbe8ca", + "metadata": {}, + "source": [ + "## Extracting Report Findings\n", + "\n", + "The report findings section is a multi-page report that ends on the last page but one. We want to ensure we extract all the info for onward processing. The first page contains a table at the top that we're not interested in, so we'll use a bounding box for that page." + ] + }, + { + "cell_type": "code", + "execution_count": 347, + "id": "94edeca0-8008-4835-8229-c5456b44000f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAAgAIIDASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD37J/un9KMn+6f0paKAEyf7p/SjJ/un9KWigBMn+6f0oyf7p/SlooATJ/un9KMn+6f0paKAEyf7p/SjJ/un9KWigBMn+6f0oyf7p/SlooATJ/un9KMn+6f0paKAEyf7p/SjJ/un9KWigBMn+6f0opaKAKmpXT2dn5kQUyNJHEpbkKXdUBI7gbs4yM4xkdawLfUdYhubjzbhZY4rqGJ/Ng2g75tmEAwUIBDfMXyrIeM4rqJI0mieKVFeNwVZGGQwPUEdxVGPQtIhlSWLSrFJEIZXW3QFSOhBxwaYA9xqTaoYobJFs41AeWeQL5rFk5j2ljhV8zIZVy20A4yRVn177JqNrYXS2ltcTRxsPPutiyOzhTHCSuZGUBieAeYxj58rtUUgMWDxFa3WsiwiltBv2NFvuQJLhDGX8yJMHen3RuBwSJOmz5tqiigAooooAKyQ2ozGby3kGXcRvuTYMMwwQV3dh0zn2rWqu1jaOxZrWBmJySYwSTQBBFfMLeyUgPcXEW5dzqoLBQee/8A3yDila/milZJrQj5JpFEb72ZUKgcY6tuzjPp+F1VVFCqAqgYAAwAKWgCvZ3S3cRkSSBwDjMMvmDOASM4Hc/lg98VYoooAKKKKACiiigD/9k=", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIIAAAAgCAIAAABRtTdPAAABoklEQVR4Ae1ZO04DMRBNUK4DBfQg0eQaVIguaeEA1On4NHCMpACJA9Bwl62XQSONrPGsTVDW+yReFFnzsT0v7613Nsm87/sZX1MzcDQ1ANb/YYAyQFwHlIEyQDAAAWLRdR0EkP8NYs4nJYQLgL0BQQU+KUGoQBkoAwYDECjYGygDBAMQIHgaKAMEAxAgeBooAwQDECB4GiBkWBRQrNd3mt1s7gvTYFO73XuIbbm8DOMTBmMZnADONbgnZxdfnx/mAhqO8SFhpkcuv7C612p1axGxzTXDssen52Kno6bySDjN9hnJ2G7f9K37Ozct+vD0Iq6MZlg2j1jqgMYs38voVsO5Ol+IVq7z5WE8DOZrDxsR3mVDx74GtZDxbu6QofHxxvimVD2k4PeiFL+7L6Wpm+urgpumxrZLMkhnlq6wb38WhaRnKG61ZXTBsT/VL/d/fH6VmU6MdK2kdE55Wrrkb3b875v1ZLfpvpK45Y3doYZcOB+NEVq5WAZL02jDAL++teG5UoUyVAhqk6YMbXiuVKEMFYLapClDG54rVShDhaA26W+TdxIdOLAYsQAAAABJRU5ErkJggg==", + "text/plain": [ + "<PIL.Image.Image image mode=RGB size=130x32>" + ] + }, + "execution_count": 347, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pages = pdf.pages[6:-2]\n", + "start_page = pdf.pages[5]\n", + "x0 = start_page.width - 180\n", + "y0 = 280\n", + "x1 = start_page.width - 50# We use this because we don't know how big the number might get\n", + "y1 = start_page.height - 480\n", + "\n", + "bounding_box = (x0, y0, x1, y1)\n", + "crop_area = start_page.crop(bounding_box)\n", + "img = crop_area.to_image()\n", + "#img.draw_rects(crop_area.extract_words())\n", + "img.original" + ] + }, + { + "cell_type": "code", + "execution_count": 348, + "id": "6855a3d8-dc77-4917-bd75-61e784b8566e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4\n" + ] + }, + { + "data": { + "text/plain": [ + "[(0, 0, 0), (0.9569, 0.9569, 0.9569), (1, 1, 1)]" + ] + }, + "execution_count": 348, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "il = crop_area.rects\n", + "print(len(il))\n", + "#img.draw_rects(il)\n", + "#crop_area.to_image()\n", + "dir(img.page.chars)\n", + "[x for x in il if x['stroking_color'] == (0.1882, 0.5529, 0.2667)]\n", + "cols = list(set([x['stroking_color'] for x in il]))\n", + "cols" + ] + }, + { + "cell_type": "code", + "execution_count": 343, + "id": "08c7e669-5920-4683-9c59-f1676338aaf7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIIAAAAgCAMAAADpCVAqAAADAFBMVEWlpf/yBxSenvh3d9RISKgdIIJhY8H9AAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8QRCQAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAn0lEQVR4nO3XyxKAIAgFUCzQ///jFNFspsZHC1xwx8JVnJFaBMEpJ4AD5TgjbEM4lLPHKRjBCEYwghE2JyDir0edkmUCA4qClggCWSUgK3JNBGJGvpfSI6Tu9RQ8+LjyZpiAIAQqDelRugRBpLa5t6xO3gg1s4S2cGYJ9WoMxDMgGhrEXbyvhLgfHER6EzkDvb4If78IvRjBCFsR9H/uL/QwBBorxugKAAAAAElFTkSuQmCC", + "text/plain": [ + "<pdfplumber.display.PageImage at 0x7ceb016c18b0>" + ] + }, + "execution_count": 343, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tgt = [x for x in il if x['stroking_color'] == cols[2]]\n", + "i = crop_area.to_image()\n", + "i.draw_rects(tgt)" + ] + }, + { + "cell_type": "code", + "execution_count": 257, + "id": "7ea833fc-d406-4426-8c4b-a2f9da5722ca", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<pdfplumber.display.PageImage at 0x7ceb01b57980>" + ] + }, + "execution_count": 257, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(crop_area.rects)\n", + "i = crop_area.to_image()\n", + "i.draw_rects(crop_area.extract_words())" + ] + }, + { + "cell_type": "code", + "execution_count": 357, + "id": "60db2f40-84fc-4cb0-97c0-716d65aa73b6", + "metadata": {}, + "outputs": [], + "source": [ + "import pymupdf\n", + "from PIL import Image" + ] + }, + { + "cell_type": "code", + "execution_count": 378, + "id": "86f2278e-87ea-40db-959e-3efabb7ffe2b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "12" + ] + }, + "execution_count": 378, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "doc = pymupdf.open(fn)\n", + "doc.page_count" + ] + }, + { + "cell_type": "code", + "execution_count": 358, + "id": "90fdbae5-3cc4-4212-8e7b-d1f43a4654f8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "<PIL.Image.Image image mode=RGB size=612x792>" + ] + }, + "execution_count": 358, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "page = doc[5]\n", + "links = page.get_links()\n", + "pix = page.get_pixmap()\n", + "mode = \"RGBA\" if pix.alpha else \"RGB\"\n", + "img = Image.frombytes(mode, [pix.width, pix.height], pix.samples)\n", + "img" + ] + }, + { + "cell_type": "code", + "execution_count": 371, + "id": "2ccc116b-237e-44ee-828b-c4d788043bbb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Text: Photo, Color: (45, 50, 61)\n", + "Text: Photo, Color: (45, 50, 61)\n" + ] + } + ], + "source": [ + "text_blocks = page.get_text(\"dict\", flags=pymupdf.TEXTFLAGS_TEXT)[\"blocks\"]\n", + "for block in text_blocks:\n", + " for line in block[\"lines\"]:\n", + " for span in line[\"spans\"]:\n", + " text = span[\"text\"]\n", + " color = pymupdf.sRGB_to_rgb(span[\"color\"])\n", + " if text == \"Photo\":\n", + " print(f\"Text: {text}, Color: {color}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 408, + "id": "02e1d8dc-0300-4ef4-acbe-abb07b502e92", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Friday, May 31, 2024\n" + ] + } + ], + "source": [ + "# Lets get report date\n", + "page = doc[2]\n", + "rect = (500, 130, 600, 140)\n", + "report_date = page.get_textbox(rect)\n", + "print(report_date)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "722a5b5e-9a09-46ea-b34d-ddd3bce1f663", + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'doc' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[42], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m page \u001b[38;5;241m=\u001b[39m \u001b[43mdoc\u001b[49m[\u001b[38;5;241m2\u001b[39m]\n\u001b[1;32m 2\u001b[0m rect \u001b[38;5;241m=\u001b[39m (\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m250\u001b[39m, \u001b[38;5;241m600\u001b[39m, \u001b[38;5;241m280\u001b[39m)\n\u001b[1;32m 3\u001b[0m listings \u001b[38;5;241m=\u001b[39m doc[\u001b[38;5;241m2\u001b[39m]\u001b[38;5;241m.\u001b[39mget_textbox(rect)\u001b[38;5;241m.\u001b[39msplit(\u001b[38;5;124m'\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m'\u001b[39m)\n", + "\u001b[0;31mNameError\u001b[0m: name 'doc' is not defined" + ] + } + ], + "source": [ + "page = doc[2]\n", + "rect = (0, 250, 600, 280)\n", + "listings = doc[2].get_textbox(rect).split('\\n')\n", + "\n", + "#p2list = p2.extract_text().split('\\n')\n", + "#report_date = p2list[3]\n", + "#listings = p2list.split(' ')\n", + "summary = {\n", + " 'total_listings_reviewed': listings[0].replace(',',''),\n", + " 'total__listings_removed': listings[1],\n", + " 'brokers_with_pii': listings[2],\n", + " 'total_pii_found': listings[3]\n", + "}\n", + "data = {\n", + " 'report_date': report_date,\n", + " 'summary': summary,\n", + "}\n", + "data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ab0227c2-0bdc-4edc-9227-f284a51f0e90", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} |