614 lines
23 KiB
Python
Executable File
614 lines
23 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
# -*- coding: UTF-8 -*-
|
|
#Nom : : foncier_insert_table.py
|
|
#Description : Insertion des données cadastrales à la base <foncier>.
|
|
#Copyright : 2021, CEN38
|
|
#Auteur : Colas Geier
|
|
#Version : 2.0
|
|
|
|
|
|
from sqlalchemy import create_engine, text
|
|
from geoalchemy2 import Geometry # need for pandas
|
|
import datetime as dt
|
|
import pandas as pd
|
|
import sys
|
|
|
|
|
|
# Parametrage geopandas
|
|
import geopandas as gpd
|
|
import warnings; warnings.filterwarnings('ignore', 'GeoSeries.isna', UserWarning)
|
|
|
|
|
|
check_duplicates = True
|
|
debug = True
|
|
# Parametres bdd CADASTRE (in)
|
|
# Données de sortie du plugin qgis "Cadastre"
|
|
# Les schéma ont une nomenclarture numérique du type "dep_nom"
|
|
user_cad = 'postgres' # utilisateur de connexion à la bdd
|
|
pwd_cad = 'foncier_test1' # mot de passe de la bdd
|
|
adr_cad = '172.17.0.2' # adresse ip de la bdd
|
|
port_cad = '5432' # port de la bdd
|
|
base_cad = 'postgres' # nom de la bdd
|
|
schema_cad = '202007' # nom unique qui compose le nom des schémas cibles de l'année à récupérer
|
|
list_dep = ['07', '26', '42', '38'] # liste des départements
|
|
|
|
|
|
# Parametres bdd FONCIER (out)
|
|
user_fon = 'colas_geier'
|
|
pwd_fon = 'adm1n*fOncier'
|
|
adr_fon = '91.134.194.221'
|
|
# user_fon = 'postgres' # utilisateur de connexion à la bdd
|
|
# pwd_fon = 'tutu' # mot de passe de la bdd
|
|
# adr_fon = '192.168.60.9' # adresse ip de la bdd
|
|
port_fon = '5432' # port de la bdd
|
|
base_fon = 'bd_cen' # nom de la bdd
|
|
schema_fon = 'cadastre' # nom du schéma cible dans la bdd
|
|
sufx_nom_tab = '_38' # sufixe du nom des tables où insérer la données dans le schéma cadastre (ex: _dep)
|
|
|
|
|
|
# Correspondance entre les tables
|
|
epsg = '2154' # code EPSG de la projection géographique en entrée.
|
|
crs = 'EPSG:%s'%epsg
|
|
chunk = 100000
|
|
|
|
# Il existe parfois des doublons en raison d'orthographes voisinent (entre autres)
|
|
# dans les tables de sortie du du plugin qgis "Cadastre"
|
|
FIND_DOUBLON = [{
|
|
'tab_in': 'proprietaire', # nom de la table où des doublons se trouvent
|
|
'on_col': ['ddenom', 'dprnlp', 'dldnss','jdatnss','ccogrm','dsglpm','dnatpr'] } # nom des champs où des corrections sont nécessaires
|
|
]
|
|
|
|
DICT_TAB = [{
|
|
'table_in' : 'proprietaire', # Table source qui provient de la sortie du plugin cadastre de qgis
|
|
'index_tab': 'proprietaire', # Pkey de la table source
|
|
'columns_in': ['ccodep', 'ccocom', 'dnupro', # Liste exaustive des champs à récupérer dans la table source
|
|
'dnuper', 'ccoqua', 'ddenom', 'jdatnss', 'dldnss', 'dsglpm', 'dlign3', 'dlign4', 'dlign5', 'dlign6', 'dnatpr', 'gtoper', 'ccogrm'],
|
|
'table_out': [{
|
|
'name': 'cptprop{}'.format(sufx_nom_tab), # Nom de la table cible
|
|
'geom': None, # Existance d'une géometrie à récupérer pour insertion (Non: None, Oui: cf tab_out parcelle_xx ci-dessous)
|
|
'drop_escape': False, # Supprime les champs vides à l'intérieure des chaines de carractères
|
|
'columns_in': ['ccodep', 'ccocom', 'dnupro'], # Liste des columns à récupérer en entrée.
|
|
'columns_add': {'dnupro': ['ccodep', 'ccocom', 'dnupro']}, # Définition des champs composés devant être ajoutés
|
|
'unique': {'cols': ['dnupro'], 'keep': 'first'}, # Champs devant être uniques à l'intérieur de la table en sortie, keep: ['first', 'last', False]
|
|
'dict': None, # Dictionnaire pour renommer les champs {'ancien_nom1': 'nouveau_nom1', 'ancien_nom2': 'nouveau_nom2', ...}
|
|
'join': [{ # Jointure de tables à réaliser.
|
|
'bdd': 'in', # ['in', 'out']: jointure des tables à l'import / avant export
|
|
'table': 'suf', # Nom de la table à joindre
|
|
'select_cols' : ['ccodep', 'ccocom', 'dnupro'], # Nom des champs à récupérer
|
|
'on': ['ccodep', 'ccocom', 'dnupro'], # Nom des champs sur lesquelles faire la jointure
|
|
'type': 'concat' # Type de jointure à réaliser ['concat', 'merge', 'isin', 'notin']
|
|
# 'concat': concatène les 2 tables; 'merge': merge les 2 tables en fonction du paramètre 'on'
|
|
# 'isin': Conservation des données présentent dans les 2 tables en fonction du paramètre 'on'
|
|
# 'notin': Conservation des données NON présentent dans la table 'join' en fonction du paramètre 'on'
|
|
},{
|
|
'bdd': 'in', 'table': 'lots', 'on': ['ccodep', 'ccocom', 'dnupro'], 'type': 'concat',
|
|
'select_cols' : ['ccodep', 'ccocom', 'dnuprol'],'dict': {'dnuprol': 'dnupro'}},{
|
|
'bdd': 'in', 'table': 'parcelle', 'on': ['ccodep', 'ccocom', 'dnupro'], 'type': 'concat',
|
|
'select_cols' : ['ccodep', 'ccocom', 'dnupro']},]
|
|
},{
|
|
'name': 'proprios{}'.format(sufx_nom_tab),
|
|
'geom': None,
|
|
'drop_escape': True,
|
|
'columns_in': ['ccodep', 'dnuper', 'ccoqua', 'ddenom', 'jdatnss', 'dldnss', 'dsglpm', 'dlign3', 'dlign4', 'dlign5', 'dlign6', 'dnatpr', 'gtoper', 'ccogrm'],
|
|
'columns_add': {'dnuper': ['ccodep', 'dnuper']},
|
|
'unique': {'cols': ['dnuper'], 'keep': 'first'},
|
|
'dict': None,
|
|
'join': False
|
|
},{
|
|
'name': 'r_prop_cptprop{}'.format(sufx_nom_tab),
|
|
'geom': None,
|
|
'drop_escape': True,
|
|
'columns_in': ['ccodep', 'dnuper', 'ccocom', 'dnupro', 'dnomlp', 'dprnlp', 'epxnee', 'dnomcp', 'dprncp', 'ccodro', 'ccodem'],
|
|
'columns_add': {
|
|
'dnuper': ['ccodep', 'dnuper'],
|
|
'dnupro': ['ccodep', 'ccocom', 'dnupro']},
|
|
'unique': {'cols': ['dnupro', 'dnuper'], 'keep': 'first'},
|
|
'dict': None,
|
|
'join': False
|
|
},]
|
|
},{
|
|
'table_in' : 'parcelle',
|
|
'index_tab': 'parcelle',
|
|
'columns_in' : ['ccodep', 'ccocom', 'ccopre', 'ccosec', 'dnupla', 'ccovoi', 'dparpi', 'dcntpa', 'ccocomm', 'ccoprem', 'ccosecm', 'dnuplam', 'dvoilib', 'type_filiation'],
|
|
'table_out': [{
|
|
'name': 'vl{}'.format(sufx_nom_tab),
|
|
'geom': None,
|
|
'drop_escape': False,
|
|
'columns_in' : ['ccodep', 'ccocom', 'ccovoi', 'dvoilib'],
|
|
'columns_add': {
|
|
'vl_id': ['ccodep', 'ccocom', 'ccovoi'],
|
|
'geom': None},
|
|
'unique': {'cols': ['vl_id'], 'keep': 'first'},
|
|
'dict': {'dvoilib': 'libelle'},
|
|
'join': [{
|
|
'bdd': 'in', 'table': 'voie', 'on': ['ccodep', 'ccocom', 'ccovoi'], 'type': 'concat',
|
|
'select_cols' : ['ccodep', 'ccocom', 'codvoi', 'libvoi'],
|
|
'dict': {'libvoi': 'libelle', 'codvoi': 'ccovoi'},
|
|
}]
|
|
},{
|
|
'name': 'parcelles{}'.format(sufx_nom_tab),
|
|
'geom': {
|
|
'table_geom_in': 'geo_parcelle',
|
|
'index_geom': 'geo_parcelle'
|
|
},
|
|
'drop_escape': True,
|
|
'columns_in' : ['ccodep', 'ccocom', 'ccopre', 'ccosec', 'dnupla', 'ccovoi', 'dparpi', 'dcntpa', 'ccocomm', 'ccoprem', 'ccosecm', 'dnuplam', 'type_filiation'],
|
|
'columns_add': {
|
|
'par_id': ['ccodep', 'ccocom', 'ccopre','ccosec', 'dnupla'],
|
|
'codcom': ['ccodep', 'ccocom'],
|
|
'vl_id': ['ccodep', 'ccocom', 'ccovoi'],
|
|
'typprop_id': None },
|
|
'unique': False,
|
|
'dict': {'type_filiation': 'type'},
|
|
'join': False
|
|
},{
|
|
'name': 'lots{}'.format(sufx_nom_tab),
|
|
'geom': None,
|
|
'drop_escape': True,
|
|
'columns_in' : ['ccodep', 'ccocom', 'ccopre', 'ccosec', 'dnupla', 'dcntpa'],
|
|
'columns_add': {
|
|
'lot_id': ['ccodep', 'ccocom', 'ccopre', 'ccosec', 'dnupla'],
|
|
'par_id': ['ccodep', 'ccocom', 'ccopre', 'ccosec', 'dnupla'],
|
|
'dnulot': None, },
|
|
'unique': False,
|
|
'dict': {'dcntpa': 'dcntlo'},
|
|
'join': [{'bdd': 'out', 'table': 'parcelles{}'.format(sufx_nom_tab), 'on': ['par_id'], 'type': 'isin',
|
|
'select_cols' :['par_id'] }]
|
|
},]
|
|
},{
|
|
'table_in' : 'lots',
|
|
'index_tab': 'lots',
|
|
'columns_in' : ['ccodep', 'ccocom', 'ccopre', 'ccosec', 'dnupla', 'dnulot', 'dnupdl', 'dcntlo', 'dnuprol'],
|
|
'table_out': [{
|
|
'name': 'lots{}'.format(sufx_nom_tab),
|
|
'geom': None,
|
|
'drop_escape': True,
|
|
'columns_in' : ['ccodep', 'ccocom', 'ccopre', 'ccosec', 'dnupla', 'dnulot', 'dnupdl', 'dcntlo'],
|
|
'columns_add': {
|
|
'lot_id': ['ccodep', 'ccocom', 'ccopre', 'ccosec', 'dnupla', 'dnulot'],
|
|
'par_id': ['ccodep', 'ccocom', 'ccopre', 'ccosec', 'dnupla'],},
|
|
'unique': {'cols': ['lot_id'], 'keep': 'first'},
|
|
'dict': None,
|
|
'join': [{'bdd': 'out', 'table': 'parcelles{}'.format(sufx_nom_tab), 'on': ['par_id'], 'type': 'isin',
|
|
'select_cols' :['par_id'] }]
|
|
},{
|
|
'name': 'lots_natcult{}'.format(sufx_nom_tab),
|
|
'geom': None,
|
|
'drop_escape': True,
|
|
'columns_in' : ['ccodep', 'ccocom', 'ccopre', 'ccosec', 'dnupla', 'dnulot'],
|
|
'columns_add': {
|
|
'lot_id': ['ccodep', 'ccocom', 'ccopre', 'ccosec', 'dnupla', 'dnulot'],},
|
|
'unique': {'cols': ['lot_id'], 'keep': 'first'},
|
|
'dict': None,
|
|
'join': [{
|
|
'bdd': 'in', 'table': 'suf', 'on': ['ccodep', 'ccocom', 'ccopre', 'ccosec', 'dnupla', 'dnulot'], 'type': 'merge',
|
|
'select_cols' : ['ccodep', 'ccocom', 'ccopre', 'ccosec', 'dnupla', 'dnulot','dsgrpf','cnatsp','dclssf','ccosub','dcntsf'],
|
|
},{
|
|
'bdd': 'out', 'table': 'lots{}'.format(sufx_nom_tab), 'on': ['lot_id'], 'type': 'isin',
|
|
'select_cols' :['lot_id'] }]
|
|
},{
|
|
'name': 'cadastre{}'.format(sufx_nom_tab),
|
|
'geom': None,
|
|
'drop_escape': True,
|
|
'columns_in' : ['ccodep', 'ccocom', 'ccopre', 'ccosec', 'dnupla', 'dnulot', 'dnuprol'],
|
|
'columns_add': {
|
|
'lot_id': ['ccodep', 'ccocom', 'ccopre', 'ccosec', 'dnupla', 'dnulot'],
|
|
'dnupro': ['ccodep', 'ccocom', 'dnuprol'],},
|
|
'unique': {'cols': ['lot_id', 'dnupro'], 'keep': 'first'},
|
|
'dict': None,
|
|
'join': [{
|
|
'bdd': 'in', 'table': 'suf', 'on': ['ccodep', 'ccocom', 'ccopre', 'ccosec', 'dnupla', 'dnulot', 'dnuprol'], 'type': 'concat',
|
|
'select_cols' : ['ccodep', 'ccocom', 'ccopre', 'ccosec', 'dnupla', 'dnulot', 'dnupro'], 'dict': {'dnupro': 'dnuprol'}
|
|
},{
|
|
'bdd': 'in', 'table': 'parcelle', 'on': ['ccodep', 'ccocom', 'ccopre', 'ccosec', 'dnupla', 'dnuprol'], 'type': 'concat',
|
|
'select_cols' : ['ccodep', 'ccocom', 'ccopre', 'ccosec', 'dnupla', 'dnupro'], 'dict': {'dnupro': 'dnuprol'}
|
|
},{
|
|
'bdd': 'out', 'table': 'lots{}'.format(sufx_nom_tab), 'on': ['lot_id'], 'type': 'isin',
|
|
'select_cols' :['lot_id'] },{
|
|
'bdd': 'out', 'table': 'cptprop{}'.format(sufx_nom_tab), 'on': ['dnupro'], 'type': 'isin',
|
|
'select_cols' :['dnupro'] },]
|
|
},]
|
|
}]
|
|
|
|
|
|
|
|
################################
|
|
########## Fonctions ##########
|
|
################################
|
|
start_time = dt.datetime.today()
|
|
def time_exec (init_time):
|
|
time = dt.datetime.today() - init_time
|
|
return str(time)
|
|
|
|
|
|
def replace_escape_by_0 (df):
|
|
# Remplacement des espaces dans les chaines de caractères par des 0
|
|
# if 'ccopre' in df.columns:
|
|
# df['ccopre'].replace([None, '', ' '], '000', inplace=True)
|
|
|
|
cols = ['ccopre', 'ccosec', 'dnupla', 'dparpi', 'dnuplam', 'dclssf', 'ccovoi']
|
|
for col in cols:
|
|
if col in df.columns:
|
|
df[col].replace([' '], '0', regex=True, inplace=True)
|
|
|
|
return df
|
|
|
|
|
|
def join_data (df, join, schema_in):
|
|
# Jointure des données avec une autre table
|
|
table = join['table']
|
|
bdd = join['bdd']
|
|
typ = join['type']
|
|
on = join['on']
|
|
if bdd == 'out':
|
|
con = engine_fon
|
|
sch = schema_fon
|
|
if bdd == 'in':
|
|
con = engine_cad
|
|
sch = schema_in
|
|
select_col = []
|
|
if 'select_cols' in join.keys():
|
|
select_col.extend(join['select_cols'])
|
|
if 'where' in join.keys():
|
|
select_col.extend(join['where'].keys())
|
|
|
|
tmp = pd.read_sql_table(
|
|
table_name = table,
|
|
con = con,
|
|
schema = sch,
|
|
columns = select_col
|
|
)
|
|
tmp = replace_escape_by_0(tmp)
|
|
if 'dict' in join.keys():
|
|
tmp.rename(columns=join['dict'], inplace=True)
|
|
if 'where' in join.keys():
|
|
where = join['where']
|
|
for key in where.keys():
|
|
tmp = tmp[tmp[key] == where[key] ]
|
|
|
|
if typ in ['isin', 'notin']:
|
|
for d in [df, tmp]:
|
|
d['on'] = ''
|
|
for col in on:
|
|
d['on'] += d[col].astype(str)
|
|
if typ == 'isin':
|
|
df = df[df['on'].isin(tmp['on'])]
|
|
if typ == 'notin':
|
|
df = df[~df['on'].isin(tmp['on'])]
|
|
df.drop(columns='on', inplace=True)
|
|
if typ == 'merge':
|
|
df = df.merge(tmp, on = on, how='left')
|
|
if typ == 'concat':
|
|
df = pd.concat([df,tmp], ignore_index=True).drop_duplicates()
|
|
|
|
return df
|
|
|
|
def get_geom_parcelle (df,get_geo,schema):
|
|
print('INIT import geodata ........... %s sec'%( time_exec(start_time) ))
|
|
|
|
# Définition des variables géometriques
|
|
ind_geo = get_geo['index_geom']
|
|
tab_geo = get_geo['table_geom_in']
|
|
|
|
sql = """select distinct on (t2.{0})
|
|
t2.{0},
|
|
t1.geom,
|
|
t1.supf::integer as dcntpa -- récupération de la contenance cadastrale associée car présence de géometrie non référencées dans la table "parcelles"
|
|
FROM "{1}".{2} t1
|
|
INNER JOIN (select distinct on ({0}) {0}, max(creat_date) creat_date, max(update_dat) update_dat FROM "{1}".{2} GROUP BY ({0})) t2
|
|
USING ({0}, creat_date, update_dat)""".format(ind_geo, schema, tab_geo)
|
|
tmp = gpd.read_postgis(
|
|
sql = sql,
|
|
con = engine_cad,
|
|
geom_col = 'geom',
|
|
crs = crs,
|
|
chunksize = chunk,
|
|
)
|
|
|
|
if chunk:
|
|
gdf = gpd.GeoDataFrame(pd.concat(tmp, ignore_index=True))
|
|
else:
|
|
gdf = tmp.copy()
|
|
del tmp
|
|
gdf.set_index(ind_geo, inplace=True)
|
|
gdf.index.name = ind_in
|
|
print('END import geodata ........... %s sec'%( time_exec(start_time) ))
|
|
|
|
|
|
print('INIT merge data - geodata ........... %s sec'%( time_exec(start_time) ))
|
|
if not gdf[gdf.dcntpa.isna()].empty:
|
|
gdf.dcntpa.fillna(0, inplace=True)
|
|
gdf['dcntpa'] = gdf['dcntpa'].astype(df.dtypes['dcntpa'].type)
|
|
tmp = gdf.merge(df, on = [ind_in, 'dcntpa'], how='right')
|
|
tmp = tmp.set_geometry('geom', drop=True, crs=crs)
|
|
tmp.rename(columns={'geometry': 'geom'}, inplace=True)
|
|
|
|
if tmp[tmp.geom.isna()].empty:
|
|
lst_ind_df = tmp[tmp.geom.isna()].index.tolist()
|
|
lst_ind_gdf = gdf.loc[gdf.index.isin(lst_ind_df)].index.tolist()
|
|
tmp.loc[tmp.index.isin(lst_ind_gdf), 'geom'] = gdf.loc[gdf.index.isin(lst_ind_gdf), 'geom']
|
|
|
|
del [gdf, df]
|
|
gdf = tmp.copy()
|
|
del tmp
|
|
export_data(gdf)
|
|
|
|
|
|
def export_data(df):
|
|
print('INIT export data TO {0}, {1} ........... {2} sec'.format(tab_out, df.shape[0], time_exec(start_time) ))
|
|
rang = [e for e in range(0, df.shape[0], chunk*5)]
|
|
|
|
cd1 = 'jdatnss' in df.columns
|
|
if cd1 :
|
|
tmp = df.jdatnss.str.split(r'/',expand=True)
|
|
if tmp.shape[1] == 3 and tmp[2].str.len().max() == 4 and tmp[1].astype(int).max() <= 12:
|
|
df.jdatnss = ['%s-%s-%s'%(i[2],i[1],i[0]) for i in df.jdatnss.str.split(r'/').sort_index()]
|
|
|
|
for i, j in enumerate(rang):
|
|
if j == max(rang) :
|
|
jj = df.shape[0]
|
|
else:
|
|
jj = rang[i+1]
|
|
|
|
df_imp = df[j:jj].copy()
|
|
|
|
print('INIT export data TO {0} ..... {1}/{2} ...... {3} sec'.format(tab_out, jj, df.shape[0], time_exec(start_time) ))
|
|
if 'geom' in df.columns and not df[~df['geom'].isna()].empty :
|
|
df_imp = df_imp.set_geometry('geom', drop=True, crs=crs)
|
|
df_imp.rename(columns={'geometry': 'geom'}, inplace=True)
|
|
df_imp.to_postgis(
|
|
name = tab_out,
|
|
con = engine_fon,
|
|
schema = schema_fon,
|
|
index = False,
|
|
if_exists = 'append',
|
|
geom_col = 'geom',
|
|
chunksize = chunk,
|
|
)
|
|
else:
|
|
df_imp.to_sql(
|
|
name = tab_out,
|
|
con = engine_fon,
|
|
schema = schema_fon,
|
|
index = False,
|
|
if_exists = 'append',
|
|
chunksize = chunk,
|
|
method = 'multi',
|
|
)
|
|
print('END export data TO {0} ........... {1} sec'.format(tab_out, time_exec(start_time) ))
|
|
|
|
def optimize_data_frame(df):
|
|
columns = df.columns
|
|
for col in columns:
|
|
# dtype = df[col].dtypes
|
|
# if dtype == 'int64' or dtype == 'int32':
|
|
len_col = len(df[col].unique())
|
|
if len_col <= df.shape[0]*0.8:
|
|
df[col] = df[col].astype('category')
|
|
|
|
return df
|
|
|
|
|
|
# Initiation des connexions bdd
|
|
engine_cad = create_engine('postgresql+psycopg2://{0}:{1}@{2}:{3}/{4}'.format(user_cad,pwd_cad,adr_cad,port_cad,base_cad), echo=False)
|
|
engine_fon = create_engine('postgresql+psycopg2://{0}:{1}@{2}:{3}/{4}'.format(user_fon,pwd_fon,adr_fon,port_fon,base_fon), echo=False)
|
|
con_cad = engine_cad.connect()
|
|
con_fon = engine_fon.connect()
|
|
|
|
|
|
################################
|
|
########## Main ##########
|
|
################################
|
|
if __name__ == "__main__":
|
|
################
|
|
# CORRECTION DUPLICATES TABLE_IN
|
|
################
|
|
if check_duplicates:
|
|
for DOUBLON in FIND_DOUBLON:
|
|
tab = DOUBLON['tab_in']
|
|
on_col = DOUBLON['on_col']
|
|
for col in on_col:
|
|
for dep in list_dep:
|
|
schema_in = dep + '_' + schema_cad
|
|
sql = '''
|
|
-- il existe des doublons en raison d'orthographes voisines :
|
|
-- recherche de ces doublons
|
|
SELECT DISTINCT '{0}' as insee_dep, dnuper, string_agg(DISTINCT {1},' / ') as orthographes_voisines
|
|
FROM "{2}".{3} GROUP BY dnuper HAVING count(DISTINCT {1}) > 1'''.format(dep, col, schema_in, tab)
|
|
df = pd.read_sql(
|
|
sql = sql,
|
|
con = engine_cad,
|
|
)
|
|
if df.empty:
|
|
print('No duplicate value dep {0} table {1} column {2} ====> next request'.format(dep, tab, col))
|
|
continue
|
|
|
|
for i, row in df.iterrows():
|
|
dnuper = row.dnuper
|
|
choix = row.orthographes_voisines.split(' / ')
|
|
choix = [i.strip() for i in choix]
|
|
Question = input("""Des orthographes voisines existent pour l'identifiant : {0}
|
|
dans la colonne : {1}.
|
|
Les valeurs voisines sont : {2}
|
|
Ecrire la mise à jour du champs {1} à enregistrer (c cancel) :""".format(dnuper,col, choix))
|
|
if Question.lower() == 'c' or Question.lower() == 'cancel':
|
|
continue
|
|
|
|
update = '''UPDATE "{0}".{1}
|
|
SET {2} = '{3}'
|
|
WHERE {2} like '{4}%'
|
|
AND dnuper = '{5}';'''.format(schema_in, tab, col, Question, "%' OR {} like '".format(col).join(map(str,choix)), dnuper)
|
|
try:
|
|
con_cad.execute(text(update))
|
|
print('''
|
|
Update OK !''')
|
|
except Exception as exept:
|
|
print('ERROR : {0}'.format(update))
|
|
print(exept)
|
|
sys.exit()
|
|
|
|
|
|
|
|
################
|
|
# TRUNCATE TABLE OUT
|
|
################
|
|
if not debug:
|
|
for i, DICT in enumerate(DICT_TAB):
|
|
tab_in = DICT_TAB[i]['table_in']
|
|
col_in = DICT_TAB[i]['columns_in']
|
|
ind_in = DICT_TAB[i]['index_tab']
|
|
tabs_out = DICT_TAB[i]['table_out']
|
|
|
|
for tab_out in reversed(tabs_out):
|
|
sql = "TRUNCATE TABLE {0}.{1} CASCADE".format(schema_fon, tab_out['name'])
|
|
print(sql)
|
|
con_fon.execute(sql)
|
|
|
|
|
|
|
|
################
|
|
# IMPORT IN TABLE OUT
|
|
################
|
|
for dep in list_dep:
|
|
schema_in = dep + '_' + schema_cad
|
|
print('''
|
|
|
|
INIT import data FROM {}
|
|
|
|
'''.format(schema_in))
|
|
for i, DICT in enumerate(DICT_TAB):
|
|
tab_in = DICT_TAB[i]['table_in']
|
|
col_in = DICT_TAB[i]['columns_in']
|
|
ind_in = DICT_TAB[i]['index_tab']
|
|
tabs_out = DICT_TAB[i]['table_out']
|
|
|
|
# Import data
|
|
print('''
|
|
INIT import data FROM {0}........... {1} sec'''.format(tab_in, time_exec(start_time) ))
|
|
tmp = pd.read_sql_table(
|
|
table_name = tab_in,
|
|
con = engine_cad,
|
|
schema = schema_in,
|
|
columns = col_in + [ind_in],
|
|
chunksize = chunk,
|
|
)
|
|
|
|
# Mise en forme des données
|
|
if chunk:
|
|
DF = pd.concat(tmp, ignore_index=True)
|
|
else:
|
|
DF = tmp.copy()
|
|
|
|
DF.drop_duplicates(inplace=True)
|
|
del tmp
|
|
DF.set_index(ind_in, inplace=True)
|
|
print('END import data ........... %s sec'%( time_exec(start_time) ))
|
|
|
|
for tab in tabs_out:
|
|
tab_out = tab['name']
|
|
dictio = tab['dict']
|
|
col_df = tab['columns_in']
|
|
col_ad = tab['columns_add']
|
|
get_geo = tab['geom']
|
|
drp_esc = tab['drop_escape']
|
|
unique = tab['unique']
|
|
join = tab['join']
|
|
|
|
print('INIT TABLE {0} ........... {1} sec'.format(tab_out, time_exec(start_time) ))
|
|
df = DF[DF.columns.intersection(col_df)].copy()
|
|
|
|
|
|
# Remplacement des espaces dans les chaines de caractères par des 0
|
|
df = replace_escape_by_0(df)
|
|
if drp_esc:
|
|
df_obj = df.select_dtypes(['object'])
|
|
df[df_obj.columns] = df_obj.apply(lambda x: x.str.strip())
|
|
|
|
if dictio :
|
|
df.rename(columns=dictio, inplace=True)
|
|
|
|
if join :
|
|
for j in join:
|
|
if j['bdd'] == 'in' :
|
|
df = join_data(df, j, schema_in)
|
|
if df.empty:
|
|
print('df EMPTY ====> next table')
|
|
continue
|
|
|
|
# Ajout des champs additionnels
|
|
if col_ad :
|
|
print('INIT addition columns ........... %s sec'%( time_exec(start_time) ))
|
|
for key in col_ad.keys():
|
|
if key in df.columns:
|
|
df[key + '_tmp'] = df[key].copy()
|
|
col_ad[key] = [x if x != key else key+'_tmp' for x in col_ad[key]]
|
|
|
|
aggreg = col_ad[key]
|
|
if aggreg :
|
|
df[key] = ''
|
|
for col in aggreg:
|
|
df[key] += df[col].fillna('')
|
|
else:
|
|
df[key] = aggreg
|
|
|
|
print('ADD column {0} : {1} ........... {2} sec'.format(key,aggreg, time_exec(start_time) ))
|
|
|
|
if tab_out == 'proprios%s'%sufx_nom_tab:
|
|
add = pd.DataFrame(data={'dnuper': ['%sY99999'%dep], 'ddenom': ['PROPRIETAIRES NON RENSEIGNES']})
|
|
df = pd.concat([df,add])
|
|
|
|
# JOINTURE
|
|
if join :
|
|
for j in join:
|
|
if j['bdd'] == 'out' :
|
|
df = join_data(df, j, schema_in)
|
|
if df.empty:
|
|
print('df EMPTY ====> next table')
|
|
continue
|
|
|
|
if unique:
|
|
df.drop_duplicates(unique['cols'], keep=unique['keep'], inplace=True)
|
|
|
|
# Conservation des champs utiles à l'insertion en bdd
|
|
name_col_out = engine_fon.dialect.get_columns(engine_fon, tab_out, schema=schema_fon)
|
|
name_col_out = [ sub['name'] for sub in name_col_out ]
|
|
if 'geom' in name_col_out and 'geom' not in df.columns:
|
|
name_col_out.remove('geom')
|
|
df = df[df.columns.intersection(name_col_out)]
|
|
|
|
####################
|
|
# Read geodataframe
|
|
# Dans le cas où un champs géometrique est nécessaire.
|
|
if get_geo:
|
|
get_geom_parcelle(df=df, get_geo=get_geo, schema=schema_in)
|
|
else:
|
|
export_data(df)
|
|
# del df
|
|
|
|
# Si insertion de données dans r_prop_cptprop,
|
|
# attribution d'un compte 'PROPRIETAIRES NON RENSEIGNES' au cptprop sans proprio
|
|
if tab_out == 'r_prop_cptprop%s'%sufx_nom_tab:
|
|
print('''ATTRIBUTION d'un compte 'PROPRIETAIRES NON RENSEIGNES' au cptprop sans proprio''')
|
|
df = pd.read_sql_table(
|
|
con = engine_fon,
|
|
table_name = 'cptprop%s'%sufx_nom_tab,
|
|
schema = schema_fon,
|
|
columns = ['dnupro'] )
|
|
tmp = pd.read_sql_table(
|
|
con = engine_fon,
|
|
table_name = 'r_prop_cptprop%s'%sufx_nom_tab,
|
|
schema = schema_fon,
|
|
columns = ['dnupro'] )
|
|
df = df[~df.dnupro.isin(tmp.dnupro)]
|
|
if df.empty:
|
|
print('TOUS les propriétaires sont renseignés ===> NEXT !')
|
|
continue
|
|
df['dnuper'] = '%sY99999'%dep
|
|
export_data(df)
|
|
del df
|
|
del DF
|
|
|
|
|
|
print('END transfert data FROM département {0} ........... {1} sec'.format(dep, time_exec(start_time) ))
|
|
print('END SCRIPT')
|