|
|
| Ligne 31 : |
Ligne 31 : |
| == Code du bot== | | == Code du bot== |
| Le code du bot est disponible à l'adresse [https://github.com/deschena/shs-digital-humanities/blob/master/w4/pyBot.py] | | Le code du bot est disponible à l'adresse [https://github.com/deschena/shs-digital-humanities/blob/master/w4/pyBot.py] |
| ```Python
| |
|
| |
| from pywikiapi import Site
| |
| from datetime import *
| |
| import re
| |
| import pandas as pd
| |
| from urllib.parse import quote
| |
|
| |
| # --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
| |
| __ROW_PATTERN = "* [[{}]] / [[{}]], {}. Mention de {} avec la catégorie {}. [{}]"
| |
| __UNK_DATE = "''(date inconnue)''"
| |
| doc2start = {
| |
| "bpt6k63243601": 123,
| |
| "bpt6k62931221": 151,
| |
| "bpt6k6286466w": 189,
| |
| "bpt6k6393838j": 219,
| |
| "bpt6k6331310g": 216,
| |
| "bpt6k6292987t": 353,
| |
| "bpt6k62906378": 288,
| |
| "bpt6k6391515w": 319,
| |
| "bpt6k6315927h": 349,
| |
| "bpt6k6319106t": 324,
| |
| "bpt6k6315985z": 82,
| |
| "bpt6k63959929": 82,
| |
| "bpt6k63197984": 56,
| |
| "bpt6k6389871r": 77,
| |
| "bpt6k6319811j": 79,
| |
| "bpt6k6282019m": 72,
| |
| "bpt6k6314752k": 190,
| |
| "bpt6k6305463c": 113,
| |
| "bpt6k6318531z": 108,
| |
| "bpt6k6324389h": 72,
| |
| "bpt6k63243920": 80,
| |
| "bpt6k6309075f": 96,
| |
| "bpt6k6333200c": 132,
| |
| "bpt6k63243905": 134,
| |
| "bpt6k6333170p": 137,
| |
| "bpt6k96727875": 135,
| |
| "bpt6k9764746t": 99,
| |
| "bpt6k97645375": 123,
| |
| "bpt6k9672117f": 125,
| |
| "bpt6k9763554c": 123,
| |
| "bpt6k9763553z": 105,
| |
| "bpt6k9677392n": 110,
| |
| "bpt6k9692809v": 113,
| |
| "bpt6k9762929c": 129,
| |
| "bpt6k9672776c": 119,
| |
| "bpt6k9764647w": 121,
| |
| "bpt6k9669143t": 145,
| |
| "bpt6k9677737t": 139,
| |
| "bpt6k9668037f": 167,
| |
| "bpt6k96839542": 171,
| |
| "bpt6k96762564": 185,
| |
| "bpt6k9685861g": 189,
| |
| "bpt6k9763471j": 153,
| |
| "bpt6k9762899p": 157,
| |
| "bpt6k97630871": 11,
| |
| "bpt6k9684454n": 235,
| |
| "bpt6k9732740w": 239,
| |
| "bpt6k9684013b": 189,
| |
| "bpt6k9692626p": 305,
| |
| "bpt6k9685098r": 281,
| |
| "bpt6k9764402m": 329,
| |
| "bpt6k97631451": 322,
| |
| "bpt6k9776121t": 49,
| |
| "bpt6k9775724t": 33,
| |
| "bpt6k97774838": 327,
| |
| "bpt6k9780089g": 339}
| |
| # --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
| |
| def entry2url(row):
| |
| """
| |
| Takes a row of an Annuaire csv and
| |
| transforms it to the corresponding Gallica url
| |
| """
| |
| url = "https://gallica.bnf.fr/ark:/12148/"
| |
|
| |
| directory = row['directory']
| |
| page = row['page'] - doc2start[directory]
| |
| url += f"{row['directory']}/f{row['page']-doc2start[row['directory']]}"
| |
|
| |
| r_strings = []
| |
| if 'name' in row and pd.notna(row['name']):
| |
| r_strings.append(quote(row['name'].replace('.', ' ')))
| |
| if 'job' in row and pd.notna(row['job']):
| |
| r_strings.append(quote(row['job'].replace('.', ' ')))
| |
| if 'street' in row and pd.notna(row['street']):
| |
| r_strings.append(quote(row['street'].replace('.', ' ')))
| |
| if 'number' in row and pd.notna(row['number']):
| |
| r_strings.append(quote(row['number'].replace('.', ' ')))
| |
|
| |
| if len(r_strings) > 0:
| |
| url += f".item.r={'%20'.join(r_strings)}.zoom"
| |
|
| |
| return url
| |
|
| |
| # --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
| |
| def format_entry(entry):
| |
| """Format an entry for wikipast
| |
|
| |
| Arguments:
| |
| entry {pandas.core.frame.DataFrame} -- pandas data row
| |
| section{int} -- section to which append entry
| |
| """
| |
| # Extracting valid fields
| |
| e = pd.notna(entry)
| |
|
| |
| # Since we don't have a lot of fields, if any of them is missing, there is no reason to keep it.
| |
| if not e["year"] or not e["name"] or not e["number_clean"] or not e["street_only"] or not e["job"]:
| |
| return None
| |
|
| |
| year = entry["year"]
| |
| name = entry["name"]
| |
| street_number = entry["number_clean"]
| |
| street = entry["street_only"]
| |
| job = entry["job"]
| |
| url = entry2url(entry)
| |
| __ROW_PATTERN = "* [[{}]] / [[{}]], {}. Mention de {} avec la catégorie {}. [{}]"
| |
| res = __ROW_PATTERN.format(f"{year}.01.01", "Paris", f"{street}, {street_number}".strip(), name, job, url)
| |
| return res
| |
| # --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
| |
|
| |
| class Bot:
| |
| # constructor method
| |
| def __init__(self):
| |
| user = 'Raphael B.@G4_6000'
| |
| password = 'fnf9033tvilqvrbmejjfpavlcn7c5isp'
| |
| self.site = Site('http://wikipast.epfl.ch/wikipast/api.php') # Définition de l'adresse de l'API
| |
| self.site.no_ssl = True # Désactivation du https, car pas activé sur wikipast
| |
| self.site.login(user, password) # Login du bot
| |
| print("Connected to wikipast API.")
| |
|
| |
| # ----------------------------------------
| |
| # ------------ Page Extractor ------------
| |
| # ----------------------------------------
| |
|
| |
| def find_pages_containing(self, title):
| |
| """Finds all the pages with the given title
| |
|
| |
| Arguments:
| |
| title {string} -- title
| |
|
| |
| Returns:
| |
| list[Page] -- pages that start with `title`
| |
| """
| |
| results = []
| |
| for res in self.site.query(list='allpages', apprefix=title):
| |
| results.append(res)
| |
| return results
| |
|
| |
| # --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
| |
| def get_page_names_containing_exactly(self, word):
| |
| """Gets the page names that contain exactly the given word
| |
|
| |
| Arguments:
| |
| word {string} -- word the titles must contain
| |
|
| |
| Returns:
| |
| list -- list of titles
| |
| """
| |
| results = self.find_pages_containing(word)
| |
| pages_names = []
| |
| for res in results[0]['allpages']: # aller dans le dictionnaire nesté
| |
| pages_names.append(res['title'])
| |
| return pages_names
| |
|
| |
| # --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
| |
| def get_page_names_containing(self, word):
| |
| """Gets the page names that contain the given word
| |
|
| |
| Arguments:
| |
| word {string} -- word the titles must contain
| |
|
| |
| Returns:
| |
| list -- list of titles
| |
| """
| |
| res = self.find_pages_containing(word)
| |
| pages_names = []
| |
| for i in range(len(res)):
| |
| for j in range(len(res[i]['allpages'])):
| |
| pages_names.append(res[i]['allpages'][j]['title'])
| |
| return pages_names
| |
|
| |
| # --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
| |
| def get_info_of_page_name_containing(self, word):
| |
| pages_names = self.get_page_names_containing(word)
| |
| results_pages = []
| |
| for res in self.site.query_pages(titles=pages_names, prop=['categories', 'links', 'extlinks']):
| |
| results_pages.append(res)
| |
| return results_pages
| |
|
| |
| # --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
| |
| def get_wiki_text(self, page, section=None):
| |
| """Gets the raw text of the whole page or the given section
| |
|
| |
| Arguments:
| |
| page {string} -- title of the page
| |
|
| |
| Keyword Arguments:
| |
| section {int} -- index of the section (default: {None})
| |
|
| |
| Returns:
| |
| string -- text of the section/page
| |
| """
| |
| result = self.site('parse', page=page, prop=['wikitext'], section=section)
| |
| return result['parse']['wikitext']
| |
|
| |
| # --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
| |
| def get_sections(self, page):
| |
| """Gets all the sections in a page
| |
|
| |
| Arguments:
| |
| page {string} -- title of the page
| |
|
| |
| Returns:
| |
| list -- list of dictionaries, each dictionary is the metadata for the section
| |
| """
| |
| result = self.site('parse', page=page, prop=['sections'])
| |
| return result['parse']['sections']
| |
|
| |
| # --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
| |
| def show_page(self, title):
| |
| """Prints a page
| |
|
| |
| Arguments:
| |
| title {string} -- title of the page
| |
| """
| |
| print(self.get_wiki_text(title, section=None))
| |
|
| |
| # --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
| |
| def get_bio_entries(self, name):
| |
| """Gets all the entries of the biography
| |
|
| |
| Arguments:
| |
| name {string} -- title of the page
| |
|
| |
| Returns:
| |
| list -- list of string, each string is a formatted entry
| |
| """
| |
| sections = self.get_sections(name)
| |
| section_biographie_id = self.get_bio_id('title')
| |
|
| |
| if section_biographie_id is not None:
| |
| wikitext = self.get_wiki_text(name, section=section_biographie_id)
| |
| return [entry for entry in wikitext.split("\n") if entry.startswith('*')]
| |
|
| |
| # --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
| |
| def get_entries(self, title):
| |
| """Gets all the entry of the given pages
| |
|
| |
| Arguments:
| |
| title {string} -- title of the page
| |
|
| |
| Returns:
| |
| list, list -- first element of tuple is dated entries, second is other entries
| |
| """
| |
| all_text = list()
| |
| date_regex = r'^\* ?\[?\[?(\d{4}\.\d{1,2}\.\d{1,2})\]?\]?'
| |
| wikitext = self.get_wiki_text(title)
| |
| bio = list()
| |
| other = list()
| |
|
| |
| for entry in wikitext.split("\n"):
| |
| if entry != '': # empty line, not an entry
| |
| if re.match(date_regex, entry):
| |
| bio.append(entry)
| |
| else:
| |
| other.append(entry)
| |
|
| |
| return list(set(bio)), list(set(other)) # use set to eliminate duplicates
| |
|
| |
| # --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
| |
| def get_bio_id(self, title):
| |
| """Gets the index of the biography section
| |
|
| |
| Arguments:
| |
| title {string} -- title of the page
| |
|
| |
| Returns:
| |
| int -- index of the biography in the page
| |
| """
| |
| sections = self.get_sections(title)
| |
| id = None
| |
| for section in sections:
| |
| if section['line'] == 'Biographie':
| |
| id = section['index']
| |
| break
| |
| return id
| |
|
| |
| # ----------------------------------------
| |
| # ------------- Entry parser -------------
| |
| # ----------------------------------------
| |
|
| |
| def get_keywords(self, entry):
| |
| return re.findall("\[\[([^\[\]]*)\]\]",entry)
| |
|
| |
| # --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
| |
| def get_all_dates(self, entry):
| |
| return re.findall("\[?\[?(\d{4}.\d{1,2}.\d{1,2})\]?\]?",entry)
| |
|
| |
| # --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
| |
| def get_all_years(self, entry):
| |
| dates = self.get_dates(entry)
| |
| annees = [re.findall("\d{4}",date) for date in dates]
| |
| return flatten_list(annees)
| |
|
| |
| # --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
| |
| def get_entry_date(self, entry):
| |
| regex = r'^\* ?\[?\[?(\d{4})\.(\d{1,2})\.(\d{1,2})\]?\]?'
| |
| res = re.match(regex, entry)
| |
| year = int(res.group(1))
| |
| month = int(res.group(2))
| |
| day = int(res.group(3))
| |
| return date(year, month, day)
| |
|
| |
| # --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
| |
| def sort_by_date(self, entries):
| |
| return sorted(entries, key=lambda entry: self.get_entry_date(entry))
| |
|
| |
| # --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
| |
| def flatten_list(self, l):
| |
| return [item for sublist in l for item in sublist]
| |
|
| |
| # ----------------------------------------
| |
| # ------------- Page creator -------------
| |
| # ----------------------------------------
| |
|
| |
| def create_page_with_bio(self, title:str, entries:list):
| |
| """Creates a page if it does not exist, or modifies it if it does not.
| |
| The title must be exact.
| |
|
| |
| Arguments:
| |
| title {string} -- title of the page
| |
| entries {list} -- list of strings, each string is an entry of type `* [] ...`
| |
| """
| |
| if self.page_exists(title):
| |
| self.modify_page(title, entries)
| |
| else:
| |
| self.create_biography(title,entries)
| |
|
| |
| # --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
| |
| def modify_page(self, title: str, entries: list):
| |
| """Modifies the page to incorporate the given entries
| |
|
| |
| Arguments:
| |
| title {string} -- title of the page
| |
| entries {list} -- list of strings, each string is an entry of type `* [] ...`
| |
| """
| |
| bio, others = self.get_entries(title)
| |
| bio_id = self.get_bio_id(title)
| |
|
| |
| if bio_id != None:
| |
| self.site('edit', title=title,
| |
| section=bio_id,
| |
| text=self.entries_to_text(['== Biographie =='] + self.sort_by_date(self.clean_entries(bio + entries))),
| |
| token=self.site.token())
| |
|
| |
| else:
| |
| self.site('edit', title=title,
| |
| text=self.entries_to_text(others),
| |
| token=self.site.token())
| |
|
| |
| self.create_biography(title,self.clean_entries(bio + entries))
| |
|
| |
| # --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
| |
| def create_biography(self, title, entries):
| |
| """Creates a biography section for the article with the given title
| |
|
| |
| Arguments:
| |
| title {string} -- title of the page
| |
| entries {list} -- list of formatted entries
| |
| """
| |
| self.site('edit', title=title,
| |
| section='new',
| |
| sectiontitle='Biographie',
| |
| text=self.entries_to_text(self.sort_by_date(entries)),
| |
| token=self.site.token())
| |
|
| |
| # --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
| |
| def page_exists(self, title):
| |
| """Checks if a page with the exact given title already exists
| |
|
| |
| Arguments:
| |
| title {string} -- title of the page
| |
|
| |
| Returns:
| |
| boolean -- true if it exists, false otherwise
| |
| """
| |
| names = self.get_page_names_containing_exactly(title)
| |
|
| |
| for name in names:
| |
| if name == title:
| |
| return True
| |
|
| |
| return False
| |
|
| |
| # --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
| |
| def entries_to_text(self, entries):
| |
| return "\n\n".join(entries)
| |
| # --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
| |
| def clean_entries(self, entries):
| |
| entries = list(set(entries))
| |
| return entries
| |
|
| |
| ```
| |
Résumé des fonctionnalités
Le bot prend comme entrée des données dans le format csv. Chaque ligne du fichier d'entrée contient le nom, le métier et l'adresse d'une personne, ainsi que l'année à laquelle l'information a été collectée. D'autres méta-données de moindre importance sont aussi présentes. Le nom des colonnes du fichier sont les suivants:
directory,page,row,year,name,job,street,number,street_clean,street_only
L'idée principale du fonctionnement du bot est d'identifier toutes les lignes correspondant à une personne distincte, extraire celles-ci et créer ou modifier une page wikipast à partir de ces données. Une fois les données extraite, chaque ligne du fichier d'entrée devrait en théorie correspondre à une entrée dans la section Biographie de la page correspondante. Les données fournies s'étalant sur un intervalle de 10 ans, le bot devrait donc avoir la capacité de générer jusqu'à 10 entrées par personne. Pour qu'un tel regroupement soit possible, il faut cependant avoir la certitude que les entrées regroupées dans un même article correspondent à la même personne. Plusieurs astuces permettent d'arriver à un résultat relativement fiable.
Regroupement des entrées d'une même personne
La stratégie utilisée pour regrouper les lignes du fichier d'entrée faisant référence à la même personne est une des principales difficultés. La technique utilisée dans la version finale du bot est simplement de regrouper les lignes dont le nom, l'adresse et le métier sont identiques. Il aurait été également possible d'utiliser un critère moins conservateur et de regrouper uniquement par nom et adresse. Il semble en effet peu probable que deux personnes avec le même nom et la même adresse soient en réalité une personne différente.
Cependant, il a été décidé de garder un critère plus strict pour plusieurs raisons. Premièrement, il est difficile de distinguer deux personnes d'une même famille sans utiliser le critère du métier. Comme les membres d'une même famille partagent le même nom de famille et souvent la même adresse, le critère du métier est dans beaucoup de cas le seul critère permettant de départager ces personnes. Deuxièmement, il paraît probable que deux personnes avec le même nom de famille habitent dans le même immeuble, même si ces personnes n'ont pas de lien de parenté. Si des données complètes sur les prénoms étaient disponibles dans tous les cas, il serait probablement possible d'exploiter cette information pour obtenir plus de précision.
L'exemple suivant, tiré des données de l'annuaire, illustre la problématique du critère du nom et de l'adresse.
* 1874.01.01 / Paris, Rivoli, 68. Mention de Mazzucchi avec la catégorie diamants pour vitriers.
* 1874.01.01 / Paris, Rivoli, 68. Mention de Mazzucchi avec la catégorie marrons en gros.
Les deux lignes datant de la même années, on peut conclure avec certitude que ces deux lignes correspondent à des personnes différentes, même si l'adresse et le nom de famille sont identiques. On peut faire l'hypothèse qu'un lien de parenté unit ces deux individus.
Désambiguïsation
Lors de l'écriture de notre bot, nous avions fais en sorte que celui-ci soit capable de "merge" les informations contenues dans notre partie du bottin avec celles des autres groupes, afin de ne pas créer de pages supplémentaires pour la même entité. Lorsque nous faisions de tels tests avec nos propres pages, cela fonctionnait très bien.
Le problème qui s'est posé à nous vient du fait que le format choisi par chaque groupe est différent. Nous avons donc essayé d'extraire la sémantique des entrées, notamment en considérant les hypermots. Cette méthode s'est malheureusement soldée par un échec et nous n'avons pas réussi à merge proprement les pages existantes avec les notre, sauf cas très précis. Nous avons finalement pris le parti de créer des pages au titre le plus simple possible. Par exemple, pour un nom peu commun comme Marion-Carème, pour laquelle il n'existe pas de pages, nous avons créé une page ne contenant que son nom. En revanche, pour une entité telle que Lemestre, il était nécessaire d'ajouter le métier de la personne (car une page Lemestre existait déjà). Nous avons donc procédé de la sorte, en spécifiant le titre à chaque fois qu'une page existait déjà. Dans le cas d'une page dont le titre contiendrait toutes les informations (nom, job et adresse), et serait le même que le notre, nous ne créons pas de nouvelle page, mais "mergeons" le nouveau contenu avec celui existant.
Nous avons aussi pris en compte le fait que la page pourrait contenir des informations que nous ne considérons pas comme des entrées du bottin (ne commencent pas par la paire date/lieu). Dans ce cas, nous séparons la page en deux sections, une section biographie, au format habituel, suivi d'une seconde contenant le reste des informations n'ayant pas le format prévu
Analyse critique et améliorations envisagées
Le bot est malheureusement peu efficace pour combattre les erreurs d'OCR ou les variations dans le format des données. Une stratégie initialement envisagée était de constituer des ensembles de métiers voisins afin d'être capable de regrouper les entrées selon des critères moins stricts. Pour créer ces ensembles, une approche possible aurait été d'identifier les entrées pouvant être regroupées avec certitude en utilisant uniquement les autres critères (nom, adresse). Pour chacune de ces personnes, on obtiendrait un ensemble des différents métiers listés sur les entrées successives. Cet ensemble pourrait ainsi être réutilisé pour identifier d'autres personnes avec ce critère. Ainsi, si une personne passe de notaire à notaire honoraire, on peut en déduire que d'autres personnes pourraient connaître une évolution similaire. Cependant, comme expliqué plus haut, il est difficile d'identifier les entrées qui se rapportent à une même personne sans utiliser le critère du métier. Pour cette raison, il est difficile d'appliquer cette stratégie en pratique.
Une autre solution envisagée était de faire recours à une source externe (par exemple Wikipédia) pour identifier les métiers similaires. Cependant, le format du métier dans les données d'entrée n'est pas toujours très cohérent. Par exemple, l'activité "vins" est souvent mentionnée dans le fichier d'entrée. Comme il ne s'agit pas d'un métier à proprement parler mais plutôt d'un secteur d'activité, il devient vite difficile d'exploiter cette information.
Code du bot
Le code du bot est disponible à l'adresse [1]