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
