def handleurl_merge(self, urlfile):
"""Merge the specified list of tracks."""
(_, _, tracks) = urlfile.split('/')
tracks = tracks.split(',')
self.log('Merging %s' % repr(tracks))
first_track = track.Track(db)
first_track.FromId(int(tracks[0]))
self.log('Before: %s' % repr(first_track.persistant))
cleanup = []
for second_track_id in tracks[1:]:
second_track = track.Track(db)
second_track.FromId(int(second_track_id))
first_track.Merge(second_track)
self.log('After: %s' % repr(first_track.persistant))
cleanup.append(second_track)
first_track.Store()
for second_track in cleanup:
second_track.Delete()
self.log('Merge finished')
self.sendfile('done.html')
def handleurl_unmerge(self, urlfile):
"""Undo a merge."""
(_, _, tracks) = urlfile.split('/')
tracks = tracks.replace(' ', '').replace('%20', '').split(',')
self.log('Unmerging %s' % repr(tracks))
first_track = track.Track(db)
first_track.persistant = eval(
db.GetOneRow('select * from events '
'where '
'event = "merge: before" '
'and '
'track_id = %s order by '
'timestamp asc limit 1;' % tracks[0])['details'])
self.log('Previous state of %s: %s' %
(tracks[0], repr(first_track.persistant)))
first_track.Store()
for t_id in tracks[1:]:
t = track.Track(db)
t.persistant = eval(
db.GetOneRow('select * from events where '
'event = "merge: deleted" and '
'track_id = %s order by '
'timestamp desc limit 1;' % t_id)['details'])
tags = eval(
db.GetOneRow('select * from events where '
'event = "merge: tags: %s" '
'order by timestamp desc limit 1;' %
t_id)['details'])
paths = eval(
db.GetOneRow('select * from events where '
'event = "merge: paths: %s" '
'order by timestamp desc limit 1;' %
t_id)['details'])
self.log('Previous state of %s: %s. Tags %s, Paths %s.' %
(t_id, repr(t.persistant), tags, paths))
t.Store()
for tag in tags:
try:
db.ExecuteSql(
'update tags set track_id=%s where tag="%s";' %
(t_id, tag['tag']))
except:
pass
for path in paths:
try:
db.ExecuteSql(
'update paths set track_id=%s where path=%s;' %
(t_id, sql.FormatSqlValue('path', path['path'])))
except:
pass
db.ExecuteSql('commit;')
def readFiles(paths: list):
tracks = []
for item in paths:
dataDict = readID3(item)
dataDict["path"] = item
tracks.append(t.Track(dataDict))
return tracks
class TrackParser():
actions = {
"TRACK": [
lambda _, n: track.Track(
comment1=n[4], comment2=n[5], track_entry=n[7])
],
"NONEMPTY_LINE": [lambda _, n: n[0]],
"TRACK_ENTRY_GROUP": [
lambda _, n: track.TrackEntry(
comment=n[0],
id=n[2],
line2=n[3],
tile_index=n[4],
line4=n[5],
length=n[6],
line6=n[7],
line7=n[8],
)
],
"TRACK_ENTRY_GROUP_LIST":
[lambda _, n: [n[0]], lambda _, n: n[0] + [n[1]]]
}
def __init__(self):
self.grammar = parglare.Grammar.from_file(
os.path.join(os.path.dirname(os.path.realpath(__file__)),
"track_grammar.pg"))
self.parser = parglare.Parser(self.grammar,
actions=self.actions,
ws="\r")
def parse(self, file_name):
with open(file_name, encoding="iso-8859-1") as f:
content = f.read()
return self.parser.parse(content)
def test_round_tick(self):
"""Test round track using tick()"""
# 1. Create default Track object
mytrack = track.Track()
# 2. Add the track from text
mytrack.from_text(ROUND[0])
# 3. Check a few things
self.assertEqual(len(mytrack.tracks), 16)
self.assertEqual(len(mytrack.carts), 2)
self.assertEqual(mytrack.time, 0)
self.assertEqual(mytrack.size(), (5, 3))
self.assertEqual(str(mytrack), ROUND[0])
# 4. Loop for all but last iteration
for i in range(1, len(ROUND) - 1):
# 5. Advance the clock by one each loop
self.assertEqual(mytrack.tick(), False)
self.assertEqual(mytrack.crashed, None)
self.assertEqual(str(mytrack), ROUND[i])
# 6. Advance the clock by one last time
self.assertEqual(mytrack.tick(), True)
self.assertEqual(mytrack.crashed, (5, 3))
self.assertEqual(str(mytrack), ROUND[len(ROUND) - 1])
def test_vertical_text(self):
"""Test vertical track using from_text()"""
# 1. Create default Track object
mytrack = track.Track()
# 2. Add the track from text
mytrack.from_text(VERTICAL_TRACK)
# 3. Check a few things
self.assertEqual(len(mytrack.tracks), 7)
self.assertEqual(len(mytrack.carts), 2)
self.assertEqual(mytrack.time, 0)
self.assertEqual(mytrack.size(), (0, 6))
self.assertEqual(str(mytrack), "|\nv\n|\n|\n|\n^\n|")
# 4. Advance the clock by one
self.assertEqual(mytrack.tick(), False)
self.assertEqual(mytrack.crashed, None)
self.assertEqual(str(mytrack), "|\n|\nv\n|\n^\n|\n|")
# 5. Advance the clock by one more
self.assertEqual(mytrack.tick(), True)
self.assertEqual(mytrack.crashed, (0, 3))
self.assertEqual(str(mytrack), "|\n|\n|\nX\n|\n|\n|")
def test_vertical(self):
"""Test vertical track"""
# 1. Create default Track object
mytrack = track.Track()
# 2. Add the vertical track
mytrack.add_track((0, 0), '|')
mytrack.add_track((0, 1), 'v')
mytrack.add_track((0, 2), '|')
mytrack.add_track((0, 3), '|')
mytrack.add_track((0, 4), '|')
mytrack.add_track((0, 5), '^')
mytrack.add_track((0, 6), '|')
# 3. Check a few things
self.assertEqual(len(mytrack.tracks), 7)
self.assertEqual(len(mytrack.carts), 2)
self.assertEqual(mytrack.time, 0)
self.assertEqual(mytrack.size(), (0, 6))
self.assertEqual(str(mytrack), "|\nv\n|\n|\n|\n^\n|")
# 4. Advance the clock by one
self.assertEqual(mytrack.tick(), False)
self.assertEqual(mytrack.crashed, None)
self.assertEqual(str(mytrack), "|\n|\nv\n|\n^\n|\n|")
# 5. Advance the clock by one more
self.assertEqual(mytrack.tick(), True)
self.assertEqual(mytrack.crashed, (0, 3))
self.assertEqual(str(mytrack), "|\n|\n|\nX\n|\n|\n|")
def test_empty_init(self):
"""Test default Track object creation"""
# 1. Create default Track object
mytrack = track.Track()
# 2. Make sure it has the default values
self.assertEqual(len(mytrack.tracks), 0)
self.assertEqual(len(mytrack.carts), 0)
self.assertEqual(mytrack.time, 0)
self.assertEqual(mytrack.size(), (0, 0))
self.assertEqual(mytrack.crashed, None)
# 3. Check methods
self.assertEqual(mytrack.get_track((0, 0)), ' ')
self.assertRaises(AssertionError, mytrack.get_track, (3, 3))
mytrack.add_track((1, 2), '-')
self.assertEqual(len(mytrack.tracks), 1)
self.assertEqual(mytrack.size(), (1, 2))
mytrack.add_track((1, 3), '+')
self.assertEqual(mytrack.size(), (1, 3))
self.assertEqual(len(mytrack.tracks), 2)
self.assertEqual(mytrack.get_track((1, 1)), ' ')
self.assertEqual(mytrack.get_track((1, 2)), '-')
self.assertEqual(mytrack.get_track((1, 3)), '+')
self.assertRaises(AssertionError, mytrack.get_track, (1, 4))
mytrack.set_crashed((0, 0))
self.assertEqual(mytrack.crashed, (0, 0))
# 4. Once last check of values
self.assertEqual(len(mytrack.tracks), 3)
self.assertEqual(len(mytrack.carts), 0)
self.assertEqual(mytrack.time, 0)
self.assertEqual(mytrack.size(), (1, 3))
def __init__(self):
self.camera = camera.Camera()
self.track = track.Track()
self.track.generateTrack(20, 50)
self.sound = sound.Sound()
#self.camera.position = (self.track.startingPoint[0], 1, self.track.startingPoint[1])
self.rotation = 0
self.unicycles = []
self.unicycles.append(
racer.Racer(
array([
self.track.startingPoint[0], 0.3,
self.track.startingPoint[1]
]), self.track.startingRot, 75, 4, self.track, self.sound))
tilted = racer.Racer(array([-2, 0.3, 2]), 0)
tilted.orientation = array([1, 1, 0])
self.unicycles.append(tilted)
tilted2 = racer.Racer(array([2, 0.3, -2]), 0)
tilted2.orientation = array([0, 1, 1])
self.unicycles.append(tilted2)
tilted3 = racer.Racer(array([-2, 0.3, -2]), 0)
tilted3.orientation = array([1, 1, 1])
self.unicycles.append(tilted3)
self.currentTime = pygame.time.get_ticks()
self.accumulator = 0
def __init__(self):
super().__init__()
self.controller = inputs.devices.gamepads[0]
self.cur_track_segment = 0
track_f = open("track.json")
track_data = json.load(track_f)
track_f.close()
self.track = track.Track(track_data, world)
self.car = car.Car(base, world, self.track)
dlight = DirectionalLight('dlight')
dlnp = render.attachNewNode(dlight)
dlnp.setHpr(0, -80, 0)
render.setLight(dlnp)
alight = AmbientLight('alight')
alight.setColor(Vec4(0.2, 0.2, 0.2, 1))
alnp = render.attachNewNode(alight)
render.setLight(alnp)
myFog = Fog("Fog")
myFog.setColor(0.2, 0.2, 0.2)
myFog.setExpDensity(0.005)
render.setFog(myFog)
taskMgr.add(self.update, 'update')
self.controller_t = threading.Thread(target=self.controller_tf,
daemon=True)
self.controller_t.start()
def removeTrack(self, track_id):
# check if more than 1 track exists
if (len(self.tracks) > 1):
self.tracks.pop(track_id)
else:
# replace last track instead of removing it
self.tracks = [track.Track(0, "New Track")]
def search_tracks(self, terms, limit):
headers = {"Authorization": "Bearer {0}".format(self._token)}
payload = {"q": "", "type": "track", "limit": str(limit)}
space = " " # used to separate search terms
for t in terms:
if payload["q"] == "":
payload["q"] = t
else:
payload["q"] += space + t
# before a request, always make sure the token is
# kept alive
self.keepalive_token()
res = requests.get(self.sp_search_endpoint,
headers=headers,
params=payload)
if res.status_code == 200:
# good
# now build a list of tracks
items = res.json()["tracks"]["items"]
out = []
for i in items:
out.append(track.Track(i))
return out
else:
# bad
print("HTTP error {0} in Spotify search operation...".format(
res.status_code))
return None
def as_track(self):
track_struct = self.__link_interface.as_track(self.__link_struct)
if track_struct is not None:
ti = _track.TrackInterface()
ti.add_ref(track_struct)
return track.Track(track_struct)
def setup_method(self, m):
self.track = track.Track()
self.player = player.Player("A", car=0, lane=0)
self.x = self.player.x
self.y = self.player.y
self.score = self.player.score
self.track.set(self.x, self.y, self.obstacle)
def test_example_tick(self):
"""Test example track using tick()"""
# 1. Create default Track object
mytrack = track.Track()
# 2. Add the track from text
mytrack.from_text(EXAMPLE[0])
# 3. Check a few things
self.assertEqual(len(mytrack.carts), 2)
self.assertEqual(mytrack.time, 0)
self.assertEqual(mytrack.size(), (12, 5))
self.assertEqual(str(mytrack), EXAMPLE[0])
# 4. Loop for all but last iteration
for i in range(1, len(EXAMPLE) - 1):
# 5. Advance the clock by one each loop
self.assertEqual(mytrack.tick(), False)
self.assertEqual(mytrack.crashed, None)
# print("........... actual %d" % i)
# print(str(mytrack))
# print("........... expected %d" % i)
# print(EXAMPLE[i])
self.assertEqual(str(mytrack), EXAMPLE[i])
# 6. Advance the clock by one last time
self.assertEqual(mytrack.tick(), True)
self.assertEqual(mytrack.crashed, (7, 3))
self.assertEqual(str(mytrack), EXAMPLE[len(EXAMPLE) - 1])
def __init__(self, client, name, drive_func):
self.client = client
self.drive_func = drive_func
self.name = name
self.track = track.Track()
self.players = {}
self.cars = [car.Car(1), car.Car(2), car.Car(3), car.Car(4)]
self.world = world.generate_world(self)
def as_track_and_offset(self):
offset = ctypes.c_int
track_struct = self.__link_interface.as_track_and_offset
if track_struct is not None:
ti = _track.TrackInterface()
ti.add_ref(track_struct)
return track.Track(track_struct), offset.value
def __init__(self):
self.server = None
self.track = track.Track()
self.looper = task.LoopingCall(self.loop)
self.players = {}
self.free_cars = set(range(config.number_of_cars))
self.free_lanes = set(range(config.max_players))
self._rate = config.game_rate
self.started = False
self.timeleft = config.game_duration
def __compare_method__(track_length=30):
time1 = timer()
t = track.Track(1, track_length)
time2 = timer()
solution = evolutionary_generate(t.points, t.scale)
time3 = timer()
timeOrig = time2 - time1
timerEvo = time3 - time2
return (track.track_length(t.points, t.scale), timeOrig,
track.track_length(solution, t.scale), timerEvo)
def generate_beckham_track(self):
beckham_track = track.Track("beckham")
for sentence in self.sentences:
target_locale = self.beckham_sentence_to_locale_map[sentence]
beckham_track.concat(
"beckham",
sentence.synthesized_sentences[target_locale],
sentence.start_time,
True,
)
self.tracks["beckham"] = beckham_track
def test_sample_solve(self):
"""Test sample track using solve()"""
# 1. Create default Track object
mytrack = track.Track()
# 2. Add the track from text
mytrack.from_text(SAMPLE)
# 3. Solve this puzzle for first collision
self.assertEqual(mytrack.solve(), (7, 3))
def main():
# TODO: algorithm expects that the shorten piece is also present in the set.
# remove this condition.
parser = argparse.ArgumentParser(description=DESCRIPTION)
args = parser.parse_args()
tracks = set()
for line in sys.stdin:
path = line.strip()
tracks.add(track.Track(path).normalize())
tracks = [t for t in tracks if not can_be_simplified(t, tracks)]
for t in tracks:
print(t.path)
def on_add_sequencer(self, *args):
empty_track = track.Track(transport=self.document.transport)
tracks = track.TrackList(
tracks=(empty_track,),
transport=self.document.transport)
self.add_unit(track.SequencerUnit(
tracks=tracks,
view_scale=self.document.view_scale,
transport=self.document.transport,
name='Sequencer',
x=self.scene_pos.x(),
y=self.scene_pos.y()))
def add_track(self, track_name, album_name, artist_name):
if artist_name not in self.artists:
raise InputError('Artist not found. Please add artist')
artist = self.artists[artist_name]
new_track = track.Track(track_name, album_name, artist_name)
self.tracks.append(new_track)
if album_name not in artist.albums:
raise InputError('Album not found. Please add album.')
album = artist.albums[album_name]
album.tracks[track_name] = new_track # Connection from album to track
new_track.album = album # Connection from track to album
new_track.artist = artist # Connection from track to artist. Maybe unecessary
return new_track
def __init__(self):
self.time_res = 1 / 30.0
self.time = 0.0
self.thecar = car.Car()
self.thetrack = track.Track()
self.curr_checkpoint = 0
self.curr_lap_number = 0
self.thecar.set_start_pos(110, 300)
self.start_time = pygame.time.get_ticks()
self.total_score = 0.0
self.game_over = False
self.current_score = 0.0
self.font = pygame.font.Font(None, 20)
def evolution_sim(self):
generations_to_run = input_with_conditions(
"Please input number of generations to evolve [1-500]", int,
[lambda x: x > 0, lambda x: x < 500])
t = track.Track(track=self.track_json)
ev = evolution.Evolution(self.population, t, generations_to_run,
self.genetics)
temp_population = ev.run()
save = input_with_conditions("Accept evolution results (y/n)", str,
[lambda x: x in ["y", "n"]])
save = True if save == "y" else False
if save:
self.population.clear()
self.population.extend(temp_population)
def ProcessDirectory(db, path):
"""Process a directory. Called recursively."""
for ent in os.listdir(path):
entpath = '%s/%s' % (path, ent)
if os.path.isdir(entpath):
ProcessDirectory(db, entpath)
elif entpath.endswith('.mp3'):
#try:
this_track = track.Track(db)
this_track.FromPath(entpath)
if this_track.AddPath(entpath):
print entpath
this_track.Store()
def track(self):
ele = 'ele' if any(b.ele for b in self.b) else 'alt'
coords = [
Coord.deg(b.lat, b.lon, getattr(b, ele), b.dt) for b in self.b
]
kwargs = {}
kwargs['filename'] = os.path.basename(self.filename)
if 'plt' in self.h and not NOT_SET_RE.match(self.h['plt']):
kwargs['pilot_name'] = self.h['plt'].strip()
if 'gty' in self.h and not NOT_SET_RE.match(self.h['gty']):
kwargs['glider_type'] = self.h['gty'].strip()
if 'gid' in self.h and not NOT_SET_RE.match(self.h['gid']):
kwargs['glider_id'] = self.h['gid'].strip()
for k in self.i.keys():
if any(getattr(b, k) for b in self.b):
kwargs[k] = [getattr(b, k) for b in self.b]
return track.Track(coords, **kwargs)
def test_sample_solve_file(self):
"""Test sample.txt using solve()"""
# 1. Create default Track sample.txt
mytrack = track.Track()
# 2. Add the track from text
mytrack.from_file("../sample.txt")
# 3. Check a few things
self.assertEqual(len(mytrack.carts), 2)
self.assertEqual(mytrack.time, 0)
self.assertEqual(mytrack.size(), (12, 5))
self.assertEqual(str(mytrack), EXAMPLE[0])
# 4. Solve this puzzle for first collision
self.assertEqual(mytrack.solve(), (7, 3))
def test_derby_derby_file(self):
"""Test derby.txt using derby()"""
# 1. Create default Track object
mytrack = track.Track()
# 2. Add the track from derby.txt
mytrack.from_file("../derby.txt")
# 3. Check a few things
self.assertEqual(len(mytrack.carts), 9)
self.assertEqual(mytrack.time, 0)
self.assertEqual(mytrack.size(), (6, 6))
self.assertEqual(str(mytrack), DERBY[0])
# 4. Solve this puzzle for the last cart standing
self.assertEqual(mytrack.derby(), (6, 4))
self.assertEqual(str(mytrack), DERBY[len(DERBY) - 1])
