def ranger_articles_xml(chemin_base, coll_articles, entree_version_section, entree_texte, entree_version_texte, dates_changement, ensemble_articles, cidTexte): if coll_articles == None: return dates_changement, ensemble_articles for i in range(len(coll_articles)): print('({}/{})'.format(i + 1, len(coll_articles)), end='') sys.stdout.flush() # Lecture brute des attributs XML id = coll_articles[i]['id'] nom = coll_articles[i].text etat_juridique = coll_articles[i]['etat'] num = coll_articles[i]['num'] debut = normalise_date(coll_articles[i]['debut']) fin = normalise_date(coll_articles[i]['fin']) # Enregistrement de l’article # TODO gérer les mises à jour try: entree_article = Article.get(Article.id == id) except: entree_article = Article.create( id=id, nom=nom, etat_juridique=etat_juridique, num=num, debut=debut, fin=fin, texte=entree_texte, version_section=entree_version_section, version_texte=entree_version_texte) # Inscription des dates et articles dates_changement |= {debut, fin} ensemble_articles |= {entree_article} nb_chiffres = len('({}/{})'.format(i + 1, len(coll_articles))) print('\033[' + str(nb_chiffres) + 'D' + (''.join([' ' * nb_chiffres])) + '\033[' + str(nb_chiffres) + 'D', end='') sys.stdout.flush() return dates_changement, ensemble_articles
def ranger_articles_xml(chemin_base, coll_articles, entree_version_section, entree_texte, entree_version_texte, dates_changement, ensemble_articles, cidTexte): if coll_articles == None: return dates_changement, ensemble_articles for i in range(len(coll_articles)): print('({}/{})'.format(i+1, len(coll_articles)), end='') sys.stdout.flush() # Lecture brute des attributs XML id = coll_articles[i]['id'] nom = coll_articles[i].text etat_juridique = coll_articles[i]['etat'] num = coll_articles[i]['num'] debut = normalise_date(coll_articles[i]['debut']) fin = normalise_date(coll_articles[i]['fin']) # Enregistrement de l’article # TODO gérer les mises à jour try: entree_article = Article.get(Article.id == id) except: entree_article = Article.create( id=id, nom=nom, etat_juridique=etat_juridique, num=num, debut=debut, fin=fin, texte=entree_texte, version_section=entree_version_section, version_texte=entree_version_texte ) # Inscription des dates et articles dates_changement |= {debut, fin} ensemble_articles |= {entree_article} nb_chiffres=len('({}/{})'.format(i+1, len(coll_articles))) print('\033[' + str(nb_chiffres) + 'D' + (''.join([' ' * nb_chiffres])) + '\033[' + str(nb_chiffres) + 'D', end='') sys.stdout.flush() return dates_changement, ensemble_articles
def lire_base_struct(chemin_base, cid): # Initialiser le dictionnaire résultat struct = dict() # Ouvrir le fichier XML chemin_xml = os.path.join(chemin_base, 'texte', 'struct', cid + '.xml') if not os.path.exists(chemin_xml): raise Exception() f_struct = open(chemin_xml, 'r') soup = BeautifulSoup(f_struct.read(), 'xml') f_struct.close() # Lecture des éléments englobants META = soup.find('META') META_COMMUN = META.find('META_COMMUN') META_SPEC = META.find('META_SPEC') META_TEXTE_CHRONICLE = META_SPEC.find('META_TEXTE_CHRONICLE') META_TEXTE_VERSION = META_SPEC.find('META_TEXTE_VERSION') VERSIONS = soup.find('VERSIONS') STRUCT = soup.find('STRUCT') # Lecture des éléments feuille struct['NATURE'] = META_COMMUN.find('NATURE').text struct['CID'] = META_TEXTE_CHRONICLE.find('CID').text struct['NOR'] = META_TEXTE_CHRONICLE.find('NOR').text struct['DATE_TEXTE'] = META_TEXTE_CHRONICLE.find('DATE_TEXTE').text struct['DATE_PUBLI'] = META_TEXTE_CHRONICLE.find('DATE_PUBLI').text struct['VERSION'] = VERSIONS.find_all('VERSION') struct['VERSION_etat'] = struct['VERSION'][0]['etat'] struct['LIEN_TXT'] = struct['VERSION'][0].find('LIEN_TXT') struct['LIEN_TXT_id'] = struct['LIEN_TXT']['id'] struct['LIEN_TXT_debut'] = struct['LIEN_TXT']['debut'] struct['LIEN_TXT_fin'] = struct['LIEN_TXT']['fin'] struct['LIEN_ART'] = STRUCT.find_all('LIEN_ART') struct['LIEN_SECTION_TA'] = STRUCT.find_all('LIEN_SECTION_TA') # Normalisations struct['DATE_TEXTE'] = normalise_date(struct['DATE_TEXTE']) struct['DATE_PUBLI'] = normalise_date(struct['DATE_PUBLI']) return struct
def lire_base_version(chemin_base, cid): # Initialiser le dictionnaire résultat version = dict() # Ouvrir le fichier XML chemin_xml = os.path.join(chemin_base, 'texte', 'version', cid + '.xml') if not os.path.exists(chemin_xml): raise FichierNonExistantException() f_version = open(chemin_xml, 'r') soup = BeautifulSoup(f_version.read(), 'xml') f_version.close() # Lecture des éléments englobants META = soup.find('META') META_COMMUN = META.find('META_COMMUN') META_SPEC = META.find('META_SPEC') META_TEXTE_CHRONICLE = META_SPEC.find('META_TEXTE_CHRONICLE') META_TEXTE_VERSION = META_SPEC.find('META_TEXTE_VERSION') # Lecture des éléments feuille version['NATURE'] = META_COMMUN.find('NATURE').text version['CID'] = META_TEXTE_CHRONICLE.find('CID').text version['NOR'] = META_TEXTE_CHRONICLE.find('NOR').text version['DATE_TEXTE'] = META_TEXTE_CHRONICLE.find('DATE_TEXTE').text version['DATE_PUBLI'] = META_TEXTE_CHRONICLE.find('DATE_PUBLI').text version['DERNIERE_MODIFICATION'] = \ META_TEXTE_CHRONICLE.find('DERNIERE_MODIFICATION').text version['TITRE'] = META_TEXTE_VERSION.find('TITRE').text version['TITREFULL'] = META_TEXTE_VERSION.find('TITREFULL').text version['DATE_DEBUT'] = META_TEXTE_VERSION.find('DATE_DEBUT').text version['DATE_FIN'] = META_TEXTE_VERSION.find('DATE_FIN').text version['ETAT'] = META_TEXTE_VERSION.find('ETAT').text # Normalisations version['DATE_TEXTE'] = normalise_date(version['DATE_TEXTE']) version['DATE_PUBLI'] = normalise_date(version['DATE_PUBLI']) version['DATE_DEBUT'] = normalise_date(version['DATE_DEBUT']) version['DATE_FIN'] = normalise_date(version['DATE_FIN']) return version
def ranger_texte_xml(chemin_base, cidTexte, nature_attendue=None): # Lecture brute du fichier XML texte/version chemin_texte_version = os.path.join(chemin_base, 'texte', 'version', cidTexte + '.xml') if not os.path.exists(chemin_texte_version): raise Exception() f_version = open(chemin_texte_version, 'r') soup_version = BeautifulSoup(f_version.read(), 'xml') version_META = soup_version.find('META') version_META_COMMUN = version_META.find('META_COMMUN') version_META_SPEC = version_META.find('META_SPEC') version_META_TEXTE_CHRONICLE = version_META_SPEC.find( 'META_TEXTE_CHRONICLE') version_META_TEXTE_VERSION = version_META_SPEC.find('META_TEXTE_VERSION') version_NATURE = version_META_COMMUN.find('NATURE').text version_CID = version_META_TEXTE_CHRONICLE.find('CID').text version_NOR = version_META_TEXTE_CHRONICLE.find('NOR').text version_DATE_TEXTE = version_META_TEXTE_CHRONICLE.find('DATE_TEXTE').text version_DATE_PUBLI = version_META_TEXTE_CHRONICLE.find('DATE_PUBLI').text version_TITRE = version_META_TEXTE_VERSION.find('TITRE').text version_TITREFULL = version_META_TEXTE_VERSION.find('TITREFULL').text version_DATE_DEBUT = version_META_TEXTE_VERSION.find('DATE_DEBUT').text version_DATE_FIN = version_META_TEXTE_VERSION.find('DATE_FIN').text version_ETAT = version_META_TEXTE_VERSION.find('ETAT').text # Lecture brute du fichier XML texte/struct chemin_texte_struct = os.path.join(chemin_base, 'texte', 'struct', cidTexte + '.xml') if not os.path.exists(chemin_texte_struct): raise Exception() f_struct = open(chemin_texte_struct, 'r') soup_struct = BeautifulSoup(f_struct.read(), 'xml') struct_META = soup_struct.find('META') struct_META_COMMUN = struct_META.find('META_COMMUN') struct_META_SPEC = struct_META.find('META_SPEC') struct_META_TEXTE_CHRONICLE = struct_META_SPEC.find('META_TEXTE_CHRONICLE') struct_META_TEXTE_VERSION = struct_META_SPEC.find('META_TEXTE_VERSION') struct_VERSIONS = soup_struct.find('VERSIONS') struct_STRUCT = soup_struct.find('STRUCT') struct_NATURE = struct_META_COMMUN.find('NATURE').text struct_CID = struct_META_TEXTE_CHRONICLE.find('CID').text struct_NOR = struct_META_TEXTE_CHRONICLE.find('NOR').text struct_DATE_TEXTE = struct_META_TEXTE_CHRONICLE.find('DATE_TEXTE').text struct_DATE_PUBLI = struct_META_TEXTE_CHRONICLE.find('DATE_PUBLI').text struct_VERSION = struct_VERSIONS.find_all('VERSION') struct_VERSION_etat = struct_VERSION[0]['etat'] struct_LIEN_TXT = struct_VERSION[0].find('LIEN_TXT') struct_LIEN_TXT_id = struct_LIEN_TXT['id'] struct_LIEN_TXT_debut = struct_LIEN_TXT['debut'] struct_LIEN_TXT_fin = struct_LIEN_TXT['fin'] struct_LIEN_ART = struct_STRUCT.find_all('LIEN_ART') struct_LIEN_SECTION_TA = struct_STRUCT.find_all('LIEN_SECTION_TA') # Traitements de base version_DATE_TEXTE = normalise_date(version_DATE_TEXTE) version_DATE_PUBLI = normalise_date(version_DATE_PUBLI) version_DATE_DEBUT = normalise_date(version_DATE_DEBUT) version_DATE_FIN = normalise_date(version_DATE_FIN) struct_DATE_TEXTE = normalise_date(struct_DATE_TEXTE) struct_DATE_PUBLI = normalise_date(struct_DATE_PUBLI) # Vérifications if not cidTexte == version_CID: raise Exception() #if nature_attendue and not version_NATURE == nature_attendue.upper() or not struct_NATURE == nature_attendue.upper(): # raise Exception() if not version_DATE_TEXTE == struct_DATE_TEXTE: raise Exception() if not version_DATE_PUBLI == struct_DATE_PUBLI: raise Exception() #if not len(struct_VERSION) == 1: # texte/version ne peut avoir qu’une seule version, donc texte/struct également et elles doivent correspondre # raise Exception() # Enregistrement du Texte # TODO gérer les mises à jour try: entree_texte = Texte.get(Texte.cid == version_CID) except: entree_texte = Texte.create( cid=version_CID.upper(), nor=version_NOR.upper(), nature=version_NATURE.lower(), date_publi=version_DATE_PUBLI, date_texte=version_DATE_TEXTE, ) # Enregistrement de la Version_texte d’autorité # TODO gérer les mises à jour try: entree_version_texte = Version_texte.get( Version_texte.texte == entree_texte) except: entree_version_texte = Version_texte.create( texte=entree_texte, titre=version_TITRE, titre_long=version_TITREFULL, etat_juridique=version_ETAT.lower(), debut=version_DATE_DEBUT, fin=version_DATE_FIN, base=None) # Recensement des dates de changement dates_changement = set([version_DATE_DEBUT, version_DATE_FIN]) ensemble_versions_sections = set() ensemble_articles = set() # Ajouter récursivement les sections et articles dates_changement, ensemble_versions_section, ensemble_articles = ranger_sections_xml( chemin_base, struct_LIEN_SECTION_TA, struct_LIEN_ART, entree_texte, entree_version_texte, None, None, dates_changement, ensemble_versions_sections, ensemble_articles, cidTexte, 1) print('') # Créer les versions de textes dates_changement = list(dates_changement) dates_changement.sort(cmp=comp_infini) for i in range(len(dates_changement) - 1): # TODO gérer les mises à jour Version_texte.create(texte=entree_texte, titre=version_TITRE, titre_long=version_TITREFULL, etat_juridique=version_ETAT.lower(), debut=dates_changement[i], fin=dates_changement[i + 1], base=entree_version_texte)
def ranger_sections_xml(chemin_base, coll_sections, coll_articles, entree_texte, entree_version_texte, section_parente, version_section_parente, dates_changement, ensemble_versions_sections, ensemble_articles, cidTexte, niv): # Prévenir les récursions infinies - les specs indiquent un max de 10 if niv == 11: raise Exception() # Traiter les articles à ce niveau dates_changement, ensemble_articles = ranger_articles_xml( chemin_base, coll_articles, version_section_parente, entree_texte, entree_version_texte, dates_changement, ensemble_articles, cidTexte) for i in range(len(coll_sections)): print('{}/{}'.format(i + 1, len(coll_sections)), end='') sys.stdout.flush() cid = coll_sections[i]['cid'] id = coll_sections[i]['id'] nom = coll_sections[i].text etat_juridique = coll_sections[i]['etat'] niveau = coll_sections[i]['niv'] debut = normalise_date(coll_sections[i]['debut']) fin = normalise_date(coll_sections[i]['fin']) url = coll_sections[i]['url'][1:] numero = i + 1 # Enregistrement de la section try: entree_section = Section.get(Section.cid == cid) except: entree_section = Section.create(cid=cid, cid_parent=section_parente, niveau=niveau, texte=entree_texte) # Ajout des dates limites pour préparer l’édition de liens dates_changement |= {debut, fin} # Enregistrement de version de section # TODO gérer les mises à jour try: entree_version_section = Version_section.get( Version_section.id == id) except: entree_version_section = Version_section.create( cid=cid, id=id, id_parent=version_section_parente, nom=nom, etat_juridique=etat_juridique, niveau=niveau, numero=numero, debut=debut, fin=fin, texte=entree_texte, version_texte=entree_version_texte) # Ajout de cette version de section ensemble_versions_sections |= {entree_version_section} print(' → ', end='') sys.stdout.flush() # Continuer récursivement chemin_section_ta = os.path.join(chemin_base, 'section_ta', url) f_section_ta = open(chemin_section_ta, 'r') soup = BeautifulSoup(f_section_ta.read(), 'xml') section_ta_STRUCTURE_TA = soup.find('STRUCTURE_TA') section_ta_LIEN_SECTION_TA = section_ta_STRUCTURE_TA.find_all( 'LIEN_SECTION_TA') section_ta_LIEN_ART = section_ta_STRUCTURE_TA.find_all('LIEN_ART') dates_changement, ensemble_versions_sections, ensemble_articles = ranger_sections_xml( chemin_base, section_ta_LIEN_SECTION_TA, section_ta_LIEN_ART, entree_texte, entree_version_texte, entree_section, entree_version_section, dates_changement, ensemble_versions_sections, ensemble_articles, cidTexte, niv + 1) print('\033[3D \033[3D', end='') nb_chiffres = len('{}/{}'.format(i + 1, len(coll_sections))) print('\033[' + str(nb_chiffres) + 'D' + (''.join([' ' * nb_chiffres])) + '\033[' + str(nb_chiffres) + 'D', end='') return dates_changement, ensemble_versions_sections, ensemble_articles
def ranger_articles_xml(chemin_base, coll_articles, entree_texte, dates, \ autres_articles, nouveaux_articles, \ date_codification, id_parent, arbre): # Si pas d’article dans cette section if coll_articles == None: return dates, autres_articles, nouveaux_articles, arbre # Sinon itérer sur les articles for i, article in enumerate(coll_articles): # Affichage de l’avancement compteur_recursif(i+1, len(coll_articles), True) # Lecture brute des attributs XML id = article['id'] nom = article['num'] etat_juridique = article['etat'] vigueur_debut = normalise_date(article['debut']) vigueur_fin = normalise_date(article['fin']) numero = i+1 # HACK - il ne devrait pas y avoir de date antérieure à la codification mais il y en a if date_codification and comp_infini_strict(vigueur_debut, date_codification): print('vigueur_debut article defectueuse {} < {}'.format(vigueur_debut,date_codification)) vigueur_debut = date_codification if date_codification and comp_infini_large(vigueur_fin, date_codification): print('vigueur_fin article defectueuse {} <= {}'.format(vigueur_fin,date_codification)) raise Exception() compteur_recursif() continue # Prise en compte de cette version d’article try: entree_article = Version_article.select().where( (Version_article.id == id) & #(Version_article.version_section == entree_version_section) & (Version_article.nom == nom) & (Version_article.etat_juridique == etat_juridique) & (Version_article.numero == numero) & (Version_article.vigueur_debut == vigueur_debut) & (Version_article.vigueur_fin == vigueur_fin) & (Version_article.condensat == None) & (Version_article.texte == entree_texte) ).get() autres_articles |= {(id, nom, etat_juridique, numero, \ vigueur_debut, vigueur_fin, None, \ entree_texte.cid)} except Version_article.DoesNotExist: nouveaux_articles |= {(id, nom, etat_juridique, numero, \ vigueur_debut, vigueur_fin, None, \ entree_texte.cid)} dates |= {vigueur_debut, vigueur_fin} arbre[id] = id_parent # Prise en compte des dates de vigueur #dates |= {vigueur_debut, vigueur_fin} # Affichage de l’avancement compteur_recursif() return dates, autres_articles, nouveaux_articles, arbre
def ranger_sections_xml(chemin_base, coll_sections, coll_articles, \ entree_texte, version_section_parente, dates, \ autres_sections, autres_articles, niv, \ nouvelles_sections, nouveaux_articles, date_codification, arbre): # Prévenir les récursions infinies - les specs indiquent un max de 10 if niv == 11: raise Exception() # Traiter les articles à ce niveau dates, autres_articles, nouveaux_articles, arbre = ranger_articles_xml( \ chemin_base, coll_articles, entree_texte, dates, autres_articles, \ nouveaux_articles, date_codification, version_section_parente, arbre) for i, section in enumerate(coll_sections): # Affichage de l’avancement compteur_recursif(i+1, len(coll_sections), False) cid = section['cid'] id = section['id'] nom = section.text etat_juridique = section['etat'] niveau = section['niv'] vigueur_debut = normalise_date(section['debut']) vigueur_fin = normalise_date(section['fin']) url = section['url'][1:] numero = i+1 # HACK - il ne devrait pas y avoir de date antérieure à la codification mais il y en a if date_codification and comp_infini_strict(vigueur_debut, date_codification): print('vigueur_debut section defectueuse {} < {}'.format(vigueur_debut,date_codification)) vigueur_debut = date_codification if date_codification and comp_infini_large(vigueur_fin, date_codification): print('vigueur_fin section defectueuse {} <= {}'.format(vigueur_fin,date_codification)) raise Exception() compteur_recursif() continue # Prise en compte de cette version de section try: entree_version_section = Version_section.select().where( (Version_section.id == id) & #(Version_section.id_parent == version_section_parente) & (Version_section.nom == nom) & (Version_section.etat_juridique == etat_juridique) & (Version_section.niveau == niveau) & (Version_section.numero == numero) & (Version_section.vigueur_debut == vigueur_debut) & (Version_section.vigueur_fin == vigueur_fin) & (Version_section.texte == entree_texte) ).get() autres_sections |= {(id, nom, etat_juridique, niveau, numero, \ vigueur_debut, vigueur_fin, entree_texte.cid)} except Version_section.DoesNotExist: nouvelles_sections |= {(id, nom, etat_juridique, niveau, \ numero, vigueur_debut, vigueur_fin, \ entree_texte.cid)} dates |= {vigueur_debut, vigueur_fin} arbre[id] = version_section_parente # Prise en compte des dates de vigueur #dates |= {vigueur_debut, vigueur_fin} # Continuer récursivement section_ta = lire_base_section_ta(chemin_base, url) dates, autres_sections, autres_articles, nouvelles_sections, \ nouveaux_articles, arbre = ranger_sections_xml(chemin_base, \ section_ta['LIEN_SECTION_TA'], section_ta['LIEN_ART'], \ entree_texte, id, dates, autres_sections, autres_articles, \ niv+1, nouvelles_sections, nouveaux_articles, date_codification, arbre) # Affichage de l’avancement compteur_recursif() return dates, autres_sections, autres_articles, nouvelles_sections, \ nouveaux_articles, arbre
def ranger_texte_xml(chemin_base, cidTexte, nature_attendue=None): # Lecture brute du fichier XML texte/version chemin_texte_version = os.path.join(chemin_base, 'texte', 'version', cidTexte + '.xml') if not os.path.exists(chemin_texte_version): raise Exception() f_version = open(chemin_texte_version, 'r') soup_version = BeautifulSoup(f_version.read(), 'xml') version_META = soup_version.find('META') version_META_COMMUN = version_META.find('META_COMMUN') version_META_SPEC = version_META.find('META_SPEC') version_META_TEXTE_CHRONICLE = version_META_SPEC.find('META_TEXTE_CHRONICLE') version_META_TEXTE_VERSION = version_META_SPEC.find('META_TEXTE_VERSION') version_NATURE = version_META_COMMUN.find('NATURE').text version_CID = version_META_TEXTE_CHRONICLE.find('CID').text version_NOR = version_META_TEXTE_CHRONICLE.find('NOR').text version_DATE_TEXTE = version_META_TEXTE_CHRONICLE.find('DATE_TEXTE').text version_DATE_PUBLI = version_META_TEXTE_CHRONICLE.find('DATE_PUBLI').text version_TITRE = version_META_TEXTE_VERSION.find('TITRE').text version_TITREFULL = version_META_TEXTE_VERSION.find('TITREFULL').text version_DATE_DEBUT = version_META_TEXTE_VERSION.find('DATE_DEBUT').text version_DATE_FIN = version_META_TEXTE_VERSION.find('DATE_FIN').text version_ETAT = version_META_TEXTE_VERSION.find('ETAT').text # Lecture brute du fichier XML texte/struct chemin_texte_struct = os.path.join(chemin_base, 'texte', 'struct', cidTexte + '.xml') if not os.path.exists(chemin_texte_struct): raise Exception() f_struct = open(chemin_texte_struct, 'r') soup_struct = BeautifulSoup(f_struct.read(), 'xml') struct_META = soup_struct.find('META') struct_META_COMMUN = struct_META.find('META_COMMUN') struct_META_SPEC = struct_META.find('META_SPEC') struct_META_TEXTE_CHRONICLE = struct_META_SPEC.find('META_TEXTE_CHRONICLE') struct_META_TEXTE_VERSION = struct_META_SPEC.find('META_TEXTE_VERSION') struct_VERSIONS = soup_struct.find('VERSIONS') struct_STRUCT = soup_struct.find('STRUCT') struct_NATURE = struct_META_COMMUN.find('NATURE').text struct_CID = struct_META_TEXTE_CHRONICLE.find('CID').text struct_NOR = struct_META_TEXTE_CHRONICLE.find('NOR').text struct_DATE_TEXTE = struct_META_TEXTE_CHRONICLE.find('DATE_TEXTE').text struct_DATE_PUBLI = struct_META_TEXTE_CHRONICLE.find('DATE_PUBLI').text struct_VERSION = struct_VERSIONS.find_all('VERSION') struct_VERSION_etat = struct_VERSION[0]['etat'] struct_LIEN_TXT = struct_VERSION[0].find('LIEN_TXT') struct_LIEN_TXT_id = struct_LIEN_TXT['id'] struct_LIEN_TXT_debut = struct_LIEN_TXT['debut'] struct_LIEN_TXT_fin = struct_LIEN_TXT['fin'] struct_LIEN_ART = struct_STRUCT.find_all('LIEN_ART') struct_LIEN_SECTION_TA = struct_STRUCT.find_all('LIEN_SECTION_TA') # Traitements de base version_DATE_TEXTE = normalise_date(version_DATE_TEXTE) version_DATE_PUBLI = normalise_date(version_DATE_PUBLI) version_DATE_DEBUT = normalise_date(version_DATE_DEBUT) version_DATE_FIN = normalise_date(version_DATE_FIN) struct_DATE_TEXTE = normalise_date(struct_DATE_TEXTE) struct_DATE_PUBLI = normalise_date(struct_DATE_PUBLI) # Vérifications if not cidTexte == version_CID: raise Exception() if nature_attendue and not version_NATURE == nature_attendue.upper() or not struct_NATURE == nature_attendue.upper(): raise Exception() if not version_DATE_TEXTE == struct_DATE_TEXTE: raise Exception() if not version_DATE_PUBLI == struct_DATE_PUBLI: raise Exception() if not len(struct_VERSION) == 1: # texte/version ne peut avoir qu’une seule version, donc texte/struct également et elles doivent correspondre raise Exception() # Enregistrement du Texte # TODO gérer les mises à jour try: entree_texte = Texte.get(Texte.cid == version_CID) except: entree_texte = Texte.create( cid=version_CID.upper(), nor=version_NOR.upper(), nature=version_NATURE.lower(), date_publi=version_DATE_PUBLI, date_texte=version_DATE_TEXTE, ) # Enregistrement de la Version_texte d’autorité # TODO gérer les mises à jour try: entree_version_texte = Version_texte.get(Version_texte.texte == entree_texte) except: entree_version_texte = Version_texte.create( texte=entree_texte, titre=version_TITRE, titre_long=version_TITREFULL, etat_juridique=version_ETAT.lower(), debut=version_DATE_DEBUT, fin=version_DATE_FIN, base=None ) # Recensement des dates de changement dates_changement = set([version_DATE_DEBUT, version_DATE_FIN]) ensemble_versions_sections = set() ensemble_articles = set() # Ajouter récursivement les sections et articles dates_changement, ensemble_versions_section, ensemble_articles = ranger_sections_xml(chemin_base, struct_LIEN_SECTION_TA, struct_LIEN_ART, entree_texte, entree_version_texte, None, None, dates_changement, ensemble_versions_sections, ensemble_articles, cidTexte, 1) print('') # Créer les versions de textes dates_changement = list(dates_changement) dates_changement.sort(cmp=comp_infini) for i in range(len(dates_changement) - 1): # TODO gérer les mises à jour Version_texte.create( texte=entree_texte, titre=version_TITRE, titre_long=version_TITREFULL, etat_juridique=version_ETAT.lower(), debut=dates_changement[i], fin=dates_changement[i+1], base=entree_version_texte )
def ranger_sections_xml(chemin_base, coll_sections, coll_articles, entree_texte, entree_version_texte, section_parente, version_section_parente, dates_changement, ensemble_versions_sections, ensemble_articles, cidTexte, niv): # Prévenir les récursions infinies - les specs indiquent un max de 10 if niv == 11: raise Exception() # Traiter les articles à ce niveau dates_changement, ensemble_articles = ranger_articles_xml(chemin_base, coll_articles, version_section_parente, entree_texte, entree_version_texte, dates_changement, ensemble_articles, cidTexte) for i in range(len(coll_sections)): print('{}/{}'.format(i+1, len(coll_sections)), end='') sys.stdout.flush() cid = coll_sections[i]['cid'] id = coll_sections[i]['id'] nom = coll_sections[i].text etat_juridique = coll_sections[i]['etat'] niveau = coll_sections[i]['niv'] debut = normalise_date(coll_sections[i]['debut']) fin = normalise_date(coll_sections[i]['fin']) url = coll_sections[i]['url'][1:] numero = i+1 # Enregistrement de la section try: entree_section = Section.get(Section.cid == cid) except: entree_section = Section.create( cid=cid, cid_parent=section_parente, niveau=niveau, texte=entree_texte ) # Ajout des dates limites pour préparer l’édition de liens dates_changement |= {debut, fin} # Enregistrement de version de section # TODO gérer les mises à jour try: entree_version_section = Version_section.get(Version_section.id == id) except: entree_version_section = Version_section.create( cid=cid, id=id, id_parent=version_section_parente, nom=nom, etat_juridique=etat_juridique, niveau=niveau, numero=numero, debut=debut, fin=fin, texte=entree_texte, version_texte=entree_version_texte ) # Ajout de cette version de section ensemble_versions_sections |= {entree_version_section} print(' → ', end='') sys.stdout.flush() # Continuer récursivement chemin_section_ta = os.path.join(chemin_base, 'section_ta', url) f_section_ta = open(chemin_section_ta, 'r') soup = BeautifulSoup(f_section_ta.read(), 'xml') section_ta_STRUCTURE_TA = soup.find('STRUCTURE_TA') section_ta_LIEN_SECTION_TA = section_ta_STRUCTURE_TA.find_all('LIEN_SECTION_TA') section_ta_LIEN_ART = section_ta_STRUCTURE_TA.find_all('LIEN_ART') dates_changement, ensemble_versions_sections, ensemble_articles = ranger_sections_xml(chemin_base, section_ta_LIEN_SECTION_TA, section_ta_LIEN_ART, entree_texte, entree_version_texte, entree_section, entree_version_section, dates_changement, ensemble_versions_sections, ensemble_articles, cidTexte, niv+1) print('\033[3D \033[3D', end='') nb_chiffres=len('{}/{}'.format(i+1, len(coll_sections))) print('\033[' + str(nb_chiffres) + 'D' + (''.join([' ' * nb_chiffres])) + '\033[' + str(nb_chiffres) + 'D', end='') return dates_changement, ensemble_versions_sections, ensemble_articles