mncheck/schemas/mn1_rec.py

'''

@author: olivier.massot, 2018
'''

import logging
from qgis.core import QgsGeometry

from core.cerberus_ import is_float, is_multi_int, is_int, \
    is_modern_french_date
from core.validation_errors import UniqueError, RelationError, \
    DuplicatedGeom, MissingItem, DimensionError, TechnicalValidationError
from core.validator import QgsModel, BaseValidator

logger = logging.getLogger("mncheck")

XMIN, XMAX, YMIN, YMAX = 1341999, 1429750, 8147750, 8294000
CRS = 'EPSG:3949' # Coordinate Reference System

TOLERANCE = 1

class Artere(QgsModel):
    layername = "artere_geo"
    geom_type = QgsModel.GEOM_LINE
    crs = CRS
    bounding_box = (XMIN,YMIN,XMAX,YMAX)
    schema = {'AR_ID_INSE': {'type': 'string', 'empty': False, 'regex': r'50\d{3}'}, 
              'AR_LONG': {'empty': False, 'validator': is_float},
              'AR_ETAT': {'type': 'string', 'empty': False, 'allowed': ['0', '1', '2', '3', '4']}, 
              'AR_OCCP': {'type': 'string', 'empty': False, 'allowed': ['0', '1.1', '1.2', '2', '3', '4']}, 
              'AR_NOEUD_A': {'type': 'string', 'empty': False, 'maxlength': 20}, 
              'AR_NOEUD_B': {'type': 'string', 'empty': False, 'maxlength': 20}, 
              'AR_NB_FOUR': {'empty': False, 'validator': is_multi_int}, 
              'AR_FOU_DIS': {'empty': False, 'validator': is_int}, 
              'AR_TYPE_FO': {'type': 'string', 'multiallowed': ['PVC', 'PEHD', 'SOUS-TUBAGE PEHD', 'SOUS-TUBAGE  SOUPLE', 'FACADE', 'AERIEN', 'ENCORBELLEMENT', 'AUTRE']}, 
              'AR_DIAM_FO': {'type': 'string', 'multiallowed': ['10', '14', '18', '25', '28', '32', '40', '45', '60', '80', '150', 'NUL']}, 
              'AR_PRO_FOU': {'type': 'string', 'multiallowed': ['MANCHE NUMERIQUE', 'COLLECTIVITE', 'ORANGE', 'PRIVE', 'ERDF', 'AUTRE (à préciser)']}, 
              'AR_PRO_CAB': {'type': 'string', 'empty': False, 'allowed': ['MANCHE NUMERIQUE']}, 
              'AR_GEST_FO': {'type': 'string', 'multiallowed': ['MANCHE NUMERIQUE', 'MANCHE TELECOM', 'COLLECTIVITE', 'ORANGE', 'MANCHE FIBRE', 'PRIVE', 'ERDF', 'AUTRE (à préciser)', 'NUL']}, 
              'AR_UTIL_FO': {'type': 'string', 'multiallowed': ['MANCHE NUMERIQUE', 'MANCHE TELECOM', 'COLLECTIVITE', 'ORANGE', 'MANCHE FIBRE', 'PRIVE', 'AUTRE (à préciser)', 'NUL']}, 
              'AR_DATE_IN': {'empty': False, 'validator': is_modern_french_date}, 
              'AR_DATE_RE': {'empty': False, 'validator': is_modern_french_date}, 
              'AR_REF_PLA': {'type': 'string', 'maxlength': 100}, 
              'AR_SRC_GEO': {'type': 'string', 'maxlength': 50}, 
              'AR_QLT_GEO': {'type': 'string', 'empty': False, 'allowed': ['A', 'B', 'C']}, 
              'AR_PRO_MD': {'type': 'string', 'empty': False, 'default': 'MANCHE NUMERIQUE', 'allowed': ['MANCHE NUMERIQUE']}, 
              'AR_COMMENT': {'type': 'string', 'maxlength': 300, 'empty': True}, 
              'AR_STATUT': {'type': 'string', 'empty': False, 'allowed': ['APS', 'APD', 'EXE', 'REC']}}

    def __repr__(self):
        return "Artere {}-{}".format(self.AR_NOEUD_A, self.AR_NOEUD_B)

class Cable(QgsModel):
    layername = "cable_geo"
    geom_type = QgsModel.GEOM_LINE
    crs = CRS
    bounding_box = (XMIN,YMIN,XMAX,YMAX)
    schema = {'CA_NUMERO': {'type': 'string', 'maxlength': 17}, 
              'CA_TYPE': {'type': 'string', 'maxlength': 10, 'empty': False, 'allowed': ['AERIEN', 'IMMEUBLE', 'FACADE', 'MIXTE', 'SOUTERRAIN']}, 
              'CA_ETAT': {'type': 'string', 'maxlength': 1, 'empty': False, 'allowed': ['0', '1', '2', '3', '4']}, 
              'CA_LONG': {'validator': is_float}, 
              'CA_EQ_A': {'type': 'string', 'maxlength': 18}, 
              'CA_EQ_B': {'type': 'string', 'maxlength': 18}, 
              'CA_DIAMETR': {'empty': False, 'validator': is_float}, 
              'CA_COULEUR': {'type': 'string', 'maxlength': 20, 'empty': False, 'allowed': ['NOIR', 'BLEU', 'BLANC']}, 
              'CA_TECHNOL': {'type': 'string', 'maxlength': 17, 'empty': False, 'allowed': ['G657A2_M6', 'G657A2_M12']}, 
              'CA_NB_FO': {'validator': is_int}, 
              'CA_NB_FO_U': {'empty': False, 'validator': is_int}, 
              'CA_NB_FO_D': {'empty': False, 'validator': is_int}, 
              'CA_PRO': {'type': 'string', 'maxlength': 20, 'empty': False, 'allowed': ['MANCHE NUMERIQUE']}, 
              'CA_GEST': {'type': 'string', 'maxlength': 20, 'empty': False, 'allowed': ['MANCHE FIBRE']}, 
              'CA_DATE_IN': {'empty': False, 'validator': is_modern_french_date}, 
              'CA_COMMENT': {'type': 'string', 'maxlength': 300, 'empty': True}, 
              'CA_STATUT': {'type': 'string', 'maxlength': 14, 'empty': False, 'allowed': ['APS', 'APD', 'EXE', 'REC']}}

    def __repr__(self):
        return "Cable {}-{}".format(self.CA_EQ_A, self.CA_EQ_B)
    
class Equipement(QgsModel):
    layername = "equipement_passif"
    geom_type = QgsModel.GEOM_POINT
    crs = CRS
    bounding_box = (XMIN,YMIN,XMAX,YMAX)
    schema = {'EQ_NOM': {'type': 'string', 'maxlength': 10, 'contains_any_of': ['PBO', 'BPE', 'BAI']}, 
              'EQ_NOM_NOE': {'type': 'string', 'maxlength': 30}, 
              'EQ_ETAT': {'type': 'string', 'maxlength': 1, 'empty': False, 'allowed': ['0', '1', '2', '3', '4']}, 
              'EQ_OCCP': {'type': 'string', 'maxlength': 3, 'empty': False, 'allowed': ['0', '1.1', '1.2', '2', '3', '4']}, 
              'EQ_TYPE': {'type': 'string', 'empty': False, 'allowed': ['PBO', 'PBOE', 'BPE', 'BAI']}, 
              'EQ_TYPE_LQ': {'type': 'string', 'maxlength': 6, 'empty': False, 'allowed': ['PBO', 'BPE JB', 'BPE JD', 'BAIDC', 'BAIOP']}, 
              'EQ_TYPE_PH': {'type': 'string', 'maxlength': 24, 'empty': False, 'allowed': ['PBO 6', 'PBO 12', 'BPE 12EP', 'BPE 24EP', 'BPE 48EP', 'BPE 72EP', 'BPE 96EP', 'BPE 144EP', 'BPE 288EP', 'BPE 576EP', 'BPE 720EP', 'BAI']}, 
              'EQ_PRO': {'type': 'string', 'maxlength': 20, 'empty': False, 'allowed': ['MANCHE NUMERIQUE', 'COLLECTIVITE', 'ORANGE', 'PRIVE', 'AUTRE (à préciser)', 'NUL']}, 
              'EQ_GEST': {'type': 'string', 'maxlength': 20, 'empty': False, 'allowed': ['MANCHE NUMERIQUE', 'MANCHE TELECOM', 'COLLECTIVITE', 'ORANGE', 'MANCHE FIBRE', 'PRIVE', 'AUTRE (à préciser)', 'NUL']}, 
              'EQ_HAUT': {'empty': False, 'validator': is_float}, 
              'EQ_DATE_IN': {'empty': False, 'validator': is_modern_french_date}, 
              'EQ_COMMENT': {'type': 'string', 'maxlength': 300, 'empty': True}, 
              'EQ_STATUT': {'type': 'string', 'maxlength': 14, 'empty': False, 'allowed': ['APS', 'APD', 'EXE', 'REC']}}
        
    def __repr__(self):
        return "Equipement {}".format(self.EQ_NOM)

class Noeud(QgsModel):
    layername = "noeud_geo"
    geom_type = QgsModel.GEOM_POINT
    crs = CRS
    bounding_box = (XMIN,YMIN,XMAX,YMAX)
    schema = {'NO_NOM': {'type': 'string', 'maxlength': 30}, 
              'NO_ID_INSE': {'type': 'string', 'empty': False, 'regex': r'50\d{3}'}, 
              'NO_VOIE': {'type': 'string', 'maxlength': 100}, 
              'NO_ETAT': {'type': 'string', 'maxlength': 1, 'empty': False, 'allowed': ['0', '1', '2', '3', '4']}, 
              'NO_OCCP': {'type': 'string', 'maxlength': 3, 'empty': False, 'allowed': ['0', '1.1', '1.2', '2', '3', '4']}, 
              'NO_TYPE': {'type': 'string', 'maxlength': 3, 'empty': False, 'allowed': ['CHA', 'POT', 'LTE', 'SEM', 'FAC', 'OUV', 'IMM']}, 
              'NO_TYPE_LQ': {'type': 'string', 'maxlength': 10, 'empty': False, 'allowed': ['CHTIR', 'CHRACC', 'POT', 'NRO', 'PM', 'MIMO', 'FAC', 'OUV', 'IMM']}, 
              'NO_TYPE_PH': {'type': 'string', 'maxlength': 20, 'empty': False, 'allowed': ['CHAMBRE', 'POTEAU', 'ARMOIRE', 'SHELTER', 'BATIMENT', 'SITE MIMO', 'FACADE', 'OUVRAGE', 'IMMEUBLE']}, 
              'NO_CODE_PH': {'type': 'string', 'maxlength': 20}, 
              'NO_TECH_PS': {'type': 'string', 'maxlength': 20, 'multiallowed': ['COAX', 'CUT', 'ECL', 'ELEC', 'VP', 'OPT', 'NC']}, 
              'NO_AMO': {'type': 'string', 'maxlength': 20}, 
              'NO_PLINOX': {'required':False, 'type': 'string', 'maxlength': 3, 'allowed': ['OUI', 'NON']}, 
              'NO_X': {'empty': False, 'validator': is_float}, 
              'NO_Y': {'empty': False, 'validator': is_float}, 
              'NO_PRO': {'type': 'string', 'maxlength': 20, 'empty': False, 'allowed': ['MANCHE NUMERIQUE', 'COLLECTIVITE', 'ORANGE', 'ERDF', 'PRIVE', 'ENEDIS', 'AUTRE (à préciser)', 'NUL']}, 
              'NO_GEST': {'type': 'string', 'maxlength': 20, 'empty': False, 'allowed': ['MANCHE NUMERIQUE', 'MANCHE TELECOM', 'COLLECTIVITE', 'ORANGE', 'ERDF', 'ENEDIS', 'MANCHE FIBRE', 'PRIVE', 'AUTRE (à préciser)', 'NUL']}, 
              'NO_HAUT': {'empty': False, 'validator': is_float}, 
              'NO_DATE_IN': {'empty': False, 'validator': is_modern_french_date}, 
              'NO_REF_PLA': {'type': 'string', 'maxlength': 100}, 
              'NO_SRC_GEO': {'type': 'string', 'maxlength': 50}, 
              'NO_QLT_GEO': {'type': 'string', 'maxlength': 1, 'empty': False, 'allowed': ['A', 'B', 'C']}, 
              'NO_PRO_MD': {'type': 'string', 'maxlength': 20, 'empty': False, 'allowed': ['MANCHE NUMERIQUE']}, 
              'NO_COMMENT': {'type': 'string', 'maxlength': 300, 'empty': True}, 
              'NO_STATUT': {'type': 'string', 'maxlength': 14, 'empty': False, 'allowed': ['APS', 'APD', 'EXE', 'REC']}}

    def __repr__(self):
        return "Noeud {}".format(self.NO_NOM)
    
class Tranchee(QgsModel):
    layername = "tranchee_geo"
    geom_type = QgsModel.GEOM_LINE
    crs = CRS
    bounding_box = (XMIN,YMIN,XMAX,YMAX)
    schema = {'TR_ID_INSE': {'type': 'string', 'empty': False, 'regex': r'50\d{3}'}, 
              'TR_VOIE': {'type': 'string', 'maxlength': 200}, 
              'TR_TYP_IMP': {'type': 'string', 'empty': False, 'allowed': ['ACCOTEMENT STABILISE', 'ACCOTEMENT NON STABILISE', 'CHAUSSEE LOURDE', 'CHAUSSEE LEGERE', 'FOSSE', 'TROTTOIR', 'ESPACE VERT', 'ENCORBELLEMENT']}, 
              'TR_MOD_POS': {'type': 'string', 'empty': False, 'allowed': ['TRADITIONNEL', 'MICRO TRANCHEE', 'FONCAGE 60', 'FONCAGE 90', 'FONCAGE 120', 'TRANCHEUSE', 'FORAGE URBAIN', 'FORAGE RURAL', 'ENCORBELLEMENT']}, 
              'TR_LONG': {'empty': False, 'validator': is_float}, 
              'TR_LARG': {'empty': False, 'validator': is_float}, 
              'TR_REVET': {'empty':True, 'type': 'string', 'allowed': ['SABLE', 'BICOUCHE', 'ENROBE', 'BETON', 'PAVE', 'TERRAIN NATUREL']}, 
              'TR_CHARGE': {'empty': False, 'validator': is_float}, 
              'TR_GRILLAG': {'empty':True, 'validator': is_float}, 
              'TR_REMBLAI': {'type': 'string'}, 
              'TR_PLYNOX': {'type': 'string', 'empty': False, 'allowed': ['OUI', 'NON']}, 
              'TR_PRO_VOI': {'type': 'string', 'empty': False, 'allowed': ['COMMUNE', 'COMMUNAUTE DE COMMUNES', 'DEPARTEMENT', 'ETAT', 'PRIVE']}, 
              'TR_GEST_VO': {'type': 'string', 'empty': False, 'allowed': ['COMMUNE', 'COMMUNAUTE DE COMMUNES', 'DEPARTEMENT', 'ETAT', 'PRIVE']}, 
              'TR_SCHEMA': {'maxlength': 100, 'type': 'string'}, 
              'TR_DATE_IN': {'empty': False, 'validator': is_modern_french_date}, 
              'TR_SRC_GEO': {'type': 'string', 'maxlength': 50}, 
              'TR_QLT_GEO': {'type': 'string', 'empty': False, 'allowed': ['A', 'B', 'C']}, 
              'TR_PRO_MD': {'type': 'string', 'maxlength': 20}, 
              'TR_COMMENT': {'type': 'string', 'maxlength': 300, 'empty': True}, 
              'TR_STATUT': {'type': 'string', 'empty': False, 'allowed': ['APS', 'APD', 'EXE', 'REC']}}

    def __repr__(self):
        return "Tranchee {}".format(self.TR_VOIE)
    
class Zapbo(QgsModel):
    layername = "zapbo_geo"
    geom_type = QgsModel.GEOM_POLYGON
    crs = CRS
    bounding_box = (XMIN,YMIN,XMAX,YMAX)
    schema = {'ID_ZAPBO': {'type': 'string', 'maxlength': 30, 'contains_any_of': ['PBO', 'BPE']}, 
              'COMMENTAIR': {'type': 'string', 'maxlength': 254, 'empty': True}, 
              'STATUT': {'type': 'string', 'empty': False, 'allowed': ['APS', 'APD', 'EXE', 'REC']}}
    
    def __repr__(self):
        return "Zapbo {}".format(self.ID_ZAPBO)
    
    
    
####### Validateur
    
    
class Validator(BaseValidator):
    schema_name = "Mn1 REC"
    models = [Artere, Cable, Equipement, Noeud, Tranchee, Zapbo]
    
    def _technical_validation(self):
        
        # construction des index
        arteres = self.dataset[Artere]
        cables = self.dataset[Cable]
        tranchees = self.dataset[Tranchee]
        
        noeuds = {}
        for noeud in self.dataset[Noeud]:
            if not noeud.NO_NOM in noeuds:
                noeuds[noeud.NO_NOM] = noeud
            else:
                self.log_error(UniqueError("Doublons dans le champs: {}".format(noeud), layername=Noeud.layername, field="NO_NOM"))
        
        equipements = {}
        for equipement in self.dataset[Equipement]:
            if not equipement.EQ_NOM in equipements:
                equipements[equipement.EQ_NOM] = equipement
            else:
                self.log_error(UniqueError("Doublons dans le champs: {}".format(equipement), layername=Equipement.layername, field="EQ_NOM"))
                
        zapbos = {}
        for zapbo in self.dataset[Zapbo]:
            if not zapbo.ID_ZAPBO in zapbos:
                zapbos[zapbo.ID_ZAPBO] = zapbo
            else:
                self.log_error(UniqueError("Doublons dans le champs: {}".format(zapbo), layername=Zapbo.layername, field="ID_ZAPBO"))
        
        # rattachement les noeuds aux artères     
        for artere in arteres:
            try:
                artere.noeud_a = noeuds[artere.AR_NOEUD_A]
            except KeyError:
                artere.noeud_a = None
                self.log_error(RelationError("Le noeud '{}' n'existe pas".format(artere.AR_NOEUD_A), layername=Artere.layername, field="AR_NOEUD_A"))
                
            try:
                artere.noeud_b = noeuds[artere.AR_NOEUD_B]
            except KeyError:
                artere.noeud_b = None
                self.log_error(RelationError("Le noeud '{}' n'existe pas".format(artere.AR_NOEUD_B), layername=Artere.layername, field="AR_NOEUD_A"))
        
        # rattachement des equipements aux cables
        for cable in cables:
            try:
                cable.equipement_a = equipements[cable.CA_EQ_A]
            except KeyError:
                cable.equipement_a = None
                self.log_error(RelationError("L'équipement '{}' n'existe pas".format(cable.CA_EQ_A), layername=Cable.layername, field="CA_EQ_A"))
                
            try:
                cable.equipement_b = equipements[cable.CA_EQ_B]
            except KeyError:
                cable.equipement_b = None
                self.log_error(RelationError("L'équipement '{}' n'existe pas".format(cable.CA_EQ_B), layername=Cable.layername, field="CA_EQ_B"))

        # rattachement des equipements aux noeuds
        for equipement in equipements.values():
            try:
                equipement.noeud = noeuds[equipement.EQ_NOM_NOE]
            except KeyError:
                equipement.noeud = None
                self.log_error(RelationError("Le noeud '{}' n'existe pas".format(equipement.EQ_NOM_NOE, equipement.EQ_NOM), layername=Equipement.layername, field="EQ_NOM_NOE"))

        # verifie que tous les equipements sont l'equipement B d'au moins un cable
        equipements_b = [cable.CA_EQ_B for cable in cables]
        for eq_id in equipements:
            if equipements[eq_id].EQ_TYPE == "BAI":
                continue
            if not eq_id in equipements_b:
                self.log_error(RelationError("L'equipement '{}' n'est l'équipement B d'aucun cable".format(eq_id), layername=Equipement.layername, field="EQ_NOM"))

        # controle des doublons graphiques
        for i, tranchee in enumerate(tranchees):
            for other in tranchees[i+1:]:
                if tranchee.geom == other.geom:
                    self.log_error(DuplicatedGeom("Une entité graphique est dupliquée".format(tranchee), layername=Tranchee.layername, field="geom"))
                    
        for i, artere in enumerate(arteres):
            for other in arteres[i+1:]:
                if artere.geom == other.geom:
                    self.log_error(DuplicatedGeom("Une entité graphique est dupliquée ('{}')".format(artere), layername=Artere.layername, field="geom"))

        for i, cable in enumerate(cables):
            for other in cables[i+1:]:
                if cable.geom == other.geom and cable.CA_EQ_A == other.CA_EQ_A and cable.CA_EQ_B == other.CA_EQ_B:
                    self.log_error(DuplicatedGeom("Une entité graphique est dupliquée ('{}')".format(cable), layername=Cable.layername, field="geom"))
        
        ls_noeuds = list(noeuds.values())
        for i, noeud in enumerate(ls_noeuds):
            for other in ls_noeuds[i+1:]:
                if noeud.geom == other.geom:
                    self.log_error(DuplicatedGeom("Une entité graphique est dupliquée ('{}')".format(noeud), layername=Noeud.layername, field="geom"))
        del ls_noeuds
        
        ls_zapbos = list(zapbos.values())
        for i, zapbo in enumerate(ls_zapbos):
            for other in ls_zapbos[i+1:]:
                if zapbo.geom == other.geom:
                    self.log_error(DuplicatedGeom("Une entité graphique est dupliquée ('{}')".format(zapbo), layername=Zapbo.layername, field="geom"))
        del ls_zapbos
           
        # Arteres: comparer la géométrie à celle des noeuds
        for artere in arteres:
            if not artere.noeud_a or not artere.noeud_b:
                continue
            
            if not any(((artere.points[0].distanceSquared(artere.noeud_a.points[0]) <= TOLERANCE and \
                         artere.points[-1].distanceSquared(artere.noeud_b.points[0]) <= TOLERANCE), 
                        (artere.points[0].distanceSquared(artere.noeud_b.points[0]) <= TOLERANCE and \
                         artere.points[-1].distanceSquared(artere.noeud_a.points[0]) <= TOLERANCE))):
                self.log_error(MissingItem("Pas de noeud aux coordonnées attendues ('{}')".format(artere), layername=Artere.layername, field="geom"))
        
        
        # Cables: comparer la géométrie à celle des equipements (on utilise en fait la geom du noeud correspondant à l'équipement)
        for cable in cables:
            if not cable.equipement_a or not cable.equipement_b or not cable.is_geometry_valid() or not cable.equipement_a.noeud or not cable.equipement_b.noeud:
                continue
            
            if not any(((cable.points[0].distanceSquared(cable.equipement_a.noeud.points[0]) <= TOLERANCE and \
                         cable.points[-1].distanceSquared(cable.equipement_b.noeud.points[0]) <= TOLERANCE), 
                        (cable.points[0].distanceSquared(cable.equipement_b.noeud.points[0]) <= TOLERANCE and \
                         cable.points[-1].distanceSquared(cable.equipement_a.noeud.points[0]) <= TOLERANCE))):
            
                self.log_error(MissingItem("Pas d'equipement aux coordonnées attendues ('{}')".format(cable), layername=Cable.layername, field="geom"))
            
            
        # Verifie que chaque tranchée a au moins une artère
        arteres_full_buffer = QgsGeometry().unaryUnion([a.geom for a in arteres]).buffer(TOLERANCE, 100)
        
        for tranchee in tranchees:
            if not arteres_full_buffer.contains(tranchee.geom):
                self.log_error(MissingItem("Tranchée ou portion de tranchée sans artère ('{}')".format(tranchee), layername=Tranchee.layername, field="*"))
        
        # Verifie que chaque cable a au moins une artère (sauf si commentaire contient 'baguette')
        for cable in cables:
            if "baguette" in cable.CA_COMMENT.lower() or not cable.is_geometry_valid():
                continue
            if not arteres_full_buffer.contains(cable.geom):
                self.log_error(MissingItem("Cable ou portion de cable sans artère ('{}')".format(cable), layername=Cable.layername, field="*"))
        
        del arteres_full_buffer
        
        # Verifie que chaque artère a au moins un cable (sauf si commentaire contient un de ces mots 'racco client adductio attente bus 'sans cable'')
        
        cables_full_buffer = QgsGeometry().unaryUnion([c.geom for c in cables]).buffer(TOLERANCE, 100)
        
        for artere in arteres:
            if any(x in artere.AR_COMMENT.lower() for x in ['racco','client','adductio','attente','bus','sans cable']):
                continue
            if not cables_full_buffer.contains(artere.geom):
                self.log_error(MissingItem("Artère sans cable ('{}')".format(artere), layername=Artere.layername, field="*"))
        
        # Contrôle des dimensions logiques
        for artere in arteres:
            try:
                if not int(artere.AR_FOU_DIS) <= int(artere.AR_NB_FOUR):
                    self.log_error(DimensionError("Le nombre de fourreaux disponibles doit être inférieur au nombre total ('{}')".format(artere), layername=Artere.layername, field="AR_FOU_DIS"))
            except (TypeError, ValueError):
                pass
         
        for cable in cables:
            try:
                if not int(cable.CA_NB_FO_U) <= int(cable.CA_NB_FO):
                    self.log_error(DimensionError("Le nombre de fourreaux utilisés doit être inférieur au nombre total ('{}')".format(cable), layername=Cable.layername, field="CA_NB_FO_U"))
                if not int(cable.CA_NB_FO_D) <= int(cable.CA_NB_FO):
                    self.log_error(DimensionError("Le nombre de fourreaux disponibles doit être inférieur au nombre total ('{}')".format(cable), layername=Cable.layername, field="CA_NB_FO_D"))
            except (TypeError, ValueError):
                pass
         
        # Verifier que chaque equipement de type PBO est contenu dans une zapbo, et que le nom de la zapbo contient le nom de l'equipement
        for equipement in equipements.values():
            if not equipement.EQ_TYPE == "PBO":
                continue
             
            #zapbos englobant l'equipement
            candidates = []
            for zapbo in zapbos.values():
                if zapbo.geom.contains(equipement.geom):
                    candidates.append(zapbo)
                     
            # le pbo doit être contenu dans une zapbo
            if not candidates:
                self.log_error(MissingItem("Le PBO n'est contenu dans aucune ZAPBO: {}".format(equipement), layername=Equipement.layername, field="geom"))
                continue
             
            # On se base sur le nom pour trouver la zapbo correspondante
            try:
                equipement.zapbo = next((z for z in candidates if equipement.EQ_NOM in z.ID_ZAPBO))
            except StopIteration:
                self.log_error(MissingItem("Le nom du PBO ne coincide avec le nom d'aucune des ZAPBO qui le contient: {}".format(equipement), layername=Equipement.layername, field="EQ_NOM"))
                break
             
            if not hasattr(equipement.zapbo, "nb_prises") or equipement.zapbo.nb_prises is None:
                equipement.zapbo.nb_prises = 0
             
            # Controle du dimensionnement des PBO
            if equipement.EQ_TYPE_PH == 'PBO 6' and not equipement.zapbo.nb_prises < 6:
                self.log_error(DimensionError("Le PBO 6 contient plus de 5 prises: {}".format(equipement), layername=Equipement.layername, field="*"))
         
            if equipement.EQ_TYPE_PH == 'PBO 12' and not equipement.zapbo.nb_prises >= 6 and equipement.zapbo.nb_prises <= 8:
                self.log_error(DimensionError("Le PBO 12 contient mois de 6 prises ou plus de 8 prises: {}".format(equipement), layername=Equipement.layername, field="*"))
         
            if equipement.zapbo.STATUT == "REC" and not equipement.EQ_STATUT == "REC":
                self.log_error(TechnicalValidationError("Le statut du PBO n'est pas cohérent avec le statut de sa ZAPBO: {}".format(equipement), layername=Equipement.layername, field="*"))
         
            if equipement.EQ_STATUT == "REC" and not equipement.zapbo.STATUT == "REC" and not equipement.zapbo.ID_ZAPBO[:4].lower() == "att_":
                self.log_error(TechnicalValidationError("Le statut du PBO n'est pas cohérent avec le statut de sa ZAPBO: {}".format(equipement), layername=Equipement.layername, field="*"))