コード例 #1
0
ファイル: threads.py プロジェクト: handsomegui/Gereqi
 def run(self):
     print("DEBUG: starting GetCovers thread")
     db = CollectionDb("cover_crawl")
     artists = db.get_artists()
     for artist in artists:
         albums = db.get_albums(artist)
         for album in albums:
             if extraneous.get_cover_source(artist=artist, album=album, check=True, download=True):
                 self.cover_found.emit(artist, album)
     self.exec_()
コード例 #2
0
ファイル: extrawidgets.py プロジェクト: handsomegui/Gereqi
class AlbumItem(QThread):
    new_item = pyqtSignal(tuple)
    def __init__(self,parent=None):
        QThread.__init__(self)
        self.db = CollectionDb("album_items")
        self.exiting = False
    
    def __del__(self):
        self.exiting = True
        self.wait()
            
    def stop(self):
        self.exiting = True
        
    def set_values(self,time_filt, filter):
        self.exiting = False  
        self.filter = filter
        self.time_filt = time_filt
    
    def run(self):
        self.exiting = False
        extras = extraneous.Extraneous()
        for item in self.db.get_albums_all(self.time_filt, self.filter):
            if self.exiting:
                break       
            cover = extras.get_cover_source(item['artist'],item['album'],True, False)
            if not cover:
                cover = ":icons/nocover.png"
            else:
                cover = cover.replace("file://", '')
            self.new_item.emit((item['album'],cover))
コード例 #3
0
ファイル: threads.py プロジェクト: handsomegui/Gereqi
class DeleteFiles(QThread):
    deleted = pyqtSignal()
    
    def __init__(self, parent):
        QThread.__init__(self)
        self.ui = parent
        self.db = CollectionDb("deleter")
        
    def set_values(self, deletions):
        self.file_list = deletions
        
    def run(self):        
        self.ui.delete_lock = True
        while self.ui.build_lock == True:
            print("DEBUG: WAITING: Deletion")
            sleep(1)
        for trk in self.file_list:
            self.db.delete_track(trk)         
        # Signals to indicate that items based on
        # DB should probably update
        self.deleted.emit()
        self.ui.delete_lock = False
        self.exec_()   
コード例 #4
0
ファイル: threads.py プロジェクト: handsomegui/Gereqi
 def __init__(self, parent):
     QThread.__init__(self, parent)
     self.ui = parent
     self.db = CollectionDb("builder")
     print("DEBUG: Setting up Builddb thread")
コード例 #5
0
ファイル: threads.py プロジェクト: handsomegui/Gereqi
class Builddb(QThread):
    """
    Gets files from a directory and build's a 
    media database from the filtered files
    """
    progress = pyqtSignal(int)
    finished = pyqtSignal(str)
    
    def __init__(self, parent):
        QThread.__init__(self, parent)
        self.ui = parent
        self.db = CollectionDb("builder")
        print("DEBUG: Setting up Builddb thread")
        
    def __file_compat(self, dirpath, fname):
        """
        Identifies if the file is compatible with supported codecs
        """
        now = os.path.join(dirpath, fname)
        ender = os.path.splitext(now)[-1].strip(".")
        ender = ender.lower() 
        # We only want to get tags for certain file formats
        if ender in self.a_formats: 
            return now  
        
    def stop(self):
        self.exiting = True
        
    def set_values(self, dirs, formats, rescan, tracks=None):
        """
        Required to put parameters into
        this thread from the outside
        """
        self.media_dir  = dirs
        self.file_list  = tracks
        self.rescan     = rescan
        self.meta       = Tagging(formats)  
        self.a_formats  = formats
     
    def __track_list(self, dir, excl):
        """
        Generates a list of compatible files
        """
        tracks = []
        not_need = [now for now in excl 
                        if dir in now]
        sets_db = Settings()
        # Recursively search                
        if sets_db.get_collection_setting("recursive") == "True":
        # No point trying to speed this up. os.walk is a generator function
            for dirpath, dirnames, filenames in os.walk(dir):
                # The exclusion part
                #FIXME: although this means you exclude the dirpath you don't 
                # exclude it's subdirs
                if dirpath in not_need:
                    pass
                for fname in filenames:
                    trk = self.__file_compat(dirpath, fname)
                    if not trk:
                        continue
                    try:
                        tracks.append(unicode(trk))
                    except UnicodeDecodeError:
                        continue
                            
        else:
            # Cannot use the loop for both as one is the above is a generator
            # and os.listdir is a list-returning function
            for fname in os.listdir(dir):
                trk = self.__file_compat(dir, fname)
                if trk is not None:
                    tracks.append(trk) 
       
        return list(set(tracks) - set(self.db.all_files() ))
        
    def __process_cue(self,file_name):
        """
        Cue sheets need to be handled differently to normal audio files
        """
        cue_now = CueSheet(file_name)
        cue_name = "%s - %s" % (cue_now.title, cue_now.performer)
        self.db.playlist_add(cue_name,file_name)
        
        
    def run(self):
        print("DEBUG: starting Builddb thread")
        
        self.ui.build_lock = True
        while self.ui.delete_lock:
            print("DEBUG: WAITING: Creation")
            sleep(1)
            
        old_prog = 0
        
        if self.rescan:
            self.db.drop_media()
            print("DEBUG: Building DB from scratch")
        else:
            print("DEBUG: Updating DB")
        
        if self.file_list is None:
            tracks = []
            for dir in self.media_dir[0]:
                tracks.extend(self.__track_list(dir, self.media_dir[1]))
        else:
            tracks = []
            for trk in self.file_list:
                tracks.append(unicode(trk))
            
        tracks_total = len(tracks)
        print("DEBUG: %d tracks to scan" % tracks_total)
        self.exiting = False
        
        strt = time()
        cnt = 0
        for trk in tracks:
            if not self.exiting:
                # Find cuesheets
                if os.path.splitext(trk)[-1].lower() == ".cue":                    
                    self.__process_cue(trk)
                    continue                   
                
                ratio = float(cnt ) /  float(tracks_total)
                prog = int(round(100 * ratio))
                if prog > old_prog:
                    old_prog = prog
                    self.progress.emit(prog)

                info = self.meta.extract(trk)
                if info:
                    # prepends the fileName as the DB function expects
                    # a certain order to the args passed
                    info.insert(0, trk) 
                    info.append(int(round(time())))
                    
                    # The default rating
                    info.append(0)
                    self.db.add_media(info)
                    cnt += 1
            else:
                print("DEBUG: User terminated DB update/build.")
                self.finished.emit("cancelled")
                self.ui.build_lock = False
                self.exit()
                return
            
        print("DEBUG: %u of %u tracks scanned in: %0.1f seconds" % \
              (cnt, tracks_total, (time() - strt)))
        self.finished.emit("complete")
        self.ui.build_lock = False
コード例 #6
0
ファイル: threads.py プロジェクト: handsomegui/Gereqi
 def __init__(self, parent):
     QThread.__init__(self)
     self.ui = parent
     self.db = CollectionDb("deleter")
コード例 #7
0
ファイル: extrawidgets.py プロジェクト: handsomegui/Gereqi
 def __init__(self,parent=None):
     QThread.__init__(self)
     self.db = CollectionDb("album_items")
     self.exiting = False