1039 lines
34 KiB
Python
1039 lines
34 KiB
Python
#!/usr/bin/env python3
|
|
# -*- coding: UTF-8 -*-
|
|
#Nom : : insert_zh.py
|
|
#Description : Insertion de nouveaux sites et mise à jour des anciens.
|
|
#Copyright : 2021, CEN38
|
|
#Auteur : Colas Geier
|
|
#Version : 1.0
|
|
|
|
from binascii import Error, Incomplete
|
|
import pandas as pd
|
|
import geopandas as gpd
|
|
from pyproj import crs
|
|
import pycen
|
|
con = pycen.con
|
|
|
|
|
|
def crsp_colSite(df):
|
|
'''
|
|
Dictionnaire pour la table sites.sites
|
|
de correspondance des colonnes :
|
|
id, nom, remarques, date_deb.
|
|
'''
|
|
df.columns = df.columns.str.lower()
|
|
return df.rename(columns={
|
|
**dict.fromkeys(['site_cod','site_code','CODE_SITE'], 'id'),
|
|
'site_name': 'nom',
|
|
'zh_remarks': 'remarques',
|
|
'editdate': 'date_deb',
|
|
})
|
|
|
|
def crsp_colGeomSite(df):
|
|
'''
|
|
Dictionnaire pour la table sites.r_sites_geom
|
|
de correspondance des colonnes :
|
|
id_site, date, link_pdf, geom, rmq_fct_majeur,
|
|
rmq_interet_patri, rmq_bilan_menace, rmq_orient_act,
|
|
rmq_usage_process.
|
|
'''
|
|
df.columns = df.columns.str.lower()
|
|
return df.rename(columns={
|
|
'site_code': 'id_site',
|
|
'site_cod': 'id_site',
|
|
'date_modif': 'date',
|
|
'www': 'link_pdf',
|
|
'geometry': 'geom',
|
|
'fct_valeurs_majeurs': 'rmq_fct_majeur',
|
|
'int_patr_majeur': 'rmq_interet_patri',
|
|
'bilan_menaces_facteurs': 'rmq_bilan_menace',
|
|
'orient_actions': 'rmq_orient_act',
|
|
'usages_process': 'rmq_usage_process',
|
|
})
|
|
|
|
def crsp_colSiteHab(df):
|
|
'''
|
|
Dictionnaire pour la table zones_humides.r_site_habitat
|
|
de correspondance des colonnes :
|
|
id_site, date, id_cb.
|
|
'''
|
|
df.columns = df.columns.str.lower()
|
|
return df.rename(columns={
|
|
'site_code': 'id_site',
|
|
'site_cod': 'id_site',
|
|
'date_modif': 'date',
|
|
'cb_cod': 'id_cb',
|
|
'code_cb': 'id_cb',
|
|
})
|
|
|
|
def crsp_colSiteUsgPrss(df):
|
|
'''
|
|
Dictionnaire pour la table zones_humides.r_site_usageprocess
|
|
de correspondance des colonnes :
|
|
id_site, date, remarques.
|
|
'''
|
|
df.columns = df.columns.str.lower()
|
|
return df.rename(columns={
|
|
'site_code': 'id_site',
|
|
'site_cod': 'id_site',
|
|
'date_modif': 'date',
|
|
'remarks': 'remarques',
|
|
})
|
|
|
|
def crsp_colSiteRegHydro(df):
|
|
'''
|
|
Dictionnaire pour la table zones_humides.r_site_reghydro
|
|
de correspondance des colonnes :
|
|
id_site, date, in, out, perm, rmq_toponymie.
|
|
'''
|
|
df.columns = df.columns.str.lower()
|
|
return df.rename(columns={
|
|
'site_code': 'id_site',
|
|
'site_cod': 'id_site',
|
|
'site_cod.1': 'id_site',
|
|
'site_cod.2': 'id_site',
|
|
'date_modif': 'date',
|
|
'entree_eau': 'in',
|
|
'sortie_eau': 'out',
|
|
'perm_in': 'perm',
|
|
'perm_out': 'perm',
|
|
'topoinfl': 'rmq_toponymie',
|
|
'topooutfl': 'rmq_toponymie',
|
|
})
|
|
|
|
def crsp_colSiteFct(df):
|
|
'''
|
|
Dictionnaire pour la table zones_humides.r_site_fctecosociopatri
|
|
de correspondance des colonnes :
|
|
id_site, date, remarques.
|
|
'''
|
|
df.columns = df.columns.str.lower()
|
|
return df.rename(columns={
|
|
'site_code': 'id_site',
|
|
'site_cod': 'id_site',
|
|
'date_modif': 'date',
|
|
'memo': 'description',
|
|
})
|
|
|
|
def crsp_idUsgPrss(df,table_param,id_col,nom_col,description=False):
|
|
'''
|
|
Réalise la correspondance entre les usages
|
|
ou les processus naturels et leur identifiants respectifs.
|
|
'''
|
|
df = df.copy()
|
|
df[nom_col] = df[nom_col].str[0].str.upper() + df[nom_col].str[1:]
|
|
# df[nom_col] = df[nom_col].str.capitalize()
|
|
ids = pycen.zh()._get_param(param_table=table_param)
|
|
if description:
|
|
df[nom_col] = df[nom_col].replace([*ids.description], [*ids.nom])
|
|
df[id_col] = df[nom_col].replace([*ids.nom], [*ids.id])
|
|
# df[id_col] = df[nom_col].replace([*ids.nom.str.capitalize()], [*ids.id])
|
|
result = any(elem in [*df[id_col].unique()] for elem in [*ids.id])
|
|
if not result:
|
|
df[nom_col] = df[nom_col].str[0].str.upper() + df[nom_col].str[1:].str.lower()
|
|
df[id_col] = df[nom_col].replace([*ids.nom], [*ids.id])
|
|
|
|
return df
|
|
|
|
|
|
def get_id_auteur(lst_autor):
|
|
'''
|
|
Récupération des identifiants auteurs en
|
|
fonction de la liste des auteurs fournis.
|
|
'''
|
|
sch = 'personnes'
|
|
tab = 'personne'
|
|
sql = """
|
|
WITH tmp as
|
|
(SELECT id, TRIM(CONCAT(UPPER(nom),' ',prenom)) as auteur FROM {sch}.{tab}
|
|
UNION ALL
|
|
SELECT id, TRIM(CONCAT(nom,' ',prenom)) as auteur FROM {sch}.{tab}),
|
|
tmp2 as
|
|
(SELECT
|
|
p.id, TRIM(UPPER(p.nom)||' '||p.prenom||' '||CONCAT('(',o."abbrev",')')) as auteur
|
|
FROM {sch}.{tab} p join {sch}.organisme o on p.id_organisme=o.id),
|
|
tmp3 as
|
|
(SELECT
|
|
p.id, TRIM(UPPER(p.nom)||' '||p.prenom||' '||CONCAT('(',o.nom,')')) as auteur
|
|
FROM {sch}.{tab} p join {sch}.organisme o on p.id_organisme=o.id),
|
|
tmp4 as (
|
|
SELECT * FROM tmp
|
|
UNION ALL
|
|
SELECT * FROM tmp2
|
|
UNION ALL
|
|
SELECT * FROM tmp3
|
|
)
|
|
SELECT DISTINCT * FROM tmp4
|
|
WHERE auteur {symb} %(lst_autor)s
|
|
ORDER BY 1;""".format(
|
|
sch=sch,
|
|
tab=tab,
|
|
symb='IN' if len(lst_autor) > 1 else '=')
|
|
df = pd.read_sql(
|
|
sql = sql,
|
|
con = con,
|
|
params = {'lst_autor': tuple(lst_autor) })
|
|
return df
|
|
|
|
|
|
def forme_typsite(df):
|
|
'''
|
|
Conversion des types de sites en identifiants
|
|
pour insertion en BDD.
|
|
'''
|
|
df = df.copy()
|
|
typsite = pycen.sites._get_typ_site()
|
|
if 'type_site' in df.columns :
|
|
print(' A CODER !!!!')
|
|
df['id_type_site'] = df.type_milieux.replace([*typsite.nom], [*typsite.id])
|
|
df.drop(columns=['type_site'], inplace=True)
|
|
else:
|
|
df['id_type_site'] = typsite.loc[typsite.nom == 'N.D.', 'id'].values[0]
|
|
return df
|
|
|
|
|
|
def forme_typsdage(df):
|
|
'''
|
|
Conversion des types de sites en identifiants
|
|
pour insertion en BDD.
|
|
'''
|
|
df = df.copy()
|
|
typsdage = pycen.sites._get_typo_sdage()
|
|
if 'typo_sdage' in df.columns :
|
|
df['id_typo_sdage'] = df.typo_sdage.replace([*typsdage.nom], [*typsdage.id])
|
|
df.drop(columns=['typo_sdage'], inplace=True)
|
|
else:
|
|
df['id_type_milieu'] = typsdage.loc[typsdage.nom == 'Inconnu', 'id'].values[0]
|
|
return df
|
|
|
|
|
|
def forme_typmilieu(df):
|
|
'''
|
|
Conversion des types de milieux en identifiants
|
|
pour insertion en BDD.
|
|
'''
|
|
df = df.copy()
|
|
typmilieux = pycen.sites._get_typ_milieux()
|
|
if 'type_milieux' in df.columns :
|
|
df['id_type_milieu'] = df.type_milieux.replace([*typmilieux.nom], [*typmilieux.id])
|
|
df.drop(columns=['type_milieux'], inplace=True)
|
|
else:
|
|
df['id_type_milieux'] = typmilieux.loc[typmilieux.nom == 'N.D.', 'id'].values[0]
|
|
return df
|
|
|
|
|
|
def drop_maxDateGeomData(shP):
|
|
'''
|
|
Récupération des attributs antérieurs
|
|
à la géométries la plus actuelle.
|
|
Fonction créée dans le cas où la géométrie
|
|
la plus actuelle ne possède pas encore d'attributs.
|
|
'''
|
|
df = shP.copy()
|
|
keys = [*df.keys()]
|
|
for k in keys:
|
|
if k != 'infos' and isinstance(df[k], pd.DataFrame):
|
|
# date_col = [col for col in df[k].columns if 'date' in col]
|
|
if 'date_geom' in df[k].columns:
|
|
date_col = 'date_geom'
|
|
elif 'date' in df[k].columns:
|
|
date_col = 'date'
|
|
df[k] = df[k].sort_values(date_col)
|
|
m = df[k][date_col].max()
|
|
index = df[k][df[k][date_col]==m].index
|
|
df[k] = df[k].drop(labels = index)
|
|
elif k != 'infos' and isinstance(df[k], dict):
|
|
kkeys = [*df[k].keys()]
|
|
if 'title' in kkeys:
|
|
kkeys.remove('title')
|
|
for kk in kkeys:
|
|
date_col = 'date_geom'
|
|
if len(df[k][kk][date_col].unique()) > 1:
|
|
df[k][kk] = df[k][kk].sort_values(date_col)
|
|
m = df[k][kk][date_col].max()
|
|
index = df[k][kk][df[k][kk][date_col]==m].index
|
|
df[k][kk] = df[k][kk].drop(labels = index)
|
|
|
|
return df
|
|
|
|
|
|
def insert_autorSiteData(df):
|
|
'''
|
|
Insertion des auteurs des sites.
|
|
'''
|
|
df = df.copy()
|
|
df = df[['id', 'auteur']].copy()
|
|
if df.auteur.str.contains(',|&').any():
|
|
df = (df
|
|
.set_index('id',drop=True)
|
|
.auteur.str.split(',|&')
|
|
.explode()
|
|
.str.strip()
|
|
.reset_index(drop=False))
|
|
df_autor = get_id_auteur([*df.auteur.unique()])
|
|
df.replace([*df_autor.auteur],[*df_autor.id], inplace=True)
|
|
df.columns = ['id_site','id_auteur']
|
|
df.to_sql(
|
|
name='r_sites_auteur',
|
|
con=con,
|
|
schema='sites',
|
|
index=False,
|
|
if_exists='append',
|
|
method='multi'
|
|
)
|
|
return 'Insert author sites data OK !'
|
|
|
|
|
|
def insert_autorGeomData(df):
|
|
'''
|
|
Insertion des auteurs des geometries.
|
|
'''
|
|
df = df.copy()
|
|
df = df[['id', 'auteur']].copy()
|
|
if df.auteur.str.contains(',|&').any():
|
|
df = (df
|
|
.set_index('id',drop=True)
|
|
.auteur.str.split(',|&')
|
|
.explode()
|
|
.str.strip()
|
|
.reset_index(drop=False))
|
|
df_autor = get_id_auteur([*df.auteur.unique()])
|
|
df.replace([*df_autor.auteur],[*df_autor.id], inplace=True)
|
|
df.columns = ['id_geom_site','id_auteur']
|
|
try :
|
|
df.to_sql(
|
|
name='r_geomsites_auteur',
|
|
con=con,
|
|
schema='sites',
|
|
index=False,
|
|
if_exists='append',
|
|
method='multi'
|
|
)
|
|
except Exception as e:
|
|
print('ERROR : News author sites insert impossible !')
|
|
print(e)
|
|
return 'Insert author sites data OK !'
|
|
|
|
|
|
def name_site(df):
|
|
'''
|
|
Définition du code_site du site.
|
|
'''
|
|
df['id'] = df.index
|
|
srd = (pycen.ref.territoire.sdr_ressources_en_eau()
|
|
.drop(columns=['superficie','perimetre']))
|
|
dep = pycen.ref.territoire.dept_isere()
|
|
if 'dept' not in df.columns:
|
|
isindep = df.intersects(dep.unary_union)
|
|
df.loc[isindep,'dept'] = '38'
|
|
if df.dept.isna().any():
|
|
notindept = df[df.dept.isna()].index.tolist()
|
|
raise('ERROR : Certaines zones humides ne sont pas dans le département :\n %s'%str(notindept))
|
|
|
|
df['surf'] = df.area
|
|
tmp = gpd.overlay(srd,df,how='intersection',make_valid=True,keep_geom_type=False)
|
|
tmp['perc_rcvmt'] = 100*tmp.area/tmp['surf']
|
|
tmp.sort_values(['id','perc_rcvmt'],inplace=True)
|
|
test = tmp.id.duplicated(keep='first')
|
|
tmp = tmp[test]
|
|
df = (df.merge(tmp[['id','code_tr']],how='left',on='id')
|
|
.rename(columns={'code_tr':'org'}))
|
|
|
|
for s in srd.iterrows():
|
|
org = s[1].code_tr
|
|
num = con.execute("SELECT max(num::int) FROM sites.sites WHERE org = '%s'"%org).one()[0]
|
|
test = df.org == org
|
|
dim = df[test].shape[0]
|
|
df.loc[test, 'num'] = list(range(num,num+dim))
|
|
|
|
df.loc[df.num.str.len() == 1,'num'] = '000'+ df.loc[df.num.str.len() == 1,'num']
|
|
df.loc[df.num.str.len() == 2,'num'] = '00' + df.loc[df.num.str.len() == 2,'num']
|
|
df.loc[df.num.str.len() == 3,'num'] = '0' + df.loc[df.num.str.len() == 3,'num']
|
|
|
|
df['id'] = df.dept + df.org + df.num
|
|
return df
|
|
|
|
|
|
def insertNewSite(df):
|
|
'''
|
|
Insertion des nouveaux sites.
|
|
|
|
columns :
|
|
---------
|
|
'site_cod', 'dept', 'org', 'num', 'site_name', 'editdate',
|
|
'auteur', 'organisat', 'maj', 'type_milieux'
|
|
'''
|
|
df = df.copy()
|
|
|
|
columns = ['id', 'nom', 'date_deb', 'old_site', 'dept', 'org',
|
|
'num', 'remarques', 'auteur', 'type_site', 'typo_sdage', 'type_milieux']
|
|
df = crsp_colSite(df)
|
|
if 'id' not in df.columns:
|
|
df = name_site(df)
|
|
c = df.columns[df.columns.isin(columns)]
|
|
df['date_deb'] = pd.to_datetime(df['date_deb'])
|
|
df = df[c]
|
|
df = forme_typsite(df)
|
|
df = forme_typmilieu(df)
|
|
df = forme_typsdage(df)
|
|
c = df.columns
|
|
try:
|
|
df[c.drop('auteur')].to_sql(
|
|
name='sites',
|
|
con=con,
|
|
schema='sites',
|
|
index=False,
|
|
if_exists='append',
|
|
method='multi'
|
|
)
|
|
try :
|
|
insert_autorSiteData(df)
|
|
except Exception as e:
|
|
print('ERROR : News author sites insert impossible !')
|
|
print(e)
|
|
except Exception as e :
|
|
print('ERROR : News sites insert impossible !')
|
|
print(e)
|
|
|
|
|
|
def insertNewGeom(gdf, rmq_geom=pd.DataFrame()):
|
|
'''
|
|
Insertion des nouvelles géométries des sites
|
|
et les éventuelles remarques associées.
|
|
|
|
paramètres :
|
|
---------
|
|
gdf : GeoDataFrame. Tableau des géométries
|
|
identifiées par leur code site respectifs.
|
|
rmq_geom : DataFrame. Tableau des remarques
|
|
globales du sites pour ces géométries:
|
|
'fct_valeurs_majeurs', 'int_patr_majeur',
|
|
'bilan_menaces_facteurs', 'orient_actions'
|
|
'''
|
|
df = gdf.copy()
|
|
columns = [ x['name'] for x in pycen.sites.columns_geomtab ] + ['auteur']
|
|
df = crsp_colGeomSite(df)
|
|
|
|
if df.crs.srs.split(':')[-1] != '2154':
|
|
df.to_crs(2154,inplace=True)
|
|
|
|
if not rmq_geom.empty :
|
|
rmq_geom.columns = rmq_geom.columns.str.lower()
|
|
rmq_geom = crsp_colGeomSite(rmq_geom)
|
|
if 'date' in df.columns and 'date' in rmq_geom.columns:
|
|
del rmq_geom['date']
|
|
if 'auteur' in df.columns and 'auteur' in rmq_geom.columns:
|
|
del rmq_geom['auteur']
|
|
df = df.merge(rmq_geom, on='id_site', how='left')
|
|
|
|
c = df.columns[df.columns.isin(columns)]
|
|
df = df[c]
|
|
df = pycen.tools.Polygons_to_MultiPolygon(df)
|
|
try:
|
|
df[c.drop('auteur')].to_postgis(
|
|
name='r_sites_geom',
|
|
con=con,
|
|
schema='sites',
|
|
#geom_col='geom',
|
|
index=False,
|
|
if_exists='append',
|
|
)
|
|
except Exception as e :
|
|
print('ERROR : News sites insert impossible !')
|
|
print(e)
|
|
|
|
sql = 'SELECT id, id_site, date FROM sites.r_sites_geom WHERE id_site IN %(id_site)s AND date IN %(date)s ;'
|
|
tmp = pd.read_sql(sql=sql, con=con, params= {
|
|
'id_site': tuple(df.id_site),
|
|
'date': tuple(df.date)
|
|
})
|
|
tmp['date'] = tmp['date'].astype(str)
|
|
df['date'] = df['date'].astype(str)
|
|
df = df.merge(tmp, on=['id_site', 'date'], how='left')
|
|
try :
|
|
insert_autorGeomData(df)
|
|
except Exception as e:
|
|
print('ERROR : News author sites insert impossible !')
|
|
print(e)
|
|
|
|
|
|
def get_idGeomSite(lst_site):
|
|
'''
|
|
Récupération des identifiants des géometries
|
|
des sites les plus récentes.
|
|
'''
|
|
id_geom = pycen.zh().get_sitesGeom(
|
|
id_site=[*lst_site], last_update=True)
|
|
id_geom = id_geom[['id','id_site']]
|
|
id_geom.columns = ['id_geom_site','id_site']
|
|
return id_geom
|
|
|
|
|
|
def select_ID(df,sch,tab):
|
|
'''
|
|
Récupération des identifiants des nouvelles
|
|
lignes insérées.
|
|
|
|
paramètres :
|
|
---------
|
|
df : pd.DataFrame, Tableau des données
|
|
attributaires insérées.
|
|
sch : str. Nom du schéma où sont stockés les attributs.
|
|
tab : str. Nom de la table.
|
|
'''
|
|
sql = 'SELECT * FROM %s.%s'%(sch,tab)
|
|
df = df.copy().dropna(axis=1)
|
|
if 'date' in df.columns:
|
|
df['date'] = df['date'].astype(str)
|
|
if 'id_cb' in df.columns:
|
|
df['id_cb'] = df['id_cb'].astype(str)
|
|
column = '(%s)'%','.join(df.columns)
|
|
df_tuple = tuple(df.itertuples(index=False, name=None))
|
|
sql = sql + ' WHERE %s IN %s'%(column,df_tuple)
|
|
if 'nan' in sql: sql = sql.replace('nan','NULL')
|
|
if '),)' in sql: sql = sql.replace('),)','))')
|
|
if '"' in sql: sql = sql.replace('"',"'")
|
|
|
|
# print(sql)
|
|
return pd.read_sql(
|
|
sql=sql,
|
|
con=con,)
|
|
|
|
|
|
def insertAttrs(sh2, sch, tab):
|
|
'''
|
|
Insertion des nouveaux attributs des sites.
|
|
Ne Concerne pas les auteurs des attributs
|
|
(cf. insertAutorAttrs).
|
|
|
|
paramètres :
|
|
---------
|
|
df : pd.DataFrame, Tableau des données
|
|
attributaires insérées.
|
|
sch : str. Nom du schéma où sont stockés les attributs.
|
|
tab : str. Nom de la table.
|
|
'''
|
|
df = sh2.copy()
|
|
df = df.merge(get_idGeomSite(df.id_site), on=['id_site'], how='left')
|
|
df.dropna(subset=['id_geom_site'],inplace=True)
|
|
df['id_geom_site'] = df['id_geom_site'].astype(int)
|
|
tab_cols = pycen.con.dialect.get_columns(con,schema=sch,table_name=tab)
|
|
columns = [ x['name'] for x in tab_cols ] + ['auteur']
|
|
c = df.columns[df.columns.isin(columns)]
|
|
df['date'] = pd.to_datetime(df['date'])
|
|
df = df[c]
|
|
if tab == 'r_site_sub':
|
|
df.dropna(subset=['id_freqsub'],inplace=True)
|
|
try:
|
|
df[c.drop('auteur')].to_sql(
|
|
name=tab,
|
|
con=con,
|
|
schema=sch,
|
|
index=False,
|
|
if_exists='append',
|
|
method='multi'
|
|
)
|
|
print('Insert attrs sites data OK !')
|
|
return [df,True]
|
|
except Exception as e :
|
|
print('ERROR : News sites insert impossible !')
|
|
print(e)
|
|
return [df,False]
|
|
|
|
|
|
def insertAutorAttrs(df,colname_rsite, sch, tab):
|
|
'''
|
|
Insertion des auteurs des attributs.
|
|
|
|
paramètres :
|
|
---------
|
|
df : pd.DataFrame, Tableau des données
|
|
attributaires insérées.
|
|
colname_rsite : str. Nom du champs
|
|
relationnelle de la table auteur,
|
|
se rapportant à la table attributaire.
|
|
sch : str. Nom du schéma où se situe la table auteur.
|
|
tab : str. Nom de la table auteur.
|
|
'''
|
|
df = df.copy()
|
|
df = df[['id', 'auteur']].copy()
|
|
df.drop_duplicates(inplace=True)
|
|
if df.auteur.str.contains(',|&').any():
|
|
df = (df
|
|
.set_index('id',drop=True)
|
|
.auteur.str.split(',|&')
|
|
.explode()
|
|
.str.strip()
|
|
.reset_index(drop=False))
|
|
# tmp = df.auteur.str.split(' & ', expand =True).stack().droplevel(-1)
|
|
# df = pd.concat([df,tmp],axis=1)
|
|
# del df['auteur']
|
|
# df.columns = ['id', 'auteur']
|
|
df_autor = get_id_auteur([*df.auteur.unique()])
|
|
df.replace([*df_autor.auteur],[*df_autor.id], inplace=True)
|
|
df.columns = [colname_rsite, 'id_auteur']
|
|
try :
|
|
df.to_sql(
|
|
name=tab,
|
|
con=con,
|
|
schema=sch,
|
|
index=False,
|
|
if_exists='append',
|
|
method='multi'
|
|
)
|
|
print('Insert author sites data OK !')
|
|
return 'Insert author sites data OK !'
|
|
except Exception as e:
|
|
print('ERROR : News author sites insert impossible !')
|
|
print(e)
|
|
|
|
|
|
def insertAttrsCB(sh3):
|
|
'''
|
|
Insertion des nouvelles version des attributs
|
|
habitats des sites zones humides.
|
|
Affectation des attributs à la géométrie la plus récente.
|
|
|
|
columns :
|
|
---------
|
|
'site_cod', 'cb_cod', 'desc_cbiotope', 'auteur', 'date'
|
|
'''
|
|
tab = 'r_site_habitat'
|
|
sch = pycen.zh().schema
|
|
df = sh3.copy()
|
|
df = crsp_colSiteHab(df)
|
|
|
|
if df.id_cb.dtype == float:
|
|
df.id_cb = df.id_cb.astype(str)
|
|
df.id_cb = df.id_cb.replace('.0','',regex=True)
|
|
df,ins = insertAttrs(df,sch, tab)
|
|
|
|
if ins:
|
|
ids = select_ID(df[df.columns.drop('auteur')],sch,tab)
|
|
same_col = df.columns[df.columns.isin(ids.columns)]
|
|
if 'date' in same_col:
|
|
df['date'] = df['date'].astype(str)
|
|
ids['date'] = ids['date'].astype(str)
|
|
df = df.merge(ids, on=[*same_col], how='left')
|
|
insertAutorAttrs(df,colname_rsite='id_sitehab', sch=sch, tab='r_rsitehab_auteur')
|
|
|
|
|
|
def insertAttrsDelim(sh3):
|
|
'''
|
|
Insertion des nouvelles version des attributs
|
|
de délimitation et de definition de l'espace de
|
|
fonctionnalité des sites zones humides.
|
|
Affectation des attributs à la géométrie la plus récente.
|
|
|
|
columns :
|
|
---------
|
|
'site_cod', 'crit_def_esp', 'crit_delim', 'auteur', 'date'
|
|
'''
|
|
tab = 'r_site_critdelim'
|
|
sch = pycen.zh().schema
|
|
df = sh3.copy()
|
|
inds = df.columns[~df.columns.isin(['crit_def_esp','crit_delim'])]
|
|
df.set_index([*inds],inplace=True)
|
|
df = df.stack().reset_index(-1)
|
|
df.columns = ['type', 'nom']
|
|
df.reset_index(inplace=True)
|
|
df.drop_duplicates(inplace=True)
|
|
|
|
param = pycen.zh()._get_param(param_table='param_delim_fct', type_table='type_param_delim_fct')
|
|
for typ in df.type.unique():
|
|
param_tmp = param.loc[param.type==typ]
|
|
df.loc[df.type == typ,'id_crit_delim'] = df.loc[df.type == typ,'nom'].replace([*param_tmp.nom],[*param_tmp.id])
|
|
df['id_crit_delim'] = df['id_crit_delim'].astype(int)
|
|
df = crsp_colSiteHab(df)
|
|
df,ins = insertAttrs(df,sch, tab)
|
|
|
|
if ins:
|
|
ids = select_ID(df[df.columns.drop('auteur')],sch,tab)
|
|
same_col = df.columns[df.columns.isin(ids.columns)]
|
|
if 'date' in same_col:
|
|
df['date'] = df['date'].astype(str)
|
|
ids['date'] = ids['date'].astype(str)
|
|
df = df.merge(ids, on=[*same_col], how='left')
|
|
insertAutorAttrs(df,colname_rsite='id_sitedelim', sch=sch, tab='r_rsitedelim_auteur')
|
|
|
|
|
|
def insertAttrsUsgPrss(sh4):
|
|
'''
|
|
Insertion des nouvelles version des attributs
|
|
usages et processus naturels des sites zones humides.
|
|
Affectation des attributs à la géométrie la plus récente.
|
|
|
|
columns :
|
|
---------
|
|
'site_cod', 'remarks', 'activ_hum_autre', 'temp', 'affich_act',
|
|
'localisation', 'activite_hum', 'typo_sdage', 'impact',
|
|
'auteur','date'
|
|
'''
|
|
tab = 'r_site_usageprocess'
|
|
sch = pycen.zh().schema
|
|
df = sh4.copy()
|
|
df = crsp_idUsgPrss(df,table_param='param_activ_hum',id_col='id_activ_hum', nom_col='activite_hum')
|
|
df = crsp_idUsgPrss(df,table_param='param_impact',id_col='id_impact', nom_col='impact')
|
|
if len(df.localisation.max()) > 10: descript = True
|
|
else : descript = False
|
|
df = crsp_idUsgPrss(
|
|
df,table_param='param_position',id_col='id_position',
|
|
nom_col='localisation',description=descript)
|
|
df = crsp_colSiteUsgPrss(df)
|
|
df,ins = insertAttrs(df,sch, tab)
|
|
|
|
if ins:
|
|
ids = select_ID(df[df.columns.drop('auteur')],sch,tab)
|
|
same_col = df.columns[df.columns.isin(ids.columns)]
|
|
if 'date' in same_col:
|
|
df['date'] = df['date'].astype(str)
|
|
ids['date'] = ids['date'].astype(str)
|
|
for col in same_col:
|
|
if df[col].dtype != ids[col].dtype:
|
|
print(col)
|
|
if df[col].dtype == float:
|
|
ids[col] = ids[col].astype(float)
|
|
elif df[col].dtype == object:
|
|
ids[col] = ids[col].astype(object)
|
|
df = df.merge(ids, on=[*same_col], how='left')
|
|
insertAutorAttrs(df,colname_rsite='id_siteusage', sch=sch, tab='r_rsiteusage_auteur')
|
|
|
|
|
|
def insertAttrsRegHydro(sh5):
|
|
'''
|
|
Insertion des nouvelles version des attributs
|
|
régimes hydriques des sites zones humides.
|
|
Affectation des attributs à la géométrie la plus récente.
|
|
|
|
columns :
|
|
---------
|
|
'site_cod', 'topoinfl', 'entree_eau', 'perm_in', 'unnamed: 4',
|
|
'unnamed: 5', 'unnamed: 6', 'site_cod.1', 'topooutfl', 'sortie_eau',
|
|
'perm_out', 'unnamed: 11', 'unnamed: 12', 'unnamed: 13', 'unnamed: 14',
|
|
'site_cod.2', 'sub_orig', 'sub_freq', 'sub_etend', 'connexion',
|
|
'auteur', 'date'
|
|
'''
|
|
dic = {
|
|
'Canaux / fossés':'Canaux/fossés',
|
|
'Nappe':'Nappes',
|
|
}
|
|
sch = pycen.zh().schema
|
|
tab_regHyd = 'r_site_reghydro'
|
|
tab_con = 'r_site_type_connect'
|
|
tab_sub = 'r_site_sub'
|
|
p_inout_perm = pycen.zh()._get_param(param_table='param_permanence')
|
|
p_inout_rHyd = pycen.zh()._get_param(param_table='param_reg_hydro')
|
|
p_con_sub = pycen.zh()._get_param(param_table='param_sub', type_table='type_param_sub',type_court=False)
|
|
p_con_cnx = pycen.zh()._get_param(param_table='param_type_connect')
|
|
|
|
df = sh5.copy()
|
|
df.set_index(['auteur', 'date'],inplace=True)
|
|
dfin = df.iloc[:,:4].copy()
|
|
dfout = df.iloc[:,7:11].copy()
|
|
dfcon = df.iloc[:,15:].copy()
|
|
dfin = crsp_colSiteRegHydro(dfin).set_index('id_site',append=True)
|
|
dfout = crsp_colSiteRegHydro(dfout).set_index('id_site',append=True)
|
|
dfcon = crsp_colSiteRegHydro(dfcon).set_index('id_site',append=True)
|
|
dfin = dfin.dropna(how='all').reset_index(drop=False)
|
|
dfout = dfout.dropna(how='all').reset_index(drop=False)
|
|
dfcon = dfcon.dropna(how='all').reset_index(drop=False)
|
|
|
|
col_inout = ['in','out']
|
|
dfinout = pd.concat([dfin,dfout])
|
|
dfinout.set_index([*dfinout.columns[~dfinout.columns.isin(col_inout)]], inplace=True)
|
|
dfinout = dfinout.stack().reset_index(-1, drop=False)
|
|
dfinout.columns = ['in_out','reg_hydro']
|
|
dfinout.reset_index(inplace=True, drop=False)
|
|
dfinout['reg_hydro'] = dfinout['reg_hydro'].str[0].str.upper() + dfinout['reg_hydro'].str[1:]
|
|
dfinout['reg_hydro'].replace(dic, inplace=True)
|
|
dfinout.in_out.replace(['in','out'],[True,False],inplace=True)
|
|
dfinout['id_reg_hydro'] = dfinout['reg_hydro'].str.lower() \
|
|
.replace([*p_inout_rHyd.nom.str.lower()],[*p_inout_rHyd.id])
|
|
dfinout['id_permanance'] = dfinout['perm'].str.lower() \
|
|
.replace([*p_inout_perm.nom.str.lower()],[*p_inout_perm.id.astype(str)])
|
|
|
|
if dfcon.columns.str.contains('sub').any():
|
|
if dfcon['sub_freq'].dtype != object:
|
|
dfcon['sub_freq'] = dfcon['sub_freq'].astype(object)
|
|
if dfcon['sub_etend'].dtype != object:
|
|
dfcon['sub_etend'] = dfcon['sub_etend'].astype(object)
|
|
dfcon['sub_freq'].fillna('Inconnu',inplace=True)
|
|
dfcon['sub_etend'].fillna('Inconnu',inplace=True)
|
|
dfcon['id_freqsub'] = dfcon['sub_freq'].str.lower() \
|
|
.replace([*p_con_sub.nom.str.lower()],[*p_con_sub.id.astype(str)])
|
|
dfcon['id_etendsub'] = dfcon['sub_etend'].str.lower() \
|
|
.replace([*p_con_sub.nom.str.lower()],[*p_con_sub.id.astype(str)])
|
|
dfcon['id_origsub'] = dfcon['sub_orig']
|
|
else :
|
|
dfcon['id_freqsub'] = p_con_sub[
|
|
(p_con_sub.type == 'Submersion fréquente') &
|
|
(p_con_sub.nom == 'Inconnu')].id.values[0]
|
|
dfcon['id_param_connect'] = dfcon['connexion'].str.lower() \
|
|
.replace([*p_con_cnx.nom.str.lower()],[*p_con_cnx.id.astype(str)])
|
|
|
|
dfinout,ins = insertAttrs(dfinout,sch, tab_regHyd)
|
|
if ins:
|
|
ids = select_ID(dfinout[dfinout.columns.drop('auteur')],sch,tab_regHyd)
|
|
same_col = dfinout.columns[dfinout.columns.isin(ids.columns)]
|
|
if 'date' in same_col:
|
|
dfinout['date'] = dfinout['date'].astype(str)
|
|
ids['date'] = ids['date'].astype(str)
|
|
for c in same_col:
|
|
if dfinout[c].dtype != ids[c].dtype:
|
|
dfinout[c] = dfinout[c].astype(ids[c].dtype)
|
|
dfinout = dfinout.merge(ids, on=[*same_col], how='left')
|
|
insertAutorAttrs(dfinout,colname_rsite='id_sitehydro', sch=sch, tab='r_rsitehydro_auteur')
|
|
else: return
|
|
|
|
dfconn = dfcon.copy()
|
|
dfcon,ins = insertAttrs(dfcon,sch, tab_sub)
|
|
if ins:
|
|
ids = select_ID(dfcon[dfcon.columns.drop('auteur')],sch,tab_sub)
|
|
ids.loc[~ids.id_etendsub.isna(),'id_etendsub'] = ids.loc[~ids.id_etendsub.isna(),'id_etendsub']\
|
|
.astype(int)
|
|
if ids.id_freqsub.dtype==int:
|
|
ids.id_freqsub = ids.id_freqsub.astype(str)
|
|
same_col = dfcon.columns[dfcon.columns.isin(ids.columns)]
|
|
if 'date' in same_col:
|
|
dfcon['date'] = dfcon['date'].astype(str)
|
|
ids['date'] = ids['date'].astype(str)
|
|
for col in same_col:
|
|
if dfcon[col].dtype != ids[col].dtype:
|
|
print(col)
|
|
if dfcon[col].dtype == float:
|
|
ids[col] = ids[col].astype(float)
|
|
elif dfcon[col].dtype == int:
|
|
ids[col] = ids[col].astype(int)
|
|
elif dfcon[col].dtype == object:
|
|
ids[col] = ids[col].astype(object)
|
|
dfcon = dfcon.merge(ids, on=[*same_col], how='left')
|
|
insertAutorAttrs(dfcon,colname_rsite='id_sitesub', sch=sch, tab='r_rsitesub_auteur')
|
|
else: return
|
|
|
|
dfconn,ins = insertAttrs(dfconn,sch, tab_con)
|
|
if ins:
|
|
ids = select_ID(dfconn[dfconn.columns.drop('auteur')],sch,tab_con)
|
|
if ids.id_param_connect.dtype==int:
|
|
ids.id_param_connect = ids.id_param_connect.astype(str)
|
|
same_col = dfconn.columns[dfconn.columns.isin(ids.columns)]
|
|
if 'date' in same_col:
|
|
dfconn['date'] = dfconn['date'].astype(str)
|
|
ids['date'] = ids['date'].astype(str)
|
|
dfconn = dfconn.merge(ids, on=[*same_col], how='left')
|
|
insertAutorAttrs(dfconn,colname_rsite='id_siteconnect', sch=sch, tab='r_rsiteconnect_auteur')
|
|
else: return
|
|
|
|
|
|
def insertAttrsFct(sh6,nom_typ_court=False):
|
|
'''
|
|
Insertion des nouvelles version des attributs
|
|
fonctions biologiques, écologiques, sociologiques,
|
|
patrimoniale des sites zones humides.
|
|
Affectation des attributs à la géométrie la plus récente.
|
|
|
|
columns :
|
|
---------
|
|
'site_cod', 'fonction', 'typ_fonc', 'memo', 'auteur', 'date'
|
|
'''
|
|
tab = 'r_site_fctecosociopatri'
|
|
sch = pycen.zh().schema
|
|
df = sh6.copy()
|
|
df = crsp_colSiteFct(df)
|
|
param = pycen.zh()._get_param(
|
|
param_table='param_fct_eco_socio_patri',
|
|
type_table='type_param_fct',type_court=nom_typ_court)
|
|
|
|
for typ in df.typ_fonc.unique():
|
|
param_tmp = param.loc[param.type==typ]
|
|
df.loc[df.typ_fonc == typ,'id_fct'] = df.loc[df.typ_fonc == typ,'fonction'] \
|
|
.str.lower() \
|
|
.replace([*param_tmp.nom.str.lower()],[*param_tmp.id])
|
|
df['id_fct'] = df['id_fct'].astype(int)
|
|
|
|
df,ins = insertAttrs(df,sch, tab)
|
|
if ins:
|
|
ids = select_ID(df[df.columns.drop('auteur')],sch,tab)
|
|
if 'description' in df.columns:
|
|
df.description = df.description.astype(str)
|
|
df.loc[df.description=='nan','description'] = 'None'
|
|
ids.description = ids.description.astype(str)
|
|
if df.description.str.contains("'").any():
|
|
df.description = df.description.replace("'","''",regex=True)
|
|
if df.shape[0] != ids.shape[0]:
|
|
ids = select_ID(df[df.columns.drop(['auteur','description'])],sch,tab)
|
|
if 'description' in df.columns:
|
|
if df.description.str.contains("''").any():
|
|
df.description = df.description.replace("''","'",regex=True)
|
|
same_col = (df.columns[df.columns.isin(ids.columns)])
|
|
if 'date' in same_col:
|
|
df['date'] = df['date'].astype(str)
|
|
ids['date'] = ids['date'].astype(str)
|
|
df = df.merge(ids, on=[*same_col], how='left')
|
|
insertAutorAttrs(df,colname_rsite='id_sitefct', sch=sch, tab='r_rsitefct_auteur')
|
|
|
|
|
|
if __name__ == "__main__":
|
|
|
|
from os import path
|
|
FILE_PATH = '/home/colas/Documents/9_PROJETS/1_ZH/MAJ/Actu 2024/TEREO - 20241002_ENVOI_SIG_ZH/ADD DATA'
|
|
GEOM_PATH = 'TEREO_newZH.gpkg'
|
|
DATA_PATH = 'Tableau_saisie_ZH_TEREO.xlsx'
|
|
|
|
Gdf = gpd.read_file(path.join(FILE_PATH,GEOM_PATH), crs='EPSG:2154')
|
|
# Gdf['site_code'] = '38GR0070'
|
|
# lst = ['38BB0089','38BB0090','38BB0091','38BB0092']
|
|
# gdf = gdf[gdf.site_code.isin(lst)]
|
|
DF = pd.read_excel(path.join(FILE_PATH,DATA_PATH), sheet_name=None, header=1)
|
|
lst_sheet = [*DF.keys()]
|
|
for k in lst_sheet:
|
|
if isinstance(DF[k], pd.DataFrame):
|
|
DF[k].columns = DF[k].columns.str.lower()
|
|
elif isinstance(DF[k], dict):
|
|
lst_tmp = [*DF[k].keys()]
|
|
for kk in lst_tmp:
|
|
if isinstance(DF[k][kk], pd.DataFrame):
|
|
DF[k][kk].columns = DF[k][kk].columns.str.lower()
|
|
|
|
sh1 = DF[lst_sheet[0]]
|
|
sh1 = sh1[sh1.maj != 'SUPP'].copy()
|
|
sh1.editdate = pd.to_datetime(sh1.editdate)
|
|
|
|
sh1.auteur.replace(
|
|
['Nicolas BIRON','Alix GUEDOU'],
|
|
['BIRON Nicolas','GUEDOU Alix'],
|
|
inplace=True)
|
|
|
|
lst_site = list(sh1.site_cod.unique())
|
|
gdf = Gdf[Gdf.site_code.isin(lst_site)].reset_index(drop=True)
|
|
if gdf.geometry.name != 'geom':
|
|
gdf.rename_geometry('geom', inplace=True)
|
|
lst_site = list(gdf.site_code.unique())
|
|
sh1 = sh1[sh1.site_cod.isin(lst_site)]
|
|
sh1.name = lst_sheet[0]
|
|
gdf['auteur'] = sh1.auteur.values[0]
|
|
|
|
|
|
data_date = sh1[['site_cod','upddate']].copy()
|
|
data_date.columns = ['site_cod', 'date']
|
|
data_date.loc[data_date.date.isnull(),'date'] = sh1.loc[
|
|
sh1.site_cod.isin(
|
|
data_date.loc[data_date.date.isnull(),'site_cod']),
|
|
'editdate']
|
|
data_date['date'] = pd.to_datetime(data_date['date'])
|
|
if 'date' not in gdf.columns:
|
|
gdf = gdf.merge(data_date, left_on=['site_code'], right_on=['site_cod'], how='left')
|
|
del gdf['site_cod']
|
|
gdf['date_modif'] = gdf['date']
|
|
del gdf['date']
|
|
|
|
sh2 = DF[lst_sheet[1]]
|
|
sh2['auteur'] = sh1.auteur.values[0]
|
|
sh2 = sh2.merge(data_date, on=['site_cod'], how='left')
|
|
sh2 = sh2[sh2.site_cod.isin(lst_site)]
|
|
sh2.name = lst_sheet[1]
|
|
sh3 = DF[lst_sheet[2]]
|
|
sh3['auteur'] = sh1.auteur.values[0]
|
|
sh3 = sh3[sh3.site_cod.isin(lst_site)]
|
|
sh3.name = lst_sheet[2]
|
|
sh3 = sh3.merge(data_date, on=['site_cod'], how='left')
|
|
sh4 = DF[lst_sheet[3]]
|
|
sh4['auteur'] = sh1.auteur.values[0]
|
|
sh4 = sh4.merge(data_date, on=['site_cod'], how='left')
|
|
sh4 = sh4[sh4.site_cod.isin(lst_site)]
|
|
sh4.name = lst_sheet[3]
|
|
sh5 = DF[lst_sheet[4]]
|
|
sh5['auteur'] = sh1.auteur.values[0]
|
|
if sh5.site_cod.isna().any():
|
|
sh5.loc[sh5.site_cod.isna(),'site_cod'] = sh5.loc[sh5.site_cod.isna(),'site_cod.1']
|
|
sh5 = sh5.merge(data_date, on=['site_cod'], how='left')
|
|
sh5 = sh5[sh5.site_cod.isin(lst_site)]
|
|
sh5.name = lst_sheet[4]
|
|
sh6 = DF[lst_sheet[5]]
|
|
sh6['auteur'] = sh1.auteur.values[0]
|
|
sh6 = sh6.merge(data_date, on=['site_cod'], how='left')
|
|
sh6 = sh6[sh6.site_cod.isin(lst_site)]
|
|
sh6.name = lst_sheet[5]
|
|
sh7 = DF[lst_sheet[6]]
|
|
sh7['auteur'] = sh1.auteur.values[0]
|
|
sh7 = sh7.merge(data_date, on=['site_cod'], how='left')
|
|
sh7 = sh7[sh7.site_cod.isin(lst_site)]
|
|
sh7.name = lst_sheet[6]
|
|
sh8 = DF[lst_sheet[7]]
|
|
sh8['auteur'] = sh1.auteur.values[0]
|
|
sh8 = sh8.merge(data_date, on=['site_cod'], how='left')
|
|
sh8 = sh8[sh8.site_cod.isin(lst_site)]
|
|
sh8.name = lst_sheet[7]
|
|
|
|
|
|
|
|
add = sh1[sh1.maj=='ADD'].copy()
|
|
add = add.dropna(axis=1, how='any')
|
|
add['type_milieux'] = 'Tourbières et marais'
|
|
add = pd.merge(
|
|
add,
|
|
sh4[['site_cod','typo_sdage']].dropna(how='any').drop_duplicates(),
|
|
how='left',on='site_cod')
|
|
# add = forme_typsdage(add)
|
|
# maj = gdf[~gdf.site_code.isin(add.site_code)].copy()
|
|
|
|
# tmp = pycen.get_sitesGeom(id_site=['38BB0052','38BB0050'])
|
|
# gdf.loc[gdf.site_code=='38BB0050','geom'] = gdf[gdf.site_code=='38BB0050'].geom
|
|
|
|
|
|
insertNewSite(add)
|
|
insertNewGeom(gdf, rmq_geom=sh7)
|
|
|
|
|
|
insertAttrsDelim(sh3)
|
|
insertAttrsCB(sh2)
|
|
insertAttrsUsgPrss(sh4)
|
|
insertAttrsRegHydro(sh5)
|
|
insertAttrsFct(sh6.dropna(axis=1,how='all'))
|
|
|
|
|
|
|
|
maj = sh1[sh1.maj=='MAJ GEOM'].copy()
|
|
lst_maj = [*maj.site_cod]
|
|
# site = lst_maj[3]
|
|
for site in lst_maj:
|
|
print(site)
|
|
shP = pycen.zh().get_bilan(code_site=site,last_update=False)
|
|
shP = drop_maxDateGeomData(shP)
|
|
sh2b = shP['corine_biotope'].copy()
|
|
sh2b[['date','auteur']] = [sh1.loc[sh1.site_cod==site,'upddate'].values[0],sh1.auteur.values[0]]
|
|
del sh2b['id']
|
|
sh3b = shP['delimitation'].copy()
|
|
sh3b[['date','auteur']] = [sh1.loc[sh1.site_cod==site,'upddate'].values[0],sh1.auteur.values[0]]
|
|
sh3b = sh3b.set_index([ *sh3b.columns[~sh3b.columns.isin(['nom_crit'])] ])\
|
|
.unstack(level=-4).droplevel(0,axis=1).reset_index(drop=False)
|
|
del sh3b['id']
|
|
sh4b = shP['description'].copy()
|
|
sh4b[['date','auteur']] = [sh1.loc[sh1.site_cod==site,'upddate'].values[0],sh1.auteur.values[0]]
|
|
sh4b.rename(columns={'position':'localisation'},inplace=True)
|
|
del sh4b['id']
|
|
sh5b = shP['fonctionnement'].copy()
|
|
sh5ba = sh5b['entree_eau'].rename(columns={'id_site':'site_cod'}).drop(columns=['id']).reset_index(drop=True)
|
|
sh5bb = sh5b['sortie_eau'].rename(columns={'id_site':'site_cod'}).drop(columns=['id']).reset_index(drop=True)
|
|
sh5bc = sh5b['sub_connex'].rename(columns={'id_site':'site_cod'}).drop(columns=['id']).reset_index(drop=True)
|
|
sh5ba = sh5ba[['site_cod','rmq_toponymie','regime_hydri','permanence']].rename(columns={'regime_hydri':'entree_eau','permanence':'perm_in'})
|
|
sh5bb = sh5bb[['site_cod','rmq_toponymie','regime_hydri','permanence']].rename(columns={'regime_hydri':'sortie_eau','permanence':'perm_out'})
|
|
sh5bc = sh5bc[['site_cod','connexion']]
|
|
sh5ba[['unnamed: 4','unnamed: 5','unnamed: 6']] = None
|
|
sh5bb[['unnamed: 11','unnamed: 12','unnamed: 13','unnamed: 14']] = None
|
|
sh5B = pd.concat([sh5ba,sh5bb,sh5bc],axis=1)
|
|
sh5B['date'] = sh1.loc[sh1.site_cod==site,'upddate'].values[0]
|
|
sh5B['auteur'] = sh1.auteur.values[0]
|
|
sh6b = shP['fonction'].copy()
|
|
sh6b = sh6b.rename(columns={'type':'typ_fonc','nom_fct':'fonction'})
|
|
sh6b[['date','auteur']] = [sh1.loc[sh1.site_cod==site,'upddate'].values[0],sh1.auteur.values[0]]
|
|
del sh6b['id']
|
|
sh7b = shP['evaluation'].copy()
|
|
sh7b[['date','auteur']] = [sh1.loc[sh1.site_cod==site,'upddate'].values[0],sh1.auteur.values[0]]
|
|
|
|
|
|
insertAttrsCB(sh2b)
|
|
insertAttrsDelim(sh3b)
|
|
insertAttrsUsgPrss(sh4b)
|
|
insertAttrsRegHydro(sh5B)
|
|
insertAttrsFct(sh6b,nom_typ_court=True)
|
|
|
|
# st_clusterdbscan |