def mapping_raison_sociale(df_siren, raison_sociale, tol_dist_lev = 2, tol_len = 2):
"""
Cette fonction fait un premier filter sur la raison sociale
et renvoie l'index des lignes de df_siren qui passe se filtre
"""
logger.debug(autolog_msg(u"Received a call to function"))
#!20180308 protection de la fonction mapping_siren: ajout de cette fonction
#if random.randint(0,3)==0: raise ValueError("Simulated error")
raison_sociale = tools.convert2unicode(raison_sociale)
len_raison_sociale = len(raison_sociale)
#np_raison_sociale_Leven = np.abs(np_raison_sociale_len-len_raison_sociale)<=tol_len
raison_sociale_filter = (df_siren[u"raison_sociale_len"]-len_raison_sociale).abs()<=tol_len
col_filtered_raison_sociale_Leven = df_siren.loc[raison_sociale_filter,u"raison_sociale"]
col_exact_match = col_filtered_raison_sociale_Leven == raison_sociale
nb_exact_match = col_exact_match.sum()
if nb_exact_match>0: #matching exacte -> on renvoit uniquement les lignes avec un matching exacte
res_index = col_filtered_raison_sociale_Leven.index[col_exact_match]
pd_dist_raison_sociale = pd.DataFrame({u"Levenstein_dist_raison_sociale": [0]*len(res_index),
u"is_subtring_raison_sociale": [True]*len(res_index)}, index = res_index)
return res_index, pd_dist_raison_sociale
else:
#filtre selon la métrique de levensthein
col_dist_Lev = col_filtered_raison_sociale_Leven.apply(lambda enseigne: Levenshtein.distance(enseigne,raison_sociale))
min_dist = col_dist_Lev.min()
res_index = col_dist_Lev.index[col_dist_Lev<=min_dist+tol_dist_lev]
#filtre selon les substring
np_raison_sociale_substring = df_siren[u"raison_sociale_len"]>len_raison_sociale
col_is_substring = df_siren.loc[np_raison_sociale_substring, u"raison_sociale"].apply(lambda enseigne: raison_sociale in enseigne)
res_index = res_index.union(col_is_substring.index[col_is_substring])
#
series_raison_soc = df_siren.loc[res_index,u"raison_sociale"]
pd_dist_raison_sociale = pd.DataFrame(index = res_index)
pd_dist_raison_sociale[u"Levenstein_dist_raison_sociale"] = series_raison_soc.apply(lambda enseigne: Levenshtein.distance(enseigne,raison_sociale))
pd_dist_raison_sociale[u"is_subtring_raison_sociale"] = series_raison_soc.apply(lambda enseigne: raison_sociale in enseigne)
return res_index, pd_dist_raison_sociale
def mapping_code_postal(df_mapping, code_postal):
"""
Cette fonction fait un filtre sur le code postal
Elle renvoie le data frame filtré
"""
logger.debug(autolog_msg(u"Received a call to function"))
if code_postal:
code_postal = tools.convert2unicode(code_postal)
match_code_postal = df_mapping[u"CODPOS"] == code_postal
res_index = df_mapping.index[match_code_postal]
n1 = len(res_index)
if n1>=1:
pd_dist_code_postal = pd.DataFrame({u"match_code_postal": match_code_postal[res_index],
u"match_code_postal_prefix": [True]*n1},
index =res_index)
else:
#on essaie un match des deux premiers chiffres du code postal
code_postal_prefix = code_postal[:2]
match_code_postal_prefix = df_mapping[u"CODPOS"].apply(lambda codpos: codpos[:2] == code_postal_prefix)
n2 = np.sum(match_code_postal_prefix)
if n2>=1:
res_index = df_mapping.index[match_code_postal_prefix]
pd_dist_code_postal = pd.DataFrame({u"match_code_postal": match_code_postal[res_index],
u"match_code_postal_prefix": match_code_postal_prefix},
index =res_index)
else: #pas de filtre sur le code postal
res_index = df_mapping.index
pd_dist_code_postal = pd.DataFrame({u"match_code_postal": match_code_postal[res_index],
u"match_code_postal_prefix": [False]*len(res_index)},
index =res_index)
df_mapping = pd.concat([df_mapping.loc[res_index], pd_dist_code_postal], axis = 1)
else: #le code postale n'a pas été trouvé dans le json
df_mapping[u"match_code_postal"] = False
df_mapping[u"match_code_postal_prefix"] = False
return df_mapping
def check_keys_existence(objet, list_key):
"""
Vérifie si la liste de clé list_key est un chemin valide de l'objet
Si oui, l'objet au bout du chemin d'accès, sinon retourne None
"""
logger.debug(autolog_msg(u"Received a call to function"))
#!20180308 passage_par_reference
#deep copy pour ne pas modidier le dictionnaire en entrée
copy_objet = copy.deepcopy(objet)
for key in list_key:
if type(key) == str or type(key) == unicode: #cas d'un dictionnaire
key = tools.convert2unicode(key)
if key not in copy_objet:
logger.warning(u"La clé {} n'a pas été trouvé.".format(key))
return None
copy_objet = copy_objet[key]
elif type(key) == int:
if len(copy_objet) <= key:
logger.warning(
u"La liste a une longeur insuffisante pour la clé {}.".
format(key))
return None
copy_objet = copy_objet[key]
else:
logger.warning(u"La clé {} a un type inconnu".format(key))
return None
return copy_objet
def get_entete_df_resultat(entete_csv_siren, entete_csv_ws,
param_add_tag_cctx_file):
"""
Fonction renvoyant l'entête du fichier de résultats résumant les choix d'insertion
de SIREN effectué
"""
logger.debug(autolog_msg(u"Received a call to function"))
ls_export_name = [
tools.convert2unicode(export_name) for import_name, export_name in
param_add_tag_cctx_file[u'list_keys_import_export']
]
#entete_csv_siren + entete_csv_ws + ['demandeur_name'] + ls_export_name
if entete_csv_ws is None:
#20180320: Ajout des paramètres d'input/output en arguments de ligne de commande
#entete_csv_resultat = [u'siren@'+name for name in entete_csv_siren] + [u'res@demandeur_name'] + [u'res@'+name for name in ls_export_name]
entete_csv_resultat = [
u'siren@' + name for name in entete_csv_siren
] + [
u'res@company_name_from_jurisprud_file',
u'res@company_name_related_to_extracted_siren_number'
] + [u'res@' + name for name in ls_export_name]
else:
#20180320: Ajout des paramètres d'input/output en arguments de ligne de commande
#entete_csv_resultat = [u'siren@'+name for name in entete_csv_siren] + [u'ws@'+name for name in entete_csv_ws] + [u'res@demandeur_name'] + [u'res@'+name for name in ls_export_name]
entete_csv_resultat = [
u'siren@' + name for name in entete_csv_siren
] + [u'ws@' + name for name in entete_csv_ws] + [
u'res@company_name_from_jurisprud_file',
u'res@company_name_related_to_extracted_siren_number'
] + [u'res@' + name for name in ls_export_name]
return entete_csv_resultat
def insert_cctx_tags_and_save(curr_filename, input_decision_path,
output_decision_path, dict_feature2export_all,
list_keys_to_export, param_add_tag_cctx_file):
"""
Insertion des tags cctx dans le fichier json de jurisprudence et sauvegarde du fichier modifié
dans le dossier output_decision_path
"""
logger.debug(autolog_msg(u"Received a call to function"))
#formation des noms des fichiers d'input et d'output
input_jurisprud_file = "{}{}{}".format(input_decision_path, curr_filename,
'.json')
output_jurisprud_file = "{}{}{}".format(output_decision_path,
curr_filename, '.json')
#lecture du fichier json de jurisprudence
curr_decision = DecisionJurisprudence(input_jurisprud_file)
#modifie le nom des clés pour correspondre aux noms des clés d'export
for import_name, export_name in param_add_tag_cctx_file[
u'list_keys_import_export']:
dict_feature2export_all[tools.convert2unicode(
export_name)] = dict_feature2export_all.pop(import_name)
#dict of lists to list of dicts
list2export = add_payload_tag_for_each_field([
dict(zip(dict_feature2export_all, t))
for t in zip(*dict_feature2export_all.values())
])
#insertion des tags
tagname = u"CCTX_entreprises"
curr_decision.insert_tag_cctx_entreprise(tagname, list2export)
#sauvegarde
curr_decision.export_json_content2jsonfile(output_jurisprud_file)
return None
def update_csv_recap(curr_filename, dict_feature2export_all, df_siren_file,
df_ws_file, entete_csv_ws, entete_csv_resultat,
output_csv_recap, param_add_tag_cctx_file):
"""
Add the new lines corresponding to the new PM demandeur inserted in the json file of jurisprudence
in the csv file output_csv_recap
"""
logger.debug(autolog_msg(u"Received a call to function"))
#20180320: Ajout des paramètres d'input/output en arguments de ligne de commande
#ls_export_name = [u"demandeur_name"]+[tools.convert2unicode(export_name) for import_name,export_name in param_add_tag_cctx_file[u'list_keys_import_export']]
ls_export_name = [
u"company_name_from_jurisprud_file",
u'company_name_related_to_extracted_siren_number'
] + [
tools.convert2unicode(export_name) for import_name, export_name in
param_add_tag_cctx_file[u'list_keys_import_export']
]
pd_feature2export_all = pd.DataFrame(
list(
tools.dict_to_listOflist_ordered(dict_feature2export_all,
ls_export_name)))
if entete_csv_ws is None: #pas de web scraping
df_recap = pd.concat([df_siren_file, pd_feature2export_all],
axis=1,
ignore_index=True)
df_recap.insert(0, column=u"FILENAME", value=curr_filename)
df_recap.to_csv(output_csv_recap,
sep=';',
decimal=',',
header=False,
index=False,
mode="a",
encoding='UTF-8')
else:
if df_ws_file is None: #fichier de web scraping non présent
df_ws_file = pd.DataFrame(index=range(df_siren_file.shape[0]),
columns=entete_csv_ws)
df_merge_file = pd.concat([df_siren_file, df_ws_file],
axis=1,
ignore_index=True)
else: #fichier de web scraping présent
df_merge_file = df_siren_file.merge(df_ws_file,
how=u'left',
on=u"NUMERO_ENTREPRISE")
#rajout de la colonne NUMERO entreprise pour le web_scraping
df_merge_file.insert(df_siren_file.shape[1],
column=u"NUMERO_ENTREPRISE" + u"_y",
value=df_merge_file[u"NUMERO_ENTREPRISE"])
df_recap = pd.concat([df_merge_file, pd_feature2export_all],
axis=1,
ignore_index=True)
df_recap.insert(0, column=u"FILENAME", value=curr_filename)
df_recap.to_csv(output_csv_recap,
sep=';',
decimal=',',
header=False,
index=False,
mode="a",
encoding='UTF-8')
def mapping_num_rue(df_mapping, num_rue):
"""
Cette fonction ajoute une colonne indiquant si le numero de voie est identique.
"""
logger.debug(autolog_msg(u"Received a call to function"))
if num_rue:
num_rue = tools.convert2unicode(num_rue)
df_mapping[u"match_exact_NUMVOIE"] = df_mapping[u"NUMVOIE_pretty"] == num_rue
else:
df_mapping[u"match_exact_NUMVOIE"] = False
return df_mapping
def mapping_ville(df_mapping, ville, tol_dist_lev=0):
"""
Ajout de la colonne: Levenstein_dist_ville
"""
logger.debug(autolog_msg(u"Received a call to function"))
if ville:
ville = tools.convert2unicode(ville)
df_mapping[u"Levenstein_dist_ville"] = df_mapping[
u"LIBCOM_pretty"].apply(lambda libcom: Levenshtein.distance(
libcom, ville) if libcom is not None else 1000)
else:
df_mapping[u"Levenstein_dist_ville"] = 1000
return df_mapping
def mapping_adresse_complete(df_mapping, adresse_complete, tol_dist_lev=4):
"""
Ajout de la colonne: Levenstein_dist_ADRESSE_COMPLETE
"""
logger.debug(autolog_msg(u"Received a call to function"))
if adresse_complete:
adresse_complete = tools.convert2unicode(adresse_complete)
df_mapping[u"Levenstein_dist_ADRESSE_COMPLETE"] = df_mapping[
u"ADRESSE_COMPLETE"].apply(lambda row: Levenshtein.distance(
row, adresse_complete) if row is not None else 1000)
else:
df_mapping[u"Levenstein_dist_ADRESSE_COMPLETE"] = 1000
return df_mapping
def compute_demandeurs_adresse_complete(self):
"""
Extrait le numero de la rue de chaque demandeur PM et remplit list_demandeur_features
"""
logger.debug(autolog_msg(u"Received a call to function"))
for i in range(self.nb_demandeur_PM):
demandeur_PM = self.list_demandeurs_PM[i]
adresse_complete = check_keys_existence(
demandeur_PM, [u"PM", 0, u"Adresse", 0, u"payload"])
if adresse_complete:
self.list_demandeur_features[i][
u"adresse_complete"] = tools.normalize_string(
tools.convert2unicode(adresse_complete))
def mapping_ville(df_mapping, ville, tol_dist_lev = 0):
"""
Cette fonction fait un filtre sur la ville
Elle renvoie le data frame filtré:
- si match exacte alors seuls les matchs excacts sont renvoyés
- sinon toutes les lignes ayant une distance de Levenshtein inférieur au minimimum
+ tol_dist_lev sont renvoyées.
"""
logger.debug(autolog_msg(u"Received a call to function"))
if ville:
ville = tools.convert2unicode(ville)
df_mapping[u"Levenstein_dist_ville"] = df_mapping[u"LIBCOM_pretty"].apply(lambda libcom: Levenshtein.distance(libcom, ville))
min_dist = np.min(df_mapping[u"Levenstein_dist_ville"])
if min_dist == 0:
df_mapping = df_mapping.loc[df_mapping[u"Levenstein_dist_ville"] == min_dist]
else:
df_mapping = df_mapping.loc[df_mapping[u"Levenstein_dist_ville"] <= min_dist+tol_dist_lev]
else:
df_mapping[u"Levenstein_dist_ville"] = 1000
return df_mapping
def mapping_adresse_complete(df_mapping, adresse_complete, tol_dist_lev = 4):
"""
Cette fonction fait un filtre sur la ville
Elle renvoie le data frame filtré:
- si match exacte alors seuls les matchs excacts sont renvoyés
- sinon toutes les lignes ayant une distance de Levenshtein inférieur au minimimum
+ tol_dist_lev sont renvoyées.
"""
logger.debug(autolog_msg(u"Received a call to function"))
if adresse_complete:
adresse_complete = tools.convert2unicode(adresse_complete)
df_mapping[u"Levenstein_dist_ADRESSE_COMPLETE"] = df_mapping[u"ADRESSE_COMPLETE"].apply(lambda row: Levenshtein.distance(row, adresse_complete))
min_dist = np.min(df_mapping[u"Levenstein_dist_ADRESSE_COMPLETE"])
if min_dist == 0:
df_mapping = df_mapping.loc[df_mapping[u"Levenstein_dist_ADRESSE_COMPLETE"] == min_dist]
else:
df_mapping = df_mapping.loc[df_mapping[u"Levenstein_dist_ADRESSE_COMPLETE"] <= min_dist+tol_dist_lev]
else:
df_mapping[u"Levenstein_dist_ADRESSE_COMPLETE"] = 1000
return df_mapping