def creer_articles_section(texte, niveau, version_section_parente, articles, version_texte, cid, cache):
marque_niveau = ''
for i in range(niveau):
marque_niveau = marque_niveau + '#'
# Champ Article
articles_section = articles.select().where(Article.version_section == version_section_parente)
# Itérer sur les articles de cette section
for article in articles_section:
if comp_infini_strict(version_texte.debut, article.debut) or comp_infini_strict(article.fin, version_texte.fin):
raise Exception('article non valide (version texte de {} à {}, version article de {} à {})'.format(version_texte.debut, version_texte.fin, article.debut, article.fin))
continue
chemin_markdown = os.path.join(cache, 'markdown', cid, article.id + '.md')
f_article = open(chemin_markdown, 'r')
texte_article = f_article.read().decode('utf-8')
f_article.close()
texte = texte \
+ marque_niveau + ' Article ' + article.num.strip() + '\n' \
+ '\n' \
+ texte_article + '\n' \
+ '\n' \
+ '\n'
return texte
def creer_sections(texte, niveau, version_section_parente, versions_sections, articles, version_texte, cid, cache):
marque_niveau = ''
for i in range(niveau):
marque_niveau = marque_niveau + '#'
# Champ Version_section
versions_section = versions_sections.select().where(Version_section.id_parent == version_section_parente).order_by(Version_section.numero)
# Itérer sur les sections de cette section
for version_section in versions_section:
if comp_infini_strict(version_texte.debut, version_section.debut) or comp_infini_strict(version_section.fin, version_texte.fin):
raise Exception('section non valide (version texte de {} à {}, version section de {} à {})'.format(version_texte.debut, version_texte.fin, version_section.debut, version_section.fin))
return texte
texte = texte \
+ marque_niveau + ' ' + version_section.nom.strip() + '\n' \
+ '\n'
texte = creer_sections(texte, niveau+1, version_section, versions_sections, articles, version_texte, cid, cache)
texte = creer_articles_section(texte, niveau, version_section, articles, version_texte, cid, cache)
return texte
def creer_sections(texte, niveau, version_section_parente, versions_sections,
articles, version_texte, cid, format, sections, dossier,
cache):
#print(sections)
marque_niveau = ''
for i in range(niveau):
marque_niveau = marque_niveau + '#'
# Champ Version_section
versions_section = versions_sections.select().where(
Version_section.id_parent == version_section_parente).order_by(
Version_section.numero)
# Itérer sur les sections de cette section
for version_section in versions_section:
if comp_infini_strict(version_texte.debut,
version_section.debut) or comp_infini_strict(
version_section.fin, version_texte.fin):
raise Exception(
'section non valide (version texte de {} à {}, version section de {} à {})'
.format(version_texte.debut, version_texte.fin,
version_section.debut, version_section.fin))
return texte
texte = texte \
+ marque_niveau + ' ' + version_section.nom.strip() + '\n' \
+ '\n'
nouv_sections = sections
nouv_sections.append(version_section.nom.strip())
texte = creer_sections(texte, niveau + 1, version_section,
versions_sections, articles, version_texte, cid,
format, nouv_sections, dossier, cache)
texte = creer_articles_section(texte, niveau + 1, version_section,
articles, version_texte, cid, format,
nouv_sections, dossier, cache)
if len(versions_section) == 0:
texte = creer_articles_section(texte, niveau + 1, None, articles,
version_texte, cid, format, sections,
dossier, cache)
return texte
def creer_articles_section(texte, niveau, version_section_parente, articles,
version_texte, cid, format, sections, dossier,
cache):
marque_niveau = ''
for i in range(niveau):
marque_niveau = marque_niveau + '#'
# Champ Article
articles_section = articles.select().where(
Article.version_section == version_section_parente)
# Itérer sur les articles de cette section
for article in articles_section:
if comp_infini_strict(version_texte.debut,
article.debut) or comp_infini_strict(
article.fin, version_texte.fin):
raise Exception(
'article non valide (version texte de {} à {}, version article de {} à {})'
.format(version_texte.debut, version_texte.fin, article.debut,
article.fin))
continue
chemin_markdown = os.path.join(cache, 'markdown', cid,
article.id + '.md')
f_article = open(chemin_markdown, 'r')
texte_article = f_article.read().decode('utf-8')
f_article.close()
texte = texte \
+ marque_niveau + ' Article ' + article.num.strip() + '\n' \
+ '\n' \
+ texte_article + '\n' \
+ '\n' \
+ '\n'
# Format « 1 dossier = 1 article »
fichier = os.path.join(dossier, article.num.strip() + '.md')
if format['organisation'] == 'repertoires-simple':
texte_article = texte_article + '\n'
f_texte = open(fichier, 'w')
f_texte.write(texte_article.encode('utf-8'))
f_texte.close()
return texte
def creer_articles_section(texte, niveau, version_section_parente, articles,
version_texte, cid, cache):
marque_niveau = ''
for i in range(niveau):
marque_niveau = marque_niveau + '#'
# Champ Article
articles_section = articles.select().where(
Article.version_section == version_section_parente)
# Itérer sur les articles de cette section
for article in articles_section:
if comp_infini_strict(version_texte.debut,
article.debut) or comp_infini_strict(
article.fin, version_texte.fin):
raise Exception(
'article non valide (version texte de {} à {}, version article de {} à {})'
.format(version_texte.debut, version_texte.fin, article.debut,
article.fin))
continue
chemin_markdown = os.path.join(cache, 'markdown', cid,
article.id + '.md')
f_article = open(chemin_markdown, 'r')
texte_article = f_article.read().decode('utf-8')
f_article.close()
texte = texte \
+ marque_niveau + ' Article ' + article.num.strip() + '\n' \
+ '\n' \
+ texte_article + '\n' \
+ '\n' \
+ '\n'
return texte
def creer_sections(texte, niveau, parent, version_texte, sql, arborescence,
format, dossier, db, cache):
marque_niveau = ''
for i in range(niveau):
marque_niveau = marque_niveau + '#'
sql_section_parente = "parent = '{0}'".format(parent)
if parent == None:
sql_section_parente = "parent IS NULL OR parent = ''"
sections = db.all("""
SELECT *
FROM sommaires
WHERE ({0})
AND ({1})
ORDER BY position
""".format(sql_section_parente, sql))
# Itérer sur les sections de cette section
for section in sections:
rcid, rparent, relement, rdebut, rfin, retat, rnum, rposition, r_source = section
#print('Article '+rnum+' : '+relement)
if comp_infini_strict(version_texte[0], rdebut) or comp_infini_strict(
rfin, version_texte[1]):
raise Exception(
u'section non valide (version texte de {} a {}, version section de {} à {})'
.format(version_texte[0], version_texte[1], rdebut, rfin))
return texte
# L’élément est un titre de sommaire, rechercher son texte et l’ajouter à la liste
if relement[4:8] == 'SCTA':
tsection = db.one("""
SELECT titre_ta, commentaire
FROM sections
WHERE id='{0}'
""".format(relement))
rarborescence = arborescence
rarborescence.append(tsection[0].strip())
texte = texte \
+ marque_niveau + ' ' + tsection[0].strip() + '\n' \
+ '\n'
texte = creer_sections(texte, niveau + 1, relement, version_texte,
sql, rarborescence, format, dossier, db,
cache)
# L’élément est un article, l’ajouter à la liste
elif relement[4:8] == 'ARTI':
article = db.one("""
SELECT id, section, num, date_debut, date_fin, bloc_textuel, cid
FROM articles
WHERE id = '{0}'
""".format(relement))
id, section, num, date_debut, date_fin, bloc_textuel, cid = article
if comp_infini_strict(version_texte[0],
date_debut) or comp_infini_strict(
date_fin, version_texte[1]):
continue
chemin_markdown = os.path.join(cache, 'markdown', cid, id + '.md')
f_article = open(chemin_markdown, 'r')
texte_article = f_article.read().decode('utf-8')
f_article.close()
texte = texte \
+ marque_niveau + ' Article ' + num.strip() + '\n' \
+ '\n' \
+ texte_article + '\n' \
+ '\n' \
+ '\n'
# Format « 1 dossier = 1 article »
fichier = os.path.join(dossier, id + '.md')
if format['organisation'] == 'repertoires-simple':
texte_article = texte_article + '\n'
f_texte = open(fichier, 'w')
f_texte.write(texte_article.encode('utf-8'))
f_texte.close()
return texte
def obtenir_texte_section( self, id, hierarchie, cid, debut_vigueur_texte, fin_vigueur_texte ):
"""
Obtenir le texte d’une section donnée par un id.
:param id:
string - ID de la section.
:param hierarchie:
[(str, str)] - Liste de couples (id, titre_ta) donnant le contexte dans la hiérarchie des titres.
:param cid:
string - CID du texte.
:param debut_vigueur_texte:
datetime.date - date de début de vigueur demandée.
:param fin_vigueur_texte:
datetime.date - date de fin de vigueur autorisée par la requête.
:returns:
(string, datetime.date) - (texte, fin_vigueur) Texte de l’article, date de fin de vigueur interne (plus proche future modification de la section).
"""
texte = ''
fins_vigueur = set()
if 'texte' not in self.sections or self.sections['texte'] != cid:
self.sections = {}
sections = self.db.all("""
SELECT sommaires.parent,
sommaires.element,
sommaires.debut,
sommaires.fin,
sommaires.num,
sommaires.position,
sections.titre_ta,
sections.commentaire,
sections.mtime
FROM sommaires
LEFT JOIN sections
ON sommaires.element = sections.id
WHERE sommaires.cid = '{0}'
AND ( sommaires.debut < sommaires.fin
OR sommaires.debut = '2999-01-01'
)
""".format( cid ) )
for section in sections:
sparent, selement, sdebut, sfin, snum, sposition, stitre_ta, scommentaire, smtime = section
sparent = sparent if sparent else None
sdebut = datetime.date(*(time.strptime(sdebut, '%Y-%m-%d')[0:3])) if sdebut != '2999-01-01' else None
sfin = datetime.date(*(time.strptime(sfin, '%Y-%m-%d')[0:3])) if sfin != '2999-01-01' else None
if selement not in self.sections:
self.sections[selement] = {}
self.sections[selement][sparent] = (sposition, snum, stitre_ta, sdebut, sfin, None, None, None)
# Marquage de ce cache comme complet : il n’y a plus à le re-calculer
self.sections['texte'] = cid
sections = {}
# Itérer sur les sections de cette section, le dictionnaire final servira ensuite à itérer dans l’ordre d’affichage des sections
for section in self.sections:
if section == 'texte' or id not in self.sections[section]:
continue
sfin = self.sections[section][id][4]
sposition = self.sections[section][id][0]
# La période de vigueur de cette section est expirée ou expire : ne pas l’ajouter au texte (sfin <= debut_vigueur_texte)
# Le cas quasi-erroné où le texte n’a pas de début de vigueur est écarté ici, mais devrait probablement renvoyer une erreur ailleurs
# TODO gérer le cas où debut_vigueur_texte == None (2 dans la base LEGI, à voir si AL trouve quand même des intervalles de vigueur)
if debut_vigueur_texte and comp_infini_large( sfin, debut_vigueur_texte ):
continue
sections[sposition] = section
# Itérer sur les sections non-expirées dans l’ordre d’affichage
position = 0
for i, section in sorted( sections.items() ):
sposition, snum, stitre_ta, sdebut, sfin, cdebut, cfin, ctexte = self.sections[section][id]
# Enregistrer la date de fin de vigueur de la section
if sdebut != None and comp_infini_strict( debut_vigueur_texte, sdebut ):
fins_vigueur.add( sdebut )
if sfin != None and comp_infini_strict( debut_vigueur_texte, sfin ):
fins_vigueur.add( sfin )
# La période de vigueur de cette section n’est pas encore commencée (fin_vigueur_texte <= sdebut)
# Les sections intemporelles (= sans date de début de vigueur (et normalement sans date de fin de vigueur)) sont considérées comme toujours en vigueur
if sdebut and comp_infini_large( fin_vigueur_texte, sdebut ):
continue
# Une des bornes de la période de vigueur de la section est strictement comprise dans l’intervalle courant de vigueur du texte : ce n’est pas censé arriver, les dates de changement de vigueur du texte sont censées être minimales
if ( sdebut and comp_infini_strict( debut_vigueur_texte, sdebut ) ) or comp_infini_strict( sfin, fin_vigueur_texte ):
raise Exception( 'Erreur interne : les intervalles de vigueur du texte sont être minimaux et il ne devrait donc pas exister une section avec une des bornes de vigueur strictement comprise dans l’intervalle courant de vigueur du texte' )
position += 1
# L’élément est un titre de sommaire, rechercher son texte et l’ajouter à la liste
if section[4:8] == 'SCTA':
chierarchie = hierarchie.copy()
chierarchie.append( (position, section, stitre_ta) )
# Le cache de section est valide et peut être utilisé pour ajouter le texte de la section
# L’intervalle de vigueur du cache de sections comprend l’intervalle courant de vigueur du texte (cdebut <= debut_vigueur_texte and fin_vigueur_texte < cfin)
# FIXME: pour les formats "articles" ou "sections", il faut désactiver ce "if" sinon certains fichier manquent, ajouter un paramètre ou autre mécanisme
if not self.desactiver_cache and comp_infini_large( cdebut, debut_vigueur_texte ) and comp_infini_large( fin_vigueur_texte, cfin ):
texte = texte + ctexte
self.stockage.ecrire_ressource( section, chierarchie, snum, stitre_ta, ctexte )
# Si la section a une fin de vigueur, celle-ci devient une borne maximale de fin de vigueur des sections parentes
if cfin:
fins_vigueur.add( cfin )
else:
if stitre_ta == None:
stitre_ta = '(sans titre)'
titre_formate = self.syntaxe.obtenir_titre( chierarchie, stitre_ta )
texte_section, fin_vigueur_section = self.obtenir_texte_section( section, chierarchie, cid, debut_vigueur_texte, fin_vigueur_texte )
snum = snum.strip() if snum else ''
texte_section = titre_formate + texte_section
texte = texte + texte_section
self.stockage.ecrire_ressource( section, chierarchie, snum, stitre_ta, texte_section )
self.sections[section][id] = (sposition, snum, stitre_ta, sdebut, sfin, debut_vigueur_texte, fin_vigueur_section, texte_section)
# Si la section a une fin de vigueur, celle-ci devient une borne maximale de fin de vigueur des sections parentes
if fin_vigueur_section:
fins_vigueur.add( fin_vigueur_section )
# L’élément est un article, l’ajouter à la liste
elif section[4:8] == 'ARTI':
chierarchie = hierarchie.copy()
chierarchie.append( (position, section, None) )
valeur_article = self.fabrique_article.obtenir_texte_article( section, chierarchie, debut_vigueur_texte, fin_vigueur_texte )
num, texte_article, debut_vigueur_article, fin_vigueur_article = valeur_article
# L’article a une période de vigueur comprise dans l’intervalle courant de vigueur du texte : ajouter le texte
if texte_article != None:
texte = texte + texte_article
# Si l’article a une fin de vigueur, celle-ci devient une borne maximale de fin de vigueur des sections parentes
if fin_vigueur_article:
fins_vigueur.add( fin_vigueur_article )
# Si l’article a un début de vigueur après l’intervalle courant de vigueur du texte,
# celle-ci devient une borne maximale de vigueur des sections parentes (debut_vigueur_texte < debut_vigueur_article)
if comp_infini_strict( debut_vigueur_texte, debut_vigueur_article ) and debut_vigueur_article:
fins_vigueur.add( debut_vigueur_article )
fin_vigueur = None
if len( fins_vigueur ):
fin_vigueur = min( fins_vigueur )
return texte, fin_vigueur
def enregistrer_versions_texte(version, livraison, dates, autres_sections, autres_articles, entree_texte, nouvelles_sections, nouveaux_articles, chemin_base, arbre):
# Chercher les versions de textes de cette livraison
dates = list(dates)
dates.sort(cmp=comp_infini)
def obtenir_sections(sections):
for section in sections:
yield {'id': section[0],
'nom': section[1],
'etat_juridique': section[2],
'niveau': section[3],
'numero': section[4],
'vigueur_debut': section[5],
'vigueur_fin': section[6],
'texte': section[7]}
def obtenir_articles(articles):
for article in articles:
yield {'id': article[0],
'nom': article[1],
'etat_juridique': article[2],
'numero': article[3],
'vigueur_debut': article[4],
'vigueur_fin': article[5],
'condensat': article[6],
'texte': article[7]}
def obtenir_travaux_articles(articles, chemin_base):
for article in articles:
yield {'version_article': article[0],
'texte': article[7],
'chemin': os.path.join(chemin_base, 'article', decompose_cid(article[0]+'.xml'))}
# Import des enregistrements sections et articles
# Il ne semble pas possible d’ajouter plus de 500 enregistrements
# par appel à insert_many, dont acte
nouvelles_sections = list(nouvelles_sections)
nouveaux_articles = list(nouveaux_articles)
for i in range(0,int(math.ceil(float(len(nouvelles_sections))/tranches_bdd))):
Version_section.insert_many(obtenir_sections(nouvelles_sections[i*tranches_bdd:(i+1)*tranches_bdd])).execute()
for i in range(0,int(math.ceil(float(len(nouveaux_articles))/tranches_bdd))):
Version_article.insert_many(obtenir_articles(nouveaux_articles[i*tranches_bdd:(i+1)*tranches_bdd])).execute()
#for i in range(0,int(math.ceil(float(len(nouveaux_articles))/tranches_bdd))):
#Travaux_articles.insert_many(obtenir_travaux_articles(nouveaux_articles[i*tranches_bdd:(i+1)*tranches_bdd], chemin_base)).execute()
#Version_section.insert_many(obtenir_sections(nouvelles_sections)).execute()
#Version_article.insert_many(obtenir_articles(nouveaux_articles)).execute()
#Travaux_articles.insert_many(obtenir_travaux_articles(nouveaux_articles, chemin_base)).execute()
# Remonter la dernière livraison (branche) jusqu’à la première
# version commune avec cette nouvelle livraison
entree_version_texte = None
nouvelles_versions = set()
if entree_texte.livraison:
livraison_texte = Livraison_texte.select().where(
Livraison_texte.livraison == entree_texte.livraison &
Livraison_texte.texte == entree_texte
).order_by(Livraison_texte.version_texte.desc()).get()
entree_version_texte = livraison_texte.version_texte
# Cette boucle représente la première date de vigueur de la
# nouvelle livraison. Réfléchir avec le croquis ci-dessous
# en faisant varier N1 (N=nouveau) entre avant V1 et V3
# V1---------V2-----------V3-------V4-------V5
# N1-----------N2
while not(entree_version_texte.vigueur_debut <= dates[0] and \
comp_infini_strict(dates[0], entree_version_texte.vigueur_fin)):
if entree_version_texte.version_prec == None:
entree_version_texte = None
break
entree_version_texte = Version_texte.select().where(
Version_texte.id == entree_version_texte.version_prec
).get()
# TODO décider quoi faire si le titre ou une autre donnée
# mineure change -> nouvelle branche ? je dirais oui
# mais réfléchir finement, e.g. à etat_juridique
if entree_version_texte != None and entree_version_texte.version_prec != None:
entree_version_texte = Version_texte.select().where(
Version_texte.id == entree_version_texte.version_prec
).get()
# La première nouvelle version est à cheval entre deux
# versions précédentes, il faut compléter l’intervalle VX-N1
# J’imagine que ce cas ne doit jamais apparaître
if entree_version_texte.vigueur_debut < dates[0] and \
comp_infini_strict(dates[0], entree_version_texte.vigueur_fin):
entree_version_texte = Version_texte.create(
titre = version['TITRE'],
titre_long = version['TITREFULL'],
nature=version['NATURE'].lower(),
date_texte=version['DATE_TEXTE'],
date_publi=version['DATE_PUBLI'],
date_modif=version['DERNIERE_MODIFICATION'],
etat_juridique = version['ETAT'].lower(),
vigueur_debut = entree_version_texte.vigueur_debut,
vigueur_fin = dates[0],
texte = entree_texte,
version_prec=entree_version_texte
)
#nouvelles_versions |= {entree_version_texte}
Livraison_texte.create(
livraison = livraison,
version_texte = entree_version_texte,
texte = entree_texte
)
# TODO recopier les sections et articles de VX
raise NonImplementeException()
compteur_recursif(0)
for i in range(len(dates) - 1):
compteur_recursif(i+1, len(dates)-1)
# Enregistrement de cette version de texte #OK
entree_version_texte = Version_texte.create(
titre = version['TITRE'],
titre_long = version['TITREFULL'],
nature=version['NATURE'].lower(),
date_texte=version['DATE_TEXTE'],
date_publi=version['DATE_PUBLI'],
date_modif=version['DERNIERE_MODIFICATION'],
etat_juridique = version['ETAT'].lower(),
vigueur_debut = dates[i],
vigueur_fin = dates[i+1],
texte = entree_texte,
version_prec=entree_version_texte
)
nouvelles_versions |= {entree_version_texte}
# Inscription du lien entre texte, livraison et version de texte #OK
Livraison_texte.create(
livraison = livraison,
version_texte = entree_version_texte,
texte = entree_texte
)
# Inscription du lien entre livraison et sections
sections = list(set(nouvelles_sections) | autres_sections)
sections = [section for section in sections if (section[5] <= entree_version_texte.vigueur_debut) and comp_infini_large(entree_version_texte.vigueur_fin, section[6])]
def liste_sections(sections, arbre, version_texte):
for section in sections:
yield {'version_section': section[0],
'version_texte': version_texte,
'id_parent': arbre[section[0]]}
#print('tranches sections={} {} {} {}'.format(len(sections), float(len(sections))/tranches_bdd, math.ceil(float(len(sections))/tranches_bdd), int(math.ceil(float(len(sections))/tranches_bdd))))
for i in range(0,int(math.ceil(len(sections)/tranches_bdd))):
#print('{}'.format(len(sections[i*tranches_bdd:(i+1)*tranches_bdd])))
Liste_sections.insert_many(liste_sections(sections[i*tranches_bdd:(i+1)*tranches_bdd], arbre, entree_version_texte)).execute()
# Inscription du lien entre livraison et articles
articles = list(set(nouveaux_articles) | autres_articles)
articles = [a for a in articles if (a[4] <= entree_version_texte.vigueur_debut) and comp_infini_large(entree_version_texte.vigueur_fin, a[5])]
def liste_articles(articles, arbre, version_texte):
for article in articles:
yield {'version_article': article[0],
'version_texte': version_texte,
'id_parent': arbre[article[0]]}
#print('tranches articles={} {} {} {}'.format(len(articles), float(len(articles))/tranches_bdd, math.ceil(float(len(articles))/tranches_bdd), int(math.ceil(float(len(articles))/tranches_bdd))))
for i in range(0,int(math.ceil(len(articles)/tranches_bdd))):
#print('{}'.format(len(articles[i*tranches_bdd:(i+1)*tranches_bdd])))
Liste_articles.insert_many(liste_articles(articles[i*tranches_bdd:(i+1)*tranches_bdd], arbre, entree_version_texte)).execute()
compteur_recursif()
# Enregistrer cette livraison du texte comme étant calculée
entree_texte.livraison = livraison
entree_texte.save()
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
