Permalink
Cannot retrieve contributors at this time
Name already in use
A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
EOASkripts/libeoabibitem.py
Go to fileThis commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
894 lines (738 sloc)
35.5 KB
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
# -*- coding: utf-8; mode: python -*- | |
"""A library for the formatting of bibliographical references. | |
The library is mostly superfluous, since the formatting is done with | |
pandoc-citeproc. | |
""" | |
import re | |
import sys | |
from lxml import etree | |
lang_dict = {"in" : {"english" : "In:", "german" : "In:"}, | |
"volume" : {"english" : "Vol.", "german" : "Bd."}, | |
"edited" : {"english" : "Ed. by", "german" : "Hrsg. von"}, | |
"editor" : {"english" : "ed.", "german" : "Hrsg."}, | |
"editors" : {"english" : "eds.", "german" : "Hrsg."}, | |
"and" : {"english" : "and", "german" : "und"}, | |
"phdthesis" : {"english" : "PhD thesis", "german" : "Diss"}, | |
# "visited" : {"english" : "last visited", "german" : "besucht am"}, | |
# "dateformat" : {"english" : "%d/%m/%Y", "german" : "%d.%m.%Y"} | |
"visited" : {"english" : "visited on", "german" : "besucht am"}, | |
"dateformat" : {"english" : "%m/%d/%Y", "german" : "%d.%m.%Y"} | |
} | |
LANGUAGE = "german" | |
punctuation_marks = ['?', '.', ';', '!'] | |
class Bibitem: | |
# TODO: Interne Funktion, um° durch Leerzeichen zu ersetzen | |
# TODO: Eine Lösung finden, für Autoren die nur aus einem Namen bestehen, ie keinen Vornamen haben | |
def __init__(self,xmlEntry): | |
self.xmlEntry = xmlEntry | |
def sanitize(self,strString): | |
strString = re.sub("°", " ", strString) | |
return strString | |
def gettext(self,xmlElement): | |
xmlText = xmlElement.text or "" | |
for xmlChild in xmlElement: | |
xmlText += self.gettext(xmlChild) | |
if xmlChild.tail: | |
xmlText += xmlChild.tail | |
return xmlText | |
def check_text(self, element_or_tail): | |
"""Check for text content of element or tail.""" | |
return_string = "" | |
if element_or_tail is not None: | |
return_string = element_or_tail | |
return(return_string) | |
# def check_text ends here | |
def check_for_subtags(self, xml_element): | |
"""Check the present XML element for subtags""" | |
# xml_element = etree.fromstring(xml_string) | |
xml_element_children = xml_element.getchildren() | |
return_string = self.check_text(xml_element.text) | |
if len(xml_element_children) != 0: | |
for child in xml_element_children: | |
if len(child.getchildren()) != 0: | |
print("[MESSAGE] Oi! This is too much! Exiting.") | |
sys.exit() | |
else: | |
if child.tag == "hi": | |
if child.attrib["rend"] == "it": | |
return_string += "<i>%s</i>%s" % (child.text, self.check_text(child.tail)) | |
elif child.attrib["rend"] == "sup": | |
return_string += "<sup>%s</sup>%s" % (child.text, self.check_text(child.tail)) | |
elif child.tag == "error": | |
print("[MESSAGE] Found a command not recognized by Tralics: %s.\nContinuing." % child.attrib["n"]) | |
print('\a') | |
input() | |
else: | |
print("[MESSAGE] Other elements besides italics are not allowed, found %s.\nExiting." % child.tag) | |
sys.exit() | |
# else: | |
# print("[MESSAGE] All clear here.\n") | |
return(return_string) | |
# def check_for_subtags ends here | |
def get_authorname(self, xmlAuthorRow, reversed_name = True): | |
"""Get name of author which sometimes as no first name. | |
Input is a list of author/mrow/mrow, return a tuple of lastname, | |
firstname | |
""" | |
str_lastname = xmlAuthorRow[0].text | |
# if only one name given | |
if len(xmlAuthorRow) <= 2: | |
str_completename = str_lastname | |
elif len(xmlAuthorRow) > 2: | |
str_firstname = xmlAuthorRow[2].text | |
if reversed_name == True: | |
str_completename = "%s, %s" % (str_lastname, str_firstname) | |
else: | |
str_completename = "%s %s" % (str_firstname, str_lastname) | |
return(self.sanitize(str_completename)) | |
# strLastName = first_author.xpath("mrow")[0].text | |
# try: | |
# strFirstName = first_author.xpath("mrow")[2].text | |
# strCompleteName = strLastName + ", " + strFirstName | |
# except IndexError: | |
# strCompleteName = strLastName | |
# strCompleteName = strLastName + ", " + strFirstName | |
# # Remaining Authors are to be Firstname Lastname | |
# for i in range(1, (intNumberOfAuthors - 1)): | |
# one_of_other_authors = xmlAuthors[i] | |
# strLastName = one_of_other_authors.xpath("mrow")[0].text | |
# try: | |
# strFirstName = one_of_other_authors.xpath("mrow")[2].text | |
# strCompleteName = strCompleteName + ", " + strFirstName + " " + strLastName | |
# except IndexError: | |
# strCompleteName = strCompleteName + ", " + strLastName | |
# try: | |
# strFirstName = last_author.xpath("mrow")[2].text | |
# str_last_author = "%s %s" % (strFirstName, strLastName) | |
# except IndexError: | |
# str_last_author = "%s" % strLastName | |
# def get_authorname ends here | |
def citekey(self): | |
xmlEntry = self.xmlEntry | |
xmlLabel = xmlEntry.find(".//label") | |
if xmlLabel is not None: | |
return xmlLabel.text | |
else: | |
return None | |
def entrytype(self): | |
strType = self.xmlEntry.find(".//type").text | |
return strType | |
def title(self): | |
xmlTitle = self.xmlEntry.find(".//title") | |
# print("xmlTitle", xmlTitle) | |
# input() | |
if xmlTitle is not None: | |
# strTitle = self.gettext(xmlTitle) | |
strTitle = self.check_for_subtags(xmlTitle) | |
if strTitle[-1] in punctuation_marks: | |
return strTitle | |
else: | |
return strTitle + "." | |
else: | |
return "" | |
# def title ends here | |
def addendum(self): | |
xmlAddendum = self.xmlEntry.find(".//addendum") | |
if xmlAddendum is not None: | |
return xmlAddendum.text | |
else: | |
return "" | |
def volume(self): | |
xmlVolume = self.xmlEntry.find(".//volume") | |
if xmlVolume is not None: | |
strResult = " " + lang_dict["volume"][LANGUAGE] + " " + xmlVolume.text + ". " | |
return strResult | |
else: | |
return "" | |
def volumenumeric(self): | |
xmlVolume = self.xmlEntry.find(".//volume") | |
if xmlVolume is not None: | |
# strResult = " " + xmlVolume.text + ". " | |
strResult = " " + self.check_for_subtags(xmlVolume) + ". " | |
return strResult | |
else: | |
return "" | |
# def volumenumeric ends here | |
def seriesnumber(self): | |
"""For books. Series which might be followed by a number""" | |
xmlSeries = self.xmlEntry.find(".//series") | |
series_present = False | |
xmlNumber = self.xmlEntry.find("number") | |
number_present = False | |
strResult = "" | |
if xmlSeries is not None: | |
series_present = True | |
if xmlSeries.text is not None: | |
xml_series_strResult = xmlSeries.text | |
else: | |
xml_series_strResult = self.check_for_subtags(xmlSeries) | |
if xmlNumber is not None: | |
number_present = True | |
xml_number_strResult = xmlNumber.text | |
if series_present == True and number_present == True: | |
strResult = " " + xml_series_strResult + " " + xml_number_strResult + ". " | |
elif series_present == True and number_present == False: | |
strResult = " " + xml_series_strResult + ". " | |
return(strResult) | |
# # old series code | |
# xmlSeries = self.xmlEntry.find(".//series") | |
# if xmlSeries is not None: | |
# if xmlSeries.text is not None: | |
# strResult = " " + xmlSeries.text + ". " | |
# else: | |
# strResult = " " + self.check_for_subtags(xmlSeries) + ". " | |
# return strResult | |
# else: | |
# return "" | |
# # end old series code | |
# # old number code | |
# xmlNumber = self.xmlEntry.find("number") | |
# strResult = "" | |
# if xmlNumber is not None: | |
# strResult = xmlNumber.text + ". " | |
# return strResult | |
# # end old number code | |
# def seriesnumber ends here | |
def series(self): | |
xmlSeries = self.xmlEntry.find(".//series") | |
if xmlSeries is not None: | |
if xmlSeries.text is not None: | |
strResult = " " + xmlSeries.text + ". " | |
else: | |
strResult = " " + self.check_for_subtags(xmlSeries) + ". " | |
return strResult | |
else: | |
return "" | |
def journaltitle(self): | |
xmlJournaltitle = self.xmlEntry.find(".//journaltitle") | |
if xmlJournaltitle is not None: | |
# strResult = " <i>" + str(xmlJournaltitle.text) + "</i>" | |
strResult = " <i>" + self.check_for_subtags(xmlJournaltitle) + "</i>" | |
return strResult | |
else: | |
return "" | |
def booktitle(self): | |
xmlBooktitle = self.xmlEntry.find(".//booktitle") | |
strResult = "" | |
if xmlBooktitle is not None: | |
if xmlBooktitle.text is not None: | |
# this is still problematic as there might be formatting in the entries! | |
strResult = " In: <i>" + str(xmlBooktitle.text) + "</i>" | |
else: | |
# this is a very unclean solution | |
strResult = " In: <i>" + self.check_for_subtags(xmlBooktitle) + "</i>" | |
return strResult | |
# def booktitle(self): | |
# xmlBooktitle = self.xmlEntry.find(".//booktitle") | |
# if xmlBooktitle is not None: | |
# strResult = " In: <i>" + str(xmlBooktitle.text) + "</i> " | |
# return strResult | |
# else: | |
# return "" | |
# def booktitle ends here | |
def number(self): | |
xmlNumber = self.xmlEntry.find("number") | |
strResult = "" | |
if xmlNumber is not None: | |
strResult = xmlNumber.text + ". " | |
return strResult | |
# def number ends here | |
def volumenumberpages(self): | |
xmlVolume = self.xmlEntry.find(".//volume") | |
xmlPages = self.xmlEntry.find(".//pages") | |
xmlNumber = self.xmlEntry.find("number") | |
strResult = "" | |
if xmlVolume is not None and xmlNumber is not None and xmlPages is not None and xmlPages.text is not None: | |
strResult = " " + xmlVolume.text + "(" + xmlNumber.text + "):" + xmlPages.text.replace("-", "–") | |
elif xmlVolume is not None and xmlNumber is None and xmlPages is not None: | |
strResult = " " + xmlVolume.text + ":" + xmlPages.text.replace("-", "–") | |
elif xmlVolume is not None and xmlNumber is not None and xmlPages is None: | |
strResult = " " + xmlVolume.text + "(" + xmlNumber.text + ")" | |
elif xmlVolume is not None and xmlNumber is None and xmlPages is None: | |
strResult = " " + xmlVolume.text | |
elif xmlVolume is None and xmlNumber is not None and xmlPages is not None: | |
strResult = "( " + xmlNumber.text + "):" + xmlPages.text.replace("-", "–") | |
elif xmlVolume is None and xmlNumber is None and xmlPages is not None: | |
strResult = ":" + xmlPages.text.replace("-", "–") | |
return strResult | |
# def volumenumberpages ends here | |
def institution(self): | |
xmlInstitution = self.xmlEntry.find(".//institution") | |
xmlLocation = self.xmlEntry.find(".//location") | |
strResult = "" | |
if xmlInstitution is not None and xmlLocation is not None: | |
strResult = " " + xmlLocation.text + ": " + xmlInstitution.text | |
elif xmlInstitution is None and xmlLocation is not None: | |
strResult = xmlLocation.text | |
elif xmlInstitution is not None and xmlLocation is None: | |
strResult = xmlInstitution.text | |
return strResult | |
# def institution ends here | |
def location(self): | |
xmlLocation = self.xmlEntry.find(".//location") | |
xmlPublisher = self.xmlEntry.find(".//publisher") | |
if xmlLocation is not None: | |
if xmlPublisher is not None: | |
strResult = " " + xmlLocation.text + ": " + self.check_for_subtags(xmlPublisher) | |
else: | |
strResult = " " + xmlLocation.text | |
if strResult.endswith("."): | |
strResult = strResult[:-1] | |
return strResult | |
elif xmlPublisher is not None: | |
strResult = " "+ self.check_for_subtags(xmlPublisher) | |
if strResult.endswith("."): | |
strResult = strResult[:-1] | |
return strResult | |
else: | |
return "" | |
def howpublished(self): | |
xmlHowpublished = self.xmlEntry.find(".//howpublished") | |
if xmlHowpublished is not None: | |
# strResult = xmlHowpublished.text | |
strResult = self.check_for_subtags(xmlHowpublished) | |
return strResult | |
else: | |
return "" | |
def note(self): | |
bib_note = self.xmlEntry.find(".//note") | |
if bib_note is not None: | |
strResult = bib_note.text | |
return strResult + ". " | |
else: | |
return "" | |
# def note ends here | |
def pages(self): | |
xmlPages = self.xmlEntry.find(".//pages") | |
if xmlPages is not None: | |
strResult = ", " + xmlPages.text | |
# in order to get rid of double period | |
if strResult.endswith("."): | |
strResult = strResult[:-1] | |
return strResult.replace("-", "–") | |
else: | |
return "" | |
# def pages ends here | |
def thesistype(self): | |
xmlTypes = self.xmlEntry.findall(".//type") | |
if len(xmlTypes) > 1: | |
if xmlTypes[1].text == "phdthesis": | |
strThesisType = " " + lang_dict["phdthesis"][LANGUAGE] + ". " | |
else: | |
strThesisType = " " + xmlTypes[1].text + ". " | |
else: | |
strThesisType = "" | |
return strThesisType | |
# def edition(self): | |
# xmlEdition = self.xmlEntry.find(".//edition") | |
# if xmlEdition is not None: | |
# if xmlEdition.text == "2" and LANGUAGE == "english": | |
# strEdition = " 2nd ed. " | |
# # elif xmlEdition.text | |
# else: | |
# strEdition = " " + xmlEdition.text + ". " | |
# return strEdition | |
# else: | |
# return "" | |
# # def edition ends here | |
def edition(self): | |
"""Prints edition | |
If value is plain integer, expand it as Latex would. | |
""" | |
xmlEdition = self.xmlEntry.find(".//edition") | |
strEdition = "" | |
if xmlEdition is not None: | |
edition_value = xmlEdition.text | |
try: | |
numeric_edition = int(edition_value) | |
if LANGUAGE == "german": | |
strEdition = " %d. Aufl. " % numeric_edition | |
if LANGUAGE == "english": | |
if edition_value[-1] == "1": | |
strEdition = " %dst ed. " % numeric_edition | |
elif edition_value[-1] == "2": | |
strEdition = " %dnd ed. " % numeric_edition | |
elif edition_value[-1] == "3": | |
strEdition = " %drd ed. " % numeric_edition | |
else: | |
strEdition = " %dth ed. " % numeric_edition | |
except ValueError: | |
strEdition = " " + edition_value + ". " | |
return(strEdition) | |
# def edition ends here | |
def edition(self): | |
xmlEdition = self.xmlEntry.find(".//edition") | |
if xmlEdition is not None: | |
strEdition = " " + xmlEdition.text + ". " | |
return strEdition | |
else: | |
return "" | |
def labelyear(self): | |
xmlEntry = self.xmlEntry | |
xmlEdition = xmlEntry.find(".//labelyear") | |
if xmlEdition is not None: | |
if xmlEdition.text == "nodate": | |
return "" | |
else: | |
return xmlEdition.text | |
else: | |
# If no year is given, return empty string | |
return "" | |
# def labelyear ends here | |
def year(self): | |
xmlEntry = self.xmlEntry | |
xmlYear = xmlEntry.find(".//year") | |
if xmlYear is not None: | |
return xmlYear.text | |
else: | |
return "" | |
# def year ends here | |
def url(self): | |
"""Not a nice solution here, but the URL has no element in the *bib.xml file | |
<urlday>28</urlday> | |
<urlmonth>10</urlmonth> | |
<urlyear>2015</urlyear> | |
<year>o.J.</year> | |
url | |
http://www.universalis.fr/encyclopedie/college-de-coqueret/ | |
<... | |
""" | |
from datetime import datetime | |
urlday = urlmonth = urlyear = "" | |
xmlEntry = self.xmlEntry | |
xml_as_string = etree.tostring(xmlEntry) | |
xml_URL = re.findall(r"\n(https?://.*?)\n", xml_as_string.decode(encoding="utf-8")) | |
xml_urlday = xmlEntry.find(".//urlday") | |
xml_urlmonth = xmlEntry.find(".//urlmonth") | |
xml_urlyear = xmlEntry.find(".//urlyear") | |
if xml_urlday is not None: | |
urlday = xml_urlday.text | |
if xml_urlmonth is not None: | |
urlmonth = xml_urlmonth.text | |
if xml_urlyear is not None: | |
urlyear = xml_urlyear.text | |
if len(xml_URL) != 0: | |
url_date = "%s-%s-%s" % (urlyear, urlmonth, urlday) | |
parsed_date = datetime.strptime(url_date, "%Y-%m-%d") | |
str_URL = "URL: <a href='" + xml_URL[0] + "'>" + xml_URL[0] + "</a> (" + lang_dict["visited"][LANGUAGE] + " " + parsed_date.strftime(lang_dict["dateformat"][LANGUAGE]) + ")." | |
return(str_URL) | |
else: | |
return("") | |
# def url ends here | |
def url(self): | |
"""Not a nice solution here, but the URL has no element in the *bib.xml file | |
<urlday>28</urlday> | |
<urlmonth>10</urlmonth> | |
<urlyear>2015</urlyear> | |
<year>o.J.</year> | |
url | |
http://www.universalis.fr/encyclopedie/college-de-coqueret/ | |
<... | |
""" | |
from datetime import datetime | |
urlday = urlmonth = urlyear = "" | |
xmlEntry = self.xmlEntry | |
xml_as_string = etree.tostring(xmlEntry) | |
xml_URL = re.findall(r"\n(https?://.*?)\n", xml_as_string.decode(encoding="utf-8")) | |
xml_urlday = xmlEntry.find(".//urlday") | |
xml_urlmonth = xmlEntry.find(".//urlmonth") | |
xml_urlyear = xmlEntry.find(".//urlyear") | |
if xml_urlday is not None: | |
urlday = xml_urlday.text | |
if xml_urlmonth is not None: | |
urlmonth = xml_urlmonth.text | |
if xml_urlyear is not None: | |
urlyear = xml_urlyear.text | |
if len(xml_URL) != 0: | |
url_date = "%s-%s-%s" % (urlyear, urlmonth, urlday) | |
parsed_date = datetime.strptime(url_date, "%Y-%m-%d") | |
if LANGUAGE == "german": | |
# make difference between languages here, because date will be formatted differently in other languages | |
str_URL = "URL: <a href='" + xml_URL[0] + "'>" + xml_URL[0] + "</a> (" + lang_dict["visited"][LANGUAGE] + " " + parsed_date.strftime("%d.%m.%Y") + ")." | |
return(str_URL) | |
elif LANGUAGE == "english": | |
# make difference between languages here, because date will be formatted differently in other languages | |
str_URL = "URL: <a href='" + xml_URL[0] + "'>" + xml_URL[0] + "</a> (" + lang_dict["visited"][LANGUAGE] + " " + parsed_date.strftime("%d/%m/%Y") + ")." | |
return(str_URL) | |
else: | |
return("") | |
# def url ends here | |
def labelyearsuffix(self): | |
xmlEntry = self.xmlEntry | |
xmlExtrayear = xmlEntry.find(".//extrayear") | |
if xmlExtrayear is not None: | |
intExtrayear = int(xmlExtrayear.text) | |
listCharacters = ["","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"] | |
strLabelYearSuffix = listCharacters[intExtrayear] | |
return strLabelYearSuffix | |
else: | |
return "" | |
def fullauthorlastfirst(self): | |
xmlEntry = self.xmlEntry | |
# If no Name is given, return either the Shorthand or the Title (Shorthand prefererred) | |
if xmlEntry.find(".//author/number") == None: | |
if xmlEntry.find(".//editor") is not None: | |
strComplete, several_editors = self.editorasauthor() | |
edited_suffix = lang_dict["editor"][LANGUAGE] | |
if several_editors == True: | |
edited_suffix = lang_dict["editors"][LANGUAGE] | |
return(strComplete, edited_suffix) | |
elif xmlEntry.find(".//shorthand") is not None: | |
strComplete = xmlEntry.find(".//shorthand").text | |
return(strComplete, "") | |
else: | |
strComplete = self.title() | |
return(strComplete, "no_author_only_title") | |
intNumberOfAuthors = int(xmlEntry.find(".//author/number").text) | |
if intNumberOfAuthors == 1: | |
xmlAuthorRows = xmlEntry.findall(".//author/mrow/mrow") | |
result_authorname = self.get_authorname(xmlAuthorRows) | |
return(result_authorname, "") | |
elif intNumberOfAuthors == 2: | |
xmlAuthors = xmlEntry.findall(".//author/mrow/mrow") | |
# First Author here would be Lastname, Firstname | |
first_author = xmlAuthors[0] | |
strCompleteName = self.get_authorname(first_author) | |
second_author = self.get_authorname(xmlAuthors[1], reversed_name = False) | |
strCompleteName = strCompleteName + " " + lang_dict["and"][LANGUAGE] + " " + second_author | |
return(self.sanitize(strCompleteName), "") | |
elif intNumberOfAuthors > 2 and intNumberOfAuthors < 12: | |
xmlAuthors = xmlEntry.findall(".//author/mrow/mrow") | |
# First Author here would be Lastname, Firstname | |
first_author = xmlAuthors[0] | |
strCompleteName = self.get_authorname(first_author) | |
for i in range(1, (intNumberOfAuthors - 1)): | |
one_of_other_authors = xmlAuthors[i] | |
another_author = self.get_authorname(one_of_other_authors, reversed_name = False) | |
strCompleteName = "%s, %s" % (strCompleteName, another_author) | |
last_author = self.get_authorname(xmlAuthors[-1], reversed_name = False) | |
if LANGUAGE == "english": | |
strCompleteName = strCompleteName + ", " + lang_dict["and"][LANGUAGE] + " " + last_author | |
elif LANGUAGE == "german": | |
strCompleteName = strCompleteName + " " + lang_dict["and"][LANGUAGE] + " " + last_author | |
return(self.sanitize(strCompleteName), "") | |
# if we have a lot of authors | |
elif intNumberOfAuthors > 12: | |
xmlAuthors = xmlEntry.findall(".//author/mrow/mrow") | |
# First Author here would be Lastname, Firstname | |
first_author = xmlAuthors[0] | |
strCompleteName = self.get_authorname(first_author) | |
strCompleteName = strCompleteName + " et al." | |
return(self.sanitize(strCompleteName), "") | |
# def fullauthorlastfirst ends here | |
def fullauthorfirstlast(self): | |
xmlEntry = self.xmlEntry | |
# If no Name is given, return either the Shorthand or the Title (Shorthand prefererred) | |
if xmlEntry.find(".//author/number") == None: | |
if xmlEntry.find(".//shorthand") is not None: | |
strComplete = xmlEntry.find(".//shorthand").text | |
return strComplete | |
else: | |
strComplete = self.title() | |
return strComplete | |
intNumberOfAuthors = int(xmlEntry.find(".//author/number").text) | |
if intNumberOfAuthors == 1: | |
xmlAuthorRows = xmlEntry.findall(".//author/mrow/mrow") | |
strLastName = xmlAuthorRows[0].text | |
if len(xmlAuthorRows) > 3: | |
strFirstName = xmlAuthorRows[2].text | |
strCompleteName = strFirstName + " " + strLastName | |
return self.sanitize(strCompleteName) | |
else: | |
return self.sanitize(strLastName) | |
if intNumberOfAuthors > 1: | |
xmlAuthorRows = xmlEntry.findall(".//author/mrow/mrow/mrow") | |
# First Author here would be Lastname, Firstname | |
strLastName = xmlAuthorRows[0].text | |
strFirstName = xmlAuthorRows[2].text | |
strCompleteName = strFirstName + " " + strLastName | |
# Remaining Authors are to be Firstname Lastname | |
for i in range(0, (intNumberOfAuthors - 1)): | |
a = i + 4 | |
strLastName = "" | |
strFirstName = "" | |
if len(xmlAuthorRows) > a: | |
strLastName = xmlAuthorRows[a].text | |
a = i + 6 | |
if len(xmlAuthorRows) > a: | |
strFirstName = xmlAuthorRows[a].text | |
strCompleteName = strCompleteName + ", " + strFirstName + " " + strLastName | |
return self.sanitize(strCompleteName) | |
def shortauthor(self): | |
xmlEntry = self.xmlEntry | |
# If no Name is given, return either the Editor, the Shorthand or the Title (Shorthand prefererred) | |
if xmlEntry.find(".//author/number") == None: | |
if xmlEntry.find(".//editor") is not None: | |
strComplete = self.editorasauthor(whole_name=False)[0] | |
return(strComplete) | |
elif xmlEntry.find(".//shorthand") is not None: | |
strComplete = xmlEntry.find(".//shorthand").text | |
return strComplete | |
else: | |
strComplete = xmlEntry.find(".//title").text | |
return strComplete | |
intNumberOfAuthors = int(xmlEntry.find(".//author/number").text) | |
if intNumberOfAuthors == 1: | |
xmlAuthorRows = xmlEntry.findall(".//author/mrow/mrow") | |
strLastName = xmlAuthorRows[0].text | |
return self.sanitize(strLastName) | |
if intNumberOfAuthors == 2: | |
xmlAuthorRows = xmlEntry.findall(".//author/mrow/mrow/mrow") | |
strLastName1 = xmlAuthorRows[0].text | |
if len(xmlAuthorRows) > 5: | |
strLastName2 = xmlAuthorRows[4].text | |
else: | |
strLastName2 = "" | |
strCompleteName = strLastName1 + " " + lang_dict["and"][LANGUAGE] + " " + strLastName2 | |
return self.sanitize(strCompleteName) | |
if intNumberOfAuthors > 2: | |
xmlAuthorRows = xmlEntry.findall(".//author/mrow/mrow/mrow") | |
strLastName1 = xmlAuthorRows[0].text | |
strCompleteName = strLastName1 + " et.al." | |
return self.sanitize(strCompleteName) | |
def editorasauthor(self, whole_name=True): | |
more_than_one = False | |
xmlEntry = self.xmlEntry | |
if xmlEntry.find(".//editor/number") is None: | |
return("") | |
intNumberOfEditors = int(xmlEntry.find(".//editor/number").text) | |
if intNumberOfEditors == 1: | |
xmlEditorRows = xmlEntry.findall(".//editor/mrow/mrow") | |
strLastName = xmlEditorRows[0].text | |
if len(xmlEditorRows) > 3: | |
try: | |
strFirstName = xmlEditorRows[2].text | |
strCompleteName = strLastName + ", " + strFirstName | |
except IndexError: | |
strCompleteName = strCompleteName + ", " + strLastName | |
if whole_name is True: | |
return(self.sanitize(strCompleteName), more_than_one) | |
else: | |
return(self.sanitize(strLastName), more_than_one) | |
else: | |
return(self.sanitize(strLastName), more_than_one) | |
elif intNumberOfEditors == 2: | |
more_than_one = True | |
xmlEditors = xmlEntry.findall(".//editor/mrow/mrow") | |
# First Author here would be Lastname, Firstname | |
strCompleteName = self.get_authorname(xmlEditors[0]) | |
second_editor = self.get_authorname(xmlEditors[1], reversed_name = False) | |
strCompleteName = strCompleteName + " " + lang_dict["and"][LANGUAGE] + " " + second_editor | |
return(self.sanitize(strCompleteName), more_than_one) | |
# elif intNumberOfEditors == 2: | |
# more_than_one = True | |
# xmlEditors = xmlEntry.findall(".//editor/mrow/mrow") | |
# # First Author here would be Lastname, Firstname | |
# first_editor = xmlEditors[0] | |
# strCompleteName = self.get_authorname(first_editor) | |
# # strLastName = first_editor.xpath("mrow")[0].text | |
# # strFirstName = first_editor.xpath("mrow")[2].text | |
# # strCompleteName = strLastName + ", " + strFirstName | |
# # Remaining Authors are to be Firstname Lastname | |
# for i in range(1, (intNumberOfEditors - 1)): | |
# one_of_other_editors = xmlEditors[i] | |
# another_editor = self.get_authorname(one_of_other_editors, reversed_name = False) | |
# strCompleteName = strCompleteName + another_editor | |
# # strLastName = one_of_other_editors.xpath("mrow")[0].text | |
# # strFirstName = one_of_other_editors.xpath("mrow")[2].text | |
# # strCompleteName = strCompleteName + ", " + strFirstName + " " + strLastName | |
# last_editor = self.get_authorname(xmlEditors[-1], reversed_name = False) | |
# # last_editor = xmlEditors[-1] | |
# # strLastName = last_editor.xpath("mrow")[0].text | |
# # strFirstName = last_editor.xpath("mrow")[2].text | |
# # strCompleteName = strCompleteName + " " + lang_dict["and"][LANGUAGE] + " " + strFirstName + " " + strLastName | |
# if LANGUAGE == "english": | |
# strCompleteName = strCompleteName + ", " + lang_dict["and"][LANGUAGE] + " " + last_editor | |
# elif LANGUAGE == "german": | |
# strCompleteName = strCompleteName + " " + lang_dict["and"][LANGUAGE] + " " + last_editor | |
# return(self.sanitize(strCompleteName), more_than_one) | |
elif intNumberOfEditors > 2: | |
more_than_one = True | |
xmlEditors = xmlEntry.findall(".//editor/mrow/mrow") | |
# First Author here would be Lastname, Firstname | |
first_editor = xmlEditors[0] | |
strLastName = first_editor.xpath("mrow")[0].text | |
strFirstName = first_editor.xpath("mrow")[2].text | |
strCompleteName = strLastName + ", " + strFirstName | |
# Remaining Authors are to be Firstname Lastname | |
for i in range(1, (intNumberOfEditors - 1)): | |
one_of_other_editors = xmlEditors[i] | |
strLastName = one_of_other_editors.xpath("mrow")[0].text | |
strFirstName = one_of_other_editors.xpath("mrow")[2].text | |
strCompleteName = strCompleteName + ", " + strFirstName + " " + strLastName | |
last_editor = xmlEditors[-1] | |
strLastName = last_editor.xpath("mrow")[0].text | |
strFirstName = last_editor.xpath("mrow")[2].text | |
if LANGUAGE == "english": | |
strCompleteName = strCompleteName + ", " + lang_dict["and"][LANGUAGE] + " " + strFirstName + " " + strLastName | |
elif LANGUAGE == "german": | |
strCompleteName = strCompleteName + " " + lang_dict["and"][LANGUAGE] + " " + strFirstName + " " + strLastName | |
return(self.sanitize(strCompleteName), more_than_one) | |
# def editorasauthor ends here | |
def editor(self): | |
xmlEntry = self.xmlEntry | |
# should be language specific | |
# If no Name is given, return either the Shorthand or the Title (Shorthand prefererred) | |
if xmlEntry.find(".//editor/number") is None: | |
return "" | |
intNumberOfEditors = int(xmlEntry.find(".//editor/number").text) | |
if intNumberOfEditors == 1: | |
xmlEditorRows = xmlEntry.findall(".//editor/mrow/mrow") | |
strLastName = xmlEditorRows[0].text | |
if len(xmlEditorRows) > 3: | |
strFirstName = xmlEditorRows[2].text | |
strCompleteName = lang_dict["edited"][LANGUAGE] + " " + strFirstName + " " + strLastName + "." | |
return self.sanitize(strCompleteName) | |
else: | |
strLastName = xmlEditorRows[0].text | |
strCompleteName = lang_dict["edited"][LANGUAGE] + " " + strLastName + "." | |
return self.sanitize(strCompleteName) | |
elif intNumberOfEditors == 2: | |
xmlEditors = xmlEntry.findall(".//editor/mrow/mrow") | |
# First Author here would be Lastname, Firstname | |
first_editor = xmlEditors[0] | |
strLastName = first_editor.xpath("mrow")[0].text | |
strFirstName = first_editor.xpath("mrow")[2].text | |
strCompleteName = lang_dict["edited"][LANGUAGE] + " " + strFirstName + " " + strLastName | |
# Remaining Authors are to be Firstname Lastname | |
for i in range(1, (intNumberOfEditors - 1)): | |
one_of_other_editors = xmlEditors[i] | |
if len(one_of_other_editors.xpath("mrow")) == 2: | |
strCompleteName = strCompleteName + ", " + one_of_other_editors.xpath("mrow")[0].text + "." | |
else: | |
strLastName = one_of_other_editors.xpath("mrow")[0].text | |
strFirstName = one_of_other_editors.xpath("mrow")[2].text | |
strCompleteName = strCompleteName + ", " + strFirstName + " " + strLastName + "." | |
last_editor = xmlEditors[-1] | |
if len(last_editor.xpath("mrow")) == 2: | |
strCompleteName = strCompleteName + " " + lang_dict["and"][LANGUAGE] + " " + last_editor.xpath("mrow")[0].text + "." | |
else: | |
strLastName = last_editor.xpath("mrow")[0].text | |
strFirstName = last_editor.xpath("mrow")[2].text | |
strCompleteName = strCompleteName + " " + lang_dict["and"][LANGUAGE] + " " + strFirstName + " " + strLastName + "." | |
elif intNumberOfEditors > 2: | |
xmlEditors = xmlEntry.findall(".//editor/mrow/mrow") | |
first_editor = xmlEditors[0] | |
strLastName = first_editor.xpath("mrow")[0].text | |
strFirstName = first_editor.xpath("mrow")[2].text | |
strCompleteName = lang_dict["edited"][LANGUAGE] + " " + strFirstName + " " + strLastName | |
# Remaining Authors are to be Firstname Lastname | |
for i in range(1, (intNumberOfEditors - 1)): | |
one_of_other_editors = xmlEditors[i] | |
if len(one_of_other_editors.xpath("mrow")) == 2: | |
strCompleteName = strCompleteName + ", " + one_of_other_editors.xpath("mrow")[0].text | |
else: | |
strLastName = one_of_other_editors.xpath("mrow")[0].text | |
strFirstName = one_of_other_editors.xpath("mrow")[2].text | |
strCompleteName = strCompleteName + ", " + strFirstName + " " + strLastName | |
last_editor = xmlEditors[-1] | |
if len(last_editor.xpath("mrow")) == 2: | |
strCompleteName = strCompleteName + " " + lang_dict["and"][LANGUAGE] + " " + last_editor.xpath("mrow")[0].text + "." | |
else: | |
strLastName = last_editor.xpath("mrow")[0].text | |
strFirstName = last_editor.xpath("mrow")[2].text | |
if LANGUAGE == "english": | |
strCompleteName = strCompleteName + ", " + lang_dict["and"][LANGUAGE] + " " + strFirstName + " " + strLastName + "." | |
elif LANGUAGE == "german": | |
strCompleteName = strCompleteName + " " + lang_dict["and"][LANGUAGE] + " " + strFirstName + " " + strLastName + "." | |
return self.sanitize(strCompleteName) |