dblp_data_extraction.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from lxml import etree\n",
    "from datetime import datetime\n",
    "import csv\n",
    "import codecs\n",
    "import ujson\n",
    "import re\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_elements = {\"article\", \"inproceedings\", \"proceedings\", \"book\", \"incollection\", \"phdthesis\", \n",
    "                \"mastersthesis\", \"www\"}\n",
    "all_features = {\"address\", \"author\", \"booktitle\", \"cdrom\", \"chapter\", \"cite\", \"crossref\", \"editor\", \"ee\", \"isbn\",\n",
    "                \"journal\", \"month\", \"note\", \"number\", \"pages\", \"publisher\", \"school\", \"series\", \"title\", \"url\",\n",
    "                \"volume\", \"year\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def log_msg(message):\n",
    "    print(datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\"), message)\n",
    "    \n",
    "def context_iter(dblp_path):\n",
    "    return etree.iterparse(source=dblp_path, dtd_validation=True, load_dtd=True)  # required dtd\n",
    "\n",
    "def clear_element(element):\n",
    "    element.clear()\n",
    "    while element.getprevious() is not None:\n",
    "        del element.getparent()[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_feature(elem, features, include_key=False):\n",
    "    if include_key:\n",
    "        attribs = {'key': [elem.attrib['key']]}\n",
    "    else:\n",
    "        attribs = {}\n",
    "    for feature in features:\n",
    "        attribs[feature] = []\n",
    "    for sub in elem:\n",
    "        if sub.tag not in features:\n",
    "            continue\n",
    "        if sub.tag == 'title':\n",
    "            text = re.sub(\"<.*?>\", \"\", etree.tostring(sub).decode('utf-8')) if sub.text is None else sub.text\n",
    "        elif sub.tag == 'pages':\n",
    "            text = count_pages(sub.text)\n",
    "        else:\n",
    "            text = sub.text\n",
    "        if text is not None and len(text) > 0:\n",
    "            attribs[sub.tag] = attribs.get(sub.tag) + [text]\n",
    "    return attribs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_pages(pages):\n",
    "    cnt = 0\n",
    "    for part in re.compile(r\",\").split(pages):\n",
    "        subparts = re.compile(r\"-\").split(part)\n",
    "        if len(subparts) > 2:\n",
    "            continue\n",
    "        else:\n",
    "            try:\n",
    "                re_digits = re.compile(r\"[\\d]+\")\n",
    "                subparts = [int(re_digits.findall(sub)[-1]) for sub in subparts]\n",
    "            except IndexError:\n",
    "                continue\n",
    "            cnt += 1 if len(subparts) == 1 else subparts[1] - subparts[0] + 1\n",
    "    return \"\" if cnt == 0 else str(cnt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parse_entity(dblp_path, save_path, type_name, features=None, save_to_csv=False, include_key=False):\n",
    "    log_msg(\"PROCESS: Start parsing for {}...\".format(str(type_name)))\n",
    "    #i=0\n",
    "    assert features is not None,\n",
    "    results = []\n",
    "    attrib_count, full_entity, part_entity = {}, 0, 0\n",
    "    for _, elem in context_iter(dblp_path):\n",
    "        if elem.tag in type_name:\n",
    "            #print(elem.tag)\n",
    "            #i+=1\n",
    "            attrib_values = extract_feature(elem, features, include_key)\n",
    "            attrib_values['type']=[]\n",
    "            attrib_values['type'].append(elem.tag)\n",
    "            #print(attrib_values)\n",
    "            results.append(attrib_values)\n",
    "            for key, value in attrib_values.items():\n",
    "                attrib_count[key] = attrib_count.get(key, 0) + len(value)\n",
    "            cnt = sum([1 if len(x) > 0 else 0 for x in list(attrib_values.values())])\n",
    "            if cnt == len(features):\n",
    "                full_entity += 1\n",
    "            else:\n",
    "                part_entity += 1\n",
    "        elif elem.tag not in all_elements:\n",
    "            continue\n",
    "        clear_element(elem)\n",
    "        '''if i > 10:\n",
    "            break '''\n",
    "    if save_to_csv:\n",
    "        f = open(save_path, 'w', newline='', encoding='utf8')\n",
    "        writer = csv.writer(f, delimiter=',')\n",
    "        features.append('type')\n",
    "        writer.writerow(features)\n",
    "        for record in results:\n",
    "            row = ['::'.join(v) for v in list(record.values())]\n",
    "            writer.writerow(row)\n",
    "        f.close()\n",
    "    else:\n",
    "        with codecs.open(save_path, mode='w', encoding='utf8', errors='ignore') as f:\n",
    "            ujson.dump(results, f)\n",
    "    return full_entity, part_entity, attrib_count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parse_publications(dblp_path, save_path, save_to_csv=False, include_key=False):\n",
    "    type_name = ['article', 'book', 'incollection', 'inproceedings']\n",
    "    features = ['title', 'author', 'year', 'journal', 'pages']\n",
    "    info = parse_entity(dblp_path, save_path, type_name, features, save_to_csv=save_to_csv, include_key=include_key)\n",
    "    log_msg('Total publications found: {}, publications contain all features: {}, publications contain part of '\n",
    "            'features: {}'.format(info[0] + info[1], info[0], info[1]))\n",
    "    log_msg(\"Features information: {}\".format(str(info[2])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    dblp_path = 'dblp/dblp.xml'\n",
    "    save_path = 'dblp/publications.csv'\n",
    "    try:\n",
    "        context_iter(dblp_path)\n",
    "        log_msg(\"LOG: Successfully loaded \\\"{}\\\".\".format(dblp_path))\n",
    "    except IOError:\n",
    "        log_msg(\"ERROR: Failed to load file \\\"{}\\\". Please check your XML and DTD files.\".format(dblp_path))\n",
    "        exit()\n",
    "    parse_publications(dblp_path, save_path, save_to_csv=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2019-12-23 14:50:30 LOG: Successfully loaded \"dblp/dblp.xml\".\n",
      "2019-12-23 14:50:30 PROCESS: Start parsing for ['article', 'book', 'incollection', 'inproceedings']...\n",
      "2019-12-23 14:53:59 Total publications found: 4724195, publications contain all features: 2735193, publications contain part of features: 1989002\n",
      "2019-12-23 14:53:59 Features information: {'title': 4724195, 'author': 14331144, 'year': 4724192, 'journal': 2145310, 'pages': 4255645, 'type': 4724195}\n"
     ]
    }
   ],
   "source": [
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/dhananjay/genealogy/.env/lib/python3.6/site-packages/IPython/core/interactiveshell.py:3051: DtypeWarning: Columns (3,4) have mixed types. Specify dtype option on import or set low_memory=False.\n",
      "  interactivity=interactivity, compiler=compiler, result=result)\n"
     ]
    }
   ],
   "source": [
    "df= pd.read_csv('dblp/publications.csv',delimiter=',',encoding='utf8')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['year']=df['year'].fillna('0000').astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "publ_count=df.groupby(['year']).size().reset_index(name='counts')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7ff6854f8908>"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "publ_count[publ_count['year']>1900].plot('year','counts')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2145537"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[df['type']=='article'].shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2500668"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[df['type']=='inproceedings'].shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "60150"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[df['type']=='incollection'].shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17840"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[df['type']=='book'].shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}