def frbnfBib2arkAut(NumNot, frbnf, nom, prenom, date_debut):
"""Recherche de l'identifiant d'auteur à partir d'une recherche N° BIB + nom d'auteur :
on cherche le n° BIB comme NNB, comme FRBNF ou comme ancien numéro"""
listeArk = []
systemid_full = frbnf.lower().replace("f", "").replace("r", "").replace(
"b", "").replace("n", "")
nnb_possible = systemid_full[0:8]
url = funcs.url_requete_sru('bib.recordid all "' + nnb_possible + '"')
(test, page) = funcs.testURLetreeParse(url)
if (test == True):
for record in page.xpath("//srw:recordData", namespaces=main.ns):
listeArk.extend(
extractARKautfromBIB(record, nom, prenom, date_debut))
if (listeArk == []):
url = funcs.url_requete_sru('bib.otherid all "' + frbnf +
'" and bib.author all "' + nom + '"')
(test, page) = funcs.testURLetreeParse(url)
if (test == True):
for record in page.xpath("//srw:recordData", namespaces=main.ns):
listeArk.extend(
extractARKautfromBIB(record, nom, prenom, date_debut))
if (listeArk == []):
systemid1 = systemid_full[0:9]
systemid2 = systemid_full[0:8]
url = funcs.url_requete_sru('bib.otherid any "' + systemid1 + " " +
systemid2 + '" and bib.author all "' +
nom + '"')
(test, page) = funcs.testURLetreeParse(url)
if (test == True):
for record in page.xpath("//srw:recordData", namespaces=main.ns):
listeArk.extend(
extractARKautfromBIB(record, nom, prenom, date_debut))
listeArk = ",".join(set(listeArk))
return listeArk
def extract1record(row, j, form, headers, parametres):
identifier = funcs.Id4record(row, parametres)
if (len(identifier.aligned_id.clean) > 1
and identifier.aligned_id.clean not in parametres["listeARK_BIB"]):
print(str(j) + ". " + identifier.aligned_id.clean)
parametres["listeARK_BIB"].append(identifier.aligned_id.clean)
url_record = ark2url(identifier, parametres)
if url_record:
(test, page) = funcs.testURLetreeParse(url_record)
if (test):
nbResults = page2nbresults(page, identifier)
# Si on part d'un ARK
if (nbResults == "1" and identifier.aligned_id.type == "ark"):
for XMLrec in page.xpath(
"//srw:record/srw:recordData/mxc:record",
namespaces=main.ns):
record2file(identifier, XMLrec, parametres["bib_file"],
parametres["format_file"], parametres)
if (parametres["AUTliees"] > 0):
bib2aut(identifier, XMLrec, parametres)
# Si on part d'un PPN
elif (nbResults == "1"
and identifier.aligned_id.type == "ppn"):
for XMLrec in page.xpath("//record"):
record2file(identifier, XMLrec, parametres["bib_file"],
parametres["format_file"], parametres)
if (parametres["AUTliees"] > 0):
bib2aut(identifier, XMLrec, parametres)
elif (identifier.aligned_id.type == "ppn"
and parametres["type_records"] == "bib"):
ppn_updated = update_bib_ppn(identifier.aligned_id.clean)
if ppn_updated is not None:
print("Nouveau PPN :", ppn_updated)
errors_list.append([
f"Fusion de notices Sudoc\t{identifier.aligned_id.init} disparu. Nouveau PPN : {ppn_updated}",
""
])
identifier = funcs.Id4record([row[0], f"PPN{ppn_updated}"],
parametres)
parametres["listeARK_BIB"].append(
identifier.aligned_id.clean)
url_record = ark2url(identifier, parametres)
if url_record:
(test, page) = funcs.testURLetreeParse(url_record)
if (test):
nbResults = page2nbresults(page, identifier)
if (nbResults == "1"):
for XMLrec in page.xpath("//record"):
record2file(identifier, XMLrec,
parametres["bib_file"],
parametres["format_file"],
parametres)
if (parametres["AUTliees"] > 0):
bib2aut(identifier, XMLrec, parametres)
def extract1record(row, j, form, headers, parametres):
ark = row[0]
ark = ark.replace("http://www.sudoc.fr/",
"ppn").replace("https://www.sudoc.fr/", "ppn")
if ("ark:/12148" in ark):
ark = ark[ark.find("ark:/12148"):]
if (len(ark) > 1 and ark not in listeARK_BIB):
print(str(j) + ". " + ark)
listeARK_BIB.append(ark)
(test, page) = funcs.testURLetreeParse(ark2url(ark, parametres))
if (test):
nbResults = page2nbresults(page, ark)
if (nbResults == "1" and "ark" in ark):
for XMLrec in page.xpath(
"//srw:record/srw:recordData/mxc:record",
namespaces=main.ns):
record2file(parametres["bib_file"], XMLrec,
parametres["format_file"])
if (parametres["AUTliees"] > 0):
bib2aut(XMLrec, ark, parametres)
elif (nbResults == "1" and "ppn" in ark.lower()):
for XMLrec in page.xpath("//record"):
record2file(parametres["bib_file"], XMLrec,
parametres["format_file"])
if (parametres["AUTliees"] > 0):
bib2aut(XMLrec, ark, parametres)
def comparerAutBnf(NumNot, ark_current, nna, nom, origineComparaison):
ark = ""
url = funcs.url_requete_sru('aut.persistentid all "' + ark_current + '"')
(test, recordBNF) = funcs.testURLetreeParse(url)
if (test == True):
ark = compareAccessPoint(NumNot, ark_current, nna, nom, recordBNF)
return ark
def bib2aut(XMLrecord, ark, parametres):
"""Si une des option "Récupérer les notices d'autorité liées" est cochée
récupération des identifiants de ces AUT pour les récupérer"""
source = "bnf"
if ("ppn" in ark.lower()):
source = "sudoc"
liste_nna = []
listefields = []
format_marc = parametres["format_BIB"].split("x")[0]
if (parametres["AUTlieesAUT"] == 1):
listefields.extend(listefieldsLiensAUT[format_marc])
if (parametres["AUTlieesSUB"] == 1):
listefields.extend(listefieldsLiensSUB[format_marc])
if (parametres["AUTlieesWORK"] == 1):
listefields.extend(listefieldsLiensWORK[format_marc])
for field in listefields:
liste_nna.extend(extract_nna_from_bib_record(XMLrecord, field, source))
for nna in liste_nna:
if (source == "sudoc"):
source = "idref"
url = nn2url(nna, "aut", parametres, source)
(test, record) = funcs.testURLetreeParse(url)
if (test and source == "bnf"
and record.find("//srw:recordData/mxc:record",
namespaces=main.ns) is not None):
XMLrec = record.xpath(".//srw:recordData/mxc:record",
namespaces=main.ns)[0]
record2file(parametres["aut_file"], XMLrec,
parametres["format_file"])
elif (test and source == "idref"
and record.find("//record") is not None):
XMLrec = record.xpath(".//record")[0]
record2file(parametres["aut_file"], XMLrec,
parametres["format_file"])
def update_bib_ppn(ppn):
url = f"https://www.sudoc.fr/services/merged/{ppn}"
test, result = funcs.testURLetreeParse(url)
if (test and result.find("//result/ppn") is not None):
new_ppn = result.find("//result/ppn").text
return new_ppn
else:
return None
def autArk2ppn(input_record, ark_nett):
Liste_ppn = []
url = f"https://www.idref.fr/services/ark2idref/http://catalogue.bnf.fr/{ark_nett}"
(test, result) = funcs.testURLetreeParse(url, display=False)
if test:
for ppn in result.xpath("//ppn"):
Liste_ppn.append(ppn.text)
Liste_ppn = ",".join(["PPN" + el for el in Liste_ppn if el])
return Liste_ppn
def isni2ppn(input_record, isni_id, parametres, origine="isni"):
Liste_ppn = []
url = "https://www.idref.fr/services/isni2idref/" + isni_id
(test, page) = funcs.testURLetreeParse(url, display=False)
if test:
for ppn in page.xpath("//ppn"):
Liste_ppn.append(ppn.text)
Liste_ppn = ",".join(["PPN" + el for el in Liste_ppn if el])
if Liste_ppn:
input_record.alignment_method.append(origine)
return Liste_ppn
def nna2ark(nna):
url = funcs.url_requete_sru('aut.recordid any ' + nna +
'and aut.status any "sparse validated"')
ark = ""
(test, record) = funcs.testURLetreeParse(url)
if (test):
if (record.find("//srw:recordIdentifier", namespaces=main.ns)
is not None):
ark = record.find("//srw:recordIdentifier",
namespaces=main.ns).text
return ark
def arkAut2arkAut(NumNot, ark):
"""Actualisation d'un ARK de notice d'autorité"""
url = funcs.url_requete_sru('aut.persistentid all "' + ark + '"')
(test, page) = funcs.testURLetreeParse(url)
nv_ark = ""
if (test == True):
if (page.find("//srw:recordIdentifier", namespaces=main.ns)
is not None):
nv_ark = page.find("//srw:recordIdentifier",
namespaces=main.ns).text
NumNotices2methode[NumNot].append("Actualisation ARK")
return nv_ark
def arkBib2arkAut(NumNot, arkBib, nom, prenom, date_debut):
"""Identifier un ARK de notice d'autorité à partir d'un ARK de notice BIB + contrôle sur le nom"""
url = funcs.url_requete_sru('bib.persistentid all "' + arkBib + '"')
(test, page) = funcs.testURLetreeParse(url)
listeArk = ""
if (test == True):
for record in page.xpath("//srw:recordData/mxc:record",
namespaces=main.ns):
listeArk.extend(
extractARKautfromBIB(record, nom, prenom, date_debut))
NumNotices2methode[NumNot].append(
"ARK notice BIB + contrôle accesspoint")
return listeArk
def isni2ark(NumNot, isni, origine="isni"):
url = funcs.url_requete_sru('aut.isni all "' + isni +
'" and aut.status any "sparse validated"')
(test, page) = funcs.testURLetreeParse(url)
nv_ark = ""
if (test == True):
if (page.find("//srw:recordIdentifier", namespaces=main.ns)
is not None):
nv_ark = page.find("//srw:recordIdentifier",
namespaces=main.ns).text
if (origine == "isni"):
NumNotices2methode[NumNot].append("ISNI")
return nv_ark
def relancerNNA_nomAuteur(NumNot, systemid, nom):
listeArk = []
if (nom != "" and nom is not None):
urlSRU = funcs.url_requete_sru('aut.accesspoint all "' + nom +
'" and aut.otherid all "' + systemid +
'"')
(test, pageSRU) = funcs.testURLetreeParse(urlSRU)
if (test == True):
for record in pageSRU.xpath("//srw:records/srw:record",
namespaces=main.ns):
ark = record.find("srw:recordIdentifier",
namespaces=main.ns).text
NumNotices2methode[NumNot].append("N° sys FRBNF + Nom")
listeArk.append(ark)
listeArk = ",".join(listeArk)
return listeArk
def bib2arkAUT(NumNot, titre, pubDate, nom, prenom, date_debut):
listeArk = []
if (pubDate == ""):
pubDate = "-"
url = funcs.url_requete_sru("".join([
'bib.title all "', titre, '" and bib.author all "', nom, " ", prenom,
'" and bib.publicationdate all "', pubDate, '"'
]))
(test, results) = funcs.testURLetreeParse(url)
if (test):
for record in results.xpath("//srw:recordData/mxc:record",
namespaces=main.ns):
listeArk.extend(
extractARKautfromBIB(record, nom, prenom, date_debut))
listeArk = ",".join(set(listeArk))
return listeArk
def rechercheNNA(NumNot, nna, nom):
ark = ""
if (nna.isdigit() is False):
#pb_frbnf_source.write("\t".join[NumNot,nnb] + "\n")
ark = "Pb FRBNF"
elif (10000000 < int(nna) < 25000000):
url = funcs.url_requete_sru('aut.recordid any "' + nna + '"')
(test, page) = funcs.testURLetreeParse(url)
if (test == True):
for record in page.xpath("//srw:records/srw:record",
namespaces=main.ns):
ark_current = record.find("srw:recordIdentifier",
namespaces=main.ns).text
ark = comparerAutBnf(NumNot, ark_current, nna, nom,
"Numéro de notice")
return ark
def aut2ppn_by_accesspoint(input_record, parametres):
"""
Exemple de requête sur nom, prénom et date de naissance
avec type d'autorité "a" (personne physique)
https://www.idref.fr/Sru/Solr?q=persname_t:%22Hugo%20Victor%201802%22%20AND%20recordtype_z:a&sort=score%20desc&version=2.2&start=0&rows=30&indent=on
"""
# Conversion du code (1 lettre) de type d'entité
# en nom d'index pour la recherche par point d'accès
aut_type_dict = {"a": "persname", "b": "corpname"}
Liste_ppn = []
query = [
'"', input_record.lastname.propre, input_record.firstname.propre, '"'
]
query_date = ""
if (input_record.firstdate.propre
and len(input_record.firstdate.propre) > 3):
query_date = urllib.parse.quote(" AND " +
aut_type_dict[parametres["type_aut"]] +
'_t:"' +
input_record.firstdate.propre + '"')
elif (input_record.lastdate.propre
and len(input_record.lastdate.propre) > 3):
query_date = urllib.parse.quote(" AND " +
aut_type_dict[parametres["type_aut"]] +
'_t:"' + input_record.lastdate.propre +
'"')
url = "".join([
"https://www.idref.fr/Sru/Solr?q=" +
aut_type_dict[parametres["type_aut"]] + "_t:",
urllib.parse.quote(" ".join(query)), query_date,
"%20AND%20recordtype_z:" + parametres["type_aut"] +
"&sort=score%20desc&version=2.2&start=0&rows=1000"
])
(test, results) = funcs.testURLetreeParse(url)
if test:
for record in results.xpath("//doc"):
ppn = record.find("str[@name='ppn_z']").text
ppn = check_idref_record(ppn, input_record,
ppn2idrefrecord(ppn, parametres),
parametres)
if ppn:
Liste_ppn.append(ppn)
Liste_ppn = ",".join(["PPN" + el for el in Liste_ppn])
if (Liste_ppn):
input_record.alignment_method.append("Point d'accès > PPN")
return Liste_ppn
def accesspoint2isniorg(NumNot, nom_nett, prenom_nett, date_debut_nett,
date_fin_nett):
url = "http://isni.oclc.nl/sru/?query=pica.nw%3D%22" + urllib.parse.quote(
" ".join([nom_nett, prenom_nett, date_debut_nett
])) + "%22&operation=searchRetrieve&recordSchema=isni-b"
isnis = []
(test, records) = funcs.testURLetreeParse(url)
if (test == True):
for rec in records.xpath("//srw:records/srw:record",
namespaces=main.nsisni):
isni = rec.find("srw:recordData//isniURI",
namespaces=main.nsisni).text
forenames = []
for forename in rec.xpath("srw:recordData//forename",
namespaces=main.nsisni):
if (unidecode(forename.text).lower() not in forenames):
forenames.append(unidecode(forename.text).lower())
surnames = []
for surname in rec.xpath("srw:recordData//surname",
namespaces=main.nsisni):
if (unidecode(surname.text).lower() not in surnames):
surnames.append(unidecode(surname.text).lower())
dates = []
for date in rec.xpath("srw:recordData//marcDate",
namespaces=main.nsisni):
if (unidecode(date.text).lower() not in dates):
dates.append(unidecode(date.text).lower())
forenames = " ".join(forenames)
surnames = " ".join(surnames)
dates = " ".join(dates)
if (nom_nett in surnames or surnames in nom_nett):
if (prenom_nett in forenames or forenames in prenom_nett):
if (date_debut_nett in dates or dates in date_debut_nett):
isnis.append(isni)
if (isnis != []):
NumNotices2methode[NumNot].append("Point d'accès > ISNI")
i = 0
for isni in isnis:
NumNotices2methode[NumNot][-1]
isni_id = isni.split("/")[-1]
ark = isni2ark(NumNot, isni_id, origine="accesspoint")
if (ark != ""):
isnis[i] = ark
NumNotices2methode[NumNot].append("ISNI > ARK")
i += 1
isnis = ",".join(isnis)
return isnis
def bib2aut(identifier, XMLrecord, parametres, multiprocess):
"""Si une des option "Récupérer les notices d'autorité liées" est cochée
récupération des identifiants de ces AUT pour les récupérer"""
source = "bnf"
if (identifier.aligned_id.type == "ppn"):
source = "sudoc"
liste_nna = []
listefields = []
linked_aut_record = []
format_marc = parametres["format_BIB"].split("x")[0]
linked_aut_records = []
if (parametres["AUTlieesAUT"] == 1):
listefields.extend(listefieldsLiensAUT[format_marc])
if (parametres["AUTlieesSUB"] == 1):
listefields.extend(listefieldsLiensSUB[format_marc])
if (parametres["AUTlieesWORK"] == 1):
listefields.extend(listefieldsLiensWORK[format_marc])
for field in listefields:
liste_nna.extend(
extract_nna_from_bib_record(XMLrecord, field, source, parametres))
for nna in liste_nna:
if (source == "sudoc"):
source = "idref"
url = nn2url(nna, "aut", parametres, source)
(test, record) = funcs.testURLetreeParse(url)
if (test and source == "bnf"
and record.find("//srw:recordData/mxc:record",
namespaces=main.ns) is not None):
XMLrec = record.xpath(".//srw:recordData/mxc:record",
namespaces=main.ns)[0]
linked_identifier = funcs.Id4record([
record.find("//srw:recordIdentifier", namespaces=main.ns).text
])
# record2file(linked_identifier, XMLrec, parametres["aut_file"],
# parametres["format_file"], parametres)
linked_aut_record.append([linked_identifier, XMLrec])
elif (test and source == "idref"
and record.find("leader") is not None):
# record2file(f"PPN{nna}", record, parametres["aut_file"],
# parametres["format_file"], parametres)
linked_aut_record.append([f"PPN{nna}", record])
if multiprocess:
for el in linked_aut_record:
el[1] = etree.tostring(el[1])
return linked_aut_record
def frbnfAut2arkAut(NumNot, frbnf, nom, prenom, date_debut):
ark = ""
frbnf = nettoyageFRBNF(frbnf)
url = funcs.url_requete_sru('aut.otherid all "' + frbnf + '"')
(test, page) = funcs.testURLetreeParse(url)
if (test == True):
nb_resultats = int(
page.find("//srw:numberOfRecords", namespaces=main.ns).text)
if (nb_resultats == 0):
ark = oldfrbnf2ark(NumNot, frbnf, nom)
elif (nb_resultats == 1):
ark = page.find("//srw:recordIdentifier", namespaces=main.ns).text
NumNotices2methode[NumNot].append("FRBNF")
else:
ark = ",".join([
ark.text for ark in page.xpath("//srw:recordIdentifier",
namespaces=main.ns)
])
return ark
def ark2metas(ark, unidec=True):
recordBNF_url = funcs.url_requete_sru('bib.persistentid any "' + ark + '"')
(test, record) = funcs.testURLetreeParse(recordBNF_url)
accesspoint = ""
accesspoint_compl = ""
dates = ""
if (test == True):
if (record.find("//mxc:datafield[@tag='200']/mxc:subfield[@code='a']",
namespaces=main.ns) is not None):
accesspoint = record.find(
"//mxc:datafield[@tag='200']/mxc:subfield[@code='a']",
namespaces=main.ns).text
if (record.find("//mxc:datafield[@tag='210']/mxc:subfield[@code='a']",
namespaces=main.ns) is not None):
accesspoint = record.find(
"//mxc:datafield[@tag='210']/mxc:subfield[@code='a']",
namespaces=main.ns).text
if (record.find("//mxc:datafield[@tag='200']/mxc:subfield[@code='b']",
namespaces=main.ns) is not None):
accesspoint_compl = record.find(
"//mxc:datafield[@tag='200']/mxc:subfield[@code='b']",
namespaces=main.ns).text
if (record.find("//mxc:datafield[@tag='210']/mxc:subfield[@code='b']",
namespaces=main.ns) is not None):
accesspoint_compl = record.find(
"//mxc:datafield[@tag='210']/mxc:subfield[@code='b']",
namespaces=main.ns).text
if (record.find("//mxc:datafield[@tag='200']/mxc:subfield[@code='f']",
namespaces=main.ns) is not None):
dates = record.find(
"//mxc:datafield[@tag='200']/mxc:subfield[@code='f']",
namespaces=main.ns).text
if (record.find("//mxc:datafield[@tag='210']/mxc:subfield[@code='f']",
namespaces=main.ns) is not None):
dates = record.find(
"//mxc:datafield[@tag='210']/mxc:subfield[@code='f']",
namespaces=main.ns).text
metas = [accesspoint, accesspoint_compl, dates]
if (unidec == True):
metas = [unidecode(meta) for meta in metas]
return metas
def ppn2metasAut(ppn, parametres={"type_aut": "a"}):
"""
A partir d'un PPN, génère une ligne de métadonnées
telles qu'attendues par le module d'alignement
pour générer
"""
url = f"https://www.idref.fr/{ppn}.xml"
line = []
#Si le fichier en entrée est composé de notices d'autorité
# PEP (a) ou ORG (b) : on s'attend à avoir 8 éléments
if ("type_aut" not in parametres or parametres["type_aut"] == "a"
or parametres["type_aut"] == "b"):
line = ["", "", "", "", "", "", "", ""]
(test, record) = funcs.testURLetreeParse(url)
if (test):
leader = record.find(".//leader").text
doctype, recordtype, doc_record = marc2tables.record2doc_recordtype(
leader, 2)
line = marc2tables.autrecord2metas(ppn, doc_record, record)
return line
def systemid2ark(NumNot, systemid, tronque, nom):
url = funcs.url_requete_sru('aut.otherid all "' + systemid + '"')
#url = "http://catalogueservice.bnf.fr/SRU?version=1.2&operation=searchRetrieve&query=NumNotice%20any%20%22" + systemid + "%22&recordSchema=InterXMarc_Complet&maximumRecords=1000&startRecord=1"
listeARK = []
(test, page) = funcs.testURLetreeParse(url)
if (test):
for record in page.xpath("//srw:records/srw:record",
namespaces=main.ns):
ark_current = record.find("srw:recordIdentifier",
namespaces=main.ns).text
for zone9XX in record.xpath(
"srw:recordData/mxc:record/mxc:datafield",
namespaces=main.ns):
#print(ark_current)
tag = zone9XX.get("tag")
if (tag[0:1] == "9"):
if (zone9XX.find("mxc:subfield[@code='a']",
namespaces=main.ns) is not None):
if (zone9XX.find("mxc:subfield[@code='a']",
namespaces=main.ns).text is not None):
if (zone9XX.find(
"mxc:subfield[@code='a']",
namespaces=main.ns).text == systemid):
#print(zone9XX.get("tag"))
listeARK.append(
comparerAutBnf(NumNot, ark_current,
systemid, nom,
"Ancien n° notice"))
listeARK = ",".join([ark1 for ark1 in listeARK if ark1 != ''])
#Si pas de réponse, on fait la recherche SystemID + Nom auteur
if (listeARK == ""):
listeARK = relancerNNA_nomAuteur(NumNot, systemid, nom)
listeARK = ",".join([ark1 for ark1 in listeARK.split(",") if ark1 != ''])
#Si à l'issue d'une première requête sur le numéro système dont on a conservé la clé ne donne rien -> on recherche sur le numéro tronqué comme numéro système
if (listeARK == "" and tronque == False):
systemid_tronque = systemid[0:len(systemid) - 1]
systemid2ark(NumNot, systemid_tronque, True, nom)
listeARK = ",".join([ark1 for ark1 in listeARK.split(",") if ark1 != ''])
return listeARK
def idrefAut2arkAut(input_record, base="idref"):
liste_ark = []
url = f"https://www.{base}.fr/{input_record.ppn.propre}.xml"
# print(url)
(test, result) = funcs.testURLetreeParse(url, display=False)
if test:
for f033 in result.xpath("//*[@tag='033']"):
val = funcs.field2subfield(f033, "a")
if ("ark:/12148/" in val):
val = val[val.find("ark:/12148/"):]
liste_ark.append(val)
if (liste_ark):
input_record.alignment_method.append("PPN > ARK")
if (liste_ark == [] and result.find("//*[@tag='035']") is not None and
"frbn" in funcs.record2fieldvalue(result, "035$a").lower()):
aut_record = funcs.XML2record(result, 2).record
#print(aut_record.metadata)
liste_ark.extend(aut2id.frbnfAut2arkAut(aut_record).split(","))
if (liste_ark):
input_record.alignment_method.append("PPN > FBRNF > ARK")
liste_ark = ",".join(liste_ark)
return liste_ark
def accesspoint2arkAut(NumNot, nom_nett, prenom_nett, date_debut, date_fin):
listeArk = []
url = funcs.url_requete_sru('aut.accesspoint adj "' +
" ".join([nom_nett, prenom_nett, date_debut]) +
'"')
testdatefin = False
if (date_debut == "" and date_fin != ""):
url = funcs.url_requete_sru('aut.accesspoint adj "' +
" ".join([nom_nett, prenom_nett]) +
'" and aut.accesspoint all "' + date_fin +
'"')
testdatefin = True
#print(url)
(test, results) = funcs.testURLetreeParse(url)
if (test):
for record in results.xpath("//srw:records/srw:record",
namespaces=main.ns):
ark = record.find("srw:recordIdentifier", namespaces=main.ns).text
if (testdatefin == True):
if (record.find(
"srw:recordData/mxc:record/mxc:datafield[@tag='103']/mxc:subfield[@code='a']",
namespaces=main.ns) is not None):
f103a_datefin = record.find(
"srw:recordData/mxc:record/mxc:datafield[@tag='103']/mxc:subfield[@code='a']",
namespaces=main.ns).text[11:15]
if (date_fin == f103a_datefin):
listeArk.append(ark)
NumNotices2methode[NumNot].append(
"Point d'accès avec date de fin")
elif (date_debut != ""):
listeArk.append(ark)
NumNotices2methode[NumNot].append(
"Point d'accès avec date de début")
else:
listeArk.append(ark)
NumNotices2methode[NumNot].append("Point d'accès")
listeArk = ",".join(listeArk)
return listeArk
