def load_gpx_file(file_name: str, use_local_time: bool) -> Track: """Load an individual GPX file as a track by using Track.load_gpx()""" log.info(f"Loading track {os.path.basename(file_name)}...") t = Track() t.use_local_time = use_local_time t.load_gpx(file_name) return t
class Generator: def __init__(self, inputt, musicName, initialBPM, initialInstrument): input_converter = Input_information_converter(inputt) translator = Translator() self._text = input_converter.get_text() self._instructions = translator.translate_text_to_instructions( self._text) self._music_name = musicName self._initial_bpm = initialBPM self._initialInstrument = initialInstrument self._track = Track(1, self._initial_bpm, self._initialInstrument) # Saída: um arquivo .mid é gerado # Retorna: o próprio texto de entrada def generate_song(self): METHOD = 0 ARG = 1 for instruction in self._instructions: method = instruction[METHOD] arg = instruction[ARG] callTrackMethod = getattr(self._track, method, 'repeatNote') callTrackMethod(arg) self._track.finishMusic(self._music_name) return self._text
def add_local_tracks(self): ''' Scan the content folder and add local tracks. This only scans the top level folder. No subdirectories. ''' # Create a bogus track to fix the issue # where the screen clears itself # This trigger the delayed import of CLI t = Track('', '', 0, '', b'', '') self.cli.log( f"Checking directory '{constant.FILE_PREFIX}' for media... ") # Only check 1 level deep tracks = [] files = os.listdir(constant.FILE_PREFIX) for file in files: if (os.path.isfile(os.path.join(constant.FILE_PREFIX, file))): self.cli.log(f"Processing '{file}'...") tracks.append(Track.from_file(file)) self.add_tracks(tracks) self.cli.log('Done')
def update_trackers(self, i, obs, match_mat): """ Updates the trackers based on the matching with detections. If match found, runs the tracker's update function. Else a new tracker is instantiated. Args: obs: List of mx1 observations match_mat (num_trackers, num_obs): Binary matrix specifying which tracker matches which detection Returns: Nothing """ for j in range(match_mat.shape[1]): total = match_mat[:,j].sum() if total>0: t_idx = match_mat[:,j].argmax() self.tracks[t_idx].update(obs[j], i) else: # Pop new tracker ontop of the queue of trackers t = Track() t.update(obs[j], i) self.tracks.append(t)
def update_and_get_tracks(self, dets, image): # ---- Initialize list of predictions with number of current trackers. ---- # curr_preds = np.zeros((len(self.trackers), self._NUM_OF_COORDINATES)) failed_to_predict = [] for p, _ in enumerate(curr_preds): success, pos = self.trackers[p].predict(image) if success: curr_preds[p] = np.array(utils.convert_xywh_to_bbox(pos)) else: failed_to_predict.append(p) # Iterate from the end so indices of need-to-be-deleted elements will be preserved. for p in reversed(failed_to_predict): curr_preds = np.delete(curr_preds, p, axis=0) self.trackers.pop(p) matched, unmatched_dets, unmatched_trks = \ utils.associate_detections_to_trackers(dets, curr_preds, self.iou_threshold) # ---- update matched trackers with assigned detections. ---- # failed_to_update = [] for t, track in enumerate(self.trackers): if t not in unmatched_trks: d = matched[np.where(matched[:, 1] == t)[0], 0][0] succ = track.update(image, utils.convert_bbox_to_xywh(dets[d])) if not succ: failed_to_update.append(t) # Iterate from the end so indices of need-to-be-deleted elements will be preserved. for p in reversed(failed_to_update): self.trackers.pop(p) # ---- create and initialise new trackers for unmatched detections ---- # for i in unmatched_dets: new_tracker = Track(tracker=self.tracker) succ = new_tracker.update(image, utils.convert_bbox_to_xywh(dets[i])) if succ: self.trackers.append(new_tracker) # ---- Return predictions ---- # returned_preds = [] # returned_preds_ids = [] i = len(self.trackers) for track in reversed(self.trackers): i -= 1 success, pos = track.get_state(image) if not success or track.time_since_update > self.max_age: self.trackers.pop(i) continue if (track.time_since_update < self.use_time_since_update) and (track.hits >= self.min_hits or self.frame_count <= self.min_hits): returned_preds.append(utils.convert_xywh_to_bbox(pos)) returned_preds_ids.append(i) return returned_preds, returned_preds_ids
def __init__(self): """Creates all game objects needed, loads resources, initializes pygame library and sound mixer, sets display mode, etc.""" self.state = STATE_TITLE pygame.mixer.pre_init(buffer=SOUND_BUFFER) pygame.init() self.clock = Clock() self.scr = pygame.display.set_mode(SCREEN_SIZE, VID_MODE_FLAGS) pygame.display.set_caption(WINDOW_CAPTION) pygame.mouse.set_visible(False) LoadingScreen(self.scr).draw() sound_box.init() self.level = GameLevel() self.stats = GameStats(self.scr) self.view_pt = ViewPoint(self.scr) self.stars = Stars(self.scr, self.view_pt) self.track = Track(self.scr, self.view_pt) self.explosions = Explosions(self.scr, self.view_pt) self.ship = Ship(self.scr, self.view_pt, self.explosions) self.asteroids = Asteroids(self.scr, self.view_pt, self.explosions, self.track) self.title_screen = TitleScreen(self.scr, self.view_pt, self.stars) self.level_start_screen = LevelStartScreen(self.scr) self.level_complete_effect = LevelCompleteEffect(self.scr) self.game_over_effect = GameOverEffect(self.scr) self.pause_screen = PauseScreen(self.scr) self.ending_screen = EndingScreen(self.scr) self._init_title()
def add_track(self, loc, trackdb): track = trackdb.get_track_by_loc(loc) if not track: track = Track(loc) respone = trackdb.add_track_from_trackobj(track) if not respone: return False tr_album = track.get_tag_raw('album', True) tr_albumartist = track.get_tag_raw('albumartist', True) if tr_albumartist == u'': tr_albumartist = track.get_tag_raw('artist', True) album = self.get_album_from_info(tr_album, tr_albumartist) if not album: # create new album album = Album(tr_album, tr_albumartist) self.__albums[(tr_album, tr_albumartist)] = album album.unchecked_add_song(track) self.__total_duration += track.get_tag_raw('__length') # cover = coverdb.get_cover(tr_album, tr_albumartist) # if not cover: # tr_cover = track.get_tag_disk('cover') # if tr_cover: # coverdb.add_cover(tr_album, tr_albumartist, tr_cover) return track
def loadTrack(self, trackfilename, track_id, flight_start): #trackflilename does not include the path, it's only name and extesion #track = open("./Flight1.txt", "r") track = Track(track_id) cont = 0 with open(self.scenariosfolder + "/" + self.scenarioName + "/" + trackfilename, "r") as trackfile: for line in trackfile: if (not (line.startswith('#') or line.startswith('/'))) and len(line)>30: #if cont >= 4 and len(line)>30: parts = line.split() timestamp = parts[0] lat = float(parts[1]) lon = float(parts[2]) altitude = float(parts[3]) heading = float(parts[6]) v_x = float(parts[8]) v_y = float(parts[10]) v_z = float(parts[9]) pitch = float(parts[4]) bank = float(parts[5]) onground = int(parts[7]) airspeed = float(parts[19]) track.addStep(timestamp, lat, lon, altitude, v_x, v_y, v_z, heading, pitch, bank, onground, airspeed) #track.addStep(timestamp, lat, lon, altitude, v_x, v_y, v_z, heading, pitch, bank) #cherrypy.log("%s,%s,%s,%s,%s,%s,%s,%s"%(timestamp, lat, lon, altitude, v_x, v_y, v_z, heading),context="EXPORT,") cont += 1 track.setStart(flight_start) return track
def create_simple_track(): """ Creates a simple track for a line follower robot. :return: the simple track. :rtype: Track. """ track_width = 2.0 track_height = 1.0 screen_width_m = SCREEN_WIDTH * PIX2M screen_height_m = SCREEN_HEIGHT * PIX2M padding_y = screen_height_m - track_height padding_x = screen_width_m - track_width track = Track() track.add_line_piece( Vector2(padding_x / 2.0 + track_height / 2.0, padding_y / 2.0), Vector2(screen_width_m - padding_x / 2.0 - track_height / 2.0, padding_y / 2.0)) track.add_arc_piece( Vector2(screen_width_m - padding_x / 2.0 - track_height / 2.0, padding_y / 2.0 + track_height / 2.0), track_height / 2.0, -pi / 2.0, pi / 2.0) track.add_line_piece( Vector2(screen_width_m - padding_x / 2.0 - track_height / 2.0, screen_height_m - padding_y / 2.0), Vector2(padding_x / 2.0 + track_height / 2.0, screen_height_m - padding_y / 2.0)) track.add_arc_piece( Vector2(padding_x / 2.0 + track_height / 2.0, padding_y / 2.0 + track_height / 2.0), track_height / 2.0, pi / 2.0, 3.0 * pi / 2.0) return track
def run(): # create instance of player player = Player("myPlayer") # create instances for the following three tracks track1 = Track("Incubus", "Drive", "Make Yourself") track2 = Track("Ritchie Valens", "La Bamba", "La Bamba") track3 = Track("Red Hot Chilli Peppers", "Californication", "Californication") # add tracks to player player.add(track1) player.add(track2) player.add(track3) # play tracks player.play() player.next() player.play() player.next() player.play() player.next() player.play() player.previous() player.play() # directly select a track player.selectTrack(1) player.play() # print out all tracks player.printTracksInfo()
def loadJSON(self, src): json_db = [] with open(src, 'r') as f: json_db = f.readlines() for track in json_db: track_object = Track() track_object.__dict__ = json.loads(track) self.db[track_object.beatport_id] = track_object
def test_likelihood(self): """ Tests that the likelihood function of track works and produces the correct result """ t = Track(np.matrix('0. 0.').T, np.matrix('1. 0.; 0. 1.')) # Pass mean and covariance y = np.matrix(0.5) print(t.likelihood(y))
def main(): parser = argparse.ArgumentParser() parser.add_argument('tracking') args = parser.parse_args() package = Track(args.tracking) os.system('clear') package.track_factory()
def initthread(mwc, mc): library = mwc.library mwc.status_msg("Initializing..") wc = Webclient() wc.login(config.user, config.password) devices = wc.get_registered_devices() mwc.status_msg("Retrieving usable device ID..") for dev in devices: if dev["type"] == "PHONE": # strip 0x if present config.devid = dev["id"][2:] if dev["id"].startswith("0x") else dev["id"] print("Found a usable device id: " + config.devid) break else: md = Gtk.MessageDialog(parent=mwc.ui, buttons=Gtk.ButtonsType.OK, message_type=Gtk.MessageType.ERROR, message_format="Could not find a usable device id. Please run the Google Play Music app at least once on your phone.") GLib.idle_add(modal_dialog_func, md) mc.login(config.user, config.password) player = Player(mc, config.devid) mwc.setplayer(player) def getalbumart(structure): if "albumArtRef" in structure: a = structure["albumArtRef"] for entry in a: if "url" in entry: return entry["url"] return None mwc.status_msg("Retrieving library..") songs = mc.get_all_songs() for song in songs: track = Track(song["id"], song["title"], song["artist"], song["album"], song["trackNumber"] if "trackNumber" in song else 0) track.albumarturl = getalbumart(song) library.add_track(track) mwc.status_msg("Retrieving playlists..") playlists = mc.get_all_user_playlist_contents() for x in playlists: tracks = [] for t in x["tracks"]: if t["trackId"].startswith("T"): # all access track trackEntry = t["track"] track = Track(t["trackId"], trackEntry["title"], trackEntry["artist"], trackEntry["album"], trackEntry["trackNumber"]) track.albumarturl = getalbumart(trackEntry) tracks.append(track) else: libtrack = library.find_track(t["trackId"]) if libtrack is not None: tracks.append(libtrack) library.add_list(Playlist(x["name"], tracks)) mwc.status_msg("Idle")
def generate_tracks(self): assert len(self.sentences) > 0 # initialize each language track self.tracks = {locale: Track(locale) for locale in self.target_locales} self.tracks[self.input_locale] = Track(self.input_locale) # save a concatenation of all the sentences in all languages to disk for idx, sentence in enumerate(self.sentences): self._add_sentence_to_track(sentence)
def row_to_entity(row): spot_entity = Spot() spot_entity.id = row.id spot_entity.name = row.name spot_entity.position = GeoPoint.row_to_object(row.position) spot_entity.tags = row.tags spot_entity.tracks_current = [Track.row_to_object(track_row) for track_row in row.tracks_current] spot_entity.tracks_old = [Track.row_to_object(track_row) for track_row in row.tracks_old] return spot_entity
def load_midi(self): chunk_extractor = ChunkExtractor(self.midi_path) self.header = Header(chunk_extractor.header) for track in chunk_extractor.tracks: self._current_track = Track(track[1], track[2]) message_extractor = MessageExtractor(track) self.tracks.append( Track(message_extractor.track[1], message_extractor.track[2])) self.allocate_messages(message_extractor.events)
def __init__(self, fn, name="Song name", cache_dir=None, refresh_cache=False, labels=None, labels_in_file=False): self._analysis = None self._checksum = None self.refresh_cache = refresh_cache self.cache_dir = cache_dir Track.__init__(self, fn, name, labels=labels, labels_in_file=labels_in_file)
def __assign_detections_to_tracks_munkres(self, detections, frame_id, save=False): # if there are no tracks yet, all detections are new tracks if len(self.tracks) == 0: for det in detections: t = Track() t.add_to_track(det) self.tracks.append(t) return True # find distance from all tracks to all detections and formulate dists matrix dists = np.zeros(shape=(len(self.tracks), len(detections))) for i, track in enumerate(self.tracks): predicted_next_bb = track.get_predicted_next_bb() for j, det in enumerate(detections): dist = util.dist_btwn_bb_centroids(predicted_next_bb, det.bbox) if track.is_singular(): max_dist = const.MAX_PIXELS_DIST_TRACK_START else: max_dist = const.MAX_PIXELS_DIST_TRACK if dist > max_dist: dist = 1e6 # set to arbitrarily high number dists[i, j] = dist # set all tracks as unassigned for t in self.tracks: t.has_match = False # assign all detections to tracks with munkres algorithm assigned_rows, assigned_cols = linear_sum_assignment(dists) for idx, row in enumerate(assigned_rows): col = assigned_cols[idx] # if track is assigned a detection with dist=1e6, discard that assignment if dists[row, col] != 1e6: self.tracks[row].has_match = True detections[col].has_match = True self.tracks[row].add_to_track(detections[col]) self.tracks[row].num_misses = 0 # create new tracks from unassigned detections: for det in detections: if det.has_match is False: t = Track() t.add_to_track(det) self.tracks.append(t) # keep track of how many times a track has gone unassigned for t in self.tracks: if t.has_match is False: t.num_misses += 1 # t.propagate_track(frame_id=frame_id) # cleanup any duplicate tracks that have formed (TODO: how do they form?) self.__delete_duplicate_tracks() # save dead tracks before deletion if save: self.__save_tracks_to_json() # remove dead tracks self.tracks = [t for t in self.tracks if (t.is_dead() is False and t.delete_me is False)]
def __init__(self, fn, name="Speech name", labels=None, labels_in_file=False): Track.__init__(self, fn, name, labels=labels, labels_in_file=labels_in_file)
def filter(self, dt, z, R): associated = [track.filter(dt, z, R) for track in self.tracks] if not any(associated): new_track = Track(filter_model=self.filter_factory()) new_track.filter(dt, z, R) self.tracks.append(new_track)
def _test_drawing(self): t1 = Track(np.matrix('0. 0.').T, np.matrix('1. 0.; 0. 1.')) t2 = Track(np.matrix('2. 2.').T, np.matrix('1. 0.; 0. 1.')) tracks = [t1, t2] e = TrackerEngine(0.1, []) e.tracks = tracks e.draw() raw_input('your mom')
def parse_response(self, response_json): playlist = [] # used to get rid of duplicate tracks in same album album_set = Set() parsed_json = json.loads(response_json) # first check if the json can be correctly parsed if not 'tracks' in parsed_json: return all_tracks json_tracks = parsed_json['tracks'] for json_track in json_tracks: track = Track() curTrackMap = {} album = json_track['album']['name'].lower() if album in album_set: continue album_set.add(album) track.set_album(album) track.set_name(json_track['name'].lower()) artists = json_track['artists'] artists_name = [] for artist in artists: artists_name.append(artist['name'].lower()) track.set_artists(artists_name) track.set_length(json_track['length']) playlist.append(track) return playlist
def get_track(provider_id): t = Track() try: ######MediaNet###### # reqUrl = 'http://ie-api.mndigital.com?method=track.get&format=json&'\ # + urllib.urlencode({'mnetid': provider_id})\ # + '&ApiKey=%s' % MusicProvider._mnDigitalIntegrationAPIKey reqUrl = "http://itunes.apple.com/lookup?" + urllib.urlencode({"id": provider_id}) # track_json = common.get_json(reqUrl)["Track"] track_json = common.get_json(reqUrl)["results"][0] t.provider_id = provider_id t.length_seconds = 0 t.url = "" # t.artist = track_json["Artist"]["Name"] # t.title = track_json["Title"] # t.length_friendly = track_json["Duration"] # t.album = track_json["Album"]["Title"] # t.art_url = track_json["Album"]["Images"]["Album150x150"] t.artist = track_json["artistName"] t.title = track_json["trackName"] t.length_friendly = "" t.album = track_json["collectionName"] t.art_url = track_json["artworkUrl100"] except Exception: pass return t
def __init__(self, scale: float = 4.0, steps: int = 30, time: float = 20.0, racers=[]): self.racers = racers self.track = Track(scale) self.trigger_distance = scale * 0.01 self.time_steps = steps self.time_limit = time self.goals = []
def __init__(self, *args, settings=None, carnum=10, width=960, height=540, vsync=True, **kwargs): config = pyglet.gl.Config(sample_buffers=1, samples=1, depth_size=16, double_buffer=True) super().__init__(width=width, height=height, config=config, resizable=True, vsync=vsync) self.keystate = key.KeyStateHandler() self.push_handlers(self.keystate) self.settings = defaultdict(bool) if type(settings) == dict: self.settings.update(settings) self.init_speed = self.settings['speed'] if type( self.settings['speed']) == int else 25 self.carnum = (carnum + 1) // 2 * 2 # need even number self.carnum = carnum self.cars = [] self.car = Car( sensors=self.settings['sensors'], human=True) # will be deleted later if simulation starts self.carline_colours = tuple() self.track = Track() self.car.put_on_track(self.track) self.generation = 0 self.cars_pos_vbo = VertexBufferObject(self.carnum * 64, GL_ARRAY_BUFFER, GL_DYNAMIC_DRAW) self.cars_col_vbo = VertexBufferObject(self.carnum * 96, GL_ARRAY_BUFFER, GL_STATIC_DRAW) self.time = 0 self.fps = pyglet.clock.ClockDisplay() self.times = defaultdict(list) self.counter = 0 self.setup_labels() self.x = 0 self.y = 0 self.scale = 1 pyglet.clock.schedule_interval(self.update, 1.0 / 60)
def __init__(self, inputt, musicName, initialBPM, initialInstrument): input_converter = Input_information_converter(inputt) translator = Translator() self._text = input_converter.get_text() self._instructions = translator.translate_text_to_instructions( self._text) self._music_name = musicName self._initial_bpm = initialBPM self._initialInstrument = initialInstrument self._track = Track(1, self._initial_bpm, self._initialInstrument)
def play(self, position = 0, onError = None): if len(self.tracks) > 0 and len(self.tracks) > position: self.position = position if onError == None: self.currentTrack = Track(self.tracks[self.position]) else: self.currentTrack = Track(self.tracks[self.position], onError) self.currentTrack.setVolume(self.volume) self.currentTrack.play() else: raise IndexError('Wrong track position')
def makeTracks(self): self.track_size = (self.screen_size[1]-(2*self.safe_area)-(2*10))/self.num_tracks tracks = [None for i in range(self.num_tracks)] tracks[0] = Track(0, 'r', self.safe_area+10) for i in range(1, self.num_tracks): if i < self.num_tracks/2: tracks[i] = Track(i, 'r', tracks[i-1].position + self.track_size) else: tracks[i] = Track(i, 'l', tracks[i-1].position + self.track_size) return tracks
def test_rgbAsGrayScale(): arr = [10,20,30,40,50,60,70,128,256] mockFrame = np.array(arr).reshape(3,3) "Mockframe is an array where the value of the number represents the color 0 being black, 256 being white" np.testing.assert_allclose( Track.rgbAsGrayscale(mockFrame, False), np.dot(mockFrame[..., :], [0.299, 0.587, 0.114]) ) np.testing.assert_allclose( Track.rgbAsGrayscale(mockFrame), (np.dot(mockFrame[..., :], [0.299, 0.587, 0.114]) / 128. - 1.) )
def lets_race(drivers=[Car("Rarri"), Car("Tesla")]) -> str: t = Track() done = False while not done: for d in drivers: print(d) d.accelerate() t.check_winner(d) if t.winner: done = True return "And the winner is: {}".format(t.winner)
def index(self, path): for top, dirnames, filenames in os.walk(path): for filename in filenames: if filename.endswith('.mp3'): full_path = os.path.join(top, filename); f = tagpy.FileRef(full_path) t = Track("file://" + full_path) t.title = f.tag().title t.artist = f.tag().artist t.album = f.tag().album a = f.audioProperties() t.duration = a.length * 1000 # to msec self.add_track(t)
def _test_likelihood_mat(self): """ Provide mock tracker objects and detections and check that the correct likelihood value is generates """ t1 = Track(np.matrix('0. 0.').T, np.matrix('1. 0.; 0. 1.')) t2 = Track(np.matrix('2. 2.').T, np.matrix('1. 0.; 0. 1.')) #tracks = [t1, t2] tracks = [] detections = [[np.matrix(0.), np.matrix(1.), np.matrix(2.)]] e = TrackerEngine(0.1, detections) print('likelihood is') print(e.likelihood_mat(tracks, detections[0]))
def __init__(self, parent=None): super(PlayerView, self).__init__(parent) # Player data self.setMinimumSize(800, 600) self.log = Log(self) self.log.widget.move(600, 100) self.track = Track(self) self.track.move(600, 300) self.hand = Hand(self) self.hand.move(0, 400) self.map = Map(self) self.multiChoice(('asdf', 'qwer'))
def load_from(data): if data["schema"] != DB_SCHEMA: return for d in data["genres"]: Genre.unpickle(d) for d in data["artists"]: Artist.unpickle(d) for d in data["albums"]: Album.unpickle(d) for d in data["tracks"]: Track.unpickle(d) for l in data["libraries"]: Library.unpickle(l)
def get_track_row(self): row = self.db.fetchone() tid = row["track_id"] position = row["position"] ptid = row["id"] self.db.commit_statement("""select * from tracks where id = ?""", [row["track_id"]]) row = self.db.fetchone() del row["id"] t = Track(**row) t.id = tid t.position = position t.ptid = ptid return t
def get_track_row(self): row = self.db.fetchone() tid = row['track_id'] position = row['position'] ptid = row['id'] self.db.commit_statement('''select * from tracks where id = ?''', [row['track_id']]) row = self.db.fetchone() del row['id'] t = Track(**row) t.id = tid t.position = position t.ptid = ptid return t
def track_agregar(self, funcion_sonido, frecuencia, volumen): """ Pre: recibe una funcion de la lista de funciones (cadena), una frecuencia, volumen (enteros o decimales). Post: crea y agrega un nuevo track. """ track = Track(funcion_sonido, frecuencia, volumen, DUTY_CYCLE) self.tracks.append(track.dar_sonido()) self.info_tracks.append( [funcion_sonido.upper(), str(frecuencia), str(volumen)]) self.canales += 1 self.cursor.track_agregar()
def output_aligns(outfile, aligns, track_name=None, contigs=None, append=False, header=True, genome=None, refseq=None, color=None, by_fasta=False, annodir=None): """Outputs alignments to file""" ext = os.path.splitext(outfile)[1] if append: out = open(outfile, 'a') else: out = open(outfile, 'w') # desc == name track_desc = track_name if aligns: if track_name and genome: Track.ucsc_targets(genome, aligns, annodir) if header and track_name: header_line = "track name=\"%s\" description=\"%s\" visibility=%d itemRgb=\"On\"" % (track_name, track_desc, 3) if color is not None: header_line += ' color=\"%s\"' % (color) out.write("%s\n" % (header_line)) # map contig to contig name contig_dict = None if contigs: contig_dict = dict((contig.num, contig) for contig in contigs) # sort alignments by contig order in original input fasta file if by_fasta: count = 0 ordered = {} for contig in contigs: ordered[contig.num] = count count += 1 aligns.sort(lambda x,y: ordered[x.query] - ordered[y.query]) for align in aligns: contig = align.query if ' ' in contig: contig = align.query.split(" ")[0] if contig_dict and contig_dict.has_key(contig): align.contig = contig_dict[contig] if ext == ".gff": out.write(align.gff("exon")) elif ext == ".psl": out.write(align.psl(refseq=refseq, genome=genome)) out.close()
def compute_tracks(event): map.clear_log() map.log(txt='>> 8: Compute tracks\n\n') if len(trajectories) == 0 or len(ntc) == 0: map.log(txt="Error: No trajectories or cluster computed.\n") else: global tracks_computed if not tracks_computed: global track_index, macro_index track_index = 0 macro_index = 0 print(macro_clusters) map.draw_init(Aoi.select(), origin, controls) for traj in trajectories: if len(tracks) == 0: tracks.append(Track()) tracks[0].add_trajectory(traj) else: if tracks[len(tracks) - 1].id == traj.track: tracks[len(tracks) - 1].add_trajectory(traj) else: tracks.append(Track()) tracks[len(tracks) - 1].add_trajectory(traj) tracks_computed = True map.log(txt="Tracks computed.\n") # Macro cluster for track in tracks: key = str(track.cluster_code) macro_clusters[key] = macro_clusters.get(key, 0) + 1 map.log(txt="Macro clusters computed.\n\n") else: map.log(txt="Tracks already computed. \n\n") ord_macroclusters = OrderedDict( sorted(macro_clusters.items(), key=operator.itemgetter(1), reverse=True)) map.log(txt="Macro clusters:\t\n") for macrocluster_code in ord_macroclusters: color_keys = [] cluster_codes = list(eval(macrocluster_code)) for cluster_code in sorted(cluster_codes, reverse=True): color_keys.append(colors.keys()[cluster_code]) map.log(txt=str(color_keys) + " " + str(ord_macroclusters[macrocluster_code]) + "\n")
class TestTrack(unittest.TestCase): def setUp(self): """Start unittest attributes""" self.talk_objects = TALK_OBJECTS self.schedule = Schedule(self.talk_objects) self.track = Track(self.schedule.list_slice[0]) def test_combination(self): self.track.get_list_track() def test_mount_str(self): time = datetime.now().replace(hour=12, minute=0) str_mount = self.track.mount_str(time, "Lunch") self.assertEqual(str_mount, "12:00PM Lunch \n")
class App(Tk): def __init__(self, ftimer): Tk.__init__(self) self.sats = Track() self.sats.load_local("data.txt") # to be changed self.sats.add_satellite(7) # achtung, hardcode menu = UserMenu(parent = self) self.config(menu = menu) self.title('SatKit Ground Tracking') self.timer = ftimer self.timer.callback_function = self.redraw self.time_speed = 1 # normal speed self.var = IntVar() self.scale = Scale(self, variable = self.var, from_ = 1, to = 3600, orient = HORIZONTAL, showvalue=0, sliderlength=15, length=400, command=self.set_time_speed) self.date = Label(self) def redraw(self): self.timer.set_speed(self.time_speed) # bad, should be improven,~event self.sats.update_satellites(self.time_speed * Time.TIMER_INTERVAL) #print self.time_speed # recompute "current" time, later,,, self.date.config(text = str(self.timer.current_time)[0:21]) self.date.grid(row = 0, column = 1) self.scale.grid(row = 0, column = 0) self.sats.anim.grid(row = 1, columnspan = 2) self.sats.draw() def set_time_speed(self, secs): self.time_speed = int(secs)
def scrapeFileTags(path): if path.suffix == ".flac": f = FLAC(path) elif path.suffix == ".mp3": f = EasyID3(path) tr = Track(0) tr.file_name = path.name tr.file_path = path # extract artist and title try: tr.artists = f['ARTIST'] or f['artist'] tr.title = f['TITLE'].pop().split(' (')[0] or f['title'].pop().split( ' (')[0] except: print("*** error cannot match file without artist or title") print(f"*** skipping {path.name}") return # try to extract remixer try: tr.remixer = f['TITLE'][0].split('(')[1].split( ')')[0] or f['title'][0].split('(')[1].split(')')[0] except: # assume it's original mix, when no remixer is supplied tr.remixer = "Original Mix" return tr
def main(args): ''' Main method ''' if len(args) < 3: print( "Please provide the necessary parameters ie kexp.py [playlist_name] [start_date] [end_date] [playlist_description]" ) else: #The name of the playlist you want to use in Spotify #If this playlist does not exist a new one with this name will be created #If this playlist exists it will be used playlist_name = args[0] #The start date time of the tracks you want to return. #The KEXP API is in UTC format so make this date must be in the UTC format and timezone #Example: 2019-02-15T02:00:00Z start_date = args[1] #The end date time of the tracks you want to return. #The KEXP API is in UTC format so make this date must be in the UTC format and timezone #Example: 2019-02-15T05:00:00Z end_date = args[2] #The description of the playlist you want to appear in Spotify playlist_description = args[3] #Create new Playlist object #Set this particular playlist properties #Send the playlist object into Spotify to create/update the latest playlist = Playlist() spotify = Spotify() playlist.name = playlist_name playlist.description = playlist_description temp_tracks = [] uri = f'https://api.kexp.org/v2/plays/?airdate_after={start_date}&airdate_before={end_date}&album=&album_exact=&artist=&artist_exact=&exclude_airbreaks=&has_comment=&host_ids=&label=&label_exact=&limit=2000&ordering=airdate&recording_id=&show_ids=&song=&song_exact=' temp_tracks = get_tracks(uri, start_date, end_date) for temp_track in temp_tracks: if not any(x.airdate == temp_track['airdate'] for x in playlist.tracks): track = Track() track.artist = temp_track['artist'] track.title = temp_track['song'] track.airdate = temp_track['airdate'] playlist.tracks.append(track) playlist.tracks.sort(key=extract_time, reverse=False) spotify.create_playlist(playlist)
class CyclopsEvolver(TournamentEvolver): def __init__(self, popSize, tournSize, nIters): super().__init__(popSize, tournSize, nIters) self.track = Track() self.simDuration = self.track.size * 4 self.startSeed = random.random() def randomIndividual(self): nNeurons = 8 return System(nNeurons) def mutated(self, system): return self.mutatedPartial(system, 1, 8) def mutatedPartial(self, system, mean, variance): sys = system.copy() #sys.trans += variance / 4 * numpy.random.randn(*sys.trans.shape) sys.trans *= mean + variance * numpy.random.randn(*sys.trans.shape) #sys.trans += 1/8 * numpy.random.randn(*sys.trans.shape) return sys def fitness(self, system): return sum(self.fitness1(system, self.startSeed + i) for i in range(64)) def fitness1(self, system, seed): distances = [] def distanceTracker(track): rawDist = track.bot.position - track.flag.position dist = min(rawDist % track.size, (-rawDist) % track.size) distances.append(dist) self.simulate(system, distanceTracker, seed) return -sum(d for d in distances[-self.track.size : ]) def simulate(self, system, watcher, seed=None): # initialize conditions self.track.reset(seed) system.reset() # simulate for iteration in range(self.simDuration): self.track.step(system) watcher(self.track) def animate(self, system): frames = [] def frameCapturer(track): frames.append(track.drawnState()) self.simulate(system, frameCapturer)#, self.startSeed) return frames
def __init__(self, width, height): self.controls = None self.round_manager = RoundManager(self) self.ui_font = font.Font("./fonts/FreeSansBold.ttf", 12) self.round_label_font = font.Font("./fonts/FreeSansBold.ttf", 20) self.mouse_position = (0, 0) self.placing_tower = False self.selected_place_tower = build_tower(self, BALLISTA_TOWER) self.selected_active_tower = None self.ui_tower_image = build_tower(self, BALLISTA_TOWER).image self.generate_tower_placement_sprite() self.tower_select_index = 0 self.money = 20000 self.lives = 50 self.start_tile = 16, 16 self.width, self.height = width, height self.entities = pygame.sprite.Group() self.towers = pygame.sprite.Group() self.projectiles = pygame.sprite.Group() self.explosions = pygame.sprite.Group() total_level_width = width*16 total_level_height = height*16 self.generate_background_image() self.track = Track() self.camera = Camera(complex_camera, total_level_width, total_level_height)
def createNewTracks(self, detections, unmatchedDetections): for detectionIndex in unmatchedDetections: detection = detections[detectionIndex] array_detection = np.array(detection, np.float32) # TODO: Create Kalman filter object kf = cv2.KalmanFilter(4, 2) kf.measurementMatrix = MEASUREMENT_MATRIX kf.transitionMatrix = TRANSITION_MATRIX # kf.processNoiseCov = PROCESS_NOISE_COV # Create the new track newTrack = Track(self.nextTrackID, kf) newTrack.update(array_detection) newTrack.locationHistory.append(detection) self.tracks.append(newTrack) self.nextTrackID += 1
def remove_track(self, loc, trackdb): """ Remove song from playlist with given location. """ track = trackdb.get_track_by_loc(loc) if not track: track = Track(loc) if not track._scan_valid: return False tr_album = track.get_tag_raw('album', True) tr_albumartist = track.get_tag_raw('albumartist', True) if tr_albumartist == u'': tr_albumartist = track.get_tag_raw('artist', True) album = self.get_album_from_info(tr_album, tr_albumartist) if not album: return False return album.remove_track(loc)
class TrackThreader(): def __init__(self): self.track = None self.onEndCustomCallback = None self.volume = volumizer.getJSON()['config']['milli'] def __play_track(self, track, callback = None): self.setVolume(volumizer.getJSON()['config']['milli']) if(callback == None): track.play() else: callback(track) self.__oversee_track(track) #This makes track to disapear after it's done playing def __oversee_track(self, track): while (track.isBusy() or track.isPaused()) and not track.shouldEnd(): continue if(self.onEndCustomCallback == None): if(self.track != None): print(self.track.getPath() + " finished playing.") self.setTrack(None) else: self.__play_track(track, self.onEndCustomCallback) def getThread(self, path): self.track = Track(path, self.volume) self.playingThread = threading.Thread(target = self.__play_track, args=(self.track, )) self.playingThread.daemon = True return {'thread' : self.playingThread, 'track' : self.track} def currentTrack(self): return self.track def setTrack(self, track): self.track = track def setVolume(self, volume): self.volume = volume if self.track != None: self.track.setVolume(volume) def registerOnEndCustomCallback(self, callback): self.onEndCustomCallback = callback
def as_list(path: str, pattern: str, default_artist="", default_title="", type="song"): file_list = [] for file_path in Path(path).glob(pattern): try: file_list.append( Track.from_path(str(file_path), default_artist, default_title, type=type, raise_error=False) ) except (KeyError, IOError) as err: print(err) return file_list
def get_track_nbr(self, nbr): self.db.commit_statement('''select * from playlist_tracks where playlist_id = ?''', [int(self.id)]) row = self.db.fetchone() # There is probably a much smarter way to fetch a specific row number i = 0 while i < nbr: row = self.db.fetchone() i = i + 1 tid = row['id'] self.db.commit_statement('''select * from tracks where id = ?''', [row['track_id']]) row = self.db.fetchone() del row['id'] t = Track(**row) t.id = tid return t
def get_all_tracks(self): self.db.commit_statement('''select * from playlist_tracks where playlist_id = ?''', [int(self.id)]) row = self.db.fetchone() tracks = [] while row != None: tracks.append((str(row['id']), row['track_id'])) # FIXME: broken! row = self.db.fetchone() ret_tracks = [] for track in tracks: # TODO: replace with an SQL statement that instantly creates a Track object self.db.commit_statement('''select * from tracks where id = ?''', [track[1]]) row = self.db.fetchone() del row['id'] t = Track(**row) t.id = track[0] # add the playlist-to-track id instead ret_tracks.append(t) return ret_tracks
def indexFromFile(self): self.file = open(os.getcwd() + '/options/index.txt', 'r') path = None line = self.file.readline() while line != '': code = line[0:2] if code == "NP": path = line[2:-1] line = self.file.readline() t = Track() t.path = path + "/" + line[0:-1] t.artist = self.file.readline()[0:-1] t.title = self.file.readline()[0:-1] t.album = self.file.readline()[0:-1] self.tracks.append(t) self.gui.addTrack(t) line = self.file.readline() self.file.close() self.gui.loading_finished()
def load(self, tracknames=None): treestr = self.level*TAB + self.id + '/' # print string to tree hierarchy and screen self.writetree(treestr + '\n') print(treestr) if tracknames != None: tracknames = tolist(tracknames) dirnames = tracknames else: # all track folder names for this animal: dirnames = [ dirname for dirname in os.listdir(self.path) if os.path.isdir(os.path.join(self.path, dirname)) and dirname.lower().startswith('tr') ] dirnames.sort() # alphabetical order for dirname in dirnames: path = os.path.join(self.path, dirname) track = Track(path, animal=self) track.load() self.tr[track.id] = track self.__setattr__('tr' + str(track.id), track) # add shortcut attrib
def post(self): j=self.request.body data=json.loads(j) video=None video=memcache.get("video of %s %s"%(data["name"],data["artist"]["name"])) trackKey=ndb.Key('Track',data["name"]+ " - " +data["artist"]["name"] ) track=trackKey.get() if track is None: track=Track(key=trackKey) track.getVideo() video={} video["ytid"]=track.ytid video["img"]="http://img.youtube.com/vi/"+video["ytid"]+"/0.jpg" memcache.set("video of %s %s"%(data["name"],data["artist"]["name"]), video) self.response.out.write(json.dumps(video))
def get_all_tracks(self): self.db.commit_statement( """select * from playlist_tracks where playlist_id = ? order by position""", [int(self.id)] ) row = self.db.fetchone() tracks = [] while row != None: tracks.append((str(row["id"]), row["track_id"])) # FIXME: broken! row = self.db.fetchone() ret_tracks = [] for track in tracks: # TODO: replace with an SQL statement that instantly creates a Track object self.db.commit_statement("""select * from tracks where id = ?""", [track[1]]) row = self.db.fetchone() del row["id"] t = Track(**row) t.id = track[0] ret_tracks.append(t) return ret_tracks
def set_files(self, files_list): for i,f in enumerate(files_list): t = Track() t.subfile_no = i t.torrent = self t.offset = f.offset t.size = f.size t.title = f.path t.filehash = f.filehash self.files.append(t)
def create_track_from_uri(self, uri): uri = SpotifySource.strip_protocol(uri) if uri == None: return None url = "http://ws.spotify.com/lookup/1/?uri=" + uri try: e = ET.parse(urllib.urlopen(url)) except Exception as e: return None ns = "http://www.spotify.com/ns/music/1" if 'album' in uri: title = "" artist = e.find('.//{%s}artist/{%s}name' % (ns, ns)).text album = e.find('.//{%s}name' % ns).text duration = 0 album_uri = uri else: title = e.find('.//{%s}name' % ns).text artist = e.find('.//{%s}artist/{%s}name' % (ns, ns)).text album = e.find('.//{%s}album/{%s}name' % (ns, ns)).text duration = int(float(e.find('.//{%s}length' % ns).text) * 1000) album_uri = "spotify://" + e.find('.//{%s}album' % ns).attrib['href'] track = Track("spotify://"+uri) track.title = title track.artist = artist track.album = album track.album_uri = album_uri track.duration = duration return track
def create_track_from_uri(self, uri): if 'youtube' not in uri: return None m = re.search('http://www.youtube.com/get_video.video_id=(.*?)&t=(.*)',uri) client = gdata.youtube.service.YouTubeService() client.ssl = False entry = client.GetYouTubeVideoEntry(video_id=m.group(1)) logging.debug("Created track from uri %s in youtubesource", uri) #PrintEntryDetails(entry) swfuri = entry.GetSwfUrl() video_id = m.group(1) t = m.group(2) track = Track(uri) track.title = entry.media.title.text track.artist = "YOUTUBE VIDEO" track.album = entry.media.category[0].text #FIXME add search for author on album? track.album_uri = None track.duration = int(entry.media.duration.seconds)*1000 return track
def create_track_from_uri(self, uri): if 'asx' not in uri: return None logging.debug("Created track from uri %s in srradiosource", uri) u = urllib.urlopen(uri) str = re.search('\"mms:.+\"', u.read()) u = open("sr.xml") tree = ET.parse(u) u.close() track = Track(str.group(0)[1:-1]) for e in tree.findall('channel'): for k in e.findall('streamingurl'): for s in k.findall('url'): if uri in s.text: track.title = e.get('name') track.artist = "SR RADIOTRACK" track.album = "SR RADIOTRACK" track.album_uri = None track.duration = 1 return track