94_make_datasets.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create DRS+non-DRS dataset for haystack.deepset.ai\n",
    "Per https://haystack.deepset.ai/tutorials/08_preprocessing, Haystack expects data to be provided as a list of documents in the following dictionary format. See also https://docs.haystack.deepset.ai/docs/document_store\n",
    "```\n",
    "docs = [\n",
    "    {\n",
    "        'content': DOCUMENT_TEXT_HERE,                                                              \n",
    "        'meta': {'name': DOCUMENT_NAME, ...}\n",
    "    }, ...\n",
    "]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import DRS metadata"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import os\n",
    "import glob\n",
    "\n",
    "metadata_mapping = pd.read_excel(os.path.join(os.getcwd(),\n",
    "                                              'data',\n",
    "                                              'DRS',\n",
    "                                              'index',\n",
    "                                              'FAA DRS',\n",
    "                                              'DRS Document Types Metadata Mapping.xlsx')) # from https://drs.faa.gov/help/helpdetails and https://drs.faa.gov/help/helpdetails\n",
    "\n",
    "doc_types = pd.unique(metadata_mapping.loc[:, \"Document Type Name in API request\"])\n",
    "doc_types = [val for val in doc_types if isinstance(val, str)]\n",
    "\n",
    "common_fields = []\n",
    "for n,doc_type in enumerate(doc_types):\n",
    "    metadata_names = metadata_mapping.loc[metadata_mapping.loc[:, \"Document Type Name in API request\"]==doc_type, \"Metadata Name in API Response \"]\n",
    "\n",
    "    if n>0:\n",
    "        common_fields = list(set(metadata_names) & set(common_fields))\n",
    "    else:\n",
    "        common_fields = list(set(metadata_names))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Subset for which it was possible to split paragraphs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "doc_types = ['AC',\n",
    "            'ORDER_8300.10',\n",
    "            'ORDER_8400.10',\n",
    "            'ORDER_8700.1',\n",
    "            'ORDER_8740.1',\n",
    "            'ORDER_8900.1',\n",
    "            'ORDERS']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_9711/3703280121.py:21: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
      "  df_drsmeta = pd.concat([this_parquet,\n",
      "/tmp/ipykernel_9711/3703280121.py:21: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
      "  df_drsmeta = pd.concat([this_parquet,\n",
      "/tmp/ipykernel_9711/3703280121.py:21: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
      "  df_drsmeta = pd.concat([this_parquet,\n",
      "/tmp/ipykernel_9711/3703280121.py:21: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
      "  df_drsmeta = pd.concat([this_parquet,\n",
      "/tmp/ipykernel_9711/3703280121.py:21: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
      "  df_drsmeta = pd.concat([this_parquet,\n",
      "/tmp/ipykernel_9711/3703280121.py:21: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
      "  df_drsmeta = pd.concat([this_parquet,\n"
     ]
    }
   ],
   "source": [
    "df_drsmeta = None\n",
    "\n",
    "for doc_type in doc_types:\n",
    "    parquet_files = sorted(glob.glob(os.path.join(os.getcwd(),\n",
    "                                                  'data', \n",
    "                                                  'DRS', \n",
    "                                                  'index', \n",
    "                                                  doc_type+'_202*.parquet')), \n",
    "                        key=os.path.getctime, \n",
    "                        reverse=True)\n",
    "\n",
    "    if len(parquet_files)>0:\n",
    "        this_parquet = pd.read_parquet(parquet_files[0])\n",
    "        this_parquet.insert(0, \n",
    "                            \"doc_type\", \n",
    "                            value=pd.Series(data=doc_type, index=this_parquet.index, dtype=\"string\"))\n",
    "\n",
    "        if df_drsmeta is None:\n",
    "            df_drsmeta = this_parquet\n",
    "        else:\n",
    "            df_drsmeta = pd.concat([this_parquet,\n",
    "                                    df_drsmeta])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import DRS or non-DRS pre-dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# source_type = 'DRS'\n",
    "source_type = 'NotInDRS'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c:\\Users\\victor\\Documents\\DeepLearning\\FAA NLP Project\\data\\NotInDRS\\dataset\\extracted_text\\extracted_text (augmented)_for_DocNotInDRS-20240128 - 213311.parquet\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>filename</th>\n",
       "      <th>position in bookmark tree</th>\n",
       "      <th>original pdf bookmark title (outline.title)</th>\n",
       "      <th>original pdf bookmark page number</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1543</th>\n",
       "      <td>Pilot Controller Glossary Basic with Change 1.pdf</td>\n",
       "      <td>20</td>\n",
       "      <td>S</td>\n",
       "      <td>118</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1544</th>\n",
       "      <td>Pilot Controller Glossary Basic with Change 1.pdf</td>\n",
       "      <td>21</td>\n",
       "      <td>T</td>\n",
       "      <td>130</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1545</th>\n",
       "      <td>Pilot Controller Glossary Basic with Change 1.pdf</td>\n",
       "      <td>22</td>\n",
       "      <td>U</td>\n",
       "      <td>142</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1546</th>\n",
       "      <td>Pilot Controller Glossary Basic with Change 1.pdf</td>\n",
       "      <td>23</td>\n",
       "      <td>V</td>\n",
       "      <td>144</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1547</th>\n",
       "      <td>Pilot Controller Glossary Basic with Change 1.pdf</td>\n",
       "      <td>24</td>\n",
       "      <td>W</td>\n",
       "      <td>150</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                               filename  \\\n",
       "1543  Pilot Controller Glossary Basic with Change 1.pdf   \n",
       "1544  Pilot Controller Glossary Basic with Change 1.pdf   \n",
       "1545  Pilot Controller Glossary Basic with Change 1.pdf   \n",
       "1546  Pilot Controller Glossary Basic with Change 1.pdf   \n",
       "1547  Pilot Controller Glossary Basic with Change 1.pdf   \n",
       "\n",
       "     position in bookmark tree original pdf bookmark title (outline.title)  \\\n",
       "1543                        20                                           S   \n",
       "1544                        21                                           T   \n",
       "1545                        22                                           U   \n",
       "1546                        23                                           V   \n",
       "1547                        24                                           W   \n",
       "\n",
       "     original pdf bookmark page number  \n",
       "1543                               118  \n",
       "1544                               130  \n",
       "1545                               142  \n",
       "1546                               144  \n",
       "1547                               150  "
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import glob\n",
    "import os\n",
    "\n",
    "predatasets = sorted(glob.glob(os.path.join(os.getcwd(), \n",
    "                                            'data', \n",
    "                                            source_type, \n",
    "                                            'dataset', \n",
    "                                            'extracted_text', \n",
    "                                            '*.parquet')), \n",
    "                    key=os.path.getctime, \n",
    "                    reverse=True)\n",
    "print(predatasets[0])\n",
    "df_predataset = pd.read_parquet(predatasets[0])\n",
    "\n",
    "df_predataset.tail()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create dataset that is haystack.deepset friendly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "if source_type=='DRS':\n",
    "    df_dataset = pd.merge(df_predataset, df_drsmeta, on='documentGuid', how='inner').dropna(axis=1, how='all')\n",
    "    df_dataset.insert(loc=0, column='content', value=pd.Series(df_dataset.shape[0]*[''], dtype=\"string\"))\n",
    "    df_dataset.insert(loc=0, column='parents_title_list', value=pd.Series(df_dataset.shape[0]*[''], dtype=\"string\"))\n",
    "elif source_type=='NotInDRS':\n",
    "    df_dataset = df_predataset\n",
    "    df_dataset.insert(loc=0, column='content', value=pd.Series(df_dataset.shape[0]*[''], dtype=\"string\"))\n",
    "    df_dataset.insert(loc=0, column='parents_title_list', value=pd.Series(df_dataset.shape[0]*[''], dtype=\"string\"))\n",
    "    df_dataset.insert(loc=0, column='drs:title', value=pd.Series(df_dataset['filename'].replace(to_replace=r'\\.pdf$', value='', regex=True), dtype=\"string\"))\n",
    "    df_dataset.insert(loc=0, column='documentGuid', value=pd.Series(df_dataset['filename'].replace(to_replace=r'\\.pdf$', value='', regex=True), dtype=\"string\"))\n",
    "    df_dataset.insert(loc=0, column='drs:status', value=pd.Series(df_dataset.shape[0]*['Current'], dtype=\"string\"))\n",
    "    df_dataset.insert(loc=0, column='doc_type', value=pd.Series(df_dataset.shape[0]*['NotInDRS'], dtype=\"string\"))\n",
    "    df_dataset.insert(loc=0, column='corrected pdf bookmark page number', value=pd.Series(df_dataset['original pdf bookmark page number'], dtype=\"string\"))\n",
    "    df_dataset.insert(loc=0, column='extracted title text', value=pd.Series(df_dataset['original pdf bookmark title (outline.title)'], dtype=\"string\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if source_type=='DRS':\n",
    "    from PyPDF2 import PdfReader\n",
    "elif source_type=='NotInDRS':\n",
    "    from pypdf import PdfReader\n",
    "\n",
    "import glob\n",
    "import re\n",
    "import logging\n",
    "import datetime\n",
    "\n",
    "logging.basicConfig(filename='94_make_datasets.log', encoding='utf-8',format='%(asctime)s %(message)s', level=logging.INFO)\n",
    "\n",
    "def get_parents_title_list(position_in_bookmark_tree, df_dataset):\n",
    "    parents_title_list = [df_dataset['drs:title'][0]]\n",
    "    parent_title_number_list = position_in_bookmark_tree.split(\">\")\n",
    "\n",
    "    for n in range(1,len(parent_title_number_list)+1):\n",
    "        matching_index = df_dataset[df_dataset[\"position in bookmark tree\"]==\">\".join(parent_title_number_list[0:n])].index[0]        \n",
    "        parents_title_list.append(df_dataset.loc[matching_index, \"original pdf bookmark title (outline.title)\"])  # extracted title text extracted title number\n",
    "        \n",
    "    return str(parents_title_list)\n",
    "\n",
    "\n",
    "def get_textcontent(pages, index, df_dataset, source_type):\n",
    "    first_page = int(df_dataset.loc[index, 'corrected pdf bookmark page number'])\n",
    "\n",
    "    if index in [df_dataset.shape[0]-1, df_dataset.index[-1]]:\n",
    "        last_page = len(pages)-1 # index starts from 0\n",
    "    else:\n",
    "        try:\n",
    "            last_page = int(df_dataset.loc[index+1, 'corrected pdf bookmark page number'])\n",
    "        except Exception as e: # last bookmark\n",
    "            n=1\n",
    "            while (n<20):\n",
    "                n = n+1\n",
    "                try:\n",
    "                    last_page = int(df_dataset.loc[index+n, 'corrected pdf bookmark page number'])\n",
    "                    logging.info(\"Degraded mode for last_page, use different next index \"+ str(n) + \" with\"+\n",
    "                                \"\\ndocumentGuid=\"+df_dataset.loc[index+n, \"documentGuid\"]+\n",
    "                                \"\\nposition in bookmark tree=\"+df_dataset.loc[index+n, \"position in bookmark tree\"]+\n",
    "                                \"\\ntitle=\"+df_dataset.loc[index+n, \"original pdf bookmark title (outline.title)\"])\n",
    "                    break\n",
    "                except Exception as e:\n",
    "                    pass                \n",
    "            if n==20:\n",
    "                last_page = len(pages)-1\n",
    "                logging.info(\"Degraded mode for last_page, use len(pages)-1 with\"+\n",
    "                            \"\\ndocumentGuid=\"+df_dataset.loc[index, \"documentGuid\"])\n",
    "                \n",
    "    textcontent = []\n",
    "\n",
    "    for n in range(first_page, last_page+1):\n",
    "        if n==first_page:\n",
    "            try:\n",
    "                if source_type=='DRS':\n",
    "                    re_search = re.search(re.escape(df_dataset.loc[index, 'first 20 characters after title']), \n",
    "                                        pages[n].extract_text())\n",
    "                    start_textcontent = re_search.span()[0]\n",
    "                elif source_type=='NotInDRS':\n",
    "                    re_search = re.search(re.escape(df_dataset.loc[index, 'original pdf bookmark title (outline.title)']), \n",
    "                                        pages[n].extract_text())\n",
    "                    start_textcontent = re_search.span()[-1]\n",
    "\n",
    "            except Exception as e:\n",
    "                logging.info(\"Error identifying start_textcontent with \"+ e.args[0] +\n",
    "                             \"\\ndocumentGuid=\"+df_dataset.loc[index, \"documentGuid\"]+\n",
    "                             \"\\nfirst_page=\"+str(first_page)+\n",
    "                             \"\\nposition in bookmark tree=\"+df_dataset.loc[index, \"position in bookmark tree\"]+\n",
    "                             \"\\ntitle=\"+df_dataset.loc[index, \"original pdf bookmark title (outline.title)\"])\n",
    "                start_textcontent = 0\n",
    "        else:\n",
    "            start_textcontent = 0\n",
    "\n",
    "        if n==last_page:\n",
    "            try:\n",
    "                if source_type=='DRS':\n",
    "                    re_search = re.search(re.escape(df_dataset.loc[index+1, 'extracted title number'])+\n",
    "                                        '.{0,5}'+\n",
    "                                        re.escape(df_dataset.loc[index+1, 'extracted title text']), \n",
    "                                        pages[n].extract_text())                                    \n",
    "                    end_textcontent = re_search.span()[0]\n",
    "                elif source_type=='NotInDRS':\n",
    "                    re_search = re.search(re.escape(df_dataset.loc[index+1, 'original pdf bookmark title (outline.title)']), \n",
    "                                        pages[n].extract_text())\n",
    "                    end_textcontent = re_search.span()[0]\n",
    "\n",
    "            except Exception as e:\n",
    "                logging.info(\"Error identifying end_textcontent with \"+ e.args[0] +\n",
    "                             \"\\ndocumentGuid=\"+df_dataset.loc[index, \"documentGuid\"]+\n",
    "                             \"\\nlast_page=\"+str(last_page)+\n",
    "                             \"\\nposition in bookmark tree=\"+df_dataset.loc[index, \"position in bookmark tree\"]+\n",
    "                             \"\\ntitle=\"+df_dataset.loc[index, \"original pdf bookmark title (outline.title)\"])\n",
    "                end_textcontent = None\n",
    "        else:\n",
    "            end_textcontent = None\n",
    "\n",
    "        textcontent.append(pages[n].extract_text()[start_textcontent:end_textcontent])\n",
    "            \n",
    "    return str(textcontent)\n",
    "\n",
    "\n",
    "for index, row in df_dataset.iterrows():\n",
    "    matching_file = glob.glob(os.path.join(os.getcwd(), 'data', source_type, 'raw data', row[\"doc_type\"], 'pdf', '*'+row['documentGuid']+'*.pdf'))\n",
    "    if (len(matching_file)>0) and (row['drs:status']=='Current'):\n",
    "        pdf = PdfReader(matching_file[0])\n",
    "        df_dataset_filtered = df_dataset[df_dataset[\"documentGuid\"]==row[\"documentGuid\"]]\n",
    "\n",
    "        try:\n",
    "            df_dataset.at[index, 'parents_title_list'] = get_parents_title_list(row[\"position in bookmark tree\"],\n",
    "                                                                                df_dataset_filtered)        \n",
    "            df_dataset.at[index, 'content'] = get_textcontent(pdf.pages, \n",
    "                                                              index, \n",
    "                                                              df_dataset_filtered,\n",
    "                                                              source_type)\n",
    "        except Exception as e:\n",
    "            logging.info(\"Error with \"+ e.args[0] +\n",
    "                         \"\\ndocumentGuid=\"+df_dataset_filtered.loc[index, \"documentGuid\"]+\n",
    "                         \"\\nposition in bookmark tree=\"+df_dataset_filtered.loc[index, \"position in bookmark tree\"]+\n",
    "                         \"\\ntitle=\"+df_dataset_filtered.loc[index, \"original pdf bookmark title (outline.title)\"])\n",
    "\n",
    "\n",
    "df_dataset.to_parquet(os.path.join(os.getcwd(),\n",
    "                                   'data', \n",
    "                                   source_type, \n",
    "                                   'dataset',\n",
    "                                   'dataset',\n",
    "                                   'dataset_for_'+'-'.join(doc_types)+'-'+datetime.datetime.now().strftime(\"%Y%m%d - %H%M%S\")+'.parquet'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Some metric\n",
    "Number of documents total, number of documents per entry, histogram of number of words total, histogram of doc per doc type, nombre de doc pas dl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import glob\n",
    "import os\n",
    "\n",
    "datasets = sorted(glob.glob(os.path.join(os.getcwd(), \n",
    "                                         'data', \n",
    "                                         source_type, \n",
    "                                         'dataset', \n",
    "                                         'dataset', \n",
    "                                         '*.parquet')), \n",
    "                      key=os.path.getctime, \n",
    "                      reverse=True)\n",
    "df_dataset = pd.read_parquet(datasets[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_exploring = df_dataset[(300<df_nbwords) & (df_nbwords<400)][['documentGuid', \n",
    "                                                                'corrected pdf bookmark page number', \n",
    "                                                                'extracted title text', \n",
    "                                                                'parents_title_list',\n",
    "                                                                'content']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 22 documents over 1548 with less then 5 words extracted for all docs for NotInDRS documents\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "plt.rcParams['figure.dpi'] = 100\n",
    "plt.rcParams['figure.figsize'] = 6.4, 4.8\n",
    "\n",
    "nb_words = 5\n",
    "nb_words_max = 40000 \n",
    "\n",
    "# All docs\n",
    "df_nbwords = df_dataset['content'].apply(len)\n",
    "nb_zerowords_docs = df_nbwords[df_nbwords<nb_words].shape[0]\n",
    "print('There are %s documents over %s with less then %s words extracted for all docs for %s documents' % \n",
    "      (nb_zerowords_docs, df_nbwords.shape[0], nb_words, source_type))\n",
    "\n",
    "df_nbwords[df_nbwords<nb_words_max].hist(bins=100)\n",
    "plt.title(\"Number of extracted words all docs\")\n",
    "plt.show()\n",
    "\n",
    "ax = df_nbwords[df_nbwords<50].hist(bins=100)\n",
    "plt.title(\"Number of extracted words all docs with less than 500 words (for dense retrieval)\")\n",
    "plt.show()\n",
    "\n",
    "df_nbwords[df_nbwords>nb_words_max].hist(bins=100)\n",
    "plt.title(\"Number of extracted words all docs\")\n",
    "plt.show()\n",
    "\n",
    "df_dataset_manywords = df_dataset.loc[df_nbwords[df_nbwords>nb_words_max].index][['documentGuid', \n",
    "                                                                                  'corrected pdf bookmark page number', \n",
    "                                                                                  'extracted title text', \n",
    "                                                                                  'parents_title_list',\n",
    "                                                                                  'content']]\n",
    "\n",
    "# By doc for DRS\n",
    "if source_type=='DRS':\n",
    "    for doc_type in doc_types:\n",
    "        df_nbwords = df_dataset.loc[df_dataset[df_dataset['doc_type']==doc_type].index, 'content'].apply(len)\n",
    "        nb_zerowords_docs = df_nbwords[df_nbwords<nb_words].shape[0]\n",
    "        print('There are %s documents over %s with less then %s words extracted for %s for %s documents' % \n",
    "              (nb_zerowords_docs, df_nbwords.shape[0], nb_words, doc_type, source_type))\n",
    "\n",
    "        df_nbwords = df_nbwords[df_nbwords>=nb_words]\n",
    "        df_nbwords.hist(bins=100) # .plot.bar() # plt.yticks(fontsize=10)\n",
    "        plt.xlim(left=0, right=4000)\n",
    "        plt.title(\"Number of extracted words for \"+doc_type)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exploring some examples to find patterns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\victor\\AppData\\Local\\Temp\\ipykernel_12708\\3165917587.py:8: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  df_dataset_debug['size content'] = df_dataset['content'].apply(len)\n"
     ]
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "nb_words = 5\n",
    "fields = ['content', 'parents_title_list', 'documentURL']\n",
    "df_dataset_debug = df_dataset[fields]\n",
    "df_dataset_debug['size content'] = df_dataset['content'].apply(len)\n",
    "df_dataset_debug = df_dataset_debug.sort_values(by=['size content'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding the FARs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c:\\Users\\victor\\Documents\\DeepLearning\\FAA NLP Project\\data\\DRS\\index\\FAR_20240115 - 224301.parquet\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\victor\\anaconda3\\envs\\faa-nlp-drs\\Lib\\site-packages\\pyarrow\\pandas_compat.py:373: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if _pandas_api.is_sparse(col):\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import os\n",
    "import glob\n",
    "import datetime\n",
    "\n",
    "parquet_files = sorted(glob.glob(os.path.join(os.getcwd(),\n",
    "                                                'data', \n",
    "                                                'DRS', \n",
    "                                                'index', \n",
    "                                                'FAR_20*.parquet')), \n",
    "                    key=os.path.getctime, \n",
    "                    reverse=True)\n",
    "print(parquet_files[0])\n",
    "df_FAR_dataset = pd.read_parquet(parquet_files[0])\n",
    "df_FAR_dataset.insert(loc=0, \n",
    "                      column='content', \n",
    "                      value=pd.Series(df_FAR_dataset.shape[0]*[''], dtype=\"string\"))\n",
    "\n",
    "for index, row in df_FAR_dataset.iterrows():\n",
    "    file_matches = sorted(glob.glob(os.path.join(os.getcwd(),\n",
    "                                                'data',\n",
    "                                                'DRS',\n",
    "                                                'raw data',\n",
    "                                                'FAR',\n",
    "                                                'pdf',\n",
    "                                                '*'+row['documentGuid']+'.txt')\n",
    "                                    ),\n",
    "                                    key=os.path.getsize)\n",
    "    if len(file_matches)>0:\n",
    "        with open(file_matches[0], \"r\") as f:\n",
    "            df_FAR_dataset.loc[index, 'content'] = f.read()\n",
    "\n",
    "df_FAR_dataset.to_parquet(os.path.join(os.getcwd(),\n",
    "                                       'data',\n",
    "                                       'DRS', \n",
    "                                       'dataset',\n",
    "                                       'FAR',\n",
    "                                       'dataset_for_-FAR-'+datetime.datetime.now().strftime(\"%Y%m%d - %H%M%S\")+'.parquet'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c:\\Users\\victor\\Documents\\DeepLearning\\FAA NLP Project\\data\\DRS\\dataset\\FAR\\dataset_for_-FAR-20240227 - 043028.parquet\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import os\n",
    "import glob\n",
    "import datetime\n",
    "\n",
    "predatasets = sorted(glob.glob(os.path.join(os.getcwd(), \n",
    "                                            'data', \n",
    "                                            'DRS', \n",
    "                                            'dataset', \n",
    "                                            'FAR', \n",
    "                                            'dataset_for_-FAR-*.parquet')), \n",
    "                    key=os.path.getctime, \n",
    "                    reverse=True)\n",
    "print(predatasets[0])\n",
    "df_FAR_dataset = pd.read_parquet(predatasets[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dataset with AIP, AIM, FARs, ACs, Orders"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c:\\Users\\victor\\Documents\\DeepLearning\\FAA NLP Project\\data\\DRS\\dataset\\dataset\\dataset_for_AC-ORDER_8300.10-ORDER_8400.10-ORDER_8700.1-ORDER_8740.1-ORDER_8900.1-ORDERS-20240127 - 111830.parquet\n",
      "c:\\Users\\victor\\Documents\\DeepLearning\\FAA NLP Project\\data\\NotInDRS\\dataset\\dataset\\dataset_for_AC-ORDER_8300.10-ORDER_8400.10-ORDER_8700.1-ORDER_8740.1-ORDER_8900.1-ORDERS-20240128 - 221738.parquet\n",
      "c:\\Users\\victor\\Documents\\DeepLearning\\FAA NLP Project\\data\\DRS\\dataset\\FAR\\dataset_for_-FAR-20240227 - 043028.parquet\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\victor\\anaconda3\\envs\\faa-nlp-drs\\Lib\\site-packages\\pyarrow\\pandas_compat.py:373: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if _pandas_api.is_sparse(col):\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import os\n",
    "import glob\n",
    "\n",
    "# DRS\n",
    "predatasets = sorted(glob.glob(os.path.join(os.getcwd(), \n",
    "                                            'data', \n",
    "                                            'DRS', \n",
    "                                            'dataset', \n",
    "                                            'dataset', \n",
    "                                            '*.parquet')), \n",
    "                    key=os.path.getctime, \n",
    "                    reverse=True)\n",
    "print(predatasets[0])\n",
    "df_DRS_dataset = pd.read_parquet(predatasets[0])\n",
    "\n",
    "# Non-DRS\n",
    "predatasets = sorted(glob.glob(os.path.join(os.getcwd(), \n",
    "                                            'data', \n",
    "                                            'NotInDRS', \n",
    "                                            'dataset', \n",
    "                                            'dataset', \n",
    "                                            '*.parquet')), \n",
    "                    key=os.path.getctime, \n",
    "                    reverse=True)\n",
    "print(predatasets[0])\n",
    "df_NotInDRS_dataset = pd.read_parquet(predatasets[0])\n",
    "\n",
    "# FAR\n",
    "predatasets = sorted(glob.glob(os.path.join(os.getcwd(), \n",
    "                                            'data', \n",
    "                                            'DRS', \n",
    "                                            'dataset', \n",
    "                                            'FAR', \n",
    "                                            'dataset_for_-FAR-*.parquet')), \n",
    "                    key=os.path.getctime, \n",
    "                    reverse=True)\n",
    "print(predatasets[0])\n",
    "df_FAR_dataset = pd.read_parquet(predatasets[0])\n",
    "\n",
    "# Together\n",
    "df_dataset = pd.concat([df_DRS_dataset,\n",
    "                        df_NotInDRS_dataset,\n",
    "                        df_FAR_dataset])\n",
    "\n",
    "df_dataset.to_parquet(os.path.join(os.getcwd(),\n",
    "                                       'data',\n",
    "                                       'DRS', \n",
    "                                       'dataset',\n",
    "                                       'all_drs',\n",
    "                                       'dataset_for_-FAR-ORDERS-ACs-AIP-AIM-'+datetime.datetime.now().strftime(\"%Y%m%d - %H%M%S\")+'.parquet'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Other datasets format\n",
    "First loading the complete dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/victor/NLP/FAA-NLP-Project/data/DRS/dataset/all_drs/dataset_for_-FAR-ORDERS-ACs-AIP-AIM-20240301 - 034459.parquet\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import os\n",
    "import glob\n",
    "import datetime\n",
    "\n",
    "predatasets = sorted(glob.glob(os.path.join(os.getcwd(), \n",
    "                                            'data', \n",
    "                                            'DRS', \n",
    "                                            'dataset', \n",
    "                                            'all_drs', \n",
    "                                            'dataset_for_-FAR-ORDERS-ACs-AIP-AIM-*.parquet')), \n",
    "                    key=os.path.getctime, \n",
    "                    reverse=True)\n",
    "print(predatasets[0])\n",
    "df_dataset = pd.read_parquet(predatasets[0])\n",
    "df_dataset = df_dataset.reset_index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "index                                                                                       4780\n",
       "parents_title_list                             [4304    Airworthiness Approval of Enhanced Vi...\n",
       "content                                        ['4 CFR § 1.1) - A specified altitude in an in...\n",
       "documentGuid                                                    C2774DBA5FFEE8D286258088005528A9\n",
       "position in bookmark tree                                                          5>2>1>1>8>0>5\n",
       "original pdf bookmark title (outline.title)    I.1.6 Decision Altitude (14 CFR § 1.1) - A spe...\n",
       "original pdf bookmark page number                                                             94\n",
       "corrected pdf bookmark page number                                                            94\n",
       "extracted title number                                                                    I.1.6 \n",
       "extracted title text                                                        Decision Altitude (1\n",
       "first 20 characters after title                                   4 CFR § 1.1) - A specified alt\n",
       "nb_keywords for title search                                                                   5\n",
       "doc_type                                                                                      AC\n",
       "drs:documentNumber                                                                    AC 20-167A\n",
       "drs:status                                                                               Current\n",
       "drs:title                                      Airworthiness Approval of Enhanced Vision Syst...\n",
       "Name: 4780, dtype: object"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_dataset.iloc[4780][['index', \n",
    "                       'parents_title_list', \n",
    "                       'content', \n",
    "                       'documentGuid', \n",
    "                       'position in bookmark tree', \n",
    "                       'original pdf bookmark title (outline.title)', \n",
    "                       'original pdf bookmark page number', \n",
    "                       'corrected pdf bookmark page number', \n",
    "                       'extracted title number', \n",
    "                       'extracted title text', \n",
    "                       'first 20 characters after title', \n",
    "                       'nb_keywords for title search', \n",
    "                       'doc_type', \n",
    "                       'drs:documentNumber', \n",
    "                       'drs:status', \n",
    "                       'drs:title']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Word count filtering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "word_count_lower_limit = 30\n",
    "word_count_upper_limit = 100000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generate JSONL\n",
    "Axolotl [pre-training](https://openaccess-ai-collective.github.io/axolotl/docs/dataset-formats/pretraining.html):\n",
    "`{\"text\": \"first row\"} {\"text\": \"second row\"}`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import os\n",
    "import glob\n",
    "\n",
    "df_jsonl = df_dataset[[\"drs:title\", \"parents_title_list\", \"content\"]]\n",
    "df_jsonl = df_gemini.loc[word_count_lower_limit<df_gemini[\"content\"].str.len()]\n",
    "df_gemini = df_gemini.loc[df_gemini[\"content\"].str.len()<word_count_upper_limit]\n",
    "\n",
    "df_gemini_title = df_gemini[\"drs:title\"].map(lambda x: \"title:\\n \"+x+\"\\n\\n\")\n",
    "df_jsonl_parents_title_list = df_gemini[\"parents_title_list\"].map(lambda x: \"document context and subtitles:\\n \"+'; '.join(x[2:-2].split('dtype: string')[-1].split(', '))+\"\\n\\n\" \n",
    "                                                                               if str(x)!='<NA>' \n",
    "                                                                               else \"\")\n",
    "df_gemini_content = df_gemini[\"content\"].map(lambda x: \"content:\\n \"+' '.join(x[2:-2].split(', ')))\n",
    "\n",
    "df_jsonl = pd.Series(df_jsonl_title+df_jsonl_parents_title_list+df_jsonl_content,\n",
    "                     name=\"text\").to_frame()\n",
    "\n",
    "df_jsonl.to_json(os.path.join(os.getcwd(),\n",
    "                            'data',\n",
    "                            'DRS', \n",
    "                            'dataset',\n",
    "                            'all_drs',\n",
    "                            'dataset_axolotl-pretraining_for_FAR-ORDERS-ACs-AIP-AIM-'+datetime.datetime.now().strftime(\"%Y%m%d - %H%M%S\")+'.jsonl'),\n",
    "                orient='records', \n",
    "                lines=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Axolotl [oasst](https://openaccess-ai-collective.github.io/axolotl/docs/dataset-formats/inst_tune.html#oasst) fine-tuning:\n",
    "`{\"INSTRUCTION\": \"...\", \"RESPONSE\": \"...\"}`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import os\n",
    "import glob\n",
    "\n",
    "df_jsonl = df_dataset[[\"drs:title\", \"parents_title_list\", \"content\"]]\n",
    "df_jsonl = df_jsonl.loc[word_count_lower_limit<df_jsonl[\"content\"].str.len()]\n",
    "df_jsonl = df_jsonl.loc[df_jsonl[\"content\"].str.len()<word_count_upper_limit]\n",
    "\n",
    "df_jsonl_title = df_jsonl[\"drs:title\"].map(lambda x: \"title:\\n \"+x+\"\\n\\n\").astype(\"string\")\n",
    "df_jsonl_parents_title_list = df_jsonl[\"parents_title_list\"].map(lambda x: \"document context:\\n \"+'; '.join(x[2:-2].split('dtype: string')[-1].split(', '))+\"\\n\\n\" \n",
    "                                                                               if str(x)!='<NA>' \n",
    "                                                                               else \"\").astype(\"string\")\n",
    "df_jsonl_content = df_jsonl[\"content\"].map(lambda x: ' '.join(x[2:-2].split(', '))).astype(\"string\")\n",
    "\n",
    "\n",
    "INSTRUCTION_introduction = 'Can you provide more explanations given the following title and document context.\\n\\n'\n",
    "df_jsonl_INSTRUCTION = pd.Series(INSTRUCTION_introduction+df_jsonl_title+df_jsonl_parents_title_list, \n",
    "                                 dtype=\"string\",\n",
    "                                 name=\"INSTRUCTION\").astype(\"string\").to_frame()\n",
    "df_jsonl_RESPONSE = pd.Series(df_jsonl_content,\n",
    "                              dtype=\"string\",\n",
    "                              name=\"RESPONSE\").astype(\"string\").to_frame()\n",
    "df_jsonl = pd.concat([df_jsonl_INSTRUCTION[\"INSTRUCTION\"], df_jsonl_RESPONSE[\"RESPONSE\"]], axis=1)\n",
    "\n",
    "df_jsonl.to_json(os.path.join(os.getcwd(),\n",
    "                            'data',\n",
    "                            'DRS', \n",
    "                            'dataset',\n",
    "                            'all_drs',\n",
    "                            'dataset_axolotl-finetuning_for_FAR-ORDERS-ACs-AIP-AIM-'+datetime.datetime.now().strftime(\"%Y%m%d - %H%M%S\")+'.jsonl'),\n",
    "                orient='records', \n",
    "                lines=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generate CSV\n",
    "For [Gemini](https://developers.googleblog.com/2024/03/tune-gemini-pro-in-google-ai-studio-or-gemini-api.html) fine tuning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import os\n",
    "import glob\n",
    "\n",
    "df_jsonl = df_dataset[[\"drs:title\", \"parents_title_list\", \"content\"]]\n",
    "df_jsonl = df_jsonl.loc[word_count_lower_limit<df_jsonl[\"content\"].str.len()]\n",
    "df_jsonl = df_jsonl.loc[df_jsonl[\"content\"].str.len()<word_count_upper_limit]\n",
    "\n",
    "df_jsonl_title = df_jsonl[\"drs:title\"].map(lambda x: \"title:\\n \"+x+\"\\n\\n\")\n",
    "df_jsonl_parents_title_list = df_jsonl[\"parents_title_list\"].map(lambda x: \"document context and subtitles:\\n \"+'; '.join(x[2:-2].split('dtype: string')[-1].split(', '))+\"\\n\\n\" \n",
    "                                                                               if str(x)!='<NA>' \n",
    "                                                                               else \"\")\n",
    "df_jsonl_content = df_jsonl[\"content\"].map(lambda x: \"content:\\n \"+' '.join(x[2:-2].split(', ')))\n",
    "\n",
    "df_jsonl = df_jsonl_title+df_jsonl_parents_title_list+df_jsonl_content\n",
    "\n",
    "df_jsonl.to_csv(os.path.join(os.getcwd(),\n",
    "                            'data',\n",
    "                            'DRS', \n",
    "                            'dataset',\n",
    "                            'all_drs',\n",
    "                            'dataset_gemini_for_FAR-ORDERS-ACs-AIP-AIM-'+datetime.datetime.now().strftime(\"%Y%m%d - %H%M%S\")+'.csv'),\n",
    "                index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Passing raw text with Gemini API"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "title:\n",
      " Acceptable Methods, Techniques, and Practices - Aircraft Inspection and Repair\n",
      "\n",
      "document context and subtitles:\n",
      " ; 'Chapter 11.pdf'; 'Ch_11-05.pdf'; 'SECTION 5.  ELECTRICAL WIRE RATING'; 'INSTRUCTIONS FOR USE OF ELECTRICAL WIRE CHART.'; 'Example No. 1.  Find the wire size in figure€11˚2 using the following known information:'; 'The voltage source is 28€volts from bus to equipment.\n",
      "\n",
      "content:\n",
      " 28 volts from bus to equipment. \n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[5], line 17\u001b[0m\n\u001b[1;32m     13\u001b[0m df_gemini_content \u001b[38;5;241m=\u001b[39m df_gemini[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcontent\u001b[39m\u001b[38;5;124m\"\u001b[39m]\u001b[38;5;241m.\u001b[39mmap(\u001b[38;5;28;01mlambda\u001b[39;00m x: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcontent:\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m \u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m+\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;241m.\u001b[39mjoin(x[\u001b[38;5;241m2\u001b[39m:\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m2\u001b[39m]\u001b[38;5;241m.\u001b[39msplit(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m, \u001b[39m\u001b[38;5;124m'\u001b[39m)))\n\u001b[1;32m     15\u001b[0m df_gemini \u001b[38;5;241m=\u001b[39m df_gemini_title\u001b[38;5;241m+\u001b[39mdf_gemini_parents_title_list\u001b[38;5;241m+\u001b[39mdf_gemini_content\n\u001b[0;32m---> 17\u001b[0m \u001b[43mdf_gemini\u001b[49m\u001b[38;5;241m.\u001b[39mto_frame()\u001b[38;5;241m.\u001b[39mto_parquet(os\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39mjoin(os\u001b[38;5;241m.\u001b[39mgetcwd(),\n\u001b[1;32m     18\u001b[0m                             \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mdata\u001b[39m\u001b[38;5;124m'\u001b[39m,\n\u001b[1;32m     19\u001b[0m                             \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mDRS\u001b[39m\u001b[38;5;124m'\u001b[39m, \n\u001b[1;32m     20\u001b[0m                             \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mdataset\u001b[39m\u001b[38;5;124m'\u001b[39m,\n\u001b[1;32m     21\u001b[0m                             \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mall_drs\u001b[39m\u001b[38;5;124m'\u001b[39m,\n\u001b[1;32m     22\u001b[0m                             \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mdataset_gemini raw data_for_FAR-ORDERS-ACs-AIP-AIM-\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;241m+\u001b[39mdatetime\u001b[38;5;241m.\u001b[39mdatetime\u001b[38;5;241m.\u001b[39mnow()\u001b[38;5;241m.\u001b[39mstrftime(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m%\u001b[39m\u001b[38;5;124mY\u001b[39m\u001b[38;5;124m%\u001b[39m\u001b[38;5;124mm\u001b[39m\u001b[38;5;132;01m%d\u001b[39;00m\u001b[38;5;124m - \u001b[39m\u001b[38;5;124m%\u001b[39m\u001b[38;5;124mH\u001b[39m\u001b[38;5;124m%\u001b[39m\u001b[38;5;124mM\u001b[39m\u001b[38;5;124m%\u001b[39m\u001b[38;5;124mS\u001b[39m\u001b[38;5;124m\"\u001b[39m)\u001b[38;5;241m+\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m.parquet\u001b[39m\u001b[38;5;124m'\u001b[39m),\n\u001b[1;32m     23\u001b[0m                 index\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m)\n",
      "Cell \u001b[0;32mIn[5], line 17\u001b[0m\n\u001b[1;32m     13\u001b[0m df_gemini_content \u001b[38;5;241m=\u001b[39m df_gemini[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcontent\u001b[39m\u001b[38;5;124m\"\u001b[39m]\u001b[38;5;241m.\u001b[39mmap(\u001b[38;5;28;01mlambda\u001b[39;00m x: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcontent:\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m \u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m+\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;241m.\u001b[39mjoin(x[\u001b[38;5;241m2\u001b[39m:\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m2\u001b[39m]\u001b[38;5;241m.\u001b[39msplit(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m, \u001b[39m\u001b[38;5;124m'\u001b[39m)))\n\u001b[1;32m     15\u001b[0m df_gemini \u001b[38;5;241m=\u001b[39m df_gemini_title\u001b[38;5;241m+\u001b[39mdf_gemini_parents_title_list\u001b[38;5;241m+\u001b[39mdf_gemini_content\n\u001b[0;32m---> 17\u001b[0m \u001b[43mdf_gemini\u001b[49m\u001b[38;5;241m.\u001b[39mto_frame()\u001b[38;5;241m.\u001b[39mto_parquet(os\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39mjoin(os\u001b[38;5;241m.\u001b[39mgetcwd(),\n\u001b[1;32m     18\u001b[0m                             \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mdata\u001b[39m\u001b[38;5;124m'\u001b[39m,\n\u001b[1;32m     19\u001b[0m                             \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mDRS\u001b[39m\u001b[38;5;124m'\u001b[39m, \n\u001b[1;32m     20\u001b[0m                             \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mdataset\u001b[39m\u001b[38;5;124m'\u001b[39m,\n\u001b[1;32m     21\u001b[0m                             \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mall_drs\u001b[39m\u001b[38;5;124m'\u001b[39m,\n\u001b[1;32m     22\u001b[0m                             \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mdataset_gemini raw data_for_FAR-ORDERS-ACs-AIP-AIM-\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;241m+\u001b[39mdatetime\u001b[38;5;241m.\u001b[39mdatetime\u001b[38;5;241m.\u001b[39mnow()\u001b[38;5;241m.\u001b[39mstrftime(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m%\u001b[39m\u001b[38;5;124mY\u001b[39m\u001b[38;5;124m%\u001b[39m\u001b[38;5;124mm\u001b[39m\u001b[38;5;132;01m%d\u001b[39;00m\u001b[38;5;124m - \u001b[39m\u001b[38;5;124m%\u001b[39m\u001b[38;5;124mH\u001b[39m\u001b[38;5;124m%\u001b[39m\u001b[38;5;124mM\u001b[39m\u001b[38;5;124m%\u001b[39m\u001b[38;5;124mS\u001b[39m\u001b[38;5;124m\"\u001b[39m)\u001b[38;5;241m+\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m.parquet\u001b[39m\u001b[38;5;124m'\u001b[39m),\n\u001b[1;32m     23\u001b[0m                 index\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m)\n",
      "File \u001b[0;32m_pydevd_bundle/pydevd_cython.pyx:1457\u001b[0m, in \u001b[0;36m_pydevd_bundle.pydevd_cython.SafeCallWrapper.__call__\u001b[0;34m()\u001b[0m\n",
      "File \u001b[0;32m_pydevd_bundle/pydevd_cython.pyx:701\u001b[0m, in \u001b[0;36m_pydevd_bundle.pydevd_cython.PyDBFrame.trace_dispatch\u001b[0;34m()\u001b[0m\n",
      "File \u001b[0;32m_pydevd_bundle/pydevd_cython.pyx:1152\u001b[0m, in \u001b[0;36m_pydevd_bundle.pydevd_cython.PyDBFrame.trace_dispatch\u001b[0;34m()\u001b[0m\n",
      "File \u001b[0;32m_pydevd_bundle/pydevd_cython.pyx:1135\u001b[0m, in \u001b[0;36m_pydevd_bundle.pydevd_cython.PyDBFrame.trace_dispatch\u001b[0;34m()\u001b[0m\n",
      "File \u001b[0;32m_pydevd_bundle/pydevd_cython.pyx:312\u001b[0m, in \u001b[0;36m_pydevd_bundle.pydevd_cython.PyDBFrame.do_wait_suspend\u001b[0;34m()\u001b[0m\n",
      "File \u001b[0;32m~/anaconda3/envs/drs_faa/lib/python3.11/site-packages/debugpy/_vendored/pydevd/pydevd.py:2070\u001b[0m, in \u001b[0;36mPyDB.do_wait_suspend\u001b[0;34m(self, thread, frame, event, arg, exception_type)\u001b[0m\n\u001b[1;32m   2067\u001b[0m             from_this_thread\u001b[38;5;241m.\u001b[39mappend(frame_custom_thread_id)\n\u001b[1;32m   2069\u001b[0m     \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_threads_suspended_single_notification\u001b[38;5;241m.\u001b[39mnotify_thread_suspended(thread_id, thread, stop_reason):\n\u001b[0;32m-> 2070\u001b[0m         keep_suspended \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_do_wait_suspend\u001b[49m\u001b[43m(\u001b[49m\u001b[43mthread\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mframe\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mevent\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43marg\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msuspend_type\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfrom_this_thread\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mframes_tracker\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   2072\u001b[0m frames_list \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m   2074\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m keep_suspended:\n\u001b[1;32m   2075\u001b[0m     \u001b[38;5;66;03m# This means that we should pause again after a set next statement.\u001b[39;00m\n",
      "File \u001b[0;32m~/anaconda3/envs/drs_faa/lib/python3.11/site-packages/debugpy/_vendored/pydevd/pydevd.py:2106\u001b[0m, in \u001b[0;36mPyDB._do_wait_suspend\u001b[0;34m(self, thread, frame, event, arg, suspend_type, from_this_thread, frames_tracker)\u001b[0m\n\u001b[1;32m   2103\u001b[0m         \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_call_input_hook()\n\u001b[1;32m   2105\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mprocess_internal_commands()\n\u001b[0;32m-> 2106\u001b[0m     time\u001b[38;5;241m.\u001b[39msleep(\u001b[38;5;241m0.01\u001b[39m)\n\u001b[1;32m   2108\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcancel_async_evaluation(get_current_thread_id(thread), \u001b[38;5;28mstr\u001b[39m(\u001b[38;5;28mid\u001b[39m(frame)))\n\u001b[1;32m   2110\u001b[0m \u001b[38;5;66;03m# process any stepping instructions\u001b[39;00m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import os\n",
    "import glob\n",
    "\n",
    "df_gemini = df_dataset[[\"drs:title\", \"parents_title_list\", \"content\"]]\n",
    "df_gemini = df_gemini.loc[word_count_lower_limit<df_gemini[\"content\"].str.len()]\n",
    "df_gemini = df_gemini.loc[df_gemini[\"content\"].str.len()<word_count_upper_limit]\n",
    "\n",
    "df_gemini_title = df_gemini[\"drs:title\"].map(lambda x: \"title:\\n \"+x+\"\\n\\n\")\n",
    "df_gemini_parents_title_list = df_gemini[\"parents_title_list\"].map(lambda x: \"document context and subtitles:\\n \"+'; '.join(x[2:-2].split('dtype: string')[-1].split(', '))+\"\\n\\n\" \n",
    "                                                                               if str(x)!='<NA>' \n",
    "                                                                               else \"\")\n",
    "df_gemini_content = df_gemini[\"content\"].map(lambda x: \"content:\\n \"+' '.join(x[2:-2].split(', ')))\n",
    "\n",
    "df_gemini = df_gemini_title+df_gemini_parents_title_list+df_gemini_content\n",
    "\n",
    "df_gemini.to_frame().to_parquet(os.path.join(os.getcwd(),\n",
    "                            'data',\n",
    "                            'DRS', \n",
    "                            'dataset',\n",
    "                            'all_drs',\n",
    "                            'dataset_gemini raw data_for_FAR-ORDERS-ACs-AIP-AIM-'+datetime.datetime.now().strftime(\"%Y%m%d - %H%M%S\")+'.parquet'),\n",
    "                index=False)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.11.5"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "8c49a9e6d6b122d0bc46f085b0f9b84866f77188fdff3252b8a9eae176833897"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}