From 739457b7ae6b6be73c63b4c372343d47170bea66 Mon Sep 17 00:00:00 2001 From: JaskaranIntugle Date: Thu, 21 Aug 2025 18:00:12 +0530 Subject: [PATCH 1/3] added quickstart notebook --- notebooks/quickstart.ipynb | 1054 ++++++++++++++++++++++ notebooks/quickstart_content.txt | 190 ++++ pyproject.toml | 1 + src/data_tools/__init__.py | 3 + src/data_tools/core/settings.py | 2 +- src/data_tools/models/resources/model.py | 2 +- src/data_tools/sql_generator.py | 3 +- uv.lock | 424 +++++++++ 8 files changed, 1676 insertions(+), 3 deletions(-) create mode 100644 notebooks/quickstart.ipynb create mode 100644 notebooks/quickstart_content.txt diff --git a/notebooks/quickstart.ipynb b/notebooks/quickstart.ipynb new file mode 100644 index 0000000..9bc64dd --- /dev/null +++ b/notebooks/quickstart.ipynb @@ -0,0 +1,1054 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "757096f5", + "metadata": {}, + "source": [ + "# Quickstart: Building a Semantic Layer with Data-Tools\n", + "\n", + "This notebook provides a quick introduction to the `data-tools` project. You'll learn how to use its key features to automatically build a semantic layer over your data.\n", + "\n", + "**What is a Semantic Layer?**\n", + "\n", + "A semantic layer is a business-friendly representation of your data. It hides the complexity of the underlying data sources and provides a unified view of your data using familiar business terms. This makes it easier for business users to understand and query the data without needing to be SQL experts.\n", + "\n", + "**In this notebook, you will learn how to:**\n", + "\n", + "1. **Profile your data:** Analyze your data sources to understand their structure, data types, and other characteristics.\n", + "2. **Automatically predict links:** Use a Large Language Model (LLM) to automatically discover relationships (foreign keys) between tables.\n", + "3. **Generate a semantic layer:** Create a `manifest.json` file that defines your semantic layer.\n", + "4. **Generate SQL queries:** Use the semantic layer to generate SQL queries and retrieve data." + ] + }, + { + "cell_type": "markdown", + "id": "a3dad9d8", + "metadata": {}, + "source": [ + "## 1. Data Profiling\n", + "\n", + "The first step in building a semantic layer is to profile your data. This involves analyzing your data sources to understand their structure, data types, and other characteristics. The `data-tools` project provides a pipeline for this purpose.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "7f0e28d7", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/raphael/intugle/data-tools/.venv/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n", + "/home/raphael/intugle/data-tools/.venv/lib/python3.12/site-packages/pydantic/_internal/_fields.py:198: UserWarning: Field name \"schema\" in \"Source\" shadows an attribute in parent \"BaseResource\"\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "from data_tools import DataSet" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "0e8971bb", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
startstoppatientencountercodesystemdescriptiontypecategoryreaction1description1severity1reaction2description2severity2
02020-02-17NaNb9c610cd-28a6-4636-ccb6-c7a0d2a4cb8501efcc52-15d6-51e9-faa2-bee069fcbe44111088007UnknownLatex (substance)allergyenvironment247472004.0Wheal (finding)MILDNaNNaNNaN
12020-02-17NaNb9c610cd-28a6-4636-ccb6-c7a0d2a4cb8501efcc52-15d6-51e9-faa2-bee069fcbe4484489001UnknownMold (organism)allergyenvironment76067001.0SneezingMILDNaNNaNNaN
22020-02-17NaNb9c610cd-28a6-4636-ccb6-c7a0d2a4cb8501efcc52-15d6-51e9-faa2-bee069fcbe44260147004UnknownHouse dust mite (organism)allergyenvironmentNaNNaNNaNNaNNaNNaN
32020-02-17NaNb9c610cd-28a6-4636-ccb6-c7a0d2a4cb8501efcc52-15d6-51e9-faa2-bee069fcbe44264287008UnknownAnimal dander (substance)allergyenvironment878820003.0Rhinoconjunctivitis (disorder)MODERATE271807003.0Eruption of skin (disorder)MILD
42020-02-17NaNb9c610cd-28a6-4636-ccb6-c7a0d2a4cb8501efcc52-15d6-51e9-faa2-bee069fcbe44256277009UnknownGrass pollen (substance)allergyenvironmentNaNNaNNaNNaNNaNNaN
\n", + "
" + ], + "text/plain": [ + " start stop patient \\\n", + "0 2020-02-17 NaN b9c610cd-28a6-4636-ccb6-c7a0d2a4cb85 \n", + "1 2020-02-17 NaN b9c610cd-28a6-4636-ccb6-c7a0d2a4cb85 \n", + "2 2020-02-17 NaN b9c610cd-28a6-4636-ccb6-c7a0d2a4cb85 \n", + "3 2020-02-17 NaN b9c610cd-28a6-4636-ccb6-c7a0d2a4cb85 \n", + "4 2020-02-17 NaN b9c610cd-28a6-4636-ccb6-c7a0d2a4cb85 \n", + "\n", + " encounter code system \\\n", + "0 01efcc52-15d6-51e9-faa2-bee069fcbe44 111088007 Unknown \n", + "1 01efcc52-15d6-51e9-faa2-bee069fcbe44 84489001 Unknown \n", + "2 01efcc52-15d6-51e9-faa2-bee069fcbe44 260147004 Unknown \n", + "3 01efcc52-15d6-51e9-faa2-bee069fcbe44 264287008 Unknown \n", + "4 01efcc52-15d6-51e9-faa2-bee069fcbe44 256277009 Unknown \n", + "\n", + " description type category reaction1 \\\n", + "0 Latex (substance) allergy environment 247472004.0 \n", + "1 Mold (organism) allergy environment 76067001.0 \n", + "2 House dust mite (organism) allergy environment NaN \n", + "3 Animal dander (substance) allergy environment 878820003.0 \n", + "4 Grass pollen (substance) allergy environment NaN \n", + "\n", + " description1 severity1 reaction2 \\\n", + "0 Wheal (finding) MILD NaN \n", + "1 Sneezing MILD NaN \n", + "2 NaN NaN NaN \n", + "3 Rhinoconjunctivitis (disorder) MODERATE 271807003.0 \n", + "4 NaN NaN NaN \n", + "\n", + " description2 severity2 \n", + "0 NaN NaN \n", + "1 NaN NaN \n", + "2 NaN NaN \n", + "3 Eruption of skin (disorder) MILD \n", + "4 NaN NaN " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Load the sample data\n", + "allergies_df = pd.read_csv('../sample_data/healthcare/allergies.csv')\n", + "allergies_df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "8d3e8299", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/raphael/intugle/data-tools/.venv/lib/python3.12/site-packages/numpy/core/fromnumeric.py:3504: RuntimeWarning: Mean of empty slice.\n", + " return _methods._mean(a, axis=axis, dtype=dtype,\n", + "/home/raphael/intugle/data-tools/.venv/lib/python3.12/site-packages/numpy/core/_methods.py:129: RuntimeWarning: invalid value encountered in scalar divide\n", + " ret = ret.dtype.type(ret / rcount)\n", + "[!] Empty column encountered for allergies ==> stop ...\n", + "100%|██████████| 15/15 [00:08<00:00, 1.74it/s]\n", + "100%|██████████| 15/15 [00:19<00:00, 1.32s/it]\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
column_namebusiness_nametable_namenull_countcountdistinct_countuniquenesscompletenesssample_datadtype_sampletsdatatype_l1datatype_l2business_glossarybusiness_tags
0startstartallergies07941790.2254411.0[1948-07-03, 2003-06-17, 1975-11-10, 1957-06-2...[2020-02-17, 1981-05-17, 1960-01-05, 1960-05-2...0.005982date & timeL2OutputTypes.dimensionIndicates the initial date and time when an al...[Allergy Onset Date, Patient Medical History, ...
1stopstopallergies79479400.0000000.0[][]0.000564othersL2OutputTypes.unknownIndicates the conclusion or cessation of a spe...[AllergyEndDate, PatientCareTimeline, Clinical...
2patientpatientallergies07941790.2254411.0[20a75f26-b297-4120-72e6-602ee5e9f4e4, 2af5741...[b9c610cd-28a6-4636-ccb6-c7a0d2a4cb85, 0288c42...0.004958alphanumericL2OutputTypes.dimensionIdentifies individuals associated with recorde...[Patient Identifier, Healthcare Record Linkage...
3encounterencounterallergies07941790.2254411.0[f0edd0d5-9371-09f3-68ef-ad3a38820c26, 3b8ea0a...[01efcc52-15d6-51e9-faa2-bee069fcbe44, 79de99b...0.005013alphanumericL2OutputTypes.dimensionA unique identifier associated with a specific...[Patient Encounter, Healthcare Event, Clinical...
4codecodeallergies0794210.0264481.0[288328004, 260147004, 782576004, 735029006, 4...[111088007, 84489001, 260147004, 264287008, 25...0.005065integerL2OutputTypes.dimensionIdentifies specific allergens or allergy categ...[Allergy Classification, Medical Code, Clinica...
\n", + "
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create a DataSet object and run the profiling pipeline\n", + "dataset_allergies = DataSet(allergies_df, \"allergies\")\n", + "dataset_allergies.run(domain=\"Healthcare\")" + ] + }, + { + "cell_type": "markdown", + "id": "0f4ea58f", + "metadata": {}, + "source": [ + "The `run()` method performs a series of analysis steps, including:\n", + "\n", + "* **Profiling:** Calculates statistics for each column, such as distinct count, uniqueness, and completeness.\n", + "* **Datatype Identification:** Identifies the data type of each column (e.g., integer, string, datetime).\n", + "* **Key Identification:** Identifies potential primary keys.\n", + "* **Glossary Generation:** Generates a business glossary for each column using an LLM.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "eb562acd", + "metadata": {}, + "source": [ + "## 3. Automated Link Prediction\n", + "\n", + "Now that we've profiled our data, let's discover the relationships between tables. The `data-tools` project uses a LLM to predict links (foreign keys) between tables.\n", + "\n", + "First, we'll load a few more tables from the sample dataset." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0aa894eb", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/raphael/intugle/data-tools/.venv/lib/python3.12/site-packages/numpy/core/fromnumeric.py:3504: RuntimeWarning: Mean of empty slice.\n", + " return _methods._mean(a, axis=axis, dtype=dtype,\n", + "/home/raphael/intugle/data-tools/.venv/lib/python3.12/site-packages/numpy/core/_methods.py:129: RuntimeWarning: invalid value encountered in scalar divide\n", + " ret = ret.dtype.type(ret / rcount)\n", + "100%|██████████| 25/25 [00:15<00:00, 1.59it/s]\n", + "[*] patients: 0%| | 0/1 [00:00 referringproviderid ...\n", + " 81%|████████ | 25/31 [00:14<00:03, 1.73it/s][!] Error while llm response parsing: Got invalid JSON object. Error: Expecting ',' delimiter: line 2 column 25 (char 26)\n", + "For troubleshooting, visit: https://python.langchain.com/docs/troubleshooting/errors/OUTPUT_PARSING_FAILURE \n", + " 90%|█████████ | 28/31 [00:15<00:01, 1.81it/s][!] Error while llm response parsing: Got invalid JSON object. Error: Expecting ',' delimiter: line 2 column 27 (char 28)\n", + "For troubleshooting, visit: https://python.langchain.com/docs/troubleshooting/errors/OUTPUT_PARSING_FAILURE \n", + "100%|██████████| 31/31 [00:17<00:00, 1.73it/s]\n", + "[*] claims: 0%| | 0/1 [00:00 modifier1 ...\n", + "[!] Empty column encountered for claims_transactions ==> modifier2 ...\n", + "[!] Empty column encountered for claims_transactions ==> adjustments ...\n", + "[!] Empty column encountered for claims_transactions ==> linenote ...\n", + " 45%|████▌ | 15/33 [00:07<00:09, 1.83it/s][!] Error while llm response parsing: Got invalid JSON object. Error: Expecting ',' delimiter: line 2 column 25 (char 26)\n", + "For troubleshooting, visit: https://python.langchain.com/docs/troubleshooting/errors/OUTPUT_PARSING_FAILURE \n", + " 88%|████████▊ | 29/33 [00:14<00:01, 2.01it/s][!] Error while llm response parsing: Got invalid JSON object. Error: Expecting ',' delimiter: line 2 column 25 (char 26)\n", + "For troubleshooting, visit: https://python.langchain.com/docs/troubleshooting/errors/OUTPUT_PARSING_FAILURE \n", + "100%|██████████| 33/33 [00:17<00:00, 1.86it/s]\n", + "[*] claims_transactions: 0%| | 0/1 [00:00 str:\n", + " \"\"\"Append the base URL to the table name.\"\"\"\n", + " return f\"https://raw.githubusercontent.com/Intugle/data-tools/refs/heads/main/sample_data/healthcare//{table_name}.csv\"\n", + "\n", + "\n", + "for table_name in table_names:\n", + " table_url = generate_table_url(table_name)\n", + " df = pd.read_csv(table_url)\n", + " dataset = DataSet(df, table_name)\n", + " dataset.run(domain=\"Healthcare\")\n", + " datasets.append(dataset)" + ] + }, + { + "cell_type": "markdown", + "id": "e083a8d8", + "metadata": {}, + "source": [ + "Now, let's run the link prediction pipeline." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "fe4cd56d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset 'allergies' is missing key identification. Running prerequisite analysis...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/raphael/intugle/data-tools/.venv/lib/python3.12/site-packages/numpy/core/fromnumeric.py:3504: RuntimeWarning: Mean of empty slice.\n", + " return _methods._mean(a, axis=axis, dtype=dtype,\n", + "/home/raphael/intugle/data-tools/.venv/lib/python3.12/site-packages/numpy/core/_methods.py:129: RuntimeWarning: invalid value encountered in scalar divide\n", + " ret = ret.dtype.type(ret / rcount)\n", + "[!] Empty column encountered for allergies ==> stop ...\n", + "100%|██████████| 15/15 [00:08<00:00, 1.85it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset 'patients' already processed. Skipping analysis.\n", + "Dataset 'claims' already processed. Skipping analysis.\n", + "Dataset 'careplans' already processed. Skipping analysis.\n", + "Dataset 'claims_transactions' already processed. Skipping analysis.\n", + "Dataset 'medications' is missing key identification. Running prerequisite analysis...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "/home/raphael/intugle/data-tools/.venv/lib/python3.12/site-packages/numpy/core/fromnumeric.py:3504: RuntimeWarning: Mean of empty slice.\n", + " return _methods._mean(a, axis=axis, dtype=dtype,\n", + "/home/raphael/intugle/data-tools/.venv/lib/python3.12/site-packages/numpy/core/_methods.py:129: RuntimeWarning: invalid value encountered in scalar divide\n", + " ret = ret.dtype.type(ret / rcount)\n", + "100%|██████████| 13/13 [00:07<00:00, 1.84it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LinkPredictor initialized with datasets: ['allergies', 'patients', 'claims', 'careplans', 'claims_transactions', 'medications']\n", + "\n", + "--- Comparing 'allergies' <=> 'patients' ---\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[*] allergies <==> patients Runs:1: 100%|██████████| 1/1 [00:05<00:00, 5.20s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 1 potential link(s).\n", + "\n", + "--- Comparing 'allergies' <=> 'claims' ---\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[*] allergies <==> claims Runs:1: 100%|██████████| 1/1 [00:01<00:00, 1.78s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No links found for this pair.\n", + "\n", + "--- Comparing 'allergies' <=> 'careplans' ---\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[*] allergies <==> careplans Runs:1: 100%|██████████| 1/1 [00:01<00:00, 1.84s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No links found for this pair.\n", + "\n", + "--- Comparing 'allergies' <=> 'claims_transactions' ---\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[*] allergies <==> claims_transactions Runs:1: 100%|██████████| 1/1 [00:01<00:00, 1.80s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No links found for this pair.\n", + "\n", + "--- Comparing 'allergies' <=> 'medications' ---\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[*] allergies <==> medications Runs:1: 100%|██████████| 1/1 [00:01<00:00, 1.74s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No links found for this pair.\n", + "\n", + "--- Comparing 'patients' <=> 'claims' ---\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[*] patients <==> claims Runs:1: 100%|██████████| 1/1 [00:01<00:00, 1.29s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 1 potential link(s).\n", + "\n", + "--- Comparing 'patients' <=> 'careplans' ---\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[*] patients <==> careplans Runs:1: 100%|██████████| 1/1 [00:01<00:00, 1.12s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 1 potential link(s).\n", + "\n", + "--- Comparing 'patients' <=> 'claims_transactions' ---\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[*] patients <==> claims_transactions Runs:1: 100%|██████████| 1/1 [00:01<00:00, 1.20s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 1 potential link(s).\n", + "\n", + "--- Comparing 'patients' <=> 'medications' ---\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[*] patients <==> medications Runs:1: 100%|██████████| 1/1 [00:01<00:00, 1.12s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 1 potential link(s).\n", + "\n", + "--- Comparing 'claims' <=> 'careplans' ---\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[*] claims <==> careplans Runs:1: 100%|██████████| 1/1 [00:06<00:00, 6.15s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No links found for this pair.\n", + "\n", + "--- Comparing 'claims' <=> 'claims_transactions' ---\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[*] claims <==> claims_transactions Runs:1: 100%|██████████| 1/1 [00:15<00:00, 15.41s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 1 potential link(s).\n", + "\n", + "--- Comparing 'claims' <=> 'medications' ---\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[*] claims <==> medications Runs:1: 100%|██████████| 1/1 [00:18<00:00, 18.19s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No links found for this pair.\n", + "\n", + "--- Comparing 'careplans' <=> 'claims_transactions' ---\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[*] careplans <==> claims_transactions Runs:1: 100%|██████████| 1/1 [00:05<00:00, 5.99s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No links found for this pair.\n", + "\n", + "--- Comparing 'careplans' <=> 'medications' ---\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[*] careplans <==> medications Runs:1: 100%|██████████| 1/1 [00:01<00:00, 1.97s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 1 potential link(s).\n", + "\n", + "--- Comparing 'claims_transactions' <=> 'medications' ---\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[*] claims_transactions <==> medications Runs:1: 100%|██████████| 1/1 [00:04<00:00, 4.28s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No links found for this pair.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "text/plain": [ + "[PredictedLink(from_dataset='allergies', from_column='patient', to_dataset='patients', to_column='id'),\n", + " PredictedLink(from_dataset='patients', from_column='id', to_dataset='claims', to_column='patientid'),\n", + " PredictedLink(from_dataset='patients', from_column='id', to_dataset='careplans', to_column='patient'),\n", + " PredictedLink(from_dataset='patients', from_column='id', to_dataset='claims_transactions', to_column='patientid'),\n", + " PredictedLink(from_dataset='patients', from_column='id', to_dataset='medications', to_column='patient'),\n", + " PredictedLink(from_dataset='claims', from_column='id', to_dataset='claims_transactions', to_column='claimid'),\n", + " PredictedLink(from_dataset='careplans', from_column='encounter', to_dataset='medications', to_column='encounter')]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from data_tools import LinkPredictor\n", + "\n", + "# Initialize the predictor\n", + "predictor = LinkPredictor(datasets)\n", + "\n", + "# Run the prediction\n", + "results = predictor.predict()\n", + "results.links" + ] + }, + { + "cell_type": "markdown", + "id": "d18dc421", + "metadata": {}, + "source": [ + "The `results` object contains the predicted links between the tables. You can also visualize the relationships as a graph.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a59704ba", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "results.show_graph()\n" + ] + }, + { + "cell_type": "markdown", + "id": "32fd4917", + "metadata": {}, + "source": [ + "## 4. The Semantic Layer (Manifest)\n", + "\n", + "The profiling and link prediction results are used to generate a `manifest.json` file. This file defines the semantic layer, including the models (tables) and their relationships.\n", + "\n", + "Let's save the datasets and the predicted links to YAML files. These files will be used to generate the manifest." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "a0daf854", + "metadata": {}, + "outputs": [], + "source": [ + "for ds in datasets:\n", + " ds.save_yaml()\n", + "\n", + "results.save_yaml(\"relationships.yml\")" + ] + }, + { + "cell_type": "markdown", + "id": "8cf08923", + "metadata": {}, + "source": [ + "Now, we can load the YAML files and create a manifest." + ] + }, + { + "cell_type": "markdown", + "id": "3d086f45", + "metadata": {}, + "source": [ + "## 5. SQL Generation\n", + "\n", + "Once you have a semantic layer, you can use the `SqlGenerator` to generate SQL queries. This allows you to query the data using business-friendly terms, without having to write complex SQL.\n", + "\n", + "Let's create an ETL model to define the query we want to generate." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "2570af46", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# # Create an ETL model\n", + "# etl_model = ETLModel(\n", + "# fields=[\n", + "# FieldModel(id=\"patients.FIRST\"),\n", + "# FieldModel(id=\"patients.LAST\"),\n", + "# FieldModel(id=\"claims.TOTAL_CLAIM_COST\"),\n", + "# ]\n", + "# )\n", + "etl = {\n", + " \"name\": \"test_etl\",\n", + " \"fields\": [\n", + " {\"id\": \"patients.first\", \"name\": \"first_name\"},\n", + " {\"id\": \"patients.last\", \"name\": \"last_name\"},\n", + " {\"id\": \"allergies.start\", \"name\": \"start_date\"},\n", + " # {\"id\": \"encounters.total_claim_cost\", \"name\": \"claim_cost\", \"category\": \"measure\", \"measure_func\": \"sum\"},\n", + " ],\n", + " \"filter\": {\n", + " \"selections\": [{\"id\": \"claims.departmentid\", \"values\": [\"3\", \"20\"]}],\n", + " # \"sort_by\": [{\"id\": \"encounters.start\", \"direction\": \"desc\"}],\n", + " },\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "2e4ff6be", + "metadata": {}, + "source": [ + "Now, let's use the `SqlGenerator` to generate the SQL query." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "f0432e77", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SELECT patients.first as `first_name`, patients.last as `last_name`, allergies.start as `start_date` FROM `claims` LEFT JOIN `patients` ON patients.id = claims.patientid LEFT JOIN `allergies` ON allergies.patient = patients.id WHERE (claims.departmentid IN '['3', '20']')\n" + ] + } + ], + "source": [ + "from data_tools.sql_generator import SqlGenerator\n", + "\n", + "# Create a SqlGenerator\n", + "sql_generator = SqlGenerator('/home/raphael/intugle/data-tools/testing_base')\n", + "\n", + "# Generate the query\n", + "sql_query = sql_generator.generate_query(etl)\n", + "\n", + "# Print the query\n", + "print(sql_query)" + ] + }, + { + "cell_type": "markdown", + "id": "c29d33de", + "metadata": {}, + "source": [ + "## Conclusion\n", + "\n", + "This notebook has provided a brief overview of the `data-tools` project. You've learned how to:\n", + "\n", + "* Profile your data to understand its characteristics.\n", + "* Use an LLM to automatically predict links between tables.\n", + "* Generate a semantic layer (`manifest.json`).\n", + "* Use the semantic layer to generate SQL queries.\n", + "\n", + "This is just a starting point. The `data-tools` project has many other features to explore. We encourage you to try it with your own data and see how it can help you build a powerful semantic layer.\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "data-tools", + "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 +} diff --git a/notebooks/quickstart_content.txt b/notebooks/quickstart_content.txt new file mode 100644 index 0000000..33bdf63 --- /dev/null +++ b/notebooks/quickstart_content.txt @@ -0,0 +1,190 @@ +--- +type: markdown +--- +# Quickstart: Building a Semantic Layer with Data-Tools + +This notebook provides a quick introduction to the `data-tools` project. You'll learn how to use its key features to automatically build a semantic layer over your data. + +**What is a Semantic Layer?** + +A semantic layer is a business-friendly representation of your data. It hides the complexity of the underlying data sources and provides a unified view of your data using familiar business terms. This makes it easier for business users to understand and query the data without needing to be SQL experts. + +**In this notebook, you will learn how to:** + +1. **Profile your data:** Analyze your data sources to understand their structure, data types, and other characteristics. +2. **Automatically predict links:** Use a Large Language Model (LLM) to automatically discover relationships (foreign keys) between tables. +3. **Generate a semantic layer:** Create a `manifest.json` file that defines your semantic layer. +4. **Generate SQL queries:** Use the semantic layer to generate SQL queries and retrieve data. +--- +type: markdown +--- +## 1. Setup + +First, let's install the necessary libraries. This project uses `uv` for package management. +--- +type: code +--- +!pip install uv +!uv pip install -r ../requirements.txt +--- +type: markdown +--- +## 2. Data Profiling + +The first step in building a semantic layer is to profile your data. This involves analyzing your data sources to understand their structure, data types, and other characteristics. The `data-tools` project provides a pipeline for this purpose. +--- +type: code +--- +import pandas as pd +from data_tools.analysis.models import DataSet +--- +type: code +--- +# Load the sample data +allergies_df = pd.read_csv('../sample_data/healthcare/allergies.csv') +allergies_df.head() +--- +type: code +--- +# Create a DataSet object and run the profiling pipeline +dataset_allergies = DataSet(allergies_df, "allergies") +dataset_allergies.run(domain="Healthcare") +--- +type: markdown +--- +The `run()` method performs a series of analysis steps, including: + +* **Profiling:** Calculates statistics for each column, such as distinct count, uniqueness, and completeness. +* **Datatype Identification:** Identifies the data type of each column (e.g., integer, string, datetime). +* **Key Identification:** Identifies potential primary keys. +* **Glossary Generation:** Generates a business glossary for each column using an LLM. + +Let's take a look at the profiling results: +--- +type: code +--- +dataset_allergies.profile_df.head() +--- +type: markdown +--- +## 3. Automated Link Prediction + +Now that we've profiled our data, let's discover the relationships between tables. The `data-tools` project uses a Large Language Model (LLM) to predict links (foreign keys) between tables. + +First, we'll load a few more tables from the sample dataset. +--- +type: code +--- +table_names = ["patients", "claims", "careplans", "claims_transactions", "medications"] +datasets = [dataset_allergies] + +for table_name in table_names: + df = pd.read_csv(f'../sample_data/healthcare/{table_name}.csv') + dataset = DataSet(df, table_name) + dataset.run(domain="Healthcare") + datasets.append(dataset) +--- +type: markdown +--- +Now, let's run the link prediction pipeline. +--- +type: code +--- +from data_tools.link_predictor import LinkPredictor + +# Initialize the predictor +predictor = LinkPredictor(datasets) + +# Run the prediction +results = predictor.predict() +results.links +--- +type: markdown +--- +The `results` object contains the predicted links between the tables. You can also visualize the relationships as a graph. +--- +type: code +--- +results.show_graph() +--- +type: markdown +--- +## 4. The Semantic Layer (Manifest) + +The profiling and link prediction results are used to generate a `manifest.json` file. This file defines the semantic layer, including the models (tables) and their relationships. + +Let's save the datasets and the predicted links to YAML files. These files will be used to generate the manifest. +--- +type: code +--- +for ds in datasets: + ds.save_yaml() + +results.save_yaml("relationships.yml") +--- +type: markdown +--- +Now, we can load the YAML files and create a manifest. +--- +type: code +--- +from data_tools.parser.manifest import ManifestLoader + +# Load the manifest +manifest_loader = ManifestLoader('.') +manifest_loader.load() +manifest = manifest_loader.manifest + +# Print the manifest +print(manifest.json(indent=4)) +--- +type: markdown +--- +## 5. SQL Generation + +Once you have a semantic layer, you can use the `SqlGenerator` to generate SQL queries. This allows you to query the data using business-friendly terms, without having to write complex SQL. + +Let's create an ETL model to define the query we want to generate. +--- +type: code +--- +from data_tools.libs.smart_query_generator.models.models import ETLModel, FieldModel + +# Create an ETL model +etl_model = ETLModel( + fields=[ + FieldModel(id="patients.FIRST"), + FieldModel(id="patients.LAST"), + FieldModel(id="claims.TOTAL_CLAIM_COST"), + ] +) +--- +type: markdown +--- +Now, let's use the `SqlGenerator` to generate the SQL query. +--- +type: code +--- +from data_tools.sql_generator import SqlGenerator + +# Create a SqlGenerator +sql_generator = SqlGenerator('.') + +# Generate the query +sql_query = sql_generator.generate_query(etl_model) + +# Print the query +print(sql_query) +--- +type: markdown +--- +## Conclusion + +This notebook has provided a brief overview of the `data-tools` project. You've learned how to: + +* Profile your data to understand its characteristics. +* Use an LLM to automatically predict links between tables. +* Generate a semantic layer (`manifest.json`). +* Use the semantic layer to generate SQL queries. + +This is just a starting point. The `data-tools` project has many other features to explore. We encourage you to try it with your own data and see how it can help you build a powerful semantic layer. diff --git a/pyproject.toml b/pyproject.toml index f6f905b..c66d003 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -52,6 +52,7 @@ test = [ ] lint = ["ruff"] dev = [ + "ipykernel>=6.30.1", "pytest>=8.4.1", "pytest-asyncio>=1.1.0", "pytest-cov>=6.2.1", diff --git a/src/data_tools/__init__.py b/src/data_tools/__init__.py index e69de29..71a6ddd 100644 --- a/src/data_tools/__init__.py +++ b/src/data_tools/__init__.py @@ -0,0 +1,3 @@ +from data_tools.analysis.models import DataSet +from data_tools.link_predictor.predictor import LinkPredictor +from data_tools.sql_generator import SqlGenerator diff --git a/src/data_tools/core/settings.py b/src/data_tools/core/settings.py index 5987f35..8796a8f 100644 --- a/src/data_tools/core/settings.py +++ b/src/data_tools/core/settings.py @@ -30,7 +30,7 @@ class Settings(BaseSettings): DI_MODEL_VERSION: str = "13052023" - PROJECT_BASE: str + PROJECT_BASE: str = str(Path(os.getenv("VSCODE_WORKSPACE", os.getcwd()))) MCP_SERVER_NAME: str = "data-tools" MCP_SERVER_DESCRIPTION: str = "Data Tools for MCP" diff --git a/src/data_tools/models/resources/model.py b/src/data_tools/models/resources/model.py index 14671df..caa9ab1 100644 --- a/src/data_tools/models/resources/model.py +++ b/src/data_tools/models/resources/model.py @@ -17,7 +17,7 @@ class Column(SchemaBase): name: str type: Optional[str] = None category: Literal["dimension", "measure"] = "dimension" - description: str + description: Optional[str] = None tags: Optional[List[str]] = Field(default_factory=list) profiling_metrics: Optional[ColumnProfilingMetrics] = None diff --git a/src/data_tools/sql_generator.py b/src/data_tools/sql_generator.py index 28b9ceb..4c886d1 100644 --- a/src/data_tools/sql_generator.py +++ b/src/data_tools/sql_generator.py @@ -1,5 +1,6 @@ from typing import TYPE_CHECKING +from data_tools.core import settings from data_tools.libs.smart_query_generator import SmartQueryGenerator from data_tools.libs.smart_query_generator.models.models import ETLModel, FieldDetailsModel, LinkModel from data_tools.libs.smart_query_generator.utils.join import Join @@ -12,7 +13,7 @@ class SqlGenerator: """Generates SQL queries based on the manifest and ETL configurations.""" - def __init__(self, project_base: str): + def __init__(self, project_base: str = settings.PROJECT_BASE): self.manifest_loader = ManifestLoader(project_base) self.manifest_loader.load() self.manifest = self.manifest_loader.manifest diff --git a/uv.lock b/uv.lock index dfc45cb..2535364 100644 --- a/uv.lock +++ b/uv.lock @@ -159,6 +159,24 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/6f/12/e5e0282d673bb9746bacfb6e2dba8719989d3660cdb2ea79aee9a9651afb/anyio-4.10.0-py3-none-any.whl", hash = "sha256:60e474ac86736bbfd6f210f7a61218939c318f43f9972497381f1c5e930ed3d1", size = 107213 }, ] +[[package]] +name = "appnope" +version = "0.1.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/35/5d/752690df9ef5b76e169e68d6a129fa6d08a7100ca7f754c89495db3c6019/appnope-0.1.4.tar.gz", hash = "sha256:1de3860566df9caf38f01f86f65e0e13e379af54f9e4bee1e66b48f2efffd1ee", size = 4170 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/29/5ecc3a15d5a33e31b26c11426c45c501e439cb865d0bff96315d86443b78/appnope-0.1.4-py2.py3-none-any.whl", hash = "sha256:502575ee11cd7a28c0205f379b525beefebab9d161b7c964670864014ed7213c", size = 4321 }, +] + +[[package]] +name = "asttokens" +version = "3.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4a/e7/82da0a03e7ba5141f05cce0d302e6eed121ae055e0456ca228bf693984bc/asttokens-3.0.0.tar.gz", hash = "sha256:0dcd8baa8d62b0c1d118b399b2ddba3c4aff271d0d7a9e0d4c1681c79035bbc7", size = 61978 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/25/8a/c46dcc25341b5bce5472c718902eb3d38600a903b14fa6aeecef3f21a46f/asttokens-3.0.0-py3-none-any.whl", hash = "sha256:e3078351a059199dd5138cb1c706e6430c05eff2ff136af5eb4790f9d28932e2", size = 26918 }, +] + [[package]] name = "async-timeout" version = "4.0.3" @@ -483,6 +501,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335 }, ] +[[package]] +name = "comm" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4c/13/7d740c5849255756bc17888787313b61fd38a0a8304fc4f073dfc46122aa/comm-0.2.3.tar.gz", hash = "sha256:2dc8048c10962d55d7ad693be1e7045d891b7ce8d999c97963a5e3e99c055971", size = 6319 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/97/891a0971e1e4a8c5d2b20bbe0e524dc04548d2307fee33cdeba148fd4fc7/comm-0.2.3-py3-none-any.whl", hash = "sha256:c615d91d75f7f04f095b30d1c1711babd43bdc6419c1be9886a85f2f4e489417", size = 7294 }, +] + [[package]] name = "contourpy" version = "1.3.2" @@ -777,6 +804,7 @@ dependencies = [ [package.dev-dependencies] dev = [ + { name = "ipykernel" }, { name = "pytest" }, { name = "pytest-asyncio" }, { name = "pytest-cov" }, @@ -823,6 +851,7 @@ requires-dist = [ [package.metadata.requires-dev] dev = [ + { name = "ipykernel", specifier = ">=6.30.1" }, { name = "pytest", specifier = ">=8.4.1" }, { name = "pytest-asyncio", specifier = ">=1.1.0" }, { name = "pytest-cov", specifier = ">=6.2.1" }, @@ -848,6 +877,40 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/c3/be/d0d44e092656fe7a06b55e6103cbce807cdbdee17884a5367c68c9860853/dataclasses_json-0.6.7-py3-none-any.whl", hash = "sha256:0dbf33f26c8d5305befd61b39d2b3414e8a407bedc2834dea9b8d642666fb40a", size = 28686 }, ] +[[package]] +name = "debugpy" +version = "1.8.16" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ca/d4/722d0bcc7986172ac2ef3c979ad56a1030e3afd44ced136d45f8142b1f4a/debugpy-1.8.16.tar.gz", hash = "sha256:31e69a1feb1cf6b51efbed3f6c9b0ef03bc46ff050679c4be7ea6d2e23540870", size = 1643809 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ce/fd/f1b75ebc61d90882595b81d808efd3573c082e1c3407850d9dccac4ae904/debugpy-1.8.16-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:2a3958fb9c2f40ed8ea48a0d34895b461de57a1f9862e7478716c35d76f56c65", size = 2085511 }, + { url = "https://files.pythonhosted.org/packages/df/5e/c5c1934352871128b30a1a144a58b5baa546e1b57bd47dbed788bad4431c/debugpy-1.8.16-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e5ca7314042e8a614cc2574cd71f6ccd7e13a9708ce3c6d8436959eae56f2378", size = 3562094 }, + { url = "https://files.pythonhosted.org/packages/c9/d5/2ebe42377e5a78dc786afc25e61ee83c5628d63f32dfa41092597d52fe83/debugpy-1.8.16-cp310-cp310-win32.whl", hash = "sha256:8624a6111dc312ed8c363347a0b59c5acc6210d897e41a7c069de3c53235c9a6", size = 5234277 }, + { url = "https://files.pythonhosted.org/packages/54/f8/e774ad16a60b9913213dbabb7472074c5a7b0d84f07c1f383040a9690057/debugpy-1.8.16-cp310-cp310-win_amd64.whl", hash = "sha256:fee6db83ea5c978baf042440cfe29695e1a5d48a30147abf4c3be87513609817", size = 5266011 }, + { url = "https://files.pythonhosted.org/packages/63/d6/ad70ba8b49b23fa286fb21081cf732232cc19374af362051da9c7537ae52/debugpy-1.8.16-cp311-cp311-macosx_14_0_universal2.whl", hash = "sha256:67371b28b79a6a12bcc027d94a06158f2fde223e35b5c4e0783b6f9d3b39274a", size = 2184063 }, + { url = "https://files.pythonhosted.org/packages/aa/49/7b03e88dea9759a4c7910143f87f92beb494daaae25560184ff4ae883f9e/debugpy-1.8.16-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b2abae6dd02523bec2dee16bd6b0781cccb53fd4995e5c71cc659b5f45581898", size = 3134837 }, + { url = "https://files.pythonhosted.org/packages/5d/52/b348930316921de7565fbe37a487d15409041713004f3d74d03eb077dbd4/debugpy-1.8.16-cp311-cp311-win32.whl", hash = "sha256:f8340a3ac2ed4f5da59e064aa92e39edd52729a88fbde7bbaa54e08249a04493", size = 5159142 }, + { url = "https://files.pythonhosted.org/packages/d8/ef/9aa9549ce1e10cea696d980292e71672a91ee4a6a691ce5f8629e8f48c49/debugpy-1.8.16-cp311-cp311-win_amd64.whl", hash = "sha256:70f5fcd6d4d0c150a878d2aa37391c52de788c3dc680b97bdb5e529cb80df87a", size = 5183117 }, + { url = "https://files.pythonhosted.org/packages/61/fb/0387c0e108d842c902801bc65ccc53e5b91d8c169702a9bbf4f7efcedf0c/debugpy-1.8.16-cp312-cp312-macosx_14_0_universal2.whl", hash = "sha256:b202e2843e32e80b3b584bcebfe0e65e0392920dc70df11b2bfe1afcb7a085e4", size = 2511822 }, + { url = "https://files.pythonhosted.org/packages/37/44/19e02745cae22bf96440141f94e15a69a1afaa3a64ddfc38004668fcdebf/debugpy-1.8.16-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64473c4a306ba11a99fe0bb14622ba4fbd943eb004847d9b69b107bde45aa9ea", size = 4230135 }, + { url = "https://files.pythonhosted.org/packages/f3/0b/19b1ba5ee4412f303475a2c7ad5858efb99c90eae5ec627aa6275c439957/debugpy-1.8.16-cp312-cp312-win32.whl", hash = "sha256:833a61ed446426e38b0dd8be3e9d45ae285d424f5bf6cd5b2b559c8f12305508", size = 5281271 }, + { url = "https://files.pythonhosted.org/packages/b1/e0/bc62e2dc141de53bd03e2c7cb9d7011de2e65e8bdcdaa26703e4d28656ba/debugpy-1.8.16-cp312-cp312-win_amd64.whl", hash = "sha256:75f204684581e9ef3dc2f67687c3c8c183fde2d6675ab131d94084baf8084121", size = 5323149 }, + { url = "https://files.pythonhosted.org/packages/62/66/607ab45cc79e60624df386e233ab64a6d8d39ea02e7f80e19c1d451345bb/debugpy-1.8.16-cp313-cp313-macosx_14_0_universal2.whl", hash = "sha256:85df3adb1de5258dca910ae0bb185e48c98801ec15018a263a92bb06be1c8787", size = 2496157 }, + { url = "https://files.pythonhosted.org/packages/4d/a0/c95baae08a75bceabb79868d663a0736655e427ab9c81fb848da29edaeac/debugpy-1.8.16-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bee89e948bc236a5c43c4214ac62d28b29388453f5fd328d739035e205365f0b", size = 4222491 }, + { url = "https://files.pythonhosted.org/packages/5b/2f/1c8db6ddd8a257c3cd2c46413b267f1d5fa3df910401c899513ce30392d6/debugpy-1.8.16-cp313-cp313-win32.whl", hash = "sha256:cf358066650439847ec5ff3dae1da98b5461ea5da0173d93d5e10f477c94609a", size = 5281126 }, + { url = "https://files.pythonhosted.org/packages/d3/ba/c3e154ab307366d6c5a9c1b68de04914e2ce7fa2f50d578311d8cc5074b2/debugpy-1.8.16-cp313-cp313-win_amd64.whl", hash = "sha256:b5aea1083f6f50023e8509399d7dc6535a351cc9f2e8827d1e093175e4d9fa4c", size = 5323094 }, + { url = "https://files.pythonhosted.org/packages/52/57/ecc9ae29fa5b2d90107cd1d9bf8ed19aacb74b2264d986ae9d44fe9bdf87/debugpy-1.8.16-py2.py3-none-any.whl", hash = "sha256:19c9521962475b87da6f673514f7fd610328757ec993bf7ec0d8c96f9a325f9e", size = 5287700 }, +] + +[[package]] +name = "decorator" +version = "5.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/fa/6d96a0978d19e17b68d634497769987b16c8f4cd0a7a05048bec693caa6b/decorator-5.2.1.tar.gz", hash = "sha256:65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360", size = 56711 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", hash = "sha256:d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a", size = 9190 }, +] + [[package]] name = "dill" version = "0.4.0" @@ -937,6 +1000,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/36/f4/c6e662dade71f56cd2f3735141b265c3c79293c109549c1e6933b0651ffc/exceptiongroup-1.3.0-py3-none-any.whl", hash = "sha256:4d111e6e0c13d0644cad6ddaa7ed0261a0b36971f6d23e7ec9b4b9097da78a10", size = 16674 }, ] +[[package]] +name = "executing" +version = "2.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/91/50/a9d80c47ff289c611ff12e63f7c5d13942c65d68125160cefd768c73e6e4/executing-2.2.0.tar.gz", hash = "sha256:5d108c028108fe2551d1a7b2e8b713341e2cb4fc0aa7dcf966fa4327a5226755", size = 978693 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/8f/c4d9bafc34ad7ad5d8dc16dd1347ee0e507a52c3adb6bfa8887e1c6a26ba/executing-2.2.0-py2.py3-none-any.whl", hash = "sha256:11387150cad388d62750327a53d3339fad4888b39a6fe233c3afbb54ecffd3aa", size = 26702 }, +] + [[package]] name = "fastapi" version = "0.116.1" @@ -1714,6 +1786,108 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/2c/e1/e6716421ea10d38022b952c159d5161ca1193197fb744506875fbb87ea7b/iniconfig-2.1.0-py3-none-any.whl", hash = "sha256:9deba5723312380e77435581c6bf4935c94cbfab9b1ed33ef8d238ea168eb760", size = 6050 }, ] +[[package]] +name = "ipykernel" +version = "6.30.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "appnope", marker = "sys_platform == 'darwin'" }, + { name = "comm" }, + { name = "debugpy" }, + { name = "ipython", version = "8.37.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "ipython", version = "9.4.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "matplotlib-inline" }, + { name = "nest-asyncio" }, + { name = "packaging" }, + { name = "psutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bb/76/11082e338e0daadc89c8ff866185de11daf67d181901038f9e139d109761/ipykernel-6.30.1.tar.gz", hash = "sha256:6abb270161896402e76b91394fcdce5d1be5d45f456671e5080572f8505be39b", size = 166260 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fc/c7/b445faca8deb954fe536abebff4ece5b097b923de482b26e78448c89d1dd/ipykernel-6.30.1-py3-none-any.whl", hash = "sha256:aa6b9fb93dca949069d8b85b6c79b2518e32ac583ae9c7d37c51d119e18b3fb4", size = 117484 }, +] + +[[package]] +name = "ipython" +version = "8.37.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11'", +] +dependencies = [ + { name = "colorama", marker = "python_full_version < '3.11' and sys_platform == 'win32'" }, + { name = "decorator", marker = "python_full_version < '3.11'" }, + { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, + { name = "jedi", marker = "python_full_version < '3.11'" }, + { name = "matplotlib-inline", marker = "python_full_version < '3.11'" }, + { name = "pexpect", marker = "python_full_version < '3.11' and sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "prompt-toolkit", marker = "python_full_version < '3.11'" }, + { name = "pygments", marker = "python_full_version < '3.11'" }, + { name = "stack-data", marker = "python_full_version < '3.11'" }, + { name = "traitlets", marker = "python_full_version < '3.11'" }, + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/85/31/10ac88f3357fc276dc8a64e8880c82e80e7459326ae1d0a211b40abf6665/ipython-8.37.0.tar.gz", hash = "sha256:ca815841e1a41a1e6b73a0b08f3038af9b2252564d01fc405356d34033012216", size = 5606088 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/91/d0/274fbf7b0b12643cbbc001ce13e6a5b1607ac4929d1b11c72460152c9fc3/ipython-8.37.0-py3-none-any.whl", hash = "sha256:ed87326596b878932dbcb171e3e698845434d8c61b8d8cd474bf663041a9dcf2", size = 831864 }, +] + +[[package]] +name = "ipython" +version = "9.4.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.13'", + "python_full_version >= '3.12.4' and python_full_version < '3.13'", + "python_full_version >= '3.12' and python_full_version < '3.12.4'", + "python_full_version == '3.11.*'", +] +dependencies = [ + { name = "colorama", marker = "python_full_version >= '3.11' and sys_platform == 'win32'" }, + { name = "decorator", marker = "python_full_version >= '3.11'" }, + { name = "ipython-pygments-lexers", marker = "python_full_version >= '3.11'" }, + { name = "jedi", marker = "python_full_version >= '3.11'" }, + { name = "matplotlib-inline", marker = "python_full_version >= '3.11'" }, + { name = "pexpect", marker = "python_full_version >= '3.11' and sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "prompt-toolkit", marker = "python_full_version >= '3.11'" }, + { name = "pygments", marker = "python_full_version >= '3.11'" }, + { name = "stack-data", marker = "python_full_version >= '3.11'" }, + { name = "traitlets", marker = "python_full_version >= '3.11'" }, + { name = "typing-extensions", marker = "python_full_version == '3.11.*'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/54/80/406f9e3bde1c1fd9bf5a0be9d090f8ae623e401b7670d8f6fdf2ab679891/ipython-9.4.0.tar.gz", hash = "sha256:c033c6d4e7914c3d9768aabe76bbe87ba1dc66a92a05db6bfa1125d81f2ee270", size = 4385338 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/63/f8/0031ee2b906a15a33d6bfc12dd09c3dfa966b3cb5b284ecfb7549e6ac3c4/ipython-9.4.0-py3-none-any.whl", hash = "sha256:25850f025a446d9b359e8d296ba175a36aedd32e83ca9b5060430fe16801f066", size = 611021 }, +] + +[[package]] +name = "ipython-pygments-lexers" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pygments", marker = "python_full_version >= '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ef/4c/5dd1d8af08107f88c7f741ead7a40854b8ac24ddf9ae850afbcf698aa552/ipython_pygments_lexers-1.1.1.tar.gz", hash = "sha256:09c0138009e56b6854f9535736f4171d855c8c08a563a0dcd8022f78355c7e81", size = 8393 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d9/33/1f075bf72b0b747cb3288d011319aaf64083cf2efef8354174e3ed4540e2/ipython_pygments_lexers-1.1.1-py3-none-any.whl", hash = "sha256:a9462224a505ade19a605f71f8fa63c2048833ce50abc86768a0d81d876dc81c", size = 8074 }, +] + +[[package]] +name = "jedi" +version = "0.19.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "parso" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/72/3a/79a912fbd4d8dd6fbb02bf69afd3bb72cf0c729bb3063c6f4498603db17a/jedi-0.19.2.tar.gz", hash = "sha256:4770dc3de41bde3966b02eb84fbcf557fb33cce26ad23da12c742fb50ecb11f0", size = 1231287 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c0/5a/9cac0c82afec3d09ccd97c8b6502d48f165f9124db81b4bcb90b4af974ee/jedi-0.19.2-py2.py3-none-any.whl", hash = "sha256:a8ef22bde8490f57fe5c7681a3c83cb58874daf72b4784de3cce5b6ef6edb5b9", size = 1572278 }, +] + [[package]] name = "jinja2" version = "3.1.6" @@ -1864,6 +2038,36 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/01/0e/b27cdbaccf30b890c40ed1da9fd4a3593a5cf94dae54fb34f8a4b74fcd3f/jsonschema_specifications-2025.4.1-py3-none-any.whl", hash = "sha256:4653bffbd6584f7de83a67e0d620ef16900b390ddc7939d56684d6c81e33f1af", size = 18437 }, ] +[[package]] +name = "jupyter-client" +version = "8.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-core" }, + { name = "python-dateutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/71/22/bf9f12fdaeae18019a468b68952a60fe6dbab5d67cd2a103cac7659b41ca/jupyter_client-8.6.3.tar.gz", hash = "sha256:35b3a0947c4a6e9d589eb97d7d4cd5e90f910ee73101611f01283732bd6d9419", size = 342019 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/11/85/b0394e0b6fcccd2c1eeefc230978a6f8cb0c5df1e4cd3e7625735a0d7d1e/jupyter_client-8.6.3-py3-none-any.whl", hash = "sha256:e8a19cc986cc45905ac3362915f410f3af85424b4c0905e94fa5f2cb08e8f23f", size = 106105 }, +] + +[[package]] +name = "jupyter-core" +version = "5.8.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "platformdirs" }, + { name = "pywin32", marker = "platform_python_implementation != 'PyPy' and sys_platform == 'win32'" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/99/1b/72906d554acfeb588332eaaa6f61577705e9ec752ddb486f302dafa292d9/jupyter_core-5.8.1.tar.gz", hash = "sha256:0a5f9706f70e64786b75acba995988915ebd4601c8a52e534a40b51c95f59941", size = 88923 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2f/57/6bffd4b20b88da3800c5d691e0337761576ee688eb01299eae865689d2df/jupyter_core-5.8.1-py3-none-any.whl", hash = "sha256:c28d268fc90fb53f1338ded2eb410704c5449a358406e8a948b75706e24863d0", size = 28880 }, +] + [[package]] name = "kiwisolver" version = "1.4.9" @@ -2504,6 +2708,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/fc/66/cd29ebc7f6c0d2a15d216fb572573e8fc38bd5d6dec3bd9d7d904c0949f7/matplotlib-3.10.5-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6c49465bf689c4d59d174d0c7795fb42a21d4244d11d70e52b8011987367ac61", size = 8672192 }, ] +[[package]] +name = "matplotlib-inline" +version = "0.1.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/99/5b/a36a337438a14116b16480db471ad061c36c3694df7c2084a0da7ba538b7/matplotlib_inline-0.1.7.tar.gz", hash = "sha256:8423b23ec666be3d16e16b60bdd8ac4e86e840ebd1dd11a30b9f117f2fa0ab90", size = 8159 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8f/8e/9ad090d3553c280a8060fbf6e24dc1c0c29704ee7d1c372f0c174aa59285/matplotlib_inline-0.1.7-py3-none-any.whl", hash = "sha256:df192d39a4ff8f21b1895d72e6a13f5fcc5099f00fa84384e0ea28c2cc0653ca", size = 9899 }, +] + [[package]] name = "mcp" version = "1.13.0" @@ -2652,6 +2868,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963 }, ] +[[package]] +name = "nest-asyncio" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/83/f8/51569ac65d696c8ecbee95938f89d4abf00f47d58d48f6fbabfe8f0baefe/nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe", size = 7418 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/c4/c2971a3ba4c6103a3d10c4b0f24f461ddc027f0f09763220cf35ca1401b3/nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c", size = 5195 }, +] + [[package]] name = "networkx" version = "3.4.2" @@ -2960,6 +3185,27 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/d5/f9/07086f5b0f2a19872554abeea7658200824f5835c58a106fa8f2ae96a46c/pandas-2.3.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:5db9637dbc24b631ff3707269ae4559bce4b7fd75c1c4d7e13f40edc42df4444", size = 13189044 }, ] +[[package]] +name = "parso" +version = "0.8.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/66/94/68e2e17afaa9169cf6412ab0f28623903be73d1b32e208d9e8e541bb086d/parso-0.8.4.tar.gz", hash = "sha256:eb3a7b58240fb99099a345571deecc0f9540ea5f4dd2fe14c2a99d6b281ab92d", size = 400609 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c6/ac/dac4a63f978e4dcb3c6d3a78c4d8e0192a113d288502a1216950c41b1027/parso-0.8.4-py2.py3-none-any.whl", hash = "sha256:a418670a20291dacd2dddc80c377c5c3791378ee1e8d12bffc35420643d43f18", size = 103650 }, +] + +[[package]] +name = "pexpect" +version = "4.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ptyprocess" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523", size = 63772 }, +] + [[package]] name = "pillow" version = "11.3.0" @@ -3062,6 +3308,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/34/e7/ae39f538fd6844e982063c3a5e4598b8ced43b9633baa3a85ef33af8c05c/pillow-11.3.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:c84d689db21a1c397d001aa08241044aa2069e7587b398c8cc63020390b1c1b8", size = 6984598 }, ] +[[package]] +name = "platformdirs" +version = "4.3.8" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fe/8b/3c73abc9c759ecd3f1f7ceff6685840859e8070c4d947c93fae71f6a0bf2/platformdirs-4.3.8.tar.gz", hash = "sha256:3d512d96e16bcb959a814c9f348431070822a6496326a4be0911c40b5a74c2bc", size = 21362 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fe/39/979e8e21520d4e47a0bbe349e2713c0aac6f3d853d0e5b34d76206c439aa/platformdirs-4.3.8-py3-none-any.whl", hash = "sha256:ff7059bb7eb1179e2685604f4aaf157cfd9535242bd23742eadc3c13542139b4", size = 18567 }, +] + [[package]] name = "pluggy" version = "1.6.0" @@ -3071,6 +3326,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538 }, ] +[[package]] +name = "prompt-toolkit" +version = "3.0.51" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "wcwidth" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bb/6e/9d084c929dfe9e3bfe0c6a47e31f78a25c54627d64a66e884a8bf5474f1c/prompt_toolkit-3.0.51.tar.gz", hash = "sha256:931a162e3b27fc90c86f1b48bb1fb2c528c2761475e57c9c06de13311c7b54ed", size = 428940 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ce/4f/5249960887b1fbe561d9ff265496d170b55a735b76724f10ef19f9e40716/prompt_toolkit-3.0.51-py3-none-any.whl", hash = "sha256:52742911fde84e2d423e2f9a4cf1de7d7ac4e51958f648d9540e0fb8db077b07", size = 387810 }, +] + [[package]] name = "propcache" version = "0.3.2" @@ -3186,6 +3453,39 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/9c/f2/80ffc4677aac1bc3519b26bc7f7f5de7fce0ee2f7e36e59e27d8beb32dd1/protobuf-6.32.0-py3-none-any.whl", hash = "sha256:ba377e5b67b908c8f3072a57b63e2c6a4cbd18aea4ed98d2584350dbf46f2783", size = 169287 }, ] +[[package]] +name = "psutil" +version = "7.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2a/80/336820c1ad9286a4ded7e845b2eccfcb27851ab8ac6abece774a6ff4d3de/psutil-7.0.0.tar.gz", hash = "sha256:7be9c3eba38beccb6495ea33afd982a44074b78f28c434a1f51cc07fd315c456", size = 497003 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ed/e6/2d26234410f8b8abdbf891c9da62bee396583f713fb9f3325a4760875d22/psutil-7.0.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:101d71dc322e3cffd7cea0650b09b3d08b8e7c4109dd6809fe452dfd00e58b25", size = 238051 }, + { url = "https://files.pythonhosted.org/packages/04/8b/30f930733afe425e3cbfc0e1468a30a18942350c1a8816acfade80c005c4/psutil-7.0.0-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:39db632f6bb862eeccf56660871433e111b6ea58f2caea825571951d4b6aa3da", size = 239535 }, + { url = "https://files.pythonhosted.org/packages/2a/ed/d362e84620dd22876b55389248e522338ed1bf134a5edd3b8231d7207f6d/psutil-7.0.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1fcee592b4c6f146991ca55919ea3d1f8926497a713ed7faaf8225e174581e91", size = 275004 }, + { url = "https://files.pythonhosted.org/packages/bf/b9/b0eb3f3cbcb734d930fdf839431606844a825b23eaf9a6ab371edac8162c/psutil-7.0.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b1388a4f6875d7e2aff5c4ca1cc16c545ed41dd8bb596cefea80111db353a34", size = 277986 }, + { url = "https://files.pythonhosted.org/packages/eb/a2/709e0fe2f093556c17fbafda93ac032257242cabcc7ff3369e2cb76a97aa/psutil-7.0.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a5f098451abc2828f7dc6b58d44b532b22f2088f4999a937557b603ce72b1993", size = 279544 }, + { url = "https://files.pythonhosted.org/packages/50/e6/eecf58810b9d12e6427369784efe814a1eec0f492084ce8eb8f4d89d6d61/psutil-7.0.0-cp37-abi3-win32.whl", hash = "sha256:ba3fcef7523064a6c9da440fc4d6bd07da93ac726b5733c29027d7dc95b39d99", size = 241053 }, + { url = "https://files.pythonhosted.org/packages/50/1b/6921afe68c74868b4c9fa424dad3be35b095e16687989ebbb50ce4fceb7c/psutil-7.0.0-cp37-abi3-win_amd64.whl", hash = "sha256:4cf3d4eb1aa9b348dec30105c55cd9b7d4629285735a102beb4441e38db90553", size = 244885 }, +] + +[[package]] +name = "ptyprocess" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220", size = 70762 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", size = 13993 }, +] + +[[package]] +name = "pure-eval" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42", size = 19752 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0", size = 11842 }, +] + [[package]] name = "pyaml" version = "25.7.0" @@ -3572,6 +3872,79 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/fa/de/02b54f42487e3d3c6efb3f89428677074ca7bf43aae402517bc7cca949f3/PyYAML-6.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:8388ee1976c416731879ac16da0aff3f63b286ffdd57cdeb95f3f2e085687563", size = 156446 }, ] +[[package]] +name = "pyzmq" +version = "27.0.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "implementation_name == 'pypy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f8/66/159f38d184f08b5f971b467f87b1ab142ab1320d5200825c824b32b84b66/pyzmq-27.0.2.tar.gz", hash = "sha256:b398dd713b18de89730447347e96a0240225e154db56e35b6bb8447ffdb07798", size = 281440 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/83/4d/2081cd7e41e340004d2051821efe1d0d67d31bdb5ac33bffc7e628d5f1bd/pyzmq-27.0.2-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:8b32c4636ced87dce0ac3d671e578b3400215efab372f1b4be242e8cf0b11384", size = 1329839 }, + { url = "https://files.pythonhosted.org/packages/ad/f1/1300b7e932671e31accb3512c19b43e6a3e8d08c54ab8b920308e53427ce/pyzmq-27.0.2-cp310-cp310-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:f9528a4b3e24189cb333a9850fddbbafaa81df187297cfbddee50447cdb042cf", size = 906367 }, + { url = "https://files.pythonhosted.org/packages/e6/80/61662db85eb3255a58c1bb59f6d4fc0d31c9c75b9a14983deafab12b2329/pyzmq-27.0.2-cp310-cp310-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3b02ba0c0b2b9ebe74688002e6c56c903429924a25630804b9ede1f178aa5a3f", size = 666545 }, + { url = "https://files.pythonhosted.org/packages/5c/6e/49fb9c75b039978cbb1f3657811d8056b0ebe6ecafd78a4457fc6de19799/pyzmq-27.0.2-cp310-cp310-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9e4dc5c9a6167617251dea0d024d67559795761aabb4b7ea015518be898be076", size = 854219 }, + { url = "https://files.pythonhosted.org/packages/b0/3c/9951b302d221e471b7c659e70f9cb64db5f68fa3b7da45809ec4e6c6ef17/pyzmq-27.0.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:f1151b33aaf3b4fa9da26f4d696e38eebab67d1b43c446184d733c700b3ff8ce", size = 1655103 }, + { url = "https://files.pythonhosted.org/packages/88/ca/d7adea6100fdf7f87f3856db02d2a0a45ce2764b9f60ba08c48c655b762f/pyzmq-27.0.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:4ecfc7999ac44c9ef92b5ae8f0b44fb935297977df54d8756b195a3cd12f38f0", size = 2033712 }, + { url = "https://files.pythonhosted.org/packages/e9/63/b34e601b36ba4864d02ac1460443fc39bf533dedbdeead2a4e0df7dfc8ee/pyzmq-27.0.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:31c26a5d0b00befcaeeb600d8b15ad09f5604b6f44e2057ec5e521a9e18dcd9a", size = 1891847 }, + { url = "https://files.pythonhosted.org/packages/cf/a2/9479e6af779da44f788d5fcda5f77dff1af988351ef91682b92524eab2db/pyzmq-27.0.2-cp310-cp310-win32.whl", hash = "sha256:25a100d2de2ac0c644ecf4ce0b509a720d12e559c77aff7e7e73aa684f0375bc", size = 567136 }, + { url = "https://files.pythonhosted.org/packages/58/46/e1c2be469781fc56ba092fecb1bb336cedde0fd87d9e1a547aaeb5d1a968/pyzmq-27.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:a1acf091f53bb406e9e5e7383e467d1dd1b94488b8415b890917d30111a1fef3", size = 631969 }, + { url = "https://files.pythonhosted.org/packages/d5/8d/d20a62f1f77e3f04633a80bb83df085e4314f0e9404619cc458d0005d6ab/pyzmq-27.0.2-cp310-cp310-win_arm64.whl", hash = "sha256:b38e01f11e9e95f6668dc8a62dccf9483f454fed78a77447507a0e8dcbd19a63", size = 559459 }, + { url = "https://files.pythonhosted.org/packages/42/73/034429ab0f4316bf433eb6c20c3f49d1dc13b2ed4e4d951b283d300a0f35/pyzmq-27.0.2-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:063845960df76599ad4fad69fa4d884b3ba38304272104fdcd7e3af33faeeb1d", size = 1333169 }, + { url = "https://files.pythonhosted.org/packages/35/02/c42b3b526eb03a570c889eea85a5602797f800a50ba8b09ddbf7db568b78/pyzmq-27.0.2-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:845a35fb21b88786aeb38af8b271d41ab0967985410f35411a27eebdc578a076", size = 909176 }, + { url = "https://files.pythonhosted.org/packages/1b/35/a1c0b988fabbdf2dc5fe94b7c2bcfd61e3533e5109297b8e0daf1d7a8d2d/pyzmq-27.0.2-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:515d20b5c3c86db95503faa989853a8ab692aab1e5336db011cd6d35626c4cb1", size = 668972 }, + { url = "https://files.pythonhosted.org/packages/a0/63/908ac865da32ceaeecea72adceadad28ca25b23a2ca5ff018e5bff30116f/pyzmq-27.0.2-cp311-cp311-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:862aedec0b0684a5050cdb5ec13c2da96d2f8dffda48657ed35e312a4e31553b", size = 856962 }, + { url = "https://files.pythonhosted.org/packages/2f/5a/90b3cc20b65cdf9391896fcfc15d8db21182eab810b7ea05a2986912fbe2/pyzmq-27.0.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2cb5bcfc51c7a4fce335d3bc974fd1d6a916abbcdd2b25f6e89d37b8def25f57", size = 1657712 }, + { url = "https://files.pythonhosted.org/packages/c4/3c/32a5a80f9be4759325b8d7b22ce674bb87e586b4c80c6a9d77598b60d6f0/pyzmq-27.0.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:38ff75b2a36e3a032e9fef29a5871e3e1301a37464e09ba364e3c3193f62982a", size = 2035054 }, + { url = "https://files.pythonhosted.org/packages/13/61/71084fe2ff2d7dc5713f8740d735336e87544845dae1207a8e2e16d9af90/pyzmq-27.0.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:7a5709abe8d23ca158a9d0a18c037f4193f5b6afeb53be37173a41e9fb885792", size = 1894010 }, + { url = "https://files.pythonhosted.org/packages/cb/6b/77169cfb13b696e50112ca496b2ed23c4b7d8860a1ec0ff3e4b9f9926221/pyzmq-27.0.2-cp311-cp311-win32.whl", hash = "sha256:47c5dda2018c35d87be9b83de0890cb92ac0791fd59498847fc4eca6ff56671d", size = 566819 }, + { url = "https://files.pythonhosted.org/packages/37/cd/86c4083e0f811f48f11bc0ddf1e7d13ef37adfd2fd4f78f2445f1cc5dec0/pyzmq-27.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:f54ca3e98f8f4d23e989c7d0edcf9da7a514ff261edaf64d1d8653dd5feb0a8b", size = 633264 }, + { url = "https://files.pythonhosted.org/packages/a0/69/5b8bb6a19a36a569fac02153a9e083738785892636270f5f68a915956aea/pyzmq-27.0.2-cp311-cp311-win_arm64.whl", hash = "sha256:2ef3067cb5b51b090fb853f423ad7ed63836ec154374282780a62eb866bf5768", size = 559316 }, + { url = "https://files.pythonhosted.org/packages/68/69/b3a729e7b03e412bee2b1823ab8d22e20a92593634f664afd04c6c9d9ac0/pyzmq-27.0.2-cp312-abi3-macosx_10_15_universal2.whl", hash = "sha256:5da05e3c22c95e23bfc4afeee6ff7d4be9ff2233ad6cb171a0e8257cd46b169a", size = 1305910 }, + { url = "https://files.pythonhosted.org/packages/15/b7/f6a6a285193d489b223c340b38ee03a673467cb54914da21c3d7849f1b10/pyzmq-27.0.2-cp312-abi3-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:4e4520577971d01d47e2559bb3175fce1be9103b18621bf0b241abe0a933d040", size = 895507 }, + { url = "https://files.pythonhosted.org/packages/17/e6/c4ed2da5ef9182cde1b1f5d0051a986e76339d71720ec1a00be0b49275ad/pyzmq-27.0.2-cp312-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:56d7de7bf73165b90bd25a8668659ccb134dd28449116bf3c7e9bab5cf8a8ec9", size = 652670 }, + { url = "https://files.pythonhosted.org/packages/0e/66/d781ab0636570d32c745c4e389b1c6b713115905cca69ab6233508622edd/pyzmq-27.0.2-cp312-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:340e7cddc32f147c6c00d116a3f284ab07ee63dbd26c52be13b590520434533c", size = 840581 }, + { url = "https://files.pythonhosted.org/packages/a6/df/f24790caf565d72544f5c8d8500960b9562c1dc848d6f22f3c7e122e73d4/pyzmq-27.0.2-cp312-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:ba95693f9df8bb4a9826464fb0fe89033936f35fd4a8ff1edff09a473570afa0", size = 1641931 }, + { url = "https://files.pythonhosted.org/packages/65/65/77d27b19fc5e845367f9100db90b9fce924f611b14770db480615944c9c9/pyzmq-27.0.2-cp312-abi3-musllinux_1_2_i686.whl", hash = "sha256:ca42a6ce2d697537da34f77a1960d21476c6a4af3e539eddb2b114c3cf65a78c", size = 2021226 }, + { url = "https://files.pythonhosted.org/packages/5b/65/1ed14421ba27a4207fa694772003a311d1142b7f543179e4d1099b7eb746/pyzmq-27.0.2-cp312-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:3e44e665d78a07214b2772ccbd4b9bcc6d848d7895f1b2d7653f047b6318a4f6", size = 1878047 }, + { url = "https://files.pythonhosted.org/packages/dd/dc/e578549b89b40dc78a387ec471c2a360766690c0a045cd8d1877d401012d/pyzmq-27.0.2-cp312-abi3-win32.whl", hash = "sha256:272d772d116615397d2be2b1417b3b8c8bc8671f93728c2f2c25002a4530e8f6", size = 558757 }, + { url = "https://files.pythonhosted.org/packages/b5/89/06600980aefcc535c758414da969f37a5194ea4cdb73b745223f6af3acfb/pyzmq-27.0.2-cp312-abi3-win_amd64.whl", hash = "sha256:734be4f44efba0aa69bf5f015ed13eb69ff29bf0d17ea1e21588b095a3147b8e", size = 619281 }, + { url = "https://files.pythonhosted.org/packages/30/84/df8a5c089552d17c9941d1aea4314b606edf1b1622361dae89aacedc6467/pyzmq-27.0.2-cp312-abi3-win_arm64.whl", hash = "sha256:41f0bd56d9279392810950feb2785a419c2920bbf007fdaaa7f4a07332ae492d", size = 552680 }, + { url = "https://files.pythonhosted.org/packages/b4/7b/b79e976508517ab80dc800f7021ef1fb602a6d55e4caa2d47fb3dca5d8b6/pyzmq-27.0.2-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:7f01118133427cd7f34ee133b5098e2af5f70303fa7519785c007bca5aa6f96a", size = 1122259 }, + { url = "https://files.pythonhosted.org/packages/2b/1c/777217b9940ebcb7e71c924184ca5f31e410580a58d9fd93798589f0d31c/pyzmq-27.0.2-cp313-cp313-android_24_x86_64.whl", hash = "sha256:e4b860edf6379a7234ccbb19b4ed2c57e3ff569c3414fadfb49ae72b61a8ef07", size = 1156113 }, + { url = "https://files.pythonhosted.org/packages/59/7d/654657a4c6435f41538182e71b61eac386a789a2bbb6f30171915253a9a7/pyzmq-27.0.2-cp313-cp313t-macosx_10_15_universal2.whl", hash = "sha256:cb77923ea163156da14295c941930bd525df0d29c96c1ec2fe3c3806b1e17cb3", size = 1341437 }, + { url = "https://files.pythonhosted.org/packages/20/a0/5ed7710037f9c096017adc748bcb1698674a2d297f8b9422d38816f7b56a/pyzmq-27.0.2-cp313-cp313t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:61678b7407b04df8f9423f188156355dc94d0fb52d360ae79d02ed7e0d431eea", size = 897888 }, + { url = "https://files.pythonhosted.org/packages/2c/8a/6e4699a60931c17e7406641d201d7f2c121e2a38979bc83226a6d8f1ba32/pyzmq-27.0.2-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e3c824b70925963bdc8e39a642672c15ffaa67e7d4b491f64662dd56d6271263", size = 660727 }, + { url = "https://files.pythonhosted.org/packages/7b/d8/d761e438c186451bd89ce63a665cde5690c084b61cd8f5d7b51e966e875a/pyzmq-27.0.2-cp313-cp313t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c4833e02fcf2751975457be1dfa2f744d4d09901a8cc106acaa519d868232175", size = 848136 }, + { url = "https://files.pythonhosted.org/packages/43/f1/a0f31684efdf3eb92f46b7dd2117e752208115e89d278f8ca5f413c5bb85/pyzmq-27.0.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:b18045668d09cf0faa44918af2a67f0dbbef738c96f61c2f1b975b1ddb92ccfc", size = 1650402 }, + { url = "https://files.pythonhosted.org/packages/41/fd/0d7f2a1732812df02c85002770da4a7864c79b210084bcdab01ea57e8d92/pyzmq-27.0.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:bbbb7e2f3ac5a22901324e7b086f398b8e16d343879a77b15ca3312e8cd8e6d5", size = 2024587 }, + { url = "https://files.pythonhosted.org/packages/f1/73/358be69e279a382dd09e46dda29df8446365cddee4f79ef214e71e5b2b5a/pyzmq-27.0.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:b751914a73604d40d88a061bab042a11d4511b3ddbb7624cd83c39c8a498564c", size = 1885493 }, + { url = "https://files.pythonhosted.org/packages/c5/7b/e9951ad53b3dfed8cfb4c2cfd6e0097c9b454e5c0d0e6df5f2b60d7c8c3d/pyzmq-27.0.2-cp313-cp313t-win32.whl", hash = "sha256:3e8f833dd82af11db5321c414638045c70f61009f72dd61c88db4a713c1fb1d2", size = 574934 }, + { url = "https://files.pythonhosted.org/packages/55/33/1a7fc3a92f2124a63e6e2a6afa0af471a5c0c713e776b476d4eda5111b13/pyzmq-27.0.2-cp313-cp313t-win_amd64.whl", hash = "sha256:5b45153cb8eadcab14139970643a84f7a7b08dda541fbc1f6f4855c49334b549", size = 640932 }, + { url = "https://files.pythonhosted.org/packages/2a/52/2598a94ac251a7c83f3887866225eea1952b0d4463a68df5032eb00ff052/pyzmq-27.0.2-cp313-cp313t-win_arm64.whl", hash = "sha256:86898f5c9730df23427c1ee0097d8aa41aa5f89539a79e48cd0d2c22d059f1b7", size = 561315 }, + { url = "https://files.pythonhosted.org/packages/42/7d/10ef02ea36590b29d48ef88eb0831f0af3eb240cccca2752556faec55f59/pyzmq-27.0.2-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:d2b4b261dce10762be5c116b6ad1f267a9429765b493c454f049f33791dd8b8a", size = 1341463 }, + { url = "https://files.pythonhosted.org/packages/94/36/115d18dade9a3d4d3d08dd8bfe5459561b8e02815f99df040555fdd7768e/pyzmq-27.0.2-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:4e4d88b6cff156fed468903006b24bbd85322612f9c2f7b96e72d5016fd3f543", size = 897840 }, + { url = "https://files.pythonhosted.org/packages/39/66/083b37839b95c386a95f1537bb41bdbf0c002b7c55b75ee737949cecb11f/pyzmq-27.0.2-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8426c0ebbc11ed8416a6e9409c194142d677c2c5c688595f2743664e356d9e9b", size = 660704 }, + { url = "https://files.pythonhosted.org/packages/76/5a/196ab46e549ba35bf3268f575e10cfac0dc86b78dcaa7a3e36407ecda752/pyzmq-27.0.2-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:565bee96a155fe6452caed5fb5f60c9862038e6b51a59f4f632562081cdb4004", size = 848037 }, + { url = "https://files.pythonhosted.org/packages/70/ea/a27b9eb44b2e615a9ecb8510ebb023cc1d2d251181e4a1e50366bfbf94d6/pyzmq-27.0.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5de735c745ca5cefe9c2d1547d8f28cfe1b1926aecb7483ab1102fd0a746c093", size = 1650278 }, + { url = "https://files.pythonhosted.org/packages/62/ac/3e9af036bfaf718ab5e69ded8f6332da392c5450ad43e8e3ca66797f145a/pyzmq-27.0.2-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:ea4f498f8115fd90d7bf03a3e83ae3e9898e43362f8e8e8faec93597206e15cc", size = 2024504 }, + { url = "https://files.pythonhosted.org/packages/ae/e9/3202d31788df8ebaa176b23d846335eb9c768d8b43c0506bbd6265ad36a0/pyzmq-27.0.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d00e81cb0afd672915257a3927124ee2ad117ace3c256d39cd97ca3f190152ad", size = 1885381 }, + { url = "https://files.pythonhosted.org/packages/4b/ed/42de80b7ab4e8fcf13376f81206cf8041740672ac1fd2e1c598d63f595bf/pyzmq-27.0.2-cp314-cp314t-win32.whl", hash = "sha256:0f6e9b00d81b58f859fffc112365d50413954e02aefe36c5b4c8fb4af79f8cc3", size = 587526 }, + { url = "https://files.pythonhosted.org/packages/ed/c8/8f3c72d6f0bfbf090aa5e283576073ca5c59839b85a5cc8c66ddb9b59801/pyzmq-27.0.2-cp314-cp314t-win_amd64.whl", hash = "sha256:2e73cf3b127a437fef4100eb3ac2ebe6b49e655bb721329f667f59eca0a26221", size = 661368 }, + { url = "https://files.pythonhosted.org/packages/69/a4/7ee652ea1c77d872f5d99ed937fa8bbd1f6f4b7a39a6d3a0076c286e0c3e/pyzmq-27.0.2-cp314-cp314t-win_arm64.whl", hash = "sha256:4108785f2e5ac865d06f678a07a1901e3465611356df21a545eeea8b45f56265", size = 574901 }, + { url = "https://files.pythonhosted.org/packages/19/d7/e388e80107b7c438c9698ce59c2a3b950021cd4ab3fe641485e4ed6b0960/pyzmq-27.0.2-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:d67a0960803a37b60f51b460c58444bc7033a804c662f5735172e21e74ee4902", size = 836008 }, + { url = "https://files.pythonhosted.org/packages/65/ef/58d3eb85f1b67a16e22adb07d084f975a7b9641463d18e27230550bb436a/pyzmq-27.0.2-pp310-pypy310_pp73-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:dd4d3e6a567ffd0d232cfc667c49d0852d0ee7481458a2a1593b9b1bc5acba88", size = 799932 }, + { url = "https://files.pythonhosted.org/packages/3c/63/66b9f6db19ee8c86105ffd4475a4f5d93cdd62b1edcb1e894d971df0728c/pyzmq-27.0.2-pp310-pypy310_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5e558be423631704803bc6a642e2caa96083df759e25fe6eb01f2d28725f80bd", size = 567458 }, + { url = "https://files.pythonhosted.org/packages/10/af/d92207fe8b6e3d9f588d0591219a86dd7b4ed27bb3e825c1d9cf48467fc0/pyzmq-27.0.2-pp310-pypy310_pp73-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c4c20ba8389f495c7b4f6b896bb1ca1e109a157d4f189267a902079699aaf787", size = 747087 }, + { url = "https://files.pythonhosted.org/packages/82/e9/d9f8b4b191c6733e31de28974d608a2475a6598136ac901a8c5b67c11432/pyzmq-27.0.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:c5be232f7219414ff672ff7ab8c5a7e8632177735186d8a42b57b491fafdd64e", size = 544641 }, + { url = "https://files.pythonhosted.org/packages/c7/60/027d0032a1e3b1aabcef0e309b9ff8a4099bdd5a60ab38b36a676ff2bd7b/pyzmq-27.0.2-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:e297784aea724294fe95e442e39a4376c2f08aa4fae4161c669f047051e31b02", size = 836007 }, + { url = "https://files.pythonhosted.org/packages/25/20/2ed1e6168aaea323df9bb2c451309291f53ba3af372ffc16edd4ce15b9e5/pyzmq-27.0.2-pp311-pypy311_pp73-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:e3659a79ded9745bc9c2aef5b444ac8805606e7bc50d2d2eb16dc3ab5483d91f", size = 799932 }, + { url = "https://files.pythonhosted.org/packages/fd/25/5c147307de546b502c9373688ce5b25dc22288d23a1ebebe5d587bf77610/pyzmq-27.0.2-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f3dba49ff037d02373a9306b58d6c1e0be031438f822044e8767afccfdac4c6b", size = 567459 }, + { url = "https://files.pythonhosted.org/packages/71/06/0dc56ffc615c8095cd089c9b98ce5c733e990f09ce4e8eea4aaf1041a532/pyzmq-27.0.2-pp311-pypy311_pp73-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:de84e1694f9507b29e7b263453a2255a73e3d099d258db0f14539bad258abe41", size = 747088 }, + { url = "https://files.pythonhosted.org/packages/06/f6/4a50187e023b8848edd3f0a8e197b1a7fb08d261d8c60aae7cb6c3d71612/pyzmq-27.0.2-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:f0944d65ba2b872b9fcece08411d6347f15a874c775b4c3baae7f278550da0fb", size = 544639 }, +] + [[package]] name = "referencing" version = "0.36.2" @@ -4301,6 +4674,20 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/ef/10/c78f463b4ef22eef8491f218f692be838282cd65480f6e423d7730dfd1fb/sse_starlette-3.0.2-py3-none-any.whl", hash = "sha256:16b7cbfddbcd4eaca11f7b586f3b8a080f1afe952c15813455b162edea619e5a", size = 11297 }, ] +[[package]] +name = "stack-data" +version = "0.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "asttokens" }, + { name = "executing" }, + { name = "pure-eval" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9", size = 44707 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521 }, +] + [[package]] name = "starlette" version = "0.47.2" @@ -4453,6 +4840,25 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/6e/c2/61d3e0f47e2b74ef40a68b9e6ad5984f6241a942f7cd3bbfbdbd03861ea9/tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc", size = 14257 }, ] +[[package]] +name = "tornado" +version = "6.5.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/09/ce/1eb500eae19f4648281bb2186927bb062d2438c2e5093d1360391afd2f90/tornado-6.5.2.tar.gz", hash = "sha256:ab53c8f9a0fa351e2c0741284e06c7a45da86afb544133201c5cc8578eb076a0", size = 510821 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f6/48/6a7529df2c9cc12efd2e8f5dd219516184d703b34c06786809670df5b3bd/tornado-6.5.2-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:2436822940d37cde62771cff8774f4f00b3c8024fe482e16ca8387b8a2724db6", size = 442563 }, + { url = "https://files.pythonhosted.org/packages/f2/b5/9b575a0ed3e50b00c40b08cbce82eb618229091d09f6d14bce80fc01cb0b/tornado-6.5.2-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:583a52c7aa94ee046854ba81d9ebb6c81ec0fd30386d96f7640c96dad45a03ef", size = 440729 }, + { url = "https://files.pythonhosted.org/packages/1b/4e/619174f52b120efcf23633c817fd3fed867c30bff785e2cd5a53a70e483c/tornado-6.5.2-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b0fe179f28d597deab2842b86ed4060deec7388f1fd9c1b4a41adf8af058907e", size = 444295 }, + { url = "https://files.pythonhosted.org/packages/95/fa/87b41709552bbd393c85dd18e4e3499dcd8983f66e7972926db8d96aa065/tornado-6.5.2-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b186e85d1e3536d69583d2298423744740986018e393d0321df7340e71898882", size = 443644 }, + { url = "https://files.pythonhosted.org/packages/f9/41/fb15f06e33d7430ca89420283a8762a4e6b8025b800ea51796ab5e6d9559/tornado-6.5.2-cp39-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e792706668c87709709c18b353da1f7662317b563ff69f00bab83595940c7108", size = 443878 }, + { url = "https://files.pythonhosted.org/packages/11/92/fe6d57da897776ad2e01e279170ea8ae726755b045fe5ac73b75357a5a3f/tornado-6.5.2-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:06ceb1300fd70cb20e43b1ad8aaee0266e69e7ced38fa910ad2e03285009ce7c", size = 444549 }, + { url = "https://files.pythonhosted.org/packages/9b/02/c8f4f6c9204526daf3d760f4aa555a7a33ad0e60843eac025ccfd6ff4a93/tornado-6.5.2-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:74db443e0f5251be86cbf37929f84d8c20c27a355dd452a5cfa2aada0d001ec4", size = 443973 }, + { url = "https://files.pythonhosted.org/packages/ae/2d/f5f5707b655ce2317190183868cd0f6822a1121b4baeae509ceb9590d0bd/tornado-6.5.2-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b5e735ab2889d7ed33b32a459cac490eda71a1ba6857b0118de476ab6c366c04", size = 443954 }, + { url = "https://files.pythonhosted.org/packages/e8/59/593bd0f40f7355806bf6573b47b8c22f8e1374c9b6fd03114bd6b7a3dcfd/tornado-6.5.2-cp39-abi3-win32.whl", hash = "sha256:c6f29e94d9b37a95013bb669616352ddb82e3bfe8326fccee50583caebc8a5f0", size = 445023 }, + { url = "https://files.pythonhosted.org/packages/c7/2a/f609b420c2f564a748a2d80ebfb2ee02a73ca80223af712fca591386cafb/tornado-6.5.2-cp39-abi3-win_amd64.whl", hash = "sha256:e56a5af51cc30dd2cae649429af65ca2f6571da29504a07995175df14c18f35f", size = 445427 }, + { url = "https://files.pythonhosted.org/packages/5e/4f/e1f65e8f8c76d73658b33d33b81eed4322fb5085350e4328d5c956f0c8f9/tornado-6.5.2-cp39-abi3-win_arm64.whl", hash = "sha256:d6c33dc3672e3a1f3618eb63b7ef4683a7688e7b9e6e8f0d9aa5726360a004af", size = 444456 }, +] + [[package]] name = "tqdm" version = "4.67.1" @@ -4465,6 +4871,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/d0/30/dc54f88dd4a2b5dc8a0279bdd7270e735851848b762aeb1c1184ed1f6b14/tqdm-4.67.1-py3-none-any.whl", hash = "sha256:26445eca388f82e72884e0d580d5464cd801a3ea01e63e5601bdff9ba6a48de2", size = 78540 }, ] +[[package]] +name = "traitlets" +version = "5.14.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/eb/79/72064e6a701c2183016abbbfedaba506d81e30e232a68c9f0d6f6fcd1574/traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7", size = 161621 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f", size = 85359 }, +] + [[package]] name = "trieregex" version = "1.0.0" @@ -4725,6 +5140,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/bd/d3/254cea30f918f489db09d6a8435a7de7047f8cb68584477a515f160541d6/watchfiles-1.1.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:923fec6e5461c42bd7e3fd5ec37492c6f3468be0499bc0707b4bbbc16ac21792", size = 454009 }, ] +[[package]] +name = "wcwidth" +version = "0.2.13" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6c/63/53559446a878410fc5a5974feb13d31d78d752eb18aeba59c7fef1af7598/wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5", size = 101301 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fd/84/fd2ba7aafacbad3c4201d395674fc6348826569da3c0937e75505ead3528/wcwidth-0.2.13-py2.py3-none-any.whl", hash = "sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859", size = 34166 }, +] + [[package]] name = "websockets" version = "15.0.1" From 1e3e703de5e2a406810293064ec4884839bf8a56 Mon Sep 17 00:00:00 2001 From: JaskaranIntugle Date: Fri, 22 Aug 2025 12:29:56 +0530 Subject: [PATCH 2/3] included autosave in run, added quickstart notebook --- .gitignore | 2 + README.md | 160 +-- notebooks/quickstart.ipynb | 1054 ----------------- notebooks/quickstart_content.txt | 61 +- quickstart.ipynb | 349 ++++++ src/data_tools/analysis/models.py | 5 +- .../core/pipeline/business_glossary/utils.py | 2 +- src/data_tools/link_predictor/predictor.py | 3 +- 8 files changed, 461 insertions(+), 1175 deletions(-) delete mode 100644 notebooks/quickstart.ipynb create mode 100644 quickstart.ipynb diff --git a/.gitignore b/.gitignore index 52b89d7..f8135bf 100644 --- a/.gitignore +++ b/.gitignore @@ -208,3 +208,5 @@ __marimo__/ notes.txt testing_base + +settings.json diff --git a/README.md b/README.md index b9de557..1007af5 100644 --- a/README.md +++ b/README.md @@ -1,142 +1,86 @@ -# Data Tools: Automated Data Understanding and Integration +# Data-Tools -Data Tools is a Python library designed to automate the complex process of understanding and connecting siloed datasets. In modern data environments, tables are often disconnected and poorly documented. This library tackles that challenge head-on by providing two primary capabilities: +[![Release](https://img.shields.io/github/release/Intugle/data-tools)](https://github.com/Intugle/data-tools/releases/tag/v0.1.0) +[![Made with Python](https://img.shields.io/badge/Made_with-Python-blue?logo=python&logoColor=white)](https://www.python.org/) +![contributions - welcome](https://img.shields.io/badge/contributions-welcome-blue) +[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) +[![Open Issues](https://img.shields.io/github/issues-raw/Intugle/data-tools)](https://github.com/Intugle/data-tools/issues) +[![GitHub star chart](https://img.shields.io/github/stars/Intugle/data-tools?style=social)](https://github.com/Intugle/data-tools/stargazers) -1. **Automated Link Prediction**: Its flagship feature, the `LinkPredictor`, analyzes multiple datasets, identifies primary keys, and automatically predicts relationships (foreign key links) between them. -2. **In-Depth Data Profiling**: A flexible, multi-step analysis pipeline that creates a rich profile for each dataset, including data types, column statistics, and generating a business glossary. +*Automated Data Profiling, Link Prediction, and Semantic Layer Generation* -By combining these features, Data Tools helps you move from a collection of separate tables to a fully documented and interconnected data model, ready for integration or analysis. +## Overview -## Core Features +Data-Tools is a Python library that helps you automatically build a semantic layer over your data. It streamlines the process of data profiling, discovering relationships between tables, and generating a business-friendly representation of your data. This makes it easier for both data and business teams to understand and query data without needing to be SQL experts. -- **Automated Link Prediction**: Intelligently discovers potential foreign key relationships across multiple datasets. -- **In-Depth Data Profiling**: A multi-step pipeline that identifies keys, profiles columns, and determines data types. -- **Business Glossary Generation**: Automatically generates business-friendly descriptions and tags for columns and tables based on a provided domain. -- **Extensible Pipeline Architecture**: Easily add custom analysis steps to the pipeline. -- **DataFrame Agnostic**: Uses a factory pattern to seamlessly handle different dataframe types (e.g., pandas). +## Who is this for? -## Installation and Setup +This tool is designed for both **data teams** and **business teams**. -### Installation - -To install the library and its dependencies, run the following command: - -```bash -pip install data_tools -``` +* **Data teams** can use it to automate data profiling, schema discovery, and documentation, significantly accelerating their workflow. +* **Business teams** can use it to gain a better understanding of their data and to perform self-service analytics without needing to write complex SQL queries. -### LLM Configuration +## Features -This library uses LLMs for features like Business Glossary Generation. It supports any LLM provider compatible with LangChain's `init_chat_model` function. To configure your LLM provider, you need to set environment variables. +* **Automated Data Profiling:** Generate detailed statistics for each column in your dataset, including distinct count, uniqueness, completeness, and more. +* **Datatype Identification:** Automatically identify the data type of each column (e.g., integer, string, datetime). +* **Key Identification:** Identify potential primary keys in your tables. +* **LLM-Powered Link Prediction:** Use a Large Language Model (LLM) to automatically discover relationships (foreign keys) between tables. +* **Business Glossary Generation:** Generate a business glossary for each column using an LLM, with support for industry-specific domains. +* **Semantic Layer Generation:** Create a `manifest.json` file that defines your semantic layer, including models (tables) and their relationships. +* **SQL Generation:** Generate SQL queries from the semantic layer, allowing you to query your data using business-friendly terms. +* **Extensible and Configurable:** Configure the tool to work with your specific environment and data sources. -The `LLM_CONFIG` environment variable should be set to your desired model, optionally including the provider, in the format `provider:model_name`. If the provider is omitted, it will try to infer the provider. +## Getting Started -**For OpenAI:** +### Prerequisites -```bash -# Provider is optional -export LLM_CONFIG="gpt-4" -export OPENAI_API_KEY="your-super-secret-key" -``` +* Python 3.10+ +* pip -**For Google GenAI:** +### Installation ```bash -export LLM_CONFIG="google_genai:gemini-pro" -export GOOGLE_API_KEY="your-google-api-key" +pip install data-tools ``` +### Configuration -## Usage Examples +Before running the project, you need to configure a Large Language Model (LLM). This is used for tasks like generating business glossaries and predicting links between tables. -### Example 1: Automated Link Prediction (Primary Use Case) +You can configure the LLM by setting the following environment variables: -This is the most direct way to use the library. Provide a dictionary of named dataframes, and the `LinkPredictor` will automatically run all prerequisite analysis steps and predict the links. +* `LLM_PROVIDER`: The LLM provider and model to use (e.g., `openai:gpt-3.5-turbo`). +* `OPENAI_API_KEY`: Your API key for the LLM provider. -```python -import pandas as pd -from data_tools.link_predictor.predictor import LinkPredictor +Here's an example of how to set these variables in your environment: -# 1. Prepare your collection of dataframes -customers_df = pd.DataFrame({"id": [1, 2, 3], "name": ["A", "B", "C"]}) -orders_df = pd.DataFrame({"order_id": [101, 102], "customer_id": [1, 3]}) - -datasets = { - "customers": customers_df, - "orders": orders_df -} - -# 2. Initialize the predictor -# This automatically runs profiling, key identification, etc., for you. -link_predictor = LinkPredictor(datasets) - -# 3. Predict the links -# (This example assumes you have implemented the logic in _predict_for_pair) -prediction_results = link_predictor.predict() - -# 4. Review the results -print(prediction_results.model_dump_json(indent=2)) +```bash +export LLM_PROVIDER="openai:gpt-3.5-turbo" +export OPENAI_API_KEY="your-openai-api-key" ``` -### Example 2: In-Depth Analysis with the Pipeline - -If you want to perform a deep analysis on a single dataset, you can use the pipeline directly. This gives you fine-grained control over the analysis steps. - -```python -import pandas as pd -from data_tools.analysis.pipeline import Pipeline -from data_tools.analysis.steps import ( - TableProfiler, - KeyIdentifier, - BusinessGlossaryGenerator -) - -# 1. Define your analysis pipeline -pipeline = Pipeline([ - TableProfiler(), - KeyIdentifier(), - BusinessGlossaryGenerator(domain="e-commerce") # Provide context for the glossary -]) - -# 2. Prepare your dataframe -products_df = pd.DataFrame({ - "product_id": [10, 20, 30], - "name": ["Laptop", "Mouse", "Keyboard"], - "unit_price": [1200, 25, 75] -}) - -# 3. Run the pipeline -# The pipeline creates and returns a DataSet object -product_dataset = pipeline.run(df=products_df, name="products") - -# 4. Access the rich analysis results -print(f"Identified Key: {product_dataset.results['key'].column_name}") -print("\n--- Table Glossary ---") -print(product_dataset.results['table_glossary']) -``` +## Quickstart -## Available Analysis Steps +For a detailed, hands-on introduction to the project, please see the [`quickstart.ipynb`](notebooks/quickstart.ipynb) notebook. It will walk you through the entire process of profiling your data, predicting links, generating a semantic layer, and querying your data. -You can construct a custom `Pipeline` using any combination of the following steps: +## Usage -- `TableProfiler`: Gathers basic table-level statistics (row count, column names). -- `ColumnProfiler`: Runs detailed profiling for each column (null counts, distinct counts, samples). -- `DataTypeIdentifierL1` & `L2`: Determines the logical data type for each column through multiple levels of analysis. -- `KeyIdentifier`: Analyzes the profiled data to predict the primary key of the dataset. -- `BusinessGlossaryGenerator(domain: str)`: Generates business-friendly descriptions and tags for all columns and the table itself, using the provided `domain` for context. +The core workflow of the project involves the following steps: -## Running Tests +1. **Load your data:** Load your data into pandas DataFrames. +2. **Create `DataSet` objects:** Create a `DataSet` object for each of your tables. +3. **Run the analysis pipeline:** Use the `run()` method to profile your data and generate a business glossary. +4. **Predict links:** Use the `LinkPredictor` to discover relationships between your tables. +5. **Generate the manifest:** Save the profiling and link prediction results to YAML files and then load them to create a `manifest.json` file. +6. **Generate SQL:** Use the `SqlGenerator` to generate SQL queries from the semantic layer. -To run the test suite, first install the testing dependencies and then execute `pytest` via `uv`. +For detailed code examples, please refer to the [`quickstart.ipynb`](quickstart.ipynb) notebook. -```bash -# Install testing library -uv pip install pytest +## Contributing -# Run tests -uv run pytest -``` +Contributions are welcome! Please see the [`CONTRIBUTING.md`](CONTRIBUTING.md) file for guidelines. ## License -This project is licensed under the terms of the LICENSE file. +This project is licensed under the MIT License. See the [`LICENSE`](LICENSE) file for details. \ No newline at end of file diff --git a/notebooks/quickstart.ipynb b/notebooks/quickstart.ipynb deleted file mode 100644 index 9bc64dd..0000000 --- a/notebooks/quickstart.ipynb +++ /dev/null @@ -1,1054 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "757096f5", - "metadata": {}, - "source": [ - "# Quickstart: Building a Semantic Layer with Data-Tools\n", - "\n", - "This notebook provides a quick introduction to the `data-tools` project. You'll learn how to use its key features to automatically build a semantic layer over your data.\n", - "\n", - "**What is a Semantic Layer?**\n", - "\n", - "A semantic layer is a business-friendly representation of your data. It hides the complexity of the underlying data sources and provides a unified view of your data using familiar business terms. This makes it easier for business users to understand and query the data without needing to be SQL experts.\n", - "\n", - "**In this notebook, you will learn how to:**\n", - "\n", - "1. **Profile your data:** Analyze your data sources to understand their structure, data types, and other characteristics.\n", - "2. **Automatically predict links:** Use a Large Language Model (LLM) to automatically discover relationships (foreign keys) between tables.\n", - "3. **Generate a semantic layer:** Create a `manifest.json` file that defines your semantic layer.\n", - "4. **Generate SQL queries:** Use the semantic layer to generate SQL queries and retrieve data." - ] - }, - { - "cell_type": "markdown", - "id": "a3dad9d8", - "metadata": {}, - "source": [ - "## 1. Data Profiling\n", - "\n", - "The first step in building a semantic layer is to profile your data. This involves analyzing your data sources to understand their structure, data types, and other characteristics. The `data-tools` project provides a pipeline for this purpose.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "7f0e28d7", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/raphael/intugle/data-tools/.venv/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", - " from .autonotebook import tqdm as notebook_tqdm\n", - "/home/raphael/intugle/data-tools/.venv/lib/python3.12/site-packages/pydantic/_internal/_fields.py:198: UserWarning: Field name \"schema\" in \"Source\" shadows an attribute in parent \"BaseResource\"\n", - " warnings.warn(\n" - ] - } - ], - "source": [ - "import pandas as pd\n", - "\n", - "from data_tools import DataSet" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "0e8971bb", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
startstoppatientencountercodesystemdescriptiontypecategoryreaction1description1severity1reaction2description2severity2
02020-02-17NaNb9c610cd-28a6-4636-ccb6-c7a0d2a4cb8501efcc52-15d6-51e9-faa2-bee069fcbe44111088007UnknownLatex (substance)allergyenvironment247472004.0Wheal (finding)MILDNaNNaNNaN
12020-02-17NaNb9c610cd-28a6-4636-ccb6-c7a0d2a4cb8501efcc52-15d6-51e9-faa2-bee069fcbe4484489001UnknownMold (organism)allergyenvironment76067001.0SneezingMILDNaNNaNNaN
22020-02-17NaNb9c610cd-28a6-4636-ccb6-c7a0d2a4cb8501efcc52-15d6-51e9-faa2-bee069fcbe44260147004UnknownHouse dust mite (organism)allergyenvironmentNaNNaNNaNNaNNaNNaN
32020-02-17NaNb9c610cd-28a6-4636-ccb6-c7a0d2a4cb8501efcc52-15d6-51e9-faa2-bee069fcbe44264287008UnknownAnimal dander (substance)allergyenvironment878820003.0Rhinoconjunctivitis (disorder)MODERATE271807003.0Eruption of skin (disorder)MILD
42020-02-17NaNb9c610cd-28a6-4636-ccb6-c7a0d2a4cb8501efcc52-15d6-51e9-faa2-bee069fcbe44256277009UnknownGrass pollen (substance)allergyenvironmentNaNNaNNaNNaNNaNNaN
\n", - "
" - ], - "text/plain": [ - " start stop patient \\\n", - "0 2020-02-17 NaN b9c610cd-28a6-4636-ccb6-c7a0d2a4cb85 \n", - "1 2020-02-17 NaN b9c610cd-28a6-4636-ccb6-c7a0d2a4cb85 \n", - "2 2020-02-17 NaN b9c610cd-28a6-4636-ccb6-c7a0d2a4cb85 \n", - "3 2020-02-17 NaN b9c610cd-28a6-4636-ccb6-c7a0d2a4cb85 \n", - "4 2020-02-17 NaN b9c610cd-28a6-4636-ccb6-c7a0d2a4cb85 \n", - "\n", - " encounter code system \\\n", - "0 01efcc52-15d6-51e9-faa2-bee069fcbe44 111088007 Unknown \n", - "1 01efcc52-15d6-51e9-faa2-bee069fcbe44 84489001 Unknown \n", - "2 01efcc52-15d6-51e9-faa2-bee069fcbe44 260147004 Unknown \n", - "3 01efcc52-15d6-51e9-faa2-bee069fcbe44 264287008 Unknown \n", - "4 01efcc52-15d6-51e9-faa2-bee069fcbe44 256277009 Unknown \n", - "\n", - " description type category reaction1 \\\n", - "0 Latex (substance) allergy environment 247472004.0 \n", - "1 Mold (organism) allergy environment 76067001.0 \n", - "2 House dust mite (organism) allergy environment NaN \n", - "3 Animal dander (substance) allergy environment 878820003.0 \n", - "4 Grass pollen (substance) allergy environment NaN \n", - "\n", - " description1 severity1 reaction2 \\\n", - "0 Wheal (finding) MILD NaN \n", - "1 Sneezing MILD NaN \n", - "2 NaN NaN NaN \n", - "3 Rhinoconjunctivitis (disorder) MODERATE 271807003.0 \n", - "4 NaN NaN NaN \n", - "\n", - " description2 severity2 \n", - "0 NaN NaN \n", - "1 NaN NaN \n", - "2 NaN NaN \n", - "3 Eruption of skin (disorder) MILD \n", - "4 NaN NaN " - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Load the sample data\n", - "allergies_df = pd.read_csv('../sample_data/healthcare/allergies.csv')\n", - "allergies_df.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "8d3e8299", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/raphael/intugle/data-tools/.venv/lib/python3.12/site-packages/numpy/core/fromnumeric.py:3504: RuntimeWarning: Mean of empty slice.\n", - " return _methods._mean(a, axis=axis, dtype=dtype,\n", - "/home/raphael/intugle/data-tools/.venv/lib/python3.12/site-packages/numpy/core/_methods.py:129: RuntimeWarning: invalid value encountered in scalar divide\n", - " ret = ret.dtype.type(ret / rcount)\n", - "[!] Empty column encountered for allergies ==> stop ...\n", - "100%|██████████| 15/15 [00:08<00:00, 1.74it/s]\n", - "100%|██████████| 15/15 [00:19<00:00, 1.32s/it]\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
column_namebusiness_nametable_namenull_countcountdistinct_countuniquenesscompletenesssample_datadtype_sampletsdatatype_l1datatype_l2business_glossarybusiness_tags
0startstartallergies07941790.2254411.0[1948-07-03, 2003-06-17, 1975-11-10, 1957-06-2...[2020-02-17, 1981-05-17, 1960-01-05, 1960-05-2...0.005982date & timeL2OutputTypes.dimensionIndicates the initial date and time when an al...[Allergy Onset Date, Patient Medical History, ...
1stopstopallergies79479400.0000000.0[][]0.000564othersL2OutputTypes.unknownIndicates the conclusion or cessation of a spe...[AllergyEndDate, PatientCareTimeline, Clinical...
2patientpatientallergies07941790.2254411.0[20a75f26-b297-4120-72e6-602ee5e9f4e4, 2af5741...[b9c610cd-28a6-4636-ccb6-c7a0d2a4cb85, 0288c42...0.004958alphanumericL2OutputTypes.dimensionIdentifies individuals associated with recorde...[Patient Identifier, Healthcare Record Linkage...
3encounterencounterallergies07941790.2254411.0[f0edd0d5-9371-09f3-68ef-ad3a38820c26, 3b8ea0a...[01efcc52-15d6-51e9-faa2-bee069fcbe44, 79de99b...0.005013alphanumericL2OutputTypes.dimensionA unique identifier associated with a specific...[Patient Encounter, Healthcare Event, Clinical...
4codecodeallergies0794210.0264481.0[288328004, 260147004, 782576004, 735029006, 4...[111088007, 84489001, 260147004, 264287008, 25...0.005065integerL2OutputTypes.dimensionIdentifies specific allergens or allergy categ...[Allergy Classification, Medical Code, Clinica...
\n", - "
" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Create a DataSet object and run the profiling pipeline\n", - "dataset_allergies = DataSet(allergies_df, \"allergies\")\n", - "dataset_allergies.run(domain=\"Healthcare\")" - ] - }, - { - "cell_type": "markdown", - "id": "0f4ea58f", - "metadata": {}, - "source": [ - "The `run()` method performs a series of analysis steps, including:\n", - "\n", - "* **Profiling:** Calculates statistics for each column, such as distinct count, uniqueness, and completeness.\n", - "* **Datatype Identification:** Identifies the data type of each column (e.g., integer, string, datetime).\n", - "* **Key Identification:** Identifies potential primary keys.\n", - "* **Glossary Generation:** Generates a business glossary for each column using an LLM.\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "id": "eb562acd", - "metadata": {}, - "source": [ - "## 3. Automated Link Prediction\n", - "\n", - "Now that we've profiled our data, let's discover the relationships between tables. The `data-tools` project uses a LLM to predict links (foreign keys) between tables.\n", - "\n", - "First, we'll load a few more tables from the sample dataset." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "0aa894eb", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/raphael/intugle/data-tools/.venv/lib/python3.12/site-packages/numpy/core/fromnumeric.py:3504: RuntimeWarning: Mean of empty slice.\n", - " return _methods._mean(a, axis=axis, dtype=dtype,\n", - "/home/raphael/intugle/data-tools/.venv/lib/python3.12/site-packages/numpy/core/_methods.py:129: RuntimeWarning: invalid value encountered in scalar divide\n", - " ret = ret.dtype.type(ret / rcount)\n", - "100%|██████████| 25/25 [00:15<00:00, 1.59it/s]\n", - "[*] patients: 0%| | 0/1 [00:00 referringproviderid ...\n", - " 81%|████████ | 25/31 [00:14<00:03, 1.73it/s][!] Error while llm response parsing: Got invalid JSON object. Error: Expecting ',' delimiter: line 2 column 25 (char 26)\n", - "For troubleshooting, visit: https://python.langchain.com/docs/troubleshooting/errors/OUTPUT_PARSING_FAILURE \n", - " 90%|█████████ | 28/31 [00:15<00:01, 1.81it/s][!] Error while llm response parsing: Got invalid JSON object. Error: Expecting ',' delimiter: line 2 column 27 (char 28)\n", - "For troubleshooting, visit: https://python.langchain.com/docs/troubleshooting/errors/OUTPUT_PARSING_FAILURE \n", - "100%|██████████| 31/31 [00:17<00:00, 1.73it/s]\n", - "[*] claims: 0%| | 0/1 [00:00 modifier1 ...\n", - "[!] Empty column encountered for claims_transactions ==> modifier2 ...\n", - "[!] Empty column encountered for claims_transactions ==> adjustments ...\n", - "[!] Empty column encountered for claims_transactions ==> linenote ...\n", - " 45%|████▌ | 15/33 [00:07<00:09, 1.83it/s][!] Error while llm response parsing: Got invalid JSON object. Error: Expecting ',' delimiter: line 2 column 25 (char 26)\n", - "For troubleshooting, visit: https://python.langchain.com/docs/troubleshooting/errors/OUTPUT_PARSING_FAILURE \n", - " 88%|████████▊ | 29/33 [00:14<00:01, 2.01it/s][!] Error while llm response parsing: Got invalid JSON object. Error: Expecting ',' delimiter: line 2 column 25 (char 26)\n", - "For troubleshooting, visit: https://python.langchain.com/docs/troubleshooting/errors/OUTPUT_PARSING_FAILURE \n", - "100%|██████████| 33/33 [00:17<00:00, 1.86it/s]\n", - "[*] claims_transactions: 0%| | 0/1 [00:00 str:\n", - " \"\"\"Append the base URL to the table name.\"\"\"\n", - " return f\"https://raw.githubusercontent.com/Intugle/data-tools/refs/heads/main/sample_data/healthcare//{table_name}.csv\"\n", - "\n", - "\n", - "for table_name in table_names:\n", - " table_url = generate_table_url(table_name)\n", - " df = pd.read_csv(table_url)\n", - " dataset = DataSet(df, table_name)\n", - " dataset.run(domain=\"Healthcare\")\n", - " datasets.append(dataset)" - ] - }, - { - "cell_type": "markdown", - "id": "e083a8d8", - "metadata": {}, - "source": [ - "Now, let's run the link prediction pipeline." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "fe4cd56d", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Dataset 'allergies' is missing key identification. Running prerequisite analysis...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/raphael/intugle/data-tools/.venv/lib/python3.12/site-packages/numpy/core/fromnumeric.py:3504: RuntimeWarning: Mean of empty slice.\n", - " return _methods._mean(a, axis=axis, dtype=dtype,\n", - "/home/raphael/intugle/data-tools/.venv/lib/python3.12/site-packages/numpy/core/_methods.py:129: RuntimeWarning: invalid value encountered in scalar divide\n", - " ret = ret.dtype.type(ret / rcount)\n", - "[!] Empty column encountered for allergies ==> stop ...\n", - "100%|██████████| 15/15 [00:08<00:00, 1.85it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Dataset 'patients' already processed. Skipping analysis.\n", - "Dataset 'claims' already processed. Skipping analysis.\n", - "Dataset 'careplans' already processed. Skipping analysis.\n", - "Dataset 'claims_transactions' already processed. Skipping analysis.\n", - "Dataset 'medications' is missing key identification. Running prerequisite analysis...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "/home/raphael/intugle/data-tools/.venv/lib/python3.12/site-packages/numpy/core/fromnumeric.py:3504: RuntimeWarning: Mean of empty slice.\n", - " return _methods._mean(a, axis=axis, dtype=dtype,\n", - "/home/raphael/intugle/data-tools/.venv/lib/python3.12/site-packages/numpy/core/_methods.py:129: RuntimeWarning: invalid value encountered in scalar divide\n", - " ret = ret.dtype.type(ret / rcount)\n", - "100%|██████████| 13/13 [00:07<00:00, 1.84it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "LinkPredictor initialized with datasets: ['allergies', 'patients', 'claims', 'careplans', 'claims_transactions', 'medications']\n", - "\n", - "--- Comparing 'allergies' <=> 'patients' ---\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[*] allergies <==> patients Runs:1: 100%|██████████| 1/1 [00:05<00:00, 5.20s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Found 1 potential link(s).\n", - "\n", - "--- Comparing 'allergies' <=> 'claims' ---\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[*] allergies <==> claims Runs:1: 100%|██████████| 1/1 [00:01<00:00, 1.78s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "No links found for this pair.\n", - "\n", - "--- Comparing 'allergies' <=> 'careplans' ---\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[*] allergies <==> careplans Runs:1: 100%|██████████| 1/1 [00:01<00:00, 1.84s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "No links found for this pair.\n", - "\n", - "--- Comparing 'allergies' <=> 'claims_transactions' ---\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[*] allergies <==> claims_transactions Runs:1: 100%|██████████| 1/1 [00:01<00:00, 1.80s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "No links found for this pair.\n", - "\n", - "--- Comparing 'allergies' <=> 'medications' ---\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[*] allergies <==> medications Runs:1: 100%|██████████| 1/1 [00:01<00:00, 1.74s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "No links found for this pair.\n", - "\n", - "--- Comparing 'patients' <=> 'claims' ---\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[*] patients <==> claims Runs:1: 100%|██████████| 1/1 [00:01<00:00, 1.29s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Found 1 potential link(s).\n", - "\n", - "--- Comparing 'patients' <=> 'careplans' ---\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[*] patients <==> careplans Runs:1: 100%|██████████| 1/1 [00:01<00:00, 1.12s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Found 1 potential link(s).\n", - "\n", - "--- Comparing 'patients' <=> 'claims_transactions' ---\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[*] patients <==> claims_transactions Runs:1: 100%|██████████| 1/1 [00:01<00:00, 1.20s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Found 1 potential link(s).\n", - "\n", - "--- Comparing 'patients' <=> 'medications' ---\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[*] patients <==> medications Runs:1: 100%|██████████| 1/1 [00:01<00:00, 1.12s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Found 1 potential link(s).\n", - "\n", - "--- Comparing 'claims' <=> 'careplans' ---\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[*] claims <==> careplans Runs:1: 100%|██████████| 1/1 [00:06<00:00, 6.15s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "No links found for this pair.\n", - "\n", - "--- Comparing 'claims' <=> 'claims_transactions' ---\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[*] claims <==> claims_transactions Runs:1: 100%|██████████| 1/1 [00:15<00:00, 15.41s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Found 1 potential link(s).\n", - "\n", - "--- Comparing 'claims' <=> 'medications' ---\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[*] claims <==> medications Runs:1: 100%|██████████| 1/1 [00:18<00:00, 18.19s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "No links found for this pair.\n", - "\n", - "--- Comparing 'careplans' <=> 'claims_transactions' ---\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[*] careplans <==> claims_transactions Runs:1: 100%|██████████| 1/1 [00:05<00:00, 5.99s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "No links found for this pair.\n", - "\n", - "--- Comparing 'careplans' <=> 'medications' ---\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[*] careplans <==> medications Runs:1: 100%|██████████| 1/1 [00:01<00:00, 1.97s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Found 1 potential link(s).\n", - "\n", - "--- Comparing 'claims_transactions' <=> 'medications' ---\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[*] claims_transactions <==> medications Runs:1: 100%|██████████| 1/1 [00:04<00:00, 4.28s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "No links found for this pair.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - }, - { - "data": { - "text/plain": [ - "[PredictedLink(from_dataset='allergies', from_column='patient', to_dataset='patients', to_column='id'),\n", - " PredictedLink(from_dataset='patients', from_column='id', to_dataset='claims', to_column='patientid'),\n", - " PredictedLink(from_dataset='patients', from_column='id', to_dataset='careplans', to_column='patient'),\n", - " PredictedLink(from_dataset='patients', from_column='id', to_dataset='claims_transactions', to_column='patientid'),\n", - " PredictedLink(from_dataset='patients', from_column='id', to_dataset='medications', to_column='patient'),\n", - " PredictedLink(from_dataset='claims', from_column='id', to_dataset='claims_transactions', to_column='claimid'),\n", - " PredictedLink(from_dataset='careplans', from_column='encounter', to_dataset='medications', to_column='encounter')]" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from data_tools import LinkPredictor\n", - "\n", - "# Initialize the predictor\n", - "predictor = LinkPredictor(datasets)\n", - "\n", - "# Run the prediction\n", - "results = predictor.predict()\n", - "results.links" - ] - }, - { - "cell_type": "markdown", - "id": "d18dc421", - "metadata": {}, - "source": [ - "The `results` object contains the predicted links between the tables. You can also visualize the relationships as a graph.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "a59704ba", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "results.show_graph()\n" - ] - }, - { - "cell_type": "markdown", - "id": "32fd4917", - "metadata": {}, - "source": [ - "## 4. The Semantic Layer (Manifest)\n", - "\n", - "The profiling and link prediction results are used to generate a `manifest.json` file. This file defines the semantic layer, including the models (tables) and their relationships.\n", - "\n", - "Let's save the datasets and the predicted links to YAML files. These files will be used to generate the manifest." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "a0daf854", - "metadata": {}, - "outputs": [], - "source": [ - "for ds in datasets:\n", - " ds.save_yaml()\n", - "\n", - "results.save_yaml(\"relationships.yml\")" - ] - }, - { - "cell_type": "markdown", - "id": "8cf08923", - "metadata": {}, - "source": [ - "Now, we can load the YAML files and create a manifest." - ] - }, - { - "cell_type": "markdown", - "id": "3d086f45", - "metadata": {}, - "source": [ - "## 5. SQL Generation\n", - "\n", - "Once you have a semantic layer, you can use the `SqlGenerator` to generate SQL queries. This allows you to query the data using business-friendly terms, without having to write complex SQL.\n", - "\n", - "Let's create an ETL model to define the query we want to generate." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "2570af46", - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "# # Create an ETL model\n", - "# etl_model = ETLModel(\n", - "# fields=[\n", - "# FieldModel(id=\"patients.FIRST\"),\n", - "# FieldModel(id=\"patients.LAST\"),\n", - "# FieldModel(id=\"claims.TOTAL_CLAIM_COST\"),\n", - "# ]\n", - "# )\n", - "etl = {\n", - " \"name\": \"test_etl\",\n", - " \"fields\": [\n", - " {\"id\": \"patients.first\", \"name\": \"first_name\"},\n", - " {\"id\": \"patients.last\", \"name\": \"last_name\"},\n", - " {\"id\": \"allergies.start\", \"name\": \"start_date\"},\n", - " # {\"id\": \"encounters.total_claim_cost\", \"name\": \"claim_cost\", \"category\": \"measure\", \"measure_func\": \"sum\"},\n", - " ],\n", - " \"filter\": {\n", - " \"selections\": [{\"id\": \"claims.departmentid\", \"values\": [\"3\", \"20\"]}],\n", - " # \"sort_by\": [{\"id\": \"encounters.start\", \"direction\": \"desc\"}],\n", - " },\n", - "}" - ] - }, - { - "cell_type": "markdown", - "id": "2e4ff6be", - "metadata": {}, - "source": [ - "Now, let's use the `SqlGenerator` to generate the SQL query." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "f0432e77", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "SELECT patients.first as `first_name`, patients.last as `last_name`, allergies.start as `start_date` FROM `claims` LEFT JOIN `patients` ON patients.id = claims.patientid LEFT JOIN `allergies` ON allergies.patient = patients.id WHERE (claims.departmentid IN '['3', '20']')\n" - ] - } - ], - "source": [ - "from data_tools.sql_generator import SqlGenerator\n", - "\n", - "# Create a SqlGenerator\n", - "sql_generator = SqlGenerator('/home/raphael/intugle/data-tools/testing_base')\n", - "\n", - "# Generate the query\n", - "sql_query = sql_generator.generate_query(etl)\n", - "\n", - "# Print the query\n", - "print(sql_query)" - ] - }, - { - "cell_type": "markdown", - "id": "c29d33de", - "metadata": {}, - "source": [ - "## Conclusion\n", - "\n", - "This notebook has provided a brief overview of the `data-tools` project. You've learned how to:\n", - "\n", - "* Profile your data to understand its characteristics.\n", - "* Use an LLM to automatically predict links between tables.\n", - "* Generate a semantic layer (`manifest.json`).\n", - "* Use the semantic layer to generate SQL queries.\n", - "\n", - "This is just a starting point. The `data-tools` project has many other features to explore. We encourage you to try it with your own data and see how it can help you build a powerful semantic layer.\n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "data-tools", - "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 -} diff --git a/notebooks/quickstart_content.txt b/notebooks/quickstart_content.txt index 33bdf63..fc85d55 100644 --- a/notebooks/quickstart_content.txt +++ b/notebooks/quickstart_content.txt @@ -9,12 +9,20 @@ This notebook provides a quick introduction to the `data-tools` project. You'll A semantic layer is a business-friendly representation of your data. It hides the complexity of the underlying data sources and provides a unified view of your data using familiar business terms. This makes it easier for business users to understand and query the data without needing to be SQL experts. +**Who is this for?** + +This tool is designed for both **data teams** and **business teams**. + +* **Data teams** can use it to automate data profiling, schema discovery, and documentation, significantly accelerating their workflow. +* **Business teams** can use it to gain a better understanding of their data and to perform self-service analytics without needing to write complex SQL queries. + **In this notebook, you will learn how to:** -1. **Profile your data:** Analyze your data sources to understand their structure, data types, and other characteristics. -2. **Automatically predict links:** Use a Large Language Model (LLM) to automatically discover relationships (foreign keys) between tables. -3. **Generate a semantic layer:** Create a `manifest.json` file that defines your semantic layer. -4. **Generate SQL queries:** Use the semantic layer to generate SQL queries and retrieve data. +1. **Configure your LLM Provider:** Set up the Large Language Model that will power the automated features. +2. **Profile your data:** Analyze your data sources to understand their structure, data types, and other characteristics. +3. **Automatically predict links:** Use a Large Language Model (LLM) to automatically discover relationships (foreign keys) between tables. +4. **Generate a semantic layer:** Create a `manifest.json` file that defines your semantic layer. +5. **Generate SQL queries:** Use the semantic layer to generate SQL queries and retrieve data. --- type: markdown --- @@ -29,7 +37,35 @@ type: code --- type: markdown --- -## 2. Data Profiling +## 2. LLM Configuration + +Before running the project, you need to configure a Large Language Model (LLM). This is used for tasks like generating business glossaries and predicting links between tables. + +You can configure the LLM by setting the following environment variables: + +* `LLM_PROVIDER`: The LLM provider and model to use (e.g., `openai:gpt-3.5-turbo`). +* `OPENAI_API_KEY`: Your API key for the LLM provider. + +Here's an example of how to set these variables in your environment: + +```bash +export LLM_PROVIDER="openai:gpt-3.5-turbo" +export OPENAI_API_KEY="your-openai-api-key" +``` + +Alternatively, you can set them in the notebook like this: +--- +type: code +--- +import os + +os.environ["LLM_PROVIDER"] = "openai:gpt-3.5-turbo" +os.environ["OPENAI_API_KEY"] = "your-openai-api-key" # Replace with your actual key + +--- +type: markdown +--- +## 3. Data Profiling The first step in building a semantic layer is to profile your data. This involves analyzing your data sources to understand their structure, data types, and other characteristics. The `data-tools` project provides a pipeline for this purpose. --- @@ -59,6 +95,10 @@ The `run()` method performs a series of analysis steps, including: * **Key Identification:** Identifies potential primary keys. * **Glossary Generation:** Generates a business glossary for each column using an LLM. +**The `domain` parameter** + +The `domain` parameter helps the LLM generate a more contextual business glossary. It specifies the industry domain that the dataset belongs to (e.g., "Healthcare", "Finance", "E-commerce"). + Let's take a look at the profiling results: --- type: code @@ -67,7 +107,7 @@ dataset_allergies.profile_df.head() --- type: markdown --- -## 3. Automated Link Prediction +## 4. Automated Link Prediction Now that we've profiled our data, let's discover the relationships between tables. The `data-tools` project uses a Large Language Model (LLM) to predict links (foreign keys) between tables. @@ -109,11 +149,11 @@ results.show_graph() --- type: markdown --- -## 4. The Semantic Layer (Manifest) +## 5. The Semantic Layer (Manifest) The profiling and link prediction results are used to generate a `manifest.json` file. This file defines the semantic layer, including the models (tables) and their relationships. -Let's save the datasets and the predicted links to YAML files. These files will be used to generate the manifest. +Let's save the datasets and the predicted links to YAML files. By default, these files are saved in a `sources` directory in the current working directory. You can configure this path by setting the `PROJECT_BASE` environment variable. --- type: code --- @@ -140,7 +180,7 @@ print(manifest.json(indent=4)) --- type: markdown --- -## 5. SQL Generation +## 6. SQL Generation Once you have a semantic layer, you can use the `SqlGenerator` to generate SQL queries. This allows you to query the data using business-friendly terms, without having to write complex SQL. @@ -182,9 +222,10 @@ type: markdown This notebook has provided a brief overview of the `data-tools` project. You've learned how to: +* Configure your LLM provider. * Profile your data to understand its characteristics. * Use an LLM to automatically predict links between tables. * Generate a semantic layer (`manifest.json`). * Use the semantic layer to generate SQL queries. -This is just a starting point. The `data-tools` project has many other features to explore. We encourage you to try it with your own data and see how it can help you build a powerful semantic layer. +This is just a starting point. The `data-tools` project has many other features to explore. We encourage you to try it with your own data and see how it can help you build a powerful semantic layer. \ No newline at end of file diff --git a/quickstart.ipynb b/quickstart.ipynb new file mode 100644 index 0000000..5606f05 --- /dev/null +++ b/quickstart.ipynb @@ -0,0 +1,349 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "757096f5", + "metadata": {}, + "source": [ + "# Quickstart: Building a Semantic Layer with Data-Tools\n", + "\n", + "This notebook provides a quick introduction to the `data-tools` project. You'll learn how to use its key features to automatically build a semantic layer over your data.\n", + "\n", + "**What is a Semantic Layer?**\n", + "\n", + "A semantic layer is a business-friendly representation of your data. It hides the complexity of the underlying data sources and provides a unified view of your data using familiar business terms. This makes it easier for business users to understand and query the data without needing to be SQL experts.\n", + "\n", + "**Who is this for?**\n", + "\n", + "This tool is designed for both **data teams** and **business teams**. \n", + "\n", + "* **Data teams** can use it to automate data profiling, schema discovery, and documentation, significantly accelerating their workflow.\n", + "* **Business teams** can use it to gain a better understanding of their data and to perform self-service analytics without needing to write complex SQL queries.\n", + "\n", + "**In this notebook, you will learn how to:**\n", + "\n", + "1. **Configure your LLM Provider:** Set up the Large Language Model that will power the automated features.\n", + "2. **Profile your data:** Analyze your data sources to understand their structure, data types, and other characteristics.\n", + "3. **Automatically predict links:** Use a Large Language Model (LLM) to automatically discover relationships (foreign keys) between tables.\n", + "4. **Generate a semantic layer:** Create a `manifest.json` file that defines your semantic layer.\n", + "5. **Generate SQL queries:** Use the semantic layer to generate SQL queries and retrieve data.\n", + "\n", + "**In this notebook, you will learn how to:**\n", + "\n", + "1. **Profile your data:** Analyze your data sources to understand their structure, data types, and other characteristics.\n", + "2. **Automatically predict links:** Use a Large Language Model (LLM) to automatically discover relationships (foreign keys) between tables.\n", + "3. **Generate a semantic layer:** Create a `manifest.json` file that defines your semantic layer.\n", + "4. **Generate SQL queries:** Use the semantic layer to generate SQL queries and retrieve data." + ] + }, + { + "cell_type": "markdown", + "id": "a2a1b244", + "metadata": {}, + "source": [ + "## 1. LLM Configuration\n", + "\n", + "Before running the project, you need to configure a Large Language Model (LLM). This is used for tasks like generating business glossaries and predicting links between tables.\n", + "\n", + "You can configure the LLM by setting the following environment variables:\n", + "\n", + "* `LLM_PROVIDER`: The LLM provider and model to use (e.g., `openai:gpt-3.5-turbo`).\n", + "* `OPENAI_API_KEY`: Your API key for the LLM provider.\n", + "\n", + "Here's an example of how to set these variables in your environment:\n", + "\n", + "```bash\n", + "export LLM_PROVIDER=\"openai:gpt-3.5-turbo\"\n", + "export OPENAI_API_KEY=\"your-openai-api-key\"\n", + "```\n", + "\n", + "Alternatively, you can set them in the notebook like this:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "36454d44", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "os.environ[\"LLM_PROVIDER\"] = \"openai:gpt-3.5-turbo\"\n", + "os.environ[\"OPENAI_API_KEY\"] = \"your-openai-api-key\" # Replace with your actual key" + ] + }, + { + "cell_type": "markdown", + "id": "a3dad9d8", + "metadata": {}, + "source": [ + "## 2. Data Profiling\n", + "\n", + "The first step in building a semantic layer is to profile your data. This involves analyzing your data sources to understand their structure, data types, and other characteristics. The `data-tools` project provides a pipeline for this purpose.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7f0e28d7", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "\n", + "from data_tools import DataSet" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0e8971bb", + "metadata": {}, + "outputs": [], + "source": [ + "# Load the sample data\n", + "allergies_df = pd.read_csv('https://raw.githubusercontent.com/Intugle/data-tools/refs/heads/main/sample_data/healthcare/allergies.csv')\n", + "allergies_df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8d3e8299", + "metadata": {}, + "outputs": [], + "source": [ + "# Create a DataSet object and run the profiling pipeline\n", + "dataset_allergies = DataSet(allergies_df, \"allergies\")\n", + "dataset_allergies.run(domain=\"Healthcare\")" + ] + }, + { + "cell_type": "markdown", + "id": "0f4ea58f", + "metadata": {}, + "source": [ + "The `run()` method performs a series of analysis steps, including:\n", + "\n", + "* **Profiling:** Calculates statistics for each column, such as distinct count, uniqueness, and completeness.\n", + "* **Datatype Identification:** Identifies the data type of each column (e.g., integer, string, datetime).\n", + "* **Key Identification:** Identifies potential primary keys.\n", + "* **Glossary Generation:** Generates a business glossary for each column using an LLM.\n", + "\n", + "> The `domain` parameter helps the LLM generate a more contextual business glossary. It specifies the industry domain that the dataset belongs to (e.g., \"Healthcare\", \"Finance\", \"E-commerce\").\n" + ] + }, + { + "cell_type": "markdown", + "id": "eb562acd", + "metadata": {}, + "source": [ + "## 3. Automated Link Prediction\n", + "\n", + "Now that we've profiled our data, let's discover the relationships between tables. The `data-tools` project uses a LLM to predict links (foreign keys) between tables.\n", + "\n", + "First, we'll load a few more tables from the sample dataset." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0aa894eb", + "metadata": {}, + "outputs": [], + "source": [ + "table_names = [\"patients\", \"claims\", \"careplans\", \"claims_transactions\", \"medications\"]\n", + "datasets = [dataset_allergies]\n", + "\n", + "\n", + "def generate_table_url(table_name: str) -> str:\n", + " \"\"\"Append the base URL to the table name.\"\"\"\n", + " return f\"https://raw.githubusercontent.com/Intugle/data-tools/refs/heads/main/sample_data/healthcare/{table_name}.csv\"\n", + "\n", + "\n", + "for table_name in table_names:\n", + " table_url = generate_table_url(table_name)\n", + " df = pd.read_csv(table_url)\n", + " dataset = DataSet(df, table_name)\n", + " dataset.run(domain=\"Healthcare\")\n", + " datasets.append(dataset)" + ] + }, + { + "cell_type": "markdown", + "id": "e083a8d8", + "metadata": {}, + "source": [ + "Now, let's run the link prediction pipeline." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fe4cd56d", + "metadata": {}, + "outputs": [], + "source": [ + "from data_tools import LinkPredictor\n", + "\n", + "# Initialize the predictor\n", + "predictor = LinkPredictor(datasets)\n", + "\n", + "# Run the prediction\n", + "results = predictor.predict()\n", + "results.links" + ] + }, + { + "cell_type": "markdown", + "id": "d18dc421", + "metadata": {}, + "source": [ + "The `results` object contains the predicted links between the tables. You can also visualize the relationships as a graph.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a59704ba", + "metadata": {}, + "outputs": [], + "source": [ + "results.show_graph()\n" + ] + }, + { + "cell_type": "markdown", + "id": "32fd4917", + "metadata": {}, + "source": [ + "## 4. The Semantic Layer (Manifest)\n", + "\n", + "The profiling and link prediction results are used to generate YAML files which are saved automatically. These files defines the semantic layer, including the models (tables) and their relationships. \n", + "\n", + "By default, these files are saved in the current working directory. You can configure this path by setting the `PROJECT_BASE` environment variable. They can also be saved manually as shown below:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a0daf854", + "metadata": {}, + "outputs": [], + "source": [ + "for ds in datasets:\n", + " ds.save_yaml()\n", + "\n", + "results.save_yaml(\"relationships.yml\")" + ] + }, + { + "cell_type": "markdown", + "id": "8cf08923", + "metadata": {}, + "source": [ + "Now, we can load the YAML files and create a manifest." + ] + }, + { + "cell_type": "markdown", + "id": "3d086f45", + "metadata": {}, + "source": [ + "## 5. SQL Generation\n", + "\n", + "Once you have a semantic layer, you can use the `SqlGenerator` to generate SQL queries. This allows you to query the data using business-friendly terms, without having to write complex SQL.\n", + "\n", + "Let's create an ETL model to define the query we want to generate." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2570af46", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "etl = {\n", + " \"name\": \"test_etl\",\n", + " \"fields\": [\n", + " {\"id\": \"patients.first\", \"name\": \"first_name\"},\n", + " {\"id\": \"patients.last\", \"name\": \"last_name\"},\n", + " {\"id\": \"allergies.start\", \"name\": \"start_date\"},\n", + " ],\n", + " \"filter\": {\n", + " \"selections\": [{\"id\": \"claims.departmentid\", \"values\": [\"3\", \"20\"]}],\n", + " },\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "2e4ff6be", + "metadata": {}, + "source": [ + "Now, let's use the `SqlGenerator` to generate the SQL query." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f0432e77", + "metadata": {}, + "outputs": [], + "source": [ + "from data_tools.sql_generator import SqlGenerator\n", + "\n", + "# Create a SqlGenerator\n", + "sql_generator = SqlGenerator()\n", + "\n", + "# Generate the query\n", + "sql_query = sql_generator.generate_query(etl)\n", + "\n", + "# Print the query\n", + "print(sql_query)" + ] + }, + { + "cell_type": "markdown", + "id": "c29d33de", + "metadata": {}, + "source": [ + "## Conclusion\n", + "\n", + "This notebook has provided a brief overview of the `data-tools` project. You've learned how to:\n", + "\n", + "* Configure your LLM provider.\n", + "* Profile your data to understand its characteristics.\n", + "* Use an LLM to automatically predict links between tables.\n", + "* Generate a semantic layer.\n", + "* Use the semantic layer to generate SQL queries.\n", + "\n", + "This is just a starting point. The `data-tools` project has many other features to explore. We encourage you to try it with your own data and see how it can help you build a powerful semantic layer.\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "data-tools", + "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 +} diff --git a/src/data_tools/analysis/models.py b/src/data_tools/analysis/models.py index 4e61880..f735906 100644 --- a/src/data_tools/analysis/models.py +++ b/src/data_tools/analysis/models.py @@ -157,13 +157,16 @@ def generate_glossary(self, domain: str = "") -> Self: self.results["table_glossary"] = glossary_output.table_glossary return self - def run(self, domain: str) -> Self: + def run(self, domain: str, save: bool = True) -> Self: """Run all stages """ self.profile()\ .identify_datatypes()\ .identify_keys()\ .generate_glossary(domain=domain) + + if save: + self.save_yaml() return self diff --git a/src/data_tools/core/pipeline/business_glossary/utils.py b/src/data_tools/core/pipeline/business_glossary/utils.py index cf8225b..e2f9656 100644 --- a/src/data_tools/core/pipeline/business_glossary/utils.py +++ b/src/data_tools/core/pipeline/business_glossary/utils.py @@ -39,7 +39,7 @@ def manual_parsing(keys_name: list, text: str, **kwargs): except Exception: log.warning("[!] Failed llm parsing also") - return "" + return [] def get_additional_context(table_name: str, global_additional_context: str = "", additional_table_context: str = ""): diff --git a/src/data_tools/link_predictor/predictor.py b/src/data_tools/link_predictor/predictor.py index 0f62533..7f65af5 100644 --- a/src/data_tools/link_predictor/predictor.py +++ b/src/data_tools/link_predictor/predictor.py @@ -143,7 +143,7 @@ def _predict_for_pair( ] return pair_links - def predict(self) -> Self: + def predict(self, filename='relationships.yml') -> Self: """ Iterates through all unique pairs of datasets, predicts the links for each pair, and returns the aggregated results. @@ -165,6 +165,7 @@ def predict(self) -> Self: print("No links found for this pair.") self.links = all_links + self.save_yaml(file_path=filename) return self def get_links_df(self): From 4aab96a22bd483c4f66273c50c36e3af45a592d8 Mon Sep 17 00:00:00 2001 From: JaskaranIntugle Date: Fri, 22 Aug 2025 12:55:20 +0530 Subject: [PATCH 3/3] updated readme and notebook --- README.md | 64 ++++++++++++++++++++++++++++++++++-------------- quickstart.ipynb | 13 +++------- 2 files changed, 49 insertions(+), 28 deletions(-) diff --git a/README.md b/README.md index 1007af5..1a12571 100644 --- a/README.md +++ b/README.md @@ -11,7 +11,7 @@ ## Overview -Data-Tools is a Python library that helps you automatically build a semantic layer over your data. It streamlines the process of data profiling, discovering relationships between tables, and generating a business-friendly representation of your data. This makes it easier for both data and business teams to understand and query data without needing to be SQL experts. +Intugle's Data-Tools is a GenAI-powered Python library that simplifies and accelerates the journey from raw data to insights. It empowers data and business teams to build an intelligent semantic layer over their data, enabling self-serve analytics and natural language queries. By automating data profiling, link prediction, and SQL generation, Data-Tools helps you build data products faster and more efficiently than traditional methods. ## Who is this for? @@ -25,19 +25,13 @@ This tool is designed for both **data teams** and **business teams**. * **Automated Data Profiling:** Generate detailed statistics for each column in your dataset, including distinct count, uniqueness, completeness, and more. * **Datatype Identification:** Automatically identify the data type of each column (e.g., integer, string, datetime). * **Key Identification:** Identify potential primary keys in your tables. -* **LLM-Powered Link Prediction:** Use a Large Language Model (LLM) to automatically discover relationships (foreign keys) between tables. -* **Business Glossary Generation:** Generate a business glossary for each column using an LLM, with support for industry-specific domains. -* **Semantic Layer Generation:** Create a `manifest.json` file that defines your semantic layer, including models (tables) and their relationships. +* **LLM-Powered Link Prediction:** Use GenAI to automatically discover relationships (foreign keys) between tables. +* **Business Glossary Generation:** Generate a business glossary for each column, with support for industry-specific domains. +* **Semantic Layer Generation:** Create YAML files that defines your semantic layer, including models (tables) and their relationships. * **SQL Generation:** Generate SQL queries from the semantic layer, allowing you to query your data using business-friendly terms. -* **Extensible and Configurable:** Configure the tool to work with your specific environment and data sources. ## Getting Started -### Prerequisites - -* Python 3.10+ -* pip - ### Installation ```bash @@ -46,7 +40,7 @@ pip install data-tools ### Configuration -Before running the project, you need to configure a Large Language Model (LLM). This is used for tasks like generating business glossaries and predicting links between tables. +Before running the project, you need to configure a LLM. This is used for tasks like generating business glossaries and predicting links between tables. You can configure the LLM by setting the following environment variables: @@ -68,14 +62,48 @@ For a detailed, hands-on introduction to the project, please see the [`quickstar The core workflow of the project involves the following steps: -1. **Load your data:** Load your data into pandas DataFrames. -2. **Create `DataSet` objects:** Create a `DataSet` object for each of your tables. -3. **Run the analysis pipeline:** Use the `run()` method to profile your data and generate a business glossary. -4. **Predict links:** Use the `LinkPredictor` to discover relationships between your tables. -5. **Generate the manifest:** Save the profiling and link prediction results to YAML files and then load them to create a `manifest.json` file. -6. **Generate SQL:** Use the `SqlGenerator` to generate SQL queries from the semantic layer. +1. **Load your data:** Load your data into a DataSet object. +2. **Run the analysis pipeline:** Use the `run()` method to profile your data and generate a business glossary. +3. **Predict links:** Use the `LinkPredictor` to discover relationships between your tables. + + ```python + from data_tools import LinkPredictor + + # Initialize the predictor + predictor = LinkPredictor(datasets) + + # Run the prediction + results = predictor.predict() + results.show_graph() + ``` + +5. **Generate SQL:** Use the `SqlGenerator` to generate SQL queries from the semantic layer. + + ```python + from data_tools import SqlGenerator + + # Create a SqlGenerator + sql_generator = SqlGenerator() + + # Create an ETL model + etl = { + name": "test_etl", + fields": [ + {"id": "patients.first", "name": "first_name"}, + {"id": "patients.last", "name": "last_name"}, + {"id": "allergies.start", "name": "start_date"}, + , + filter": { + "selections": [{"id": "claims.departmentid", "values": ["3", "20"]}], + , + } + + # Generate the query + sql_query = sql_generator.generate_query(etl_model) + print(sql_query) + ``` -For detailed code examples, please refer to the [`quickstart.ipynb`](quickstart.ipynb) notebook. +For detailed code examples and a complete walkthrough, please refer to the [`quickstart.ipynb`](quickstart.ipynb) notebook. ## Contributing diff --git a/quickstart.ipynb b/quickstart.ipynb index 5606f05..78589cf 100644 --- a/quickstart.ipynb +++ b/quickstart.ipynb @@ -11,7 +11,7 @@ "\n", "**What is a Semantic Layer?**\n", "\n", - "A semantic layer is a business-friendly representation of your data. It hides the complexity of the underlying data sources and provides a unified view of your data using familiar business terms. This makes it easier for business users to understand and query the data without needing to be SQL experts.\n", + "A semantic layer is a business-friendly representation of your data. It hides the complexity of the underlying data sources and provides a unified view of your data using familiar business terms. This makes it easier for both business users and data teams to understand and query the data, accelerating data-driven insights.\n", "\n", "**Who is this for?**\n", "\n", @@ -22,17 +22,10 @@ "\n", "**In this notebook, you will learn how to:**\n", "\n", - "1. **Configure your LLM Provider:** Set up the Large Language Model that will power the automated features.\n", - "2. **Profile your data:** Analyze your data sources to understand their structure, data types, and other characteristics.\n", - "3. **Automatically predict links:** Use a Large Language Model (LLM) to automatically discover relationships (foreign keys) between tables.\n", - "4. **Generate a semantic layer:** Create a `manifest.json` file that defines your semantic layer.\n", - "5. **Generate SQL queries:** Use the semantic layer to generate SQL queries and retrieve data.\n", - "\n", - "**In this notebook, you will learn how to:**\n", - "\n", "1. **Profile your data:** Analyze your data sources to understand their structure, data types, and other characteristics.\n", + "2. **Business Glossary Generation:** Generate a business glossary for each column, with support for industry-specific domains.\n", "2. **Automatically predict links:** Use a Large Language Model (LLM) to automatically discover relationships (foreign keys) between tables.\n", - "3. **Generate a semantic layer:** Create a `manifest.json` file that defines your semantic layer.\n", + "3. **Generate a semantic layer:** Create YAML files file that defines your semantic layer.\n", "4. **Generate SQL queries:** Use the semantic layer to generate SQL queries and retrieve data." ] },