def update(self, metadata, media, lang, force=False):
Log.Debug(
"--- Update Begin -------------------------------------------------------------------------------------------"
)
if force:
HTTP.ClearCache()
logging.New_Milestones()
logging.New_AniDB()
logging.Log_Milestone("WholeUpdate")
common.RefreshData()
source, id = metadata.id.split("-")
Log("Source: %s, ID: %s" % (source, id))
#filename = ""
#for sea_item in media.seasons:
# Log("FileName1: %s" % (sea_item))
# for eps_item in media.seasons[sea_item].episodes:
# Log("FileName2: %s" % (eps_item))
# for media_item in media.seasons[sea_item].episodes[eps_item].items:
# for item_part in media_item.parts:
# filename = item_part.file.lower()
# Log("FileName: %s" % (filename))
#functions.downloadfile("test.webm", "https://my.mixtape.moe/sovrtq.webm")
mappingData = None
if source in ["anidb", "anidb2"]:
mappingData = scudlee.ScudLee(id)
if source in ["tvdb", "tvdb2", "tvdb3", "tvdb4", "tvdb5"]:
mappingData = scudlee.ScudLee(None, id)
Log.Debug(
"Init - Update() - source: '%s', anidbid: '%s', tvdbid: '%s'" %
(source, mappingData.AnidbId, mappingData.TvdbId))
if mappingData != None:
map = common.MapSeries(mappingData)
#functions.SaveFile(etree.tostring(map, pretty_print=True, xml_declaration=True, encoding="UTF-8"), mappingData.FirstSeries + ".bundle.xml", "Bundles")
#common.MapLocal(media, map, mappingData.AnidbId)
common.MapLocal(map, media)
common.MapMeta(map)
functions.SaveFile(
etree.tostring(map,
pretty_print=True,
xml_declaration=True,
encoding="UTF-8"),
mappingData.FirstSeries + ".bundle.xml", "Bundles")
if constants.ExportBundles:
common.ExportMap(map, mappingData.FirstSeries + ".bundle.xml")
common.MapMedia(map, metadata, mappingData.AnidbId,
mappingData.TvdbId)
logging.Log_Milestone("WholeUpdate")
logging.Log_AniDB(None, True)
def scoreTitle(anime=anime,
maxi=maxi,
anidb=anidb,
perfectScore=perfectScore):
logging.Log_Milestone("Title")
anime = Titles(anime, orig_title)
logging.Log_Milestone("Title")
isValid = True
if (anime.Id in maxi
and maxi[anime.Id] <= anime.Score) or (not anime.Id
in maxi):
maxi[anime.Id] = anime.Score
else:
isValid = False
if isValid:
startdate = None
if (media.year and anime.Score >= 90):
show = anidb.AniDB(anime.Id)
if show:
try:
startdate = dateParse(
show.Originally_Available_At).year
except:
pass
if str(startdate) != str(media.year):
isValid = False
Log.Debug(
"Init - Search() - date: '%s', aired: '%s'"
% (media.year, startdate))
elite.append(isValid)
elif anime.Score >= 90:
elite.append(isValid)
if isValid:
if anime.Score == 100:
perfectScore.append(anime.Id)
Log.Debug(
"Init - Search() - find - id: '%s-%s', title: '%s', score: '%s'"
%
("anidb", anime.Id, anime.Title, anime.Score))
results.Append(
MetadataSearchResult(
id="%s-%s" % ("anidb", anime.Id),
name="%s [%s-%s]" %
(anime.Title, "anidb", anime.Id),
year=startdate,
lang=Locale.Language.English,
score=anime.Score))
def SearchMap(root, media, anidbId, tvdbId):
logging.Log_Milestone("SearchMap")
streamTag = []
seasonNo = 0
seasonMap = root.xpath("""./Season[@AnidbId="%s" and @num!="0"]""" %
(anidbId))
if not seasonMap:
seasonMap = root.xpath("""./Season[@TvdbId="%s" and @num!="0"]""" %
(tvdbId))
if seasonMap:
seasonMap = seasonMap[0]
seasonNo = int(seasonMap.get("num"))
season = str(int(map.getparent().get('num')) - seasonNo + 1)
for seasonNo in media.seasons:
for episodeNo in media.seasons[seasonNo].episodes:
map = root.xpath("""./Season[@num>=%s]/Episode""" % (seasonNo))
logging.Log_Milestone("SearchMap")
def GetAnimeTitleByName(Tree, Name):
logging.Log_Milestone("GetAnimeTitleByName_" + Name)
Name = Name.lower()
#Log("Name: %s" % (Name))
result = []
logging.Log_Milestone("GetAnimeTitleByName_Xpath_" + Name)
result = Tree.xpath(u"""./anime/title
[@type='main' or @type='official' or @type='syn' or @type='short']
[lower-case(string(clean-title(string(text()))))="%s"
or contains(lower-case(string(clean-title(string(text())))), "%s")]"""
% (Name, Name))
logging.Log_Milestone("GetAnimeTitleByName_Xpath_" + Name)
if not result:
logging.Log_Milestone("GetAnimeTitleByName_DiffLib_" + Name)
result = Tree.xpath(u"""./anime/title
[@type='main' or @type='official' or @type='syn' or @type='short']
[is-match("%s", lower-case(string(clean-title(string(text())))))]"""
% (Name))
logging.Log_Milestone("GetAnimeTitleByName_DiffLib_" + Name)
logging.Log_Milestone("GetAnimeTitleByName_" + Name)
return result
def __init__(self, id):
logging.Log_Milestone("TvDB" + "_" + id)
self.ID = id
self.MetaType = "Tvdb"
data = XMLFromURL(constants.TVDB_HTTP_API_URL % id, id + ".xml",
os.path.join("TvDB", id),
CACHE_1HOUR * 24).xpath("""/Data""")[0]
##--------------------------------Title--------------------------------##
if GetElementText(data, "Series/SeriesName"):
self.Title = str(GetElementText(
data, "Series/SeriesName")).encode('utf-8').strip().translate(
constants.ReplaceChars)
##--------------------------------Summary------------------------------##
if GetElementText(data, "Series/Overview"):
self.Summary = GetElementText(data, "Series/Overview")
##--------------------------------Originally_Available_At--------------##
if GetElementText(data, "Series/FirstAired"):
self.Originally_Available_At = GetElementText(
data, "Series/FirstAired")
##--------------------------------Rating-------------------------------##
if GetElementText(data, "Series/Rating"):
self.Rating = GetElementText(data, "Series/Rating")
##--------------------------------Studio-------------------------------##
if GetElementText(data, "Series/Network"):
self.Studio = GetElementText(data, "Series/Network")
##--------------------------------Countries----------------------------##
##--------------------------------Genres-------------------------------##
if GetElementText(data, "Series/Genre"):
self.Genres = filter(
None,
GetElementText(data, "Series/Genre").split("|"))
##--------------------------------Tags---------------------------------##
##--------------------------------Collections--------------------------##
##--------------------------------Content_Rating-----------------------##
if GetElementText(data, "Series/ContentRating"):
self.Content_Rating = GetElementText(data, "Series/ContentRating")
##--------------------------------Writers------------------------------##
##--------------------------------Directors----------------------------##
##--------------------------------Producers----------------------------##
##--------------------------------Roles--------------------------------##
self.Roles = []
##--------------------------------Images-------------------------------##
banners = []
bannersXml = XMLFromURL(constants.TVDB_BANNERS_URL % id,
id + "_banners.xml", os.path.join("TvDB", id),
CACHE_1HOUR * 24)
if bannersXml:
art = etree.tostring(E.Images(),
pretty_print=True,
xml_declaration=True,
encoding="UTF-8")
art = XML.ElementFromString(art)
artCount = 2
posters = etree.tostring(E.Images(),
pretty_print=True,
xml_declaration=True,
encoding="UTF-8")
posters = XML.ElementFromString(posters)
postersCount = 2
banners = etree.tostring(E.Images(),
pretty_print=True,
xml_declaration=True,
encoding="UTF-8")
banners = XML.ElementFromString(banners)
bannersCount = 2
season = etree.tostring(E.Images(),
pretty_print=True,
xml_declaration=True,
encoding="UTF-8")
season = XML.ElementFromString(season)
seasonCount = []
for banner in sorted(
bannersXml.xpath("./Banner"),
key=lambda x: float(GetElementText(x, "Rating", 0)),
reverse=True):
bannerType = GetElementText(banner, "BannerType")
bannerType2 = GetElementText(banner, "BannerType2")
bannerPath = GetElementText(banner, "BannerPath")
bannerThumb = GetElementText(banner, "ThumbnailPath")
if bannerThumb == None or bannerThumb == "":
bannerThumb = "_cache" + "/" + bannerPath
metatype = ("art" if bannerType == "fanart" else \
"posters" if bannerType == "poster" else \
"banners" if bannerType == "series" or bannerType2=="seasonwide" else \
"season" if bannerType == "season" and bannerType2=="680x1000" else \
"season" if bannerType == "season" and bannerType2=="season" else None)
#Log("Images: %s, %s, %s, %s, %s" % (bannerPath, constants.TVDB_IMAGES_URL, id, metatype, bannerThumb))
mainUrl, thumbUrl, mainLocalPath, thumbLocalPath = functions.ParseImage(
bannerPath, constants.TVDB_IMAGES_URL,
os.path.join("TvDB", id, metatype), bannerThumb)
if metatype == "art":
SubElement(art,
"Image",
id=str(1 if bannerPath == GetElementText(
data, "Series/fanart") else artCount),
mainUrl=mainUrl,
thumbUrl=thumbUrl,
mainLocalPath=mainLocalPath,
thumbLocalPath=thumbLocalPath)
artCount = artCount + 1
if metatype == "posters":
SubElement(posters,
"Image",
id=str(1 if bannerPath == GetElementText(
data, "Series/poster") else postersCount),
mainUrl=mainUrl,
thumbUrl=thumbUrl,
mainLocalPath=mainLocalPath,
thumbLocalPath=thumbLocalPath)
postersCount = postersCount + 1
if metatype == "banners":
SubElement(banners,
"Image",
id=str(1 if bannerPath == GetElementText(
data, "Series/banner") else bannersCount),
mainUrl=mainUrl,
thumbUrl=thumbUrl,
mainLocalPath=mainLocalPath,
thumbLocalPath=thumbLocalPath)
bannersCount = bannersCount + 1
if metatype == "season":
seasonCount.append(GetElementText(banner, "Season"))
SubElement(season,
"Image",
id=str(
seasonCount.count(
GetElementText(banner, "Season"))),
mainUrl=mainUrl,
thumbUrl=thumbUrl,
mainLocalPath=mainLocalPath,
thumbLocalPath=thumbLocalPath,
season=str(GetElementText(banner, "Season")))
self.Art = art
self.Posters = posters
self.Banners = banners
self.Season = season
##--------------------------------Themes-------------------------------##
self.Themes = []
##--------------------------------EpisodeCount-------------------------##
self.EpisodeCount = len(
data.xpath("""./Episode/SeasonNumber[text()>0]"""))
##--------------------------------SpecialCount-------------------------##
self.SpecialCount = len(
data.xpath("""./Episode/SeasonNumber[text()=0]"""))
##--------------------------------Duration-----------------------------##
if GetElementText(data, "Series/Runtime"):
self.Duration = int(
int(self.EpisodeCount) *
int(GetElementText(data, "Series/Runtime")))
##--------------------------------OP/ED_List---------------------------##
self.OpList = []
self.EdList = []
##--------------------------------Episodes-----------------------------##
if len(data.xpath("""./Episode""")) > 0:
self.Episodes = []
for item in data.xpath("""./Episode"""):
self.Episodes.append(self.Episode(item, id))
#Log("AniDB - __init__() - Populate Title: '%s', Network: '%s', Overview: '%s', FirstAired: '%s', Genre: '%s', ContentRating: '%s', Rating: '%s', Episodes: '%s', EpisodeCount: '%s', SpecialCount: '%s', OpedCount: '%s', Posters: '%s'"
#% (self.Title, self.Network, self.Overview, self.FirstAired, self.Genre, self.ContentRating, self.Rating, self.Episodes, self.EpisodeCount, self.SpecialCount, self.OpedCount, self.Posters) )
logging.Log_Milestone("TvDB" + "_" + id)
def __init__(self, id):
logging.Log_Milestone("AniDB" + "_" + id)
data = XMLFromURL(constants.ANIDB_HTTP_API_URL + id, id + ".xml",
os.path.join("AniDB", id),
CACHE_1HOUR * 24).xpath("""/anime""")[0]
##--------------------------------ID-----------------------------------##
self.ID = id
self.MetaType = "Anidb"
self.Type = GetElementText(data, "type")
##--------------------------------Title--------------------------------##
if data.xpath("""./titles"""):
self.Title = functions.GetPreferedTitle(
data.xpath("""./titles/title""")).encode(
'utf-8').strip().translate(constants.ReplaceChars)
##--------------------------------Summary------------------------------##
if GetElementText(data, "description"):
description = re.sub(
r'(?m)^\*.*\n?', '',
GetElementText(data, "description").replace("`", "'")).strip()
self.Summary = re.sub(
r"http://anidb\.net/[a-z]{2}[0-9]+ \[(.+?)\]", r"\1",
description)
##--------------------------------Originally_Available_At--------------##
if GetElementText(data, "startdate"):
self.Originally_Available_At = GetElementText(data, "startdate")
##--------------------------------Rating-------------------------------##
if GetElementText(data, "ratings/permanent") and GetElementText(
data, "ratings/temporary"):
self.Rating = (
float(GetElementText(data, "ratings/permanent")) +
float(GetElementText(data, "ratings/temporary"))) / 2
elif GetElementText(data, "ratings/permanent"):
self.Rating = float(GetElementText(data, "ratings/permanent"))
elif GetElementText(data, "ratings/temporary"):
self.Rating = float(GetElementText(data, "ratings/temporary"))
##--------------------------------Studio-------------------------------##
for creator in data.xpath(
"""./creators/name[@type="Animation Work"]"""):
self.Studio = creator.text
##--------------------------------Countries----------------------------##
for setting in data.xpath("""./tags/tag/name[text()="setting"]/.."""):
for place in data.xpath("""./tags/tag[@parentid="%s"]""" %
(setting.get("id"))):
for planet in data.xpath("""./tags/tag[@parentid="%s"]""" %
(place.get("id"))):
for continent in data.xpath(
"""./tags/tag[@parentid="%s"]""" %
(planet.get("id"))):
for country in data.xpath(
"""./tags/tag[@parentid="%s" and @weight>="%s"]/name"""
%
(continent.get("id"), constants.MINIMUM_WEIGHT)):
if self.Countries is None: self.Countries = []
self.Countries.append(country.text)
##--------------------------------Duration-----------------------------##
for length in data.xpath("""./episodes/episode/epno[@type="1"]/.."""):
if GetElementText(length, "length"):
if self.Duration is None: self.Duration = 0
self.Duration = self.Duration + int(
GetElementText(length, "length"))
##--------------------------------Genres-------------------------------##
for element in data.xpath("""./tags/tag/name[text()="elements"]/.."""):
for genre in data.xpath(
"""./tags/tag[@parentid="%s" and @weight>="%s"]/name""" %
(element.get("id"), constants.MINIMUM_WEIGHT)):
if self.Genres is None: self.Genres = []
self.Genres.append(str(genre.text).title())
##--------------------------------Tags---------------------------------##
for tag in data.xpath("""./tags/tag[@infobox="true"]/name"""):
if self.Tags is None: self.Tags = []
self.Tags.append(str(tag.text).title())
##--------------------------------Collections--------------------------##
for collection in data.xpath(
"""./relatedanime/anime[(@type="Prequel") or (@type="Sequel")]"""
):
if self.Collections is None: self.Collections = []
self.Collections.append(collection.text)
##--------------------------------Content_Rating-----------------------##
for indicators in data.xpath(
"""./tags/tag/name[text()="content indicators"]/.."""):
ratingInt = 0
for tag in data.xpath(
"""./tags/tag[(@parentid="%s") and (@weight>="%s")]/name"""
% (indicators.get("id"), constants.MINIMUM_WEIGHT)):
if tag.text == "nudity": 1 if ratingInt < 1 else ratingInt
elif tag.text == "sex": 2 if ratingInt < 2 else ratingInt
elif tag.text == "violence": 2 if ratingInt < 2 else ratingInt
if ratingInt == 0: self.Content_Rating = "PG-13"
elif ratingInt == 1: self.Content_Rating = "R"
elif ratingInt == 2: self.Content_Rating = "NC-17"
##--------------------------------Writers------------------------------##
for writer in data.xpath(
"""./creators/name[(@type="Original Work") or (@type="Script") or (@type="Screenplay")]"""
):
if self.Writers is None: self.Writers = []
self.Writers.append(writer.text)
##--------------------------------Directors----------------------------##
for director in data.xpath("""./creators/name[@type="Direction"]"""):
if self.Directors is None: self.Directors = []
self.Directors.append(director.text)
##--------------------------------Producers----------------------------##
for producer in data.xpath(
"""./creators/name[@type="Series Composition"]"""):
if self.Producers is None: self.Producers = []
self.Producers.append(producer.text)
##--------------------------------Roles--------------------------------##
roles = etree.tostring(E.Roles(),
pretty_print=True,
xml_declaration=True,
encoding="UTF-8")
roles = XML.ElementFromString(roles)
for role in data.xpath(
"""./characters/character/charactertype[text()="Character"]/.."""
):
character_name = ""
seiyuu_name = ""
seiyuu_pic = ""
if GetElementText(role, "name"):
character_name = str(GetElementText(role, "name"))
if GetElementText(role, "seiyuu"):
seiyuu_name = GetElementText(role, "seiyuu")
seiyuu_pic = ""
if role.find('seiyuu').get('picture'):
seiyuu_pic = constants.ANIDB_PIC_BASE_URL + role.find(
'seiyuu').get('picture')
SubElement(roles,
"Role",
character_name=character_name,
seiyuu_name=seiyuu_name,
seiyuu_pic=seiyuu_pic)
if not roles is None: self.Roles = roles
##--------------------------------Images------------------------------##
if GetElementText(data, "picture"):
season = etree.tostring(E.Images(),
pretty_print=True,
xml_declaration=True,
encoding="UTF-8")
season = XML.ElementFromString(season)
bannerPath = GetElementText(data, "picture")
mainUrl, thumbUrl, mainLocalPath, thumbLocalPath = functions.ParseImage(
bannerPath, constants.ANIDB_PIC_BASE_URL,
os.path.join("AniDB", id,
"season"), constants.ANIDB_PIC_THUMB_URL %
os.path.splitext(bannerPath)[0])
SubElement(season,
"Image",
id="1",
mainUrl=mainUrl,
thumbUrl=thumbUrl,
mainLocalPath=mainLocalPath,
thumbLocalPath=thumbLocalPath,
season="1")
self.Season = season
self.Posters = copy.deepcopy(season)
##--------------------------------Themes-------------------------------##
self.Themes = []
##--------------------------------Links--------------------------------##
if GetElementText(data, "resources"):
links = etree.tostring(E.Links(),
pretty_print=True,
xml_declaration=True,
encoding="UTF-8")
links = XML.ElementFromString(links)
value = []
for externalentity in data.xpath("""./resources/resource/*"""):
for identifier in externalentity.xpath("""./identifier"""):
if externalentity.getparent().get("type") == "1":
SubElement(links,
"Link",
type="ANN",
url=constants.ANIDB_RESOURCES_ANN %
(identifier.text),
value=identifier.text)
elif externalentity.getparent().get("type") == "2":
SubElement(links,
"Link",
type="MAL",
url=constants.ANIDB_RESOURCES_MAL %
(identifier.text),
value=identifier.text)
elif externalentity.getparent().get("type") == "3":
value.append(identifier.text)
elif externalentity.getparent().get("type") == "4":
SubElement(links,
"Link",
type="OfficialJP",
url=identifier.text)
elif externalentity.getparent().get("type") == "5":
SubElement(links,
"Link",
type="OfficialEN",
url=identifier.text)
elif externalentity.getparent().get("type") == "6":
SubElement(links,
"Link",
type="WikiEN",
url=constants.ANIDB_RESOURCES_WIKIEN %
(identifier.text),
value=identifier.text)
elif externalentity.getparent().get("type") == "7":
SubElement(links,
"Link",
type="WikiJP",
url=constants.ANIDB_RESOURCES_WIKIJP %
(identifier.text),
value=identifier.text)
elif externalentity.getparent().get("type") == "8":
SubElement(links,
"Link",
type="Schedule",
url=constants.ANIDB_RESOURCES_SCHEDULE %
(identifier.text),
value=identifier.text)
elif externalentity.getparent().get("type") == "9":
SubElement(links,
"Link",
type="AllCinema",
url=constants.ANIDB_RESOURCES_ALLCINEMA %
(identifier.text),
value=identifier.text)
elif externalentity.getparent().get("type") == "10":
SubElement(links,
"Link",
type="Anison",
url=constants.ANIDB_RESOURCES_ANISON %
(identifier.text),
value=identifier.text)
elif externalentity.getparent().get("type") == "11":
SubElement(links,
"Link",
type="Lain",
url=constants.ANIDB_RESOURCES_LAIN %
(identifier.text),
value=identifier.text)
elif externalentity.getparent().get("type") == "14":
SubElement(links,
"Link",
type="VNDB",
url=constants.ANIDB_RESOURCES_VNDB %
(identifier.text),
value=identifier.text)
elif externalentity.getparent().get("type") == "15":
SubElement(links,
"Link",
type="Marumegane",
url=constants.ANIDB_RESOURCES_MARUMEGANE %
(identifier.text),
value=identifier.text)
if externalentity.getparent().get("type") == "3":
SubElement(links,
"Link",
type="AnimeNfo",
url=constants.ANIDB_RESOURCES_ANIMENFO %
(u"%s" % value[0], u"%s" % value[1]),
value=u"%s" % value)
self.Links = links
##--------------------------------EpisodeCount-------------------------##
self.EpisodeCount = int(GetElementText(data, "episodecount"))
##--------------------------------SpecialCount-------------------------##
self.SpecialCount = len(
data.xpath("""./episodes/episode/epno[@type="2"]"""))
##--------------------------------OP/ED_List---------------------------##
self.OpList = []
self.EdList = []
for specials in data.xpath(
"""./episodes/episode/epno[@type="3"]/.."""):
if functions.CleanTitle(
functions.GetPreferedTitleNoType(
specials.xpath("""./title"""))).startswith("Opening"):
self.OpList.append(str(GetElementText(specials, "epno")))
if functions.CleanTitle(
functions.GetPreferedTitleNoType(
specials.xpath("""./title"""))).startswith("Ending"):
self.EdList.append(str(GetElementText(specials, "epno")))
##--------------------------------Episodes-----------------------------##
if len(data.xpath("""./episodes/episode""")) > 0:
self.Episodes = []
for item in data.xpath("""./episodes/episode"""):
self.Episodes.append(self.Episode(item, id))
#Log("AniDB - __init__() - Populate Title: '%s', Network: '%s', Overview: '%s', FirstAired: '%s', Genre: '%s', ContentRating: '%s', Rating: '%s', Episodes: '%s', EpisodeCount: '%s', SpecialCount: '%s', OpCount: '%s', EdCount: '%s', Posters: '%s'"
#% (self.Title, self.Network, self.Overview, self.FirstAired, self.Genre, self.ContentRating, self.Rating, self.Episodes, self.EpisodeCount, self.SpecialCount, len(self.OpList), len(self.EdList), self.Posters) )
logging.Log_Milestone("AniDB" + "_" + id)
def Episode_Task(map=map,
metadata=metadata,
anidbId=anidbId,
tvdbId=tvdbId,
seasonNo=seasonNo):
season = str(int(map.getparent().get('num')) - seasonNo + 1)
#Log("SeasonNumber: %s, %s, %s" % (seasonNo, map.getparent().get('num'), str(int(map.getparent().get('num')) - seasonNo + 1)))
episode = map.get('num')
#Log("Episode: '%s', '%s', %s, %s" % (season, episode, anidbId, map.getparent().get('AnidbId')))
logging.Log_Milestone("MapMedia_Episode_S" + season + "E" +
episode)
metadata.seasons[season].episodes[
episode].title = functions.PopulateMetadata(
map.xpath("""./Title/*[node()]"""), str,
constants.EPISODE_TITLE_PRIORITY, None, "EpisodeTitle")
metadata.seasons[season].episodes[
episode].summary = functions.PopulateMetadata(
map.xpath("""./Summary/*[node()]"""), str,
constants.EPISODE_SUMMARY_PRIORITY)
metadata.seasons[season].episodes[
episode].originally_available_at = functions.PopulateMetadata(
map.xpath("""./Originally_Available_At/*[node()]"""),
datetime.date,
constants.EPISODE_ORIGINALLYAVAILABLEAT_PRIORITY)
metadata.seasons[season].episodes[
episode].rating = functions.PopulateMetadata(
map.xpath("""./Rating/*[node()]"""), float,
constants.EPISODE_RATING_PRIORITY)
metadata.seasons[season].episodes[
episode].absolute_index = functions.PopulateMetadata(
map.xpath("""./Absolute_Index/*[node()]"""), int,
constants.EPISODE_ABSOLUTE_INDEX_PRIORITY)
functions.PopulateMetadata(
map.xpath("""./Writers/*[node()]"""),
Framework.modelling.attributes.SetObject,
constants.EPISODE_WRITERS_PRIORITY,
metadata.seasons[season].episodes[episode].writers)
functions.PopulateMetadata(
map.xpath("""./Directors/*[node()]"""),
Framework.modelling.attributes.SetObject,
constants.EPISODE_DIRECTORS_PRIORITY,
metadata.seasons[season].episodes[episode].directors)
functions.PopulateMetadata(
map.xpath("""./Producers/*[node()]"""),
Framework.modelling.attributes.SetObject,
constants.EPISODE_PRODUCERS_PRIORITY,
metadata.seasons[season].episodes[episode].producers)
functions.PopulateMetadata(
map.xpath("""./Thumbs//Image"""),
Framework.modelling.attributes.ProxyContainerObject,
constants.EPISODE_THUMBS_PRIORITY,
metadata.seasons[season].episodes[episode].thumbs,
"Images")
if map.xpath(
"""count(./Streams/Stream[@type="%s"][@lang="%s"])""" %
("audio", "eng")
) > 0 and not "English Dubbed" in metadata.collections:
metadata.collections.add("English Dubbed")
streamTag.append("English Dubbed")
if map.xpath(
"""count(./Streams/Stream[@type="%s"][@lang="%s"])""" %
("audio", "jpn")) > 0 and map.xpath(
"""count(./Streams/Stream[@type="%s"][@lang="%s"])""" %
("subtitle", "eng")
) > 0 and not "English Subbed" in metadata.collections:
metadata.collections.add("English Subbed")
streamTag.append("English Subbed")
logging.Log_Milestone("MapMedia_Episode_S" + season + "E" +
episode)
def MapMedia(root, metadata, anidbId, tvdbId):
logging.Log_Milestone("MapMedia")
streamTag = []
seasonNo = 0
seasonMap = root.xpath("""./Season[@AnidbId="%s" and @num!="0"]""" %
(anidbId))
if not seasonMap:
seasonMap = root.xpath("""./Season[@TvdbId="%s" and @num!="0"]""" %
(tvdbId))
if seasonMap:
seasonMap = seasonMap[0]
seasonNo = int(seasonMap.get("num"))
#Log("Populate Season")
logging.Log_Milestone("MapMedia_Season")
metadata.title = functions.PopulateMetadata(
seasonMap.xpath("""./Title/*[node()]"""), str,
constants.SERIES_TITLE_PRIORITY)
metadata.summary = functions.PopulateMetadata(
seasonMap.xpath("""./Summary/*[node()]"""), str,
constants.SERIES_SUMMARY_PRIORITY)
metadata.originally_available_at = functions.PopulateMetadata(
seasonMap.xpath("""./Originally_Available_At/*[node()]"""),
datetime.date, constants.SERIES_ORIGINALLYAVAILABLEAT_PRIORITY)
metadata.rating = functions.PopulateMetadata(
seasonMap.xpath("""./Rating/*[node()]"""), float,
constants.SERIES_RATING_PRIORITY)
metadata.studio = functions.PopulateMetadata(
seasonMap.xpath("""./Studio/*[node()]"""), str,
constants.SERIES_STUDIO_PRIORITY)
functions.PopulateMetadata(seasonMap.xpath("""./Countries/*[node()]"""),
list, constants.SERIES_COUNTRIES_PRIORITY,
metadata.countries)
metadata.duration = functions.PopulateMetadata(
seasonMap.xpath("""./Duration/*[node()]"""), int,
constants.SERIES_DURATION_PRIORITY)
functions.PopulateMetadata(seasonMap.xpath("""./Genres/*[node()]"""), list,
constants.SERIES_GENRES_PRIORITY,
metadata.genres)
functions.PopulateMetadata(seasonMap.xpath("""./Tags/*[node()]"""), list,
constants.SERIES_TAGS_PRIORITY, metadata.tags)
functions.PopulateMetadata(seasonMap.xpath("""./Collections/*[node()]"""),
list, constants.SERIES_COLLECTIONS_PRIORITY,
metadata.collections)
metadata.content_rating = functions.PopulateMetadata(
seasonMap.xpath("""./Content_Rating/*[node()]"""), str,
constants.SERIES_CONTENTRATING_PRIORITY)
functions.PopulateMetadata(seasonMap.xpath("""./Roles/*[node()]"""),
Framework.modelling.attributes.SetObject,
constants.SERIES_ROLES_PRIORITY, metadata.roles)
functions.PopulateMetadata(
seasonMap.xpath("""./Posters//Image"""),
Framework.modelling.attributes.ProxyContainerObject,
constants.SERIES_IMAGES_PRIORITY, metadata.posters, "Images")
functions.PopulateMetadata(
seasonMap.xpath("""./Art//Image"""),
Framework.modelling.attributes.ProxyContainerObject,
constants.SERIES_IMAGES_PRIORITY, metadata.art, "Images")
functions.PopulateMetadata(
seasonMap.xpath("""./Banners//Image"""),
Framework.modelling.attributes.ProxyContainerObject,
constants.SERIES_IMAGES_PRIORITY, metadata.banners, "Images")
functions.PopulateMetadata(
seasonMap.xpath("""./Season//Image"""),
Framework.modelling.attributes.ProxyContainerObject,
constants.SERIES_IMAGES_PRIORITY, metadata.seasons, "Images")
functions.PopulateMetadata(
seasonMap.xpath("""./Themes//Theme"""),
Framework.modelling.attributes.ProxyContainerObject,
constants.SERIES_THEMES_PRIORITY, metadata.themes, "Themes")
logging.Log_Milestone("MapMedia_Season")
@parallelize
def Episode_Par():
for map in sorted(root.xpath(
"""./Season[@num>=%s or @num=0]/Episode""" % (seasonNo)),
key=lambda x: x.getparent().get("num"),
reverse=False):
@task
def Episode_Task(map=map,
metadata=metadata,
anidbId=anidbId,
tvdbId=tvdbId,
seasonNo=seasonNo):
season = str(int(map.getparent().get('num')) - seasonNo + 1)
#Log("SeasonNumber: %s, %s, %s" % (seasonNo, map.getparent().get('num'), str(int(map.getparent().get('num')) - seasonNo + 1)))
episode = map.get('num')
#Log("Episode: '%s', '%s', %s, %s" % (season, episode, anidbId, map.getparent().get('AnidbId')))
logging.Log_Milestone("MapMedia_Episode_S" + season + "E" +
episode)
metadata.seasons[season].episodes[
episode].title = functions.PopulateMetadata(
map.xpath("""./Title/*[node()]"""), str,
constants.EPISODE_TITLE_PRIORITY, None, "EpisodeTitle")
metadata.seasons[season].episodes[
episode].summary = functions.PopulateMetadata(
map.xpath("""./Summary/*[node()]"""), str,
constants.EPISODE_SUMMARY_PRIORITY)
metadata.seasons[season].episodes[
episode].originally_available_at = functions.PopulateMetadata(
map.xpath("""./Originally_Available_At/*[node()]"""),
datetime.date,
constants.EPISODE_ORIGINALLYAVAILABLEAT_PRIORITY)
metadata.seasons[season].episodes[
episode].rating = functions.PopulateMetadata(
map.xpath("""./Rating/*[node()]"""), float,
constants.EPISODE_RATING_PRIORITY)
metadata.seasons[season].episodes[
episode].absolute_index = functions.PopulateMetadata(
map.xpath("""./Absolute_Index/*[node()]"""), int,
constants.EPISODE_ABSOLUTE_INDEX_PRIORITY)
functions.PopulateMetadata(
map.xpath("""./Writers/*[node()]"""),
Framework.modelling.attributes.SetObject,
constants.EPISODE_WRITERS_PRIORITY,
metadata.seasons[season].episodes[episode].writers)
functions.PopulateMetadata(
map.xpath("""./Directors/*[node()]"""),
Framework.modelling.attributes.SetObject,
constants.EPISODE_DIRECTORS_PRIORITY,
metadata.seasons[season].episodes[episode].directors)
functions.PopulateMetadata(
map.xpath("""./Producers/*[node()]"""),
Framework.modelling.attributes.SetObject,
constants.EPISODE_PRODUCERS_PRIORITY,
metadata.seasons[season].episodes[episode].producers)
functions.PopulateMetadata(
map.xpath("""./Thumbs//Image"""),
Framework.modelling.attributes.ProxyContainerObject,
constants.EPISODE_THUMBS_PRIORITY,
metadata.seasons[season].episodes[episode].thumbs,
"Images")
if map.xpath(
"""count(./Streams/Stream[@type="%s"][@lang="%s"])""" %
("audio", "eng")
) > 0 and not "English Dubbed" in metadata.collections:
metadata.collections.add("English Dubbed")
streamTag.append("English Dubbed")
if map.xpath(
"""count(./Streams/Stream[@type="%s"][@lang="%s"])""" %
("audio", "jpn")) > 0 and map.xpath(
"""count(./Streams/Stream[@type="%s"][@lang="%s"])""" %
("subtitle", "eng")
) > 0 and not "English Subbed" in metadata.collections:
metadata.collections.add("English Subbed")
streamTag.append("English Subbed")
logging.Log_Milestone("MapMedia_Episode_S" + season + "E" +
episode)
logging.Log_Milestone("MapMedia")
def MapMeta(root):
logging.Log_Milestone("MapMeta")
providerList = [["Anidb"], ["Tvdb", "Plex"]]
@parallelize
def Providers_Par():
for providers in providerList:
@task
def Providers_Task(root=root, providers=providers):
@parallelize
def Provider_Par():
for provider in providers:
@task
def Provider_Task(root=root,
providers=providers,
provider=provider):
#Log("Provider: %s" %(providers))
data = None
for map in sorted(
root.xpath(
"""./Season/Episode/Mapped/%s""" %
(providers[0].lower())),
key=lambda x: int(
x.get("series") if x.get("series") and
x.get("series") != "None" else 0)):
if map.get("series"):
for existing in map.getparent().getparent(
).xpath(""".//%s""" % (providers[0])):
if not existing.getparent(
).tag == "Mapped":
existing.getparent().remove(
existing)
#Log("Provider: %s" %(provider))
if data == None or data.ID != map.get(
"series"
) or data.MetaType != provider:
if provider == "Anidb":
data = anidb.AniDB(
map.get("series"))
elif provider == "Tvdb":
data = tvdb.TvDB(map.get("series"))
elif provider == "Plex":
data = plex.Plex(map.get("series"))
if not map.getparent().getparent(
).getparent().get("%s" % provider + "Id"):
map.getparent().getparent().getparent(
).attrib["%s" % provider +
"Id"] = map.get("series")
for attrib in constants.SeriesAttribs:
if not map.getparent().getparent(
).getparent().xpath(
"""./%s/%s""" %
(attrib, provider)):
#Log("Provider: %s %s" %(provider, attrib))
if getattr(data, attrib):
if type(getattr(
data, attrib)) is type(
Element("None")):
elementList = copy.deepcopy(
getattr(data, attrib))
SubElement(
map.getparent().
getparent().getparent(
).find("""./%s""" %
(attrib)),
provider).extend(
elementList.
getchildren())
else:
elementItem = copy.copy(
getattr(data, attrib))
SubElement(
map.getparent().
getparent().getparent(
).find("""./%s""" %
(attrib)),
provider).text = (
u'%s' %
(elementItem))
for episode in data.Episodes:
if (
providers[0] == "Anidb"
and "%s" % (episode.Number)
== map.get("episode")
) or (providers[0] == "Tvdb"
and "S%sE%s" %
(episode.Season, episode.Number)
== map.get("episode")):
for attrib in constants.EpisodeAttribs:
#Log("Provider: %s %s" %(provider, attrib))
if getattr(episode, attrib):
if type(
getattr(
episode,
attrib)
) is type(Element("None")):
elementList = copy.deepcopy(
getattr(
episode,
attrib))
SubElement(
map.getparent(
).getparent().find(
"""./%s""" %
(attrib)),
provider).extend(
elementList)
else:
elementItem = copy.copy(
getattr(
episode,
attrib))
SubElement(
map.getparent(
).getparent().find(
"""./%s""" %
(attrib)),
provider).text = (
u'%s' %
(elementItem))
logging.Log_Milestone("MapMeta")
def MapSeries(mappingData):
#logging.Log_Milestone("MapSeries")
root = None
existing = None
#existing = functions.LoadFile(mappingData.FirstSeries + ".bundle.xml", "Bundles")
if existing:
#for item in media.
#SearchMap(season, episode, filename, root, anidbid=None)
root = XML.ElementFromString(existing)
if not root:
root = etree.tostring(E.Series(),
pretty_print=True,
xml_declaration=True,
encoding="UTF-8")
root = XML.ElementFromString(root)
if not existing:
Log.Debug("Common - MapSeries() - Generate Bundle %s" %
(len(mappingData.SeriesList)))
mapping = SubElement(root, "Mapping")
openingEpsNo = 101
endingEpsNo = 151
for item in mappingData.SeriesList if mappingData.SeriesList else []:
ScudLee = scudlee.ScudLee()
ScudLee.Load(item)
AniDB = None
AniDB = anidb.AniDB(ScudLee.AnidbId)
Log.Debug(
"Common - MapSeries() - AniDB ID: '%s', mappingcount: '%s', episodecount: '%s', specialCount: '%s', opCount: '%s', edCount: '%s'"
% (AniDB.ID, len(ScudLee.MappingList), AniDB.EpisodeCount,
AniDB.SpecialCount, len(AniDB.OpList), len(AniDB.EdList)))
seriesMap = SubElement(mapping,
"Series",
anidbid=str(ScudLee.AnidbId),
tvdbid=str(ScudLee.TvdbId),
episodeoffset=str(ScudLee.EpisodeOffset),
absolute=str(ScudLee.Absolute))
for season in ScudLee.MappingList:
Log("Common - MapSeries() - Season - AniDB: '%s', TvDB: '%s', Text: '%s'"
% (season.AnidbSeason, season.TvdbSeason, season.Text))
if season.Offset:
for i in range(season.Start, season.End + 1):
status = "scudlee missing"
tvdbParse = tvdb.ParseNoFromSeason(
0, 0, ScudLee.DefaultTvdbSeason)
if not mapping.xpath(
"""./Series/Episode[@tvdb="S%sE%s"]""" %
(season.TvdbSeason, str(i + int(season.Offset)))):
status = ""
tvdbParse = tvdb.ParseNoFromSeason(
int(season.TvdbSeason), i + int(season.Offset),
ScudLee.DefaultTvdbSeason)
SubElement(seriesMap,
"Episode",
anidb="%s" % (anidb.ParseNoFromSeason(
int(season.AnidbSeason), i)),
tvdb=tvdbParse,
status=status)
Log("Common - MapSeries() - Season - AniDB: '%s', TvDB: '%s'"
% (anidb.ParseNoFromSeason(int(season.AnidbSeason),
i), tvdbParse))
if season.Text != None:
for string in filter(None, season.Text.split(";")):
for i in range(0,
len(string.split("-")[1].split("+"))):
status = "scudlee missing"
tvdbParse = tvdb.ParseNoFromSeason(
0, 0, ScudLee.DefaultTvdbSeason)
if not mapping.xpath(
"""./Series/Episode[@tvdb="S%sE%s"]""" %
(season.TvdbSeason, string.split("-")
[1].split("+")[i].zfill(2))) and "S%sE%s" % (
season.TvdbSeason, string.split("-")
[1].split("+")[i].zfill(2)) != "S00E00":
status = ""
tvdbParse = tvdb.ParseNoFromSeason(
int(season.TvdbSeason),
int(string.split("-")[1].split("+")[i]),
ScudLee.DefaultTvdbSeason)
elif not mapping.xpath(
"""./Series/Episode[@tvdb="S%sE%s"]""" %
(season.TvdbSeason,
string.split("-")[1].split("+")[i].zfill(2))):
status = "tvdb missing"
SubElement(seriesMap,
"Episode",
anidb="%s" % (anidb.ParseNoFromSeason(
int(season.AnidbSeason),
string.split("-")[0])),
tvdb=tvdbParse,
status=status)
Log("Common - MapSeries() - Season - AniDB: '%s', TvDB: '%s'"
% (anidb.ParseNoFromSeason(
int(season.AnidbSeason),
string.split("-")[0]), tvdbParse))
if not ScudLee.Absolute:
for i in range(1, AniDB.EpisodeCount + 1):
status = "scudlee missing"
tvdbParse = "S00E00"
if not seriesMap.xpath("""./Episode[@anidb="%s"]""" %
(anidb.ParseNoFromSeason(1, i))):
if not mapping.xpath(
"""./Series/Episode[@tvdb="S%sE%s"]""" %
(str(ScudLee.DefaultTvdbSeason).zfill(2),
'S' + str(i + ScudLee.EpisodeOffset).zfill(2))):
status = ""
tvdbParse = "S%sE%s" % (
str(ScudLee.DefaultTvdbSeason).zfill(2),
str(i + ScudLee.EpisodeOffset).zfill(2))
SubElement(seriesMap,
"Episode",
anidb="%s" %
(anidb.ParseNoFromSeason(1, i)),
tvdb=tvdbParse,
status=status)
Log("Common - MapSeries() - Season - AniDB: '%s', TvDB: '%s'"
% (anidb.ParseNoFromSeason(1, i), tvdbParse))
for i in range(1, AniDB.SpecialCount + 1):
status = "scudlee missing"
tvdbParse = "S00E00"
if not seriesMap.xpath("""./Episode[@anidb="%s"]""" %
(anidb.ParseNoFromType(2, i))):
if not mapping.xpath(
"""./Series/Episode[@tvdb="S%sE%s"]""" %
("00", str(i + ScudLee.EpisodeOffset).zfill(2))):
status = ""
tvdbParse = "S%sE%s" % (
"00", str(i + ScudLee.EpisodeOffset).zfill(2))
SubElement(seriesMap,
"Episode",
anidb="%s" % (anidb.ParseNoFromType(2, i)),
tvdb=tvdbParse,
status=status)
Log("Common - MapSeries() - Season - AniDB: '%s', TvDB: '%s'"
% (anidb.ParseNoFromType(2, i), tvdbParse))
for opening in AniDB.OpList:
if not seriesMap.xpath("""./Episode[@anidb="%s"]""" %
(opening)):
SubElement(seriesMap,
"Episode",
anidb="%s" % (opening),
tvdb="%s" % (anidb.ParseLocalNoFromType(
3, openingEpsNo, "op")),
status="")
openingEpsNo = openingEpsNo + 1
for ending in AniDB.EdList:
if not seriesMap.xpath("""./Episode[@anidb="%s"]""" %
(ending)):
SubElement(
seriesMap,
"Episode",
anidb="%s" % (ending),
tvdb="%s" %
(anidb.ParseLocalNoFromType(3, endingEpsNo, "ed")),
status="")
endingEpsNo = endingEpsNo + 1
else:
TvDB = tvdb.TvDB(ScudLee.TvdbId)
for episode in TvDB.Episodes if TvDB.Episodes else []:
if episode.Absolute_Index:
if episode.Absolute_Index > ScudLee.EpisodeOffset and episode.Absolute_Index <= AniDB.EpisodeCount + ScudLee.EpisodeOffset:
SubElement(seriesMap,
"Episode",
anidb="%s" % (anidb.ParseNoFromSeason(
1, episode.Absolute_Index -
ScudLee.EpisodeOffset)),
tvdb="S%sE%s" %
(episode.Season, episode.Number),
status="")
Log("Common - MapSeries() - Season - AniDB: '%s', TvDB: 'S%sE%s'"
% (anidb.ParseNoFromSeason(
1, episode.Absolute_Index -
ScudLee.EpisodeOffset), episode.Season,
episode.Number))
seriesMap[:] = sorted(
seriesMap,
key=lambda x: (0
if re.sub('[^A-Z]', '', x.get("anidb")) else 1,
int(re.sub('[^0-9]', '', x.get("anidb")))))
unmappedlist = sorted(mapping.xpath(
"""./Series/Episode[@tvdb="S00E00" and @missing!=""]"""),
key=lambda x: x.getparent().get("anidbid"))
if unmappedlist:
unmapped = SubElement(mapping, "Unmapped")
i = 1
for episode in unmappedlist:
Log("Common - MapSeries() - Unmapped: '%s', '%s' , '%s'" %
(episode.getparent().get("anidbid"), episode.get("anidb"),
episode.get("missing")))
SubElement(unmapped,
"Episode",
anidbid=episode.getparent().get("anidbid"),
anidb=episode.get("anidb"),
missing=episode.get("missing"),
id=str(i))
i = i + 1
logging.Log_Milestone("MapSeries")
return root
def search(self, results, media, lang, manual=False):
Log.Debug(
"--- Search Begin -------------------------------------------------------------------------------------------"
)
logging.New_Milestones()
logging.Log_Milestone("WholeSearch")
common.RefreshData()
orig_title = media.show
if orig_title.startswith("clear-cache"): HTTP.ClearCache()
Log.Info(
"Init - Search() - Show: '%s', Title: '%s', name: '%s', filename: '%s', manual:'%s'"
%
(media.show, orig_title, media.name, urllib.unquote(media.filename)
if media.filename else "", str(manual)))
match = re.search(
"(?P<show>.*?) ?\[(?P<source>(.*))-(tt)?(?P<id>[0-9]{1,7})\]",
orig_title, re.IGNORECASE)
if match:
title = match.group("show")
source = match.group("source").lower()
if source in [
"anidb", "anidb2", "tvdb", "tvdb2", "tvdb3", "tvdb4",
"tvdb5"
]:
id = match.group("id")
startdate = None
if source in ["anidb", "anidb2"]:
title = functions.GetPreferedTitle(
common.GetAnimeTitleByID(id))
Log.Debug(
"Init - Search() - force - id: '%s-%s', title from id: '%s' provided in foldername: '%s'"
% (source, id, title, orig_title))
results.Append(
MetadataSearchResult(id="%s-%s" % (source, id),
name=title,
year=startdate,
lang=Locale.Language.English,
score=100))
return
else:
orig_title = functions.CleanTitle(title)
maxi = {}
elite = []
perfectScore = []
orig_title = functions.CleanTitle(orig_title)
@parallelize
def searchTitles():
for anime in common.GetAnimeTitleByName(orig_title):
@task
def scoreTitle(anime=anime,
maxi=maxi,
anidb=anidb,
perfectScore=perfectScore):
logging.Log_Milestone("Title")
anime = Titles(anime, orig_title)
logging.Log_Milestone("Title")
isValid = True
if (anime.Id in maxi
and maxi[anime.Id] <= anime.Score) or (not anime.Id
in maxi):
maxi[anime.Id] = anime.Score
else:
isValid = False
if isValid:
startdate = None
if (media.year and anime.Score >= 90):
show = anidb.AniDB(anime.Id)
if show:
try:
startdate = dateParse(
show.Originally_Available_At).year
except:
pass
if str(startdate) != str(media.year):
isValid = False
Log.Debug(
"Init - Search() - date: '%s', aired: '%s'"
% (media.year, startdate))
elite.append(isValid)
elif anime.Score >= 90:
elite.append(isValid)
if isValid:
if anime.Score == 100:
perfectScore.append(anime.Id)
Log.Debug(
"Init - Search() - find - id: '%s-%s', title: '%s', score: '%s'"
%
("anidb", anime.Id, anime.Title, anime.Score))
results.Append(
MetadataSearchResult(
id="%s-%s" % ("anidb", anime.Id),
name="%s [%s-%s]" %
(anime.Title, "anidb", anime.Id),
year=startdate,
lang=Locale.Language.English,
score=anime.Score))
if len(list(set(perfectScore))) > 1:
for result in results:
if result.score == 100:
show = anidb.AniDB(result.id.split("-")[1])
if show.Type != "TV Series":
result.score = result.score - 1
if len(elite) > 0 and not True in elite: del results[:]
results.Sort("score", descending=True)
logging.Log_Milestone("WholeSearch")
return
