def main(window):
# shortcuts for callbacks
jump_callback = lambda event: move(event, frog, window.width, window.height)
move_callback = lambda event: move(event, frog, window.width, window.height, draw=True)
turn_callback = lambda event: move(event, frog, window.width, window.height, turnonly=True)
# create a new frog
frog = Frog(window)
frog.shape = 'frog'
frog.bodycolor = 'green'
# let the frog jump and turn it, if necessary
window.listen('<Key-Up>', jump_callback)
window.listen('<Key-Down>', jump_callback)
window.listen('<Key-Left>', jump_callback)
window.listen('<Key-Right>', jump_callback)
# move the frog and turn it, if necessary
window.listen('<Shift-Key-Up>', move_callback)
window.listen('<Shift-Key-Down>', move_callback)
window.listen('<Shift-Key-Left>', move_callback)
window.listen('<Shift-Key-Right>', move_callback)
# turn the frog without moving it
window.listen('<Control-Key-Up>', turn_callback)
window.listen('<Control-Key-Down>', turn_callback)
window.listen('<Control-Key-Left>', turn_callback)
window.listen('<Control-Key-Right>', turn_callback)
# "write" a dot with space
window.listen('<space>', lambda event: frog.dot())
# you can quit the game by clicking `q` or [Esc]
window.listen('<Key-Escape>', lambda e: window.quit())
window.listen('<Key-q>', lambda e: window.quit())
def morph_counts_new_version(self, words):
#Word List to list of all morphisms
frog = Frog(FrogOptions(tok=True, lemma=True, morph=True, daringmorph=False, mwu=False, chunking=False, ner=False,parser=False))
words_string = ' '.join(words)
morphisms = []
print_counter = 1
t0 = time.time()
print("Starting Frog Processing..")
output = frog.process(words_string)
print("Process time:")
process_time = self.format_time(time.time() - t0)
print(process_time)
t1 = time.time()
for i in range(0,len(words)-1):
morphisms_word = output[i].get("morph")
morphisms_word_list = morphisms_word.replace('[', '').split(']')
#Momenteel GEEN GEHELE WOORDEN IN COUNT
if len(morphisms_word_list) > 2:
morphisms += morphisms_word_list
total_length = len(words)
print(str(print_counter) + " of " + str(total_length))
print_counter += 1
print("Process Time:")
print(process_time)
print("Getting Morphisms Time:")
print(self.format_time(time.time() - t1))
print("Total Time:")
print(self.format_time(time.time() - t0))
morphisms = list(filter(None, morphisms))
morph_counts = Counter(morphisms)
return morph_counts
def __init__(self, width, height, controller, weightIndex=None):
self.justDied = False
self.forceUpdate = False
self.weightIndex = weightIndex
self.localTrainMode = TRAIN_MODE or GATHER_STATS # start in train mode if GATHER_STATS
self.setUpdateIntervals(self.localTrainMode)
self.width = width
self.height = height
self.boardHeight = int(1.5 * height) # buffers 50% of board
self.player = Frog(int(width / 2), int(height - 1))
self.controller = controller
self.controller.loadWeights()
self.rowOptions = 2 * ["SAFE"] + 10 * ["ROAD"] + ["RIVER"]
# open logging file
if GATHER_STATS:
self.logfile = open('log.txt', 'w')
self.logfile.write("TRAINING DATA FOR " +
self.controller.id.upper() + " USING " +
FEATURE_EXTRACTOR.__name__.upper() + "\n")
# initialize game
self.startNewGame()
# for drawing
self.surf = pygame.display.set_mode(
(self.width * BLOCK_SIZE, self.height * BLOCK_SIZE),
pygame.HWSURFACE)
pygame.font.init()
self.score_font = pygame.font.SysFont("monospace", 20)
# set game to running
self.running = True
def play_game(screen):
frog = Frog(FROG_IMAGE)
cars = create_cars()
cars_2 = create_cars()
cars.extend(cars_2)
score = Display(color='white', x=-450, y=350)
game_over = Display('white', 0, 0)
while True:
score.display_score(frog.lvl)
for car in cars:
car.forward(car.speed)
frog.move(screen)
teleport(car)
if (frog.frog_passed_lvl(LIMIT_UP)):
random_car = random.choice(cars)
random_car.speed += 1
change_car_positions(cars)
if car.run_over_frog(frog):
game_over.display_game_over()
return
screen.update()
time.sleep(0.01)
def morph_counts_old_version(self, words):
#Word List to list of all morphisms
print("len words: ")
print(len(words))
print("len unique words: ")
print(len(set(words)))
frog = Frog(
FrogOptions(tok=True,
lemma=True,
morph=True,
daringmorph=False,
mwu=False,
chunking=False,
ner=False,
parser=False))
morphisms = []
print_counter = 1
t0 = time.time()
for word in words:
output = frog.process(word)
morphisms_word = output[0].get("morph")
morphisms_word_list = morphisms_word.replace('[', '').split(']')
#Momenteel GEEN GEHELE WOORDEN IN COUNT
if len(morphisms_word_list) > 2:
morphisms += morphisms_word_list
total_length = len(words)
print(str(print_counter) + " of " + str(total_length))
print_counter += 1
print("Frog Processing Time:")
print(self.format_time(time.time() - t0))
morphisms = list(filter(None, morphisms))
morph_counts = Counter(morphisms)
return morph_counts
def prep_nl(df, filename):
from frog import Frog, FrogOptions
print("Tokenizing, POS tagging, and lemmatizing the Dutch data...")
# Create 'frog' instance. Turn off various options to save time.
frog = Frog(
FrogOptions(parser=False, morph=False, chunking=False, ner=False))
# Define set of possible answers
if not "STAT_C" in str(filename):
answers = ['Answer']
elif "STAT_C" in str(filename):
answers = ['Answer4a', 'Answer2aDec', 'Answer2aCaus']
# Loop through answers
for question_type in answers:
for index in df.index:
ans = df.loc[index, question_type]
# Logging
if index % 20 == 0:
print(index, "/", df.index[-1], question_type[6:])
# Remove numbers
ans = re.sub("\d+", "", ans)
# Remove tags in spelling-corrected data
ans = ans.replace("_abbreviation", "")
# Remove non-Dutch and illegible words
ans = re.sub("\w+_nonexistent", "", ans)
ans = re.sub("\w+_nonexisting", "", ans)
ans = re.sub("\w+_english", "", ans)
ans = re.sub("\w+_german", "", ans)
ans = re.sub("\?+_illegible", "", ans)
# Preprocess the data with Frog
ans_dict = frog.process(ans)
tok_answer = []
lem_answer = []
pos_tags = []
# Append outcomes to list
for word_index in range(len(ans_dict)):
if ans_dict[word_index][
'pos'] != "LET()": # Exclude punctuation
tok_answer.append(ans_dict[word_index]['text'].lower())
lem_answer.append(ans_dict[word_index]['lemma'])
pos_tags.append(ans_dict[word_index]['pos'])
# Fill in the dataframe
df.at[index, 'Tokenized{}'.format(question_type[6:])] = tok_answer
df.at[index, 'Lemmatized{}'.format(question_type[6:])] = lem_answer
df.at[index, 'POS{}'.format(question_type[6:])] = pos_tags
return df
def morph_counts_faster_version(self, words):
#Word List to list of all morphisms
frog = Frog(FrogOptions(tok=True, lemma=True, morph=True, daringmorph=False, mwu=False, chunking=False, ner=False,parser=False))
batch_size = 400
morphisms = []
print_batch_number = 1
start_time = time.time()
total_batch_number = math.ceil(len(words)/batch_size)
total_process_time = 0
total_getting_morphisms_time = 0
for i in range(0, len(words), batch_size):
t0 = time.time()
#print_counter = 1
words_batch = words[i:i + batch_size]
words_batch_string = ' '.join(words_batch)
#print("Starting Frog Processing.. for batch = " + str(print_batch_number))
output = frog.process(words_batch_string)
#print("Process time:")
process_time = time.time() - t0
#print(self.format_time(process_time))
#print(process_time)
t1 = time.time()
for j in range(0,len(words_batch)-1):
morphisms_word = output[j].get("morph")
morphisms_word_list = morphisms_word.replace('[', '').split(']')
#Momenteel GEEN GEHELE WOORDEN IN COUNT
if len(morphisms_word_list) > 2:
morphisms += morphisms_word_list
total_batch_length = len(words_batch)
#print(str(print_counter) + " of " + str(total_batch_length) + " -- of batch -- " + str(print_batch_number) + " of " + str(total_batch_number) )
#print("batch" + " (batch_size: " + str(batch_size) + " words): " + str(print_batch_number) + " of " + str(total_batch_number))
#print_counter += 1
print_batch_number += 1
getting_morphisms_time = time.time() - t1
total_process_time += process_time
total_getting_morphisms_time += getting_morphisms_time
print("Total number of words: ")
print(len(words))
print("")
print("Unique number words: ")
print(len(set(words)))
print("")
print("Total Process Time:")
print(self.format_time(total_process_time))
print("")
print("Total Getting Morphisms Time: ")
print(self.format_time(total_getting_morphisms_time))
print("")
print("Total Time:")
print(self.format_time(time.time() - start_time))
print("")
morphisms = list(filter(None, morphisms))
morph_counts = Counter(morphisms)
return morph_counts
def test_get_range_circle_returns_circle_of_correct_size(self):
# arrange
position = Point(2, 2)
max_jump = 3
frog = Frog(position, 3, 0)
# act
range_circle = frog.get_range_circle()
# assert
assert range_circle.radius == max_jump
def test_find_possible_lilly_pads_returns_empty_list_when_none_are_available(
self):
# arrange
position = Point(20, 20)
frog = Frog(position, 1, 0)
pad = LillyPad(Point(2, 4), 1)
# act
possible_pads = frog._find_possible_lilly_pads([pad])
# assert
assert len(possible_pads) == 0
def __populate(self):
self.pop = [ Frog(function=self.ff,
constraints=self.constraints)
for i in range(self.n)]
for idx, f in enumerate(self.pop):
while f.current_fit.ret == 0:
f = Frog(function=self.ff,
constraints=self.constraints)
self.pop[idx] = f
def test_find_possible_pads_returns_no_pads_if_nearby_pad_occupied(self):
# arrange
position = Point(2, 2)
frog = Frog(position, 5, 0)
pad = LillyPad(Point(2, 4), 1)
pad.currently_occupied = True
# act
possible_pads = frog._find_possible_lilly_pads([pad])
# assert
assert len(possible_pads) == 0
def test_move_to_lilly_pad_updates_frog_current_lilly_pad(self):
# arrange
mock_pad = mock.create_autospec(LillyPad)
mock_pad.circle = Circle(Point(0, 0), 3)
position = Point(2, 2)
frog = Frog(position, 1, 0)
# act
frog._move_to_lilly_pad(mock_pad)
# assert
assert frog.current_lilly_pad == mock_pad
def test_find_possible_lilly_pads_returns_list_of_lilly_pads_when_some_are_available(
self):
# arrange
position = Point(2, 2)
frog = Frog(position, 1, 0)
pad = LillyPad(Point(2, 4), 1)
# act
possible_pads = frog._find_possible_lilly_pads([pad])
# assert
assert pad in possible_pads
def test_move_to_lilly_pad_calls_lilly_pad_visit_method(self):
# arrange
mock_pad = mock.create_autospec(LillyPad)
mock_pad.circle = Circle(Point(0, 0), 3)
position = Point(2, 2)
frog = Frog(position, 1, 0)
# act
frog._move_to_lilly_pad(mock_pad)
# assert
assert mock_pad.visit.called
def test_move_to_lilly_pad_calls_leave_on_current_lilly_pad(self):
# arrange
mock_current_pad = mock.create_autospec(LillyPad)
mock_dest_pad = mock.create_autospec(LillyPad)
mock_dest_pad.circle = Circle(Point(0, 0), 3)
position = Point(2, 2)
frog = Frog(position, 1, 0)
frog.current_lilly_pad = mock_current_pad
# act
frog._move_to_lilly_pad(mock_dest_pad)
# assert
assert mock_current_pad.leave.called
def test_find_centre_lilly_pad_returns_lilly_pad_where_centre_is_true(
self):
# arrange
frog = Frog(Point(2, 2), 3, 0)
pad1 = mock.create_autospec(LillyPad)
pad1.centre_pad = False
pad2 = mock.create_autospec(LillyPad)
pad2.centre_pad = True
# act
centre_pad = frog._find_centre_lilly_pad([pad1, pad2])
# assert
assert centre_pad == pad2
def change_text_to_morphs(sentences,
frog_merge=False,
save=False,
filename=None):
# sentence list to sentence list in frog morphism form
morphSentences = []
frog = Frog(
FrogOptions(tok=True,
lemma=True,
morph=True,
daringmorph=False,
mwu=False,
chunking=False,
ner=False,
parser=False))
for sentenceNumber in range(0, len(sentences)):
print(sentenceNumber)
print("of")
print(len(sentences))
sentenceToBeProcessed = sentences[sentenceNumber]
sentenceToBeProcessed = sentenceToBeProcessed.replace("\n", " ")
morphSentence = []
output = frog.process(sentenceToBeProcessed)
for i in range(0, len(output)):
morphisms_word = output[i].get("morph")
morphisms_word_list = morphisms_word.replace('[', '').split(']')
if frog_merge:
morphisms_word_list = list(filter(None, morphisms_word_list))
morphisms_word_list = intersperse(morphisms_word_list,
"insertmergetoken")
#print(morphisms_word_list)
#print("EVET")
#print(morphisms_word_list)
morphSentence += morphisms_word_list
#print("MORPHSENTENCE")
#print(morphSentence)
# Remove the empty strings
morphSentence = list(filter(None, morphSentence))
#print("ok")
#print(morphSentence)
morphSentence = ' '.join(morphSentence)
#print("HERE")
#print(morphSentence)
morphSentences.append(morphSentence)
if save is True:
with open(filename, 'wb') as outputfile:
pickle.dump(morphSentences, outputfile)
return morphSentences
def change_text_to_morphs(sentences,
frog_merge=False,
save=False,
filename=None):
# sentence list to sentence list in frog morphism form
morphSentences = []
frog = Frog(
FrogOptions(tok=True,
lemma=True,
morph=True,
daringmorph=False,
mwu=False,
chunking=False,
ner=False,
parser=False))
j = 0
for sentenceToBeProcessed in sentences:
if j % 1000 == 0:
print(j + 1)
print("of")
print(len(sentences))
j += 1
sentenceToBeProcessed = sentenceToBeProcessed.rstrip('\n')
morphSentence = []
output = frog.process(sentenceToBeProcessed)
for i in range(0, len(output)):
morphisms_word = output[i].get("morph")
morphisms_word_list = morphisms_word.replace('[', '').split(']')
if frog_merge:
morphisms_word_list = list(filter(None, morphisms_word_list))
morphisms_word_list = intersperse(morphisms_word_list,
"__add_merge__")
morphSentence += morphisms_word_list
# Remove the empty strings
morphSentence = list(filter(None, morphSentence))
morphSentence = ' '.join(morphSentence)
morphSentences.append(morphSentence)
if save is True:
with open(filename, 'wb') as outputfile:
pickle.dump(morphSentences, outputfile)
return morphSentences
def main():
app = QApplication(sys.argv)
frog = Frog(Point(900, 300))
level = Level(5, Point(100, 100), Point(700, 700))
game = Game(frog, level)
a = MainGame(1700, 1000, game)
sys.exit(app.exec_())
def __evolve(self, sub):
xb = sub[0]
xw = sub[-1]
xs = self.pop[0]
r = np.random.uniform(0, 1)
# Try to learn from local best
xt = xb - xw
xt.p = xw.p + r * (xt.p)
if (xt.current_fit.ret > xw.current_fit.ret):
sub[-1] = xt
return sub
else:
# Try to learn from local best
xt = xs - xw
xt.p = xw.p + r * (xt.p)
if (xt.current_fit.ret > xw.current_fit.ret):
sub[-1] = xt
return sub
else:
# Randomize the worst frog in the submemeplex
sub[-1] = Frog(self.ff, self.constraints)
return sub
class FrogTagger(TaggerI):
def __init__(self, **kwargs):
# Disable multiword recognition, which is performed by the chunker
options = FrogOptions(parser=False, mwu=False, xmlIn=True, **kwargs)
self.__frog = Frog(options)
def tag(self, sentences):
if isinstance(sentences, list):
doc = folia.Document(id='nltk-sentence')
folia_sent = doc.add(folia.Text)
for sent in sentences:
folia_sent.add(folia.Word, sent)
_input = doc
else:
_input = sentences
self.__output = self.__frog.process(_input)
return [(token['text'], token['pos'].split('(')[0])
for token in self.__output]
def get_tag_probabilities(self):
if self.__output is None:
return []
return [(token['text'], token['posprob']) for token in self.__output]
def get_lemmas(self):
if self.__output is None:
return []
return [(token['text'], token['lemma']) for token in self.__output]
def get_morph(self):
if self.__output is None:
return []
return [(token['text'], token['morph']) for token in self.__output]
class AbstractFrogChunker(ChunkParserI):
_frog = None
def __init__(self, **kwargs):
self._frog = Frog(FrogOptions(parser=False, mwu=False, tok=False, xmlIn=True, **kwargs))
def __get_folia_doc__(self, tokens):
doc = folia.Document(id='nltk-sentence')
folia_sent = doc.add(folia.Text)
for tok, pos in tokens:
word = folia_sent.add(folia.Word, tok)
word.add(folia.PosAnnotation(None, set='custom', cls=pos))
return doc
def __create_tree__(self, tokens, key):
_input = self.__get_folia_doc__(tokens)
__output = self._frog.process(_input)
for token in __output:
token['pos'] = token['pos'].split('(')[0]
if token['pos'].startswith('SPEC'):
token['pos'] = 'NNP'
return conlltags2tree([(token['text'], token['pos'], token[key]) for token in __output ])
def parse(self, tokens):
raise NotImplementedError()
def generate_dataset(
N=100,
sigma=0.1,
mu=0,
balanced_sample=True, # equal number of each class
p=[1. / 5] * 5, # for multinomial distribution of classes
datapath="/home/joel/datasets/csi5138-img/dataset1"
): # do not add trailing /
for i in range(N):
if balanced_sample:
c = i % 5
else:
c = np.random.multinomial(1, p) # choose class from distribution p
c = np.argmax(c)
# construct vector of N(mu, sigma**2)
var = sigma * np.random.randn(5) + mu
# no switch statement in Python?#yes noswitch statement in python
if c == 0:
obj = Dog(*var)
elif c == 1:
obj = Truck(*var)
elif c == 2:
obj = Airplane(*var)
elif c == 3:
obj = Person(*var)
else:
obj = Frog(*var)
obj.generate(datapath, i)
def main():
app = QApplication(sys.argv)
frog = Frog(Point(200, 400))
level = Level(1, Point(0, 0), Point(700, 700))
game = Game(frog, level)
g = Graphics(game, Point(900, 900))
sys.exit(app.exec_())
def load(self, levelConfigPath):
"""Load the level.
Args:
levelConfigPath: Absolute path to the level configuration
file. String.
"""
config = configparser.ConfigParser()
config.read(levelConfigPath)
cfg = config['general']
self.name = cfg.get('name', '')
# Level background image.
path = cfg.get('background')
self.background = StaticImage(os.path.join(self.imageDir, path))
self.frogPosX = cfg.getint('frogPosX')
self.frogPosY = cfg.getint('frogPosY')
self.frogCollisionWidth = cfg.getint('frogCollisionWidth')
self.frogCollisionHeight = cfg.getint('frogCollisionHeight')
path = cfg.get('frog')
self.frog = Frog(self.frogPosX, self.frogPosY, self.screenWidth,
self.screenHeight, self.configDir, self.imageDir)
# Load finish image.
filepath = cfg.get('finishImage')
posX = cfg.getint('finishImageX')
posY = cfg.getint('finishImageY')
centerX = cfg.getint('finishCenterWidth')
centerY = cfg.getint('finishcenterHeight')
finish = StaticImage(os.path.join(self.imageDir, filepath),
useAlpha=True)
finish.rect.topleft = (posX, posY)
width = int((finish.rect.width - centerX) / 2)
height = int((finish.rect.height - centerY) / 2)
finish.collisionRect = pygame.Rect(finish.rect.left + width,
finish.rect.top + height, centerX,
centerY)
self.finishImage = finish
self.cars, self.shadows = self.loadCars(config,
self.allowedTrackSections)
riverTracks, floatingObjects = self.loadFloaters(
config, self.allowedRiverSections)
if riverTracks:
riverTrackRects = []
for track in riverTracks:
rect = pygame.Rect(0, track['top'], self.screenWidth,
track['bottom'] - track['top'])
riverTrackRects.append(rect)
self.riverTracks = riverTracks
self.floaters = floatingObjects
self.riverTrackRects = riverTrackRects
def init(self):
self._changed = set()
self._changed_rects = []
self.overlays = []
self.ui = {}
self.dirty = True
if self.ident != self._last_ident:
self.game.clear_caches()
data = conf.LEVELS[self.ident]
sx, sy = LEVEL_SIZE
self.objs = objs = [[[] for j in xrange(sx)] for i in xrange(sy)]
self.road = Road(self)
self.frog = Frog(self, data['frog pos'], data.get('frog dirn', 1))
for pos, os in data['objs'].iteritems():
if isinstance(os, basestring):
os = (os, )
objs[pos[0]][pos[1]] = [
getattr(obj_module, obj)(self, pos) for obj in os
]
self.update_held()
def __init__(self, window):
self.hangman = Hangman()
self.window = window
# create a new pen to write the dashes
self.pen = Frog(self.window)
self.pen.visible = False
self.pen.write(' '.join('_' for char in self.hangman.word))
if SHOW_SOLUTION:
# show the solution
solution = Frog(self.window)
solution.visible = False
solution.jumpto(0, 50)
solution.write(' '.join(char for char in self.hangman.word))
# prepare a pen for writing the gallow
self.gallow_writer = Frog(self.window)
self.gallow_writer.visible = False
self.gallow_writer.jump(-150)
def init (self):
self._changed = set()
self._changed_rects = []
self.overlays = []
self.ui = {}
self.dirty = True
if self.ident != self._last_ident:
self.game.clear_caches()
data = conf.LEVELS[self.ident]
sx, sy = LEVEL_SIZE
self.objs = objs = [[[] for j in xrange(sx)] for i in xrange(sy)]
self.road = Road(self)
self.frog = Frog(self, data['frog pos'], data.get('frog dirn', 1))
for pos, os in data['objs'].iteritems():
if isinstance(os, basestring):
os = (os,)
objs[pos[0]][pos[1]] = [getattr(obj_module, obj)(self, pos)
for obj in os]
self.update_held()
def game_run():
pygame.init()
screen = pygame.display.set_mode((1200, 800))
frog = Frog(screen)
pygame.display.set_caption("Firing frog")
bg_color = (255, 255, 255)
screen.fill(
bg_color) # Using fill method of pygame.display on screen object
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_RIGHT:
moving_right = True
elif event.key == pygame.K_LEFT:
moving_left = True
elif event.key == pygame.K_UP:
moving_up = True
elif event.key == pygame.K_DOWN:
moving_down = True
elif event.type == pygame.KEYUP:
if event.key == pygame.K_RIGHT:
moving_right = False
elif event.key == pygame.K_LEFT:
moving_left = False
elif event.key == pygame.K_UP:
moving_up = False
elif event.key == pygame.K_DOWN:
moving_down = False
frog.update()
frog.blitme()
pygame.display.flip()
#!/usr/bin/env python3
from __future__ import print_function, unicode_literals
from frog import Frog, FrogOptions
import folia.main as folia
frog = Frog(FrogOptions(parser=True))
output = frog.process_raw("Dit is een test")
print("RAW OUTPUT=", output)
output = frog.process("Dit is nog een test.")
print("PARSED OUTPUT=", output)
frog = Frog(FrogOptions(parser=True, xmlout=True))
output = frog.process("Dit is een FoLiA test.")
assert isinstance(output, folia.Document)
assert isinstance(len(output.data), 1)
assert isinstance(
next(output.data.select(folia.Sentence)).text(), "Dit is een FoLiA test.")
#output is now no longer a string but an instance of folia.Document, provided by the FoLiA library in PyNLPl (pynlpl.formats.folia)
print("FOLIA OUTPUT=")
print(output.xmlstring())
print("Inspecting FoLiA output (example):")
for word in output.words():
print(word.text() + " " + word.pos() + " " + word.lemma())
assert len(output.words()) == 5
class HangmanWidget(object):
""" The GUI stuff """
def __init__(self, window):
self.hangman = Hangman()
self.window = window
# create a new pen to write the dashes
self.pen = Frog(self.window)
self.pen.visible = False
self.pen.write(' '.join('_' for char in self.hangman.word))
if SHOW_SOLUTION:
# show the solution
solution = Frog(self.window)
solution.visible = False
solution.jumpto(0, 50)
solution.write(' '.join(char for char in self.hangman.word))
# prepare a pen for writing the gallow
self.gallow_writer = Frog(self.window)
self.gallow_writer.visible = False
self.gallow_writer.jump(-150)
def reset(self):
""" clear the whole window and restart the game """
# delete the 'frogs'
self.pen.exit()
self.gallow_writer.exit()
self.__init__(self.window)
def attempt(self, event):
guessed_char = event['name']
# lock the pen if it is just writing
if self.gallow_writer.active:
return
self.gallow_writer.speed = 'max'
# TODO: write a list of all guessed letters
# right attempt
if guessed_char.lower() in self.hangman.word:
self.pen.write(self.hangman.guess(guessed_char))
if len(self.hangman.right_attempts) == len(set(self.hangman.word)):
self.gallow_writer.message(
'info',
'Congratulation! You guessed the word correctly!'
)
# start a new game
self.reset()
# wrong attempt
else:
# the number of mistakes
num_mistakes = len(self.hangman.wrong_attempts)
figures = [
self.hill,
self.first_beam,
self.second_beam,
self.bracket,
self.rope,
self.head,
self.body,
self.first_leg,
self.second_leg,
self.first_arm,
self.second_arm,
]
# only draw a figure if the guessed
# letter was not already guessed earlier
if guessed_char not in self.hangman.attempts:
figures[num_mistakes]()
self.hangman.guess(guessed_char)
def hill(self):
self.gallow_writer.turnto(90)
self.gallow_writer.circle(50, 180)
def first_beam(self):
self.gallow_writer.circle(50, -90, draw = False)
self.gallow_writer.turnto(90)
self.gallow_writer.move(100)
def second_beam(self):
self.gallow_writer.turnto(0)
self.gallow_writer.move(100)
def bracket(self):
# move back and build the supporting beam (and yes, the strange
# number 36 is necessary because the gallow must be hit exactly
# on the right place)
self.gallow_writer.jump(-75)
self.gallow_writer.turnto(225)
self.gallow_writer.move(36)
# don't forget to to move to the place where the man will be hung
self.gallow_writer.jump(-36)
self.gallow_writer.turnto(0)
self.gallow_writer.jump(75)
def rope(self):
self.gallow_writer.turnto(270)
self.gallow_writer.move(25)
def head(self):
self.gallow_writer.turnto(0)
self.gallow_writer.circle(-15)
def body(self):
self.gallow_writer.turnto(270)
self.gallow_writer.jump(30)
self.gallow_writer.move(50)
def first_leg(self):
self.gallow_writer.turnto(225)
self.gallow_writer.move(25)
def second_leg(self):
self.gallow_writer.jump(-25)
self.gallow_writer.turnto(315)
self.gallow_writer.move(25)
def first_arm(self):
self.gallow_writer.jump(-25)
self.gallow_writer.turnto(90)
self.gallow_writer.jump(25)
self.gallow_writer.turnto(135)
self.gallow_writer.move(25)
def second_arm(self):
""" last figure -> user lost! """
self.gallow_writer.jump(-25)
self.gallow_writer.turnto(45)
self.gallow_writer.move(25)
self.gallow_writer.message(
'Info',
'You lost! Shame on you! The word was: ' + self.hangman.word
)
# start a new game
self.reset()
def main(screen, window_size):
"""
:param screen: the surface object
:param window_size: the window size as a tuple
:return: void
This is the main game loop
"""
FPS = 30
FPS_CLOCK = pygame.time.Clock()
pygame.mixer.music.load('battle.ogg')
pygame.mixer.music.play(-1)
whip = pygame.mixer.Sound('whip.ogg')
boom = pygame.mixer.Sound('boom.ogg')
pond = pygame.image.load('pond.png')
# Draw Frogs
frog1 = Frog(1, window_size)
crosshair1 = Crosshair(window_size, 1)
frog2 = Frog(2, window_size)
crosshair2 = Crosshair(window_size, 2)
# Fly Setup
fly_sprites = pygame.sprite.Group()
FLY_SPAWN = pygame.USEREVENT + 1
pygame.time.set_timer(FLY_SPAWN, 1000)
# Dragonfly Setup
dfly_sprites = pygame.sprite.Group()
DFLY_SPAWN = pygame.USEREVENT + 2
pygame.time.set_timer(DFLY_SPAWN, 5000)
fireballs1 = pygame.sprite.Group()
fireballs2 = pygame.sprite.Group()
# Text
start_ticks = pygame.time.get_ticks()
timer = 61
timer_font = pygame.font.SysFont('berlinsansfb', 50)
score_font = pygame.font.SysFont('berlinsansfb', 30)
p1_move_right = False
p1_move_left = False
p1_charge = 0
p1_score = 0
p1_fire = 0
p2_move_right = False
p2_move_left = False
p2_charge = 0
p2_score = 0
p2_fire = 0
while True: # <--- main game loop
seconds = (pygame.time.get_ticks() - start_ticks)/1000
# render objects
SCREEN.blit(pond, (0, 0))
frog1.draw(SCREEN)
frog2.draw(SCREEN)
if len(dfly_sprites) > 0:
dfly_sprites.update()
dfly_sprites.draw(SCREEN)
if len(fly_sprites) > 0:
fly_sprites.update()
fly_sprites.draw(SCREEN)
if len(fireballs1) > 0:
fireballs1.update()
fireballs1.draw(SCREEN)
frogs_stunned = pygame.sprite.spritecollide(frog2, fireballs1, True)
if len(frogs_stunned) > 0:
frog2.stunned = True
p2_charge = 0
crosshair2.charging = 0
frog2.time_of_stun = timer - seconds
if len(fireballs2) > 0:
fireballs2.update()
fireballs2.draw(SCREEN)
frogs_stunned = pygame.sprite.spritecollide(frog1, fireballs2, True)
if len(frogs_stunned) > 0:
frog1.stunned = True
p1_charge = 0
crosshair1.charging = 0
frog1.time_of_stun = timer - seconds
# draw targeting line and charge meter for frog 1
draw_line(screen, frog1.mouth, (crosshair1.x + crosshair1.size[0]/2, crosshair1.y + crosshair1.size[1]/2))
crosshair1.draw(SCREEN, p1_charge * 5)
# draw targeting line and charge meter for frog 2
draw_line(screen, frog2.mouth, (crosshair2.x + crosshair2.size[0]/2, crosshair2.y + crosshair2.size[1]/2))
crosshair2.draw(SCREEN, p2_charge * 5)
for event in pygame.event.get():
if event.type == QUIT: # QUIT event to exit the game
pygame.quit()
sys.exit()
# Fly event timer
if event.type == FLY_SPAWN:
if len(fly_sprites) < 10:
if random.randrange(0, 2) == 0:
fly = Fly(0, random.randrange(175, 501), random.randrange(1, 11))
fly_sprites.add(fly)
else:
fly = Fly(700, random.randrange(175, 501), random.randrange(1, 11))
fly_sprites.add(fly)
# Dragonfly event timer
if event.type == DFLY_SPAWN:
if len(dfly_sprites) < 1:
if random.randrange(0, 2) == 0:
dragonfly = Dragonfly(0, random.randrange(175, 450), random.randrange(5, 11), random.randrange(3,11))
dfly_sprites.add(dragonfly)
else:
dragonfly = Dragonfly(700, random.randrange(175, 450), random.randrange(5, 11), random.randrange(3,11))
dfly_sprites.add(dragonfly)
# Input events
if event.type == KEYDOWN:
if event.key == K_ESCAPE:
return 0
# Player 1
if event.key == K_LEFT:
p1_move_left = True
if event.key == K_RIGHT:
p1_move_right = True
if event.key == K_DOWN and not frog1.stunned:
crosshair1.charging = True
# Player 2
if event.key == K_a:
p2_move_left = True
if event.key == K_d:
p2_move_right = True
if event.key == K_s and not frog2.stunned:
crosshair2.charging = True
# Quit
if event.key == K_ESCAPE:
pygame.quit()
sys.exit()
if event.type == KEYUP:
# Player 1
if event.key == K_LEFT:
p1_move_left = False
if event.key == K_RIGHT:
p1_move_right = False
if event.key == K_DOWN and not frog1.stunned:
whip.play()
crosshair1.charging = False
xhair1 = (crosshair1.x + crosshair1.size[0]/2,crosshair1.y + crosshair1.size[1]/2)
hit_list, is_dragon = frog1.fire_tongue(SCREEN, p1_charge, xhair1[0], xhair1[1], fly_sprites, dfly_sprites)
p1_score += len(hit_list)
if len(hit_list) > 0 and p1_charge >= 15:
p1_score += 2
if is_dragon:
p1_fire += 1
p1_score += 1
p1_charge = 0
if event.key == K_UP and not frog1.stunned:
if p1_fire > 0:
boom.play()
fireball = Fireball(1, frog1.x + 50, frog1.y)
fireballs1.add(fireball)
p1_fire -= 1
# Player 2
if event.key == K_a:
p2_move_left = False
if event.key == K_d:
p2_move_right = False
if event.key == K_s and not frog2.stunned:
whip.play()
crosshair2.charging = False
xhair2 = (crosshair2.x + crosshair2.size[0]/2, crosshair2.y + crosshair2.size[1]/2)
hit_list, is_dragon = frog2.fire_tongue(SCREEN, p2_charge, xhair2[0], xhair2[1], fly_sprites, dfly_sprites)
p2_score += len(hit_list)
if len(hit_list) > 0 and p2_charge >= 15:
p2_score += 2
if is_dragon:
p2_fire += 1
p2_score += 1
p2_charge = 0
if event.key == K_w and not frog2.stunned:
if p2_fire > 0:
boom.play()
fireball = Fireball(2, frog2.x + 50, frog2.size[1] - 45)
fireballs2.add(fireball)
p2_fire -= 1
# Player 1 crosshair events
if p1_move_left and not crosshair1.x < 0:
crosshair1.change_x(-15)
if p1_move_right and not crosshair1.x > window_size[0] - crosshair1.size[0]:
crosshair1.change_x(15)
if crosshair1.charging:
if p1_charge < 20:
p1_charge += 0.5
# Player 2 crosshair events
if p2_move_left and not crosshair2.x < 0:
crosshair2.change_x(-15)
if p2_move_right and not crosshair2.x > window_size[0] - crosshair2.size[0]:
crosshair2.change_x(15)
if crosshair2.charging:
if p2_charge < 20:
p2_charge += 0.5
# Calculate, render timers
if timer - seconds > 0:
timer_text = str(round(timer - seconds, 2))
else:
timer_text = 'GAME OVER'
if frog1.stunned:
if (timer - seconds) < frog1.time_of_stun - 2:
frog1.stunned = False
if frog2.stunned:
if (timer - seconds) < frog2.time_of_stun - 2:
frog2.stunned = False
SCREEN.blit(timer_font.render(timer_text, False, (255, 0, 0)), (25, 25))
if (timer - seconds) <= 0:
if p1_score > p2_score:
return 1
elif p2_score > p1_score:
return 2
elif p1_score == p2_score:
return 3
# render HUD info
p1_score_text = 'Player 1: ' + str(p1_score)
p1_fire_text = 'Fireballs: ' + str(p1_fire)
p2_score_text = 'Player 2: ' + str(p2_score)
p2_fire_text = 'Fireballs: ' + str(p2_fire)
SCREEN.blit(score_font.render(p1_score_text, True, (0, 0, 0)),
(window_size[0]/2 + frog1.size[0]/2 + 25, window_size[1] - 75))
SCREEN.blit(score_font.render(p1_fire_text, True, (0, 0, 0)),
(window_size[0]/2 + frog1.size[0]/2 + 25, window_size[1] - 50))
SCREEN.blit(score_font.render(p2_score_text, True, (0, 0, 0)),
(window_size[0]/2 + frog1.size[0]/2 + 25, 25))
SCREEN.blit(score_font.render(p2_fire_text, True, (0, 0, 0)),
(window_size[0]/2 + frog1.size[0]/2 + 25, 50))
pygame.display.update()
FPS_CLOCK.tick(FPS)
line_txt = re.sub(r'\\-', ' ', line_txt) # spelling
line_txt = re.sub(r'"', '', line_txt)
line_txt = re.sub(r'[ ]+(?=[.,:;?!])', "", line_txt)
# line_txt = re.sub(r'[\.!]*[!]+[\.!]*', '!', line_txt) # replace combos including at least 1 '!'
# line_txt = re.sub(r'[\.!?]*[?]+[\.!?]*', '?', line_txt) # replace combos including at least 1 '?'
# line_txt = re.sub(r'\.+', '.', line_txt) # replace clusters of '.' with a single '.'
line_txt = re.sub(r'[!.?]+', '!', line_txt)
line_txt = re.sub(r'[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\xff]',
'', line_txt)
line_txt = re.sub(r" 's ", " ''s ", line_txt)
line_txt = re.sub(r"^'s ", "''s ", line_txt)
# if re.search(r'"".+""', line_txt):
# print(re.search(r'"".+""', line_txt).group())
txt_dict[pair][part][spkr] += line_txt + " "
frog = Frog(FrogOptions(mwu=False, ner=False))
for pair in txt_dict:
for part in txt_dict[pair]:
with open("{}pos/{}/{}_{}.pos".format(ecsd_path, pair, pair, part),
"w",
encoding="utf-8") as g:
for spkr in txt_dict[pair][part]:
print(pair, part, spkr)
text = txt_dict[pair][part][spkr]
word_list = frog.process(text)
s_counter = 0
w_counter = 0
for word in word_list:
if word["index"] == "1":
s_counter += 1
y[-1].append('yes' if fields[-1] == 'animate' else 'no')
return X, y
X, y = load_data(sys.argv[1], limit=None)
model = Word2Vec.load_word2vec_format(sys.argv[2], binary=True)
full_feature_vectorizer = FeatureStacker(('windower', Windower(window_size=3)),
('embeddings', WordEmbeddings(model)))
backoff_feature_vectorizer = FeatureStacker(('windower', Windower(window_size=3)))
X_full = full_feature_vectorizer.fit_transform([[word for word in doc] for doc in X])
X_backoff = backoff_feature_vectorizer.fit_transform([[word for word in doc] for doc in X])
y = LabelEncoder().fit_transform([l for labels in y for l in labels])
clf_full = LogisticRegression().fit(X_full, y)
clf_backoff = LogisticRegression().fit(X_backoff, y)
frogger = Frog(int(sys.argv[3]))
for filename in glob.glob(os.path.join(sys.argv[4], "*")):
print filename
characters = Counter()
with codecs.open(filename, encoding='utf-8') as infile:
doc = infile.read()
document = frogger.tag(doc)
document = [[f.decode('utf-8') for f in w[:-1]]
for sentence in document for w in sentence]
words = [word[0] for word in document]
X_test_full = full_feature_vectorizer.transform([document])
X_test_backoff = backoff_feature_vectorizer.transform([document])
for i, word in enumerate(X_test_full):
if words[i].lower() not in model:
pred = clf_backoff.predict(X_test_backoff[i])[0]
class Level (object):
def __init__ (self, game, event_handler, ident = 0):
self.game = game
event_handler.add_event_handlers({
pg.MOUSEBUTTONDOWN: self._click,
pg.MOUSEMOTION: self._move_mouse
})
event_handler.add_key_handlers([
(conf.KEYS_BACK, self.end, eh.MODE_ONDOWN)
])
self._held_sfc = pg.Surface(TILE_SIZE).convert_alpha()
self._held_sfc.fill(conf.UI_BG)
self._last_ident = self.ident = ident
self._locked = False
self.drop_input()
self.game.linear_fade(*conf.INIT_FADE)
self.init()
def init (self):
self._changed = set()
self._changed_rects = []
self.overlays = []
self.ui = {}
self.dirty = True
if self.ident != self._last_ident:
self.game.clear_caches()
data = conf.LEVELS[self.ident]
sx, sy = LEVEL_SIZE
self.objs = objs = [[[] for j in xrange(sx)] for i in xrange(sy)]
self.road = Road(self)
self.frog = Frog(self, data['frog pos'], data.get('frog dirn', 1))
for pos, os in data['objs'].iteritems():
if isinstance(os, basestring):
os = (os,)
objs[pos[0]][pos[1]] = [getattr(obj_module, obj)(self, pos)
for obj in os]
self.update_held()
def restart (self):
self.cutscene(self.init, *conf.RESTART)
def end (self, *args):
self.cutscene(self.game.quit_backend, *conf.END, persist = True)
def _progress (self):
if hasattr(self, '_cleanup'):
self._cleanup()
self.game.switch_backend(level_backends[self.ident], self.ident)
def progress (self):
self.ident += 1
if self.ident >= len(conf.LEVELS):
self.end()
else:
self.cutscene(self._progress, *conf.PROGRESS)
def _end_cutscene (self):
self._locked = False
def cutscene (self, evt_f, evt_t, fade, ctrl_t = None, persist = False):
self._locked = True
self.frog.stop()
self.game.linear_fade(*fade, persist = persist)
self.game.scheduler.add_timeout(evt_f, seconds = evt_t)
if ctrl_t is None:
ctrl_t = evt_t
self.game.scheduler.add_timeout(self._end_cutscene, seconds = ctrl_t)
def _click (self, evt):
if self._locked:
return
if self._grab_click(evt) and evt.button in conf.ACTION_SETS:
self._rm_ui('msg')
pos = tuple(x / s for x, s in zip(evt.pos, TILE_SIZE))
self.frog.action(conf.ACTION_SETS[evt.button],
self.objs[pos[0]][pos[1]], pos)
def _move_mouse (self, evt):
if self._grab_move(evt):
orig_x, orig_y = evt.pos
x = orig_x / TILE_SIZE[0]
y = orig_y / TILE_SIZE[1]
obj = self.top_obj(self.objs[x][y])
if obj is None:
self._rm_ui('label')
return
label = obj_module.name(obj)
sfc = self.game.render_text(
'label', label, conf.FONT_COLOUR, bg = conf.UI_BG,
pad = conf.LABEL_PADDING, cache = ('label', label)
)[0]
o = conf.LABEL_OFFSET
ws, hs = sfc.get_size()
x, y = orig_x + o[0], orig_y - hs + o[1]
w, h = conf.RES
x = min(max(x, 0), w - ws)
y = min(max(y, 0), h - hs)
self._add_ui('label', sfc, (x, y))
def _native_click (self, evt):
return True
def _native_move (self, evt):
return True
def grab_input (self, click, move):
self._grab_click = click
self._grab_move = move
def drop_input (self):
self._grab_click = self._native_click
self._grab_move = self._native_move
def change_tile (self, tile):
self._changed.add(tuple(tile))
def rect_tiles (self, rect):
sx, sy = TILE_SIZE
x, y, w, h = rect
x0 = int(x / sx)
y0 = int(y / sy)
x1 = int(ceil(float(x + w) / sx))
y1 = int(ceil(float(y + h) / sy))
w, h = LEVEL_SIZE
tiles = []
for i in xrange(x0, x1):
if 0 <= i < w:
for j in xrange(y0, y1):
if 0 <= j < h:
tiles.append((i, j))
return tiles
def change_rect (self, rect, tiles = None):
if tiles is None:
tiles = self.rect_tiles(rect)
self._changed.update(tiles)
self._changed_rects.append(rect)
return tiles
def add_obj (self, obj, pos):
self.objs[pos[0]][pos[1]].append(obj)
if isinstance(obj, obj_module.OneTileObj):
self.change_tile(pos)
road = self.road
if road.tile_rect.collidepoint(pos) and hasattr(obj, 'on_crash') and \
road.lane_moving(pos[1]):
obj.on_crash(self.frog, road)
assert not (obj.holdable and obj.solid)
def rm_obj (self, obj, pos = None):
if pos is None:
pos = obj.pos
self.objs[pos[0]][pos[1]].remove(obj)
if isinstance(obj, obj_module.OneTileObj):
self.change_tile(pos)
if self.road.tile_rect.collidepoint(pos) and \
hasattr(obj, 'on_uncrash'):
obj.on_uncrash(self.frog, self.road)
def top_obj (self, objs):
# select uppermost (last) obj
return objs[-1] if objs else None
def solid_objs (self, *ignore):
# return set of tiles of containing solid objects
objs = set()
for x, col in enumerate(self.objs):
for y, os in enumerate(col):
for o in os:
if o.solid and o not in ignore:
objs.add((x, y))
break
return objs
def _add_ui (self, ident, sfc, pos = None):
if pos is None:
pos = conf.UI_POS[ident]
ui = self.ui
if ident in ui:
ui[ident].hide()
ui[ident] = Overlay(self, sfc, pos).show()
def _rm_ui (self, ident):
ui = self.ui
if ident in ui:
overlay = ui[ident]
del ui[ident]
overlay.hide()
def update_held (self):
sfc = self._held_sfc
if self.frog.item is not None:
sfc = sfc.copy()
self.frog.item.draw(sfc, (0, 0))
self._add_ui('held', sfc)
def say (self, msg):
sfc = self.game.render_text(
'msg', msg, conf.FONT_COLOUR, width = conf.MSG_WIDTH,
bg = conf.UI_BG, pad = conf.MSG_PADDING, cache = ('msg', msg)
)[0]
self._add_ui('msg', sfc)
def update (self):
self.frog.update()
self.road.update()
self._changed.update(self.road.tiles)
def _draw_objs (self, screen, objs):
last = None
# draw non-solid
for o in objs:
if isinstance(o, obj_module.OneTileObj):
if o.solid:
last = o
else:
o.draw(screen)
# draw solid
if last is not None:
last.draw(screen)
def _draw_cars (self, screen):
for dirn, cars in self.road.cars:
for car in cars:
car.draw(screen)
def draw (self, screen):
bg = self.game.img('bg.png')
draw_objs = self._draw_objs
overlays = self.overlays
road = self.road
if self.dirty:
self.dirty = False
# background
screen.blit(bg, (0, 0))
# objects
for col in self.objs:
for objs in col:
if objs:
draw_objs(screen, objs)
# moving cars
self._draw_cars(screen)
# overlays
for overlay in overlays:
overlay.draw(screen)
rtn = True
else:
# draw changed tiles
rects = self._changed_rects
in_road_rect = road.tile_rect.collidepoint
objs = self.objs
sx, sy = TILE_SIZE
todo_os = set()
# draw bg and objs
screen.blit(bg, road.rect, road.rect)
for x, y in road.tiles:
draw_objs(screen, objs[x][y])
for overlay in overlays:
if (x, y) in overlay.tiles:
todo_os.add(overlay)
for tile in self._changed:
if in_road_rect(tile):
continue
x, y = tile
this_objs = objs[x][y]
x *= sx
y *= sy
r = (x, y, sx, sy)
screen.blit(bg, (x, y), r)
draw_objs(screen, this_objs)
# add to changed rects
rects.append(r)
# add overlays
for overlay in overlays:
if tile in overlay.tiles:
todo_os.add(overlay)
self._draw_cars(screen)
rects.append(road.rect)
# draw overlays
for overlay in todo_os:
overlay.draw(screen)
rtn = rects
self._changed = set()
self._changed_rects = []
return rtn
line_txt) # deal with d'rbij
line_txt = re.sub(r'^\.', '', line_txt)
line_txt = re.sub(
r'[!?\.,:;]', lambda m: " " + m.group(),
line_txt) # prevent from being interpreted as SPEC(afk)
# if re.search(r'"".+""', line_txt):
# print(re.search(r'"".+""', line_txt).group())
# if len(line_txt) > 0:
# if line_txt[-1] not in [".", ",", "!", "?", ":", ";"]: # add . if chunk does not end in punctuation
# if re.search(r' [A-Za-z]$', line_txt): # prevent from being interpreted as SPEC(afk)
# line_txt += "!"
# else:
# line_txt += " ."
txt_dict[file_n][speakers[file_n][spkr]] += line_txt + " "
frog = Frog(FrogOptions(parser=True))
def tag_files(files):
for fl in files:
with open(tens_path + "Annotations/pos/" + fl + ".pos", "w") as g:
for spkr in txt_dict[fl]:
print(fl, spkr)
text = txt_dict[fl][spkr]
# print(text)
word_list = frog.process(text)
print("BLA")
s_counter = 0
for word in word_list:
if word["index"] == "1":
s_counter += 1
from storypy import Story
import glob
import codecs
import os
import sys
from frog import Frog, Word
frogger = Frog(int(sys.argv[1]))
def token_boundaries(tokens, original_text):
curr_pos = 0
for tok in tokens:
start_pos = original_text.index(tok, curr_pos)
# TODO: Check if we fail to find the token!
end_pos = start_pos + len(tok)
yield (start_pos, end_pos)
curr_pos = end_pos
for filename in glob.glob(os.path.join(sys.argv[2], "SINVS*.ann")):
if 'anomalies' in filename:
continue
story = Story.load(filename)
if sys.argv[3] == 'chars':
characters = {(start, end): (id, name)
for character in story.characters
for id, name, start, end in character.chain}
else:
characters = {(start, end): (id, name)
for location in story.locations
for id, name, start, end in location.chain}
