Re: ERROR 000496 and Delete_management

GregoireCatineau — Wed, 15 Jun 2022 16:53:31 GMT

# 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

topic Re: ERROR 000496 and Delete_management in Python Questions

ERROR 000496 and Delete_management

Re: ERROR 000496 and Delete_management

Re: ERROR 000496 and Delete_management

Re: ERROR 000496 and Delete_management

Re: ERROR 000496 and Delete_management