Пример #1
0
def HasVideoStream(path):

    try:

        info = Hydrusffmpeg_parse_infos(path)

    except IOError as e:

        HydrusData.ShowException('Determining the mime for the file at ' +
                                 path + ' caused the following problem:')
        HydrusData.ShowException(e)

        return False

    return info['video_found']
Пример #2
0
def LoadFromPng(path):

    # this is to deal with unicode paths, which cv2 can't handle
    (os_file_handle, temp_path) = ClientPaths.GetTempPath()

    try:

        shutil.copy2(path, temp_path)

        numpy_image = cv2.imread(temp_path, flags=IMREAD_UNCHANGED)

    except Exception as e:

        HydrusData.ShowException(e)

        raise Exception('That did not appear to be a valid image!')

    finally:

        HydrusPaths.CleanUpTempPath(os_file_handle, temp_path)

    try:

        (height, width) = numpy_image.shape

        complete_data = numpy_image.tostring()

        top_height_header = complete_data[:2]

        (top_height, ) = struct.unpack('!H', top_height_header)

        full_payload_string = complete_data[width * top_height:]

        payload_length_header = full_payload_string[:4]

        (payload_length, ) = struct.unpack('!I', payload_length_header)

        payload = full_payload_string[4:4 + payload_length]

    except Exception as e:

        HydrusData.ShowException(e)

        raise Exception(
            'The image was fine, but it did not seem to have hydrus data encoded in it!'
        )

    return payload
Пример #3
0
    def REPEATINGWorkOnQueue(self, page_key):

        with self._lock:

            if ClientImporting.PageImporterShouldStopWorking(page_key):

                self._queue_repeating_job.Cancel()

                return

            queue_paused = self._queue_paused or HG.client_controller.new_options.GetBoolean(
                'pause_all_gallery_searches')

            queue_good = not queue_paused
            page_shown = not HG.client_controller.PageClosedButNotDestroyed(
                page_key)
            network_engine_good = not HG.client_controller.network_engine.IsBusy(
            )

            ok_to_work = queue_good and page_shown and network_engine_good

        while ok_to_work:

            try:

                did_work = self._WorkOnQueue(page_key)

                if did_work:

                    time.sleep(ClientImporting.
                               DID_SUBSTANTIAL_FILE_WORK_MINIMUM_SLEEP_TIME)

                else:

                    return

                HG.client_controller.WaitUntilViewFree()

            except Exception as e:

                HydrusData.ShowException(e)

            with self._lock:

                if ClientImporting.PageImporterShouldStopWorking(page_key):

                    self._queue_repeating_job.Cancel()

                    return

                queue_paused = self._queue_paused or HG.client_controller.new_options.GetBoolean(
                    'pause_all_gallery_searches')

                queue_good = not queue_paused
                page_shown = not HG.client_controller.PageClosedButNotDestroyed(
                    page_key)
                network_engine_good = not HG.client_controller.network_engine.IsBusy(
                )

                ok_to_work = queue_good and page_shown and network_engine_good
Пример #4
0
    def REPEATINGWorkOnChecker(self):

        with self._lock:

            if ClientImporting.PageImporterShouldStopWorking(self._page_key):

                self._checker_repeating_job.Cancel()

                return

            able_to_check = self._HasURL() and not self._checking_paused
            check_due = HydrusData.TimeHasPassed(self._next_check_time)
            no_delays = HydrusData.TimeHasPassed(self._no_work_until)
            page_shown = not HG.client_controller.PageClosedButNotDestroyed(
                self._page_key)

            time_to_check = able_to_check and check_due and no_delays and page_shown

        if time_to_check:

            try:

                self._CheckWatchableURL()

            except Exception as e:

                HydrusData.ShowException(e)
Пример #5
0
def MergeFile( source, dest ):
    
    if not os.path.isdir( source ):
        
        MakeFileWritable( source )
        
    
    if PathsHaveSameSizeAndDate( source, dest ):
        
        DeletePath( source )
        
    else:
        
        try:
            
            # this overwrites on conflict without hassle
            shutil.move( source, dest )
            
        except Exception as e:
            
            HydrusData.ShowText( 'Trying to move ' + source + ' to ' + dest + ' caused the following problem:' )
            
            HydrusData.ShowException( e )
            
            return False
            
        
    
    return True
Пример #6
0
    def run(self):

        time.sleep(3)

        while True:

            if IsThreadShuttingDown(): return

            try:

                self._callable(self._controller)

            except HydrusExceptions.ShutdownException:

                return

            except Exception as e:

                HydrusData.ShowText('Daemon ' + self._name +
                                    ' encountered an exception:')

                HydrusData.ShowException(e)

            if IsThreadShuttingDown(): return

            self._event.wait(self._period)

            self._event.clear()
Пример #7
0
        def THREADdo_it():
            def wx_code(mappings):

                if not self:

                    return

                self._mappings = mappings

                for mapping in self._mappings:

                    self._mappings_list_ctrl.Append(mapping, mapping)

                self._status_st.SetLabelText('')

            try:

                mappings = HydrusNATPunch.GetUPnPMappings()

            except Exception as e:

                HydrusData.ShowException(e)

                wx.CallAfter(
                    wx.MessageBox,
                    'Could not load mappings:' + os.linesep * 2 + str(e))

                return

            wx.CallAfter(wx_code, mappings)
Пример #8
0
    def run(self):

        time.sleep(3)

        while True:

            while self._queue.empty():

                if IsThreadShuttingDown(): return

                self._event.wait(self._period)

                self._event.clear()

            items = []

            while not self._queue.empty():
                items.append(self._queue.get())

            try:

                self._callable(self._controller, items)

            except HydrusExceptions.ShutdownException:

                return

            except Exception as e:

                HydrusData.ShowException(e)
Пример #9
0
    def run(self):

        while True:

            while self._queue.empty():

                if self._controller.ModelIsShutdown(): return

                self._event.wait(1200)

                self._event.clear()

            try:

                (callable, args, kwargs) = self._queue.get()

                callable(*args, **kwargs)

                del callable

            except HydrusExceptions.ShutdownException:

                return

            except Exception as e:

                HydrusData.ShowException(e)

            time.sleep(0.00001)
Пример #10
0
def DeletePath( path ):
    
    if os.path.exists( path ):
        
        MakeFileWritable( path )
        
        try:
            
            if os.path.isdir( path ):
                
                shutil.rmtree( path )
                
            else:
                
                os.remove( path )
                
            
        except Exception as e:
            
            if 'Error 32' in HydrusData.ToUnicode( e ):
                
                # file in use by another process
                
                HydrusData.DebugPrint( 'Trying to delete ' + path + ' failed because it was in use by another process.' )
                
            else:
                
                HydrusData.ShowText( 'Trying to delete ' + path + ' caused the following error:' )
                HydrusData.ShowException( e )
Пример #11
0
    def REPEATINGWorkOnChecker(self):

        with self._lock:

            if ClientImporting.PageImporterShouldStopWorking(self._page_key):

                self._checker_repeating_job.Cancel()

                return

            checking_paused = self._checking_paused or HG.client_controller.new_options.GetBoolean(
                'pause_all_watcher_checkers')

            able_to_check = self._checking_status == ClientImporting.CHECKER_STATUS_OK and self._HasURL(
            ) and not checking_paused
            check_due = HydrusData.TimeHasPassed(self._next_check_time)
            no_delays = HydrusData.TimeHasPassed(self._no_work_until)
            page_shown = not HG.client_controller.PageClosedButNotDestroyed(
                self._page_key)
            network_engine_good = not HG.client_controller.network_engine.IsBusy(
            )

            time_to_check = able_to_check and check_due and no_delays and page_shown and network_engine_good

        if time_to_check:

            try:

                self._CheckWatchableURL()

            except Exception as e:

                HydrusData.ShowException(e)
Пример #12
0
def HasVideoStream(path):

    try:

        info = Hydrusffmpeg_parse_infos(path)

    except IOError as e:
        HydrusData.ShowException(e)
        return False

    return info['video_found']
Пример #13
0
    def REPEATINGWorkOnFiles(self):

        with self._lock:

            if ClientImporting.PageImporterShouldStopWorking(self._page_key):

                self._files_repeating_job.Cancel()

                return

            files_paused = self._files_paused or HG.client_controller.new_options.GetBoolean(
                'pause_all_file_queues')
            work_pending = self._file_seed_cache.WorkToDo(
            ) and not files_paused
            no_delays = HydrusData.TimeHasPassed(self._no_work_until)
            page_shown = not HG.client_controller.PageClosedButNotDestroyed(
                self._page_key)
            network_engine_good = not HG.client_controller.network_engine.IsBusy(
            )

            ok_to_work = work_pending and no_delays and page_shown and network_engine_good

        while ok_to_work:

            try:

                self._WorkOnFiles()

                HG.client_controller.WaitUntilViewFree()

            except Exception as e:

                HydrusData.ShowException(e)

            with self._lock:

                if ClientImporting.PageImporterShouldStopWorking(
                        self._page_key):

                    self._files_repeating_job.Cancel()

                    return

                files_paused = self._files_paused or HG.client_controller.new_options.GetBoolean(
                    'pause_all_file_queues')
                work_pending = self._file_seed_cache.WorkToDo(
                ) and not files_paused
                no_delays = HydrusData.TimeHasPassed(self._no_work_until)
                page_shown = not HG.client_controller.PageClosedButNotDestroyed(
                    self._page_key)
                network_engine_good = not HG.client_controller.network_engine.IsBusy(
                )

                ok_to_work = work_pending and no_delays and page_shown and network_engine_good
Пример #14
0
            def do_it():

                try:

                    self._service.SyncAccount(force=True)

                except Exception as e:

                    HydrusData.ShowException(e)

                    wx.CallAfter(wx.MessageBox, HydrusData.ToUnicode(e))

                wx.CallAfter(self._Refresh)
Пример #15
0
 def _SetError( self, e, error ):
     
     self._error_exception = e
     self._error_text = error
     
     if HG.network_report_mode:
         
         HydrusData.ShowText( 'Network error should follow:' )
         HydrusData.ShowException( e )
         HydrusData.ShowText( error )
         
     
     self._SetDone()
Пример #16
0
    def REPEATINGWorkOnGallery(self, page_key):

        with self._lock:

            if ClientImporting.PageImporterShouldStopWorking(page_key):

                self._gallery_repeating_job.Cancel()

                return

            gallery_paused = self._paused or HG.client_controller.new_options.GetBoolean(
                'pause_all_gallery_searches')

            work_to_do = self._gallery_seed_log.WorkToDo() and not (
                gallery_paused
                or HG.client_controller.PageClosedButNotDestroyed(page_key))
            network_engine_good = not HG.client_controller.network_engine.IsBusy(
            )

            ok_to_work = work_to_do and network_engine_good

        while ok_to_work:

            try:

                self._WorkOnGallery(page_key)

                HG.client_controller.WaitUntilViewFree()

            except Exception as e:

                HydrusData.ShowException(e)

            with self._lock:

                if ClientImporting.PageImporterShouldStopWorking(page_key):

                    self._gallery_repeating_job.Cancel()

                    return

                gallery_paused = self._paused or HG.client_controller.new_options.GetBoolean(
                    'pause_all_gallery_searches')

                work_to_do = self._gallery_seed_log.WorkToDo() and not (
                    gallery_paused or
                    HG.client_controller.PageClosedButNotDestroyed(page_key))
                network_engine_good = not HG.client_controller.network_engine.IsBusy(
                )

                ok_to_work = work_to_do and network_engine_good
Пример #17
0
def GetFFMPEGVersion():

    # open the file in a pipe, provoke an error, read output

    cmd = [FFMPEG_PATH, '-version']

    try:

        proc = subprocess.Popen(
            cmd,
            bufsize=10**5,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            startupinfo=HydrusData.GetHideTerminalSubprocessStartupInfo())

    except Exception as e:

        if not os.path.exists(FFMPEG_PATH):

            return 'no ffmpeg found'

        else:

            HydrusData.ShowException(e)

            return 'unable to execute ffmpeg'

    infos = proc.stdout.read().decode('utf8')

    proc.terminate()

    del proc

    lines = infos.splitlines()

    if len(lines) > 0:

        # typically 'ffmpeg version [VERSION] Copyright ...
        top_line = lines[0]

        if top_line.startswith('ffmpeg version '):

            top_line = top_line.replace('ffmpeg version ', '')

            if ' ' in top_line:

                version_string = top_line.split(' ')[0]

                return version_string

    return 'unknown'
Пример #18
0
    def run(self):

        while True:

            try:

                while self._NoWorkToStart():

                    if self._controller.ModelIsShutdown():

                        return

                    #

                    if self._cancel_filter_needed.is_set():

                        self._FilterCancelled()

                        self._cancel_filter_needed.clear()

                    if self._sort_needed.is_set():

                        self._SortWaiting()

                        self._sort_needed.clear()

                        continue  # if some work is now due, let's do it!

                    #

                    wait_time = self._GetLoopWaitTime()

                    self._new_job_arrived.wait(wait_time)

                    self._new_job_arrived.clear()

                self._StartWork()

            except HydrusExceptions.ShutdownException:

                return

            except Exception as e:

                HydrusData.Print(traceback.format_exc())

                HydrusData.ShowException(e)

            time.sleep(0.00001)
Пример #19
0
 def _Paste( self ):
 
     raw_text = HG.client_controller.GetClipboardText()
     
     try:
         
         tag_import_options = HydrusSerialisable.CreateFromString( raw_text )
         
         self._tag_import_options = tag_import_options
         
     except Exception as e:
         
         wx.MessageBox( 'I could not understand what was in the clipboard' )
         
         HydrusData.ShowException( e )
Пример #20
0
    def DAEMONPubSub(self):

        while not HG.model_shutdown:

            if self._pubsub.WorkToDo():

                try:

                    self.ProcessPubSub()

                except Exception as e:

                    HydrusData.ShowException(e, do_wait=True)

            else:

                self._pubsub.WaitOnPub()
Пример #21
0
    def REPEATINGWorkOnQueue(self, page_key):

        with self._lock:

            if ClientImporting.PageImporterShouldStopWorking(page_key):

                self._queue_repeating_job.Cancel()

                return

            ok_to_work = not (
                self._queue_paused
                or HG.client_controller.PageClosedButNotDestroyed(page_key))

        while ok_to_work:

            try:

                did_work = self._WorkOnQueue(page_key)

                if did_work:

                    time.sleep(ClientImporting.
                               DID_SUBSTANTIAL_FILE_WORK_MINIMUM_SLEEP_TIME)

                else:

                    return

                HG.client_controller.WaitUntilViewFree()

            except Exception as e:

                HydrusData.ShowException(e)

            with self._lock:

                if ClientImporting.PageImporterShouldStopWorking(page_key):

                    self._queue_repeating_job.Cancel()

                    return

                ok_to_work = not (
                    self._queue_paused or
                    HG.client_controller.PageClosedButNotDestroyed(page_key))
Пример #22
0
 def REPEATINGWorkOnFiles( self ):
     
     with self._lock:
         
         if ClientImporting.PageImporterShouldStopWorking( self._page_key ):
             
             self._files_repeating_job.Cancel()
             
             return
             
         
         work_pending = self._file_seed_cache.WorkToDo() and not self._files_paused
         no_delays = HydrusData.TimeHasPassed( self._no_work_until )
         page_shown = not HG.client_controller.PageClosedButNotDestroyed( self._page_key )
         
         ok_to_work = work_pending and no_delays and page_shown
         
     
     while ok_to_work:
         
         try:
             
             self._WorkOnFiles()
             
             HG.client_controller.WaitUntilViewFree()
             
         except Exception as e:
             
             HydrusData.ShowException( e )
             
         
         with self._lock:
             
             if ClientImporting.PageImporterShouldStopWorking( self._page_key ):
                 
                 self._files_repeating_job.Cancel()
                 
                 return
                 
             
             work_pending = self._file_seed_cache.WorkToDo() and not self._files_paused
             no_delays = HydrusData.TimeHasPassed( self._no_work_until )
             page_shown = not HG.client_controller.PageClosedButNotDestroyed( self._page_key )
             
             ok_to_work = work_pending and no_delays and page_shown
Пример #23
0
    def do_it(launch_path):

        if HC.PLATFORM_WINDOWS and launch_path is None:

            os.startfile(path)

        else:

            if launch_path is None:

                launch_path = GetDefaultLaunchPath()

            cmd = launch_path.replace('%path%', path)

            if HC.PLATFORM_WINDOWS:

                preexec_fn = None

            else:

                # setsid call un-childs this new process

                preexec_fn = os.setsid

                cmd = shlex.split(cmd)

            try:

                process = subprocess.Popen(
                    cmd,
                    preexec_fn=preexec_fn,
                    startupinfo=HydrusData.
                    GetHideTerminalSubprocessStartupInfo())

                process.wait()

                process.communicate()

            except Exception as e:

                HydrusData.ShowText(
                    'Could not launch a file! Command used was:' + os.linesep +
                    HydrusData.ToUnicode(cmd))

                HydrusData.ShowException(e)
Пример #24
0
def DumpToPng(width, payload, title, payload_description, text, path):

    payload_length = len(payload)

    payload_string_length = payload_length + 4

    payload_height = int(float(payload_string_length) / width)

    if float(payload_string_length) / width % 1.0 > 0:

        payload_height += 1

    top_image = CreateTopImage(width, title, payload_description, text)

    payload_length_header = struct.pack('!I', payload_length)

    num_empty_bytes = payload_height * width - payload_string_length

    full_payload_string = payload_length_header + payload + '\x00' * num_empty_bytes

    payload_image = numpy.fromstring(full_payload_string,
                                     dtype='uint8').reshape(
                                         (payload_height, width))

    finished_image = numpy.concatenate((top_image, payload_image))

    # this is to deal with unicode paths, which cv2 can't handle
    (os_file_handle, temp_path) = ClientPaths.GetTempPath(suffix='.png')

    try:

        cv2.imwrite(temp_path, finished_image,
                    [cv2.IMWRITE_PNG_COMPRESSION, 9])

        shutil.copy2(temp_path, path)

    except Exception as e:

        HydrusData.ShowException(e)

        raise Exception('Could not save the png!')

    finally:

        HydrusPaths.CleanUpTempPath(os_file_handle, temp_path)
Пример #25
0
def MirrorFile(source, dest):

    if not PathsHaveSameSizeAndDate(source, dest):

        try:

            shutil.copy2(source, dest)

        except Exception as e:

            HydrusData.ShowText('Trying to copy ' + source + ' to ' + dest +
                                ' caused the following problem:')

            HydrusData.ShowException(e)

            return False

    return True
Пример #26
0
    def run(self):

        while True:

            try:

                while self._queue.empty():

                    if IsThreadShuttingDown():

                        return

                    self._event.wait(1200)

                    self._event.clear()

                self._DoPreCall()

                (callable, args, kwargs) = self._queue.get()

                self._callable = (callable, args, kwargs)

                callable(*args, **kwargs)

                self._callable = None

                del callable

            except HydrusExceptions.ShutdownException:

                return

            except Exception as e:

                HydrusData.Print(traceback.format_exc())

                HydrusData.ShowException(e)

            finally:

                self._currently_working = False

            time.sleep(0.00001)
Пример #27
0
 def run( self ):
     
     self._event.wait( self._init_wait )
     
     while True:
         
         if IsThreadShuttingDown():
             
             return
             
         
         time_started_waiting = HydrusData.GetNow()
         
         while not self._CanStart( time_started_waiting ):
             
             time.sleep( 1 )
             
             if IsThreadShuttingDown():
                 
                 return
                 
             
         
         try:
             
             self._callable( self._controller )
             
         except HydrusExceptions.ShutdownException:
             
             return
             
         except Exception as e:
             
             HydrusData.ShowText( 'Daemon ' + self._name + ' encountered an exception:' )
             
             HydrusData.ShowException( e )
             
         
         if IsThreadShuttingDown(): return
         
         self._event.wait( self._period )
         
         self._event.clear()
Пример #28
0
 def REPEATINGWorkOnFiles( self, page_key ):
     
     with self._lock:
         
         if ClientImporting.PageImporterShouldStopWorking( page_key ):
             
             self._files_repeating_job.Cancel()
             
             return
             
         
         paused = self._paused or HG.client_controller.new_options.GetBoolean( 'pause_all_file_queues' )
         
         work_to_do = self._file_seed_cache.WorkToDo() and not ( paused or HG.client_controller.PageClosedButNotDestroyed( page_key ) )
         
     
     while work_to_do:
         
         try:
             
             self._WorkOnFiles( page_key )
             
             HG.client_controller.WaitUntilViewFree()
             
         except Exception as e:
             
             HydrusData.ShowException( e )
             
         
         with self._lock:
             
             if ClientImporting.PageImporterShouldStopWorking( page_key ):
                 
                 self._files_repeating_job.Cancel()
                 
                 return
                 
             
             paused = self._paused or HG.client_controller.new_options.GetBoolean( 'pause_all_file_queues' )
             
             work_to_do = self._file_seed_cache.WorkToDo() and not ( paused or HG.client_controller.PageClosedButNotDestroyed( page_key ) )
Пример #29
0
def DeletePath(path):

    if os.path.exists(path):

        MakeFileWritable(path)

        try:

            if os.path.isdir(path):

                shutil.rmtree(path)

            else:

                os.remove(path)

        except Exception as e:

            HydrusData.ShowText('Trying to delete ' + path +
                                ' caused the following error:')
            HydrusData.ShowException(e)
Пример #30
0
def MirrorFile(source, dest):

    if not PathsHaveSameSizeAndDate(source, dest):

        try:

            MakeFileWritable(dest)

            # this overwrites on conflict without hassle
            shutil.copy2(source, dest)

        except Exception as e:

            HydrusData.ShowText('Trying to copy ' + source + ' to ' + dest +
                                ' caused the following problem:')

            HydrusData.ShowException(e)

            return False

    return True