ERROR 000496 and Delete_management

GregoireCatineau

Hello,

On SDE ( Register as Versioned )  when a run a Python 3.7.11 (ArcGis Pro) script with a cursor and setValue I take the following error at the arcpy.Delete_management instruction :

arcgisscripting.ExecuteError: ERROR 000496: table is being edited

Is this normal ?

 

GregoireCatineau

# coding: utf-8

#

# ATTENTION :

#

#    - la version de python utilisée est : Python 3.7.11 . c'est la version utilisée par ARCGIS Pro.

#    - il faut alors faire un unregister as versioned puis lancer ce script et ensiote faire un Register as versionned

#    

#

# but du script : calcul des ratio, sommes, et des champs doubles comptes des secteurs opérationnels.

#

# pour les ZAC toujours calc égal brut

#

# les champs suivants dans la base devront avoir été préalablement renommé :

# NB_LOG_CALC -> NB_LOG_RATIO

# M2_LOG_CALC -> M2_LOG_RATIO

#

# en effet les caluls seront enregistrés dans les champs ??_LOG_CALC ( anciennement utilisé avec double comptes)

#

#

#   champ  : b_exclusion_m2_sdc_calc ='O' A exclure pour le calcul des m² sans double-compte / à exclure du calcul des sans double compte. 'N' à compter calculer en sans double compte.

#

#

#

#  en cas de certains champs non renseignés dans la couche d'origine, comme par exemple n_sq_co, il faut lancer le script (toolbox) STAT_BD_PROJET  ( cocher la case NSQ )

#  qui est dans Z:\SIG\12_BDPPC\maj_pc\script\BD_PROJET

#  penser à rafraichir la liste dans arccatalog si toujours le problème.

#

#

# si erreur   "ERROR 160706: Cannot acquire a lock."  une autre ouverture de la couche doit exister. sinon Réouvrir la session windows ou au pire redémarrer le PC.

#

#

#  afin de débuger le programme mettre en commentaire les appels au fonctions suivante :

#

#  initialisation_champs_calc(feature_layer_temp)

#

#  calcul_ratio(list_layer)

#

#

#   la varaiable on_arcigs_pro détecte si on lance le programme depuis une toolbox ou non en consultant l'état non vide de arcpy.GetParameterAsText(0)

#

#

#   si erreur de données de type None si le champ "n_sq_co" il faut alors lancer préalablement le script STAT_BD_PROJET de la toolbox BD_PROJET.tbx

#

#   ATTENTION IL PEUT Y AVOIR UNE ERREUR SI CE DOSSIER N'EXISTE PAS SUR LE POSTE LOCAL DE L'UTILISATEUR :

#   arcpy.env.workspace = r"c:\\Temp.gdb"  

 

import os

import sys  # pour sys.exit()

import arcpy

import datetime

import time # juste pour le sleep() en fin de programme

# listes les départements (optinnel)

dep_PARIS = ["75"]

dep_PC = ["92","93","94"]

dep_GC = ["77","78","91","95"]

 

# liste des années

annees = ["","_2025","_2030"]

 

# liste des type de surface m2 et nb

type_surf_m2 = ['m2_log','m2_log_soc','m2_bur','m2_act','m2_eq','m2_com','m2_hot','m2_evp','m2_tot','m2_acteco']

# type_surf_m2 = ['m2_log','m2_log_soc']

# log_soc = logements sociaux   log_res = logements residences

# pas de nb_log_res_calc ?

# type_surf_nb = ['nb_log','nb_log_soc','nb_log_res']

type_surf_nb = ['nb_log','nb_log_soc']

# suffixe des valeurs sans double comptes et ratio

 

debug=True # peut etre utiliser pour des comportements de code différents ou l'affichage de traces

 

suffixe_sdc = "_calc"

 

suffixe_ratio = "_ratio"

# flag pour savoir si on est sous l'env arcgis pro ou en mode extérieur pour l'execution de ce module.

 

on_arcigs_pro = False

 

# si à True on effectue le traitement en direct sur SDE, sinon en local

traitement_sde = True

 

# si à True on effectue initalement le traitement des totaux et ratios.

traitement_ratio_totaux=True

 

# feature layer à traiter :

 

#gdb_feature_source="apur.projet.secteur_oper"

if not traitement_sde:

    gdb_feature_source="secteur_oper_02_05_2022"

else:

    gdb_feature_source="secteur_oper"

# workspace arcgis pour la gdb :

 

# arcpy.env.workspace = r"\\zsfa\ZSF-APUR\SIG\06_RESSOURCES\Connexions\utilisateur@apur@zpostgresig.sde"

 

if not traitement_sde:

    arcpy.env.workspace = r"c:\\Temp.gdb"  # ATTENTION IL PEUT Y AVOIR UNE ERREUR SI CE DOSSIER N'EXISTE PAS SUR LE POSTE LOCAL DE L'UTILISATEUR

else:

    arcpy.env.workspace = r"\\zsfa\ZSF-APUR\SIG\12_BDPPC\maj_pc\script\connexions_sde\projet.sde"

# message composé avec la timeline

def ArcMessage(message😞

    message=str(message)

    # disable info if we are inside the arcgis python environment

    info=datetime.datetime.now().strftime('[%H:%M:%S][%Y-%m-%d]')

    # enable arcpy.AddMessage if we are inside the arcgis python environment

    if on_arcigs_pro:

        arcpy.AddMessage(info+" "+message)

    else:

    # enable print if we are outside of the arcgis python environment

        print(info+" "+message)

if (arcpy.GetParameterAsText(0)) is not None and (arcpy.GetParameterAsText(0))!='':

    on_arcigs_pro = True

    #gdb_feature_source = arcpy.GetParameterAsText(0)

    traitement_ratio_totaux = arcpy.GetParameter(0)

    ArcMessage("lancement depuis la toolbox - couche a traiter : "+gdb_feature_source)

 

# layers à traiter :

list_layer = [gdb_feature_source]

# creation d'un champ spécifique s'il n'existe pas déjà.

def add_field_if_not_exist(featureclass,new_field😞

    try:

        #ArcMessage("recuperation de la liste des champs...")

        Listfields = arcpy.ListFields(featureclass)

        field_names = [f.name for f in arcpy.ListFields(featureclass)]

        if new_field in field_names:

            ArcMessage("champ :"+new_field+" existe deja !")

        else:

 

            #arcpy.AddField_management(feature_class_name, champ_special.lower(), "TEXT",field_length=1000)

            ArcMessage("creation du champ : ",new_field)

 

    except:

        ArcMessage("impossible d acceder au fichier :"+feature)

        return

# on efface toutes les valeurs des champs calc de type surf_m2 et surf_nb pour toute les années

def effacer_calc_row_toutes_annees(row,annees,valeur😞

 

    # mettre tout type_surf_m2 = ['m2_log','m2_log_soc','m2_bur','m2_act','m2_eq','m2_com','m2_hot','m2_evp','m2_acteco']

 

    for i in range(0,len(annees)):

        for surf_m2 in type_surf_m2:

           

            row.setValue(surf_m2+suffixe_sdc+annees[i],valeur)

        for surf_nb in type_surf_nb:

         

            row.setValue(surf_nb+suffixe_sdc+annees[i],valeur)

            #if surf_nb!='nb_log_res':

            #    row.setValue(surf_nb+suffixe_sdc+annees[i],valeur)

 

    return row

# retourne un dictionnaire rempli avec les champs spécifiés (type_surf_m2 et type_surf_nb) de la row pour toutes les années et de type calc nb et m2.

 

def lire_row_calc_avec_annees(row,annees😞

    zone_dans_pru_dict={}

    zone_dans_pru_dict['id_zone']=row.getValue("objectid")

    zone_dans_pru_dict['type_zone']=row.getValue("c_ns")

    for i in range(0,len(annees)):

        # les champs de type m2 # à revoir.

        for type_surf_m2_ in type_surf_m2:

            if type_surf_m2_=='m2_acteco':

                zone_dans_pru_dict[type_surf_m2_+suffixe_sdc+annees[i]]=row.getValue(type_surf_m2_+suffixe_sdc+annees[i])

            else:

                zone_dans_pru_dict[type_surf_m2_+suffixe_sdc+annees[i]]=row.getValue(type_surf_m2_+suffixe_sdc+annees[i])

                # zone_dans_pru_dict[type_surf_m2_+suffixe_sdc+annees[i]]=row.getValue(type_surf_m2_+annees[i])

 

        # les champs de type nb

        for type_surf_nb_ in type_surf_nb:

            if type_surf_nb_=='nb_acteco': # pas de nb pour acteco_calc

                zone_dans_pru_dict[type_surf_nb_+suffixe_sdc+annees[i]]=None

            else:

                zone_dans_pru_dict[type_surf_nb_+suffixe_sdc+annees[i]]=row.getValue(type_surf_nb_+suffixe_sdc+annees[i])

                # zone_dans_pru_dict[type_surf_nb_+suffixe_sdc+annees[i]]=row.getValue(type_surf_nb_+annees[i])

        # somme des valeurs qui se cumulent dans les champs avec suffixe _sum

        # zone_dans_pru_dict['m2_log_calc_sum'+annees[i]]=(zone_dans_pru_dict['m2_log_calc'+annees[i]] or 0)+(row.getValue("m2_log_calc"+annees[i]) or 0)

        # zone_dans_pru_dict['nb_log_calc_sum'+annees[i]]=(zone_dans_pru_dict['nb_log_calc'+annees[i]] or)+(row.getValue("nb_log_calc"+annees[i]) or 0)

        # zone_dans_pru_dict['m2_log_soc_calc_sum'+annees[i]]=(zone_dans_pru_dict['m2_log_soc_calc'+annees[i]] or 0)+(row.getValue("m2_log_soc_calc"+annees[i]) or 0)

        # zone_dans_pru_dict['nb_log_soc_calc_sum'+annees[i]]=(zone_dans_pru_dict['nb_log_soc_calc'+annees[i]] or 0)+(row.getValue("nb_log_soc_calc"+annees[i]) or 0)

 

    return zone_dans_pru_dict

 

# preparer la nouvelle row avec les nouveaux enregistrements calculé à ecrire dedans.

# def ecrire_row_avec_annees_et_calcul(row,tableau,annees):

#     for i in range(0,len(tableau)):

#         # en position zéro, on a la PRU elle-même

#         zone_dans_pru_dict=tableau[i]

#         objectid=zone_dans_pru_dict['id_zone']

#         type_zone=zone_dans_pru_dict['type_zone']

#         for i in range(0,len(annees)):

 

#             m2_log_calc_annees[i]=zone_dans_pru_dict["m2_log_calc"+annees[i]]

#             nb_log_calc_annees[i]=zone_dans_pru_dict["nb_log_calc"+annees[i]]

#             m2_log_soc_calc_annees[i]=zone_dans_pru_dict["m2_log_soc_calc"+annees[i]]

#             nb_log_soc_calc_annees[i]=zone_dans_pru_dict["nb_log_soc_calc"+annees[i]]

 

#     return row

 

#

#

# 14/04/2022

#

# reprise du script secteur_oper_calc_v4.py qui est exécuté en second traitement dans ce module.

#

# calcul des ratio sur les champs : NB_LOG_RATIO, M2_LOG_RATIO,  NB_LOG_SOC_RATIO M2_LOG_SOC_RATIO  M2_TOT_CALC, M2_TOT_CALC_2030

#

#   le faire sur toutes les années = Oui

#

#

def calcul_ratio(list_layer😞

   # debut de traitement

    for i in range (len(list_layer)):

 

       feature = str(list_layer[i])

       feature_layer = str(list_layer[i])+"_layer"

 

       # print feature+"    "+feature_layer

       arcpy.MakeFeatureLayer_management(feature, feature_layer, "", "", "")

       ArcMessage("***************************************************************************************")

       ArcMessage("traitement des champs NB_LOG_RATIO, M2_LOG_RATIO, M2_ACTECO_CALC, M2_TOT_CALC de la couche :"+list_layer[i]+" ... ")

 

       # 1 ) NB_LOG_RATIO - c'est le nombre de logement calculés

       #

       # égal au nombre de logements programmés (NB_LOG) si renseigné

       # sinon calculé en fonction de la surface de logements programmés (M2_LOG) selon un ration qui diffère entre Paris et le reste de la Métropole

       # M2_LOG  75 PARIS = 59 M2   + op�ration de calcul

       #         92,93,94 PC    = 69

       #         77,78,91,95 GC = 89

       #

       #   nombre logement

       #   NB_LOG_RATIO      = M2_LOG / (surf dep)

       #

       #

       #

       for annee in annees:

           ArcMessage("traitement du champ NB_LOG_RATIO   annee : ".rjust(55)+annee)

           arcpy.SelectLayerByAttribute_management(feature_layer, "" )

           # lire le code département

           # affecter la valeur qui correspont à surface suivant le département

           # calculer la surface LOG divisée par la surface moyenne d'un logement.

           fields = arcpy.ListFields(feature_layer)

           fields = ['NB_LOG_RATIO'+annee]

           cursor = arcpy.UpdateCursor(feature_layer,fields)

           for row in cursor:

            #if row.getValue("objectid")==2802:

            #    print("debug")

 

            NB_LOG= row.getValue("NB_LOG"+annee)

            M2_LOG= row.getValue("M2_LOG"+annee)

            NB_LOG_ratio=None

 

            # NB_LOG vide ou Null et M2_LOG renseigné.

            if (NB_LOG==0 or NB_LOG==None) and ((M2_LOG or 0)>0😞

                # calcul des ratios:

                # fonctionnement différent qu'en python 2.7 : dep_from_n_sq_co = str(int(row.getValue("n_sq_co"))/10000000)

                dep_from_n_sq_co = str(int(int(row.getValue("n_sq_co"))/10000000))

                if dep_from_n_sq_co in dep_PARIS:

                    NB_LOG_ratio = int(M2_LOG / 59)

                if dep_from_n_sq_co in dep_PC:

                    NB_LOG_ratio = int(M2_LOG / 69)

                if dep_from_n_sq_co in dep_GC:

                    NB_LOG_ratio = int(M2_LOG / 89)

 

                if NB_LOG_ratio==None:   # si NB_LOG vide

                    row.setNull("NB_LOG_RATIO"+annee)

                else:

                    #row.setValue("NB_LOG_RATIO"+annee,96969)   # attention risque d'erreur si pas de droits d'écriture

                    row.setValue("NB_LOG_RATIO"+annee,int(NB_LOG_ratio))   # attention risque d'erreur si pas de droits d'écriture

 

            # si aucun champ renseigné ni NB_LOG ni M2_LOG.

            elif (NB_LOG==0 or NB_LOG==None) and ((M2_LOG or 0)==0 or (M2_LOG==None)):

                row.setNull("NB_LOG_RATIO"+annee)

            else:

                assert NB_LOG!=None, "NB LOG"+annee+" à None"

                # donc si NB_LOG est renseigné on met le NB_LOG ( le brut)

                row.setValue("NB_LOG_RATIO"+annee,int(NB_LOG)) # row.setValue("NB_LOG_ ",int(NB_LOG))

 

            cursor.updateRow(row)

            #print (f"id ={row.getValue('objectid')}   annee = {annee}    commune={row.getValue('n_sq_co')}     M2_LOG={M2_LOG}    NB_LOG={NB_LOG}     NB_LOG_RATIO={row.getValue('NB_LOG_ratio'+annee)}")

 

           del cursor, row

 

           ArcMessage("fin de traitement du champ NB_LOG_RATIO   annee : ".rjust(55)+annee)

       #

       # 2 ) M2_LOG_RATIO  - c'est la surface de logement calculés

       #

       #  il est égal à la surface programmée (M2_Log) si renseignée

       #    sinon calculer elle est estimée suivant le nombre de logement programmés (NB_LOG)

       #    75 PARIS = 59 M2   + opération de calcul

       #         92,93,94 PC    = 69

       #         77,78,91,95 GC = 89

       #

 

       for annee in annees:

 

           ArcMessage("traitement du champ M2_LOG_RATIO   annee : ".rjust(55)+annee)

           arcpy.SelectLayerByAttribute_management(feature_layer, "new_selection", "" )

 

           fields = ['M2_LOG_RATIO'+annee]

           cursor = arcpy.UpdateCursor(feature_layer,fields)

           for row in cursor:

                #if row.getValue("objectid")==3 and annee=='_2030':

                #    print("debug")

 

                M2_LOG=row.getValue("M2_LOG"+annee)

                NB_LOG=row.getValue("NB_LOG"+annee)

                M2_LOG_ratio=None

                if (M2_LOG==0 or M2_LOG is None) and ((NB_LOG or 0)>0😞

                    if row.getValue("n_sq_co")==None:

                        print("none type")

                    dep_from_n_sq_co = str(int(int(row.getValue("n_sq_co"))/10000000))

                    if dep_from_n_sq_co in dep_PARIS:

                        M2_LOG_ratio = NB_LOG * 59

                    if dep_from_n_sq_co in dep_PC:

                        M2_LOG_ratio = NB_LOG * 69

                    if dep_from_n_sq_co in dep_GC:

                        M2_LOG_ratio = NB_LOG * 89

                        # NB_LOG = surface_log

                        # example https://pro.arcgis.com/fr/pro-app/arcpy/classes/row.htm

                    if M2_LOG_ratio==None: # si M2_LOG vide

                        row.setNull("M2_LOG_RATIO"+annee)

                    else:

                        row.setValue("M2_LOG_RATIO"+annee,int(M2_LOG_ratio))   # attention risque d'erreur si pas de droits d'�criture

                # si aucun champ renseigné ni NB_LOG ni M2_LOG.

                elif (M2_LOG==0 or M2_LOG is None) and ((NB_LOG or 0)==0 or (NB_LOG==None)):

                     row.setNull("M2_LOG_RATIO"+annee)

                else:

                     assert M2_LOG!=None, "M2 LOG"+annee+" à None"

                      # donc si M2_LOG est renseigné on met le M2_LOG ( le brut)

                     row.setValue("M2_LOG_RATIO"+annee,int(M2_LOG)) # row.setValue("NB_LOG_ ",int(NB_LOG))

 

                cursor.updateRow(row)

                #print (f"id ={row.getValue('objectid')}   annee = {annee}    commune={row.getValue('n_sq_co')}     M2_LOG={M2_LOG}    NB_LOG={NB_LOG}     M2_LOG_RATIO={row.getValue('M2_LOG_ratio'+annee)}")

 

           del cursor, row

           ArcMessage("fin de traitement du champ M2_LOG_RATIO   annee : ".rjust(55)+annee)

 

       # 3 ) NB_LOG_SOC_RATIO - c'est le nombre de logement sociaux calculés

       #

       # égal au nombre de logements programmés (NB_LOG_SOC) si renseigné

       # sinon calculé en fonction de la surface de logements programmés (M2_LOG_SOC) selon un ration qui diffère entre Paris et le reste de la Métropole

       # M2_LOG  75 PARIS = 59 M2   + op�ration de calcul

       #         92,93,94 PC    = 69

       #         77,78,91,95 GC = 89

       #

       #   nombre logement

       #   NB_LOG_RATIO      = M2_LOG / (surf dep)

       #

       #

       #

       for annee in annees:

           ArcMessage("traitement du champ NB_LOG_SOC_RATIO   annee : ".rjust(55)+annee)

           arcpy.SelectLayerByAttribute_management(feature_layer, "new_selection" )

           # lire le code département

           # affecter la valeur qui correspont à surface suivant le département

           # calculer la surface LOG divisée par la surface moyenne d'un logement.

           fields = arcpy.ListFields(feature_layer)

           fields = ['NB_LOG_SOC_RATIO'+annee]

           cursor = arcpy.UpdateCursor(feature_layer,fields)

           for row in cursor:

            #if row.getValue("objectid")==2802:

            #    print("debug")

 

            NB_LOG= row.getValue("NB_LOG_SOC"+annee)

            M2_LOG= row.getValue("M2_LOG_SOC"+annee)

            NB_LOG_ratio=None

 

            # NB_LOG vide ou Null et M2_LOG renseigné.

            if (NB_LOG==0 or NB_LOG==None) and ((M2_LOG or 0)>0😞

                # calcul des ratios:

                # fonctionnement différent qu'en python 2.7 : dep_from_n_sq_co = str(int(row.getValue("n_sq_co"))/10000000)

                dep_from_n_sq_co = str(int(int(row.getValue("n_sq_co"))/10000000))

                if dep_from_n_sq_co in dep_PARIS:

                    NB_LOG_ratio = int(M2_LOG / 59)

                if dep_from_n_sq_co in dep_PC:

                    NB_LOG_ratio = int(M2_LOG / 69)

                if dep_from_n_sq_co in dep_GC:

                    NB_LOG_ratio = int(M2_LOG / 89)

 

                if NB_LOG_ratio==None:   # si NB_LOG vide

                    row.setNull("NB_LOG_SOC_RATIO"+annee)

                else:

                    row.setValue("NB_LOG_SOC_RATIO"+annee,int(NB_LOG_ratio))   # attention risque d'erreur si pas de droits d'écriture

 

            # si aucun champ renseigné ni NB_LOG ni M2_LOG.

            elif (NB_LOG==0 or NB_LOG==None) and ((M2_LOG or 0)==0 or (M2_LOG==None)):

                row.setNull("NB_LOG_SOC_RATIO"+annee)

            else:

                assert NB_LOG!=None, "NB LOG"+annee+" à None"

                # donc si NB_LOG est renseigné on met le NB_LOG ( le brut)

                row.setValue("NB_LOG_SOC_RATIO"+annee,int(NB_LOG)) # row.setValue("NB_LOG_ ",int(NB_LOG))

           

            cursor.updateRow(row)

            #print (f"id ={row.getValue('objectid')}   annee = {annee}    commune={row.getValue('n_sq_co')}     M2_LOG_SOC={M2_LOG}    NB_LOG_SOC={NB_LOG}     NB_LOG_SOC_RATIO={row.getValue('NB_LOG_soc_ratio'+annee)}")

 

           del cursor, row

 

           ArcMessage("fin de traitement du champ NB_LOG_SOC_RATIO   annee : ".rjust(55)+annee)

       #

       # 4 ) M2_LOG_SOC_RATIO  - c'est la surface de logement calculés

       #

       #  il est égal à la surface programmée de logement sociaux (M2_Log_soc) si renseignée

       #    sinon calculer elle est estimée suivant le nombre de logement programmés (NB_LOG_soc)

       #    75 PARIS = 59 M2   + opération de calcul

       #         92,93,94 PC    = 69

       #         77,78,91,95 GC = 89

       #

 

       for annee in annees:

 

           ArcMessage("traitement du champ M2_LOG_SOC_RATIO   annee : ".rjust(55)+annee)

           arcpy.SelectLayerByAttribute_management(feature_layer, "new_selection", "" )

 

           fields = ['M2_LOG_SOC_RATIO'+annee]

           cursor = arcpy.UpdateCursor(feature_layer,fields)

           for row in cursor:

                #if row.getValue("objectid")==3 and annee=='_2030':

                #    print("debug")

 

                M2_LOG=row.getValue("M2_LOG_SOC"+annee)

                NB_LOG=row.getValue("NB_LOG_SOC"+annee)

                M2_LOG_ratio=None

                if (M2_LOG==0 or M2_LOG is None) and ((NB_LOG or 0)>0😞

                    if row.getValue("n_sq_co")==None:

                        print("none type")

                    dep_from_n_sq_co = str(int(int(row.getValue("n_sq_co"))/10000000))

                    if dep_from_n_sq_co in dep_PARIS:

                        M2_LOG_ratio = NB_LOG * 59

                    if dep_from_n_sq_co in dep_PC:

                        M2_LOG_ratio = NB_LOG * 69

                    if dep_from_n_sq_co in dep_GC:

                        M2_LOG_ratio = NB_LOG * 89

                        # NB_LOG = surface_log

                        # example https://pro.arcgis.com/fr/pro-app/arcpy/classes/row.htm

                    if M2_LOG_ratio==None: # si M2_LOG vide

                        row.setNull("M2_LOG_SOC_RATIO"+annee)

                    else:

                        row.setValue("M2_LOG_SOC_RATIO"+annee,int(M2_LOG_ratio))   # attention risque d'erreur si pas de droits d'�criture

                # si aucun champ renseigné ni NB_LOG ni M2_LOG.

                elif (M2_LOG==0 or M2_LOG is None) and ((NB_LOG or 0)==0 or (NB_LOG==None)):

                     row.setNull("M2_LOG_SOC_RATIO"+annee)

                else:

                     assert M2_LOG!=None, "M2 LOG"+annee+" à None"

                      # donc si M2_LOG est renseigné on met le M2_LOG ( le brut)

                     row.setValue("M2_LOG_SOC_RATIO"+annee,int(M2_LOG)) # row.setValue("NB_LOG_ ",int(NB_LOG))

 

                cursor.updateRow(row)

                #print (f"id ={row.getValue('objectid')}   annee = {annee}    commune={row.getValue('n_sq_co')}     M2_LOG_SOC={M2_LOG}    NB_LOG_SOC={NB_LOG}     M2_LOG_SOC_RATIO={row.getValue('M2_LOG_soc_ratio'+annee)}")

 

           del cursor, row

           ArcMessage("fin de traitement du champ M2_LOG_SOC_RATIO   annee : ".rjust(55)+annee)

       # M2_TOT_CALC =======================================================================================================

 

       # 5 ) M2_TOT_CALC c'est la surface totale calculee des batiments. (logements + activites + equipements)

       #

       #  est egal a M2_TOT si renseigne

       #  sinon est egal a M2_LOG_RATIO + M2_ACTECO_CALC + M2_EQ

       #

 

       for annee in annees:

 

       

           ArcMessage("traitement du champ M2_TOT_CALC annee : ".rjust(55)+annee)

           arcpy.SelectLayerByAttribute_management(feature_layer, "new_selection", "" )

           fields = ['M2_TOT_CALC'+annee]

           cursor = arcpy.UpdateCursor(feature_layer,fields)

           for row in cursor:

              OBJECTID=row.getValue("objectid") # pour debugage

 

              # en 1er M2_TOT

              M2_TOT = row.getValue("M2_TOT"+annee)

              M2_LOG = row.getValue("M2_LOG_RATIO"+annee)

              M2_ACT = row.getValue("M2_ACTECO_CALC"+annee) # pas de champ M2_ACTECO.

              M2_EQ = row.getValue("M2_EQ"+annee)

              row.setNull("M2_TOT_CALC"+annee)

              # faire une fois

              if annee==annees[0]:

                  row.setNull("B_M2PROGDET_RENS")

                  row.setNull("B_M2PROGTOT_RENS")

              # si tout les champs à aditionner sont à none on ne met que le M2_TOT s'il n'est pas à None.

              if M2_TOT is not None and (M2_LOG is None and M2_ACT is None and M2_EQ is None😞

                 row.setValue("M2_TOT_CALC"+annee,int(M2_TOT))

                 row.setValue("B_M2PROGTOT_RENS","O")

                 # print "setvalue M2_TOT_CALC" ce cas existe

              else:

           

                    #print ("CAS TROUVE M2_TOT_CALC:"+str(surface_log))

                 # sinon on cacul # mettre des setValue pour mettre des zéro au lieu de None.

                 if M2_LOG is None:

                    M2_LOG=0

                 if M2_ACT is None:

                    M2_ACT=0

                 if M2_EQ is None:

                    M2_EQ=0

                 surface_tot = M2_LOG+M2_ACT+M2_EQ

                 if (surface_tot>0😞

                    row.setValue("M2_TOT_CALC"+annee,int(surface_tot))

                    row.setValue("B_M2PROGDET_RENS","O")

                    row.setValue("B_M2PROGTOT_RENS","O")

                    # print "setvalue M2_TOT_CALC" ce cas existe

 

              cursor.updateRow(row)

           del cursor, row

           ArcMessage(" fin de traitement du champ M2_TOT_CALC annee : ".rjust(55)+annee)

       # ============================================================================================================================================================================================================================

       # 6 ) M2_ACTECO_CALC - c'est la surface totale d'activite calculee (sommes des activites)

       # = somme de M2_BUR + M2_COM + M2_ACT + M2_HOT

       #

       for annee in annees:

           ArcMessage("traitement du champ M2_ACTECO_CALC annee : ".rjust(55)+annee+" et m2_act -> m2_act_calc")

 

           arcpy.SelectLayerByAttribute_management(feature_layer, "new_selection", "" )

           # nombre selectionne = arcpy.GetCount_management(feature_layer).getOutput(0)))

 

           fields = ['M2_ACTECO'+suffixe_sdc,'M2_ACT'+suffixe_sdc] # 'M2_ACTECO_CALC' à la place de 'M2_ACT_CALC'

           cursor = arcpy.UpdateCursor(feature_layer, fields)

           for row in cursor:

               

               #if row.getValue("objectid") == 821:

               #    print("debug")

               M2_BUR = row.getValue("M2_BUR"+annee)

               if M2_BUR is None:

                   M2_BUR=0

               M2_COM = row.getValue("M2_COM"+annee)

               if M2_COM is None:

                   M2_COM=0

               M2_ACT = row.getValue("M2_ACT"+annee)

               if M2_ACT is None:

                   M2_ACT=0

               M2_HOT = row.getValue("M2_HOT"+annee)

               row.setNull("M2_ACT_CALC"+annee)

               if M2_HOT is None:

                   M2_HOT=0

               surface_act = M2_BUR+M2_COM+M2_ACT+M2_HOT

               if surface_act>0:

                   # row.setValue("M2_ACTECO_CALC",int(surface_act)) # commenté le 14/06/2022

                   row.setValue("M2_ACTECO_CALC"+annee,int(surface_act)) # ajouté le 14/06/2022

                   row.setValue("M2_ACTECO_SOMME"+annee,int(surface_act)) # ajouté le 14/06/2022

 

               # Attention ici:

               # report de act dans act_calc  

               #

               row.setValue("M2_ACT"+suffixe_sdc+annee,(row.getValue("M2_ACT"+annee) or 0))

           

               cursor.updateRow(row)

                   # print "M2_ACTECO_CALC = "+str(surface_act) # ce cas existe

           del cursor, row

           ArcMessage("fin de traitement du champ M2_ACTECO_CALC annee : ".rjust(55)+annee+" et m2_act -> m2_act_calc")

 

 

       # ============================================================================================================================================================================================================================

       # 6 ) M2_TOT_SOMME - c'est

       # la somme de M2_LOG_RATIO + M2_ACTECO_SOMME + M2_EQ

       #

       for annee in annees:

           ArcMessage("traitement du champ M2_TOT_SOMME annee : ".rjust(55)+annee+"")

 

           arcpy.SelectLayerByAttribute_management(feature_layer, "new_selection", "" )

           # nombre selectionne = arcpy.GetCount_management(feature_layer).getOutput(0)))

 

           fields = ['M2_TOT_SOMME'+annee]

           cursor = arcpy.UpdateCursor(feature_layer, fields)

           for row in cursor:

               

               #if row.getValue("objectid") == 821:

               #    print("debug")

               M2_LOG_RATIO = row.getValue("M2_LOG_RATIO"+annee)

               if M2_LOG_RATIO is None:

                   M2_LOG_RATIO=0

                   

               M2_ACTECO_SOMME = row.getValue("M2_ACTECO_SOMME"+annee)

               if M2_ACTECO_SOMME is None:

                   M2_ACTECO_SOMME=0

                   

               M2_EQ = row.getValue("M2_EQ"+annee)

               if M2_EQ is None:

                   M2_EQ=0

           

               surface_tot_somme = M2_LOG_RATIO+M2_ACTECO_SOMME+M2_EQ

               if surface_tot_somme>0:

                   row.setValue("M2_TOT_SOMME"+annee,int(surface_tot_somme))

               else: # sinon on met la valeur de M2_TOT+annee

                   row.setValue("M2_TOT_SOMME"+annee,(row.getValue("M2_TOT"+annee) or 0))

           

           

               cursor.updateRow(row)

                   # print "M2_ACTECO_CALC = "+str(surface_act) # ce cas existe

           del cursor, row

           ArcMessage("fin de traitement du champ M2_TOT_SOMME annee : ".rjust(55)+annee+"")

 

       arcpy.Delete_management(feature_layer, "")

    ArcMessage("***************************************************************************************")

 

# ( pour toutes les types de secteur )

# on affecte tous les champs calc de type surf_m2 et surf_nb pour toutes les années avec le champ brut correspondant ou le ratio correspondant si logement.

# pour toutes les années

# suffixe_sdc = '_calc'

#

def initialisation_champs_calc(feature😞

    ArcMessage("initialisation des champs ["+suffixe_sdc+"]")

    cursor = arcpy.UpdateCursor(feature,['*'])

    for row in cursor:

        for annee in annees:

            #if row.getValue('objectid')==754:

            #    print("debug")

            # intilasiation des champs calc avec le brut

            for surf_m2 in type_surf_m2:

                if "log" in surf_m2:  # prendre ratio pour les logement m2

                    row.setValue(surf_m2+suffixe_sdc+annee,row.getValue(surf_m2+"_ratio"+annee))

                else:

                    if surf_m2=="m2_acteco": # pas de "m2_acteco" sans _calc

                        row.setValue(surf_m2+suffixe_sdc+annee,0)

                    else:

                        row.setValue(surf_m2+suffixe_sdc+annee,row.getValue(surf_m2+annee))

                # après coup, si Null dans _calc on met 0

                if row.getValue(surf_m2+suffixe_sdc+annee)==None:

                    row.setValue(surf_m2+suffixe_sdc+annee,0)

 

            for surf_nb in type_surf_nb:

                if surf_nb!='nb_log_res':

                    if "log" in surf_nb: # prendre ratio pour les logement nb

                        row.setValue(surf_nb+suffixe_sdc+annee,row.getValue(surf_nb+"_ratio"+annee))

                    else:

                        row.setValue(surf_nb+suffixe_sdc+annee,row.getValue(surf_nb+annee))

                # après coup, si Null dans _calc on met 0

                if row.getValue(surf_nb+suffixe_sdc+annee)==None:

                    row.setValue(surf_nb+suffixe_sdc+annee,0)    

 

        cursor.updateRow(row)

    del cursor, row

    ArcMessage("fin d'initialisation des champs ["+suffixe_sdc+"]")

#

# calcul des sommes des _calc de toutes les zones (sauf la n°0 = PRU ) pour chaque année et les deux type nb et m2.

#

# ( row = row de la pru)

def caclul_sommes_calc_annees(row,annees,zones_du_pru😞

 

    # m2_log_calc_sum=[0]*len(annees)

    # nb_log_calc_sum=[0]*len(annees)

    # m2_log_soc_calc_sum=[0]*len(annees)

    # nb_log_soc_calc_sum=[0]*len(annees)

 

    champs_m2_calc_sum=[[0]*len(annees) for i in range(len(type_surf_m2))]   # [type_surf_m2[annees]] ex : ['m2_log_calc'['','2025','2030'],nb_log_calc['','2025','2030']]

    champs_nb_calc_sum=[[0]*len(annees) for i in range(len(type_surf_nb))]

 

    #

    # ne pas partir de zéro car c'est la zone contenante qui est en zéro, la normalement la pru

    #

    # sommages dans deux tableaux (nb, et m2) à partir du dictionnaire zones_du_pru

    #

    #   i_zones_du_pru numéro de la zone de 0 à len(zones_pru) y compris la PRU elle même

    #

    # pour une année

    for i_annee in range(0,len(annees)):

       

        i_type_surface=0 # indice de type de surface pour nb et m2

        # pour un type de surface m2:

        for type_surf_m2_ in type_surf_m2:

            # pour une zone dans la pru

            for i_zones_du_pru in range(1,len(zones_du_pru)): # -1 pour ne pas prendre en compte la PRU

           

                champs_m2_calc_sum[i_type_surface][i_annee]+=(zones_du_pru[i_zones_du_pru][type_surf_m2_+suffixe_sdc+annees[i_annee]] or 0)    

            i_type_surface+=1            

       

        i_type_surface=0

        # pour un type de surface nb:

        for type_surf_nb_ in type_surf_nb:

 

            for i_zones_du_pru in range(1,len(zones_du_pru)): # -1 pour ne pas prendre en compte la PRU

         

                champs_nb_calc_sum[i_type_surface][i_annee]+=(zones_du_pru[i_zones_du_pru][type_surf_nb_+suffixe_sdc+annees[i_annee]] or 0)    

            i_type_surface+=1

 

    # calcul des delta de la valeur de la PRU et la somme des m² des secteurs qui sont à l'inérieur, si le delta >0 on ecrit la valeur dans les m² du PRU (row).

    # ABE Quid des autres m² ??? (bureau, activité, équipement, commerce, hôtel, evp) et m² total

 

    # type_surf_m2 = ['m2_log','m2_log_soc','m2_bur','m2_act','m2_eq','m2_com','m2_hot','m2_evp','m2_tot','m2_acteco']

    # calculs de delta à partir et sur les champs de la PRU (row)

    #

    # le zones_du_pru[0] = PRU elle même.

    #

    delta_positif=False

    for j in range(0,len(annees)):

 

        # traitement des m2

        k=0

        for type_surf_m2_ in type_surf_m2:

            #

           

            # ne rien faire pour ces 2 cas

            if  "m2_tot" in type_surf_m2_ or "m2_actgeco" in type_surf_m2:

                pass

            else:

                # m2 normaux

                if row.getValue(type_surf_m2_+suffixe_sdc+annees[j])!=None and ((zones_du_pru[0][type_surf_m2_+suffixe_sdc+annees[j]] or 0)-champs_m2_calc_sum[k][j])>0:

                    row.setValue(type_surf_m2_+suffixe_sdc+annees[j],((zones_du_pru[0][type_surf_m2_+suffixe_sdc+annees[j]] or 0)-champs_m2_calc_sum[k][j]))

                    delta_positif=True

            k+=1

        # traitement des nb

        k=0

        for type_surf_nb_ in type_surf_nb:

            if row.getValue(type_surf_nb_+suffixe_sdc+annees[j])!=None and ((zones_du_pru[0][type_surf_nb_+suffixe_sdc+annees[j]] or 0)-champs_nb_calc_sum[k][j])>0:

                row.setValue(type_surf_nb_+suffixe_sdc+annees[j],((zones_du_pru[0][type_surf_nb_+suffixe_sdc+annees[j]] or 0)-champs_nb_calc_sum[k][j]))

                #print(str(type_surf_nb_+suffixe_sdc+annees[j])+" = "+str(row.getValue(type_surf_nb_+suffixe_sdc+annees[j])))

                delta_positif=True

            k+=1

    if delta_positif:

        ArcMessage("delta positif trouve d'une somme de secteurs avec le secteur englobant id : ["+str(row.getValue("objectid"))+"] ecriture..")

    # déduire les sommes des valeurs de la PRU si les sommes sont inférieures

    # si résultat négatif on mets à zéro le valeur dans la row du PRU.

    return row

 

#

# ----------------------------------------- DEBUT DU MAIN ------------------------------------------------------------------

#

# constitution des dictionnaires avec les champs concernés qui vont service à effectuer les calcul de sans double compte pour une PRU.

ArcMessage("debut du traitement :"+os.path.abspath('.').upper())

 

ArcMessage("set env : "+arcpy.env.workspace)

 

somme_annees_calc = {}

 

for i in range(0,len(annees)):

    somme_annees_calc["m2_log_calc"+annees[i]]=None

    somme_annees_calc["nb_log_calc"+annees[i]]=None

    somme_annees_calc["m2_log_soc_calc"+annees[i]]=None

    somme_annees_calc["nb_log_soc_calc"+annees[i]]=None

# M2 calc = M2 brut ( M2_log_ratio pour les logements )

# NB calc = NB brut ( NB_log_ratio pour les logements )

 

for i in range (len(list_layer)):

 

    feature = str(list_layer[i])

 

    ArcMessage("working feature:"+str(list_layer))

 

    # pour layer temporaire

    feature_layer_temp = str(list_layer[i])+"_temp_layer"

 

    ArcMessage("make feature layer temp:"+feature_layer_temp)

 

    if not arcpy.Exists(feature😞

        ArcMessage("impossible d'ouvrir la couche : "+feature)

        break

 

    # MakeFeatureLayer_management de arcgis desktop

    # arcpy.MakeFeatureLayer_management(feature, feature_layer_temp, "", "", "")

   

    arcpy.management.MakeFeatureLayer(feature, feature_layer_temp,"")

       

    # initialisation des champs calc avec les champs brut ( non calc)

    initialisation_champs_calc(feature_layer_temp)

    arcpy.Delete_management(feature_layer_temp, "")

 

   

 

   

    #  calcul des ratio et totaux sur les champs : NB_LOG_RATIO, M2_LOG_RATIO,NB_LOG_SOC_RATIO, M2_LOG_SOC_RATIO, M2_TOT_CALC, M2_TOT_CALC_2030

 

    if traitement_ratio_totaux:

        calcul_ratio(list_layer)

 

    # sys.exit("fin traitement pour debuggage")

 

    # les layer temporaires pour la selection spatiale

    #

    # pour la selection spatiale, il faut générer deux feature layer temporaires:

 

    arcpy.MakeFeatureLayer_management(feature, feature_layer_temp,"b_exclusion_m2_sdc_calc IS NOT NULL")

    # arcpy.management.MakeFeatureLayer(feature, feature_layer_temp,"b_exclusion_m2_sdc_calc IS NOT NULL")

   

 

    ArcMessage("make feature layer temp: ZAC et PRU...")

 

    #      une des PRU feature_layer_PRU_temp :  c_ns = 'PRU' et  b_actif = 'O'

    # ABE: Pourquoi cette sélection?  Elle est refaite plus tard sur le PRU en cours de traitement...

 

    # arcpy.management.MakeFeatureLayer(feature, feature_layer_temp+"_PRU","c_ns = 'PRU' and b_actif = 'O'")

    arcpy.management.MakeFeatureLayer(feature, feature_layer_temp+"_PRU")

    #

 

    #      l'autre des ZAC feature_layer_ZAC :  c_ns in ('ZAC','AUT')  et  b_actif='O' et  c_av=2 (en cours de réalisation)

 

    arcpy.management.MakeFeatureLayer(feature, feature_layer_temp+"_ZAC_AUT","c_ns in ('ZAC','AUT') and b_actif='O' and c_av=2")

    #

 

    # creation des champs suivant s'il n'existent pas déjà

##    for annee in annees:

##        add_field_if_not_exist(feature_layer_temp,"m2_log"+suffixe_sdc+annee)

##        add_field_if_not_exist(feature_layer_temp,"nb_log"+suffixe_sdc+annee)

##        add_field_if_not_exist(feature_layer_temp,"m2_log_soc"+suffixe_sdc+annee)

##        add_field_if_not_exist(feature_layer_temp,"nb_log_soc"+suffixe_sdc+annee)

 

    ArcMessage("traitement des b_exclusion_m2_sdc_calc == 'O' :"+list_layer[i]+" ... ")

 

    arcpy.SelectLayerByAttribute_management(feature_layer_temp, "" )

 

    pru_count=arcpy.GetCount_management(feature_layer_temp)

 

    ArcMessage("parcours d'un ensemble de "+str(pru_count)+" secteurs:")

 

    # selection des champs

    fields = ['NB_LOG_RATIO']

    # parcours du cursor de toutes les Row de type 'PRU'

    #cursor = arcpy.UpdateCursor(feature_layer_temp,fields)

    cursor = arcpy.UpdateCursor(feature_layer_temp,fields) # 15/06/2022

    # effacer tout les calc:

    for row in cursor:

        pru_id = row.getValue("objectid")

 

        #arcpy.AddWarning(pru_id)

 

        # si b_exclusion_m2_sdc_calc =='O'  ( dans la cas d'un chevauchement)

        if row.getValue("b_exclusion_m2_sdc_calc")=='O':

            if row.getValue("c_ns") in ['PRU','AUT']:

 

                ArcMessage(" ")

                try:

                    ArcMessage("object id :["+str(row.getValue("objectid"))+"] de type:"+str(row.getValue("c_ns"))+" b_exclusion_m2_sdc_calc=='O' nom:"+str(row.getValue("l_nom_se_min")))

                except:

                    ArcMessage("object id :["+str(row.getValue("objectid"))+"] de type:"+str(row.getValue("c_ns"))+" b_exclusion_m2_sdc_calc=='O' nom (non affiche pbl utf-8)")

                #ArcMessage("object id :["+str(row.getValue("objectid"))+"] de type:"+str(row.getValue("c_ns"))+" b_exclusion_m2_sdc_calc=='O' nom:"+str(row.getValue("l_nom_se_min")))

                # ArcMessage("object id :["+str(row.getValue("objectid"))+"] effacement des champs "+suffixe_sdc+" : "+str(type_surf_nb)+" "+str(type_surf_m2))

 

                row=effacer_calc_row_toutes_annees(row,annees,0)

 

                cursor.updateRow(row)

        # else ( donc b_exclusion_m2_sdc_calc = 'N' ) ( traiter les zones à calculer en double comptes )

        elif row.getValue("b_exclusion_m2_sdc_calc")=='N' and row.getValue("c_ns")=='PRU':

             # pour chaque row de type 'PRU' dans cursor

           

 

            # selection du PRU courant afin d'y baser la selection spatiale

 

            arcpy.SelectLayerByAttribute_management(feature_layer_temp+"_PRU", "new_selection","objectid="+str(pru_id))

            matchcount_pru = int(arcpy.GetCount_management(feature_layer_temp+"_PRU")[0])

            # selection spatiale des PRU dont des ZAC ont leur centroide à l'intérieur (c_ns in ('AUT','ZAC') and b_actif =='O')

            # calculer m2_calc_logement = m2bautçlogement - somme ("m2_brut_logement des opérations selectionnées)

 

            arcpy.SelectLayerByLocation_management (feature_layer_temp+"_ZAC_AUT", "HAVE_THEIR_CENTER_IN",feature_layer_temp+"_PRU","","NEW_SELECTION" )

            matchcount_zac_aut = int(arcpy.GetCount_management(feature_layer_temp+"_ZAC_AUT")[0])

            # devrait avoir 3 résultats. (2171,2175,2390 ) zac_aut incluent

            #arcpy.SelectLayerByLocation_management (feature_layer_temp+"_PRU", "HAVE_THEIR_CENTER_IN",feature_layer_temp+"_ZAC" )

 

            # le nombre de PRU qui comporte des zac_aut

            matchcount = int(arcpy.GetCount_management(feature_layer_temp+"_ZAC_AUT")[0])

            # if matchcount !=0:

            #     print("non")

            #     pass

            if matchcount ==0:

                pass

            #ArcMessage("PRU:"+str(pru_id)+" pas de ZAC/AUT à l interieur")

            else:

 

                #ArcMessage("        arcpy.SelectLayerByLocation_management ("+feature_layer_temp+'_zac_aut'+", 'HAVE_THEIR_CENTER_IN',"+feature_layer_temp+'_pru'+",'','NEW_SELECTION' )")

 

                ArcMessage(" ")

                try:

                    ArcMessage("il y a ["+str(matchcount)+"] ZAC_AUT  qui ont leur centroide dans le PRU '"+str(row.getValue("l_nom_se_min")))

                except:

                    ArcMessage("il y a ["+str(matchcount)+"] ZAC_AUT  qui ont leur centroide dans le PRU '"+" nom (non affiche pbl utf-8)")

                ArcMessage("objectid:"+str(pru_id).ljust(6)+" de la PRU       "+"".ljust(40)+" "+str(row.getValue("nb_log"))+" "+str(row.getValue("m2_log"))+" "+str(row.getValue("nb_log_2025"))+" "+str(row.getValue("m2_log_2025"))+" "+str(row.getValue("nb_log_2030"))+" "+str(row.getValue("m2_log_2030")))

                ArcMessage("-------------------------------------------------------------------------nb---m2---nb2020-m22020-nb2025-m22025-nb_030-m22030")

                #ArcMessage("cas c_ns=='PRU' and b_exclusion_m2_sdc_calc='N'  -  objectid : "+str(pru_id)+" nom de la PRU : "+str(row.getValue("l_nom_se_min")))

 

                somme_annee=[0]*len(annees) # afin d'y mettre les sommes '','2025','2030' de toutes les zac_aut incluses dans le PRU courant

 

                #if pru_id == 687:

                #    print(pru_id)

                #    pass

 

                zones_du_pru=[]

                # ajouter les infos du PRU dans le tableau zones_du_pru

                # REMARQUE : le premier élément de ce tableau 'zones_du_pru' est toujours la PRU elle même. Donc en position 0

                zones_du_pru.append(lire_row_calc_avec_annees(row,annees))

                cursor_zac_aut = arcpy.SearchCursor(feature_layer_temp+"_ZAC_AUT")

                 # parcours du curseur des ZAC et AUT contenu dans le PRU (SelectLayerByLocation_management).

                for row_zac_aut in cursor_zac_aut:

 

                    try:

                        ArcMessage("objectid:"+str(row_zac_aut.getValue("objectid")).ljust(6)+" nom de la "+str(row_zac_aut.getValue("c_ns"))+" : "+str(row_zac_aut.getValue("l_nom_se_min")).ljust(40)+" "+str(row_zac_aut.getValue("nb_log"))+" "+str(row_zac_aut.getValue("m2_log"))+" "+str(row_zac_aut.getValue("nb_log_2025"))+" "+str(row_zac_aut.getValue("m2_log_2025"))+" "+str(row_zac_aut.getValue("nb_log_2030"))+" "+str(row_zac_aut.getValue("m2_log_2030"))+" m2_acteco_calc:"+str(row_zac_aut.getValue("m2_acteco_calc")))

                    except:

                        ArcMessage("objectid:"+str(row_zac_aut.getValue("objectid")).ljust(6)+" nom de la "+str(row_zac_aut.getValue("c_ns"))+" : nom (non affiche pbl utf-8) ".ljust(40)+" "+str(row_zac_aut.getValue("nb_log"))+" "+str(row_zac_aut.getValue("m2_log"))+" "+str(row_zac_aut.getValue("nb_log_2025"))+" "+str(row_zac_aut.getValue("m2_log_2025"))+" "+str(row_zac_aut.getValue("nb_log_2030"))+" "+str(row_zac_aut.getValue("m2_log_2030")))

                    annee_i=0

 

                    zones_du_pru.append(lire_row_calc_avec_annees(row_zac_aut,annees))

                del cursor_zac_aut,row_zac_aut

 

                # if pru_id == 206:

                #     print(pru_id)

                 

                 # mise à jour des row avec les sommes des _calc calculées pour la PRU.

                row = caclul_sommes_calc_annees(row,annees,zones_du_pru)

               

                cursor.updateRow(row)

 

 

                #

                # sommes=caclul_sommes_calc_annees()

                # faire le calcul des sans double compte de la PRU avec ses zones incluses. ( pour toutes annees sur différents champs nb_log, m2_log, nb_log_soc, m2_log_soc)

                # si la somme(m2_log_calc[0] - les m2_log_calc[>0] ) est négative alors ne pas y toucher sinon mettre le resultat dans le m2_log_calc[0]

                # attention aux valeurs à None

                # procedé :

                # établisement des sommes m2_log_calc[>0]

                # comparaison des sommes et du m2_log_calc[0]

    del cursor, row

    # traitement final des m2_tot et m2_acteco:  m2_log_calc+m2_acteco_calc+m2_eq_calc

 

    arcpy.Delete_management(feature_layer_temp, "")  # sur SDE on a l'erreur arcgisscripting.ExecuteError: ERROR 000496: table is being edited

                                                     # il faut alors faire un (1) unregister as versioned traiter puis  (2) Register as versionned

       

   

    # on recree le feature_layer_temp afin de repartir sur l'ensemble des enregistrements.

    arcpy.management.MakeFeatureLayer(feature, feature_layer_temp,"")

 

    ArcMessage("post traitement des totaux : m2_tot_calc et m2_acteco_calc ")

    # d'abord acteco

    #arcpy.SelectLayerByAttribute_management(feature_layer_temp, "NEW_SELECTION" )

    cursor = arcpy.UpdateCursor(feature_layer_temp,['*'])

    for row in cursor:

        #print("somme acteco :"+str(row.getValue('objectid')))

       

        #if row.getValue("objectid")==1114:

        #    print("debug")

 

        for j in range(0,len(annees)):          

            row.setValue('m2_acteco'+suffixe_sdc+annees[j],((row.getValue('m2_bur'+suffixe_sdc+annees[j]) or 0)+(row.getValue('m2_com'+suffixe_sdc+annees[j]) or 0)+(row.getValue('m2_act'+suffixe_sdc+annees[j]) or 0) +(row.getValue('m2_hot'+suffixe_sdc+annees[j]) or 0)))

        cursor.updateRow(row)

   

    # puis tot  

    cursor = arcpy.UpdateCursor(feature_layer_temp,['*'])

    for row in cursor:

        for j in range(0,len(annees)):

            row.setValue('m2_tot'+suffixe_sdc+annees[j],((row.getValue('m2_log'+suffixe_sdc+annees[j]) or 0)+(row.getValue('m2_acteco'+suffixe_sdc+annees[j]) or 0)+(row.getValue('m2_eq'+suffixe_sdc+annees[j]) or 0)))

       

        cursor.updateRow(row)

 

    ArcMessage("fin de traitement des totaux : m2_tot_calc et m2_acteco_calc ")

 

    # mettre tous les calc qui sont à None à zéro:

    ArcMessage("post traitement des "+suffixe_sdc+" à None -> 0")

    cursor = arcpy.UpdateCursor(feature_layer_temp,['*'])

    for row in cursor:

        for j in range(0,len(annees)):            

            for surf_m2 in type_surf_m2:

                if row.getValue(surf_m2+suffixe_sdc+annees[i]) is None: # modifié le 14/06/2022 == -> is

                    row.setValue(surf_m2+suffixe_sdc+annees[i],0)

            for surf_nb in type_surf_nb:

                if row.getValue(surf_nb+suffixe_sdc+annees[i]) is None: # aussi

                    row.setValue(surf_nb+suffixe_sdc+annees[i],0)

        cursor.updateRow(row)

                #if surf_nb!='nb_log_res':

                #    row.setValue(surf_nb+suffixe_sdc+annees[i],valeur)

    ArcMessage("fin de traitement des "+suffixe_sdc+" à None ->0 ")    

    del cursor, row

 

 

    ArcMessage("delete feature layer temp ...")

   

    arcpy.Delete_management(feature_layer_temp, "")  # sur SDE on a l'erreur arcgisscripting.ExecuteError: ERROR 000496: table is being edited

   

   

    arcpy.Delete_management(feature_layer_temp+"_PRU", "")

    arcpy.Delete_management(feature_layer_temp+"_ZAC_AUT", "")

    ArcMessage("fin de traitement")

    time.sleep(5) # attente de 5 secondes