def coherence_libelle_infractiontype():
''' On regarde la cohérence entre les colonnes de infraction_histo
et celle que l'on peut avoir dans infraction_type
cohérence entre l'infraction type et articles, titre et libelle
'''
infraction_histo = read_table('infractionhisto')
infractiontype = read_table('infractiontype')
infractiontype.drop(['active', 'ordre'], axis=1, inplace=True)
infractiontype.rename(columns={'id': 'infractiontype_id'}, inplace=True)
test = infraction_histo.merge(infractiontype,
on='infractiontype_id',
how='outer',
indicator=True)
pb_article = test['articles_x'] != test['articles_y']
test['pb_article'] = pb_article
pb_titre = test['titre_x'] != test['titre_y']
test['pb_titre'] = pb_titre
pb_libelle = test['libelle_x'] != test['libelle_y']
test['pb_libelle'] = pb_libelle
pb_quelconque = pb_article | pb_titre | pb_libelle
pb = test[pb_quelconque]
len(test) - len(pb) # on a 30% sans problème
pb[['pb_libelle', 'pb_titre', 'pb_article']].sum()
pb.groupby(['pb_libelle', 'pb_titre', 'pb_article']).size()
# bcp de problème de cohérence titre
pb[pb_libelle].groupby(['libelle_x', 'libelle_y']).size()
infraction_histo.libelle.isin(infractiontype.libelle).value_counts()
def _recherche_valeurs_in_id(liste_valeurs, in_vars=['id'], verbose=False):
''' fonction utile pour la questions suivante
elle cherche dans les tables si les id contiennent toutes les
valeurs de liste_valeurs
si la liste des valeurs est _id alors on cherche dans toutes les
colonnes se terminant par _id
'''
primary_key, foreign_key = read_sql()
tables_on_disk = set(x[:-4] for x in os.listdir(path_sarah))
potentiel_match = []
vars_a_etudier = in_vars
for name in tables_on_disk:
tab = read_table(name, nrows=0)
if in_vars == '_id':
vars_a_etudier = [col for col in tab.columns if col[-3:] == '_id']
if any([var in tab.columns for var in vars_a_etudier]):
if verbose:
print('table', name)
tab = read_table(name)
for var in vars_a_etudier:
if var in tab.columns:
id_tab = tab[var]
if all(liste_valeurs.isin(id_tab)):
if verbose:
print(' matched pour', id_tab, '!!!')
if in_vars == '_id':
potentiel_match.append((name, var))
else:
potentiel_match.append(name)
return potentiel_match
def signalement_des_affaires():
''' lorsque l'on fuisionne affhygiene avec signalement affaire,
on a beaucoup de raté, comment se fait-ce ?
'''
affaire = read_table('affaire')
affhyg = read_table('affhygiene')
signalement_affaire = read_table('signalement_affaire')
test = pd.merge(affhyg,
signalement_affaire,
on='affaire_id',
how='outer',
indicator='provenance')
#test.provenance.value_counts()
#both 30692
#left_only 10433
#right_only 179
# => beaucoup d'affaire n'ont pas de signalement
id_affaires_sans_signalement = test.loc[test.provenance == 'left_only',
'affaire_id']
id_affaires_sans_signalement.sort_values(inplace=True)
shift = id_affaires_sans_signalement - id_affaires_sans_signalement.shift(
1)
# => 2/3 beaucoup d'écart de 1 comme si cela concernait des affaires proches
# exemple
# random = id_affaires_sans_signalement.iloc[5644] # = 5685
random = 5644
affaire_ids = id_affaires_sans_signalement.iloc[random - 5:random + 5]
bien_id_correspondant = affhyg.loc[affhyg['affaire_id'].isin(affaire_ids)]
cr = read_table('cr_visite')
cr[cr['affaire_id'].isin(bien_id_correspondant['affaire_id'])]
ccc = cr[cr['affaire_id'].isin(id_affaires_sans_signalement)]
def lien_infractionhisto_infraction():
infraction_brut = read_table('infraction')
infractionhisto = read_table('infractionhisto')
# étudie le lien entre infractionhisto et infraction
#len(infraction_brut) # 31022
#len(infractionhisto) # 49614
assert infractionhisto.infraction_id.isin(infraction_brut.id).all()
def incitation_table():
"""
Crée la table <incitation> au ravalement.
"""
incitation_ravalement = read_table('incitation_ravalement')
#pour la même affaire ouverte à une adresse donnée
# plusieurs incitations au ravalement possibles (jusqu'à 20)
incitation_ravalement.drop(
['copieconforme_en_cours', 'renotification_en_cours', 'nature'],
axis=1,
inplace=True,
)
incitation_ravalement.rename(columns={
'id':
'incitation_ravalement_id',
'date_envoi':
'date_envoi_incitation_ravalement'
},
inplace=True)
incitation_ravalement['date_envoi_incitation_ravalement'] = \
incitation_ravalement['date_envoi_incitation_ravalement'].str[:10]
incitation_ravalement_facade = read_table('incitation_ravalement_facade')
incitation_ravalement_facade.rename(
columns={'facadesconcernees_id': 'facade_id'},
inplace=True,
)
incitation = incitation_ravalement.merge(incitation_ravalement_facade,
on='incitation_ravalement_id',
how='left')
###Petit travail sur les délais d'incitation ###
delai = incitation['delai'] * (
(incitation['type_delai'] == 3).astype(int) + 30 *
((incitation['type_delai'] == 4).astype(int)))
incitation['delai_incitation_raval_en_jours'] = delai
incitation.drop(['delai', 'type_delai'], axis=1, inplace=True)
# une incitation peut consuire à un arrêté
arrete_ravalement_incitation_ravalement = read_table(
'arrete_ravalement_incitation_ravalement')
arrete_ravalement_incitation_ravalement.rename(
columns={'incitationsreferencees_id': 'incitation_ravalement_id'},
inplace=True)
incitation = incitation.merge(
arrete_ravalement_incitation_ravalement,
on='incitation_ravalement_id',
how='left',
#indicator = True,
)
incitation.rename(
columns={'arrete_ravalement_id': 'arrete_suite_a_incitation_id'},
inplace=True)
incitation['arrete_suite_a_incitation'] = incitation[
'arrete_suite_a_incitation_id'].notnull()
incitation.drop('arrete_suite_a_incitation_id', axis=1, inplace=True)
return incitation
def adresses_via_signalement(table,
liste_var_signalement=None,
prevent_duplicates=True):
'''
Trouve l'adresse d'une affaire en utilisant le signalement
La fonction utilise une table contenant une variable affaire_id
et
retrounes la table avec l'adresse_id correspondant à chaque affaire
repérée par affaire_id
en éliminant les affaire_id qui ne sont pas dans signalement_affaire
'''
assert 'affaire_id' in table.columns
# signalements
signalement_affaire = read_table('signalement_affaire')
signalement = read_table('signalement')
var_to_keep = ['id', 'adresse_id']
if liste_var_signalement is not None:
var_to_keep += liste_var_signalement
signalement = signalement[var_to_keep]
##Rename 'id' column of signalement table
signalement.rename(columns = {'id':'signalement_id'}, inplace = True)
table_signalement = pd.merge(signalement_affaire, signalement,
on='signalement_id',
how='left')
# est-ce que pour une affaire on a une seule adresse
table_signalement.groupby(['affaire_id'])['adresse_id'].nunique().value_counts()
# => non
# l'étude de ces cas, montre que l'on peut utiliser une seule des adresse_id
# adresse[adresse.adresse_id.isin(table_signalement.loc[table_signalement.affaire_id == 12795, 'adresse_id'])]
if prevent_duplicates:
table_signalement.drop_duplicates(['affaire_id'], inplace=True)
assert table_signalement.affaire_id.value_counts().max() == 1
if 'signalement_id' in table.columns:
table.rename(columns = {'signalement_id':'signalement_id_orig'},
inplace = True)
if 'libelle' in table_signalement.columns:
table_signalement.rename(columns = {'libelle':'libelle_table'}, inplace = True)
table_avec_signalement = pd.merge(table, table_signalement,
on='affaire_id',
how='left',
indicator='merge_signalement')
# len(table.affaire_id) # => 37322
# len(lien_signalement_affaire.affaire_id) ## => 30871
# len(result1.affaire_id) ## => 30692
return table_avec_signalement
def pv_table():
""""
Crée la table <PV> ravalement: affaires avec pv (ou non) avec quelques
infos comme la date de l'envoi du pv, quel facade concernée, quel
immeuble.
"""
##Travail sur la table pv ravalement##
pv_ravalement = read_table('pv_ravalement')
pv_ravalement.rename(columns={
'id': 'pv_ravalement_id',
'date_envoi': 'date_envoi_pv',
'date_creation': 'date_creation_pv'
},
inplace=True)
#pb_de_date = ['11-04-29 00:00:00']
#pv_ravalement.query('date_envoi >= "11-04-29 00:00:00"')
pv_ravalement['date_envoi_pv'] = pv_ravalement['date_envoi_pv'].str[:10]
pv_ravalement['date_creation_pv'] = pv_ravalement[
'date_creation_pv'].astype(str).str[:10]
pv_ravalement.drop(
['copieconforme_en_cours', 'renotification_en_cours', 'numero'],
axis=1,
inplace=True,
)
# un procès verbal a été envoyé à date_envoi
##Merge avec affravalement##
affravalement = read_table('affravalement')
table = affravalement.merge(
pv_ravalement,
on='affaire_id',
how='left',
)
#tables_reliees_a('pv_ravalement')
pv_ravalement_facade = read_table('pv_ravalement_facade')
pv_ravalement_facade.rename(
columns={'facadesconcernees_id': 'facade_id'},
inplace=True,
)
##Merge avec pv_ravalementè_facade##
#Fais la liaison avec les façades
table = table.merge(
pv_ravalement_facade,
on='pv_ravalement_id',
how='left',
#indicator = True,
)
return table
def columns_by_table():
columns = dict()
tables_on_disk = set(x[:-4] for x in os.listdir(path_sarah))
for table in tables_on_disk:
tab = read_table(table, nrows=0)
columns[table] = tab.columns
return columns
def table_affaire():
""" retourne la table avec date, adresse_id et affaire_id """
cr = read_table('cr_visite')[['date_creation','affaire_id']]
assert all(cr.date_creation.notnull())
# ne garde que la date (pas l'heure)
cr['date_creation'] = cr['date_creation'].dt.date
# on garde une seule date par affaire (la premiere)
cr = cr.groupby('affaire_id')['date_creation'].min().reset_index()
hyg = read_table('affhygiene')[['affaire_id', 'bien_id']]
# on garde les affaires ayant déjà eu au moins une visite
hyg = hyg.merge(cr,
on = 'affaire_id',
how = 'right')
return hyg
def facade_table():
"""
Crée la table <façade> qui donne des infos sur chaque façade: son nom
(voir désignation), sa hauteur, le matériau de construction.
"""
facade = read_table('facade')
facade.rename(columns = {'id':'facade_id'},inplace = True)
####Merge avec type facade###
def add_info(table_ini, info_table_name, col):
info_table = read_table(info_table_name)
info_table.drop(['active','ordre'], axis = 1, inplace = True)
info_table.rename(columns = {'id':col[0],'libelle':col[1]},
inplace = True,
)
table = table_ini.merge(info_table, on = col[0], how = 'left')
table.drop([col[0]], axis = 1, inplace = True)
return table
####Merge avec type facade###
table = add_info(facade,'typefacade',['typefacade_id','type_facade'])
###Merge avec haut facade###
table = add_info(table, 'hautfacade',['hautfacade_id','hauteur_facade'])
####Merge avec mater facade###
table = add_info(table, 'materfacade',['materfacade_id','materiau_facade'])
####Merge avec affect facade###
table = add_info(table, 'affectfacade',['affectfacade_id','affectation_facade'])
####Variables inutiles####
table.drop(['the_geom','possedecbles','possedeterr','recolable'],
axis = 1, inplace = True)
return table
def parcelles():
''' travaille au niveau de la parcelle cadastrale et offre une
table propre
A l'issue de ce programme, les tables:
- parcelle_cadastrale
- ilot
- quartier_admin
- arrondissement
n'ont plus de raison d'être appelée
'''
print(" On a :\n",
" - 75105 parcelle cadastralle, dans\n",
" - 5031 ilots, dans\n",
" - 80 quarties administratifs, dans\n",
" - 20 arrondissements, dans\n",
)
parcelle_cadastrale = read_table('parcelle_cadastrale')
parcelle_cadastrale.rename(columns = {'id':'parcelle_id'}, inplace = True)
# les variables non retenues n'ont pas d'intérêt
parcelle_cadastrale = parcelle_cadastrale[['parcelle_id','ilot_id',\
'code_cadastre']]
ilot = read_table('ilot')
ilot.rename(columns = {'nsq_ia':'ilot_id'}, inplace = True)
parcelle_augmentee = parcelle_cadastrale.merge(ilot, on='ilot_id', how='left')
quartier_admin = read_table('quartier_admin')
quartier_admin = quartier_admin[['nsq_qu', 'tln', 'nsq_ca']]
quartier_admin.rename(columns = {'nsq_qu':'nqu',
'tln': 'quartier_admin'}, inplace = True)
parcelle_augmentee = parcelle_augmentee.merge(
quartier_admin, on='nqu', how='left')
arrondissement = read_table('arrondissement')
arrond = arrondissement[['id', 'codeinsee', 'codepostal', 'nomcommune']]
arrond.rename(columns = {'id':'nsq_ca'}, inplace = True)
parcelle_augmentee = parcelle_augmentee.merge(arrond, on='nsq_ca', how='left')
# on renomme ilot_id pour ne pas chercher à fusionner encore par la suite
parcelle_augmentee.drop(['nqu', 'nsq_ca'], axis=1, inplace=True)
parcelle_augmentee['ilot_id'].fillna(-1, inplace=True)
parcelle_augmentee['numero_ilot'] = parcelle_augmentee['ilot_id'].astype(int)
del parcelle_augmentee['ilot_id']
return parcelle_augmentee
def non_empty_tables():
tables_on_disk = set(x[:-4] for x in os.listdir(path_sarah))
for table in tables_on_disk:
path_file = os.path.join(path_sarah, table + '.csv')
path_good = os.path.join(path_csv_good, table + '.csv')
tab = read_table(table)
if len(tab) > 0:
shutil.copy(path_file, path_good)
def infraction_table():
infraction = read_table('infraction')[['affaire_id', 'infractiontype_id']]
infractiontype = read_table('infractiontype')
infractiontype.drop(['active', 'ordre'], axis=1, inplace=True)
infractiontype.rename(columns={
'id': 'infractiontype_id',
'libelle': 'type_infraction'
},
inplace=True)
infraction_augmentee = infraction.merge(infractiontype,
on='infractiontype_id',
how='left')
infraction_augmentee = infraction_augmentee.groupby(
'affaire_id').first().reset_index()
return infraction_augmentee
def add_info(table_ini, info_table_name, col):
info_table = read_table(info_table_name)
info_table.drop(['active','ordre'], axis = 1, inplace = True)
info_table.rename(columns = {'id':col[0],'libelle':col[1]},
inplace = True,
)
table = table_ini.merge(info_table, on = col[0], how = 'left')
table.drop([col[0]], axis = 1, inplace = True)
return table
def prescription_table():
##prépare table prescription
prescription = read_table('prescription')
prescription.rename(columns={
'id': 'prescription_id',
'libelle': 'prescription'
},
inplace=True)
#prépare table prescription_type
prescription_type = read_table('prescriptiontype')
#prescription_type.ordre.isnull().all() ## =>True
#prescription_type.active.value_counts()
#True 32, False 1
prescription_type.drop(['active', 'ordre'], axis=1, inplace=True)
prescription_type.rename(columns={
'id': 'prescriptiontype_id',
'libelle': 'type_prescription'
},
inplace=True)
prescription_augmentee = prescription.merge(
prescription_type,
on='prescriptiontype_id',
how='left',
# indicator = True
)
##prépare etat_prescription
etat_prescription = read_table('etatprescription')
assert prescription.etat_id.isin(etat_prescription.id).all()
etat_prescription.rename(columns={
'id': 'etat_id',
'libelle': 'etat_prescription'
},
inplace=True)
prescription_augmentee = prescription_augmentee.merge(etat_prescription,
on='etat_id',
how='left')
prescription_augmentee = prescription_augmentee.groupby(
'affaire_id').first().reset_index()
return prescription_augmentee
def coherence_affaires_histoinfractions():
'''
infractionhisto pointe vers cr_visite qui pointe vers affaire
infractionhisto pointe vers infraction qui pointe vers affaire
On verifie la cohérence
'''
infractionhisto = read_table('infractionhisto')
cr_visite = read_table('cr_visite')
cr_visite.rename(columns={'id': 'compterenduvisite_id'}, inplace=True)
infraction = read_table('infraction')
infraction.rename(columns={'id': 'infraction_id'}, inplace=True)
##=>True
#Est-ce vrai pour toute ligne de infractionhisto?
infractionhisto = infractionhisto[[
'id', 'infraction_id', 'compterenduvisite_id'
]]
infractionhisto.rename(columns={'id': 'infractionhisto_id'}, inplace=True)
infractionhisto.drop_duplicates(inplace=True)
via_table_cr_visite = infractionhisto.merge(cr_visite,
on='compterenduvisite_id',
how='left')
via_table_infraction = infractionhisto.merge(infraction,
on='infraction_id',
how='left',
indicator='is_in_infraction')
infractionhisto.infraction_id.isin(infraction.infraction_id)
parinfraction = pd.Series(via_table_infraction.affaire_id.unique())
parvisite = pd.Series(via_table_cr_visite.affaire_id.unique())
parinfraction.isin(parvisite).value_counts() ##=> True 16937, False 1
parvisite.isin(parinfraction).value_counts() ##=> True 16937, False 125
test_coherence = via_table_infraction.merge(
via_table_cr_visite,
on=['infractionhisto_id', 'affaire_id'],
how='outer',
indicator=True)
problemes = test_coherence[test_coherence['_merge'] != 'both']
test_coherence._merge.value_counts()
def question_bien_id():
''' On va regarder les id de toutes les tables et
selectionner celle qui contiennent les valeur de bien_id
'''
hyg = read_table('affhygiene')
liste_valeurs = hyg.bien_id
print(_recherche_valeurs_in_id(liste_valeurs))
# => ['ficherecolem']
# autre hypothèse bien_id se retrouve dans plusieurs tables !
immeuble = read_table('immeuble')
batiment = read_table('batiment')
parcelle = read_table('parcelle_cadastrale')
localhabite = read_table('localhabite')
tous_les_ids = immeuble.id.append(batiment.id).append(parcelle.id).append(
localhabite.id)
assert all(tous_les_ids.value_counts() == 1)
assert all(liste_valeurs.isin(tous_les_ids))
def arrete_table():
"""
Crée la table <arrêté> avec les infos temporelles sur la vie de l'arrêté
"""
###Travail sur la table arrete ravalement ###
arrete_ravalement = read_table('arrete_ravalement')
arrete_ravalement.drop(
[
'copieconforme_en_cours', 'renotification_en_cours', 'cdd_id',
'nature'
],
axis=1,
inplace=True,
)
dates = [
'date_delai', 'date_enregistrement', 'date_envoi', 'date_notification',
'date_signature', 'date_visite'
]
arrete_ravalement[dates] = arrete_ravalement[dates].apply(
lambda x: x.astype(str).str[:10])
dates_arrete = [col + '_arrete' for col in dates]
rename_dates = dict(zip(dates, dates_arrete))
rename_dates['id'] = 'arrete_ravalement_id'
arrete_ravalement.rename(columns=rename_dates, inplace=True)
###Petit travail sur les délais d'arreté ###
delai = arrete_ravalement['delai'] * (
(arrete_ravalement['type_delai'] == 3).astype(int) + 30 *
((arrete_ravalement['type_delai'] == 4).astype(int)))
arrete_ravalement['delai_arrete_raval_en_jours'] = delai
arrete_ravalement.drop(['delai', 'type_delai'], axis=1, inplace=True)
arrete_ravalement_facade = read_table('arrete_ravalement_facade')
arrete_ravalement_facade.rename(
columns={'facadesconcernees_id': 'facade_id'}, inplace=True)
table = arrete_ravalement.merge(arrete_ravalement_facade,
on='arrete_ravalement_id',
how='left')
table['injonction'] = table['injonction_id'].notnull()
table.drop('injonction_id', axis=1, inplace=True)
return table
def traitement_reprise_infractionhisto():
infractionhisto = read_table('infractionhisto')
# on retire les Reprise qui sont dures à exploiter
# TODO: vérifier le sens de ces reprises et la pertinence de les enlever
reprise = (infractionhisto['libelle'] == 'Reprise') & \
(infractionhisto['titre'] == 'Reprise')
infractionhisto = infractionhisto[~reprise]
# il y a un problème de cohérence entre l'infraction type et articles, titre et
#libelle: voir questions.py
# Solution : mettre les reprises (les premières lignes) de côtés
return infractionhisto
def fusion(list_des_fusions, verbose=False):
for tab2_name in list_des_fusions:
tab2 = read_table(tab2_name)
var2 = primary_key[tab2_name]
assert var2 in tab2 or var2 == 'None'
# print(tab2_name, len(tab2))
for link in [x for x in foreign_key if x[2] == tab2_name]:
tab1_name = link[0]
var1 = link[1]
if verbose:
print('On augmente ', tab1_name, 'avec', tab2_name)
def coherence_infractions_histoinfractions():
'''
on regarde si les infractions sont dans histoinfraction et inversement
'''
infractionhisto = read_table('infractionhisto')
infraction = read_table('infraction')
infraction.rename(columns={'id': 'infraction_id'}, inplace=True)
#Est-ce vrai pour toute ligne de infractionhisto?
infractionhisto = infractionhisto[[
'id', 'infraction_id', 'compterenduvisite_id'
]]
infractionhisto.rename(columns={'id': 'infractionhisto_id'}, inplace=True)
test_coherence = infractionhisto.merge(infraction,
on='infraction_id',
how='outer',
indicator=True)
test_coherence._merge.value_counts()
problemes = test_coherence[test_coherence['_merge'] != 'both']
def coherence_adresses_via_signalement_et_via_bien_id():
hyg = read_table('affhygiene')
hyg_bien_id = adresse_via_bien_id(hyg)
hyg_bien_id = hyg_bien_id[[
'affaire_id', 'bien_id', 'bien_id_provenance', 'parcelle_id',
'adresse_id', 'codeinsee', 'codepostal'
]]
hyg_bien_id = hyg_bien_id[hyg_bien_id.adresse_id.notnull()]
hyg_signalement = adresses_via_signalement(hyg)
hyg_signalement = hyg_signalement[hyg_signalement.adresse_id.notnull()]
hyg_signalement = hyg_signalement.groupby(
'affaire_id').first().reset_index()
test = hyg_signalement.merge(
hyg_bien_id,
on='affaire_id',
how='outer',
indicator='origine',
suffixes=('_bien', '_sign'),
)
test.origine.value_counts()
matched = test[test['origine'] == 'both']
matched['valid'] = matched['adresse_id_bien'] == matched['adresse_id_sign']
adresse = adresses()[[
'adresse_id', 'libelle', 'codepostal', 'code_cadastre'
]]
matched = matched.merge(adresse,
left_on='adresse_id_bien',
right_on='adresse_id',
how='left')
del matched['adresse_id']
matched = matched.merge(
adresse,
left_on='adresse_id_sign',
right_on='adresse_id',
how='left',
suffixes=('_bien', '_sign'),
)
pd.crosstab(matched['bien_id_provenance_bien'], matched['valid'])
pb = matched[~matched['valid']][[
'affaire_id',
'adresse_id_bien',
'libelle_bien',
'adresse_id_sign',
'libelle_sign',
]]
def coherence_arretehyautre_pvscp():
''' Question : quelle cohérence entre arretehyautre et pvscp ? '''
## Ne marche pas !
arrete = read_table('arretehyautre')[['id', 'affaire_id', 'type_id']]
arrete.rename(columns={'id': 'arrete_hygiene_id'}, inplace=True)
pvcsp = read_table('pvcsp')
## Première vérification
pvcsp_avec_arrete = pvcsp.merge(arrete,
on='arrete_hygiene_id',
how='outer',
indicator=True)
# bcp moins de pvscp que d'arrete mais tous dedans.
# supsicion : il n'y a que les arrêté en cours, les autres sont dans classés
# sinon, il y a bien cohérence puisque les pvcsp renvoie à arrete
## vérification des cohérences des affaires
cr = read_table('cr_visite')
cr = cr[['id', 'affaire_id']]
cr.rename(columns={'id': 'compte_rendu_id'}, inplace=True)
arrete_avec_cr = arrete.merge(cr,
on='affaire_id',
how='left',
indicator=True)
# => 15 non match ? cf arrete_avec_cr._merge.value_counts()
pvcsp_avec_cr = pvcsp.merge(cr,
on='compte_rendu_id',
how='left',
indicator=True)
# pvcsp_avec_cr._merge.value_counts()
affaires_pvscp = pvcsp_avec_cr.affaire_id
affaires_arrete = arrete_avec_cr.affaire_id
assert all(affaires_pvscp.isin(affaires_arrete))
assert not all(affaires_arrete.isin(affaires_pvscp))
def affaires_hyg_ou_raval():
'''
On regarde si une affaire de la table affaire et ou bien dans
aff_hygiene ou bien dans aff_ravalement
'''
affaire = read_table('affaire')
hyg = read_table('affhygiene')
rava = read_table('affravalement')
# premier test
assert len(affaire) == len(hyg) + len(rava)
# affaire_id est bien dans l'id de affaire
assert all(hyg['affaire_id'].isin(affaire['id']))
assert all(rava['affaire_id'].isin(affaire['id']))
# affaire_id n'est pas à la fois dans hygiène et dans ravalement
assert (all(~hyg['affaire_id'].isin(rava['affaire_id'])))
assert (all(~rava['affaire_id'].isin(hyg['affaire_id'])))
# les affaires sont bien dans affhygiene et dans affravalement
liste_affaire = (rava['affaire_id'].append(hyg['affaire_id'])).tolist()
assert (all(affaire['id'].isin(liste_affaire)))
def date_crvisite():
cr_visite_brut = read_table('cr_visite')
## Vaine tentative de drop_duplicates
# all_but_id = [x for x in cr_visite_brut.columns
# if x not in ['id', 'date_creation']
# ]
# cr_visite = cr_visite_brut.drop_duplicates(subset=all_but_id) #à ne pas faire
# parce que l'on perd des id et que l'on rate un merge plus loin
cr_visite = cr_visite_brut[['id', 'affaire_id', 'date']]
#len(cr_visite) ##=>49548 visites
#cr_visite.affaire_id.value_counts()
#cr_visite.affaire_id.nunique() #34122 affaires distinctes
# avec n>=1 visites chacune
### on a des problème de date
pb_de_date = [
'1000-10-16 00:00:00', '0029-06-29 00:00:00', '1010-04-06 00:00:00'
]
# on regarde si date et date_creation correspondent
# et c'est pareil dans la moitié des cas, très proche dans les autres
# => on peut se dire qu'en cas de problème on prend date_creation à la
# place de date
# date = cr_visite_brut['date'].str[:10]
# date_creation = cr_visite_brut['date_creation'].astype(str).str[:10]
# (date == date_creation).value_counts()
cr_visite.loc[cr_visite['date'].isin(pb_de_date), 'date'] = \
cr_visite_brut.loc[cr_visite['date'].isin(pb_de_date), 'date_creation']
cr_visite.loc[cr_visite['date'].isnull(), 'date'] = \
cr_visite_brut.loc[cr_visite['date'].isnull(), 'date_creation']
cr_visite['date'] = pd.to_datetime(cr_visite['date'])
# une affaire entraîne peut avoir plusieurs visites dans la journée
#assert not all(cr_visite.groupby(['affaire_id', 'date']).size() == 1)
#cr_visite_brut[cr_visite.affaire_id == 14665]
return cr_visite
def immeuble_table():
"""
Crée la table <immeuble> qui fait le pont entre l'immeuble et la parcelle
dans laquelle il se trouve
"""
immeuble = read_table('immeuble')
immeuble.rename(columns = {'id':'immeuble_id',
'adresseprincipale_id': 'adresse_id'},
inplace = True)
###Suppression colonnes inutiles ###
immeuble = immeuble.loc[:, immeuble.notnull().sum() > 1] # retire les colonnes vides
# une étude colonne par colonne
del immeuble['champprocedure'] # tous vrais sauf 10
del immeuble['demoli'] # tous vrais sauf 1
que_des_2 = ['diagplomb', 'diagtermite', 'etudemql', 'grilleanah',
'rapportpreop', 'risquesaturn', 'signalementprefecturepolice',
]
immeuble.drop(que_des_2, axis=1, inplace=True)
del immeuble['tournee_id'] # que 8 valeurs
### Date recolement ####
immeuble['daterecolement'] = immeuble['daterecolement'].astype(str).str[:10]
return immeuble
def adresse_via_bien_id(table):
'''
Trouve l'adresse d'une affaire en utilisant le bien_id
Cet identifiant renvoie à l'une des quatre tables suivante :
- localhabite
- batiment
- immeuble
- parcelle_cadastrale
La fonction utilise une table contenant une variable bien_id
et
retrounes la table avec l'adresse_id correspondant à chaque affaire
'''
assert 'bien_id' in table.columns
bien_ids = table['bien_id']
# autre hypothèse bien_id se retrouve dans plusieurs tables !
localhabite = read_table('localhabite')
batiment = read_table('batiment')
immeuble = read_table('immeuble')
parcelle_cadastrale = read_table('parcelle_cadastrale')
table['bien_id_provenance'] = ''
for origine_possible in [
'localhabite', 'batiment', 'immeuble', 'parcelle_cadastrale'
]:
cond = bien_ids.isin(eval(origine_possible).id)
table.loc[cond, 'bien_id_provenance'] = origine_possible
print('origine de bien_id \n', table['bien_id_provenance'].value_counts(),
"\n")
##### Travail sur les info des differentes tables
del localhabite['codification'] #inutile et incomplet
# TODO: on pourrait travailler sur l'étage
# en passant
batiment['designation'] = batiment['designation'].str.lower().str.strip()
batiment['designation'] = batiment['designation'].str.replace(
'timent', 't')
batiment['designation'] = batiment['designation'].str.replace('bat', 'bât')
batiment['designation'] = batiment['designation'].str.replace('bät', 'bât')
batiment['designation'] = batiment['designation'].str.replace(
'bât.', 'bât ')
del batiment['digicode'] # inutile
immeuble = immeuble.loc[:, immeuble.notnull().sum() >
1] # retire les colonnes vides
# une étude colonne par colonne
del immeuble['champprocedure'] # tous vrais sauf 10
del immeuble['demoli'] # tous vrais sauf 1
que_des_2 = [
'diagplomb',
'diagtermite',
'etudemql',
'grilleanah',
'rapportpreop',
'risquesaturn',
'signalementprefecturepolice',
]
immeuble.drop(que_des_2, axis=1, inplace=True)
del immeuble['tournee_id'] # que 8 valeurs
parcelle_cadastrale = parcelles()
### Travail sur les id et les fusions
print("Un local habité est dans un bâtiment\n",
"Un bâtiment est dans un immeuble\n",
"Un immeuble est dans une parcelle\n")
# on va chercher d'abord pour chaque table les info annexes
# parcelle_cadastrale ok grace à parcelle()
# on a pas mal d'adresse principale vide ?!
immeuble.rename(columns={'adresseprincipale_id': 'adresse_id'},
inplace=True)
#=> on s'arrête là car toute la gestion des adresses est faire ailleurs
# voir adresse_de_l_affaire
entree = read_table('modentbat')[['id', 'libelle']]
entree.columns = ['modentbat_id', 'mode_entree_batiment']
batiment = batiment.merge(entree, how='left')
del batiment['modentbat_id']
hautfacade = read_table('hautfacade')[['id', 'libelle']]
hautfacade.columns = ['hautfacade_id', 'hauteur_facade']
batiment = batiment.merge(hautfacade, how='left')
del batiment['hautfacade_id']
table['localhabite_id'] = table['bien_id'] * (table['bien_id_provenance']
== 'localhabite')
table.replace(0, np.nan, inplace=True)
localhabite.rename(columns={'id': 'localhabite_id'}, inplace=True)
assert localhabite['localhabite_id'].value_counts().max() == 1
table = table.merge(localhabite, on='localhabite_id', how='left')
bien_id_batiment = table['bien_id_provenance'] == 'batiment'
table.loc[bien_id_batiment, 'batiment_id'] = table.loc[bien_id_batiment,
'bien_id']
batiment.rename(columns={'id': 'batiment_id'}, inplace=True)
assert batiment['batiment_id'].value_counts().max() == 1
table = table.merge(batiment, on='batiment_id', how='left')
bien_id_immeuble = table['bien_id_provenance'] == 'immeuble'
table.loc[bien_id_immeuble, 'immeuble_id'] = table.loc[bien_id_immeuble,
'bien_id']
immeuble.rename(columns={'id': 'immeuble_id'}, inplace=True)
assert immeuble['immeuble_id'].value_counts().max() == 1
table = table.merge(immeuble, on='immeuble_id', how='left')
bien_id_parcelle = table['bien_id_provenance'] == 'parcelle_cadastrale'
table.loc[bien_id_parcelle, 'parcelle_id'] = table.loc[bien_id_parcelle,
'bien_id']
assert parcelle_cadastrale['parcelle_id'].value_counts().max() == 1
table = table.merge(parcelle_cadastrale, on='parcelle_id', how='left')
table.rename(columns={
'observations_x': 'observations_localhabite',
'observations_y': 'observations_batiment',
'observations': 'observations_immeuble',
},
inplace=True)
return table
'bien_id']
assert parcelle_cadastrale['parcelle_id'].value_counts().max() == 1
table = table.merge(parcelle_cadastrale, on='parcelle_id', how='left')
table.rename(columns={
'observations_x': 'observations_localhabite',
'observations_y': 'observations_batiment',
'observations': 'observations_immeuble',
},
inplace=True)
return table
if __name__ == '__main__':
hyg = read_table('affhygiene')
hyg = adresse_via_bien_id(hyg)
### dans immeuble il y a parcelle et adresse.
# or adresse est lié à parcelle, il faut vérifier la cohérence
adresse = adresses()[['adresse_id', 'parcelle_id']]
test = hyg[hyg.adresse_id.notnull()].merge(adresse,
on='adresse_id',
how='left',
indicator=True)
sum(test['parcelle_id_x'] != test['parcelle_id_y'])
# 1 seule erreur
path_adresses = os.path.join(path_output, 'adresses.csv')
hyg.to_csv(path_adresses)
Ce programme étudier les pistes pour déterminer les bâtiments non insalubres
Idée 1: les cr_visites sans histoinfraction
Idée 2: les cr_visites sans histoinfraction
Idée 3: les affaires sans infraction
"""
import pandas as pd
from insalubrite.Sarah.read import read_table
from insalubrite.config_insal import path_output
### Idée 1: cr_visites sans histoinfraction
cr = read_table('cr_visite')
cr = cr[['id', 'affaire_id']]
infraction_histo = read_table('infractionhisto')
infraction_histo = infraction_histo[[
'date_historisation',
'compterenduvisite_id',
'infraction_id',
'infractiontype_id',
'titre',
'libelle',
'articles',
]]
# il y a un problème de cohérence entre l'infraction type et articles, titre et
#libelle
suffixes=('_sign', '_bien'),
indicator=indicator,
)
# assert len(table_adresses_max) == len(table_bien_id)
#table_adresses_max.adresse_id_bien.value_counts(dropna=False)
##=> NaN 30832, reste 21843
#table_adresses_max.adresse_id_sign.value_counts(dropna=False)
##=> NaN 14339, reste 38336
(table_adresses_max.adresse_id_bien == \
table_adresses_max.adresse_id_sign).value_counts(dropna = False)
##=>False 40568, True 12107
#Idée: Construire une colonne adresse_id avec adresse_id_sign quand ça
# existe et sinon adresse_id_bien
table_adresses_max['adresse_id'] = table_adresses_max['adresse_id_sign']
no_adresse_signalement = table_adresses_max['adresse_id_sign'].isnull()
table_adresses_max.loc[no_adresse_signalement, 'adresse_id'] = \
table_adresses_max.loc[no_adresse_signalement, 'adresse_id_bien' ]
#retire les doublons, en ne gardant
table_adresses_max.drop_duplicates(inplace=True)
table_adresses_max.groupby(var_to_merge_on)['adresse_id'].nunique()
assert len(table_adresses_max) == len(table)
return table_adresses_max
if __name__ == '__main__':
hyg = read_table('affhygiene')[['affaire_id', 'bien_id']]
adresse_par_affaires = add_adresse_id(hyg, indicator='origine')
