{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Inizio radunando tutti gli **IMPORT** necessari per girare il notebook, per chiarezza."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# IMPORT ESSENZIALI\n",
    "\n",
    "# Per il parsing dell'XML -- questo pacchetto è incluso anche nel più generale lxml\n",
    "import xml.etree.ElementTree as ET\n",
    "# Utilities per leggere/scrivere files csv\n",
    "import csv\n",
    "# Utilities per gestire i character encodings\n",
    "import unicodedata\n",
    "# Dizionari ordinati\n",
    "from collections import OrderedDict\n",
    "\n",
    "# IMPORT OPZIONALI\n",
    "\n",
    "# Per fare un stima della velocità delle varie istruzioni\n",
    "from datetime import datetime\n",
    "# Generatore di numeri casuali -- può sempre servire in fase di testing\n",
    "from random import *\n",
    "# Può servire per alcuni test\n",
    "import sys"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# FUNZIONI\n",
    "\n",
    "**ElementTree** ha una funzione built-in, **iter**, che scorre (molto velocemente) su tutti i 'nodi' dell'albero di dati che rappresenta l'XML. La funzione *iter* purtroppo però non traccia i nodi 'parents'.\n",
    "\n",
    "Ho esteso quindi la libreria scrivendo una mia versione di *iter*, **'traceElems'**, che dovrebbe riuscire a fornirci tutto quello di cui abbiamo bisogno.\n",
    "\n",
    "*traceElems* traccia tutti i nodi nell'albero tenendo conto dei 'parents', e restituisce tutti quelli per cui la funzione-argomento 'condition' ritorna True. **NON** indaga i nodi **figli** di quelli che sono restituiti."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# La funzione BASE: traceElems\n",
    "def traceElems(node: ET.Element, condition, parents: list = [], coords: list = []):\n",
    "    res = []\n",
    "    jj = 0\n",
    "    for child in node:\n",
    "        if condition(child):\n",
    "            res.append({'a_par': parents+[node],\n",
    "                        'coords': coords+[jj], 'child': child})\n",
    "        else:\n",
    "            res = res + traceElems(child, condition, parents+[node], coords+[jj])\n",
    "        jj = jj+1   \n",
    "    return res\n",
    "\n",
    "# Funzione-base per stoppare traceElems\n",
    "def isLeafOrC(aa: ET.Element):\n",
    "    if(aa.tag=='c' or len(aa)==0):\n",
    "        return True\n",
    "    else:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Funzioni-utilità che servono solo a visualizzare meglio i dati sul notebook.\n",
    "def shownode(node: ET.Element):\n",
    "    return (node.tag, node.attrib, node.text.replace('\\t','').replace('n','').strip() \\\n",
    "                               if type(node.text) is str else '')\n",
    "\n",
    "def shownodelist(el: ET.Element):\n",
    "    return list(map(shownode, el))\n",
    "\n",
    "\n",
    "# Utility copiata da INTERNEZZ -- versione 'multipla' del metodo str.index:\n",
    "def indices(lst, element):\n",
    "    result = []\n",
    "    offset = -1\n",
    "    while True:\n",
    "        try:\n",
    "            offset = lst.index(element, offset+1)\n",
    "        except ValueError:\n",
    "            return result\n",
    "        result.append(offset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# AL LAVORO"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**DA CAMBIARE A SECONDA DEL COMPUTER**: directory di input e output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import_dir = '/Users/federicaspinelli/TEAMOVI/Parser/DATA/ASPO/XML/'\n",
    "export_dir = '/Users/federicaspinelli/TEAMOVI/Parser/DATA/ASPO/DATE/MARCOVALDI/'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Importo il file XML del Datini, tracciando il tempo necessario"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.06925296783447266\n"
     ]
    }
   ],
   "source": [
    "ts1 = datetime.timestamp(datetime.now())\n",
    "\n",
    "treeDatini = ET.parse(import_dir + 'export_aspoMV001--marcovaldi.xml')\n",
    "rootDatini = treeDatini.getroot()\n",
    "\n",
    "ts2 = datetime.timestamp(datetime.now())\n",
    "print(ts2 - ts1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uso *iter* per trovare tutti i nodi con label **'c'** nel file Datini, e mi faccio restituire il\n",
    "valore dell'attributo **'level'**; salvo tutti i *levels* nella variabile **cLevs**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'fonds', 'item'}\n"
     ]
    }
   ],
   "source": [
    "cLevs = set(map(lambda a : a.attrib['level'], rootDatini.iter('c')))\n",
    "print(cLevs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A questo punto metto al lavoro la funzione **traceElems**: registro TUTTI i nodi **'c'** dividendoli in base all'attributo **'level'**; mi faccio stampare il numero di elementi per ogni livello ed il tempo trascorso.\n",
    "\n",
    "**OCCHIO:** per come è costruita, questa routine non va ad investigare dentro i livelli restituiti -- quindi si perde eventuali sotto-livelli con la stessa label di quelli che trova durante il primo scan. La presenza di sotto-livelli di questo tipo va controllata separatamente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# di tag \"c\", livello fonds, primo passaggio: 1\n",
      "# di tag \"c\", livello item, primo passaggio: 827\n",
      "\n",
      "Tempo trascorso: 0.0028460025787353516\n"
     ]
    }
   ],
   "source": [
    "ts1 = datetime.timestamp(datetime.now())\n",
    "\n",
    "allCs = {}\n",
    "\n",
    "for label in cLevs:\n",
    "    def tempFilt(aa: ET.Element):\n",
    "        if(aa.tag=='c' and aa.attrib['level']==label):\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "       \n",
    "    allCs[label] = traceElems(rootDatini, tempFilt);\n",
    "    print('# di tag \"c\", livello ' + label + ', primo passaggio:', len(allCs[label]))\n",
    "print()\n",
    "print('Tempo trascorso:', datetime.timestamp(datetime.now()) - ts1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notare che l'elaborazione è piuttosto veloce (sul mio laptop) malgrado la dimensione del file.\n",
    "\n",
    "Rimane il problema dei livelli dentro a livelli omonimi. Vediamo di affrontarlo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# di tag \"c\", livello fonds, primo passaggio: 1\n",
      "# di tag \"c\", livello fonds, totali: 1\n",
      "# di tag \"c\", livello item, primo passaggio: 827\n",
      "# di tag \"c\", livello item, totali: 827\n",
      "\n",
      "Tempo trascorso: 0.04576706886291504\n"
     ]
    }
   ],
   "source": [
    "ts1 = datetime.timestamp(datetime.now())\n",
    "\n",
    "allCs2 = {}\n",
    "\n",
    "for label in cLevs:\n",
    "    partial = allCs[label]\n",
    "    print('# di tag \"c\", livello ' + label + ', primo passaggio:', len(partial))\n",
    "    allCs2[label] = partial\n",
    "    partialUpdate = []\n",
    "    while True:\n",
    "        def tempFilt(aa: ET.Element):\n",
    "            if(aa.tag=='c' and aa.attrib['level']==label):\n",
    "                 return True\n",
    "            else:\n",
    "                 return False\n",
    "        for node in partial:\n",
    "            partialUpdate = partialUpdate + traceElems(node['child'], tempFilt)\n",
    "        #print(len(partialUpdate))\n",
    "        partial = partialUpdate\n",
    "        if(len(partialUpdate)==0):\n",
    "            break\n",
    "        allCs2[label] = allCs2[label] + partial\n",
    "        partialUpdate = []\n",
    "\n",
    "    print('# di tag \"c\", livello ' + label + ', totali:', len(allCs2[label]))\n",
    "\n",
    "print()\n",
    "print('Tempo trascorso:', datetime.timestamp(datetime.now()) - ts1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A questo punto diventa facile visualizzare tutti i dettagli dei vari elementi **'c'**, di qualunque livello; un esempio è fornito nella prossima cella. Si può cambiare l'elemento da visualizzare cambiando il valore delle variabili *ii* e *level*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def traduttoreItem(elem):\n",
    "    # Variabile che contiene l'output della traduzione:\n",
    "    csvProt = {}\n",
    "\n",
    "    # Processo i nodi-parent di 'elem'\n",
    "    par_tags = list(map(lambda a: a.tag, elem['a_par']))\n",
    "    par_attributes = list(map(lambda a: a.attrib, elem['a_par']))\n",
    "    # e0: Le varie id dei nodi parent\n",
    "    for ii in indices(par_tags, 'c'):\n",
    "        key = 'id_' + par_attributes[ii]['level']\n",
    "        csvProt[key] = par_attributes[ii]['id']\n",
    "    \n",
    "    # Processo i nodi-child di 'elem'\n",
    "    toProc = traceElems(elem['child'], isLeafOrC)\n",
    "    first = True\n",
    "    for node in toProc:\n",
    "        tags = list(map(lambda a: a.tag, node['a_par'])) + [node['child'].tag]\n",
    "        attributes = list(map(lambda a: a.attrib, node['a_par'])) + [node['child'].attrib]\n",
    "        content = node['child'].text\n",
    "\n",
    "        # Da controllare solo per il primo nodo\n",
    "        # (informazioni a livello del nodo, uguali per tutti i figli)\n",
    "        if(first):\n",
    "            # e1 ID della item\n",
    "            csvProt['id'] = attributes[tags.index('c')]['id']\n",
    "            # e2 Audience: external o internal\n",
    "            try:\n",
    "                csvProt['audience'] = attributes[tags.index('c')]['audience']\n",
    "            except:\n",
    "                pass\n",
    "            # e3 Otherlevel\n",
    "            try:\n",
    "                csvProt['altro_livello'] = attributes[tags.index('c')]['otherlevel']\n",
    "            except:\n",
    "                pass\n",
    "            first = False\n",
    "\n",
    "        # La 'ciccia': si processa il contenuto vero e proprio\n",
    "        # e4 Repository (qui dovrebbe essere sempre l'Archivio di Prato)\n",
    "        if('repository' in tags):\n",
    "            csvProt['repository'] = content\n",
    "        \n",
    "        # e8 Tipologia\n",
    "        try:\n",
    "            ii = tags.index('materialspec')\n",
    "            if(attributes[ii]['label']=='tipologia'): \n",
    "                csvProt['tipologia'] = content\n",
    "        except:\n",
    "            pass\n",
    "        \n",
    "        # e9 Segnature buste e registri\n",
    "        try:\n",
    "            ii = tags.index('container')\n",
    "            type1 = attributes[ii]['type']\n",
    "            if(type1=='busta'):\n",
    "                csvProt['segnatura_busta'] = content\n",
    "            elif(type1=='inserto'):\n",
    "                csvProt['segnatura_inserto'] = content\n",
    "        except:\n",
    "            pass\n",
    "\n",
    "        # e9 Segnatura codice (solo Marcovaldi ha segnatura in unitid)\n",
    "        try:\n",
    "            ii = tags.index('unitid')\n",
    "            type1 = attributes[ii]['type']\n",
    "            if(type1.find('chiave')>=0):\n",
    "               csvProt['segnatura_codice'] = content\n",
    "        except:\n",
    "            pass\n",
    "\n",
    "        # e11: Il titolo da unittitle\n",
    "        try:\n",
    "            aa = csvProt['titolo_aspo']\n",
    "        except:\n",
    "            try:\n",
    "                ii = tags.index('unittitle')\n",
    "                try:\n",
    "                    csvProt['titolo_aspo'] = str(node['a_par'][ii].text).replace('\\t','').replace('\\n','').strip()\n",
    "                except:\n",
    "                    csvProt['titolo_aspo'] = str(content).replace('\\t','').replace('\\n','').strip()\n",
    "            except:\n",
    "                pass\n",
    "        \n",
    "        # e12 Scope-content head & body\n",
    "        if('scopecontent' in tags):\n",
    "            if('head' in tags):\n",
    "                csvProt['scope-content_head'] = content\n",
    "            else:\n",
    "                if('p' in tags):\n",
    "                    csvProt['scope-content_body'] = content\n",
    "        \n",
    "        # e14 Nome della compagnia\n",
    "        try:\n",
    "            ii = tags.index('corpname')\n",
    "            if(attributes[ii]['role']=='compagnia'):\n",
    "                try:\n",
    "                    authId = attributes[ii]['authfilenumber']\n",
    "                    csvProt['compagnia'] = '{nome: ' + content + ', authID: ' + authId + '}'\n",
    "                except:\n",
    "                    csvProt['compagnia'] = '{nome: ' + content + '}'\n",
    "        except:\n",
    "            pass\n",
    "       \n",
    "       # e16 Persona + ruolo\n",
    "        try:\n",
    "            ii = tags.index('persname')\n",
    "            key = 'persona_' + attributes[ii]['role']\n",
    "            try:\n",
    "                authId = attributes[ii]['authfilenumber']\n",
    "                csvProt[key] = '{\"nome\": ' + \"\\\"\" + content + \"\\\"\" + ', \"authID\": ' + \"\\\"\" + authId + \"\\\"\" + '}'\n",
    "            except:\n",
    "                csvProt[key] = '{\"nome\": ' + \"\\\"\" + content + \"\\\"\" + '}'\n",
    "        except:\n",
    "            pass\n",
    "        \n",
    "        # e17 Date varie: tutte quelle con 'type' definito\n",
    "        try:\n",
    "            ii = tags.index('date')\n",
    "            key = 'data_' + attributes[ii]['type']\n",
    "            aa = csvProt[key]\n",
    "        except:\n",
    "                try:\n",
    "                    ii = tags.index('date')\n",
    "                    try:\n",
    "                        csvProt[key] = str(node['a_par'][ii].text).replace('\\t','').replace('\\n','').strip()\n",
    "                        try:\n",
    "                            ii = tags.index('emph')\n",
    "                            csvProt[key+'_note'] = content\n",
    "                        except:\n",
    "                            pass\n",
    "                        try:\n",
    "                            ii = tags.index('date')\n",
    "                            key = 'data_' + attributes[ii]['type'] + '_normalizzata'\n",
    "                            try:\n",
    "                                norm = attributes[ii]['normal']\n",
    "                                csvProt[key] = norm\n",
    "                            except:\n",
    "                                csvProt[key] = 'NOTNORMAL'\n",
    "                        except:\n",
    "                            pass\n",
    "                    except:\n",
    "                        csvProt[key] = str(content).replace('\\t','').replace('\\n','').strip()\n",
    "                        try:\n",
    "                            ii = tags.index('date')\n",
    "                            key = 'data_' + attributes[ii]['type'] + '_normalizzata'\n",
    "                            try:\n",
    "                                norm = attributes[ii]['normal']\n",
    "                                csvProt[key] = norm\n",
    "                            except:\n",
    "                                csvProt[key] = 'NOTNORMAL'\n",
    "                        except:\n",
    "                            pass\n",
    "                except:\n",
    "                    pass\n",
    "\n",
    "        # e18 Data 1: periodo\n",
    "        if('unitdate' in tags):\n",
    "            csvProt['data_periodo'] = content    \n",
    "\n",
    "        if('unitdate' in tags):\n",
    "            try:\n",
    "                ii = tags.index('unitdate')\n",
    "                key = 'data_periodo_normalizzata'\n",
    "                try:\n",
    "                    norm = attributes[ii]['normal']\n",
    "                    csvProt[key] = norm\n",
    "                except:\n",
    "                    csvProt[key] = 'NOTNORMAL'\n",
    "            except:\n",
    "                pass\n",
    "\n",
    "        # e19 Luogo + 'ruolo'\n",
    "        try:\n",
    "            ii = tags.index('geogname')\n",
    "            key = 'luogo_' + attributes[ii]['role']\n",
    "            try:\n",
    "                authId = attributes[ii]['authfilenumber']\n",
    "                csvProt[key] = '{luogo: ' + content + ', authID: ' + authId + '}'\n",
    "            except:\n",
    "                csvProt[key] = '{luogo: ' + content + '}'\n",
    "        except:\n",
    "            pass\n",
    "        \n",
    "        # e20 Supporto fisico\n",
    "        try:\n",
    "            ii = tags.index('physfacet')\n",
    "            if(attributes[ii]['type']=='supporto'):\n",
    "                csvProt['supporto'] = content\n",
    "        except:\n",
    "            pass\n",
    "\n",
    "        # e21 Physdesc \n",
    "        if('extent' in tags):\n",
    "            csvProt['numero'] = content\n",
    "        if('genreform' in tags):\n",
    "            csvProt['genere'] = content  \n",
    "\n",
    "        # e23 Consistenza\n",
    "        try:\n",
    "            ii = tags.index('extent')\n",
    "            type1 = attributes[ii]['unit']\n",
    "            cvsProt['consistenza'] = type1 + ': ' + content\n",
    "        except:\n",
    "            pass\n",
    "        \n",
    "        # e24 Note\n",
    "        if('note' in tags):\n",
    "            csvProt['nota'] = content\n",
    "   \n",
    "        # e26 Oggetto digitale allegato (nome)\n",
    "        # Questo è un campo multiplo; per il momento, salviamo tutto\n",
    "        # su una cella concatenando e separando i campi con una pipe\n",
    "        # '| '\n",
    "        try:\n",
    "            ii = tags.index('daoloc')\n",
    "            out = attributes[ii]['title']\n",
    "            try:\n",
    "                csvProt['oggetto_digitale'] = csvProt['oggetto_digitale'] + ' | ' + out\n",
    "            except:\n",
    "                csvProt['oggetto_digitale'] = out\n",
    "        except:\n",
    "            pass  \n",
    "    \n",
    "    return csvProt\n",
    "\n",
    "\n",
    "# Di pari passo alla funzione, definisco un dict contenente tutti gli header;\n",
    "# servirà per il CSV.\n",
    "itemHeader = OrderedDict()\n",
    "\n",
    "# e1 ID dell'entità\n",
    "itemHeader.update({'id': '<c level=\"X\" id=#>'})\n",
    "\n",
    "# e2 Audience: external o internal\n",
    "itemHeader.update({'audience': '<c level=\"item\" audience=#>'})\n",
    "\n",
    "# bioghist\n",
    "itemHeader.update({'bioghist': '<bioghist=#>'})\n",
    "\n",
    "# arrangement\n",
    "itemHeader.update({'arrangement': '<arrangement=#>'})\n",
    "\n",
    "# relatedmaterial\n",
    "itemHeader.update({'relatedmaterial': '<relatedmaterial=#>'})\n",
    "\n",
    "# e3 Scope content, head & body\n",
    "itemHeader.update(\n",
    "{'scope-content_head': '<scopecontent><head>#',\n",
    " 'scope-content_body': '<scopecontent><p>#'})\n",
    "\n",
    "# e4 Titolo\n",
    "itemHeader.update({'titolo_aspo': '<unittitle>#'})\n",
    "\n",
    "# e5 Nome della compagnia\n",
    "itemHeader.update({'compagnia': '<corpname>#'})\n",
    "\n",
    "# e6 Soggetto\n",
    "itemHeader.update({'soggetto': '<subject>#'})\n",
    "\n",
    "# e8 Date varie: tutte quelle con 'type' definito\n",
    "itemHeader.update(\n",
    "{'data_inizio': '<date type=\"inizio\">#', 'data_inizio_normalizzata': '<date>#',\n",
    " 'data_fine': '<date type=\"fine\">#', 'data_fine_normalizzata': '<date>#',\n",
    " 'data_chiusura': '<date type=\"chiusura\">#', 'data_chiusura_normalizzata': '<date>#',})\n",
    "\n",
    "# e18 Data 1: periodo\n",
    "itemHeader.update({'data_periodo': '<unitdate>#' , 'data_periodo_normalizzata': '<unitdate>#' })\n",
    "\n",
    "# e9 Origine\n",
    "itemHeader.update({'origine': '<origination label=#1>#2, #1 - #2'})\n",
    "\n",
    "# e10 Tipologia\n",
    "itemHeader.update({'tipologia': '<materialspec label=\"tipologia\">#'})\n",
    "\n",
    "# e11 Persona + ruolo\n",
    "itemHeader.update(\n",
    "{'persona_tenutario': '<persname role=\"tenutario\">#', \n",
    " 'persona_destinatario': '<persname role=\"destinatario\">#',\n",
    " 'persona_mittente': '<persname role=\"mittente\">#',\n",
    " 'persona_indirizzata': '<persname role=\"indirizzata\">#',\n",
    " 'persona_mano': '<persname role=\"mano\">#',})\n",
    "\n",
    "# e12 Segnature buste e registri Datini\n",
    "itemHeader.update(\n",
    "{'segnatura_registri_1': '<container type=\"%numero un%\">#',\n",
    " 'segnatura_registri_2': '<container type=\"%numero sott%\">#',\n",
    " 'segnatura_inserto': '<container type=\"inserto\">#',\n",
    " 'segnatura_busta': '<container type=\"busta\">#'})\n",
    "\n",
    "# e17 Segnatura codice\n",
    "itemHeader.update({'segnatura_codice': '<unitid type=\"chiave\">#'})\n",
    "\n",
    "# e13 Luogo + 'ruolo'\n",
    "itemHeader.update(\n",
    "{\"luogo_partenza\": '<geogname role=\"partenza\">#',\n",
    " \"luogo_arrivo\": '<geogname role=\"arrivo\">#',\n",
    " \"luogo_luogo\": '<geogname role=\"luogo\">#'})\n",
    "\n",
    "# e14 Supporto fisico\n",
    "itemHeader.update({'supporto': '<physfacet type=\"supporto\">#'})\n",
    "\n",
    "itemHeader.update({'numero': '<extent>#'})\n",
    "\n",
    "itemHeader.update({'genere': '<genreform>#'})\n",
    "\n",
    "# e15 Repository (qui dovrebbe essere sempre l'Archivio di Prato)\n",
    "itemHeader.update({'repository': '<repository>#'})\n",
    "\n",
    "# Note\n",
    "itemHeader.update({'nota': '<note>#'})\n",
    "\n",
    "# Odd\n",
    "itemHeader.update({'altre_informazioni': '<odd>#'})\n",
    "\n",
    "# e16 Consistenza\n",
    "itemHeader.update({'consistenza': '<extent unit=#1>#2, #1: #2'})\n",
    "\n",
    "# e18 Oggetto digitale allegato (nome)\n",
    "itemHeader.update({'oggetto_digitale': '<daoloc title=#>'})\n",
    "\n",
    "# e19 Otherlevel\n",
    "itemHeader.update({'altro_livello': '<c otherlevel=#>'})\n",
    "\n",
    "#0: Le varie id dei nodi parent\n",
    "itemHeader.update(\n",
    "{'id_subfonds': '<c level=\"subfonds\" id=#>',\n",
    " 'id_fonds': '<c level=\"fonds\" id=#>',\n",
    " 'id_series': '<c level=\"series\" id=#>',\n",
    " 'id_subseries': '<c level=\"subseries\" id=#>',\n",
    " 'id_file': '<c level=\"file\" id=#>',\n",
    " 'id_otherlevel': '<c level=\"otherlevel\" id=#>',\n",
    " 'id_collection': '<c level=\"collection\" id=#>'})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test della funzione traduttore\n",
    "\n",
    "**NB:** l'ho definita basandomi sugli item, ma sembra funzionare decentemente anche sugli altri livelli!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "id_fonds: IT-ASPO-MV001-0000827\n",
      "\n",
      "id: IT-ASPO-MV001-0000001\n",
      "\n",
      "audience: external\n",
      "\n",
      "tipologia: carteggio\n",
      "\n",
      "repository: Archivio di Stato di Prato\n",
      "\n",
      "segnatura_codice: 2\n",
      "\n",
      "titolo_aspo: ANGIOLINI GINO DI FALCONIERI a ANGIOLINI LOTTO DI FALCONIERI PRETE DI GALCIANA (SER)\n",
      "\n",
      "persona_mittente: {\"nome\": \"ANGIOLINI GINO DI FALCONIERI\", \"authID\": \"IT-ASPO-AU00003-0005595\"}\n",
      "\n",
      "persona_destinatario: {\"nome\": \"ANGIOLINI LOTTO DI FALCONIERI PRETE DI GALCIANA (SER)\", \"authID\": \"IT-ASPO-AU00003-0005596\"}\n",
      "\n",
      "luogo_partenza: {luogo: AREZZO, authID: IT-ASPO-GEO0001-0000496}\n",
      "\n",
      "luogo_arrivo: {luogo: PRATO, authID: IT-ASPO-GEO0001-0000532}\n",
      "\n",
      "data_inizio: 24/09/****\n",
      "\n",
      "data_inizio_normalizzata: NOTNORMAL\n",
      "\n",
      "data_periodo: 24/09/****\n",
      "\n",
      "data_periodo_normalizzata: 08-2012\n",
      "\n",
      "numero: 1\n",
      "\n",
      "segnatura_busta: 7028\n",
      "\n",
      "nota: data al banco di Leo di ser Iacopo in Prato\n",
      "\n",
      "oggetto_digitale: MV000000201.jpg | MV000000202.jpg\n",
      "\n"
     ]
    }
   ],
   "source": [
    "test = allCs2['item'][1]\n",
    "toShow = traduttoreItem(test)\n",
    "for key in toShow.keys():\n",
    "    print(key + ': ' + str(toShow[key]))\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Export\n",
    "\n",
    "Produciamo il CSV per gli item tracciando, al solito, il tempo impiegato."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tempo trascorso: 0.28243494033813477\n"
     ]
    }
   ],
   "source": [
    "# Do it! Export del CSV - items.\n",
    "\n",
    "ts1 = datetime.timestamp(datetime.now())\n",
    "\n",
    "# Apro il file per l'export\n",
    "with open(export_dir + \"data_item.csv\", \"w\", newline=\"\") as csv_file:\n",
    "    # Definisco la classe-motore per l'export\n",
    "    writer = csv.DictWriter(csv_file, fieldnames=list(itemHeader.keys()))\n",
    "    # Scrivo l'intestazione\n",
    "    writer.writeheader()\n",
    "    # Scrivo la seconda riga, esplicativa\n",
    "    writer.writerow(itemHeader)\n",
    "    # Scrivo gli item tradotti, uno a uno\n",
    "    for ii in range(len(allCs2['item'])):\n",
    "        test = allCs2['item'][ii]\n",
    "        writer.writerow(traduttoreItem(test))\n",
    "\n",
    "print('Tempo trascorso:', datetime.timestamp(datetime.now()) - ts1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Altri livelli"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Definisco un dizionario ridotto per l'header delle *subseries*, poi esporto -- per il momento con lo stesso traduttore usato per gli *item*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Rinse & Repeat* con i livelli *series*, *subfonds* e *fonds*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tempo trascorso: 0.025516986846923828\n"
     ]
    }
   ],
   "source": [
    "ts1 = datetime.timestamp(datetime.now())\n",
    "\n",
    "fondsKeys = set()\n",
    "for ii in range(len(allCs2['fonds'])):\n",
    "    test = allCs2['fonds'][ii]\n",
    "    fondsKeys = fondsKeys.union( traduttoreItem(test).keys() )\n",
    "\n",
    "fondsHeader = OrderedDict()\n",
    "for key in itemHeader:\n",
    "    if(key in fondsKeys):\n",
    "        fondsHeader[key] = itemHeader[key]\n",
    "\n",
    "\n",
    "with open(export_dir + \"data_fonds.csv\", \"w\", newline=\"\") as csv_file:\n",
    "    writer = csv.DictWriter(csv_file, fieldnames=list(fondsHeader.keys()))\n",
    "    writer.writeheader()\n",
    "    writer.writerow(fondsHeader)\n",
    "    for ii in range(len(allCs2['fonds'])):\n",
    "        test = allCs2['fonds'][ii]\n",
    "        writer.writerow(traduttoreItem(test))\n",
    "\n",
    "print('Tempo trascorso:', datetime.timestamp(datetime.now()) - ts1)"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "397704579725e15f5c7cb49fe5f0341eb7531c82d19f2c29d197e8b64ab5776b"
  },
  "kernelspec": {
   "display_name": "Python 3.9.0 64-bit",
   "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.9.0"
  },
  "metadata": {
   "interpreter": {
    "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}