#!/usr/bin/python
# -*- coding: iso-8859-1 -*-

# Copyright 2003, 2004 DGEFP, Georges-Andre Silber (CRI/ENSMP).
#
# $Id: lheo_utils.py,v 1.5 2004/09/24 14:45:41 silber Exp $
#
# Cette boite a outils est copiable et utilisable gratuitement
# sans limitation de duree. Par contre, aucune modification 
# n'est autorisee sans l'autorisation expresse des 
# detenteurs du copyright.

import codecs
import sys
import cgi
import cgitb

from cStringIO import StringIO
from xml.dom.ext.reader import Sax2
from xml.dom.ext import *

class ErreurDeValidation:
    def __init__(self):
        print "ERREUR DE VALIDATION"

#
# Element de base
#
class ObjetElement (object):
    typecontenu = 'vide'

    def __init__(self, motcle):
        self.motcle = motcle

    def valide(self):
        return 2
    def valideXML(self, node):
        return 2
    def affiche(self):
        pass
    def afficheXML(self):
        pass
    def afficheExempleXML(self):
        pass
    def info(self):
        print "Élément: <%s>"%self.motcle
        print "  type     = '%s'"%self.typecontenu
    def HTMLLibelle(self, urlglossaire):
        if urlglossaire != '' and self.glossaire != '':
            return "<a href=\"%s\">%s</a>"%(urlglossaire+"#"+self.glossaire,self.libelle)
        else:
            return "%s"%self.libelle
    def afficheHTMLFormLabel(self, urlglossaire):
        if urlglossaire != '' and self.glossaire != '':
            print "<label class=\"%s\"><a href=\"%s\">%s</a></label>"%(self.motcle,urlglossaire+"#"+self.glossaire,self.libelle)
        else:
            print "<label class=\"%s\">%s</label>"%(self.motcle,self.libelle)
    def afficheHTMLFormWidget(self, identificateur, lignes, colonnes):
        pass

#
# Element de type 'NUL'
#
class ObjetElementNul (ObjetElement):
    typecontenu = 'nul'
    def __init__(self):
        ObjetElement.__init__(self, 'nul')

#
# Element de type 'alpha'
#
class ObjetElementTexte (ObjetElement):
    typecontenu = 'alpha'

    def modeleContenu(self):
        print "Le contenu doit être compris entre",
        print self.lgmin,
        print "et",
        print self.lgmax,
        print "caractères."

    def info(self):
        ObjetElement.info(self)
        print "  taille       = %d"%self.tailletexte()
        print "  nblignes     = %d"%len(self.lignes)
        print "  longueur min = %d"%self.lgmin
        print "  longueur max = %d"%self.lgmax

    def valide(self):
        niveau_validation = 2
        taille_totale = self.tailletexte()
        if taille_totale < self.lgmin:            
            print "Erreur de validation"
            print "Élément <%s>: contenu trop court (%d)"%(self.motcle,taille_totale) 
            self.modeleContenu()
            niveau_validation = 0
        elif taille_totale > self.lgmax:
            print "Erreur de validation"
            print "Élément <%s>: contenu trop long (%d)"%(self.motcle,taille_totale) 
            self.modeleContenu()
            niveau_validation = 0
        return niveau_validation

    def lisDOM(self, node):
        niveau_validation = 0
        if node.nodeName != self.motcle:
            print "Erreur de lecture: l'element devrait etre un '%s'"%self.motcle
            print "  et non pas un '%s'"%node.nodeName            
            niveau_validation = -1
        for n in node.childNodes:
            if n.nodeName != '#text' and n.nodeName != 'rc':
                print "Erreur de lecture: les éléments fils de '%s'"%self.motcle
                print "  doivent etre de type '#text' ou 'rc'"
                print "  et non pas un '%s'"%node.nodeName
                niveau_validation = -1
            elif n.nodeName == '#text':
                self.ajoute(n.nodeValue)
            elif n.nodeName == 'rc':
                self.ajouterc()
        return niveau_validation
    
    def __init__(self, motcle):
        ObjetElement.__init__(self, motcle)
        self.lignes = []
        self.tailles = []

    def contenu(self):
        log = []
        pr = log.append
        if len(self.lignes) :
            for l in self.lignes[:-1]:
                pr(l)
                pr('\n')                
            pr(self.lignes[-1])
        str = ''.join(log).encode('iso-8859-1')
        return str
    
    def affiche(self):
        str = self.contenu()
        if len(str):
            print str
        
    def afficheXML(self):
        log = []
        pr = log.append        
        pr("<"+self.motcle+">")
        if len(self.lignes) :
            for l in self.lignes[:-1]:
                pr(l)
                pr('<rc/>')                
            pr(self.lignes[-1])
        pr("</"+self.motcle+">")
        print ''.join(log).encode('iso-8859-1')

    def afficheExempleXML(self):
        log = []
        pr = log.append        
        pr("<"+self.motcle+">")
        pr(self.exemple)
        pr("</"+self.motcle+">")
        print ''.join(log).encode('iso-8859-1')

    def tailletexte(self):
        taille = 0
        if len(self.lignes) > 1:
            taille = len(self.lignes) - 1
        for tailleligne in self.tailles:
            taille += tailleligne
        return taille

    def ajouterc(self):
        self.lignes.append('')
        self.tailles.append(0)

    def transcode(self, c):
        ajout = ''
        if c == '<':
            ajout = '&lt;'
        elif c == '>':
            ajout = '&gt;'
        elif c == '\'':
            ajout = '&apos;'
        elif c == '"':
            ajout = '&aquot;'
        elif c == '&':
            ajout = '&amp;'
        elif c == '\n':
            ajout = ''
        else:
            ajout = c
        return ajout

    def ajoute(self, texte):
        stexte = texte.strip()
        taille = 0
        textexml = ''
        for c in stexte:
            ajout = self.transcode(c)
            if ajout != '':
                textexml += ajout
                taille += 1
        if taille != 0:
            self.lignes.append(textexml)
            self.tailles.append(taille)

    def afficheHTMLFormWidget(self, identificateur, lignes, colonnes):
        if lignes != 0:
            l = lignes
        else:
            l = 3
        if colonnes != 0:
            c = colonnes
        else:
            c = 45
        n= identificateur+"/"+self.motcle
        if self.lgmax <= 70:
            print "<input",
            print "class=\"%s\""%self.motcle,
            print "type=\"text\"",
            print "name=\"%s\""%n,
            print "maxlength=\"%s\""%self.lgmax,
            print "size=\"%s\""%c,            
            print ">%s</input>"%self.contenu()
        else:
            print "<textarea",
            print "class=\"%s\""%self.motcle,
            print "wrap=\"soft\"",
            print "name=\"%s\""%n,
            print "cols=\"%s\""%c,
            print "rows=\"%s\""%l,
            print ">%s</textarea>"%self.contenu()
#
# Element de type 'num'
#
class ObjetElementNombre (ObjetElement):
    typecontenu = 'num'

    def modeleContenu(self):
        print "Le contenu doit être compris entre",
        print self.lgmin,
        print "et",
        print self.lgmax,
        print "chiffres."

    def info(self):
        ObjetElement.info(self)
        print "  taille       = %d"%len(str(self.valeur))
        print "  longueur min = %d"%self.lgmin
        print "  longueur max = %d"%self.lgmax
        
    def affiche(self):
        if len(str(self.valeur)):
            print str(self.valeur).encode('iso-8859-1')

    def valide(self):
        niveau_validation = 2
        t = str(self.valeur)
        taille_totale = len(t)
        if taille_totale < self.lgmin:            
            print "Erreur de validation"
            print "Élément <%s>: contenu trop court (%d)"%(self.motcle,taille_totale) 
            self.modeleContenu()
            niveau_validation = 0
        elif taille_totale > self.lgmax:
            print "Erreur de validation"
            print "Élément <%s>: contenu trop long (%d)"%(self.motcle,taille_totale) 
            self.modeleContenu()
            niveau_validation = 0
        ok = 1
        for c in t:
            if c < '0' or c > '9':
                ok = 0
        if ok == 0:
            print "Erreur de validation"
            print "Élément <%s>: contenu erroné"%self.motcle
            self.modeleContenu()
            niveau_validation = 0
        return niveau_validation

    def lisDOM(self, node):
        niveau_validation = 0
        if node.nodeName != self.motcle:
            print "Erreur de lecture: l'element devrait etre un '%s'"%self.motcle
            print "  et non pas un '%s'"%node.nodeName            
            niveau_validation = -1
        for n in node.childNodes:
            if n.nodeName != '#text':
                print "Erreur de lecture: les éléments fils de '%s'"%self.motcle
                print "  doivent etre de type '#text' ou 'rc'"
                print "  et non pas un '%s'"%node.nodeName
                niveau_validation = -1
            elif n.nodeName == '#text' and len(n.nodeValue) != 0:
                self.ajoute(n.nodeValue)
        return niveau_validation
            
    def __init__(self, motcle):
        ObjetElement.__init__(self, motcle)
        self.valeur = ''

    def afficheXML(self):
        log = []
        pr = log.append        
        pr("<"+self.motcle+">")
        pr(self.valeur)
        pr("</"+self.motcle+">")
        print ''.join(log).encode('iso-8859-1')
        
    def afficheExempleXML(self):
        log = []
        pr = log.append        
        pr("<"+self.motcle+">")
        pr(self.exemple)
        pr("</"+self.motcle+">")
        print ''.join(log).encode('iso-8859-1')
        
    def ajoute(self, v):
        sv = str(v).strip()
        self.valeur = sv

    def tailletexte(self):
        return len(self.valeur)

    def contenu(self):
        return self.valeur

    def afficheHTMLFormWidget(self, identificateur, lignes, colonnes):
        if lignes != 0:
            l = lignes
        else:
            l = 3
        if colonnes != 0:
            c = colonnes
        else:
            c = 45
        n= identificateur+"/"+self.motcle
        print "<input",
        print "class=\"%s\""%self.motcle,
        print "type=\"text\"",
        print "name=\"%s\""%n,
        print "maxlength=\"%s\""%self.lgmax,
        print "size=\"%s\""%self.lgmax,
        print ">%s</input>"%self.contenu()

#
# Element de type 'date'
#
class ObjetElementDate (ObjetElement):
    typecontenu = 'date'

    def modeleContenu(self):
        print "Le contenu doit avoir",
        print self.lgmax,
        print "chiffres."

    def info(self):
        ObjetElement.info(self)
        print "  taille       = %d"%len(str(self.valeur))
        print "  longueur min = %d"%self.lgmin
        print "  longueur max = %d"%self.lgmax

    def affiche(self):
        if len(str(self.valeur)):
            print str(self.valeur).encode('iso-8859-1')

    def valide(self):
        niveau_validation = 2
        t = str(self.valeur)
        taille_totale = len(t)
        if taille_totale < self.lgmin:            
            print "Erreur de validation"
            print "Élément <%s>: contenu trop court (%d)"%(self.motcle,taille_totale) 
            self.modeleContenu()
            niveau_validation = 0
        elif taille_totale > self.lgmax:
            print "Erreur de validation"
            print "Élément <%s>: contenu trop long (%d)"%(self.motcle,taille_totale) 
            self.modeleContenu()
            niveau_validation = 0
        ok = 1
        for c in t:
            if c < '0' or c > '9':
                ok = 0
        if ok == 0:
            print "Erreur de validation"
            print "Élément <%s>: contenu erroné"%self.motcle
            self.modeleContenu()
            niveau_validation = 0
        return niveau_validation

    def lisDOM(self, node):
        niveau_validation = 0
        if node.nodeName != self.motcle:
            print "Erreur de lecture: l'element devrait etre un '%s'"%self.motcle
            print "  et non pas un '%s'"%node.nodeName            
            niveau_validation = -1
        for n in node.childNodes:
            if n.nodeName != '#text':
                print "Erreur de lecture: les éléments fils de '%s'"%self.motcle
                print "  doivent etre de type '#text' ou 'rc'"
                print "  et non pas un '%s'"%node.nodeName
                niveau_validation = -1
            elif n.nodeName == '#text' and len(n.nodeValue) != 0:
                self.ajoute(n.nodeValue)
        return niveau_validation
            
    def __init__(self, motcle):
        self.valeur = ''
        ObjetElement.__init__(self, motcle)
        
    def afficheXML(self):
        log = []
        pr = log.append        
        pr("<"+self.motcle+">")
        pr(self.valeur)
        pr("</"+self.motcle+">")
        #print ''.join(log)
        print ''.join(log).encode('iso-8859-1')
        
    def afficheExempleXML(self):
        log = []
        pr = log.append        
        pr("<"+self.motcle+">")
        pr(self.exemple)
        pr("</"+self.motcle+">")
        #print ''.join(log)
        print ''.join(log).encode('iso-8859-1')

    def ajoute(self, v):
        sv = str(v).strip()
        self.valeur = sv

    def tailletexte(self):
        return len(self.valeur)

    def contenu(self):
        return self.valeur

    def afficheHTMLFormWidget(self, identificateur, lignes, colonnes):
        if lignes != 0:
            l = lignes
        else:
            l = 3
        if colonnes != 0:
            c = colonnes
        else:
            c = 45
        n= identificateur+"/"+self.motcle
        print "<input",
        print "class=\"%s\""%self.motcle,
        print "type=\"text\"",
        print "name=\"%s\""%n,
        print "maxlength=\"%s\""%self.lgmax,
        print "size=\"%s\""%self.lgmax,
        print ">%s</input>"%self.contenu()

#
# Element de type 'code'
#
class ObjetElementCode (ObjetElement):
    typecontenu = 'code'

    def modeleContenu(self):
        print "Le contenu doit être une code de",
        print self.lgmin,
        print "à",
        print self.lgmax,
        print "caractères."

    def info(self):
        ObjetElement.info(self)
        print "  taille       = %d"%len(str(self.valeur))
        print "  table        = '%s'"%self.table
        print "  longueur min = %d"%self.lgmin
        print "  longueur max = %d"%self.lgmax

    def affiche(self):
        if len(str(self.valeur)):
            print str(self.valeur).encode('iso-8859-1')
            
    def valide(self):
        niveau_validation = 1
        t = str(self.valeur)
        taille_totale = len(t)
        if taille_totale < self.lgmin:            
            print "Erreur de validation"
            print "Élément <%s>: contenu trop court (%d)"%(self.motcle,taille_totale) 
            self.modeleContenu()
            niveau_validation = 0
        elif taille_totale > self.lgmax:
            print "Erreur de validation"
            print "Élément <%s>: contenu trop long (%d)"%(self.motcle,taille_totale) 
            self.modeleContenu()
            niveau_validation = 0
        if self.contenutable.has_key(t) and niveau_validation == 1:
            niveau_validation = 2
        else:
            print "Avertissement: code '%s' non trouvé dans la table '%s'"%(t,self.table)
        return niveau_validation

    def lisDOM(self, node):
        niveau_validation = 0
        if node.nodeName != self.motcle:
            print "Erreur de lecture: l'element devrait etre un '%s'"%self.motcle
            print "  et non pas un '%s'"%node.nodeName            
            niveau_validation = -1
        for n in node.childNodes:
            if n.nodeName != '#text' and n.nodeName != 'rc':
                print "Erreur de lecture: les éléments fils de '%s'"%self.motcle
                print "  doivent etre de type '#text' ou 'rc'"
                print "  et non pas un '%s'"%node.nodeName
                niveau_validation = -1
            elif n.nodeName == '#text' and len(n.nodeName) > 0:
                self.ajoute(n.nodeValue)
        return niveau_validation
            
    def __init__(self, motcle, table):
        ObjetElement.__init__(self, motcle)
        self.valeur = ''        
        self.table = table
        
    def afficheXML(self):
        log = []
        pr = log.append        
        pr("<"+self.motcle+">")
        pr(self.valeur)
        pr("</"+self.motcle+">")
        print ''.join(log).encode('iso-8859-1')
        
    def afficheExempleXML(self):
        log = []
        pr = log.append        
        pr("<"+self.motcle+">")
        pr(self.exemple)
        pr("</"+self.motcle+">")
        print ''.join(log).encode('iso-8859-1')

    def ajoute(self, v):
        sv = str(v).strip()
        self.valeur = sv

            
    def afficheHTMLFormWidget(self, identificateur, lignes, colonnes):
        if lignes != 0:
            l = lignes
        else:
            l = 3
        if colonnes != 0:
            c = colonnes
        else:
            c = 45
        n= identificateur+"/"+self.motcle
        print "<select",
        print "class=\"%s\""%self.motcle,
        print "name=\"%s\""%n,
        print ">"
        print "<option value=\"NC\">(Non précisé)</option>"
        for t in self.contenutable.keys():
            print "<option",
            print "value=\"%s\">%s</option>"%(t,self.contenutable[t])
        print "</select>"

#
# Element de type 'basic'
#
class ObjetElementBasic (ObjetElement):
    typecontenu = 'basic'

    def modeleContenu(self):
        print "Le contenu doit-être un élément %s", self.typedebase

    def valide(self):
        return self.element.valide()

    def info(self):
        ObjetElement.info(self)
        print "  typedebase   = '%s'"%self.typedebase
        
    def affiche(self):
        self.element.affiche()
 
    def lisDOM(self, node):
        niveau_validation = 0
        if node.nodeName != self.motcle:
            print "Erreur de lecture: l'element devrait etre un '%s'"%self.motcle
            print "  et non pas un '%s'"%node.nodeName            
            niveau_validation = -1
        nb = 0
        bt = ObjetElementNul()
        for n in node.childNodes:
            if n.nodeName != self.typedebase and n.nodeName != "#text":
                print "Erreur de lecture: l'élément fils de '%s'"%self.motcle
                print "  doit etre de type '%s'"%self.typedebase
                print "  et non pas un '%s'"%n.nodeName
                niveau_validation = -1
                break
            elif n.nodeName == self.typedebase:
                nb = nb + 1
                bt = n
        if nb == 1:
            niveau_validation = self.element.lisDOM(bt)
        else:
            print "Erreur de lecture: il doit y avoir un seul élément '%s'"%self.typedebase
            print " comme élément fils de '%s'"%self.motcle
        return niveau_validation
    
    def __init__(self, motcle, element):
        ObjetElement.__init__(self, motcle)
        self.element = element
        
    def afficheXML(self):
        print("<"+self.motcle+">")        
        self.element.afficheXML()
        print("</"+self.motcle+">")

    def afficheExempleXML(self):
        print("<"+self.motcle+">")        
        self.element.afficheExempleXML()
        print("</"+self.motcle+">")

    def ajoute(self, element):
        self.element = element

#
# Element de type 'any'
#
class ObjetElementAny (ObjetElement):
    typecontenu = 'any'

    def modeleContenu(self):
        print "Le contenu peut-être n'importe quel élément"

    def valide(self):
        return 2

    def lisDOM(self, node):
        niveau_validation = 0
        if len(node.childNodes)>1:
            print "Avertissement: contenu dans un élément <extra...>"
            niveau_validation = -1
        return niveau_validation

    def __init__(self, motcle):
        ObjetElement.__init__(self, motcle)
        
    def afficheXML(self):
        pass

    def afficheExempleXML(self):
        pass

#
# Element de type 'reference'
#
class ObjetElementReference (ObjetElement):
    typecontenu = 'reference'

    def modeleContenu(self):
        print "Le contenu est vide, avec un attribut référençant l'id d'un autre élément."

    def valide(self):
        return 2

    def lisDOM(self, node):
        niveau_validation = 0
        if len(node.childNodes)>1:
            print "Avertissement: utilisation d'un élément 'reference'"
            niveau_validation = -1
        return niveau_validation
    
    def __init__(self, motcle, reference):
        ObjetElement.__init__(self, motcle)
        self.reference = reference
        
    def afficheXML(self):
        print("<"+self.motcle+' ref="%s"/>', self.reference)
        
    def afficheExempleXML(self):
        pass

#
# Element de type 'sequence'
#
class ObjetElementSequence (ObjetElement):
    typecontenu = 'sequence'

    def modeleContenu(self):
        print "Cet objet contient une sequence d'éléments:"
        j = 0
        for i in self.elements:
            if self.options[j] > 0:
                print j, ": <"+i+">*"
            else:
                print j, ": <"+i+">"
            j += 1

    def info(self):
        ObjetElement.info(self)
        j = 0
        for i in self.elements:
            print "  sequence[%d] (%s):"%(j,i),
            print self.sequence[j].motcle
            j += 1
        
    def affiche(self):
        for i in self.sequence:
            i.affiche()
                
    def __init__(self, motcle, elements, options):
        ObjetElement.__init__(self, motcle)
        self.elements = elements
        self.options = options
        self.sequence = []
        
    def afficheXML(self):
        print("<"+self.motcle+">")
        for e in self.sequence:
            e.afficheXML()
        print("</"+self.motcle+">")        

    def afficheExempleXML(self):
        print("<"+self.motcle+">")
        for e in self.sequence:
            e.afficheExempleXML()
        print("</"+self.motcle+">")        

    def valide(self):
        niveau_validation = 2
        for e in self.sequence:
            val = e.valide()
            if val < 2:
                niveau_validation = val
        return niveau_validation

    def lisDOM(self, node):
        niveau_validation = 0
        if node.nodeName != self.motcle:
            print "Erreur de lecture: l'element devrait etre un '%s'"%self.motcle
            print "  et non pas un '%s'"%node.nodeName            
            niveau_validation = -1

        # Calcule le nombre d'éléments obligatoires de la séquence
        nbobli = 0
        for t in self.options:
            if t == 0: nbobli += 1

        # Récupère les éléments de la séquence lus dans le fichier XML
        types = []
        for n in node.childNodes:
            if n.nodeName != "#text":
                types.append(n)
                
        # vérifie qu'il y a au moins le nombre d'éléments obligatoires
        if len(types) < nbobli:
            print "Erreur de lecture: l'element '%s' a %d éléments fils obligatoires"%(self.motcle,nbobli)
            niveau_validation = -1
        # si il y a un nombre "plausible" éléments dans la séquence
        elif len(types) <= len(self.elements):
            # vérifie le type de chaque élément de la séquence
            i = 0 # indice des types
            j = 0 # indices des elements
            while i < len(types) and j < len(self.elements):                
                if types[i].nodeName == self.elements[j]:
                    i = i + 1
                j = j + 1
            if i < len(types):
                print "Erreur de lecture: les elements de la sequence dans '%s'"%self.motcle
                print "  ne sont pas du bon type (i=%d,j=%d)"%(i,j)
                self.modeleContenu()
                niveau_validation = -1
        else:
            print "Erreur de lecture: l'element '%s' a trop d'éléments fils"%(self.motcle)
            niveau_validation = -1
        
        if niveau_validation >= 0:
            i = 0
            while i < len(types):
                n = types[i]
                o = cree_element_objet(n.nodeName)
                v = o.lisDOM(n)
                self.ajoute(o)
                if v < niveau_validation:
                    niveau_validation = v
                i = i + 1
        return niveau_validation

#
# Element de type 'liste'
#
class ObjetElementListe (ObjetElement):
    typecontenu = 'liste'
    
    def modeleContenu(self):
        print "Cet objet contient une liste:"
        print "<%s> [%d,%d]"%(self.typedeliste,self.lgmin,self.lgmax)
        print "La longueur actuelle est de %d objets."%len(self.liste)

    def info(self):
        ObjetElement.info(self)
        print "  longueur     = %d"%len(self.liste)
        print "  typedeliste  = '%s'"%self.typedeliste
        print "  longueur min = %d"%self.lgmin
        print "  longueur max = %d"%self.lgmax
        
    def affiche(self):
        for i in self.liste:
            i.affiche()
    
    def valide(self):
        niveau_validation = 2
        taille_totale = len(self.liste)
        if taille_totale < self.lgmin:            
            print "Erreur de validation"
            print "Élément <%s>: contenu trop court (%d)"%(self.motcle,taille_totale) 
            self.modeleContenu()
            niveau_validation = 0
        elif self.lgmax >= 1 and taille_totale > self.lgmax:
            print "Erreur de validation"
            print "Élément <%s>: contenu trop long (%d)"%(self.motcle,taille_totale) 
            self.modeleContenu()
            niveau_validation = 0
        for e in self.liste:
            val = e.valide()
            if val < 2:
                niveau_validation = val
        return niveau_validation
    
    def __init__(self, motcle, element, typedeliste):
        ObjetElement.__init__(self, motcle)
        self.liste = []
        self.liste.append(element)
        self.typedeliste = typedeliste
        
    def afficheXML(self):
        print("<"+self.motcle+">")
        for e in self.liste:
            e.afficheXML()
        print("</"+self.motcle+">")        

    def afficheExempleXML(self):
        print("<"+self.motcle+">")
        for e in self.liste:
            e.afficheExempleXML()
        print("</"+self.motcle+">")        

    def lisDOM(self, node):
        niveau_validation = 0
        if node.nodeName != self.motcle:
            print "Erreur de lecture: l'element devrait etre un '%s'"%self.motcle
            print "  et non pas un '%s'"%node.nodeName            
            niveau_validation = -1
        l = []
        for n in node.childNodes:
            if n.nodeName != "#text" and n.nodeName != self.typedeliste:
                print "Erreur: l'element devrait etre un '%s'"%self.typedeliste
            elif n.nodeName != "#text":
                l.append(n)
        self.liste = []
        for n in l:
            o = cree_element_objet(self.typedeliste)
            v = o.lisDOM(n)
            self.liste.append(o)
            if v < niveau_validation:
                niveau_validation = v
        return niveau_validation


#
# @element: FOAD
#
class Element_FOAD (ObjetElementCode):
  def __init__(self):    
    self.cercle = '1'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "foad"
    self.lgmin = 1
    self.lgmax = 1
    self.libelle = """Formation en centre ou à distance"""
    self.commentaire = """
	Cet élément contient un code qui indique si la formation se
	déroule en centre ou à distance.
      """
    self.exemple = """0"""
    ObjetElementCode.__init__(self,'FOAD', 'FOAD')
    self.contenutable = {'0' : "formation en centre", '1' : "formation à distance", '2' : "formation en centre et à distance"    }

#
# @element: SIREN
#
class Element_SIREN (ObjetElementNombre):
  def __init__(self):    
    self.glossaire = ""
    self.lgmin = 14
    self.lgmax = 14
    self.libelle = """SIRET"""
    self.commentaire = """
	Cet élément permet de décrire un numéro SIREN (qui ici est un
	SIRET).
      """
    self.exemple = """63445123124916"""
    ObjetElementNombre.__init__(self,'SIREN')

#
# @element: SIREN-formateur
#
class Element_SIREN_formateur (ObjetElementBasic):
  def __init__(self):    
    self.cercle = '2'
    self.atomique = '1'
    self.typedebase = 'SIREN'
    self.base = 'non'
    self.glossaire = "siren"
    self.libelle = """SIRET de l'organisme formateur"""
    self.commentaire = """
	Cet élément permet de préciser le numéro SIRET de l'organisme
	formateur, c'est-à-dire de l'organisme qui assure la
	formation.
      """
    ObjetElementBasic.__init__(self,'SIREN-formateur', Element_SIREN())

#
# @element: SIREN-organisme-formation
#
class Element_SIREN_organisme_formation (ObjetElementBasic):
  def __init__(self):    
    self.cercle = '1'
    self.atomique = '1'
    self.typedebase = 'SIREN'
    self.base = 'non'
    self.glossaire = "siren"
    self.libelle = """Numéro SIREN, SIRET de l'organisme de formation"""
    self.commentaire = """
	Cet élément permet de préciser le numéro SIRET de l'organisme
	responsable de l'offre.
      """
    ObjetElementBasic.__init__(self,'SIREN-organisme-formation', Element_SIREN())

#
# @element: action-formation
#
class Element_action_formation (ObjetElementSequence):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '2'
    self.base = 'non'
    self.glossaire = "action"
    self.libelle = """Action de formation"""
    self.commentaire = """
	Cet élément permet de décrire une action de formation.
      """
    ObjetElementSequence.__init__(self,'action-formation', ['domaine-formation', 'intitule-action', 'objectif-formation', 'resultats-attendus', 'contenu-formation', 'diplomante', 'public-vise', 'sexe-public-vise', 'age-public-vise', 'rythme-formation', 'duree-indicative', 'contact-offre', 'statut-public-vise', 'objectif-general-formation', 'extras-action-formation'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2])
    self.sequence = [ Element_domaine_formation(), Element_intitule_action(), Element_objectif_formation(), Element_resultats_attendus(), Element_contenu_formation(), Element_diplomante(), Element_public_vise(), Element_sexe_public_vise(), Element_age_public_vise(), Element_rythme_formation(), Element_duree_indicative(), Element_contact_offre(), ObjetElementNul(), ObjetElementNul(), ObjetElementNul() ]

  def ajoute(self, element):
    if isinstance(element, Element_domaine_formation):
      self.sequence[0] = element
    elif isinstance(element, Element_intitule_action):
      self.sequence[1] = element
    elif isinstance(element, Element_objectif_formation):
      self.sequence[2] = element
    elif isinstance(element, Element_resultats_attendus):
      self.sequence[3] = element
    elif isinstance(element, Element_contenu_formation):
      self.sequence[4] = element
    elif isinstance(element, Element_diplomante):
      self.sequence[5] = element
    elif isinstance(element, Element_public_vise):
      self.sequence[6] = element
    elif isinstance(element, Element_sexe_public_vise):
      self.sequence[7] = element
    elif isinstance(element, Element_age_public_vise):
      self.sequence[8] = element
    elif isinstance(element, Element_rythme_formation):
      self.sequence[9] = element
    elif isinstance(element, Element_duree_indicative):
      self.sequence[10] = element
    elif isinstance(element, Element_contact_offre):
      self.sequence[11] = element
    elif isinstance(element, Element_statut_public_vise):
      self.sequence[12] = element
    elif isinstance(element, Element_objectif_general_formation):
      self.sequence[13] = element
    elif isinstance(element, Element_extras_action_formation):
      self.sequence[14] = element
    else:
        print "Erreur d'ajout, élément du mauvais type."
	self.modeleContenu()

#
# @element: adresse
#
class Element_adresse (ObjetElementSequence):
  def __init__(self):    
    self.glossaire = ""
    self.libelle = """Adresse"""
    self.commentaire = """Cet élément contient une adresse postale "stricte",
      c'est-à-dire que l'adresse doit être complète (sauf la région et
      la pays qui sont optionnels)."""
    ObjetElementSequence.__init__(self,'adresse', ['lignesad', 'codepostal', 'ville', 'departement', 'code-INSEE-commune', 'region', 'pays'], [0, 0, 0, 0, 1, 1, 1])
    self.sequence = [ Element_lignesad(), Element_codepostal(), Element_ville(), Element_departement(), ObjetElementNul(), ObjetElementNul(), ObjetElementNul() ]

  def ajoute(self, element):
    if isinstance(element, Element_lignesad):
      self.sequence[0] = element
    elif isinstance(element, Element_codepostal):
      self.sequence[1] = element
    elif isinstance(element, Element_ville):
      self.sequence[2] = element
    elif isinstance(element, Element_departement):
      self.sequence[3] = element
    elif isinstance(element, Element_code_INSEE_commune):
      self.sequence[4] = element
    elif isinstance(element, Element_region):
      self.sequence[5] = element
    elif isinstance(element, Element_pays):
      self.sequence[6] = element
    else:
        print "Erreur d'ajout, élément du mauvais type."
	self.modeleContenu()

#
# @element: adresse-inscription
#
class Element_adresse_inscription (ObjetElementBasic):
  def __init__(self):    
    self.cercle = '1'
    self.atomique = '1'
    self.typedebase = 'adresse'
    self.base = 'non'
    self.glossaire = "lieu-date-inscription"
    self.libelle = """Adresse d'information et d'inscription"""
    self.commentaire = """
	Cet élément permet d'indiquer l'adresse où se déroule
	l'inscription à la formation.
      """
    ObjetElementBasic.__init__(self,'adresse-inscription', Element_adresse())

#
# @element: age
#
class Element_age (ObjetElementTexte):
  def __init__(self):    
    self.cercle = '1'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "age"
    self.lgmin = 1
    self.lgmax = 50
    self.libelle = """Âge"""
    self.commentaire = """
	Cet élément indique une tranche d'âge à laquelle s'adresse la
	formation.
      """
    self.exemple = """De 16 à 25 ans."""
    ObjetElementTexte.__init__(self,'age')

#
# @element: age-public-vise
#
class Element_age_public_vise (ObjetElementCode):
  def __init__(self):    
    self.cercle = '1'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "public-vise"
    self.lgmin = 1
    self.lgmax = 1
    self.libelle = """Âge du public visé"""
    self.commentaire = """
	Cet élément permet de coder l'âge du public visé par la
	formation (indifférent, plus de 26 ans, 26 ans et moins).
      """
    self.exemple = """0"""
    ObjetElementCode.__init__(self,'age-public-vise', 'age-public-vise')
    self.contenutable = {'0' : "Indifférent", '1' : "Supérieur à 26 ans", '2' : "26 ans et moins"    }

#
# @element: canal
#
class Element_canal (ObjetElementSequence):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.base = 'non'
    self.glossaire = ""
    ObjetElementSequence.__init__(self,'canal', ['urlweb'], [0])
    self.sequence = [ Element_urlweb() ]

  def ajoute(self, element):
    if isinstance(element, Element_urlweb):
      self.sequence[0] = element
    else:
        print "Erreur d'ajout, élément du mauvais type."
	self.modeleContenu()

#
# @element: code-FORMACODE
#
class Element_code_FORMACODE (ObjetElementCode):
  def __init__(self):    
    self.glossaire = ""
    self.lgmin = 5
    self.lgmax = 5
    self.libelle = """Code FORMACODE"""
    self.commentaire = """Code FORMACODE pour décrire le domaine de formation."""
    self.exemple = """22477"""
    ObjetElementCode.__init__(self,'code-FORMACODE', 'FORMACODE')
    self.contenutable = {'46278' : "PHOTOGRAPHIE", '42079' : "SERVICE MAISON", '21295' : "ENGIN FORESTIER", '21223' : "VITICULTURE", '21258' : "CULTURE LEGUMIERE", '21056' : "ELEVAGE", '42077' : "CASINO", '42050' : "COIFFURE", '43485' : "ASSISTANCE DENTAIRE", '42837' : "POLICE GENDARMERIE"    }

#
# @element: code-INSEE-commune
#
class Element_code_INSEE_commune (ObjetElementNombre):
  def __init__(self):    
    self.glossaire = ""
    self.lgmin = 5
    self.lgmax = 5
    self.libelle = """Code commune INSEE"""
    self.commentaire = """
	Cet élément contient un code INSEE de commune. Validation:
	vérifier l'adéquation entre l'élément 'ville', le contenu
	de l'élément 'codepostal' et le contenu de cet élément.
      """
    self.exemple = """77000"""
    ObjetElementNombre.__init__(self,'code-INSEE-commune')

#
# @element: code-NSF
#
class Element_code_NSF (ObjetElementCode):
  def __init__(self):    
    self.glossaire = ""
    self.lgmin = 3
    self.lgmax = 3
    self.libelle = """Code NSF"""
    self.commentaire = """Code NSF pour décrire le domaine de formation."""
    self.exemple = """100"""
    ObjetElementCode.__init__(self,'code-NSF', 'NSF')
    self.contenutable = {'100' : "Formations générales", '114' : "Mathématiques", '133' : "Musique, arts du spectacle", '227' : "Énergie, génie climatique", '242' : "Habillement", '253' : "Mécanique aéronautique et spatiale", '321' : "Journalisme et communication", '334' : "Accueil, hôtellerie, tourisme", '324' : "Secrétariat, bureautique", '323' : "Techniques de l'image et du son"    }

#
# @element: code-ROME
#
class Element_code_ROME (ObjetElementCode):
  def __init__(self):    
    self.glossaire = ""
    self.lgmin = 5
    self.lgmax = 5
    self.libelle = """Code ROME"""
    self.commentaire = """Code ROME pour décrire le domaine de formation."""
    self.exemple = """21131"""
    ObjetElementCode.__init__(self,'code-ROME', 'ROME')
    self.contenutable = {'21131' : "PHOTOGRAPHE", '12121' : "AGENT ADMINISTRATIF D'ENTREPRISE", '14225' : "VENDEUR EN PX CULTURELS ET LUDIQUES", '32214' : "SPECIALISTE DE LA GESTION DE L'INFORMATION", '32311' : "INFORMATICIEN D'EXPLOITATION", '32321' : "INFORMATICIEN D'ETUDE", '32331' : "INFORMATICIEN EXPERT", '32341' : "ORGANISATEUR INFORMATICIEN", '44213' : "INTERCONNECTEUR EN ELECTRONIQUE"    }

#
# @element: code-financeur
#
class Element_code_financeur (ObjetElementCode):
  def __init__(self):    
    self.cercle = '2'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "organisme-financeur"
    self.lgmin = 1
    self.lgmax = 1
    self.libelle = """Code organisme financeur"""
    self.commentaire = """
	Cet élément contient le code d'un organisme financeur de la
	table correspondante.
      """
    self.exemple = """2"""
    ObjetElementCode.__init__(self,'code-financeur', 'financeurs')
    self.contenutable = {'0' : "Autres", '1' : "État", '2' : "Conseil régional", '3' : "FSE", '4' : "UNÉDIC", '5' : "Entreprise", '6' : "FAS", '7' : "AGEFIPH"    }

#
# @element: code-niveau-entree
#
class Element_code_niveau_entree (ObjetElementCode):
  def __init__(self):    
    self.cercle = '1'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "niveau-entree"
    self.lgmin = 1
    self.lgmax = 1
    self.libelle = """Statut du niveau à l'entrée en formation"""
    self.commentaire = """
	Cet élément permet de dire si le niveau à l'entrée en
	formation décrit dans l'élément 'niveau-entree' est exigé
	ou souhaité.
      """
    self.exemple = """1"""
    ObjetElementCode.__init__(self,'code-niveau-entree', 'code-niveau-entree')
    self.contenutable = {'0' : "Niveau exigé", '1' : "Niveau souhaité"    }

#
# @element: code-perimetre-recrutement
#
class Element_code_perimetre_recrutement (ObjetElementCode):
  def __init__(self):    
    self.cercle = '2'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "perimetre-recrutement"
    self.lgmin = 1
    self.lgmax = 1
    self.libelle = """Périmètre de recrutement"""
    self.commentaire = """
	Cet élément indique un code issu de la table correspondante
	pour le périmètre de recrutement.
      """
    self.exemple = """3"""
    ObjetElementCode.__init__(self,'code-perimetre-recrutement', 'perimetre-recrutement')
    self.contenutable = {'0' : "Autres", '1' : "Commune", '2' : "Département", '3' : "Région", '4' : "Interrégion", '5' : "Pays", '6' : "International"    }

#
# @element: code-public-vise
#
class Element_code_public_vise (ObjetElementCode):
  def __init__(self):    
    self.glossaire = ""
    self.lgmin = 5
    self.lgmax = 5
    self.libelle = """Code public visé"""
    self.commentaire = """
	Cet élément contient un code issu de la table correspondante
	et indiquant le public visé par la formation.
	Ce code partage les deux derniers chiffres avec le code des
	publics que l'on peut trouver dans le FORMACODE.
      """
    self.exemple = """20037"""
    ObjetElementCode.__init__(self,'code-public-vise', 'code-public-vise-formacode')
    self.contenutable = {'20003' : "agent de l'état et des collectivités locales", '20001' : "agent de l'hospitalisation publique", '20002' : "agent de maîtrise", '20055' : "agent de la fonction publique", '20004' : "artisan, salarié de l'artisanat", '00099' : "autre public ", '00005' : "bas niveau de qualification", '20006' : "cadre d'entreprise", '20009' : "commerçant, salarié du commerce", '20010' : "consultant ", '10011' : "demandeur d'emploi", '10012' : "demandeur d'emploi longue durée", '00013' : "détenu", '00014' : "élu local", '20015' : "employé", '20016' : "enseignant", '20017' : "exploitant agricole, salarié agricole", '02018' : "femme", '20019' : "formateur", '00020' : "handicapé", '00021' : "illetré", '00022' : "immigré", '00050' : "individuel", '00000' : "information non communiquée", '20023' : "ingénieur, cadre technique", '20051' : "intermittent du spectacle", '00224' : "jeune 16-25 ans", '10225' : "jeune demandeur d'emploi (16-25 ans)", '20252' : "jeune en alternance", '20226' : "jeune sous contrat d'adaptation ", '20227' : "jeune sous contrat d'apprentissage ", '20229' : "jeune sous contrat de qualification ", '20228' : "jeune sous contrat d'orientation", '10030' : "licencié pour motif économique", '20031' : "médecin du travail", '20032' : "ouvrier", '20033' : "ouvrier qualifié", '20034' : "policier et militaire", '20036' : "profession de la santé et du travail social", '20035' : "profession de l'information", '20037' : "profession des arts et du spectacle", '00038' : "profession libérale", '20039' : "profession scientifique, chercheur", '00040' : "public dépendant des services sociaux", '00041' : "public DOM-TOM", '10058' : "public en emploi", '20059' : "public sans emploi", '10042' : "réfugié", '20043' : "représentant du personnel", '20044' : "salarié", '20045' : "salarié en reconversion", '20057' : "salarié sous contrat accès à l'emploi (DOM-TOM)", '20047' : "salarié sous contrat de travail particulier", '20048' : "salarié sous contrat initiative emploi", '20049' : "technicien", '00056' : "tout public"    }

#
# @element: codeinsee-lieu-de-formation
#
class Element_codeinsee_lieu_de_formation (ObjetElementBasic):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.typedebase = 'code-INSEE-commune'
    self.base = 'non'
    self.glossaire = ""
    ObjetElementBasic.__init__(self,'codeinsee-lieu-de-formation', Element_code_INSEE_commune())

#
# @element: codepostal
#
class Element_codepostal (ObjetElementNombre):
  def __init__(self):    
    self.glossaire = ""
    self.lgmin = 5
    self.lgmax = 5
    self.libelle = """Code postal"""
    self.commentaire = """
	Cet élément contient un code postal. Validation: vérifier
	l'adéquation entre l'élément 'ville' et le contenu de
	l'élément 'codepostal'.
      """
    self.exemple = """68110"""
    ObjetElementNombre.__init__(self,'codepostal')

#
# @element: codes-FORMACODE
#
class Element_codes_FORMACODE (ObjetElementListe):
  def __init__(self):    
    self.glossaire = ""
    self.lgmin = 1
    self.lgmax = 5
    self.libelle = """Liste de codes FORMACODE"""
    self.commentaire = """
	Liste de codes FORMACODE.
      """
    ObjetElementListe.__init__(self,'codes-FORMACODE', Element_code_FORMACODE(), 'code-FORMACODE')

  def ajoute(self, element):
    if isinstance(element, Element_code_FORMACODE):
        self.liste.append(element)
    else:
        print "Erreur d'ajout, élément du mauvais type."

#
# @element: codes-NSF
#
class Element_codes_NSF (ObjetElementListe):
  def __init__(self):    
    self.glossaire = ""
    self.lgmin = 1
    self.lgmax = 3
    self.libelle = """Liste de codes NSF"""
    self.commentaire = """
	Liste de codes NSF.
      """
    ObjetElementListe.__init__(self,'codes-NSF', Element_code_NSF(), 'code-NSF')

  def ajoute(self, element):
    if isinstance(element, Element_code_NSF):
        self.liste.append(element)
    else:
        print "Erreur d'ajout, élément du mauvais type."

#
# @element: codes-ROME
#
class Element_codes_ROME (ObjetElementListe):
  def __init__(self):    
    self.glossaire = ""
    self.lgmin = 1
    self.lgmax = 5
    self.libelle = """Liste de codes ROME"""
    self.commentaire = """
	Liste de codes ROME.
      """
    ObjetElementListe.__init__(self,'codes-ROME', Element_code_ROME(), 'code-ROME')

  def ajoute(self, element):
    if isinstance(element, Element_code_ROME):
        self.liste.append(element)
    else:
        print "Erreur d'ajout, élément du mauvais type."

#
# @element: conditions-administratives
#
class Element_conditions_administratives (ObjetElementSequence):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '2'
    self.base = 'non'
    self.glossaire = ""
    self.libelle = """Conditions administratives"""
    self.commentaire = """
	Cet élément décrit les conditions d'admissions administratives de
	l'offre de formation.
      """
    ObjetElementSequence.__init__(self,'conditions-administratives', ['age', 'prise-en-charge-frais-possible', 'remuneration-possible', 'extras-conditions-administratives'], [0, 0, 0, 2])
    self.sequence = [ Element_age(), Element_prise_en_charge_frais_possible(), Element_remuneration_possible(), ObjetElementNul() ]

  def ajoute(self, element):
    if isinstance(element, Element_age):
      self.sequence[0] = element
    elif isinstance(element, Element_prise_en_charge_frais_possible):
      self.sequence[1] = element
    elif isinstance(element, Element_remuneration_possible):
      self.sequence[2] = element
    elif isinstance(element, Element_extras_conditions_administratives):
      self.sequence[3] = element
    else:
        print "Erreur d'ajout, élément du mauvais type."
	self.modeleContenu()

#
# @element: conditions-pedagogiques
#
class Element_conditions_pedagogiques (ObjetElementSequence):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '2'
    self.base = 'non'
    self.glossaire = "conditions-pedagogiques"
    self.libelle = """Conditions pédagogiques"""
    self.commentaire = """
	Cet élément décrit les conditions d'admissions pédagogiques de
	l'offre de formation.
      """
    ObjetElementSequence.__init__(self,'conditions-pedagogiques', ['code-niveau-entree', 'niveau-entree', 'modalite-alternance', 'FOAD', 'conditions-specifiques', 'extras-conditions-pedagogiques'], [0, 0, 0, 0, 0, 2])
    self.sequence = [ Element_code_niveau_entree(), Element_niveau_entree(), Element_modalite_alternance(), Element_FOAD(), Element_conditions_specifiques(), ObjetElementNul() ]

  def ajoute(self, element):
    if isinstance(element, Element_code_niveau_entree):
      self.sequence[0] = element
    elif isinstance(element, Element_niveau_entree):
      self.sequence[1] = element
    elif isinstance(element, Element_modalite_alternance):
      self.sequence[2] = element
    elif isinstance(element, Element_FOAD):
      self.sequence[3] = element
    elif isinstance(element, Element_conditions_specifiques):
      self.sequence[4] = element
    elif isinstance(element, Element_extras_conditions_pedagogiques):
      self.sequence[5] = element
    else:
        print "Erreur d'ajout, élément du mauvais type."
	self.modeleContenu()

#
# @element: conditions-specifiques
#
class Element_conditions_specifiques (ObjetElementTexte):
  def __init__(self):    
    self.cercle = '1'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "conditions-specifiques"
    self.lgmin = 1
    self.lgmax = 300
    self.libelle = """Conditions spécifiques"""
    self.commentaire = """
	Cet élément indique les conditions spécifiques d'accès à la
	formation, les aptitudes requises, etc.
      """
    self.exemple = """Savoir se servir d'un appareil photo."""
    ObjetElementTexte.__init__(self,'conditions-specifiques')

#
# @element: contact-offre
#
class Element_contact_offre (ObjetElementBasic):
  def __init__(self):    
    self.cercle = '1'
    self.atomique = '1'
    self.typedebase = 'coordonnees-libres'
    self.base = 'non'
    self.glossaire = "contact-offre"
    self.libelle = """Contact de l'action de formation"""
    self.commentaire = """
	Cet élément permet de donner les coordonnées (typiquement un
	nom, avec une adresse ou un numéro de téléphone, une adresse
	de courrier électronique, etc.) d'une personne pouvant donner
	des renseignements sur l'action de formation. Cette personne
	peut être la même que celle précisée dans l'élément
	'contact-organisme'.
      """
    ObjetElementBasic.__init__(self,'contact-offre', Element_coordonnees_libres())

#
# @element: contact-organisme
#
class Element_contact_organisme (ObjetElementBasic):
  def __init__(self):    
    self.cercle = '1'
    self.atomique = '1'
    self.typedebase = 'coordonnees-libres'
    self.base = 'non'
    self.glossaire = "contact-organisme"
    self.libelle = """Contact avec l'organisme"""
    self.commentaire = """
	Cet élément permet de donner les coordonnées (typiquement un
	nom, avec une adresse ou un numéro de téléphone, une adresse
	de courrier électronique, etc.) d'une personne de l'organisme
	responsable de l'offre à contacter.
      """
    ObjetElementBasic.__init__(self,'contact-organisme', Element_coordonnees_libres())

#
# @element: contenu-formation
#
class Element_contenu_formation (ObjetElementTexte):
  def __init__(self):    
    self.cercle = '1'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "contenu-formation"
    self.lgmin = 1
    self.lgmax = 3000
    self.libelle = """Contenu de la formation"""
    self.commentaire = """
	Cet élément décrit le contenu de la formation.
      """
    self.exemple = """Apprendre les techniques de prises de vues.
      Choisir et fabriquer une mise en scène.
      Maîtriser les éclairages et les couleurs.
      Effectuer des travaux de développements et d'agrandissements.
    """
    ObjetElementTexte.__init__(self,'contenu-formation')

#
# @element: conventionnement-possible
#
class Element_conventionnement_possible (ObjetElementCode):
  def __init__(self):    
    self.cercle = '2'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "conventionnement-possible"
    self.lgmin = 1
    self.lgmax = 1
    self.libelle = """Possibilité de conventionnement"""
    self.commentaire = """
	Cet élément contient un code indiquant si un conventionnement
	est possible ou non.
      """
    self.exemple = """1"""
    ObjetElementCode.__init__(self,'conventionnement-possible', 'boolean')
    self.contenutable = {'0' : "non", '1' : "oui"    }

#
# @element: coordonnees
#
class Element_coordonnees (ObjetElementSequence):
  def __init__(self):    
    self.glossaire = ""
    self.libelle = """Coordonnées"""
    self.commentaire = """Cet élément contient des coordonnées "strictes", c'est-à-dire
      que l'adresse doit être définie."""
    ObjetElementSequence.__init__(self,'coordonnees', ['lignesco', 'adresse', 'telfixe', 'portable', 'fax', 'courriel', 'web'], [0, 0, 1, 1, 1, 1, 1])
    self.sequence = [ Element_lignesco(), Element_adresse(), ObjetElementNul(), ObjetElementNul(), ObjetElementNul(), ObjetElementNul(), ObjetElementNul() ]

  def ajoute(self, element):
    if isinstance(element, Element_lignesco):
      self.sequence[0] = element
    elif isinstance(element, Element_adresse):
      self.sequence[1] = element
    elif isinstance(element, Element_telfixe):
      self.sequence[2] = element
    elif isinstance(element, Element_portable):
      self.sequence[3] = element
    elif isinstance(element, Element_fax):
      self.sequence[4] = element
    elif isinstance(element, Element_courriel):
      self.sequence[5] = element
    elif isinstance(element, Element_web):
      self.sequence[6] = element
    else:
        print "Erreur d'ajout, élément du mauvais type."
	self.modeleContenu()

#
# @element: coordonnees-libres
#
class Element_coordonnees_libres (ObjetElementSequence):
  def __init__(self):    
    self.glossaire = ""
    self.libelle = """Coordonnées libres"""
    self.commentaire = """Cet élément contient des coordonnées "libres", c'est-à-dire
      que l'adresse peut ne pas être définie."""
    ObjetElementSequence.__init__(self,'coordonnees-libres', ['lignesco', 'adresse', 'telfixe', 'portable', 'fax', 'courriel', 'web'], [0, 1, 1, 1, 1, 1, 1])
    self.sequence = [ Element_lignesco(), ObjetElementNul(), ObjetElementNul(), ObjetElementNul(), ObjetElementNul(), ObjetElementNul(), ObjetElementNul() ]

  def ajoute(self, element):
    if isinstance(element, Element_lignesco):
      self.sequence[0] = element
    elif isinstance(element, Element_adresse):
      self.sequence[1] = element
    elif isinstance(element, Element_telfixe):
      self.sequence[2] = element
    elif isinstance(element, Element_portable):
      self.sequence[3] = element
    elif isinstance(element, Element_fax):
      self.sequence[4] = element
    elif isinstance(element, Element_courriel):
      self.sequence[5] = element
    elif isinstance(element, Element_web):
      self.sequence[6] = element
    else:
        print "Erreur d'ajout, élément du mauvais type."
	self.modeleContenu()

#
# @element: coordonnees-organisme
#
class Element_coordonnees_organisme (ObjetElementBasic):
  def __init__(self):    
    self.cercle = '1'
    self.atomique = '1'
    self.typedebase = 'coordonnees'
    self.base = 'non'
    self.glossaire = "coordonnees-organisme"
    self.libelle = """Coordonnées de l'organisme"""
    self.commentaire = """
	Cet élément permet de donner les coordonnées les coordonnées
	complètes de l'organisme responsable de l'offre.
      """
    ObjetElementBasic.__init__(self,'coordonnees-organisme', Element_coordonnees())

#
# @element: courriel
#
class Element_courriel (ObjetElementTexte):
  def __init__(self):    
    self.glossaire = ""
    self.lgmin = 3
    self.lgmax = 60
    self.libelle = """Courriel"""
    self.commentaire = """Cet élément contient une adresse de courrier
      électronique."""
    self.exemple = """shrdlu@laposte.net"""
    ObjetElementTexte.__init__(self,'courriel')

#
# @element: date
#
class Element_date (ObjetElementDate):
  def __init__(self):    
    self.glossaire = ""
    self.lgmin = 8
    self.lgmax = 8
    self.libelle = """Date"""
    self.commentaire = """
	Indique une date sous la forme 'JJMMAAAA' où
	'JJ' sont les deux chiffres du jour du mois,
	'MM' sont les deux chiffres du mois et 'AAAA'
	sont les quatre chiffres de l'année.
      """
    self.exemple = """21062004"""
    ObjetElementDate.__init__(self,'date')

#
# @element: date-inscription
#
class Element_date_inscription (ObjetElementBasic):
  def __init__(self):    
    self.cercle = '1'
    self.atomique = '1'
    self.typedebase = 'date'
    self.base = 'non'
    self.glossaire = "lieu-date-inscription"
    self.libelle = """Date d'information et d'inscription"""
    self.commentaire = """
	Cet élément permet d'indiquer la date d'inscription à
	la formation.
      """
    ObjetElementBasic.__init__(self,'date-inscription', Element_date())

#
# @element: date-limite-inscription
#
class Element_date_limite_inscription (ObjetElementBasic):
  def __init__(self):    
    self.cercle = '2'
    self.atomique = '1'
    self.typedebase = 'date'
    self.base = 'non'
    self.glossaire = "date-limite-inscription"
    self.libelle = """Date limite d'inscription"""
    self.commentaire = """
	Cet élément permet de préciser la date limite d'inscription à
	la formation.
      """
    ObjetElementBasic.__init__(self,'date-limite-inscription', Element_date())

#
# @element: dates-debut-fin-stage
#
class Element_dates_debut_fin_stage (ObjetElementTexte):
  def __init__(self):    
    self.cercle = '1'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "dates-debut-fin-stage"
    self.lgmin = 1
    self.lgmax = 150
    self.libelle = """Dates prévues de début et de fin de stage"""
    self.commentaire = """
	Cet élément permet de lister les différentes sessions de
	formation en format libre.
      """
    self.exemple = """De septembre à juin."""
    ObjetElementTexte.__init__(self,'dates-debut-fin-stage')

#
# @element: deb
#
class Element_deb (ObjetElementDate):
  def __init__(self):    
    self.glossaire = ""
    self.lgmin = 8
    self.lgmax = 8
    self.libelle = """Début"""
    self.commentaire = """
	Cet élément permet d'indiquer une date de départ sous la forme
	'JJMMAAAA' où 'JJ' sont les deux chiffres du
	jour du mois, 'MM' sont les deux chiffres du mois et
	'AAAA' sont les quatre chiffres de l'année.
      """
    self.exemple = """21062004"""
    ObjetElementDate.__init__(self,'deb')

#
# @element: departement
#
class Element_departement (ObjetElementCode):
  def __init__(self):    
    self.glossaire = ""
    self.lgmin = 1
    self.lgmax = 3
    self.libelle = """Département"""
    self.commentaire = """
	Cet élément contient un numéro de département.
      """
    self.exemple = """68"""
    ObjetElementCode.__init__(self,'departement', 'departements-france')
    self.contenutable = {'1' : "Ain", '01' : "Ain", '001' : "Ain", '2' : "Aisne", '02' : "Aisne", '002' : "Aisne", '3' : "Allier", '03' : "Allier", '003' : "Allier", '4' : "Alpes de Haute-Provence", '04' : "Alpes de Haute-Provence", '004' : "Alpes de Haute-Provence", '5' : "Hautes-Alpes", '05' : "Hautes-Alpes", '005' : "Hautes-Alpes", '6' : "Alpes-Maritimes", '06' : "Alpes-Maritimes", '006' : "Alpes-Maritimes", '7' : "Ardèche", '07' : "Ardèche", '007' : "Ardèche", '8' : "Ardennes", '08' : "Ardennes", '008' : "Ardennes", '9' : "Ariège", '09' : "Ariège", '009' : "Ariège", '10' : "Aube", '010' : "Aube", '11' : "Aude", '011' : "Aude", '12' : "Aveyron", '012' : "Aveyron", '13' : "Bouches-du-Rhône", '013' : "Bouches-du-Rhône", '14' : "Calvados", '014' : "Calvados", '15' : "Cantal", '015' : "Cantal", '16' : "Charente", '016' : "Charente", '17' : "Charente-Maritime", '017' : "Charente-Maritime", '18' : "Cher", '018' : "Cher", '19' : "Corrèze", '019' : "Corrèze", '20' : "Corse", '020' : "Corse", '21' : "Côte-d'Or", '021' : "Côte-d'Or", '22' : "Côtes-d'Armor", '022' : "Côtes-d'Armor", '23' : "Creuse", '023' : "Creuse", '24' : "Dordogne", '024' : "Dordogne", '25' : "Doubs", '025' : "Doubs", '26' : "Drôme", '026' : "Drôme", '27' : "Eure", '027' : "Eure", '28' : "Eure-et-Loir", '028' : "Eure-et-Loir", '29' : "Finistère", '029' : "Finistère", '30' : "Gard", '030' : "Gard", '31' : "Haute-Garonne", '031' : "Haute-Garonne", '32' : "Gers", '032' : "Gers", '33' : "Gironde", '033' : "Gironde", '34' : "Hérault", '034' : "Hérault", '35' : "Ille-et-Vilaine", '035' : "Ille-et-Vilaine", '36' : "Indre", '036' : "Indre", '37' : "Indre-et-Loire", '037' : "Indre-et-Loire", '38' : "Isère", '038' : "Isère", '39' : "Jura", '039' : "Jura", '40' : "Landes", '040' : "Landes", '41' : "Loir-et-Cher", '041' : "Loir-et-Cher", '42' : "Loire", '042' : "Loire", '43' : "Haute-Loire", '043' : "Haute-Loire", '44' : "Loire-Atlantique", '044' : "Loire-Atlantique", '45' : "Loiret", '045' : "Loiret", '46' : "Lot", '046' : "Lot", '47' : "Lot-et-Garonne", '047' : "Lot-et-Garonne", '48' : "Lozère", '048' : "Lozère", '49' : "Maine-et-Loire", '049' : "Maine-et-Loire", '50' : "Manche", '050' : "Manche", '51' : "Marne", '051' : "Marne", '52' : "Haute-Marne", '052' : "Haute-Marne", '53' : "Mayenne", '053' : "Mayenne", '54' : "Meurthe-et-Moselle", '054' : "Meurthe-et-Moselle", '55' : "Meuse", '055' : "Meuse", '56' : "Morbihan", '056' : "Morbihan", '57' : "Moselle", '057' : "Moselle", '58' : "Nièvre", '058' : "Nièvre", '59' : "Nord", '059' : "Nord", '60' : "Oise", '060' : "Oise", '61' : "Orne", '061' : "Orne", '62' : "Pas-de-Calais", '062' : "Pas-de-Calais", '63' : "Puy-de-Dôme", '063' : "Puy-de-Dôme", '64' : "Pyrénées-Atlantiques", '064' : "Pyrénées-Atlantiques", '65' : "Hautes-Pyrénées", '065' : "Hautes-Pyrénées", '66' : "Pyrénées-Orientales", '066' : "Pyrénées-Orientales", '67' : "Bas-Rhin", '067' : "Bas-Rhin", '68' : "Haut-Rhin", '068' : "Haut-Rhin", '69' : "Rhône", '069' : "Rhône", '70' : "Haute-Saône", '070' : "Haute-Saône", '71' : "Saône-et-Loire", '071' : "Saône-et-Loire", '72' : "Sarthe", '072' : "Sarthe", '73' : "Savoie", '073' : "Savoie", '74' : "Haute-Savoie", '074' : "Haute-Savoie", '75' : "Paris", '075' : "Paris", '76' : "Seine-Maritime", '076' : "Seine-Maritime", '77' : "Seine-et-Marne", '077' : "Seine-et-Marne", '78' : "Yvelines", '078' : "Yvelines", '79' : "Deux-Sèvres", '079' : "Deux-Sèvres", '80' : "Somme", '080' : "Somme", '81' : "Tarn", '081' : "Tarn", '82' : "Tarn-et-Garonne", '082' : "Tarn-et-Garonne", '83' : "Var", '083' : "Var", '84' : "Vaucluse", '084' : "Vaucluse", '85' : "Vendée", '085' : "Vendée", '86' : "Vienne", '086' : "Vienne", '87' : "Haute-Vienne", '087' : "Haute-Vienne", '88' : "Vosges", '088' : "Vosges", '89' : "Yonne", '089' : "Yonne", '90' : "Territoire de Belfort", '090' : "Territoire de Belfort", '91' : "Essonne", '091' : "Essonne", '92' : "Hauts-de-Seine", '092' : "Hauts-de-Seine", '93' : "Seine-Saint-Denis", '093' : "Seine-Saint-Denis", '94' : "Val-de-Marne", '094' : "Val-de-Marne", '95' : "Val-d'Oise", '095' : "Val-d'Oise", '971' : "Guadeloupe", '972' : "Martinique", '973' : "Guyane", '974' : "Réunion", '975' : "Saint-Pierre-et-Miquelon", '976' : "Mayotte"    }

#
# @element: departement-lieu-de-formation
#
class Element_departement_lieu_de_formation (ObjetElementBasic):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.typedebase = 'departement'
    self.base = 'non'
    self.glossaire = ""
    ObjetElementBasic.__init__(self,'departement-lieu-de-formation', Element_departement())

#
# @element: detail-conditions-prise-en-charge
#
class Element_detail_conditions_prise_en_charge (ObjetElementTexte):
  def __init__(self):    
    self.cercle = '2'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "detail-conditions"
    self.lgmin = 1
    self.lgmax = 600
    self.libelle = """Détails des conditions de prise en charge"""
    self.commentaire = """
	Cet élément permet d'indiquer les conditions particulières de
	prise en charge: homologation Assedic, existence d'agréments
	(nombre, public, durée), etc.
      """
    self.exemple = """Homologation Assedic."""
    ObjetElementTexte.__init__(self,'detail-conditions-prise-en-charge')

#
# @element: diplomante
#
class Element_diplomante (ObjetElementCode):
  def __init__(self):    
    self.cercle = '1'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "diplome"
    self.lgmin = 1
    self.lgmax = 1
    self.libelle = """Formation diplômante"""
    self.commentaire = """
	Cet élément indique si la formation est diplomante ou
	non. Validation: si la formation est diplomante, on devrait
	retrouver dans l'intitulé de l'action (élément
	'intitule-action') ou les résultats attendus (élément
	'resultats-attendus') la description d'un diplôme.
      """
    self.exemple = """1"""
    ObjetElementCode.__init__(self,'diplomante', 'boolean')
    self.contenutable = {'0' : "non", '1' : "oui"    }

#
# @element: domaine-formation
#
class Element_domaine_formation (ObjetElementSequence):
  def __init__(self):    
    self.cercle = '1'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "domaine-formation"
    self.libelle = """Domaine de la formation"""
    self.commentaire = """
	Cet élément liste les codes décrivant le domaine de la formation.
      """
    ObjetElementSequence.__init__(self,'domaine-formation', ['codes-NSF', 'codes-FORMACODE', 'codes-ROME', 'extras-domaine-formation'], [1, 1, 1, 2])
    self.sequence = [ ObjetElementNul(), ObjetElementNul(), ObjetElementNul(), ObjetElementNul() ]

  def ajoute(self, element):
    if isinstance(element, Element_codes_NSF):
      self.sequence[0] = element
    elif isinstance(element, Element_codes_FORMACODE):
      self.sequence[1] = element
    elif isinstance(element, Element_codes_ROME):
      self.sequence[2] = element
    elif isinstance(element, Element_extras_domaine_formation):
      self.sequence[3] = element
    else:
        print "Erreur d'ajout, élément du mauvais type."
	self.modeleContenu()

#
# @element: duree-conventionnee
#
class Element_duree_conventionnee (ObjetElementNombre):
  def __init__(self):    
    self.cercle = '2'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "duree-conventionnee"
    self.lgmin = 1
    self.lgmax = 5
    self.libelle = """Durée du conventionnement"""
    self.commentaire = """
	Cet élément contient le nombre d'heures conventionnées.
      """
    self.exemple = """160"""
    ObjetElementNombre.__init__(self,'duree-conventionnee')

#
# @element: duree-indicative
#
class Element_duree_indicative (ObjetElementTexte):
  def __init__(self):    
    self.cercle = '1'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "duree-indicative"
    self.lgmin = 1
    self.lgmax = 50
    self.libelle = """Durée indicative"""
    self.commentaire = """
	Cet élément permet de donner la durée indicative moyenne de la
	formation pour le stagiaire.
      """
    self.exemple = """2 ans"""
    ObjetElementTexte.__init__(self,'duree-indicative')

#
# @element: extras-action-formation
#
class Element_extras_action_formation (ObjetElementAny):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.base = 'non'
    self.glossaire = ""
    self.commentaire = """
	Informations supplémentaires communes à la définition d'une
	action de formation particulière.
      """
    ObjetElementAny.__init__(self,'extras-action-formation')

#
# @element: extras-conditions-administratives
#
class Element_extras_conditions_administratives (ObjetElementAny):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.base = 'non'
    self.glossaire = ""
    self.commentaire = """
	Informations supplémentaires pour la définition des éléments
	liés aux conditions administratives d'une offre de formation
	particulière.
      """
    ObjetElementAny.__init__(self,'extras-conditions-administratives')

#
# @element: extras-conditions-pedagogiques
#
class Element_extras_conditions_pedagogiques (ObjetElementAny):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.base = 'non'
    self.glossaire = ""
    self.commentaire = """
	Informations supplémentaires pour la définition des
	éléments liés aux conditions pédagogiques d'une offre de formation
	particulière.
      """
    ObjetElementAny.__init__(self,'extras-conditions-pedagogiques')

#
# @element: extras-domaine-formation
#
class Element_extras_domaine_formation (ObjetElementAny):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.base = 'non'
    self.glossaire = ""
    self.commentaire = """
	Informations supplémentaires pour la définition des éléments
	liés à la définition du domaine de formation pour une offre de
	formation particulière.
      """
    ObjetElementAny.__init__(self,'extras-domaine-formation')

#
# @element: extras-lieu-date-inscription
#
class Element_extras_lieu_date_inscription (ObjetElementAny):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.base = 'non'
    self.glossaire = ""
    self.commentaire = """
	Informations supplémentaires pour la définition des éléments
	liés aux lieux et dates d'inscription à une offre de formation
	particulière.
      """
    ObjetElementAny.__init__(self,'extras-lieu-date-inscription')

#
# @element: extras-modalites-acces
#
class Element_extras_modalites_acces (ObjetElementAny):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.base = 'non'
    self.glossaire = ""
    self.commentaire = """
	Informations supplémentaires pour la définition des éléments
	liés aux conditions administratives d'une offre de formation
	particulière.
      """
    ObjetElementAny.__init__(self,'extras-modalites-acces')

#
# @element: extras-offre-formation
#
class Element_extras_offre_formation (ObjetElementAny):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.base = 'non'
    self.glossaire = ""
    self.libelle = """Données libres sur une offre"""
    self.commentaire = """
	Informations supplémentaires communes à la définition d'une
	offre de formation particulière.
      """
    ObjetElementAny.__init__(self,'extras-offre-formation')

#
# @element: extras-offres
#
class Element_extras_offres (ObjetElementAny):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.base = 'non'
    self.glossaire = ""
    self.libelle = """Données libres sur les offres"""
    self.commentaire = """
	Informations supplémentaires communes à toutes les offres de
	formation.
	Cet élément peut contenir un ou plusieurs autres éléments
	définis dans une DTD utilisant LHEO.
      """
    ObjetElementAny.__init__(self,'extras-offres')

#
# @element: extras-organisation-administrative
#
class Element_extras_organisation_administrative (ObjetElementAny):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.base = 'non'
    self.glossaire = ""
    self.commentaire = """
	Informations supplémentaires pour la définition des
	éléments liés à l'organisation administrative d'une offre de formation
	particulière.
      """
    ObjetElementAny.__init__(self,'extras-organisation-administrative')

#
# @element: extras-organisation-formation
#
class Element_extras_organisation_formation (ObjetElementAny):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.base = 'non'
    self.glossaire = ""
    self.commentaire = """
	Informations supplémentaires communes à la définition des
	éléments liés à l'organisation pour une offre de formation
	particulière.
      """
    ObjetElementAny.__init__(self,'extras-organisation-formation')

#
# @element: extras-organisation-materielle
#
class Element_extras_organisation_materielle (ObjetElementAny):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.base = 'non'
    self.glossaire = ""
    self.commentaire = """
	Informations supplémentaires pour la définition des
	éléments liés à l'organisation matérielle d'une offre de formation
	particulière.
      """
    ObjetElementAny.__init__(self,'extras-organisation-materielle')

#
# @element: extras-organisation-pedagogique
#
class Element_extras_organisation_pedagogique (ObjetElementAny):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.base = 'non'
    self.glossaire = ""
    self.commentaire = """
	Informations supplémentaires pour la définition des
	éléments liés à l'organisation pédagogique d'une offre de formation
	particulière.
      """
    ObjetElementAny.__init__(self,'extras-organisation-pedagogique')

#
# @element: extras-organisme-formateur
#
class Element_extras_organisme_formateur (ObjetElementAny):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.base = 'non'
    self.glossaire = ""
    self.commentaire = """
	Informations supplémentaires pour la définition des éléments
	liés à l'organisme formateur d'une pour une offre de formation
	particulière.
      """
    ObjetElementAny.__init__(self,'extras-organisme-formateur')

#
# @element: extras-organisme-formation-responsable
#
class Element_extras_organisme_formation_responsable (ObjetElementAny):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.base = 'non'
    self.glossaire = ""
    self.commentaire = """
	Informations supplémentaires pour la définition des éléments
	liés à l'organisme de formation responsable d'une ou de
	plusieurs offres de formation.
      """
    ObjetElementAny.__init__(self,'extras-organisme-formation-responsable')

#
# @element: extras-organismes
#
class Element_extras_organismes (ObjetElementAny):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.base = 'non'
    self.glossaire = ""
    self.commentaire = """
	Informations supplémentaires pour la définition des éléments
	liés aux organismes participant à une offre de formation
	particulière.
      """
    ObjetElementAny.__init__(self,'extras-organismes')

#
# @element: fax
#
class Element_fax (ObjetElementListe):
  def __init__(self):    
    self.glossaire = ""
    self.lgmin = 1
    self.lgmax = 3
    self.libelle = """Fax"""
    self.commentaire = """Cet élément contient une liste de numéros de FAX."""
    ObjetElementListe.__init__(self,'fax', Element_numtel(), 'numtel')

  def ajoute(self, element):
    if isinstance(element, Element_numtel):
        self.liste.append(element)
    else:
        print "Erreur d'ajout, élément du mauvais type."

#
# @element: fin
#
class Element_fin (ObjetElementDate):
  def __init__(self):    
    self.glossaire = ""
    self.lgmin = 8
    self.lgmax = 8
    self.libelle = """Fin"""
    self.commentaire = """
	Indique une date de fin sous la forme 'JJMMAAAA' où
	'JJ' sont les deux chiffres du jour du mois,
	'MM' sont les deux chiffres du mois et 'AAAA'
	sont les quatre chiffres de l'année.
      """
    self.exemple = """21062004"""
    ObjetElementDate.__init__(self,'fin')

#
# @element: infos-perimetre-recrutement
#
class Element_infos_perimetre_recrutement (ObjetElementTexte):
  def __init__(self):    
    self.cercle = '2'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "perimetre-recrutement"
    self.lgmin = 0
    self.lgmax = 50
    self.libelle = """Informations supplémentaires sur le périmètre de recrutement"""
    self.commentaire = """
	Cet élément permet de donner des informations supplémentaires
	par rapport à l'élément 'code-perimetre-recrutement' sur
	le périmètre de recrutement. Cet élément est surtout utile
	dans le cas où le code du périmètre de recrutement est égal à
	la valeur "Autres", puisqu'il permet de préciser une
	information non présente dans la table.
      """
    self.exemple = """Canton de Bray."""
    ObjetElementTexte.__init__(self,'infos-perimetre-recrutement')

#
# @element: intitule-action
#
class Element_intitule_action (ObjetElementTexte):
  def __init__(self):    
    self.cercle = '1'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "intitule-action"
    self.lgmin = 1
    self.lgmax = 255
    self.nomenclature = """référence aux tables de l'Éducation nationale pour
    les diplômes et au RNCP pour les titres
    professionnels"""
    self.libelle = """Intitulé de l'action ou de la certification préparée"""
    self.commentaire = """
	Cet élément décrit l'intitulé de l'action ou la certification
	préparée. Si c'est un diplôme, faire référence aux tables de
	l'éducation nationale. Si c'est un titre, faire référence au
	RNCP.
      """
    self.exemple = """CAP Photographe"""
    ObjetElementTexte.__init__(self,'intitule-action')

#
# @element: lheo
#
class Element_lheo (ObjetElementSequence):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.base = 'non'
    self.glossaire = ""
    self.libelle = """Offres de formation en LHÉO/XML"""
    self.commentaire = """
	Élément racine d'un document XML au format LHÉO.
      """
    ObjetElementSequence.__init__(self,'lheo', ['offres', 'extras-offres'], [0, 2])
    self.sequence = [ Element_offres(), ObjetElementNul() ]

  def ajoute(self, element):
    if isinstance(element, Element_offres):
      self.sequence[0] = element
    elif isinstance(element, Element_extras_offres):
      self.sequence[1] = element
    else:
        print "Erreur d'ajout, élément du mauvais type."
	self.modeleContenu()

#
# @element: lheo-leger
#
class Element_lheo_leger (ObjetElementSequence):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.base = 'non'
    self.glossaire = ""
    self.commentaire = """
	Le nombre maximal d'offres renvoyées pour une requête dans le
	cadre d'une requête est limitée à 100.
      """
    ObjetElementSequence.__init__(self,'lheo-leger', ['canal', 'resumes', 'nombre-offres'], [0, 0, 0])
    self.sequence = [ Element_canal(), Element_resumes(), Element_nombre_offres() ]

  def ajoute(self, element):
    if isinstance(element, Element_canal):
      self.sequence[0] = element
    elif isinstance(element, Element_resumes):
      self.sequence[1] = element
    elif isinstance(element, Element_nombre_offres):
      self.sequence[2] = element
    else:
        print "Erreur d'ajout, élément du mauvais type."
	self.modeleContenu()

#
# @element: lheo-requete
#
class Element_lheo_requete (ObjetElementSequence):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.base = 'non'
    self.glossaire = ""
    self.libelle = """Requête permettant d'effectuer une recherche sur des offres"""
    self.commentaire = """
	Cet élément permet de modéliser une requête dans une base
	d'offres en LHÉO/XML ou une base d'offres résumées en
	LHÉO-LÉGER/XML. L'élément 'nombre-offres' permet d'indiquer le
	nombre maximal d'offres à retourner. Par rapport aux niveaux de
	validation LHÉO/XML, certains champs de cette requête en
	LHÉO-REQUÊTE peuvent être vides. Les éléments
	'prise-en-charge-frais-possible' (1),
	'departement-lieu-de-formation' (2) et 'diplomante' (3)
	doivent correspondre exactement aux champs correspondant dans
	une offre ou un résumé d'offre. Pour la recherche, on fait un
	ET de ces trois premiers critères (uniquement pour ceux qui ne
	sont pas vides). Pour les deux éléments 'codes-FORMACODE' (4)
	et 'codes-ROME' (5), on fait un OU des différents codes
	présents. On fait ensuite un ET avec les éléments précédents.
	Les quatre éléments 'intitule-action' (6),
	'resultats-attendus' (7), 'ville-lieu-de-formation' (8) et
	'nom-organisme' (9) peuvent contenir des caractères (3 au
	minimum) qui seront recherchés dans les offres ou les résumés
	d'offres.  La formule complète est donc (1) ET (2) ET (3) ET
	((4) OU (5)) ET (6) ET (7) ET (8) ET (9). Au moins un des
	éléments doit être non nul.
      """
    ObjetElementSequence.__init__(self,'lheo-requete', ['nombre-offres', 'codes-FORMACODE', 'codes-ROME', 'prise-en-charge-frais-possible', 'departement-lieu-de-formation', 'diplomante', 'intitule-action', 'resultats-attendus', 'ville-lieu-de-formation', 'nom-organisme'], [0, 1, 1, 1, 1, 1, 1, 1, 1, 1])
    self.sequence = [ Element_nombre_offres(), ObjetElementNul(), ObjetElementNul(), ObjetElementNul(), ObjetElementNul(), ObjetElementNul(), ObjetElementNul(), ObjetElementNul(), ObjetElementNul(), ObjetElementNul() ]

  def ajoute(self, element):
    if isinstance(element, Element_nombre_offres):
      self.sequence[0] = element
    elif isinstance(element, Element_codes_FORMACODE):
      self.sequence[1] = element
    elif isinstance(element, Element_codes_ROME):
      self.sequence[2] = element
    elif isinstance(element, Element_prise_en_charge_frais_possible):
      self.sequence[3] = element
    elif isinstance(element, Element_departement_lieu_de_formation):
      self.sequence[4] = element
    elif isinstance(element, Element_diplomante):
      self.sequence[5] = element
    elif isinstance(element, Element_intitule_action):
      self.sequence[6] = element
    elif isinstance(element, Element_resultats_attendus):
      self.sequence[7] = element
    elif isinstance(element, Element_ville_lieu_de_formation):
      self.sequence[8] = element
    elif isinstance(element, Element_nom_organisme):
      self.sequence[9] = element
    else:
        print "Erreur d'ajout, élément du mauvais type."
	self.modeleContenu()

#
# @element: lieu-date-inscription
#
class Element_lieu_date_inscription (ObjetElementSequence):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.base = 'non'
    self.glossaire = ""
    self.libelle = """Lieu et date d'inscription"""
    self.commentaire = """
	Cet élément décrit le lieu et la date d'information et d'inscription à la formation.
      """
    ObjetElementSequence.__init__(self,'lieu-date-inscription', ['adresse-inscription', 'date-inscription', 'extras-lieu-date-inscription'], [0, 0, 2])
    self.sequence = [ Element_adresse_inscription(), Element_date_inscription(), ObjetElementNul() ]

  def ajoute(self, element):
    if isinstance(element, Element_adresse_inscription):
      self.sequence[0] = element
    elif isinstance(element, Element_date_inscription):
      self.sequence[1] = element
    elif isinstance(element, Element_extras_lieu_date_inscription):
      self.sequence[2] = element
    else:
        print "Erreur d'ajout, élément du mauvais type."
	self.modeleContenu()

#
# @element: lieu-de-formation
#
class Element_lieu_de_formation (ObjetElementBasic):
  def __init__(self):    
    self.cercle = '1'
    self.atomique = '1'
    self.typedebase = 'coordonnees'
    self.base = 'non'
    self.glossaire = "lieu-formation"
    self.libelle = """Lieu de la formation"""
    self.commentaire = """
	Cet élément permet de donner le lieu où se déroule la
	formation.
      """
    ObjetElementBasic.__init__(self,'lieu-de-formation', Element_coordonnees())

#
# @element: lignead
#
class Element_lignead (ObjetElementTexte):
  def __init__(self):    
    self.glossaire = ""
    self.lgmin = 1
    self.lgmax = 60
    self.libelle = """Ligne d'adresse"""
    self.commentaire = """
	Cet élément contient une ligne de texte pour une
	adresse. Typiquement, un nom et un numéro de rue.
      """
    self.exemple = """23, rue du petit bois"""
    ObjetElementTexte.__init__(self,'lignead')

#
# @element: ligneco
#
class Element_ligneco (ObjetElementTexte):
  def __init__(self):    
    self.glossaire = ""
    self.lgmin = 1
    self.lgmax = 50
    self.libelle = """Ligne de coordonnées"""
    self.commentaire = """
	Cet élément contient une ligne de texte pour des coordonnées.
	Typiquement, un nom de personne ou d'établissement.
      """
    self.exemple = """Centre de formation"""
    ObjetElementTexte.__init__(self,'ligneco')

#
# @element: lignesad
#
class Element_lignesad (ObjetElementListe):
  def __init__(self):    
    self.glossaire = ""
    self.lgmin = 1
    self.lgmax = 4
    self.libelle = """Lignes d'adresse"""
    self.commentaire = """
	Cet élément contient une liste de lignes de texte pour une adresse.
      """
    ObjetElementListe.__init__(self,'lignesad', Element_lignead(), 'lignead')

  def ajoute(self, element):
    if isinstance(element, Element_lignead):
        self.liste.append(element)
    else:
        print "Erreur d'ajout, élément du mauvais type."

#
# @element: lignesco
#
class Element_lignesco (ObjetElementListe):
  def __init__(self):    
    self.glossaire = ""
    self.lgmin = 1
    self.lgmax = 4
    self.libelle = """Lignes de coordonnées"""
    self.commentaire = """
	Cet élément contient une liste de lignes de texte pour une adresse.
      """
    ObjetElementListe.__init__(self,'lignesco', Element_ligneco(), 'ligneco')

  def ajoute(self, element):
    if isinstance(element, Element_ligneco):
        self.liste.append(element)
    else:
        print "Erreur d'ajout, élément du mauvais type."

#
# @element: modalite-alternance
#
class Element_modalite_alternance (ObjetElementTexte):
  def __init__(self):    
    self.cercle = '1'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "modalites-alternance"
    self.lgmin = 1
    self.lgmax = 150
    self.libelle = """Modalité de l'alternance"""
    self.commentaire = """
	Cet élément permet de préciser les dates et la durée des
	périodes en centre ou en entreprise.
      """
    self.exemple = """Aprentissage"""
    ObjetElementTexte.__init__(self,'modalite-alternance')

#
# @element: modalite-entrees-sorties
#
class Element_modalite_entrees_sorties (ObjetElementCode):
  def __init__(self):    
    self.cercle = '1'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "modalite-entrees-sorties"
    self.lgmin = 1
    self.lgmax = 1
    self.libelle = """Dates fixes ou entrées/sorties permanentes ?"""
    self.commentaire = """
	Cet élément contient un code permettant de dire si la
	formation est à dates fixes ou avec des entrées/sorties
	permanentes.
      """
    self.exemple = """0"""
    ObjetElementCode.__init__(self,'modalite-entrees-sorties', 'modalites-es')
    self.contenutable = {'0' : "entrées/sorties à dates fixes", '1' : "entrées/sorties permanentes"    }

#
# @element: modalites-acces
#
class Element_modalites_acces (ObjetElementSequence):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '2'
    self.base = 'non'
    self.glossaire = ""
    self.libelle = """Modalités d'accès"""
    self.commentaire = """
	Cet élément permet de préciser tout ce qui est lié aux
	modalités d'accès et aux modalités temporelles d'une offre de
	formation.
      """
    ObjetElementSequence.__init__(self,'modalites-acces', ['lieu-de-formation', 'modalite-entrees-sorties', 'lieu-date-inscription', 'sessions', 'dates-debut-fin-stage', 'extras-modalites-acces'], [0, 0, 0, 1, 1, 2])
    self.sequence = [ Element_lieu_de_formation(), Element_modalite_entrees_sorties(), Element_lieu_date_inscription(), ObjetElementNul(), ObjetElementNul(), ObjetElementNul() ]

  def ajoute(self, element):
    if isinstance(element, Element_lieu_de_formation):
      self.sequence[0] = element
    elif isinstance(element, Element_modalite_entrees_sorties):
      self.sequence[1] = element
    elif isinstance(element, Element_lieu_date_inscription):
      self.sequence[2] = element
    elif isinstance(element, Element_sessions):
      self.sequence[3] = element
    elif isinstance(element, Element_dates_debut_fin_stage):
      self.sequence[4] = element
    elif isinstance(element, Element_extras_modalites_acces):
      self.sequence[5] = element
    else:
        print "Erreur d'ajout, élément du mauvais type."
	self.modeleContenu()

#
# @element: modalites-pedagogiques
#
class Element_modalites_pedagogiques (ObjetElementTexte):
  def __init__(self):    
    self.cercle = '2'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "modalites-pedagogiques"
    self.lgmin = 0
    self.lgmax = 200
    self.libelle = """Modalités pédagogiques"""
    self.commentaire = """
	Cet élément permet de préciser les modalités pédagogiques,
	dont l'individualisation de la formation.
      """
    self.exemple = """Individualisation de la formation."""
    ObjetElementTexte.__init__(self,'modalites-pedagogiques')

#
# @element: modalites-recrutement
#
class Element_modalites_recrutement (ObjetElementTexte):
  def __init__(self):    
    self.cercle = '2'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "modalites-recrutement"
    self.lgmin = 0
    self.lgmax = 100
    self.libelle = """Modalités de recrutement"""
    self.commentaire = """
	Cet élément permet de préciser les modalités de recrutement et
	d'admission (tests, entretiens).
      """
    self.exemple = """Entretien."""
    ObjetElementTexte.__init__(self,'modalites-recrutement')

#
# @element: niveau-entree
#
class Element_niveau_entree (ObjetElementTexte):
  def __init__(self):    
    self.cercle = '1'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "niveau-entree"
    self.lgmin = 1
    self.lgmax = 100
    self.libelle = """Niveau à l'entrée en formation"""
    self.commentaire = """
	Cet élément permet de décrire le niveau à l'entrée en
	formation et/ou l'expérience professionnelle. Ce niveau peut
	être souhaité ou exigé en fonction de la valeur du code
	contenu dans l'élément 'code-niveau-entree'.
      """
    self.exemple = """Niveau VI - Fin de scolarité obligatoire"""
    ObjetElementTexte.__init__(self,'niveau-entree')

#
# @element: nom-organisme
#
class Element_nom_organisme (ObjetElementTexte):
  def __init__(self):    
    self.cercle = '1'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "nom-organisme"
    self.lgmin = 1
    self.lgmax = 250
    self.libelle = """Nom de l'organisme de formation"""
    self.commentaire = """
	Cet élément décrit le nom usuel de l'organisme responsable de
	la formation.
      """
    self.exemple = """Centre de formation d'apprentis académique (CFA)"""
    ObjetElementTexte.__init__(self,'nom-organisme')

#
# @element: nombre-heures-totales
#
class Element_nombre_heures_totales (ObjetElementNombre):
  def __init__(self):    
    self.cercle = '2'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "prix-total"
    self.lgmin = 1
    self.lgmax = 5
    self.libelle = """Nombre d'heures totales"""
    self.commentaire = """
	Cet élément permet d'indiquer en heures la durée totale de la
	formation.
      """
    self.exemple = """320"""
    ObjetElementNombre.__init__(self,'nombre-heures-totales')

#
# @element: nombre-offres
#
class Element_nombre_offres (ObjetElementNombre):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.base = 'non'
    self.glossaire = ""
    self.lgmin = 1
    self.lgmax = 5
    self.libelle = """Nombre de résumés d'offres de formation"""
    ObjetElementNombre.__init__(self,'nombre-offres')

#
# @element: numero-activite
#
class Element_numero_activite (ObjetElementNombre):
  def __init__(self):    
    self.cercle = '1'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "numero-activite"
    self.lgmin = 11
    self.lgmax = 11
    self.libelle = """Numéro de déclaration d'activité"""
    self.commentaire = """
	Cet élément permet de préciser le numéro de déclaration
	d'activité de l'organisme responsable de l'offre.
      """
    self.exemple = """64194292762"""
    ObjetElementNombre.__init__(self,'numero-activite')

#
# @element: numtel
#
class Element_numtel (ObjetElementTexte):
  def __init__(self):    
    self.glossaire = ""
    self.lgmin = 1
    self.lgmax = 25
    self.libelle = """Numéro de téléphone"""
    self.commentaire = """
	Cet élément contient les chiffres d'un numéro de téléphone,
	avec éventuellement un '+', des parenthèses et des
	blancs.
      """
    self.exemple = """01 64 69 48 36"""
    ObjetElementTexte.__init__(self,'numtel')

#
# @element: objectif-formation
#
class Element_objectif_formation (ObjetElementTexte):
  def __init__(self):    
    self.cercle = '1'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "objectif-formation"
    self.lgmin = 1
    self.lgmax = 3000
    self.libelle = """Objectif de formation"""
    self.commentaire = """
	Cet élément décrit l'objectif de la formation.
      """
    self.exemple = """Effectuer des travaux de prises de vue (photos d'identité,
      travaux de reportage, prises de vue d'un objet technique en 3
      dimensions, prises de vue publicitaires type catalogue...) et
      les travaux de laboratoire : tirage en noir et blanc ou en
      couleur."""
    ObjetElementTexte.__init__(self,'objectif-formation')

#
# @element: objectif-formation-resume
#
class Element_objectif_formation_resume (ObjetElementTexte):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "objectif-formation"
    self.lgmin = 1
    self.lgmax = 300
    self.libelle = """Objectif de formation résumé"""
    self.commentaire = """
	Cet élément décrit l'objectif de la formation.
      """
    ObjetElementTexte.__init__(self,'objectif-formation-resume')

#
# @element: objectif-general-formation
#
class Element_objectif_general_formation (ObjetElementCode):
  def __init__(self):    
    self.cercle = '2'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "objectif-general-formation"
    self.lgmin = 1
    self.lgmax = 1
    self.libelle = """Objectif général de la formation (liste fermée AIS)"""
    self.commentaire = """
	Cet élément contient un code d'une table qui indique
	l'objectif général de la formation. Correspond à la table ANPE
	utilisée pour l'AIS (Attestation d'Inscription à un Stage).
      """
    self.exemple = """1"""
    ObjetElementCode.__init__(self,'objectif-general-formation', 'AIS')
    self.contenutable = {'1' : "Qualification", '2' : "Perfectionnement", '3' : "Élargissement de compétences", '4' : "Création d'entreprises", '5' : "Remise à niveau"    }

#
# @element: offre-formation
#
class Element_offre_formation (ObjetElementSequence):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.base = 'non'
    self.glossaire = ""
    self.libelle = """Offre de formation"""
    self.commentaire = """
	Cet élément contient tous les renseignements du cercle 1 et du
	cercle 2 et décrit une action de formation, tous les aspects
	organisationnels de cette formation et enfin, les organismes liés
	à cette formation.
      """
    ObjetElementSequence.__init__(self,'offre-formation', ['action-formation', 'organisation-formation', 'organismes', 'extras-offre-formation'], [0, 0, 0, 2])
    self.sequence = [ Element_action_formation(), Element_organisation_formation(), Element_organismes(), ObjetElementNul() ]

  def ajoute(self, element):
    if isinstance(element, Element_action_formation):
      self.sequence[0] = element
    elif isinstance(element, Element_organisation_formation):
      self.sequence[1] = element
    elif isinstance(element, Element_organismes):
      self.sequence[2] = element
    elif isinstance(element, Element_extras_offre_formation):
      self.sequence[3] = element
    else:
        print "Erreur d'ajout, élément du mauvais type."
	self.modeleContenu()

#
# @element: offre-html
#
class Element_offre_html (ObjetElementBasic):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.typedebase = 'urlweb'
    self.base = 'non'
    self.glossaire = ""
    ObjetElementBasic.__init__(self,'offre-html', Element_urlweb())

#
# @element: offre-xml
#
class Element_offre_xml (ObjetElementBasic):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.typedebase = 'urlweb'
    self.base = 'non'
    self.glossaire = ""
    ObjetElementBasic.__init__(self,'offre-xml', Element_urlweb())

#
# @element: offres
#
class Element_offres (ObjetElementListe):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.base = 'non'
    self.glossaire = ""
    self.lgmin = 1
    self.lgmax = -1
    self.libelle = """Liste d'offres de formation"""
    self.commentaire = """
	Élément contenant un liste d'offres de formation.
      """
    ObjetElementListe.__init__(self,'offres', Element_offre_formation(), 'offre-formation')

  def ajoute(self, element):
    if isinstance(element, Element_offre_formation):
        self.liste.append(element)
    else:
        print "Erreur d'ajout, élément du mauvais type."

#
# @element: organisation-administrative
#
class Element_organisation_administrative (ObjetElementSequence):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.base = 'non'
    self.glossaire = ""
    self.libelle = """Organisation administrative"""
    self.commentaire = """
	Cet élément décrit les aspects administratifs de l'offre de
	formation.
      """
    ObjetElementSequence.__init__(self,'organisation-administrative', ['code-perimetre-recrutement', 'infos-perimetre-recrutement', 'prix-horaire-TTC', 'nombre-heures-totales', 'detail-conditions-prise-en-charge', 'conventionnement-possible', 'duree-conventionnee', 'date-limite-inscription', 'extras-organisation-administrative'], [1, 1, 1, 1, 1, 1, 1, 1, 2])
    self.sequence = [ ObjetElementNul(), ObjetElementNul(), ObjetElementNul(), ObjetElementNul(), ObjetElementNul(), ObjetElementNul(), ObjetElementNul(), ObjetElementNul(), ObjetElementNul() ]

  def ajoute(self, element):
    if isinstance(element, Element_code_perimetre_recrutement):
      self.sequence[0] = element
    elif isinstance(element, Element_infos_perimetre_recrutement):
      self.sequence[1] = element
    elif isinstance(element, Element_prix_horaire_TTC):
      self.sequence[2] = element
    elif isinstance(element, Element_nombre_heures_totales):
      self.sequence[3] = element
    elif isinstance(element, Element_detail_conditions_prise_en_charge):
      self.sequence[4] = element
    elif isinstance(element, Element_conventionnement_possible):
      self.sequence[5] = element
    elif isinstance(element, Element_duree_conventionnee):
      self.sequence[6] = element
    elif isinstance(element, Element_date_limite_inscription):
      self.sequence[7] = element
    elif isinstance(element, Element_extras_organisation_administrative):
      self.sequence[8] = element
    else:
        print "Erreur d'ajout, élément du mauvais type."
	self.modeleContenu()

#
# @element: organisation-formation
#
class Element_organisation_formation (ObjetElementSequence):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.base = 'non'
    self.glossaire = "organisation-formation"
    self.libelle = """Organisation de la formation"""
    self.commentaire = """
	Cet élément regroupe tous les éléments décrivant les aspects liés
	à l'organisation de la formation: conditions d'admission,
	organisation pédagogique, administrative et matérielle.
      """
    ObjetElementSequence.__init__(self,'organisation-formation', ['conditions-pedagogiques', 'conditions-administratives', 'modalites-acces', 'organisation-pedagogique', 'organisation-administrative', 'organisation-materielle', 'extras-organisation-formation'], [0, 0, 0, 1, 1, 1, 2])
    self.sequence = [ Element_conditions_pedagogiques(), Element_conditions_administratives(), Element_modalites_acces(), ObjetElementNul(), ObjetElementNul(), ObjetElementNul(), ObjetElementNul() ]

  def ajoute(self, element):
    if isinstance(element, Element_conditions_pedagogiques):
      self.sequence[0] = element
    elif isinstance(element, Element_conditions_administratives):
      self.sequence[1] = element
    elif isinstance(element, Element_modalites_acces):
      self.sequence[2] = element
    elif isinstance(element, Element_organisation_pedagogique):
      self.sequence[3] = element
    elif isinstance(element, Element_organisation_administrative):
      self.sequence[4] = element
    elif isinstance(element, Element_organisation_materielle):
      self.sequence[5] = element
    elif isinstance(element, Element_extras_organisation_formation):
      self.sequence[6] = element
    else:
        print "Erreur d'ajout, élément du mauvais type."
	self.modeleContenu()

#
# @element: organisation-materielle
#
class Element_organisation_materielle (ObjetElementSequence):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.base = 'non'
    self.glossaire = "organisation-materielle"
    self.libelle = """Organisation matérielle"""
    self.commentaire = """
	Cet élément décrit les aspects matériels de l'offre de formation.
      """
    ObjetElementSequence.__init__(self,'organisation-materielle', ['restauration-hebergement-transport', 'extras-organisation-materielle'], [1, 2])
    self.sequence = [ ObjetElementNul(), ObjetElementNul() ]

  def ajoute(self, element):
    if isinstance(element, Element_restauration_hebergement_transport):
      self.sequence[0] = element
    elif isinstance(element, Element_extras_organisation_materielle):
      self.sequence[1] = element
    else:
        print "Erreur d'ajout, élément du mauvais type."
	self.modeleContenu()

#
# @element: organisation-pedagogique
#
class Element_organisation_pedagogique (ObjetElementSequence):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.base = 'non'
    self.glossaire = ""
    self.libelle = """Organisation pédagogique"""
    self.commentaire = """
	Cet élément décrit les aspects pédagogiques de l'offre de
	formation.
      """
    ObjetElementSequence.__init__(self,'organisation-pedagogique', ['modalites-recrutement', 'modalites-pedagogiques', 'extras-organisation-pedagogique'], [1, 1, 2])
    self.sequence = [ ObjetElementNul(), ObjetElementNul(), ObjetElementNul() ]

  def ajoute(self, element):
    if isinstance(element, Element_modalites_recrutement):
      self.sequence[0] = element
    elif isinstance(element, Element_modalites_pedagogiques):
      self.sequence[1] = element
    elif isinstance(element, Element_extras_organisation_pedagogique):
      self.sequence[2] = element
    else:
        print "Erreur d'ajout, élément du mauvais type."
	self.modeleContenu()

#
# @element: organisme-formateur
#
class Element_organisme_formateur (ObjetElementSequence):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '2'
    self.base = 'non'
    self.glossaire = "organisme-formateur"
    self.libelle = """Organisme formateur"""
    self.commentaire = """
	Cet élément décrit l'organisme formateur.
      """
    ObjetElementSequence.__init__(self,'organisme-formateur', ['SIREN-formateur', 'raison-sociale-formateur', 'extras-organisme-formateur'], [0, 0, 2])
    self.sequence = [ Element_SIREN_formateur(), Element_raison_sociale_formateur(), ObjetElementNul() ]

  def ajoute(self, element):
    if isinstance(element, Element_SIREN_formateur):
      self.sequence[0] = element
    elif isinstance(element, Element_raison_sociale_formateur):
      self.sequence[1] = element
    elif isinstance(element, Element_extras_organisme_formateur):
      self.sequence[2] = element
    else:
        print "Erreur d'ajout, élément du mauvais type."
	self.modeleContenu()

#
# @element: organisme-formation-responsable
#
class Element_organisme_formation_responsable (ObjetElementSequence):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '2'
    self.externalisable = 'ref-organisme-formation-responsable'
    self.base = 'non'
    self.glossaire = "organisme-responsable"
    self.libelle = """Organisme de formation responsable"""
    self.commentaire = """
	Cet élément décrit l'organisme de formation responsable de la
	formation. Le contenu de cet élément (la séquence) peut être
	remplacé par une référence (élément
	'ref-organisme-formation-responsable') à un organisme de
	formation décrit à un autre endroit du document XML LHEO (par
	exemple sous un élément 'info').  Validation: il faut que
	l'organisme référencé soit présent dans le fichier.
      """
    ObjetElementSequence.__init__(self,'organisme-formation-responsable', ['numero-activite', 'SIREN-organisme-formation', 'nom-organisme', 'raison-sociale', 'coordonnees-organisme', 'contact-organisme', 'renseignements-specifiques', 'extras-organisme-formation-responsable'], [0, 0, 0, 0, 0, 0, 1, 2])
    self.sequence = [ Element_numero_activite(), Element_SIREN_organisme_formation(), Element_nom_organisme(), Element_raison_sociale(), Element_coordonnees_organisme(), Element_contact_organisme(), ObjetElementNul(), ObjetElementNul() ]

  def ajoute(self, element):
    if isinstance(element, Element_numero_activite):
      self.sequence[0] = element
    elif isinstance(element, Element_SIREN_organisme_formation):
      self.sequence[1] = element
    elif isinstance(element, Element_nom_organisme):
      self.sequence[2] = element
    elif isinstance(element, Element_raison_sociale):
      self.sequence[3] = element
    elif isinstance(element, Element_coordonnees_organisme):
      self.sequence[4] = element
    elif isinstance(element, Element_contact_organisme):
      self.sequence[5] = element
    elif isinstance(element, Element_renseignements_specifiques):
      self.sequence[6] = element
    elif isinstance(element, Element_extras_organisme_formation_responsable):
      self.sequence[7] = element
    else:
        print "Erreur d'ajout, élément du mauvais type."
	self.modeleContenu()

#
# @element: organismes
#
class Element_organismes (ObjetElementSequence):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.base = 'non'
    self.glossaire = ""
    self.libelle = """Organismes"""
    self.commentaire = """
	Cet élément décrit les organismes liés à la formation. Les
	éléments optionnels sont dans le cercle 2. L'élément
	'extras-organismes' est du cercle 3.
      """
    ObjetElementSequence.__init__(self,'organismes', ['organisme-formation-responsable', 'organisme-formateur', 'organismes-financeurs', 'extras-organismes'], [0, 1, 1, 2])
    self.sequence = [ Element_organisme_formation_responsable(), ObjetElementNul(), ObjetElementNul(), ObjetElementNul() ]

  def ajoute(self, element):
    if isinstance(element, Element_organisme_formation_responsable):
      self.sequence[0] = element
    elif isinstance(element, Element_organisme_formateur):
      self.sequence[1] = element
    elif isinstance(element, Element_organismes_financeurs):
      self.sequence[2] = element
    elif isinstance(element, Element_extras_organismes):
      self.sequence[3] = element
    else:
        print "Erreur d'ajout, élément du mauvais type."
	self.modeleContenu()

#
# @element: organismes-financeurs
#
class Element_organismes_financeurs (ObjetElementListe):
  def __init__(self):    
    self.cercle = '2'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "organisme-financeur"
    self.lgmin = 1
    self.lgmax = 8
    self.libelle = """Organismes financeurs"""
    self.commentaire = """
	Cet élément liste les codes des financeurs de la formation, par
	ordre décroissant d'importance.
      """
    ObjetElementListe.__init__(self,'organismes-financeurs', Element_code_financeur(), 'code-financeur')

  def ajoute(self, element):
    if isinstance(element, Element_code_financeur):
        self.liste.append(element)
    else:
        print "Erreur d'ajout, élément du mauvais type."

#
# @element: pays
#
class Element_pays (ObjetElementCode):
  def __init__(self):    
    self.glossaire = ""
    self.lgmin = 2
    self.lgmax = 2
    self.libelle = """Pays"""
    self.commentaire = """Cet élément contient un code de pays issu de la
      table correspondante."""
    self.exemple = """FR"""
    ObjetElementCode.__init__(self,'pays', 'pays')
    self.contenutable = {'AF' : "AFGHANISTAN", 'ZA' : "AFRIQUE DU SUD", 'AL' : "ALBANIE", 'DZ' : "ALGÉRIE", 'DE' : "ALLEMAGNE", 'AD' : "ANDORRE", 'AO' : "ANGOLA", 'AI' : "ANGUILLA", 'AQ' : "ANTARCTIQUE", 'AG' : "ANTIGUA-ET-BARBUDA", 'AN' : "ANTILLES NÉERLANDAISES", 'SA' : "ARABIE SAOUDITE", 'AR' : "ARGENTINE", 'AM' : "ARMÉNIE", 'AW' : "ARUBA", 'AU' : "AUSTRALIE", 'AT' : "AUTRICHE", 'AZ' : "AZERBAÏDJAN", 'BS' : "BAHAMAS", 'BH' : "BAHREÏN", 'BD' : "BANGLADESH", 'BB' : "BARBADE", 'BY' : "BÉLARUS", 'BE' : "BELGIQUE", 'BZ' : "BELIZE", 'BJ' : "BÉNIN", 'BM' : "BERMUDES", 'BT' : "BHOUTAN", 'BO' : "BOLIVIE", 'BA' : "BOSNIE-HERZÉGOVINE", 'BW' : "BOTSWANA", 'BV' : "BOUVET, ÎLE", 'BR' : "BRÉSIL", 'BN' : "BRUNÉI DARUSSALAM", 'BG' : "BULGARIE", 'BF' : "BURKINA FASO", 'BI' : "BURUNDI", 'KY' : "CAÏMANES, ÎLES", 'KH' : "CAMBODGE", 'CM' : "CAMEROUN", 'CA' : "CANADA", 'CV' : "CAP-VERT", 'CF' : "CENTRAFRICAINE, RÉPUBLIQUE", 'CL' : "CHILI", 'CN' : "CHINE", 'CX' : "CHRISTMAS, ÎLE", 'CY' : "CHYPRE", 'CC' : "COCOS (KEELING), ÎLES", 'CO' : "COLOMBIE", 'KM' : "COMORES", 'CG' : "CONGO", 'CD' : "CONGO, LA RÉPUBLIQUE DÉMOCRATIQUE DU", 'CK' : "COOK, ÎLES", 'KR' : "CORÉE, RÉPUBLIQUE DE", 'KP' : "CORÉE, RÉPUBLIQUE POPULAIRE DÉMOCRATIQUE DE", 'CR' : "COSTA RICA", 'CI' : "CÔTE D'IVOIRE", 'HR' : "CROATIE", 'CU' : "CUBA", 'DK' : "DANEMARK", 'DJ' : "DJIBOUTI", 'DO' : "DOMINICAINE, RÉPUBLIQUE", 'DM' : "DOMINIQUE", 'EG' : "ÉGYPTE", 'SV' : "EL SALVADOR", 'AE' : "ÉMIRATS ARABES UNIS", 'EC' : "ÉQUATEUR", 'ER' : "ÉRYTHRÉE", 'ES' : "ESPAGNE", 'EE' : "ESTONIE", 'US' : "ÉTATS-UNIS", 'ET' : "ÉTHIOPIE", 'FK' : "FALKLAND, ÎLES (MALVINAS)", 'FO' : "FÉROÉ, ÎLES", 'FJ' : "FIDJI", 'FI' : "FINLANDE", 'FR' : "FRANCE", 'GA' : "GABON", 'GM' : "GAMBIE", 'GE' : "GÉORGIE", 'GS' : "GÉORGIE DU SUD ET LES ÎLES SANDWICH DU SUD", 'GH' : "GHANA", 'GI' : "GIBRALTAR", 'GR' : "GRÈCE", 'GD' : "GRENADE", 'GL' : "GROENLAND", 'GP' : "GUADELOUPE", 'GU' : "GUAM", 'GT' : "GUATEMALA", 'GN' : "GUINÉE", 'GW' : "GUINÉE-BISSAU", 'GQ' : "GUINÉE ÉQUATORIALE", 'GY' : "GUYANA", 'GF' : "GUYANE FRANÇAISE", 'HT' : "HAÏTI", 'HM' : "HEARD, ÎLE ET MCDONALD, ÎLES", 'HN' : "HONDURAS", 'HK' : "HONG-KONG", 'HU' : "HONGRIE", 'UM' : "ÎLES MINEURES ÉLOIGNÉES DES ÉTATS-UNIS", 'VG' : "ÎLES VIERGES BRITANNIQUES", 'VI' : "ÎLES VIERGES DES ÉTATS-UNIS", 'IN' : "INDE", 'ID' : "INDONÉSIE", 'IR' : "IRAN, RÉPUBLIQUE ISLAMIQUE D'", 'IQ' : "IRAQ", 'IE' : "IRLANDE", 'IS' : "ISLANDE", 'IL' : "ISRAËL", 'IT' : "ITALIE", 'JM' : "JAMAÏQUE", 'JP' : "JAPON", 'JO' : "JORDANIE", 'KZ' : "KAZAKHSTAN", 'KE' : "KENYA", 'KG' : "KIRGHIZISTAN", 'KI' : "KIRIBATI", 'KW' : "KOWEÏT", 'LA' : "LAO, RÉPUBLIQUE DÉMOCRATIQUE POPULAIRE", 'LS' : "LESOTHO", 'LV' : "LETTONIE", 'LB' : "LIBAN", 'LR' : "LIBÉRIA", 'LY' : "LIBYENNE, JAMAHIRIYA ARABE", 'LI' : "LIECHTENSTEIN", 'LT' : "LITUANIE", 'LU' : "LUXEMBOURG", 'MO' : "MACAO", 'MK' : "MACÉDOINE, L'EX-RÉPUBLIQUE YOUGOSLAVE DE", 'MG' : "MADAGASCAR", 'MY' : "MALAISIE", 'MW' : "MALAWI", 'MV' : "MALDIVES", 'ML' : "MALI", 'MT' : "MALTE", 'MP' : "MARIANNES DU NORD, ÎLES", 'MA' : "MAROC", 'MH' : "MARSHALL, ÎLES", 'MQ' : "MARTINIQUE", 'MU' : "MAURICE", 'MR' : "MAURITANIE", 'YT' : "MAYOTTE", 'MX' : "MEXIQUE", 'FM' : "MICRONÉSIE, ÉTATS FÉDÉRÉS DE", 'MD' : "MOLDOVA, RÉPUBLIQUE DE", 'MC' : "MONACO", 'MN' : "MONGOLIE", 'MS' : "MONTSERRAT", 'MZ' : "MOZAMBIQUE", 'MM' : "MYANMAR", 'NA' : "NAMIBIE", 'NR' : "NAURU", 'NP' : "NÉPAL", 'NI' : "NICARAGUA", 'NE' : "NIGER", 'NG' : "NIGÉRIA", 'NU' : "NIUÉ", 'NF' : "NORFOLK, ÎLE", 'NO' : "NORVÈGE", 'NC' : "NOUVELLE-CALÉDONIE", 'NZ' : "NOUVELLE-ZÉLANDE", 'IO' : "OCÉAN INDIEN, TERRITOIRE BRITANNIQUE DE L'", 'OM' : "OMAN", 'UG' : "OUGANDA", 'UZ' : "OUZBÉKISTAN", 'PK' : "PAKISTAN", 'PW' : "PALAOS", 'PS' : "PALESTINIEN OCCUPÉ, TERRITOIRE", 'PA' : "PANAMA", 'PG' : "PAPOUASIE-NOUVELLE-GUINÉE", 'PY' : "PARAGUAY", 'NL' : "PAYS-BAS", 'PE' : "PÉROU", 'PH' : "PHILIPPINES", 'PN' : "PITCAIRN", 'PL' : "POLOGNE", 'PF' : "POLYNÉSIE FRANÇAISE", 'PR' : "PORTO RICO", 'PT' : "PORTUGAL", 'QA' : "QATAR", 'RE' : "RÉUNION", 'RO' : "ROUMANIE", 'GB' : "ROYAUME-UNI", 'RU' : "RUSSIE, FÉDÉRATION DE", 'RW' : "RWANDA", 'EH' : "SAHARA OCCIDENTAL", 'SH' : "SAINTE-HÉLÈNE", 'LC' : "SAINTE-LUCIE", 'KN' : "SAINT-KITTS-ET-NEVIS", 'SM' : "SAINT-MARIN", 'PM' : "SAINT-PIERRE-ET-MIQUELON", 'VA' : "SAINT-SIÈGE (ÉTAT DE LA CITÉ DU VATICAN)", 'VC' : "SAINT-VINCENT-ET-LES GRENADINES", 'SB' : "SALOMON, ÎLES", 'WS' : "SAMOA", 'AS' : "SAMOA AMÉRICAINES", 'ST' : "SAO TOMÉ-ET-PRINCIPE", 'SN' : "SÉNÉGAL", 'SC' : "SEYCHELLES", 'SL' : "SIERRA LEONE", 'SG' : "SINGAPOUR", 'SK' : "SLOVAQUIE", 'SI' : "SLOVÉNIE", 'SO' : "SOMALIE", 'SD' : "SOUDAN", 'LK' : "SRI LANKA", 'SE' : "SUÈDE", 'CH' : "SUISSE", 'SR' : "SURINAME", 'SJ' : "SVALBARD ET ÎLE JAN MAYEN", 'SZ' : "SWAZILAND", 'SY' : "SYRIENNE, RÉPUBLIQUE ARABE", 'TJ' : "TADJIKISTAN", 'TW' : "TAÏWAN, PROVINCE DE CHINE", 'TZ' : "TANZANIE, RÉPUBLIQUE-UNIE DE", 'TD' : "TCHAD", 'CZ' : "TCHÈQUE, RÉPUBLIQUE", 'TF' : "TERRES AUSTRALES FRANÇAISES", 'TH' : "THAÏLANDE", 'TL' : "TIMOR-LESTE", 'TG' : "TOGO", 'TK' : "TOKELAU", 'TO' : "TONGA", 'TT' : "TRINITÉ-ET-TOBAGO", 'TN' : "TUNISIE", 'TM' : "TURKMÉNISTAN", 'TC' : "TURKS ET CAÏQUES, ÎLES", 'TR' : "TURQUIE", 'TV' : "TUVALU", 'UA' : "UKRAINE", 'UY' : "URUGUAY", 'VU' : "VANUATU", 'VE' : "VENEZUELA", 'VN' : "VIET NAM", 'WF' : "WALLIS ET FUTUNA", 'YE' : "YÉMEN", 'YU' : "YOUGOSLAVIE", 'ZM' : "ZAMBIE", 'ZW' : "ZIMBABWE"    }

#
# @element: periode
#
class Element_periode (ObjetElementSequence):
  def __init__(self):    
    self.glossaire = ""
    self.libelle = """Période"""
    self.commentaire = """
	Cet élément permet de définir une période comprise entre deux
	dates. Validation: la date contenue dans l'élément 'deb'
	doit être inférieure ou égale à la date contenue dans
	l'élément 'fin'.
      """
    ObjetElementSequence.__init__(self,'periode', ['deb', 'fin'], [0, 0])
    self.sequence = [ Element_deb(), Element_fin() ]

  def ajoute(self, element):
    if isinstance(element, Element_deb):
      self.sequence[0] = element
    elif isinstance(element, Element_fin):
      self.sequence[1] = element
    else:
        print "Erreur d'ajout, élément du mauvais type."
	self.modeleContenu()

#
# @element: portable
#
class Element_portable (ObjetElementListe):
  def __init__(self):    
    self.glossaire = ""
    self.lgmin = 1
    self.lgmax = 3
    self.libelle = """Téléphone portable"""
    self.commentaire = """Cet élément contient une liste de numéros de téléphone portable."""
    ObjetElementListe.__init__(self,'portable', Element_numtel(), 'numtel')

  def ajoute(self, element):
    if isinstance(element, Element_numtel):
        self.liste.append(element)
    else:
        print "Erreur d'ajout, élément du mauvais type."

#
# @element: prise-en-charge-frais-possible
#
class Element_prise_en_charge_frais_possible (ObjetElementCode):
  def __init__(self):    
    self.cercle = '1'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "prise-charge-frais"
    self.lgmin = 1
    self.lgmax = 1
    self.libelle = """Prise en charge des frais de formation possible"""
    self.commentaire = """
	Cet élément indique si une prise en charge des frais de
	formation est possible (renvoi vers les conseillers en charge
	de l'élaboration des parcours).
      """
    self.exemple = """1"""
    ObjetElementCode.__init__(self,'prise-en-charge-frais-possible', 'boolean')
    self.contenutable = {'0' : "non", '1' : "oui"    }

#
# @element: prix-horaire-TTC
#
class Element_prix_horaire_TTC (ObjetElementNombre):
  def __init__(self):    
    self.cercle = '2'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "prix-horaire-ttc"
    self.lgmin = 1
    self.lgmax = 4
    self.libelle = """Prix horaire TTC"""
    self.commentaire = """
	Cet élément permet d'indiquer en euros, toutes taxes
	comprises, le prix de vente de l'heure de formation.
      """
    self.exemple = """100"""
    ObjetElementNombre.__init__(self,'prix-horaire-TTC')

#
# @element: public-vise
#
class Element_public_vise (ObjetElementCode):
  def __init__(self):    
    self.cercle = '1'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "public-vise"
    self.lgmin = 1
    self.lgmax = 1
    self.libelle = """Type de Public visé"""
    self.commentaire = """
	Cet élément permet de coder le type de public visé par la
	formation (en emploi, sans emploi, tout public).
      """
    self.exemple = """1"""
    ObjetElementCode.__init__(self,'public-vise', 'public-vise')
    self.contenutable = {'0' : "Tout public", '1' : "Sans emploi", '2' : "En emploi"    }

#
# @element: raison-sociale
#
class Element_raison_sociale (ObjetElementTexte):
  def __init__(self):    
    self.cercle = '1'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "raison-sociale-organisme"
    self.lgmin = 1
    self.lgmax = 250
    self.libelle = """Raison sociale de l'organisme"""
    self.commentaire = """
	Cet élément permet de préciser la raison sociale de
	l'organisme responsable de l'offre.
      """
    self.exemple = """Centre de formation d'apprentis académique (CFA)"""
    ObjetElementTexte.__init__(self,'raison-sociale')

#
# @element: raison-sociale-formateur
#
class Element_raison_sociale_formateur (ObjetElementTexte):
  def __init__(self):    
    self.cercle = '2'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "raison-sociale-formateur"
    self.lgmin = 0
    self.lgmax = 250
    self.libelle = """Raison sociale de l'organisme formateur"""
    self.commentaire = """
	Cet élément permet de préciser la raison sociale de
	l'organisme formateur, c'est-à-dire de l'organisme qui assure
	la formation.
      """
    self.exemple = """CFA ACADEMIQUE"""
    ObjetElementTexte.__init__(self,'raison-sociale-formateur')

#
# @element: ref-organisme-formation-responsable
#
class Element_ref_organisme_formation_responsable (ObjetElementReference):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.base = 'non'
    self.glossaire = "organisme-responsable"
    self.libelle = """Référence à un organisme de formation"""
    self.commentaire = """
	Cet élément décrit une référence à un organisme de formation
	décrit à un autre endroit du document XML LHEO (par exemple sous un élément 'info').
	L'attribut 'ref' de cet élément est obligatoire et doit contenir la valeur d'un attribut
	'id' d'un élément 'organisme-formation-responsable' présent à un autre endroit
	du document LHEO. Les deux seuls endroits où cet élément peut se trouver sont: 1) dans une autre
	offre de formation dans le même document ou 2) sous un élément 'info'.
      """
    ObjetElementReference.__init__(self,'ref-organisme-formation-responsable')

#
# @element: region
#
class Element_region (ObjetElementCode):
  def __init__(self):    
    self.glossaire = ""
    self.lgmin = 2
    self.lgmax = 2
    self.libelle = """Région"""
    self.commentaire = """Cet élément contient un numéro de région."""
    self.exemple = """02"""
    ObjetElementCode.__init__(self,'region', 'regions-france')
    self.contenutable = {'01' : "Guadeloupe", '1' : "Guadeloupe", '02' : "Martinique", '2' : "Martinique", '03' : "Guyane", '3' : "Guyane", '04' : "Réunion", '4' : "Réunion", '11' : "Île-de-France", '21' : "Champagne-Ardenne", '22' : "Picardie", '23' : "Haute-Normandie", '24' : "Centre", '25' : "Basse-Normandie", '26' : "Bourgogne", '31' : "Nord-Pas-de-Calais", '41' : "Lorraine", '42' : "Alsace", '43' : "Franche-Comté", '52' : "Pays de la Loire", '53' : "Bretagne", '54' : "Poitou-Charentes", '72' : "Aquitaine", '73' : "Midi-Pyrénées", '74' : "Limousin", '82' : "Rhône-Alpes", '83' : "Auvergne", '91' : "Languedoc-Roussillon", '93' : "Provence-Alpes-Côte d'Azur", '94' : "Corse"    }

#
# @element: remuneration-possible
#
class Element_remuneration_possible (ObjetElementCode):
  def __init__(self):    
    self.cercle = '1'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "remuneration-possible"
    self.lgmin = 1
    self.lgmax = 1
    self.libelle = """Rémunération possible"""
    self.commentaire = """
	Cet élément permet d'indiquer si il y a possibilité ou non de
	percevoir une rémunération.
      """
    self.exemple = """1"""
    ObjetElementCode.__init__(self,'remuneration-possible', 'boolean')
    self.contenutable = {'0' : "non", '1' : "oui"    }

#
# @element: renseignements-specifiques
#
class Element_renseignements_specifiques (ObjetElementTexte):
  def __init__(self):    
    self.cercle = '1'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "renseignements-specifiques"
    self.lgmin = 0
    self.lgmax = 3000
    self.libelle = """Renseignements spécifiques sur l'organisme"""
    self.commentaire = """
	Cet élément permet de donner des renseignements spécifiques
	sur l'organisme responsable de l'offre, comme par exemple une
	démarque qualité, un label, etc.
      """
    self.exemple = """Formation initiale (cursus scolaire)."""
    ObjetElementTexte.__init__(self,'renseignements-specifiques')

#
# @element: restauration-hebergement-transport
#
class Element_restauration_hebergement_transport (ObjetElementTexte):
  def __init__(self):    
    self.cercle = '2'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "restauration"
    self.lgmin = 1
    self.lgmax = 250
    self.libelle = """Restauration, hébergement, transport"""
    self.commentaire = """
	Cet élément permet de préciser l'organisation matérielle de la
	formation, en précisant des aspects pratiques comme la
	restauration, les possibilités d'hébergement, les accès
	handicapés, etc.
      """
    self.exemple = """Accès handicapés."""
    ObjetElementTexte.__init__(self,'restauration-hebergement-transport')

#
# @element: resultats-attendus
#
class Element_resultats_attendus (ObjetElementTexte):
  def __init__(self):    
    self.cercle = '1'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "resultats-formation"
    self.lgmin = 1
    self.lgmax = 200
    self.nomenclature = """référence aux tables de l'Éducation nationale pour
    les diplômes et au RNCP pour les titres
    professionnels"""
    self.libelle = """Résultats attendus de la formation"""
    self.commentaire = """
	Cet élément décrit les résultats attendus de la formation
	(titre, diplôme, certificat, attestation, ...). Si c'est un
	diplôme, faire référence aux tables de l'éducation
	nationale. Si c'est un titre, faire référence au
	RNCP.
      """
    self.exemple = """CAP Photographe"""
    ObjetElementTexte.__init__(self,'resultats-attendus')

#
# @element: resume-offre
#
class Element_resume_offre (ObjetElementSequence):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.base = 'non'
    self.glossaire = ""
    ObjetElementSequence.__init__(self,'resume-offre', ['offre-xml', 'domaine-formation', 'diplomante', 'prise-en-charge-frais-possible', 'intitule-action', 'resultats-attendus', 'departement-lieu-de-formation', 'ville-lieu-de-formation', 'nom-organisme', 'objectif-formation-resume'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
    self.sequence = [ Element_offre_xml(), Element_domaine_formation(), Element_diplomante(), Element_prise_en_charge_frais_possible(), Element_intitule_action(), Element_resultats_attendus(), Element_departement_lieu_de_formation(), Element_ville_lieu_de_formation(), Element_nom_organisme(), Element_objectif_formation_resume() ]

  def ajoute(self, element):
    if isinstance(element, Element_offre_xml):
      self.sequence[0] = element
    elif isinstance(element, Element_domaine_formation):
      self.sequence[1] = element
    elif isinstance(element, Element_diplomante):
      self.sequence[2] = element
    elif isinstance(element, Element_prise_en_charge_frais_possible):
      self.sequence[3] = element
    elif isinstance(element, Element_intitule_action):
      self.sequence[4] = element
    elif isinstance(element, Element_resultats_attendus):
      self.sequence[5] = element
    elif isinstance(element, Element_departement_lieu_de_formation):
      self.sequence[6] = element
    elif isinstance(element, Element_ville_lieu_de_formation):
      self.sequence[7] = element
    elif isinstance(element, Element_nom_organisme):
      self.sequence[8] = element
    elif isinstance(element, Element_objectif_formation_resume):
      self.sequence[9] = element
    else:
        print "Erreur d'ajout, élément du mauvais type."
	self.modeleContenu()

#
# @element: resumes
#
class Element_resumes (ObjetElementListe):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.base = 'non'
    self.glossaire = ""
    self.lgmin = 0
    self.lgmax = -1
    ObjetElementListe.__init__(self,'resumes', Element_resume_offre(), 'resume-offre')

  def ajoute(self, element):
    if isinstance(element, Element_resume_offre):
        self.liste.append(element)
    else:
        print "Erreur d'ajout, élément du mauvais type."

#
# @element: rythme-formation
#
class Element_rythme_formation (ObjetElementTexte):
  def __init__(self):    
    self.cercle = '1'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "rythme-formation"
    self.lgmin = 1
    self.lgmax = 50
    self.libelle = """Rythme de la formation"""
    self.commentaire = """
	Cet élément permet de donner le rythme de la formation: temps plein, temps partiel, etc.
      """
    self.exemple = """Alternance"""
    ObjetElementTexte.__init__(self,'rythme-formation')

#
# @element: session
#
class Element_session (ObjetElementBasic):
  def __init__(self):    
    self.cercle = '1'
    self.atomique = '1'
    self.typedebase = 'periode'
    self.base = 'non'
    self.glossaire = "session-formation"
    self.libelle = """Session de formation"""
    self.commentaire = """
	Cet élément permet de lister les différentes sessions de
	formation en format fixe.
      """
    ObjetElementBasic.__init__(self,'session', Element_periode())

#
# @element: sessions
#
class Element_sessions (ObjetElementListe):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.base = 'non'
    self.glossaire = "session-formation"
    self.lgmin = 1
    self.lgmax = 5
    self.libelle = """Liste de sessions"""
    self.commentaire = """
	Liste de sessions (dates de début et fin de stage).
      """
    ObjetElementListe.__init__(self,'sessions', Element_session(), 'session')

  def ajoute(self, element):
    if isinstance(element, Element_session):
        self.liste.append(element)
    else:
        print "Erreur d'ajout, élément du mauvais type."

#
# @element: sexe-public-vise
#
class Element_sexe_public_vise (ObjetElementCode):
  def __init__(self):    
    self.cercle = '1'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "public-vise"
    self.lgmin = 1
    self.lgmax = 1
    self.libelle = """Sexe du public visé"""
    self.commentaire = """
	Cet élément permet de coder le sexe du public visé par la formation (indifférent, masculin, féminin).
      """
    self.exemple = """0"""
    ObjetElementCode.__init__(self,'sexe-public-vise', 'sexe-public-vise')
    self.contenutable = {'0' : "Indifférent", '1' : "Masculin", '2' : "Féminin"    }

#
# @element: statut-public-vise
#
class Element_statut_public_vise (ObjetElementListe):
  def __init__(self):    
    self.cercle = '2'
    self.atomique = '1'
    self.base = 'non'
    self.glossaire = "public-details"
    self.lgmin = 1
    self.lgmax = 8
    self.libelle = """Statut du public visé"""
    self.commentaire = """
	Liste permettant d'indiquer plusieurs codes décrivant le ou les
	publics visés par l'action de formation.
      """
    ObjetElementListe.__init__(self,'statut-public-vise', Element_code_public_vise(), 'code-public-vise')

  def ajoute(self, element):
    if isinstance(element, Element_code_public_vise):
        self.liste.append(element)
    else:
        print "Erreur d'ajout, élément du mauvais type."

#
# @element: telfixe
#
class Element_telfixe (ObjetElementListe):
  def __init__(self):    
    self.glossaire = ""
    self.lgmin = 1
    self.lgmax = 3
    self.libelle = """Téléphone fixe"""
    self.commentaire = """Cet élément contient une liste de numéros de téléphone fixe."""
    ObjetElementListe.__init__(self,'telfixe', Element_numtel(), 'numtel')

  def ajoute(self, element):
    if isinstance(element, Element_numtel):
        self.liste.append(element)
    else:
        print "Erreur d'ajout, élément du mauvais type."

#
# @element: urlweb
#
class Element_urlweb (ObjetElementTexte):
  def __init__(self):    
    self.glossaire = ""
    self.lgmin = 3
    self.lgmax = 150
    self.libelle = """URL"""
    self.commentaire = """Cet élément contient une adresse de site web."""
    self.exemple = """http://demo.lheo.org"""
    ObjetElementTexte.__init__(self,'urlweb')

#
# @element: ville
#
class Element_ville (ObjetElementTexte):
  def __init__(self):    
    self.glossaire = ""
    self.lgmin = 1
    self.lgmax = 50
    self.libelle = """Ville"""
    self.commentaire = """
	Cet élément contient un nom de ville. Validation: vérifier
	l'adéquation entre l'élément 'ville' et le contenu de
	l'élément 'codepostal'.
      """
    self.exemple = """Lyon"""
    ObjetElementTexte.__init__(self,'ville')

#
# @element: ville-lieu-de-formation
#
class Element_ville_lieu_de_formation (ObjetElementBasic):
  def __init__(self):    
    self.cercle = '0'
    self.atomique = '0'
    self.typedebase = 'ville'
    self.base = 'non'
    self.glossaire = ""
    ObjetElementBasic.__init__(self,'ville-lieu-de-formation', Element_ville())

#
# @element: web
#
class Element_web (ObjetElementListe):
  def __init__(self):    
    self.glossaire = ""
    self.lgmin = 1
    self.lgmax = 3
    self.libelle = """Web"""
    self.commentaire = """Cet élément contient une liste d'adresses de sites web."""
    ObjetElementListe.__init__(self,'web', Element_urlweb(), 'urlweb')

  def ajoute(self, element):
    if isinstance(element, Element_urlweb):
        self.liste.append(element)
    else:
        print "Erreur d'ajout, élément du mauvais type."
def dom2objet(node):
  objet = ObjetElementNul()
  if node.nodeName=='FOAD':
    objet = Element_FOAD()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='SIREN':
    objet = Element_SIREN()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='SIREN-formateur':
    objet = Element_SIREN_formateur()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='SIREN-organisme-formation':
    objet = Element_SIREN_organisme_formation()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='action-formation':
    objet = Element_action_formation()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='adresse':
    objet = Element_adresse()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='adresse-inscription':
    objet = Element_adresse_inscription()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='age':
    objet = Element_age()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='age-public-vise':
    objet = Element_age_public_vise()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='canal':
    objet = Element_canal()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='code-FORMACODE':
    objet = Element_code_FORMACODE()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='code-INSEE-commune':
    objet = Element_code_INSEE_commune()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='code-NSF':
    objet = Element_code_NSF()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='code-ROME':
    objet = Element_code_ROME()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='code-financeur':
    objet = Element_code_financeur()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='code-niveau-entree':
    objet = Element_code_niveau_entree()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='code-perimetre-recrutement':
    objet = Element_code_perimetre_recrutement()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='code-public-vise':
    objet = Element_code_public_vise()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='codeinsee-lieu-de-formation':
    objet = Element_codeinsee_lieu_de_formation()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='codepostal':
    objet = Element_codepostal()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='codes-FORMACODE':
    objet = Element_codes_FORMACODE()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='codes-NSF':
    objet = Element_codes_NSF()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='codes-ROME':
    objet = Element_codes_ROME()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='conditions-administratives':
    objet = Element_conditions_administratives()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='conditions-pedagogiques':
    objet = Element_conditions_pedagogiques()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='conditions-specifiques':
    objet = Element_conditions_specifiques()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='contact-offre':
    objet = Element_contact_offre()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='contact-organisme':
    objet = Element_contact_organisme()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='contenu-formation':
    objet = Element_contenu_formation()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='conventionnement-possible':
    objet = Element_conventionnement_possible()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='coordonnees':
    objet = Element_coordonnees()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='coordonnees-libres':
    objet = Element_coordonnees_libres()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='coordonnees-organisme':
    objet = Element_coordonnees_organisme()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='courriel':
    objet = Element_courriel()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='date':
    objet = Element_date()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='date-inscription':
    objet = Element_date_inscription()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='date-limite-inscription':
    objet = Element_date_limite_inscription()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='dates-debut-fin-stage':
    objet = Element_dates_debut_fin_stage()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='deb':
    objet = Element_deb()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='departement':
    objet = Element_departement()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='departement-lieu-de-formation':
    objet = Element_departement_lieu_de_formation()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='detail-conditions-prise-en-charge':
    objet = Element_detail_conditions_prise_en_charge()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='diplomante':
    objet = Element_diplomante()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='domaine-formation':
    objet = Element_domaine_formation()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='duree-conventionnee':
    objet = Element_duree_conventionnee()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='duree-indicative':
    objet = Element_duree_indicative()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='extras-action-formation':
    objet = Element_extras_action_formation()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='extras-conditions-administratives':
    objet = Element_extras_conditions_administratives()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='extras-conditions-pedagogiques':
    objet = Element_extras_conditions_pedagogiques()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='extras-domaine-formation':
    objet = Element_extras_domaine_formation()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='extras-lieu-date-inscription':
    objet = Element_extras_lieu_date_inscription()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='extras-modalites-acces':
    objet = Element_extras_modalites_acces()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='extras-offre-formation':
    objet = Element_extras_offre_formation()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='extras-offres':
    objet = Element_extras_offres()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='extras-organisation-administrative':
    objet = Element_extras_organisation_administrative()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='extras-organisation-formation':
    objet = Element_extras_organisation_formation()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='extras-organisation-materielle':
    objet = Element_extras_organisation_materielle()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='extras-organisation-pedagogique':
    objet = Element_extras_organisation_pedagogique()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='extras-organisme-formateur':
    objet = Element_extras_organisme_formateur()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='extras-organisme-formation-responsable':
    objet = Element_extras_organisme_formation_responsable()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='extras-organismes':
    objet = Element_extras_organismes()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='fax':
    objet = Element_fax()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='fin':
    objet = Element_fin()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='infos-perimetre-recrutement':
    objet = Element_infos_perimetre_recrutement()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='intitule-action':
    objet = Element_intitule_action()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='lheo':
    objet = Element_lheo()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='lheo-leger':
    objet = Element_lheo_leger()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='lheo-requete':
    objet = Element_lheo_requete()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='lieu-date-inscription':
    objet = Element_lieu_date_inscription()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='lieu-de-formation':
    objet = Element_lieu_de_formation()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='lignead':
    objet = Element_lignead()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='ligneco':
    objet = Element_ligneco()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='lignesad':
    objet = Element_lignesad()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='lignesco':
    objet = Element_lignesco()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='modalite-alternance':
    objet = Element_modalite_alternance()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='modalite-entrees-sorties':
    objet = Element_modalite_entrees_sorties()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='modalites-acces':
    objet = Element_modalites_acces()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='modalites-pedagogiques':
    objet = Element_modalites_pedagogiques()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='modalites-recrutement':
    objet = Element_modalites_recrutement()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='niveau-entree':
    objet = Element_niveau_entree()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='nom-organisme':
    objet = Element_nom_organisme()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='nombre-heures-totales':
    objet = Element_nombre_heures_totales()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='nombre-offres':
    objet = Element_nombre_offres()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='numero-activite':
    objet = Element_numero_activite()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='numtel':
    objet = Element_numtel()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='objectif-formation':
    objet = Element_objectif_formation()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='objectif-formation-resume':
    objet = Element_objectif_formation_resume()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='objectif-general-formation':
    objet = Element_objectif_general_formation()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='offre-formation':
    objet = Element_offre_formation()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='offre-html':
    objet = Element_offre_html()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='offre-xml':
    objet = Element_offre_xml()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='offres':
    objet = Element_offres()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='organisation-administrative':
    objet = Element_organisation_administrative()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='organisation-formation':
    objet = Element_organisation_formation()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='organisation-materielle':
    objet = Element_organisation_materielle()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='organisation-pedagogique':
    objet = Element_organisation_pedagogique()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='organisme-formateur':
    objet = Element_organisme_formateur()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='organisme-formation-responsable':
    objet = Element_organisme_formation_responsable()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='organismes':
    objet = Element_organismes()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='organismes-financeurs':
    objet = Element_organismes_financeurs()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='pays':
    objet = Element_pays()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='periode':
    objet = Element_periode()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='portable':
    objet = Element_portable()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='prise-en-charge-frais-possible':
    objet = Element_prise_en_charge_frais_possible()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='prix-horaire-TTC':
    objet = Element_prix_horaire_TTC()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='public-vise':
    objet = Element_public_vise()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='raison-sociale':
    objet = Element_raison_sociale()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='raison-sociale-formateur':
    objet = Element_raison_sociale_formateur()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='ref-organisme-formation-responsable':
    objet = Element_ref_organisme_formation_responsable()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='region':
    objet = Element_region()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='remuneration-possible':
    objet = Element_remuneration_possible()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='renseignements-specifiques':
    objet = Element_renseignements_specifiques()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='restauration-hebergement-transport':
    objet = Element_restauration_hebergement_transport()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='resultats-attendus':
    objet = Element_resultats_attendus()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='resume-offre':
    objet = Element_resume_offre()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='resumes':
    objet = Element_resumes()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='rythme-formation':
    objet = Element_rythme_formation()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='session':
    objet = Element_session()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='sessions':
    objet = Element_sessions()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='sexe-public-vise':
    objet = Element_sexe_public_vise()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='statut-public-vise':
    objet = Element_statut_public_vise()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='telfixe':
    objet = Element_telfixe()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='urlweb':
    objet = Element_urlweb()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='ville':
    objet = Element_ville()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='ville-lieu-de-formation':
    objet = Element_ville_lieu_de_formation()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  elif node.nodeName=='web':
    objet = Element_web()
    nv = objet.lisDOM(node)
    if nv != 0:
      raise ErreurDeValidation
  return objet
def cree_element_objet(nom):
  objet = ObjetElementNul()
  if nom=='FOAD':
    objet = Element_FOAD()
  elif nom=='SIREN':
    objet = Element_SIREN()
  elif nom=='SIREN-formateur':
    objet = Element_SIREN_formateur()
  elif nom=='SIREN-organisme-formation':
    objet = Element_SIREN_organisme_formation()
  elif nom=='action-formation':
    objet = Element_action_formation()
  elif nom=='adresse':
    objet = Element_adresse()
  elif nom=='adresse-inscription':
    objet = Element_adresse_inscription()
  elif nom=='age':
    objet = Element_age()
  elif nom=='age-public-vise':
    objet = Element_age_public_vise()
  elif nom=='canal':
    objet = Element_canal()
  elif nom=='code-FORMACODE':
    objet = Element_code_FORMACODE()
  elif nom=='code-INSEE-commune':
    objet = Element_code_INSEE_commune()
  elif nom=='code-NSF':
    objet = Element_code_NSF()
  elif nom=='code-ROME':
    objet = Element_code_ROME()
  elif nom=='code-financeur':
    objet = Element_code_financeur()
  elif nom=='code-niveau-entree':
    objet = Element_code_niveau_entree()
  elif nom=='code-perimetre-recrutement':
    objet = Element_code_perimetre_recrutement()
  elif nom=='code-public-vise':
    objet = Element_code_public_vise()
  elif nom=='codeinsee-lieu-de-formation':
    objet = Element_codeinsee_lieu_de_formation()
  elif nom=='codepostal':
    objet = Element_codepostal()
  elif nom=='codes-FORMACODE':
    objet = Element_codes_FORMACODE()
  elif nom=='codes-NSF':
    objet = Element_codes_NSF()
  elif nom=='codes-ROME':
    objet = Element_codes_ROME()
  elif nom=='conditions-administratives':
    objet = Element_conditions_administratives()
  elif nom=='conditions-pedagogiques':
    objet = Element_conditions_pedagogiques()
  elif nom=='conditions-specifiques':
    objet = Element_conditions_specifiques()
  elif nom=='contact-offre':
    objet = Element_contact_offre()
  elif nom=='contact-organisme':
    objet = Element_contact_organisme()
  elif nom=='contenu-formation':
    objet = Element_contenu_formation()
  elif nom=='conventionnement-possible':
    objet = Element_conventionnement_possible()
  elif nom=='coordonnees':
    objet = Element_coordonnees()
  elif nom=='coordonnees-libres':
    objet = Element_coordonnees_libres()
  elif nom=='coordonnees-organisme':
    objet = Element_coordonnees_organisme()
  elif nom=='courriel':
    objet = Element_courriel()
  elif nom=='date':
    objet = Element_date()
  elif nom=='date-inscription':
    objet = Element_date_inscription()
  elif nom=='date-limite-inscription':
    objet = Element_date_limite_inscription()
  elif nom=='dates-debut-fin-stage':
    objet = Element_dates_debut_fin_stage()
  elif nom=='deb':
    objet = Element_deb()
  elif nom=='departement':
    objet = Element_departement()
  elif nom=='departement-lieu-de-formation':
    objet = Element_departement_lieu_de_formation()
  elif nom=='detail-conditions-prise-en-charge':
    objet = Element_detail_conditions_prise_en_charge()
  elif nom=='diplomante':
    objet = Element_diplomante()
  elif nom=='domaine-formation':
    objet = Element_domaine_formation()
  elif nom=='duree-conventionnee':
    objet = Element_duree_conventionnee()
  elif nom=='duree-indicative':
    objet = Element_duree_indicative()
  elif nom=='extras-action-formation':
    objet = Element_extras_action_formation()
  elif nom=='extras-conditions-administratives':
    objet = Element_extras_conditions_administratives()
  elif nom=='extras-conditions-pedagogiques':
    objet = Element_extras_conditions_pedagogiques()
  elif nom=='extras-domaine-formation':
    objet = Element_extras_domaine_formation()
  elif nom=='extras-lieu-date-inscription':
    objet = Element_extras_lieu_date_inscription()
  elif nom=='extras-modalites-acces':
    objet = Element_extras_modalites_acces()
  elif nom=='extras-offre-formation':
    objet = Element_extras_offre_formation()
  elif nom=='extras-offres':
    objet = Element_extras_offres()
  elif nom=='extras-organisation-administrative':
    objet = Element_extras_organisation_administrative()
  elif nom=='extras-organisation-formation':
    objet = Element_extras_organisation_formation()
  elif nom=='extras-organisation-materielle':
    objet = Element_extras_organisation_materielle()
  elif nom=='extras-organisation-pedagogique':
    objet = Element_extras_organisation_pedagogique()
  elif nom=='extras-organisme-formateur':
    objet = Element_extras_organisme_formateur()
  elif nom=='extras-organisme-formation-responsable':
    objet = Element_extras_organisme_formation_responsable()
  elif nom=='extras-organismes':
    objet = Element_extras_organismes()
  elif nom=='fax':
    objet = Element_fax()
  elif nom=='fin':
    objet = Element_fin()
  elif nom=='infos-perimetre-recrutement':
    objet = Element_infos_perimetre_recrutement()
  elif nom=='intitule-action':
    objet = Element_intitule_action()
  elif nom=='lheo':
    objet = Element_lheo()
  elif nom=='lheo-leger':
    objet = Element_lheo_leger()
  elif nom=='lheo-requete':
    objet = Element_lheo_requete()
  elif nom=='lieu-date-inscription':
    objet = Element_lieu_date_inscription()
  elif nom=='lieu-de-formation':
    objet = Element_lieu_de_formation()
  elif nom=='lignead':
    objet = Element_lignead()
  elif nom=='ligneco':
    objet = Element_ligneco()
  elif nom=='lignesad':
    objet = Element_lignesad()
  elif nom=='lignesco':
    objet = Element_lignesco()
  elif nom=='modalite-alternance':
    objet = Element_modalite_alternance()
  elif nom=='modalite-entrees-sorties':
    objet = Element_modalite_entrees_sorties()
  elif nom=='modalites-acces':
    objet = Element_modalites_acces()
  elif nom=='modalites-pedagogiques':
    objet = Element_modalites_pedagogiques()
  elif nom=='modalites-recrutement':
    objet = Element_modalites_recrutement()
  elif nom=='niveau-entree':
    objet = Element_niveau_entree()
  elif nom=='nom-organisme':
    objet = Element_nom_organisme()
  elif nom=='nombre-heures-totales':
    objet = Element_nombre_heures_totales()
  elif nom=='nombre-offres':
    objet = Element_nombre_offres()
  elif nom=='numero-activite':
    objet = Element_numero_activite()
  elif nom=='numtel':
    objet = Element_numtel()
  elif nom=='objectif-formation':
    objet = Element_objectif_formation()
  elif nom=='objectif-formation-resume':
    objet = Element_objectif_formation_resume()
  elif nom=='objectif-general-formation':
    objet = Element_objectif_general_formation()
  elif nom=='offre-formation':
    objet = Element_offre_formation()
  elif nom=='offre-html':
    objet = Element_offre_html()
  elif nom=='offre-xml':
    objet = Element_offre_xml()
  elif nom=='offres':
    objet = Element_offres()
  elif nom=='organisation-administrative':
    objet = Element_organisation_administrative()
  elif nom=='organisation-formation':
    objet = Element_organisation_formation()
  elif nom=='organisation-materielle':
    objet = Element_organisation_materielle()
  elif nom=='organisation-pedagogique':
    objet = Element_organisation_pedagogique()
  elif nom=='organisme-formateur':
    objet = Element_organisme_formateur()
  elif nom=='organisme-formation-responsable':
    objet = Element_organisme_formation_responsable()
  elif nom=='organismes':
    objet = Element_organismes()
  elif nom=='organismes-financeurs':
    objet = Element_organismes_financeurs()
  elif nom=='pays':
    objet = Element_pays()
  elif nom=='periode':
    objet = Element_periode()
  elif nom=='portable':
    objet = Element_portable()
  elif nom=='prise-en-charge-frais-possible':
    objet = Element_prise_en_charge_frais_possible()
  elif nom=='prix-horaire-TTC':
    objet = Element_prix_horaire_TTC()
  elif nom=='public-vise':
    objet = Element_public_vise()
  elif nom=='raison-sociale':
    objet = Element_raison_sociale()
  elif nom=='raison-sociale-formateur':
    objet = Element_raison_sociale_formateur()
  elif nom=='ref-organisme-formation-responsable':
    objet = Element_ref_organisme_formation_responsable()
  elif nom=='region':
    objet = Element_region()
  elif nom=='remuneration-possible':
    objet = Element_remuneration_possible()
  elif nom=='renseignements-specifiques':
    objet = Element_renseignements_specifiques()
  elif nom=='restauration-hebergement-transport':
    objet = Element_restauration_hebergement_transport()
  elif nom=='resultats-attendus':
    objet = Element_resultats_attendus()
  elif nom=='resume-offre':
    objet = Element_resume_offre()
  elif nom=='resumes':
    objet = Element_resumes()
  elif nom=='rythme-formation':
    objet = Element_rythme_formation()
  elif nom=='session':
    objet = Element_session()
  elif nom=='sessions':
    objet = Element_sessions()
  elif nom=='sexe-public-vise':
    objet = Element_sexe_public_vise()
  elif nom=='statut-public-vise':
    objet = Element_statut_public_vise()
  elif nom=='telfixe':
    objet = Element_telfixe()
  elif nom=='urlweb':
    objet = Element_urlweb()
  elif nom=='ville':
    objet = Element_ville()
  elif nom=='ville-lieu-de-formation':
    objet = Element_ville_lieu_de_formation()
  elif nom=='web':
    objet = Element_web()
  return objet
# $Id: lheo_fonctions.py,v 1.4 2004/09/23 15:51:14 silber Exp $

def litXML(stream):
    try:
        reader = Sax2.Reader()
        doc = reader.fromStream(stream)
    except:
        raise ErreurDeValidation()
    else:
        return doc.lastChild

def ouvreFichierXML(nom):
    fichier = open(nom, 'r')
    return litXML(fichier)

def ouvreLHEO(nom):
    d = ouvreFichierXML(nom)
    lheo = dom2objet(d)
    return lheo

def valide(objet):
    print "Validation de l'objet <%s>"%objet.motcle
    nv = objet.valide()
    if nv == 0:
        print "Objet valide au niveau 0 (DTD)"
    elif nv == 1:
        print "Objet valide au niveau 1 (0 + XML Schema + tailles)"
    elif nv == 2:
        print "Objet valide au niveau 2 (1 + Codes de tables)"
    else:
        print "Objet non valide !"
    return nv

def ouvreEtValideLHEO(nom):
    lheo = ouvreLHEO(nom)
    valide(lheo)
    return lheo

def formulaire2listeobjets(formulaire):
    listeelements=[]
    listeobjets=[]
    for entree in formulaire:
        listeelements.append(entree)
    for element in listeelements:
        val = formulaire[element].value
        if val != '' and val != 'NC':
            objet = cree_element_objet(element)
            objet.ajoute(val)
            listeobjets.append(objet)
    return listeobjets

def cgivalide(string):
    try:
        doc = litXML(StringIO(fichier_xml))
        l = dom2objet(doc)
    except:
        print "Erreur de validation !"
        print "Fichier LHEO/XML non valide par rapport à la DTD"
    else:
        nv = valide(l)
        if nv >= 0:
            print
            print "===================================="
            print " CONTENU DU FICHIER LHEO/XML "
            print "===================================="
            l.afficheXML()