EMTIAZZ/data-estate

Quick start — get everything in one command

pip install -U huggingface_hub
hf download EMTIAZZ/data-estate --repo-type dataset --local-dir ./data-estate

This downloads everything (all tables, PDFs, scanned images, emails, and transcripts) into ./data-estate. See How to download for more ways.

---

Hints

These are hints, not answers. They point out what to look for in each kind of data and what to think about. Picking the tools and building the pipeline is your job.

All the data is connected: the same customer, policy, and claim show up in many places. Keep that connection through every step, so any answer can be traced back to where it came from.

The kinds of data, and what to think about

Kind of data	How to ingest it (batch / streaming)	Where to keep it
Customer records (tables)	Load all the old data once (batch), then capture new changes as they happen (streaming)	A database with tables you can join
Policy and claim records (tables)	Same — load everything once (batch), then keep capturing changes (streaming)	A database with tables you can join
PDFs and scanned forms (images — you must read the text out first)	Load the old pile once (batch); when a new file arrives, read it then (streaming)	Keep the original files; put the text you pull out in a database, and also in a retrieval (search) index
Emails (with reply history; personal info inside the text)	Load the old emails once (batch); stream new ones as they arrive	Keep the originals; put the text in a retrieval (search) index
Call transcripts (spoken chats; personal info inside the text)	Load the old ones once (batch); stream new ones as calls finish	Keep the originals; put the text in a retrieval (search) index
Reference support text	Just load it once (batch)	A database / search index

Where to store things

• Original files: keep every file exactly as it came in, so you can always redo the work.
• Cleaned data: normalized, deduplicated tables — cleaned to one common format with duplicates removed — so you can join them.
• Search data: text turned into embeddings (numbers that capture meaning) kept in a retrieval index. Think about mixing keyword search with semantic (meaning-based) search, and keeping each customer's data separate.
• History: a note of where each piece of data came from (file → cleaned → search → answer).

Q1 — ingesting the data (batch vs. streaming)

Decide which data you load once (the old history) and which data keeps changing. The tables can be loaded once and then kept up to date. The files (documents, emails, calls) can be loaded in bulk, then new ones handled as they arrive. The main question: where does batch loading fit (big one-time loads), and where does streaming fit (handling items as they arrive)?

Q2 — clean, deduplicate, and normalize (and handle personal info)

• Personal info is not only in the obvious table columns — it's also inside the email text, the call transcripts, and printed on the documents. So you must find it in the free text too, after you pull the text out.
• Deduplicate: some customer records are the same person saved more than once, under different IDs, with small differences (capital letters, spaces, a changed phone format). Match people by who they are, not by their ID. For documents, compare both the image and the text; for emails, don't count the same quoted message twice.
• Normalize: the tables don't use the same column names or date format — clean them into one common shape.

Q3 — getting data ready for search (chunks, embeddings, retrieval index)

• Split each kind of data into chunks in a sensible way: long documents, single table rows, one email at a time, or one part of a conversation.
• Turn the chunks into embeddings and store them in a retrieval index. Only re-embed the data that changed. Keep each customer's data separate. Think about how this stays fast with millions of items, and how to mix keyword search with semantic (meaning-based) search.

Q4 — preparing data to train models

• Build training and test sets from the cleaned data. Remove personal info first. Make sure the same person is never in both the training set and the test set.
• When an input has a known correct answer (for example, a document and the values it should produce), build those input–answer pairs from the connected records.
• Plan how you save versions of your datasets, track your experiments, and undo a change if needed.

Q5 — keeping it healthy over time

• Keep an eye on health (is the data fresh? did reading the files work? is anything piling up?), changes over time (new kinds of records or new form layouts), and answer quality (does each answer point to a real source?).
• Keep a record of where each piece of data came from, control who can see what, and plan for changes to the tables so they don't quietly break your joins.

---

What's inside

data-estate/
├── structured/                  # the tables (load into a database)
│   ├── crm_customers.csv         # customers + personal info
│   ├── erp_policies.csv          # policies (different column names + date format)
│   ├── claims.csv                # claims, linked to policies + customers
│   └── postgres_dump.sql         # ready-to-load database file for all three tables
├── documents/                   # claim forms
│   ├── pdf/<claim_no>.pdf         # 450 claim-form PDFs
│   └── scans/<claim_no>.png       # the same 450 forms as messy "scanned" images
├── emails/thread_*.txt          # 700 support email threads (reply history + personal info)
├── transcripts/call_*.txt       # 350 call transcripts (filler words + spoken personal info)
├── real/                        # extra real support-chat data
│   ├── customer_support_faqs/data.csv
│   └── bitext_customer_support/data.csv
├── *_index.json                 # simple lists of the emails / calls / documents
├── MANIFEST.json                # counts + how things connect + the messy parts
├── examples/quickstart.py       # a ready-to-run example (load, join, read a file)
└── generate.py                  # the script that made the synthetic data

The table files (in structured/)

File	Comes from	Main columns	Notes
crm_customers.csv	CRM	customer_id, full_name, email, phone, dob, ssn, address…	lowercase names, ISO dates. About 8% are duplicate rows.
erp_policies.csv	ERP	PolicyNo, CustomerID, LineOfBusiness, Premium, EffectiveDate…	different name style, MM/DD/YYYY dates (different on purpose).
claims.csv	claims	claim_no, policy_no, customer_id, line, filed_date, amount_claimed, status	links policies and customers.

The files (documents, emails, calls)

• documents/scans/<claim_no>.png — claim forms made to look like real scans (gray, tilted, noisy, blurry). Read the text and fields out of these images.
• documents/pdf/<claim_no>.pdf — the clean PDF of each form.
• emails/thread_*.txt — back-and-forth support emails with reply history; the customer's personal info is in the signature.
• transcripts/call_*.txt — agent/customer phone chats with filler words ("um", "uh") and personal info said out loud (phone, date of birth).

How everything connects

crm_customers.customer_id  ─┐
                            ├─►  erp_policies.CustomerID
                            │        └─ erp_policies.PolicyNo ─► claims.policy_no
                            └─►  claims.customer_id
                                          └─ claims.claim_no ─► documents/{pdf,scans}/<claim_no>
                                                              ─► emails (subject + body)
                                                              ─► transcripts (header + body)

The same person shows up in a claim, a scanned form, an email, and a call. That's what makes joining, cleaning, and tracing the data a real challenge.

The messy parts (on purpose)

• Duplicate customers: the same person saved under different IDs, with capital-letter, spacing, and typo changes, different phone formats, slightly different emails, and some missing fields.
• Different table styles: one table uses lowercase names + ISO dates, the other uses CamelCase names + MM/DD/YYYY dates.
• Personal info inside text: in emails, transcripts, and scanned forms.
• Messy scans: hard to read, like real scans.

How much data

Data	Count
Customer rows (including duplicates)	2,592
Policies	3,100
Claims	3,900
Scanned forms (PNG) + PDFs	450 + 450
Support email threads	700
Call transcripts	350
Extra real support records	1,700

---

How to download

Option A — one command, everything (easiest)

pip install -U huggingface_hub
hf download EMTIAZZ/data-estate --repo-type dataset --local-dir ./data-estate

Option B — Python, everything

from huggingface_hub import snapshot_download
path = snapshot_download(repo_id="EMTIAZZ/data-estate",
                         repo_type="dataset", local_dir="data-estate")
print("downloaded to:", path)

Option C — only part of it (just the images, or just the tables)

from huggingface_hub import snapshot_download
# only the scanned images:
snapshot_download("EMTIAZZ/data-estate", repo_type="dataset",
                  local_dir="scans_only", allow_patterns=["documents/scans/*"])
# only the tables:
snapshot_download("EMTIAZZ/data-estate", repo_type="dataset",
                  local_dir="tables_only", allow_patterns=["structured/*"])

Option D — one file, no extra tools

import pandas as pd
url = "https://huggingface.co/datasets/EMTIAZZ/data-estate/resolve/main/structured/claims.csv"
claims = pd.read_csv(url)          # loads straight from the web

# or with curl:
curl -L -o claims.csv "https://huggingface.co/datasets/EMTIAZZ/data-estate/resolve/main/structured/claims.csv"

Option E — git clone (needs git-lfs for the images/PDFs)

git lfs install
git clone https://huggingface.co/datasets/EMTIAZZ/data-estate

---

How to use it

Load and join the tables

import pandas as pd
root = "data-estate"          # the folder you downloaded
cust   = pd.read_csv(f"{root}/structured/crm_customers.csv")
pol    = pd.read_csv(f"{root}/structured/erp_policies.csv")
claims = pd.read_csv(f"{root}/structured/claims.csv")

# join the three tables (the column names don't match, so map them):
full = (claims
        .merge(cust, on="customer_id", how="left")
        .merge(pol, left_on="policy_no", right_on="PolicyNo", how="left"))
print(full.shape)

Load the tables into a database

createdb insurance
psql -d insurance -f data-estate/structured/postgres_dump.sql

Open a scanned form and find its correct values

from PIL import Image
import pandas as pd, glob, os

root = "data-estate"
scan = sorted(glob.glob(f"{root}/documents/scans/*.png"))[0]
claim_no = os.path.basename(scan).replace(".png", "")
img = Image.open(scan)                       # read the text out of this image
truth = pd.read_csv(f"{root}/structured/claims.csv").query("claim_no == @claim_no")
print(claim_no, img.size, "\ncorrect values:\n", truth.T)

Read an email or a transcript

print(open(f"{root}/emails/thread_0000.txt").read())
print(open(f"{root}/transcripts/call_0000.txt").read())

Or just run the example

python data-estate/examples/quickstart.py data-estate