lecture_6.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python\n",
    "\n",
    "## Работа с файлами\n",
    "\n",
    "### Раздел 1. Общие сведения\n",
    "\n",
    "В некоторых проектах просто невозможно избежать необходимости создавать хранилище данных. В случаях, когда речь идет о большом количестве данных, которые реализуют какую-то схему (в контексте релляционных БД это озночает, что они могут быть описаны в виде таблицы или совокупности таблиц), лучше всего подходят базы данных. Но очевидно, что создавать базу данных только лишь для хранения конфигурации — не самое оптимальное решение. К тому же, часть задач требует чтения информации из файлов или записи информации в файлы. Таким образом, понимание работы с файлами необходима и может пригодиться в очень задачах из различных областей.\n",
    "\n",
    "### Раздел 2. Взаимодействие с binary-файлами\n",
    "\n",
    "Прежде всего необходимо отметить, что в Python есть два типа данных, которые позволяют оперировать над двоичными данными: bytes и bytearray. Оба из них содержат последовательность из нуля и более целых чисел от 0 до 255 включительно. Оба типа похожи на тип string и предоставляют схожий интерфейс. В дополнение, bytes является неизменяемым, а bytearray — изменяемым. В результате, для последнего доступен интерфейс, схожий со списками.\n",
    "\n",
    "Взаимодействие с двоичным представлением данных как правило позволяет добиться наибольшей компрессии данных. Самым удобным в данном случае является использование модуля Pickles, хотя ручная обработка бинарных данных может помочь сэкономить немного дискового пространства.\n",
    "\n",
    "#### Pickles с опциональным сжатием\n",
    "\n",
    "Pickles — самый удобный способ сохранять в и загружать из файлов данные, представленные в виде объектов языка Python. При этом Pickles не предоставляет никаких механизмов защиты, так что загрузка объекта, полученного извне, несет с собой потенциальные угрозы.\n",
    "\n",
    "Вот пример кода для экспорт объекта при помощи Pickles (из Саммерфилда):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def export_pickle(self, filename, compress=False):\n",
    "    fh = None\n",
    "    try:\n",
    "        if compress:\n",
    "            fh = gzip.open(filename, \"wb\")\n",
    "        else:\n",
    "            fh = open(filename, \"wb\")\n",
    "        pickle.dump(self, fh, pickle.HIGHEST_PROTOCOL)\n",
    "        return True\n",
    "    except (EnvironmentError, pickle.PicklingError) as err:\n",
    "        print(\"{0}: export error: {1}\".format(os.path.basename(sys.argv[0]), err))\n",
    "        return False\n",
    "    finally:\n",
    "        if fh is not None:\n",
    "            fh.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если был передан параметр compression со значением True, то будет выполнено сжатие при помощи модуля gzip. В противном случае, дескриптор файла будет получен при помощи функции open. И в том, и в другом случае доступ к файлу будет осуществляться в бинарном режиме для чтения (wb). Для записи объекта в файл используется вызов dump модуля pickle, с параметром pickle.HIGHEST_PROTOCOL который отвечает за использование компактного двоичного формата.\n",
    "\n",
    "В случае, если мы получили какое-то исключение, мы его обработает, выведя сообщение об ошибке и вернув False в качестве результата.\n",
    "\n",
    "Если никаких исключений не было, то возвращается значение True.\n",
    "\n",
    "В любом случае, дескриптор файла необходимо закрыть, так что в блоке finally содержится соответствующий вызов, если дескриптор файла не является None на момент вызова."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Небольшая вставка про магические числа\n",
    "\n",
    "Магические числа (magic numbers) — специальные последовательности бит, которые располагаются где-то вначале файла, которые позволяют определить, к какому типу относится данный файл. За всеми подробностями обращайтесь к `man file` и `man magic`, но если коротко, то волшебные числа определяются при помощи смещения, типа значения и самого значения. Т.е. вы можете определить собственное магическое число, которое представлено, скажем строкой \"Lambda\" со смещением 42. Тогда взяв любой файл, вы сможете определить, относится он или не относится к определенному вами типу."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Перейдем теперь к импорту файлов при помощи Pickles (код также из Саммерфилда):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "GZIP_MAGIC = b\"\\x1F\\x8B\"\n",
    "\n",
    "def import_pickle(self, filename):\n",
    "    fh = None\n",
    "    try:\n",
    "        fh = open(filename, \"rb\")\n",
    "        magic = fh.read(len(GZIP_MAGIC))\n",
    "        if magic == GZIP_MAGIC:\n",
    "            fh.close()\n",
    "            fh = gzip.open(filename, \"rb\")\n",
    "        else:\n",
    "            fh.seek(0)\n",
    "        self.clear()\n",
    "        self.update(pickle.load(fh))\n",
    "        return True\n",
    "    except (EnvironmentError, pickle.UnpicklingError) as err:\n",
    "        print(\"{0}: import error: {1}\".format(os.path.basename(sys.argv[0]), err))\n",
    "        return False\n",
    "    finally:\n",
    "        if fh is not None:\n",
    "            fh.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Здесь мы просто открываем файл, проверяем, есть ли в начале него магическое число, отвечающее формату gzip. Если есть, то закрываем дескриптор файла и открываем снова при помощи вызова open модуля gzip. В противном случае возвращаемся к началу файла при помощи метода seek файлового дескриптора. В обоих случаях открытие происходит с двоичным доступом для чтения (rb). После чего очищаем объект self при помощи метода clear и заполняем его при помощи метода update результатом работы вызова load модуля pickle, которому передаем файловый дескриптор.\n",
    "\n",
    "Если в результате было получено исключение, выведем его и вернем False. В противном случае возвращаемое значение равно True. В блоке finally закрываем дескриптор файла, если он существует."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Раздел 3. Взаимодействие с тексстовыми файлами\n",
    "\n",
    "Запись текстовых файлов — очень простой процесс, но вот парсинг данных из текстового файла — занятие трудозатратное.\n",
    "\n",
    "#### Запись в текстовые файлы\n",
    "\n",
    "Мы можем записать текст в виде пар key=value, обозначив данные narrative (описание произошедшего) при помощи маркеров .NARRATIVE_START и .NARRATIVE_END\n",
    "\n",
    "Например:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[20070927022009C]\n",
    "\n",
    "date=2007-09-27\n",
    "\n",
    "aircraft_id=1675B\n",
    "\n",
    "aircraft_type=DHC-2-MK1\n",
    "\n",
    "airport=MERLE K (MUDHOLE) SMITH\n",
    "\n",
    "pilot_percent_hours_on_type=46.1538461538\n",
    "\n",
    "pilot_total_hours=13000\n",
    "\n",
    "midair=0\n",
    "\n",
    ".NARRATIVE_START.\n",
    "\n",
    "    ACCORDING TO THE PILOT, THE DRAG LINK FAILED DUE TO AN OVERSIZED\n",
    "    TAIL WHEEL TIRE LANDING ON HARD SURFACE.\n",
    "    \n",
    ".NARRATIVE_END."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Запись текста в файл будет производиться следующим образом (код из Саммерфилда):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def export_text(self, filename):\n",
    "    wrapper = textwrap.TextWrapper(initial_indent=\"    \", subsequent_indent=\"    \")\n",
    "    fh = None\n",
    "    try:\n",
    "        fh = open(filename, \"w\", encoding=\"utf8\")\n",
    "        for incident in self.values():\n",
    "            narrative = \"\\n\".join(wrapper.wrap(incident.narrative.strip()))\n",
    "            fh.write(\"[{0.report_id}]\\n\"\n",
    "                \"date={0.date!s}\\n\"\n",
    "                \"aircraft_id={0.aircraft_id}\\n\"\n",
    "                \"aircraft_type={0.aircraft_type}\\n\"\n",
    "                \"airport={airport}\\n\"\n",
    "                \"pilot_percent_hours_on_type=\"\n",
    "                \"{0.pilot_percent_hours_on_type}\\n\"\n",
    "                \"pilot_total_hours={0.pilot_total_hours}\\n\"\n",
    "                \"midair={0.midair:d}\\n\"\n",
    "                \".NARRATIVE_START.\\n{narrative}\\n\"\n",
    "                \".NARRATIVE_END.\\n\\n\".format(incident, airport=incident.airport.strip(), narrative=narrative))\n",
    "        if fh is not None:\n",
    "            fh.close()\n",
    "        return True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Здесь мы просто открываем файл для записи в текстовом режиме (w) в кодировке utf-8 и делаем форматный вывод нашего объекта."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Чтение текстового файла\n",
    "\n",
    "Чтение текстового файла может производиться при помощи \"ручной\" обработки текста:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def import_text_manual(self, filename):\n",
    "    fh = None\n",
    "    try:\n",
    "        fh = open(filename, encoding=\"utf8\")\n",
    "        self.clear()\n",
    "        data = {}\n",
    "        narrative = None\n",
    "        for lino, line in enumerate(fh, start=1):\n",
    "            line = line.rstrip()\n",
    "            if not line and narrative is None:\n",
    "                continue\n",
    "            if narrative is not None:\n",
    "                if line == \".NARRATIVE_END.\":\n",
    "                    data[\"narrative\"] = textwrap.dedent(\n",
    "                    narrative).strip()\n",
    "                if len(data) != 9:\n",
    "                    raise IncidentError(\"missing data on \"\n",
    "                \"line {0}\".format(lino))\n",
    "                incident = Incident(**data)\n",
    "                self[incident.report_id] = incident\n",
    "                data = {}\n",
    "                narrative = None\n",
    "                else:\n",
    "                    narrative += line + \"\\n\"\n",
    "            elif (not data and line[0] == \"[\" and line[-1] == \"]\"):\n",
    "                data[\"report_id\"] = line[1:-1]\n",
    "            elif \"=\" in line:\n",
    "                key, value = line.split(\"=\", 1)\n",
    "                if key == \"date\":\n",
    "                    data[key] = datetime.datetime.strptime(value, \"%Y-%m-%d\").date()\n",
    "                elif key == \"pilot_percent_hours_on_type\":\n",
    "                    data[key] = float(value)\n",
    "                elif key == \"pilot_total_hours\":\n",
    "                    data[key] = int(value)\n",
    "                elif key == \"midair\":\n",
    "                    data[key] = bool(int(value))\n",
    "                else:\n",
    "                    data[key] = value\n",
    "            elif line == \".NARRATIVE_START.\":\n",
    "                narrative = \"\"\n",
    "            else:\n",
    "                raise KeyError(\"parsing error on line {0}\".format(\n",
    "                lino))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как видно, парсинг файла \"вручную\" сопряжено с огромной головной болью, необходимо вручную отлавливать ключи и т.д.\n",
    "\n",
    "С другой стороны, можно подключить инструментарий регулярных выражений для парсинга текста:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def import_text_regex(self, filename):\n",
    "    incident_re = re.compile(\n",
    "    r\"\\[(?P<id>[^]]+)\\](?P<keyvalues>.+?)\"\n",
    "    r\"^\\.NARRATIVE_START\\.$(?P<narrative>.*?)\"\n",
    "    r\"^\\.NARRATIVE_END\\.$\",\n",
    "    re.DOTALL|re.MULTILINE)\n",
    "    key_value_re = re.compile(r\"^\\s*(?P<key>[^=]+?)\\s*=\\s*\"\n",
    "    r\"(?P<value>.+?)\\s*$\", re.MULTILINE)\n",
    "    fh = None\n",
    "    try:\n",
    "        fh = open(filename, encoding=\"utf8\")\n",
    "        self.clear()\n",
    "        for incident_match in incident_re.finditer(fh.read()):\n",
    "            data = {}\n",
    "            data[\"report_id\"] = incident_match.group(\"id\")\n",
    "            data[\"narrative\"] = textwrap.dedent(\n",
    "            incident_match.group(\"narrative\")).strip()\n",
    "            keyvalues = incident_match.group(\"keyvalues\")\n",
    "            for match in key_value_re.finditer(keyvalues):\n",
    "                data[match.group(\"key\")] = match.group(\"value\")\n",
    "                data[\"date\"] = datetime.datetime.strptime(\n",
    "                data[\"date\"], \"%Y-%m-%d\").date()\n",
    "                data[\"pilot_percent_hours_on_type\"] = (\n",
    "                float(data[\"pilot_percent_hours_on_type\"]))\n",
    "                data[\"pilot_total_hours\"] = int(\n",
    "                data[\"pilot_total_hours\"])\n",
    "                data[\"midair\"] = bool(int(data[\"midair\"]))\n",
    "            if len(data) != 9:\n",
    "                raise IncidentError(\"missing data\")\n",
    "        incident = Incident(**data)\n",
    "        self[incident.report_id] = incident\n",
    "        return True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Регулярные выражения в значительной степени облегчают поиск паттернов (они для этого и нужны) в текстовых файлах."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Раздел 4. Работа с XML-файлами\n",
    "\n",
    "XML — специальный язык для разметки данных. Работа с ним может осуществляться при помощи модуля Element Tree, DOM и в ручном режиме, а также при помощи Simple API for XML (SAX).\n",
    "\n",
    "#### Использование Element Trees\n",
    "\n",
    "Запись XML:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def export_xml_etree(self, filename):\n",
    "    root = xml.etree.ElementTree.Element(\"incidents\")\n",
    "    for incident in self.values():\n",
    "        element = xml.etree.ElementTree.Element(\"incident\",\n",
    "        report_id=incident.report_id,\n",
    "        date=incident.date.isoformat(),\n",
    "        aircraft_id=incident.aircraft_id,\n",
    "        aircraft_type=incident.aircraft_type,\n",
    "        pilot_percent_hours_on_type=str(\n",
    "        incident.pilot_percent_hours_on_type),\n",
    "        pilot_total_hours=str(incident.pilot_total_hours),\n",
    "        midair=str(int(incident.midair)))\n",
    "        airport = xml.etree.ElementTree.SubElement(element,\n",
    "        \"airport\")\n",
    "        airport.text = incident.airport.strip()\n",
    "        narrative = xml.etree.ElementTree.SubElement(element,\n",
    "        \"narrative\")\n",
    "        narrative.text = incident.narrative.strip()\n",
    "        root.append(element)\n",
    "        tree = xml.etree.ElementTree.ElementTree(root)\n",
    "    try:\n",
    "        tree.write(filename, \"UTF-8\")\n",
    "    except EnvironmentError as err:\n",
    "        print(\"{0}: import error: {1}\".format(\n",
    "        os.path.basename(sys.argv[0]), err))\n",
    "        return False\n",
    "    return True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Здесь мы просто проходим по вершинам дерева и заполняем соответствующие данные.\n",
    "\n",
    "Чтение XML:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def import_xml_etree(self, filename):\n",
    "    try:\n",
    "        tree = xml.etree.ElementTree.parse(filename)\n",
    "    except (EnvironmentError,\n",
    "        xml.parsers.expat.ExpatError) as err:\n",
    "        print(\"{0}: import error: {1}\".format(\n",
    "        os.path.basename(sys.argv[0]), err))\n",
    "        return False\n",
    "    self.clear()\n",
    "    for element in tree.findall(\"incident\"):\n",
    "        try:\n",
    "            data = {}\n",
    "            for attribute in (\"report_id\", \"date\", \"aircraft_id\",\n",
    "                \"aircraft_type\",\n",
    "                \"pilot_percent_hours_on_type\",\n",
    "                \"pilot_total_hours\", \"midair\"):\n",
    "                data[attribute] = element.get(attribute)\n",
    "                data[\"date\"] = datetime.datetime.strptime(\n",
    "                data[\"date\"], \"%Y-%m-%d\").date()\n",
    "                data[\"pilot_percent_hours_on_type\"] = (\n",
    "                float(data[\"pilot_percent_hours_on_type\"]))\n",
    "                data[\"pilot_total_hours\"] = int(\n",
    "                data[\"pilot_total_hours\"])\n",
    "                data[\"midair\"] = bool(int(data[\"midair\"]))\n",
    "                data[\"airport\"] = element.find(\"airport\").text.strip()\n",
    "                narrative = element.find(\"narrative\").text\n",
    "                data[\"narrative\"] = (narrative.strip() if narrative is not None else \"\")\n",
    "                incident = Incident(**data)\n",
    "                self[incident.report_id] = incident\n",
    "        except (ValueError, LookupError, IncidentError) as err:\n",
    "            print(\"{0}: import error: {1}\".format(\n",
    "            os.path.basename(sys.argv[0]), err))\n",
    "            return False\n",
    "    return True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В данном случае логика обратная, загружаем дерево, обходим дерево и заполняем объект self данными.\n",
    "\n",
    "#### Чтение и запись XML при помощи DOM\n",
    "\n",
    "Запись:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def export_xml_dom(self, filename):\n",
    "    dom = xml.dom.minidom.getDOMImplementation()\n",
    "    tree = dom.createDocument(None, \"incidents\", None)\n",
    "    root = tree.documentElement\n",
    "    for incident in self.values():\n",
    "        element = tree.createElement(\"incident\")\n",
    "        for attribute, value in (\n",
    "            (\"report_id\", incident.report_id),\n",
    "            (\"date\", incident.date.isoformat()),\n",
    "            (\"aircraft_id\", incident.aircraft_id),\n",
    "            (\"aircraft_type\", incident.aircraft_type),\n",
    "            (\"pilot_percent_hours_on_type\",\n",
    "            str(incident.pilot_percent_hours_on_type)),\n",
    "            (\"pilot_total_hours\",\n",
    "            str(incident.pilot_total_hours)),\n",
    "            (\"midair\", str(int(incident.midair)))):\n",
    "                element.setAttribute(attribute, value)\n",
    "                for name, text in ((\"airport\", incident.airport), (\"narrative\", incident.narrative)):\n",
    "                    text_element = tree.createTextNode(text)\n",
    "                    name_element = tree.createElement(name)\n",
    "                    name_element.appendChild(text_element)\n",
    "                    element.appendChild(name_element)\n",
    "                    root.appendChild(element)\n",
    "    fh = None\n",
    "    try:\n",
    "        fh = open(filename, \"w\", encoding=\"utf8\")\n",
    "        tree.writexml(fh, encoding=\"UTF-8\")\n",
    "        return True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "Чтение:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def import_xml_dom(self, filename):\n",
    "    def get_text(node_list):\n",
    "        text = []\n",
    "        for node in node_list:\n",
    "            if node.nodeType == node.TEXT_NODE:\n",
    "                text.append(node.data)\n",
    "        return \"\".join(text).strip()\n",
    "    \n",
    "    try:\n",
    "        dom = xml.dom.minidom.parse(filename)\n",
    "    except (EnvironmentError,\n",
    "        xml.parsers.expat.ExpatError) as err:\n",
    "        print(\"{0}: import error: {1}\".format(\n",
    "        os.path.basename(sys.argv[0]), err))\n",
    "        return False\n",
    "    self.clear()\n",
    "    for element in dom.getElementsByTagName(\"incident\"):\n",
    "        try:\n",
    "            data = {}\n",
    "            for attribute in (\"report_id\", \"date\", \"aircraft_id\",\n",
    "            \"aircraft_type\",\n",
    "            \"pilot_percent_hours_on_type\",\n",
    "            \"pilot_total_hours\", \"midair\"):\n",
    "                data[attribute] = element.getAttribute(attribute)\n",
    "                data[\"date\"] = datetime.datetime.strptime(\n",
    "                data[\"date\"], \"%Y-%m-%d\").date()\n",
    "                data[\"pilot_percent_hours_on_type\"] = (\n",
    "                float(data[\"pilot_percent_hours_on_type\"]))\n",
    "                data[\"pilot_total_hours\"] = int(\n",
    "                data[\"pilot_total_hours\"])\n",
    "                data[\"midair\"] = bool(int(data[\"midair\"]))\n",
    "                airport = element.getElementsByTagName(\"airport\")[0]\n",
    "                data[\"airport\"] = get_text(airport.childNodes)\n",
    "                narrative = element.getElementsByTagName(\n",
    "                \"narrative\")[0]\n",
    "                data[\"narrative\"] = get_text(narrative.childNodes)\n",
    "                incident = Incident(**data)\n",
    "                self[incident.report_id] = incident\n",
    "        except (ValueError, LookupError, IncidentError) as err:\n",
    "            print(\"{0}: import error: {1}\".format(\n",
    "            os.path.basename(sys.argv[0]), err))\n",
    "            return False\n",
    "    return True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Запись XML-файлов \"вручную\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def export_xml_manual(self, filename):\n",
    "    fh = None\n",
    "    try:\n",
    "        fh = open(filename, \"w\", encoding=\"utf8\")\n",
    "        fh.write('<?xml version=\"1.0\" encoding=\"UTF-8\"?>\\n')\n",
    "        fh.write(\"<incidents>\\n\")\n",
    "        for incident in self.values():\n",
    "            fh.write('<incident report_id={report_id} '\n",
    "            'date=\"{0.date!s}\" '\n",
    "            'aircraft_id={aircraft_id} '\n",
    "            'aircraft_type={aircraft_type} '\n",
    "            'pilot_percent_hours_on_type='\n",
    "            '\"{0.pilot_percent_hours_on_type}\" '\n",
    "            'pilot_total_hours=\"{0.pilot_total_hours}\" '\n",
    "            'midair=\"{0.midair:d}\">\\n'\n",
    "            '<airport>{airport}</airport>\\n'\n",
    "            '<narrative>\\n{narrative}\\n</narrative>\\n'\n",
    "            '</incident>\\n'.format(incident,\n",
    "            report_id=xml.sax.saxutils.quoteattr(\n",
    "            incident.report_id),\n",
    "            aircraft_id=xml.sax.saxutils.quoteattr(\n",
    "            incident.aircraft_id),\n",
    "            aircraft_type=xml.sax.saxutils.quoteattr(\n",
    "            incident.aircraft_type),\n",
    "            airport=xml.sax.saxutils.escape(incident.airport),\n",
    "            narrative=\"\\n\".join(textwrap.wrap(\n",
    "            xml.sax.saxutils.escape(\n",
    "            incident.narrative.strip()), 70))))\n",
    "            fh.write(\"</incidents>\\n\")\n",
    "        return True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Чтение XML при помощи SAX"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def import_xml_sax(self, filename):\n",
    "    fh = None\n",
    "    try:\n",
    "        handler = IncidentSaxHandler(self)\n",
    "        parser = xml.sax.make_parser()\n",
    "        parser.setContentHandler(handler)\n",
    "        parser.parse(filename)\n",
    "        return True\n",
    "    except (EnvironmentError, ValueError, IncidentError,\n",
    "        xml.sax.SAXParseException) as err:\n",
    "        print(\"{0}: import error: {1}\".format(\n",
    "        os.path.basename(sys.argv[0]), err))\n",
    "        return False\n",
    "\n",
    "class IncidentSaxHandler(xml.sax.handler.ContentHandler):\n",
    "    def __init__(self, incidents):\n",
    "        super().__init__()\n",
    "        self.__data = {}\n",
    "        self.__text = \"\"\n",
    "        self.__incidents = incidents\n",
    "        self.__incidents.clear()\n",
    "\n",
    "    def startElement(self, name, attributes):\n",
    "        if name == \"incident\":\n",
    "            self.__data = {}\n",
    "        for key, value in attributes.items():\n",
    "            if key == \"date\":\n",
    "                self.__data[key] = datetime.datetime.strptime(\n",
    "                value, \"%Y-%m-%d\").date()\n",
    "            elif key == \"pilot_percent_hours_on_type\":\n",
    "                self.__data[key] = float(value)\n",
    "            elif key == \"pilot_total_hours\":\n",
    "                self.__data[key] = int(value)\n",
    "            elif key == \"midair\":\n",
    "                self.__data[key] = bool(int(value))\n",
    "            else:\n",
    "                self.__data[key] = value\n",
    "                self.__text = \"\"\n",
    "\n",
    "    def endElement(self, name):\n",
    "        if name == \"incident\":\n",
    "            if len(self.__data) != 9:\n",
    "                raise IncidentError(\"missing data\")\n",
    "            incident = Incident(**self.__data)\n",
    "            self.__incidents[incident.report_id] = incident\n",
    "        elif name in frozenset({\"airport\", \"narrative\"}):\n",
    "            self.__data[name] = self.__text.strip()\n",
    "            self.__text = \"\"\n",
    "\n",
    "        def characters(self, text):\n",
    "            self.__text += text"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Раздел 5. Работа с файлами, формалированными в других стандартах описания данных\n",
    "\n",
    "Зачастую конфигурации удобно хранить в форматах JSON и Yaml. Доступ осуществляется соответственно при помощи модулей JSON и PyYaml.\n",
    "\n",
    "Чтение и запись из производится при помощи методов load и dump из соответствующих классов."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Раздел 6. Домашнее задание\n",
    "\n",
    "- Выполнить все упражнения после 7 главы Саммерфилда\n",
    "- Прочитать в Саммерфилде про ручную работу с binary-файлами и Random Access binary-файлами\n",
    "- Почитать про Big Endian / Little Endian\n",
    "- Почитать про Document Object Model (DOM)\n",
    "- Выполнить субботнюю задачу\n",
    "\n",
    "Для самых настойчивых:\n",
    "\n",
    "- Написать свой reader и writer для файлов JSON и/или Yaml"
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}