Creatiing a tree from an xml element and all its descendant

[arbiel]

Hi

Sorry for the disturbance. My trouble was that I had some difficulties for creating an xml document from an element and its descendants. I actually found how to do it.

So I updated my script, which reads as follows :

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#pour classer les mots d'une phrase par ordre alphabétique
#liste=str.split(phrase)
#liste.sort(key=grec_vocab.atonique)


import sys
from html.parser import HTMLParser
from unicodedata import name as ucd_nom
from unicodedata import lookup as ucd_car
from xml.etree.ElementTree import ElementTree as arbre
from xml.etree.ElementTree import Element as xml

def les_dia():
	"""Noms anglais des diacritiques."""
	return  {'DASIA', 'DIALYTIKA', 'MACRON', 'OXIA', 'PERISPOMENI', 'PROSGEGRAMMENI', 'PSILI', 'TONOS', 'VARIA', 'VRACHY', 'YPOGEGRAMMENI'}
def les_symb():
	"""Symboles qui portent le nom de lettres."""
	return {"BETA", "EPSILON", "KAPPA", "PHI", "PI", "RHO", "SIGMA", "THETA", "UPSILON"}
def les_grecques():
	"""Fichier des lettres et leurs caractéristiques"""
	return '/home/remi/Documents/programmation/python/grec_vocab/grec.xhtml'
def les_unicodes():
	"""Url des pages de définition des lettres"""
	return "https://unicode-table.com/fr/blocks/greek-coptic/", "https://unicode-table.com/fr/blocks/greek-extended/"
def le_fichier_xml():
	"""Table de correspondance."""
	return '/home/remi/Documents/programmation/python/grec_vocab/alphabet.xml'
def alphabétisation():
	"""Éléments du nom qui induisent le calcul de la lettre «alphabétique»."""
	return {"CAPITAL", "WITH", "SYMBOL"}
def les_minus():
	"""Début du nom des lettres minuscules."""
	return {"GREEK SMALL LETTER " }
def le_rep():
	"""Répertoire du script."""
	return '/home/remi/Documents/programmation/python/grec_vocab'

class MyHTMLParser(HTMLParser):
	"""Recherche des caractéristiques des lettres.

	Les voyelles et le ρ, en grec ancien, peuvent recevoir des symboles diacritiques (esprit, accents, iota souscrit), auxquelles s'ajoutent le tréma et un accent tonique du grec moderne. Les blocs «grec-coptic» et «greek-extended» de l'Unicode décrivent chacune de ces lettres"""
	nues=[]
	combinées=[]
	def handle_starttag(self, tag, attrs):
		if tag == 'div' and len(attrs) > 2 and "disabled" not in attrs[0][1] and attrs[1][0] == 'data-symbol':
			symbol=attrs[1][1]
			n_attr=dict()
			n_attr["titre"]=attrs[2][1]
			n_attr["unicd"]='U+' + attrs[3][1].split("/")[2]
			n_attr["dia"]={}
			n_attr["nat"]="minus"
			grecque=symbol
			nom_Unicode=ucd_nom(symbol)
			liste_termes=set(nom_Unicode.split(None, -1))
			if len(alphabétisation().intersection(liste_termes)) > 0:
				if "SYMBOL" in nom_Unicode:
# recherche du symbole assimilable à une lettre
					symb=les_symb().intersection (liste_termes)
					if len(symb) > 0:
						nom_Unicode="GREEK SMALL LETTER " + symb.pop()
				else:
# les caractères diacritiques sont introduits par la préposition «WITH»
					if "WITH" in nom_Unicode:
# les supprimer
						nom_Unicode=nom_Unicode[: nom_Unicode.find("WITH")-1]
# en faire la liste
						n_attr["dia"]=liste_termes.intersection(les_dia())
					if "CAPITAL" in nom_Unicode:
						nom_Unicode=nom_Unicode.replace("CAPITAL", "SMALL")
						nat="majus"
				try:
					n_attr["lettre"]=ucd_car(nom_Unicode)
				except:
			# le nom du caractère minuscule Yot ('GREEK LETTER YOT) ne contient pas le mot SMALL
					n_attr["lettre"]="ϳ"
				self.combinées.append(xml(symbol,n_attr))
			else:
				self.nues.append(xml(symbol,n_attr))

def gen_xml_alpha ():
	'''Procédure de création du fichier xml décrivant les lettres du grec ancien et du grec moderne.'''
	import requests
	xml_nues=xml("div", id='simples')
	xml_combinées=xml('div', id='combinées')
	parser=MyHTMLParser(convert_charrefs=True)
	for bloc in les_unicodes():
		try:
			html=requests.get(bloc, timeout=2 )
		except requests.exceptions.ConnectionError:
			print("La connexion au site de l'Unicode n'a pas pu être établie")
			return False
		except requests.exceptions.Timeout:
			print("Le serveur de l'Unicode ne répond pas")
			return False
		else:
			pass
		parser.feed(html.text)
		xml_nues.extend(parser.nues)
		xml_combinées.extend(parser.combinées)
#	table=parser.fin()
	alphabet=xml("section", id='alphabet')
	alphabet.append(xml_nues)
	alphabet.append(xml_combinées)
#	parser.close()
	doc=arbre(alphabet)
	doc.write(le_fichier_xml(), encoding="utf-8")
	return alphabet

def lire_tabTrans():
	import pickle
	try:
		with open(la_table(),"rb") as traduc:
			données=pickle.Unpickler(traduc)
			dictionnaire=données.load()
	except FileNotFoundError:
		dictionnaire=[]
	return dictionnaire

def enreg_xml(alphabet):
	import pickle
	with open(la_table(),"wb") as les_données:
		données=pickle.Pickler(les_données)
		données.dump(dictionnaire)
	return 0


def atonique (mot_polytonique: str)  -> str:
	dictrans=lire_tabTrans()
	if len(dictrans) == 0:
		dictrans=gen_dic_trad()
	table=str.maketrans(dictrans)
	return mot_polytonique.translate(table)

def charge():
	importlib.reload(grec_vocab)

def diataxis(*mots):
	les_mots=[]
	for un_mot in mots:
		les_mots.append(un_mot)
#	les_mots=mots
	les_mots.sort(key=atonique)
	print(les_mots)

def psylote(*mots):
	latrade=""
	for mot in mots:
		psylone=atonique(mot)
		latrade=latrade+", "+psylone
	return latrade[2:]

I let it published, as it may be sort of an exemple on how to do, in the case other people face the same difficulties.
Arbiel

[Larz60+]

Thread moved to code sharing