diff --git a/dsnotebooks/settings.py b/dsnotebooks/settings.py index d5809bb..686ebf7 100644 --- a/dsnotebooks/settings.py +++ b/dsnotebooks/settings.py @@ -33,6 +33,11 @@ def set_kg_key(cls, v): return v or input("Knowledge graph key: ") +class CollOptionalNotebookSettings(NotebookSettings): + proj_key: Optional[str] = None + index_key: Optional[str] = None + + class CollQANotebookSettings(ProjectNotebookSettings): sem_on_idx_key: str retr_k: int = 5 diff --git a/examples/data_query_quick_start/quick_start.ipynb b/examples/data_query_quick_start/quick_start.ipynb index ffa1c71..0d3aa3a 100644 --- a/examples/data_query_quick_start/quick_start.ipynb +++ b/examples/data_query_quick_start/quick_start.ipynb @@ -10,6 +10,15 @@ "Deep Search parses and interprets large collections of documents quickly and concurrently.\n", "These collections are stored and indexed such that you can search and retrieve any document according to their contents.\n", "\n", + "Depending if the user is querying public or private data, the commands will look a bit different.\n", + "In this example we first showcase both:\n", + "\n", + "1. Query public data\n", + " 1. [Inspect Deep Search data](#Inspect-Deep-Search-data)\n", + " 2. [Search documents](#Search-documents)\n", + "3. [Query private data](#Query-private-data)\n", + "\n", + "\n", "### Access required\n", "\n", "The content of this notebook requires access to Deep Search capabilities which are not\n", @@ -31,15 +40,31 @@ "cell_type": "code", "execution_count": 1, "id": "13560ae0", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2024-05-27T16:58:30.702563Z", + "iopub.status.busy": "2024-05-27T16:58:30.702155Z", + "iopub.status.idle": "2024-05-27T16:58:32.815522Z", + "shell.execute_reply": "2024-05-27T16:58:32.814752Z", + "shell.execute_reply.started": "2024-05-27T16:58:30.702532Z" + } + }, "outputs": [], "source": [ - "from dsnotebooks.settings import NotebookSettings\n", + "from dsnotebooks.settings import CollOptionalNotebookSettings\n", "\n", "# notebook settings auto-loaded from .env / env vars\n", - "notebook_settings = NotebookSettings()\n", + "notebook_settings = CollOptionalNotebookSettings()\n", + "\n", + "PROFILE_NAME = notebook_settings.profile # the profile to use\n", "\n", - "PROFILE_NAME = notebook_settings.profile # the profile to use" + "# The following settings are required only for running the private data part of this example\n", + "PROJ_KEY = (\n", + " notebook_settings.proj_key\n", + ") # the project containing the private data to query\n", + "INDEX_KEY = (\n", + " notebook_settings.index_key\n", + ") # the data collection containing the private data to query" ] }, { @@ -54,7 +79,15 @@ "cell_type": "code", "execution_count": 2, "id": "1ea3cd26", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2024-05-27T16:58:32.816786Z", + "iopub.status.busy": "2024-05-27T16:58:32.816408Z", + "iopub.status.idle": "2024-05-27T16:58:34.102341Z", + "shell.execute_reply": "2024-05-27T16:58:34.101592Z", + "shell.execute_reply.started": "2024-05-27T16:58:32.816764Z" + } + }, "outputs": [], "source": [ "# Import standard dependenices\n", @@ -71,7 +104,12 @@ "\n", "# Import the deepsearch-toolkit\n", "import deepsearch as ds\n", - "from deepsearch.cps.client.components.elastic import ElasticDataCollectionSource\n", + "from deepsearch.cps.client.components.elastic import (\n", + " ElasticDataCollectionSource,\n", + ") # For public collections\n", + "from deepsearch.cps.client.components.data_indices import (\n", + " ElasticProjectDataCollectionSource,\n", + ") # For private collections\n", "from deepsearch.cps.queries import DataQuery" ] }, @@ -87,7 +125,15 @@ "cell_type": "code", "execution_count": 3, "id": "fae4dee3", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2024-05-27T16:58:34.103786Z", + "iopub.status.busy": "2024-05-27T16:58:34.103345Z", + "iopub.status.idle": "2024-05-27T16:58:34.520849Z", + "shell.execute_reply": "2024-05-27T16:58:34.519980Z", + "shell.execute_reply.started": "2024-05-27T16:58:34.103761Z" + } + }, "outputs": [], "source": [ "api = ds.CpsApi.from_env(profile_name=PROFILE_NAME)" @@ -121,7 +167,15 @@ "cell_type": "code", "execution_count": 4, "id": "45beab94", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2024-05-27T16:58:34.523584Z", + "iopub.status.busy": "2024-05-27T16:58:34.522938Z", + "iopub.status.idle": "2024-05-27T16:58:35.455009Z", + "shell.execute_reply": "2024-05-27T16:58:35.453883Z", + "shell.execute_reply.started": "2024-05-27T16:58:34.523550Z" + } + }, "outputs": [], "source": [ "# Fetch list of all data collections\n", @@ -134,7 +188,13 @@ "execution_count": 5, "id": "f915761b", "metadata": { - "scrolled": false + "execution": { + "iopub.execute_input": "2024-05-27T16:58:35.459159Z", + "iopub.status.busy": "2024-05-27T16:58:35.457758Z", + "iopub.status.idle": "2024-05-27T16:58:35.487512Z", + "shell.execute_reply": "2024-05-27T16:58:35.486265Z", + "shell.execute_reply.started": "2024-05-27T16:58:35.459008Z" + } }, "outputs": [ { @@ -168,6 +228,14 @@ " \n", " \n", " 0\n", + " AAAI\n", + " Document\n", + " 16.02K\n", + " 2024-01-23\n", + " default/aaai\n", + " \n", + " \n", + " 1\n", " ACL Anthology\n", " Document\n", " 55.28K\n", @@ -175,15 +243,15 @@ " default/acl\n", " \n", " \n", - " 1\n", + " 2\n", " Annual Reports\n", " Document\n", - " 79.79K\n", - " 2023-07-21\n", + " 107.38K\n", + " 2024-01-23\n", " default/annual-report\n", " \n", " \n", - " 2\n", + " 3\n", " arXiv abstracts\n", " Document\n", " 2.35M\n", @@ -191,7 +259,15 @@ " default/arxiv-abstract\n", " \n", " \n", - " 3\n", + " 4\n", + " arXiv full documents\n", + " Document\n", + " 2.29M\n", + " 2024-01-27\n", + " default/arxiv\n", + " \n", + " \n", + " 5\n", " ClinicalTrials\n", " Document\n", " 426.42K\n", @@ -199,7 +275,7 @@ " default/clinical-trials\n", " \n", " \n", - " 4\n", + " 6\n", " Cord19\n", " Document\n", " 655.45K\n", @@ -207,7 +283,7 @@ " default/cord19\n", " \n", " \n", - " 5\n", + " 7\n", " Crossref\n", " Document\n", " 131.86M\n", @@ -215,15 +291,15 @@ " default/crossref\n", " \n", " \n", - " 6\n", + " 8\n", " ESG Reports\n", " Document\n", - " 10.93K\n", - " 2023-10-03\n", + " 17.36K\n", + " 2024-01-22\n", " default/esg-report\n", " \n", " \n", - " 7\n", + " 9\n", " IBM Redbooks\n", " Document\n", " 2.75K\n", @@ -231,7 +307,7 @@ " default/ibm-redbooks\n", " \n", " \n", - " 8\n", + " 10\n", " IPCC\n", " Document\n", " 819\n", @@ -239,23 +315,23 @@ " default/ipcc\n", " \n", " \n", - " 9\n", + " 11\n", " PatCID\n", " Record\n", - " 50.83M\n", + " 13.03M\n", " 2023-09-05\n", " default/patcid\n", " \n", " \n", - " 10\n", + " 12\n", " Patent SMILES\n", " Document\n", " 2.84M\n", - " 2023-10-06\n", + " 2024-01-21\n", " default/patent-smiles\n", " \n", " \n", - " 11\n", + " 13\n", " Patents from USPTO\n", " Document\n", " 15.76M\n", @@ -263,7 +339,23 @@ " default/patent-uspto\n", " \n", " \n", - " 12\n", + " 14\n", + " PLOS\n", + " Document\n", + " 340.28K\n", + " 2024-01-22\n", + " default/plos\n", + " \n", + " \n", + " 15\n", + " Press Release\n", + " Document\n", + " 43.04K\n", + " 2024-02-27\n", + " default/press-release\n", + " \n", + " \n", + " 16\n", " PubChem\n", " Record\n", " 118.24M\n", @@ -271,7 +363,7 @@ " default/pubchem\n", " \n", " \n", - " 13\n", + " 17\n", " PubMed Central\n", " Document\n", " 5.08M\n", @@ -279,7 +371,7 @@ " default/pubmed\n", " \n", " \n", - " 14\n", + " 18\n", " Red Hat\n", " Document\n", " 6.21K\n", @@ -287,7 +379,7 @@ " default/redhat\n", " \n", " \n", - " 15\n", + " 19\n", " Semantic Scholar Academic Graph\n", " Document\n", " 212.11M\n", @@ -300,40 +392,48 @@ ], "text/plain": [ " Name Type Num entries Date \\\n", - "0 ACL Anthology Document 55.28K 2023-10-05 \n", - "1 Annual Reports Document 79.79K 2023-07-21 \n", - "2 arXiv abstracts Document 2.35M 2023-10-24 \n", - "3 ClinicalTrials Document 426.42K 2023-06-01 \n", - "4 Cord19 Document 655.45K 2023-04-14 \n", - "5 Crossref Document 131.86M 2023-04-15 \n", - "6 ESG Reports Document 10.93K 2023-10-03 \n", - "7 IBM Redbooks Document 2.75K 2023-08-02 \n", - "8 IPCC Document 819 2023-06-15 \n", - "9 PatCID Record 50.83M 2023-09-05 \n", - "10 Patent SMILES Document 2.84M 2023-10-06 \n", - "11 Patents from USPTO Document 15.76M 2023-09-07 \n", - "12 PubChem Record 118.24M 2023-10-06 \n", - "13 PubMed Central Document 5.08M 2023-04-12 \n", - "14 Red Hat Document 6.21K 2023-07-14 \n", - "15 Semantic Scholar Academic Graph Document 212.11M 2023-05-28 \n", + "0 AAAI Document 16.02K 2024-01-23 \n", + "1 ACL Anthology Document 55.28K 2023-10-05 \n", + "2 Annual Reports Document 107.38K 2024-01-23 \n", + "3 arXiv abstracts Document 2.35M 2023-10-24 \n", + "4 arXiv full documents Document 2.29M 2024-01-27 \n", + "5 ClinicalTrials Document 426.42K 2023-06-01 \n", + "6 Cord19 Document 655.45K 2023-04-14 \n", + "7 Crossref Document 131.86M 2023-04-15 \n", + "8 ESG Reports Document 17.36K 2024-01-22 \n", + "9 IBM Redbooks Document 2.75K 2023-08-02 \n", + "10 IPCC Document 819 2023-06-15 \n", + "11 PatCID Record 13.03M 2023-09-05 \n", + "12 Patent SMILES Document 2.84M 2024-01-21 \n", + "13 Patents from USPTO Document 15.76M 2023-09-07 \n", + "14 PLOS Document 340.28K 2024-01-22 \n", + "15 Press Release Document 43.04K 2024-02-27 \n", + "16 PubChem Record 118.24M 2023-10-06 \n", + "17 PubMed Central Document 5.08M 2023-04-12 \n", + "18 Red Hat Document 6.21K 2023-07-14 \n", + "19 Semantic Scholar Academic Graph Document 212.11M 2023-05-28 \n", "\n", " Coords \n", - "0 default/acl \n", - "1 default/annual-report \n", - "2 default/arxiv-abstract \n", - "3 default/clinical-trials \n", - "4 default/cord19 \n", - "5 default/crossref \n", - "6 default/esg-report \n", - "7 default/ibm-redbooks \n", - "8 default/ipcc \n", - "9 default/patcid \n", - "10 default/patent-smiles \n", - "11 default/patent-uspto \n", - "12 default/pubchem \n", - "13 default/pubmed \n", - "14 default/redhat \n", - "15 default/semantic-scholar " + "0 default/aaai \n", + "1 default/acl \n", + "2 default/annual-report \n", + "3 default/arxiv-abstract \n", + "4 default/arxiv \n", + "5 default/clinical-trials \n", + "6 default/cord19 \n", + "7 default/crossref \n", + "8 default/esg-report \n", + "9 default/ibm-redbooks \n", + "10 default/ipcc \n", + "11 default/patcid \n", + "12 default/patent-smiles \n", + "13 default/patent-uspto \n", + "14 default/plos \n", + "15 default/press-release \n", + "16 default/pubchem \n", + "17 default/pubmed \n", + "18 default/redhat \n", + "19 default/semantic-scholar " ] }, "metadata": {}, @@ -372,18 +472,24 @@ "execution_count": 6, "id": "81df4c38", "metadata": { - "scrolled": false + "execution": { + "iopub.execute_input": "2024-05-27T16:58:35.489724Z", + "iopub.status.busy": "2024-05-27T16:58:35.489353Z", + "iopub.status.idle": "2024-05-27T16:58:41.935686Z", + "shell.execute_reply": "2024-05-27T16:58:41.934388Z", + "shell.execute_reply.started": "2024-05-27T16:58:35.489694Z" + } }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "d289cd48772842f99c6ab8ba9a284410", + "model_id": "ebe3e6e6cd604219bccebb0b6d93f30c", "version_major": 2, "version_minor": 0 }, "text/plain": [ - " 0%| | 0/16 [00:00\n", " \n", " 3\n", - " Annual Reports\n", - " 160\n", + " arXiv full documents\n", + " 2031\n", " \n", " \n", " 4\n", - " Cord19\n", - " 93\n", + " PLOS\n", + " 570\n", " \n", " \n", " 5\n", - " arXiv abstracts\n", - " 70\n", + " Annual Reports\n", + " 194\n", " \n", " \n", " 6\n", - " IBM Redbooks\n", - " 20\n", + " Cord19\n", + " 93\n", " \n", " \n", " 7\n", - " ESG Reports\n", - " 18\n", + " arXiv abstracts\n", + " 70\n", " \n", " \n", " 8\n", + " ESG Reports\n", + " 33\n", + " \n", + " \n", + " 9\n", + " IBM Redbooks\n", + " 20\n", + " \n", + " \n", + " 10\n", " ACL Anthology\n", " 9\n", " \n", " \n", - " 9\n", + " 11\n", " IPCC\n", " 7\n", " \n", " \n", - " 10\n", + " 12\n", + " Press Release\n", + " 4\n", + " \n", + " \n", + " 13\n", + " AAAI\n", + " 2\n", + " \n", + " \n", + " 14\n", " ClinicalTrials\n", " 1\n", " \n", " \n", - " 11\n", + " 15\n", " Crossref\n", " 0\n", " \n", " \n", - " 12\n", + " 16\n", " Patent SMILES\n", " 0\n", " \n", " \n", - " 13\n", + " 17\n", " Red Hat\n", " 0\n", " \n", @@ -494,17 +620,21 @@ "0 Semantic Scholar Academic Graph 10939\n", "1 Patents from USPTO 10487\n", "2 PubMed Central 6050\n", - "3 Annual Reports 160\n", - "4 Cord19 93\n", - "5 arXiv abstracts 70\n", - "6 IBM Redbooks 20\n", - "7 ESG Reports 18\n", - "8 ACL Anthology 9\n", - "9 IPCC 7\n", - "10 ClinicalTrials 1\n", - "11 Crossref 0\n", - "12 Patent SMILES 0\n", - "13 Red Hat 0" + "3 arXiv full documents 2031\n", + "4 PLOS 570\n", + "5 Annual Reports 194\n", + "6 Cord19 93\n", + "7 arXiv abstracts 70\n", + "8 ESG Reports 33\n", + "9 IBM Redbooks 20\n", + "10 ACL Anthology 9\n", + "11 IPCC 7\n", + "12 Press Release 4\n", + "13 AAAI 2\n", + "14 ClinicalTrials 1\n", + "15 Crossref 0\n", + "16 Patent SMILES 0\n", + "17 Red Hat 0" ] }, "metadata": {}, @@ -538,12 +668,20 @@ "cell_type": "code", "execution_count": 7, "id": "115b4ee0", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2024-05-27T16:58:41.938640Z", + "iopub.status.busy": "2024-05-27T16:58:41.938179Z", + "iopub.status.idle": "2024-05-27T16:58:42.522971Z", + "shell.execute_reply": "2024-05-27T16:58:42.522024Z", + "shell.execute_reply.started": "2024-05-27T16:58:41.938597Z" + } + }, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 7, @@ -552,7 +690,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -593,12 +731,20 @@ "cell_type": "code", "execution_count": 8, "id": "28035763", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2024-05-27T16:58:42.524589Z", + "iopub.status.busy": "2024-05-27T16:58:42.524128Z", + "iopub.status.idle": "2024-05-27T16:58:43.988301Z", + "shell.execute_reply": "2024-05-27T16:58:43.987345Z", + "shell.execute_reply.started": "2024-05-27T16:58:42.524563Z" + } + }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "08f08b02b20c4691b6b7d2c31e9bb928", + "model_id": "9652e493fccd45838311e1b4a66ade13", "version_major": 2, "version_minor": 0 }, @@ -690,6 +836,13 @@ "execution_count": 9, "id": "09817a25", "metadata": { + "execution": { + "iopub.execute_input": "2024-05-27T16:58:44.032379Z", + "iopub.status.busy": "2024-05-27T16:58:43.989577Z", + "iopub.status.idle": "2024-05-27T16:58:44.066456Z", + "shell.execute_reply": "2024-05-27T16:58:44.064824Z", + "shell.execute_reply.started": "2024-05-27T16:58:44.019826Z" + }, "scrolled": true }, "outputs": [ @@ -775,12 +928,200 @@ "cell_type": "code", "execution_count": 10, "id": "e308f0a5", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2024-05-27T16:58:44.080619Z", + "iopub.status.busy": "2024-05-27T16:58:44.079956Z", + "iopub.status.idle": "2024-05-27T16:58:44.620383Z", + "shell.execute_reply": "2024-05-27T16:58:44.619743Z", + "shell.execute_reply.started": "2024-05-27T16:58:44.080587Z" + } + }, "outputs": [], "source": [ "# Save the results to an Excel table\n", "df.to_excel(\"quick_start_results.xlsx\")" ] + }, + { + "cell_type": "markdown", + "id": "fc5a4f51-85f5-4b6a-bea2-8b2c75bd4de5", + "metadata": {}, + "source": [ + "---" + ] + }, + { + "cell_type": "markdown", + "id": "7dbe93ca-0e38-4d36-8cd2-3b421b750dda", + "metadata": {}, + "source": [ + "## Query private data\n", + "\n", + "In this section we search for documents in the arXiv.org data collection matching the input query.\n", + "For each matched document we return the filename and the document_hash identifier.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "e88416cd-b5aa-4d9c-af96-e362f74e2e01", + "metadata": { + "execution": { + "iopub.execute_input": "2024-05-27T16:58:44.622081Z", + "iopub.status.busy": "2024-05-27T16:58:44.621684Z", + "iopub.status.idle": "2024-05-27T16:58:44.627090Z", + "shell.execute_reply": "2024-05-27T16:58:44.625453Z", + "shell.execute_reply.started": "2024-05-27T16:58:44.622055Z" + } + }, + "outputs": [], + "source": [ + "if PROJ_KEY is None or INDEX_KEY is None:\n", + " raise RuntimeError(\n", + " \"Private data query requires `PROJ_KEY` and `INDEX_KEY` to be defined at the beginning of the notebook.\"\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "b084d46c-2dc7-44c7-955a-c712608d72d9", + "metadata": { + "execution": { + "iopub.execute_input": "2024-05-27T16:58:44.629744Z", + "iopub.status.busy": "2024-05-27T16:58:44.629193Z", + "iopub.status.idle": "2024-05-27T16:58:45.447855Z", + "shell.execute_reply": "2024-05-27T16:58:45.446858Z", + "shell.execute_reply.started": "2024-05-27T16:58:44.629703Z" + } + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f3f93a56ed674b9faae62e7fc12ab327", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1 [00:00\n", + " \n", + " \n", + " \n", + " Filename\n", + " Document hash\n", + " \n", + " \n", + " \n", + " \n", + " 0\n", + " natural-language-processing.pdf\n", + " 000f892ddcc67f165797a96e94f44fb9e0697c7912a383072cea77e56011a9c3\n", + " \n", + " \n", + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize the table with all results\n", + "df = pd.json_normalize(all_results)\n", + "display(HTML(df.head().to_html(render_links=True)))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f9a491fe-5efa-45ff-8089-d9cc3d32ba5f", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -799,7 +1140,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.4" + "version": "3.10.13" } }, "nbformat": 4,