def genCharacterReport(mainFrame, sp):
report = characterreport.CharacterReport(sp)
if not report.cinfo:
wx.MessageBox("No characters speaking found.", "Error", wx.OK,
mainFrame)
return
charNames = [character.name for character in report.cinfo]
charCheckBoxItems = list([misc.CheckBoxItem(name) for name in charNames])
dlg = misc.CheckBoxDlg(mainFrame, "Report type", report.inf,
"Information to include:", False, charCheckBoxItems,
"Characters to include:", True)
ok = False
if dlg.ShowModal() == wx.ID_OK:
ok = True
for i in range(len(report.cinfo)):
report.cinfo[i].include = charCheckBoxItems[i].selected
dlg.Destroy()
if not ok:
return
data = report.generate()
gutil.showTempPDF(data, sp.cfgGl, mainFrame)
def __init__(self, sp):
self.sp = sp
# list of SceneInfos
self.scenes = []
line = 0
while 1:
if line >= len(sp.lines):
break
startLine, endLine = sp.getSceneIndexesFromLine(line)
si = SceneInfo(sp)
si.read(sp, startLine, endLine)
self.scenes.append(si)
line = endLine + 1
# we don't use these, but ScriptReport does
lineSeq = [si.lines for si in self.scenes]
self.longestScene = max(lineSeq)
self.avgScene = sum(lineSeq) / float(len(self.scenes))
# information about what to include (and yes, the comma is needed
# to unpack the list)
self.INF_SPEAKERS, = range(1)
self.inf = []
for s in ["Speakers"]:
self.inf.append(misc.CheckBoxItem(s))
def genCharacterReport(mainFrame, sp):
report = characterreport.CharacterReport(sp)
if not report.cinfo:
wx.MessageBox("No Speaking Characters Found", "Error", wx.OK,
mainFrame)
return
charNames = []
for s in util.listify(report.cinfo, "name"):
charNames.append(misc.CheckBoxItem(s))
dlg = misc.CheckBoxDlg(mainFrame, "Report Type", report.inf,
"Information to include", False, charNames,
"Characters to include", True)
ok = False
if dlg.ShowModal() == wx.ID_OK:
ok = True
for i in range(len(report.cinfo)):
report.cinfo[i].include = charNames[i].selected
dlg.Destroy()
if not ok:
return
data = report.generate()
gutil.showTempPDF(data, sp.cfgGl, mainFrame)
def __init__(self, sr):
self.sp = sr.sp
# key = scene name, value = LocationInfo. note that multiple keys
# can point to the same LocationInfo.
locations = {}
# like locations, but this one stores per-scene information
self.scenes = {}
# make grouped scenes point to the same LocationInfos.
for sceneList in self.sp.locations.locations:
li = LocationInfo(self.sp)
for scene in sceneList:
locations[scene] = li
# merge scene information for locations and store scene
# information
for si in sr.scenes:
locations.setdefault(si.name, LocationInfo(self.sp)).addScene(si)
self.scenes.setdefault(si.name, LocationInfo(self.sp)).\
addScene(si)
# remove empty LocationInfos, sort them and store to a list
tmp = []
for li in locations.values():
if (len(li.scenes) > 0) and (li not in tmp):
tmp.append(li)
def cmpfunc(a, b):
return (a > b) - (a < b)
def sortFunc(o1, o2):
ret = cmpfunc(o2.lines, o1.lines)
if ret != 0:
return ret
else:
return cmpfunc(o1.scenes[0], o2.scenes[0])
tmp = sorted(tmp, key=functools.cmp_to_key(sortFunc))
self.locations = tmp
# information about what to include (and yes, the comma is needed
# to unpack the list)
self.INF_SPEAKERS, = list(range(1))
self.inf = []
for s in ["Speakers"]:
self.inf.append(misc.CheckBoxItem(s))
def genDialogueChart(mainFrame, sp):
# TODO: would be nice if this behaved like the other reports, i.e. the
# junk below would be inside the class, not outside. this would allow
# testcases to be written. only complication is the minLines thing
# which would need some thinking.
inf = []
for it in [("Characters with < 10 lines", None),
("Sorted by First Appearance", cmpFirst),
("Sorted by Last Appearance", cmpLast),
("Sorted by Number of Spoken Lines", cmpCount),
("Sorted by Name", cmpName)]:
inf.append(misc.CheckBoxItem(it[0], cdata=it[1]))
dlg = misc.CheckBoxDlg(mainFrame, "Report type", inf,
"Information to include", False)
if dlg.ShowModal() != wx.ID_OK:
dlg.Destroy()
return
dlg.Destroy()
minLines = 1
if not inf[0].selected:
minLines = 10
chart = DialogueChart(sp, minLines)
if not chart.cinfo:
wx.MessageBox("No Speaking Characters Found", "Error", wx.OK,
mainFrame)
return
del inf[0]
if len(misc.CheckBoxItem.getClientData(inf)) == 0:
wx.MessageBox("Can't Disable All Output", "Error", wx.OK, mainFrame)
return
data = chart.generate(inf)
gutil.showTempPDF(data, sp.cfgGl, mainFrame)
def __init__(self, sp):
self.sp = sp
ls = sp.lines
# key = character name, value = CharInfo
chars = {}
name = None
scene = "(NO SCENE NAME)"
# how many lines processed for current speech
curSpeechLines = 0
for i in xrange(len(ls)):
line = ls[i]
if (line.lt == screenplay.SCENE) and\
(line.lb == screenplay.LB_LAST):
scene = util.upper(line.text)
elif (line.lt == screenplay.CHARACTER) and\
(line.lb == screenplay.LB_LAST):
name = util.upper(line.text)
curSpeechLines = 0
elif line.lt in (screenplay.DIALOGUE, screenplay.PAREN) and name:
ci = chars.get(name)
if not ci:
ci = CharInfo(name, sp)
chars[name] = ci
if scene:
ci.scenes[scene] = ci.scenes.get(scene, 0) + 1
if curSpeechLines == 0:
ci.speechCnt += 1
curSpeechLines += 1
# PAREN lines don't count as spoken words
if line.lt == screenplay.DIALOGUE:
ci.lineCnt += 1
words = util.splitToWords(line.text)
ci.wordCnt += len(words)
ci.wordCharCnt += reduce(lambda x, y: x + len(y), words, 0)
ci.pages.addPage(sp.line2page(i))
else:
name = None
curSpeechLines = 0
# list of CharInfo objects
self.cinfo = []
for v in chars.values():
self.cinfo.append(v)
self.cinfo.sort(cmpLines)
self.totalSpeechCnt = self.sum("speechCnt")
self.totalLineCnt = self.sum("lineCnt")
self.totalWordCnt = self.sum("wordCnt")
self.totalWordCharCnt = self.sum("wordCharCnt")
# information types and what to include
self.INF_BASIC, self.INF_PAGES, self.INF_LOCATIONS = range(3)
self.inf = []
for s in ["Basic information", "Page list", "Location list"]:
self.inf.append(misc.CheckBoxItem(s))
def importFountain(fileName, frame):
# regular expressions for fountain markdown.
# https://github.com/vilcans/screenplain/blob/master/screenplain/richstring.py
ire = re.compile(
# one star
r'\*'
# anything but a space, then text
r'([^\s].*?)'
# finishing with one star
r'\*'
# must not be followed by star
r'(?!\*)')
bre = re.compile(
# two stars
r'\*\*'
# must not be followed by space
r'(?=\S)'
# inside text
r'(.+?[*_]*)'
# finishing with two stars
r'(?<=\S)\*\*')
ure = re.compile(
# underline
r'_'
# must not be followed by space
r'(?=\S)'
# inside text
r'([^_]+)'
# finishing with underline
r'(?<=\S)_')
boneyard_re = re.compile('/\\*.*?\\*/', flags=re.DOTALL)
# random magicstring used to escape literal star '\*'
literalstar = "Aq7RR"
# returns s with markdown formatting removed.
def unmarkdown(s):
s = s.replace("\\*", literalstar)
for style in (bre, ire, ure):
s = style.sub(r'\1', s)
return s.replace(literalstar, "*")
data = util.loadFile(fileName, frame, 1000000)
if data == None:
return None
if len(data) == 0:
wx.MessageBox("File is empty.", "Error", wx.OK, frame)
return None
inf = []
inf.append(misc.CheckBoxItem("Import titles as action lines."))
inf.append(misc.CheckBoxItem("Remove unsupported formatting markup."))
inf.append(misc.CheckBoxItem("Import section/synopsis as notes."))
dlg = misc.CheckBoxDlg(frame, "Fountain import options", inf,
"Import options:", False)
if dlg.ShowModal() != wx.ID_OK:
dlg.Destroy()
return None
importTitles = inf[0].selected
removeMarkdown = inf[1].selected
importSectSyn = inf[2].selected
# pre-process data - fix newlines, remove boneyard.
data = util.fixNL(data)
data = boneyard_re.sub('', data)
prelines = data.split("\n")
for i in xrange(len(prelines)):
try:
util.toLatin1(prelines[i])
except:
prelines[i] = util.cleanInput(
u"" + prelines[i].decode('UTF-8', "ignore"))
lines = []
tabWidth = 4
lns = []
sceneStartsList = ("INT", "EXT", "EST", "INT./EXT", "INT/EXT", "I/E",
"I./E")
TWOSPACE = " "
skipone = False
# First check if title lines are present:
c = 0
while c < len(prelines):
if prelines[c] != "":
c = c + 1
else:
break
# prelines[0:i] are the first bunch of lines, that could be titles.
# Our check for title is simple:
# - the line does not start with 'fade'
# - the first line has a single ':'
if c > 0:
l = util.toInputStr(prelines[0].expandtabs(tabWidth).lstrip().lower())
if not l.startswith("fade") and l.count(":") == 1:
# these are title lines. Now do what the user requested.
if importTitles:
# add TWOSPACE to all the title lines.
for i in xrange(c):
prelines[i] += TWOSPACE
else:
#remove these lines
prelines = prelines[c + 1:]
for l in prelines:
if l != TWOSPACE:
lines.append(util.toInputStr(l.expandtabs(tabWidth)))
else:
lines.append(TWOSPACE)
linesLen = len(lines)
def isPrevEmpty():
if lns and lns[-1].text == "":
return True
return False
def isPrevType(ltype):
return (lns and lns[-1].lt == ltype)
# looks ahead to check if next line is not empty
def isNextEmpty(i):
return (i + 1 < len(lines) and lines[i + 1] == "")
def getPrevType():
if lns:
return lns[-1].lt
else:
return screenplay.ACTION
def isParen(s):
return (s.startswith('(') and s.endswith(')'))
def isScene(s):
if s.endswith(TWOSPACE):
return False
if s.startswith(".") and not s.startswith(".."):
return True
tmp = s.upper()
if (re.match(r'^(INT|EXT|EST)[ .]', tmp)
or re.match(r'^(INT\.?/EXT\.?)[ .]', tmp)
or re.match(r'^I/E[ .]', tmp)):
return True
return False
def isTransition(s):
return ((s.isupper() and s.endswith("TO:"))
or (s.startswith(">") and not s.endswith("<")))
def isCentered(s):
return s.startswith(">") and s.endswith("<")
def isPageBreak(s):
return s.startswith('===') and s.lstrip('=') == ''
def isNote(s):
return s.startswith("[[") and s.endswith("]]")
def isSection(s):
return s.startswith("#")
def isSynopsis(s):
return s.startswith("=") and not s.startswith("==")
# first pass - identify linetypes
for i in range(linesLen):
if skipone:
skipone = False
continue
s = lines[i]
sl = s.lstrip()
# mark as ACTION by default.
line = screenplay.Line(screenplay.LB_FORCED, screenplay.ACTION, s)
# Start testing lines for element type. Go in order:
# Scene Character, Paren, Dialog, Transition, Note.
if s == "" or isCentered(s) or isPageBreak(s):
# do nothing - import as action.
pass
elif s == TWOSPACE:
line.lt = getPrevType()
elif isScene(s):
line.lt = screenplay.SCENE
if sl.startswith('.'):
line.text = sl[1:]
else:
line.text = sl
elif isTransition(sl) and isPrevEmpty() and isNextEmpty(i):
line.lt = screenplay.TRANSITION
if line.text.startswith('>'):
line.text = sl[1:].lstrip()
elif s.isupper() and isPrevEmpty() and not isNextEmpty(i):
line.lt = screenplay.CHARACTER
if s.endswith(TWOSPACE):
line.lt = screenplay.ACTION
elif isParen(sl) and (isPrevType(screenplay.CHARACTER)
or isPrevType(screenplay.DIALOGUE)):
line.lt = screenplay.PAREN
elif (isPrevType(screenplay.CHARACTER)
or isPrevType(screenplay.DIALOGUE)
or isPrevType(screenplay.PAREN)):
line.lt = screenplay.DIALOGUE
elif isNote(sl):
line.lt = screenplay.NOTE
line.text = sl.strip('[]')
elif isSection(s) or isSynopsis(s):
if not importSectSyn:
if isNextEmpty(i):
skipone = True
continue
line.lt = screenplay.NOTE
line.text = sl.lstrip('=#')
if line.text == TWOSPACE:
pass
elif line.lt != screenplay.ACTION:
line.text = line.text.lstrip()
else:
tmp = line.text.rstrip()
# we don't support center align, so simply add required indent.
if isCentered(tmp):
tmp = tmp[1:-1].strip()
width = frame.panel.ctrl.sp.cfg.getType(
screenplay.ACTION).width
if len(tmp) < width:
tmp = ' ' * ((width - len(tmp)) // 2) + tmp
line.text = tmp
if removeMarkdown:
line.text = unmarkdown(line.text)
if line.lt == screenplay.CHARACTER and line.text.endswith('^'):
line.text = line.text[:-1]
lns.append(line)
ret = []
# second pass helper functions.
def isLastLBForced():
return ret and ret[-1].lb == screenplay.LB_FORCED
def makeLastLBLast():
if ret:
ret[-1].lb = screenplay.LB_LAST
def isRetPrevType(t):
return ret and ret[-1].lt == t
# second pass - remove unneeded empty lines, and fix the linebreaks.
for ln in lns:
if ln.text == '':
if isLastLBForced():
makeLastLBLast()
else:
ret.append(ln)
elif not isRetPrevType(ln.lt):
makeLastLBLast()
ret.append(ln)
else:
ret.append(ln)
makeLastLBLast()
return ret
