128af4521b
git-svn-id: http://comictagger.googlecode.com/svn/trunk@623 6c5673fe-1810-88d6-992b-cd32ca31540c
257 lines
7.0 KiB
Python
257 lines
7.0 KiB
Python
"""
|
|
Functions for parsing comic info from filename
|
|
|
|
This should probably be re-written, but, well, it mostly works!
|
|
|
|
"""
|
|
|
|
"""
|
|
Copyright 2012 Anthony Beville
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
"""
|
|
|
|
|
|
# Some portions of this code were modified from pyComicMetaThis project
|
|
# http://code.google.com/p/pycomicmetathis/
|
|
|
|
import re
|
|
import os
|
|
from urllib import unquote
|
|
|
|
class FileNameParser:
|
|
|
|
def repl(self, m):
|
|
return ' ' * len(m.group())
|
|
|
|
def fixSpaces( self, string, remove_dashes=True ):
|
|
if remove_dashes:
|
|
placeholders = ['[-_]',' +']
|
|
else:
|
|
placeholders = ['[_]',' +']
|
|
for ph in placeholders:
|
|
string = re.sub(ph, self.repl, string )
|
|
return string #.strip()
|
|
|
|
# check for silly .1 or .5 style issue strings
|
|
# allow up to 5 chars total
|
|
def isPointIssue( self, word ):
|
|
ret = False
|
|
try:
|
|
float(word)
|
|
if (len(word) < 5 and not word.isdigit()):
|
|
ret = True
|
|
except ValueError:
|
|
pass
|
|
return ret
|
|
|
|
|
|
def getIssueCount( self,filename ):
|
|
|
|
count = ""
|
|
# replace any name seperators with spaces
|
|
tmpstr = self.fixSpaces(filename)
|
|
found = False
|
|
|
|
match = re.search('(?<=\sof\s)\d+(?=\s)', tmpstr, re.IGNORECASE)
|
|
if match:
|
|
count = match.group()
|
|
found = True
|
|
|
|
if not found:
|
|
match = re.search('(?<=\(of\s)\d+(?=\))', tmpstr, re.IGNORECASE)
|
|
if match:
|
|
count = match.group()
|
|
found = True
|
|
|
|
|
|
count = count.lstrip("0")
|
|
|
|
return count
|
|
|
|
def getIssueNumber( self, filename ):
|
|
|
|
# Returns a tuple of issue number string, and start and end indexs in the filename
|
|
# (The indexes will be used to split the string up for further parsing)
|
|
|
|
found = False
|
|
issue = ''
|
|
start = 0
|
|
end = 0
|
|
|
|
# first, look for multiple "--", this means it's formatted differently from most:
|
|
if "--" in filename:
|
|
# the pattern seems to be that anything to left of the first "--" is the series name followed by issue
|
|
filename = re.sub("--.*", self.repl, filename)
|
|
|
|
elif "__" in filename:
|
|
# the pattern seems to be that anything to left of the first "__" is the series name followed by issue
|
|
filename = re.sub("__.*", self.repl, filename)
|
|
|
|
filename = filename.replace("+", " ")
|
|
|
|
# replace parenthetical phrases with spaces
|
|
filename = re.sub( "\(.*?\)", self.repl, filename)
|
|
filename = re.sub( "\[.*?\]", self.repl, filename)
|
|
|
|
# replace any name seperators with spaces
|
|
filename = self.fixSpaces(filename)
|
|
|
|
# remove any "of NN" phrase with spaces (problem: this might break some titles)
|
|
filename = re.sub( "of [\d]+", self.repl, filename)
|
|
|
|
print u"[{0}]".format(filename)
|
|
|
|
# we should now have a cleaned up filename version with all the words in
|
|
# the same positions as original filename
|
|
|
|
# make a list of each word and its position
|
|
word_list = list()
|
|
for m in re.finditer("\S+", filename):
|
|
word_list.append( (m.group(0), m.start(), m.end()) )
|
|
|
|
# Now try to search for the likely issue number word in the list
|
|
|
|
# first look for a word with "#" followed by digits with optional sufix
|
|
# this is almost certainly the issue number
|
|
for w in reversed(word_list):
|
|
if re.match("#[-]?(([0-9]*\.[0-9]+|[0-9]+)(\w*))", w[0]):
|
|
found = True
|
|
break
|
|
|
|
# same as above but w/o a '#'
|
|
if not found:
|
|
for w in reversed(word_list):
|
|
if re.match("[-]?(([0-9]*\.[0-9]+|[0-9]+)(\w*))", w[0]):
|
|
found = True
|
|
break
|
|
|
|
# now try to look for a # followed by any characters
|
|
if not found:
|
|
for w in reversed(word_list):
|
|
if re.match("#\w+", w[0]):
|
|
found = True
|
|
break
|
|
|
|
if found:
|
|
issue = w[0]
|
|
start = w[1]
|
|
end = w[2]
|
|
if issue[0] == '#':
|
|
issue = issue[1:]
|
|
|
|
return issue, start, end
|
|
|
|
def getSeriesName(self, filename, issue_start ):
|
|
|
|
# use the issue number string index to split the filename string
|
|
|
|
filename = filename[:issue_start-1]
|
|
|
|
filename = filename.replace("+", " ")
|
|
tmpstr = self.fixSpaces(filename, remove_dashes=False)
|
|
|
|
series = tmpstr
|
|
volume = ""
|
|
|
|
#save the last word
|
|
last_word = series.split()[-1]
|
|
|
|
# remove any parenthetical phrases
|
|
series = re.sub( "\(.*?\)", "", series)
|
|
|
|
# search for volume number
|
|
match = re.search('(.+)([vV]|[Vv][oO][Ll]\.?\s?)(\d+)\s*$', series)
|
|
if match:
|
|
series = match.group(1)
|
|
volume = match.group(3)
|
|
|
|
# if a volume wasn't found, see if the last word is a year in parentheses
|
|
# since that's a common way to designate the volume
|
|
if volume == "":
|
|
#match either (YEAR), (YEAR-), or (YEAR-YEAR2)
|
|
match = re.search("(\()(\d{4})(-(\d{4}|)|)(\))", last_word)
|
|
if match:
|
|
volume = match.group(2)
|
|
|
|
|
|
return series.strip(), volume.strip()
|
|
|
|
def getYear( self,filename, issue_end):
|
|
|
|
filename = filename[issue_end:]
|
|
|
|
year = ""
|
|
# look for four digit number with "(" ")" or "--" around it
|
|
match = re.search('(\(\d\d\d\d\))|(--\d\d\d\d--)', filename)
|
|
if match:
|
|
year = match.group()
|
|
# remove non-numerics
|
|
year = re.sub("[^0-9]", "", year)
|
|
return year
|
|
|
|
def getRemainder( self, filename, year, count ):
|
|
#make a guess at where the the non-interesting stuff begins
|
|
|
|
remainder = ""
|
|
|
|
if "--" in filename:
|
|
remainder = filename.split("--",1)[1]
|
|
elif "__" in filename:
|
|
remainder = filename.split("__",1)[1]
|
|
elif "(" in filename:
|
|
remainder = "(" + filename.split("(",1)[1]
|
|
|
|
remainder = self.fixSpaces(remainder, remove_dashes=False)
|
|
if year != "":
|
|
remainder = remainder.replace(year,"",1)
|
|
if count != "":
|
|
remainder = remainder.replace("of "+count,"",1)
|
|
|
|
remainder = remainder.replace("()","")
|
|
|
|
return remainder.strip()
|
|
|
|
def parseFilename( self, filename ):
|
|
|
|
# remove the path
|
|
filename = os.path.basename(filename)
|
|
|
|
# remove the extension
|
|
filename = os.path.splitext(filename)[0]
|
|
|
|
#url decode, just in case
|
|
filename = unquote(filename)
|
|
|
|
# sometimes archives get messed up names from too many decodings
|
|
# often url encodings will break and leave "_28" and "_29" in place
|
|
# of "(" and ")" see if there are a number of these, and replace them
|
|
if filename.count("_28") > 1 and filename.count("_29") > 1:
|
|
filename = filename.replace("_28", "(")
|
|
filename = filename.replace("_29", ")")
|
|
|
|
self.issue, issue_start, issue_end = self.getIssueNumber(filename)
|
|
self.series, self.volume = self.getSeriesName(filename, issue_start)
|
|
self.year = self.getYear(filename, issue_end)
|
|
self.issue_count = self.getIssueCount(filename)
|
|
self.remainder = self.getRemainder( filename, self.year, self.issue_count )
|
|
|
|
if self.issue != "":
|
|
# strip off leading zeros
|
|
self.issue = self.issue.lstrip("0")
|
|
if self.issue == "":
|
|
self.issue = "0"
|
|
if self.issue[0] == ".":
|
|
self.issue = "0" + self.issue
|
|
|