import os import random import typing from qtpy import QtCore as QC from qtpy import QtWidgets as QW from hydrus.core import HydrusConstants as HC from hydrus.core import HydrusData from hydrus.core import HydrusExceptions from hydrus.core import HydrusGlobals as HG from hydrus.core import HydrusSerialisable from hydrus.core import HydrusTags from hydrus.core.networking import HydrusNetwork from hydrus.client import ClientConstants as CC from hydrus.client import ClientData from hydrus.client import ClientDefaults from hydrus.client import ClientDuplicates from hydrus.client import ClientLocation from hydrus.client import ClientParsing from hydrus.client import ClientPaths from hydrus.client import ClientSearch from hydrus.client import ClientThreading from hydrus.client.gui import ClientGUICore as CGC from hydrus.client.gui import ClientGUIDialogs from hydrus.client.gui import ClientGUIDialogsQuick from hydrus.client.gui import ClientGUIFunctions from hydrus.client.gui import ClientGUIMenus from hydrus.client.gui import ClientGUIScrolledPanels from hydrus.client.gui import ClientGUIFileSeedCache from hydrus.client.gui import ClientGUIGallerySeedLog from hydrus.client.gui import ClientGUIScrolledPanelsEdit from hydrus.client.gui import ClientGUITopLevelWindowsPanels from hydrus.client.gui import QtPorting as QP from hydrus.client.gui.canvas import ClientGUICanvas from hydrus.client.gui.canvas import ClientGUICanvasFrame from hydrus.client.gui.importing import ClientGUIImport from hydrus.client.gui.importing import ClientGUIImportOptions from hydrus.client.gui.lists import ClientGUIListBoxes from hydrus.client.gui.lists import ClientGUIListConstants as CGLC from hydrus.client.gui.lists import ClientGUIListCtrl from hydrus.client.gui.networking import ClientGUIHydrusNetwork from hydrus.client.gui.networking import ClientGUINetworkJobControl from hydrus.client.gui.pages import ClientGUIResults from hydrus.client.gui.pages import ClientGUIResultsSortCollect from hydrus.client.gui.parsing import ClientGUIParsingFormulae from hydrus.client.gui.search import ClientGUIACDropdown from hydrus.client.gui.widgets import ClientGUICommon from hydrus.client.gui.widgets import ClientGUIControls from hydrus.client.gui.widgets import ClientGUIMenuButton from hydrus.client.importing import ClientImporting from hydrus.client.importing import ClientImportGallery from hydrus.client.importing import ClientImportLocal from hydrus.client.importing import ClientImportSimpleURLs from hydrus.client.importing import ClientImportWatchers from hydrus.client.importing.options import FileImportOptions from hydrus.client.importing.options import PresentationImportOptions from hydrus.client.media import ClientMedia from hydrus.client.metadata import ClientTags from hydrus.client.metadata import ClientMetadataMigration MANAGEMENT_TYPE_DUMPER = 0 MANAGEMENT_TYPE_IMPORT_MULTIPLE_GALLERY = 1 MANAGEMENT_TYPE_IMPORT_SIMPLE_DOWNLOADER = 2 MANAGEMENT_TYPE_IMPORT_HDD = 3 MANAGEMENT_TYPE_IMPORT_WATCHER = 4 # defunct MANAGEMENT_TYPE_PETITIONS = 5 MANAGEMENT_TYPE_QUERY = 6 MANAGEMENT_TYPE_IMPORT_URLS = 7 MANAGEMENT_TYPE_DUPLICATE_FILTER = 8 MANAGEMENT_TYPE_IMPORT_MULTIPLE_WATCHER = 9 MANAGEMENT_TYPE_PAGE_OF_PAGES = 10 management_panel_types_to_classes = {} def AddPresentationSubmenu( menu: QW.QMenu, importer_name: str, single_selected_presentation_import_options: typing.Optional[ PresentationImportOptions.PresentationImportOptions ], callable ): submenu = QW.QMenu( menu ) # inbox only # detect single_selected_presentation_import_options and deal with it description = 'Gather these files for the selected importers and show them.' if single_selected_presentation_import_options is None: ClientGUIMenus.AppendMenuItem( submenu, 'default presented files', description, callable ) else: ClientGUIMenus.AppendMenuItem( submenu, 'default presented files ({})'.format( single_selected_presentation_import_options.GetSummary() ), description, callable ) sets_of_options = [] presentation_import_options = PresentationImportOptions.PresentationImportOptions() presentation_import_options.SetPresentationStatus( PresentationImportOptions.PRESENTATION_STATUS_NEW_ONLY ) sets_of_options.append( presentation_import_options ) presentation_import_options = PresentationImportOptions.PresentationImportOptions() presentation_import_options.SetPresentationInbox( PresentationImportOptions.PRESENTATION_INBOX_REQUIRE_INBOX ) sets_of_options.append( presentation_import_options ) presentation_import_options = PresentationImportOptions.PresentationImportOptions() sets_of_options.append( presentation_import_options ) presentation_import_options = PresentationImportOptions.PresentationImportOptions() presentation_import_options.SetLocationContext( ClientLocation.LocationContext.STATICCreateSimple( CC.COMBINED_LOCAL_FILE_SERVICE_KEY ) ) sets_of_options.append( presentation_import_options ) for presentation_import_options in sets_of_options: if single_selected_presentation_import_options is not None and presentation_import_options == single_selected_presentation_import_options: continue ClientGUIMenus.AppendMenuItem( submenu, presentation_import_options.GetSummary(), description, callable, presentation_import_options = presentation_import_options ) ClientGUIMenus.AppendMenu( menu, submenu, 'show files' ) def CreateManagementController( page_name, management_type, location_context = None ): if location_context is None: location_context = ClientLocation.LocationContext.STATICCreateSimple( CC.COMBINED_LOCAL_MEDIA_SERVICE_KEY ) new_options = HG.client_controller.new_options management_controller = ManagementController( page_name ) management_controller.SetType( management_type ) management_controller.SetVariable( 'media_sort', new_options.GetDefaultSort() ) management_controller.SetVariable( 'media_collect', new_options.GetDefaultCollect() ) management_controller.SetVariable( 'location_context', location_context ) return management_controller def CreateManagementControllerDuplicateFilter(): default_location_context = HG.client_controller.new_options.GetDefaultLocalLocationContext() management_controller = CreateManagementController( 'duplicates', MANAGEMENT_TYPE_DUPLICATE_FILTER, location_context = default_location_context ) file_search_context = ClientSearch.FileSearchContext( location_context = default_location_context, predicates = [ ClientSearch.Predicate( ClientSearch.PREDICATE_TYPE_SYSTEM_EVERYTHING ) ] ) synchronised = HG.client_controller.new_options.GetBoolean( 'default_search_synchronised' ) management_controller.SetVariable( 'synchronised', synchronised ) management_controller.SetVariable( 'file_search_context_1', file_search_context ) management_controller.SetVariable( 'file_search_context_2', file_search_context.Duplicate() ) management_controller.SetVariable( 'dupe_search_type', CC.DUPE_SEARCH_ONE_FILE_MATCHES_ONE_SEARCH ) management_controller.SetVariable( 'pixel_dupes_preference', CC.SIMILAR_FILES_PIXEL_DUPES_ALLOWED ) management_controller.SetVariable( 'max_hamming_distance', 4 ) return management_controller def CreateManagementControllerImportGallery( page_name = None ): if page_name is None: page_name = 'gallery' gug_key_and_name = HG.client_controller.network_engine.domain_manager.GetDefaultGUGKeyAndName() multiple_gallery_import = ClientImportGallery.MultipleGalleryImport( gug_key_and_name = gug_key_and_name ) location_context = multiple_gallery_import.GetFileImportOptions().GetDestinationLocationContext() management_controller = CreateManagementController( page_name, MANAGEMENT_TYPE_IMPORT_MULTIPLE_GALLERY, location_context = location_context ) management_controller.SetVariable( 'multiple_gallery_import', multiple_gallery_import ) return management_controller def CreateManagementControllerImportSimpleDownloader(): simple_downloader_import = ClientImportSimpleURLs.SimpleDownloaderImport() formula_name = HG.client_controller.new_options.GetString( 'favourite_simple_downloader_formula' ) simple_downloader_import.SetFormulaName( formula_name ) location_context = simple_downloader_import.GetFileImportOptions().GetDestinationLocationContext() management_controller = CreateManagementController( 'simple downloader', MANAGEMENT_TYPE_IMPORT_SIMPLE_DOWNLOADER, location_context = location_context ) management_controller.SetVariable( 'simple_downloader_import', simple_downloader_import ) return management_controller def CreateManagementControllerImportHDD( paths, file_import_options: FileImportOptions.FileImportOptions, metadata_routers: typing.Collection[ ClientMetadataMigration.SingleFileMetadataRouter ], paths_to_additional_service_keys_to_tags, delete_after_success ): location_context = file_import_options.GetDestinationLocationContext() management_controller = CreateManagementController( 'import', MANAGEMENT_TYPE_IMPORT_HDD, location_context = location_context ) hdd_import = ClientImportLocal.HDDImport( paths = paths, file_import_options = file_import_options, metadata_routers = metadata_routers, paths_to_additional_service_keys_to_tags = paths_to_additional_service_keys_to_tags, delete_after_success = delete_after_success ) management_controller.SetVariable( 'hdd_import', hdd_import ) return management_controller def CreateManagementControllerImportMultipleWatcher( page_name = None, url = None ): if page_name is None: page_name = 'watcher' multiple_watcher_import = ClientImportWatchers.MultipleWatcherImport( url = url ) location_context = multiple_watcher_import.GetFileImportOptions().GetDestinationLocationContext() management_controller = CreateManagementController( page_name, MANAGEMENT_TYPE_IMPORT_MULTIPLE_WATCHER, location_context = location_context ) management_controller.SetVariable( 'multiple_watcher_import', multiple_watcher_import ) return management_controller def CreateManagementControllerImportURLs( page_name = None ): if page_name is None: page_name = 'url import' urls_import = ClientImportSimpleURLs.URLsImport() location_context = urls_import.GetFileImportOptions().GetDestinationLocationContext() management_controller = CreateManagementController( page_name, MANAGEMENT_TYPE_IMPORT_URLS, location_context = location_context ) management_controller.SetVariable( 'urls_import', urls_import ) return management_controller def CreateManagementControllerPetitions( petition_service_key ): petition_service = HG.client_controller.services_manager.GetService( petition_service_key ) page_name = petition_service.GetName() + ' petitions' petition_service_type = petition_service.GetServiceType() if petition_service_type in HC.LOCAL_FILE_SERVICES or petition_service_type == HC.FILE_REPOSITORY: location_context = ClientLocation.LocationContext.STATICCreateSimple( petition_service_key ) else: location_context = ClientLocation.LocationContext.STATICCreateSimple( CC.COMBINED_FILE_SERVICE_KEY ) management_controller = CreateManagementController( page_name, MANAGEMENT_TYPE_PETITIONS, location_context = location_context ) management_controller.SetVariable( 'petition_service_key', petition_service_key ) return management_controller def CreateManagementControllerQuery( page_name, file_search_context: ClientSearch.FileSearchContext, search_enabled ): location_context = file_search_context.GetLocationContext() management_controller = CreateManagementController( page_name, MANAGEMENT_TYPE_QUERY, location_context = location_context ) synchronised = HG.client_controller.new_options.GetBoolean( 'default_search_synchronised' ) management_controller.SetVariable( 'file_search_context', file_search_context ) management_controller.SetVariable( 'search_enabled', search_enabled ) management_controller.SetVariable( 'synchronised', synchronised ) return management_controller class ManagementController( HydrusSerialisable.SerialisableBase ): SERIALISABLE_TYPE = HydrusSerialisable.SERIALISABLE_TYPE_MANAGEMENT_CONTROLLER SERIALISABLE_NAME = 'Client Page Management Controller' SERIALISABLE_VERSION = 12 def __init__( self, page_name = 'page' ): HydrusSerialisable.SerialisableBase.__init__( self ) self._page_name = page_name self._management_type = None self._last_serialisable_change_timestamp = 0 self._variables = HydrusSerialisable.SerialisableDictionary() def __repr__( self ): return 'Management Controller: {} - {}'.format( self._management_type, self._page_name ) def _GetSerialisableInfo( self ): # don't save these TRANSITORY_KEYS = { 'page' } serialisable_variables = self._variables.GetSerialisableTuple() return ( self._page_name, self._management_type, serialisable_variables ) def _InitialiseDefaults( self ): self._variables[ 'media_sort' ] = ClientMedia.MediaSort( ( 'system', CC.SORT_FILES_BY_FILESIZE ), CC.SORT_ASC ) def _InitialiseFromSerialisableInfo( self, serialisable_info ): ( self._page_name, self._management_type, serialisable_variables ) = serialisable_info self._InitialiseDefaults() self._variables.update( HydrusSerialisable.CreateFromSerialisableTuple( serialisable_variables ) ) def _SerialisableChangeMade( self ): self._last_serialisable_change_timestamp = HydrusData.GetNow() def _UpdateSerialisableInfo( self, version, old_serialisable_info ): if version == 1: ( management_type, serialisable_keys, serialisable_simples, serialisable_serialisables ) = old_serialisable_info if management_type == MANAGEMENT_TYPE_IMPORT_HDD: advanced_import_options = serialisable_simples[ 'advanced_import_options' ] paths_info = serialisable_simples[ 'paths_info' ] paths_to_tags = serialisable_simples[ 'paths_to_tags' ] delete_after_success = serialisable_simples[ 'delete_after_success' ] paths = [ path_info for ( path_type, path_info ) in paths_info if path_type != 'zip' ] exclude_deleted = advanced_import_options[ 'exclude_deleted' ] preimport_hash_check_type = FileImportOptions.DO_CHECK_AND_MATCHES_ARE_DISPOSITIVE preimport_url_check_type = FileImportOptions.DO_CHECK preimport_url_check_looks_for_neighbours = True allow_decompression_bombs = False min_size = advanced_import_options[ 'min_size' ] max_size = None max_gif_size = None min_resolution = advanced_import_options[ 'min_resolution' ] max_resolution = None automatic_archive = advanced_import_options[ 'automatic_archive' ] associate_primary_urls = True associate_source_urls = True file_import_options = FileImportOptions.FileImportOptions() file_import_options.SetPreImportOptions( exclude_deleted, preimport_hash_check_type, preimport_url_check_type, allow_decompression_bombs, min_size, max_size, max_gif_size, min_resolution, max_resolution ) file_import_options.SetPreImportURLCheckLooksForNeighbours( preimport_url_check_looks_for_neighbours ) file_import_options.SetPostImportOptions( automatic_archive, associate_primary_urls, associate_source_urls ) paths_to_tags = { path : { bytes.fromhex( service_key ) : tags for ( service_key, tags ) in additional_service_keys_to_tags } for ( path, additional_service_keys_to_tags ) in paths_to_tags.items() } hdd_import = ClientImportLocal.HDDImport( paths = paths, file_import_options = file_import_options, paths_to_additional_service_keys_to_tags = paths_to_tags, delete_after_success = delete_after_success ) serialisable_serialisables[ 'hdd_import' ] = hdd_import.GetSerialisableTuple() del serialisable_serialisables[ 'advanced_import_options' ] del serialisable_serialisables[ 'paths_info' ] del serialisable_serialisables[ 'paths_to_tags' ] del serialisable_serialisables[ 'delete_after_success' ] new_serialisable_info = ( management_type, serialisable_keys, serialisable_simples, serialisable_serialisables ) return ( 2, new_serialisable_info ) if version == 2: ( management_type, serialisable_keys, serialisable_simples, serialisable_serialisables ) = old_serialisable_info page_name = 'page' new_serialisable_info = ( page_name, management_type, serialisable_keys, serialisable_simples, serialisable_serialisables ) return ( 3, new_serialisable_info ) if version == 3: ( page_name, management_type, serialisable_keys, serialisable_simples, serialisable_serialisables ) = old_serialisable_info if 'page_of_images_import' in serialisable_serialisables: serialisable_serialisables[ 'simple_downloader_import' ] = serialisable_serialisables[ 'page_of_images_import' ] del serialisable_serialisables[ 'page_of_images_import' ] new_serialisable_info = ( page_name, management_type, serialisable_keys, serialisable_simples, serialisable_serialisables ) return ( 4, new_serialisable_info ) if version == 4: ( page_name, management_type, serialisable_keys, serialisable_simples, serialisable_serialisables ) = old_serialisable_info if 'thread_watcher_import' in serialisable_serialisables: serialisable_serialisables[ 'watcher_import' ] = serialisable_serialisables[ 'thread_watcher_import' ] del serialisable_serialisables[ 'thread_watcher_import' ] new_serialisable_info = ( page_name, management_type, serialisable_keys, serialisable_simples, serialisable_serialisables ) return ( 5, new_serialisable_info ) if version == 5: ( page_name, management_type, serialisable_keys, serialisable_simples, serialisable_serialisables ) = old_serialisable_info if 'gallery_import' in serialisable_serialisables: serialisable_serialisables[ 'multiple_gallery_import' ] = serialisable_serialisables[ 'gallery_import' ] del serialisable_serialisables[ 'gallery_import' ] new_serialisable_info = ( page_name, management_type, serialisable_keys, serialisable_simples, serialisable_serialisables ) return ( 6, new_serialisable_info ) if version == 6: ( page_name, management_type, serialisable_keys, serialisable_simples, serialisable_serialisables ) = old_serialisable_info if 'watcher_import' in serialisable_serialisables: watcher = HydrusSerialisable.CreateFromSerialisableTuple( serialisable_serialisables[ 'watcher_import' ] ) management_type = MANAGEMENT_TYPE_IMPORT_MULTIPLE_WATCHER multiple_watcher_import = ClientImportWatchers.MultipleWatcherImport() multiple_watcher_import.AddWatcher( watcher ) serialisable_multiple_watcher_import = multiple_watcher_import.GetSerialisableTuple() serialisable_serialisables[ 'multiple_watcher_import' ] = serialisable_multiple_watcher_import del serialisable_serialisables[ 'watcher_import' ] new_serialisable_info = ( page_name, management_type, serialisable_keys, serialisable_simples, serialisable_serialisables ) return ( 7, new_serialisable_info ) if version == 7: ( page_name, management_type, serialisable_keys, serialisable_simples, serialisable_serialisables ) = old_serialisable_info if page_name.startswith( '[USER]' ) and len( page_name ) > 6: page_name = page_name[6:] new_serialisable_info = ( page_name, management_type, serialisable_keys, serialisable_simples, serialisable_serialisables ) return ( 8, new_serialisable_info ) if version == 8: ( page_name, management_type, serialisable_keys, serialisable_simples, serialisable_serialisables ) = old_serialisable_info if management_type == MANAGEMENT_TYPE_DUPLICATE_FILTER: if 'duplicate_filter_file_domain' in serialisable_keys: del serialisable_keys[ 'duplicate_filter_file_domain' ] location_context = ClientLocation.LocationContext.STATICCreateSimple( CC.LOCAL_FILE_SERVICE_KEY ) file_search_context = ClientSearch.FileSearchContext( location_context = location_context, predicates = [ ClientSearch.Predicate( ClientSearch.PREDICATE_TYPE_SYSTEM_EVERYTHING ) ] ) serialisable_serialisables[ 'file_search_context' ] = file_search_context.GetSerialisableTuple() serialisable_simples[ 'both_files_match' ] = False new_serialisable_info = ( page_name, management_type, serialisable_keys, serialisable_simples, serialisable_serialisables ) return ( 9, new_serialisable_info ) if version == 9: ( page_name, management_type, serialisable_keys, serialisable_simples, serialisable_serialisables ) = old_serialisable_info if 'media_collect' in serialisable_simples: try: old_collect = serialisable_simples[ 'media_collect' ] if old_collect is None: old_collect = [] namespaces = [ n for ( t, n ) in old_collect if t == 'namespace' ] rating_service_keys = [ bytes.fromhex( r ) for ( t, r ) in old_collect if t == 'rating' ] except: namespaces = [] rating_service_keys = [] media_collect = ClientMedia.MediaCollect( namespaces = namespaces, rating_service_keys = rating_service_keys ) serialisable_serialisables[ 'media_collect' ] = media_collect.GetSerialisableTuple() del serialisable_simples[ 'media_collect' ] new_serialisable_info = ( page_name, management_type, serialisable_keys, serialisable_simples, serialisable_serialisables ) return ( 10, new_serialisable_info ) if version == 10: ( page_name, management_type, serialisable_keys, serialisable_simples, serialisable_serialisables ) = old_serialisable_info if 'file_service' in serialisable_keys: file_service_key_encoded = serialisable_keys[ 'file_service' ] try: file_service_key = bytes.fromhex( file_service_key_encoded ) except: file_service_key = CC.COMBINED_LOCAL_FILE_SERVICE_KEY del serialisable_keys[ 'file_service' ] location_context = ClientLocation.LocationContext.STATICCreateSimple( file_service_key ) serialisable_serialisables[ 'location_context' ] = location_context.GetSerialisableTuple() new_serialisable_info = ( page_name, management_type, serialisable_keys, serialisable_simples, serialisable_serialisables ) return ( 11, new_serialisable_info ) if version == 11: ( page_name, management_type, serialisable_keys, serialisable_simples, serialisable_serialisables ) = old_serialisable_info # notice I rename them to _key here! # we had 'page' and 'petition_service' before, so adding the key brings us in line with elsewhere keys = { name + '_key' : bytes.fromhex( key ) for ( name, key ) in serialisable_keys.items() } simples = dict( serialisable_simples ) serialisables = { name : HydrusSerialisable.CreateFromSerialisableTuple( value ) for ( name, value ) in list(serialisable_serialisables.items()) } variables = HydrusSerialisable.SerialisableDictionary() variables.update( keys ) variables.update( simples ) variables.update( serialisables ) if management_type == MANAGEMENT_TYPE_DUPLICATE_FILTER: value = CC.DUPE_SEARCH_ONE_FILE_MATCHES_ONE_SEARCH if 'both_files_match' in variables: if variables[ 'both_files_match' ]: value = CC.DUPE_SEARCH_BOTH_FILES_MATCH_ONE_SEARCH del variables[ 'both_files_match' ] variables[ 'dupe_search_type' ] = value default_location_context = HG.client_controller.new_options.GetDefaultLocalLocationContext() file_search_context = ClientSearch.FileSearchContext( location_context = default_location_context, predicates = [ ClientSearch.Predicate( ClientSearch.PREDICATE_TYPE_SYSTEM_EVERYTHING ) ] ) variables[ 'file_search_context_1' ] = file_search_context variables[ 'file_search_context_2' ] = file_search_context.Duplicate() if 'file_search_context' in variables: variables[ 'file_search_context_1' ] = variables[ 'file_search_context' ] del variables[ 'file_search_context' ] serialisable_variables = variables.GetSerialisableTuple() new_serialisable_info = ( page_name, management_type, serialisable_variables ) return ( 12, new_serialisable_info ) def GetAPIInfoDict( self, simple ): d = {} if self._management_type == MANAGEMENT_TYPE_IMPORT_HDD: hdd_import = self._variables[ 'hdd_import' ] d[ 'hdd_import' ] = hdd_import.GetAPIInfoDict( simple ) elif self._management_type == MANAGEMENT_TYPE_IMPORT_SIMPLE_DOWNLOADER: simple_downloader_import = self._variables[ 'simple_downloader_import' ] d[ 'simple_downloader_import' ] = simple_downloader_import.GetAPIInfoDict( simple ) elif self._management_type == MANAGEMENT_TYPE_IMPORT_MULTIPLE_GALLERY: multiple_gallery_import = self._variables[ 'multiple_gallery_import' ] d[ 'multiple_gallery_import' ] = multiple_gallery_import.GetAPIInfoDict( simple ) elif self._management_type == MANAGEMENT_TYPE_IMPORT_MULTIPLE_WATCHER: multiple_watcher_import = self._variables[ 'multiple_watcher_import' ] d[ 'multiple_watcher_import' ] = multiple_watcher_import.GetAPIInfoDict( simple ) elif self._management_type == MANAGEMENT_TYPE_IMPORT_URLS: urls_import = self._variables[ 'urls_import' ] d[ 'urls_import' ] = urls_import.GetAPIInfoDict( simple ) return d def GetNumSeeds( self ): try: if self._management_type == MANAGEMENT_TYPE_IMPORT_HDD: hdd_import = self._variables[ 'hdd_import' ] return hdd_import.GetNumSeeds() elif self._management_type == MANAGEMENT_TYPE_IMPORT_SIMPLE_DOWNLOADER: simple_downloader_import = self._variables[ 'simple_downloader_import' ] return simple_downloader_import.GetNumSeeds() elif self._management_type == MANAGEMENT_TYPE_IMPORT_MULTIPLE_GALLERY: multiple_gallery_import = self._variables[ 'multiple_gallery_import' ] return multiple_gallery_import.GetNumSeeds() elif self._management_type == MANAGEMENT_TYPE_IMPORT_MULTIPLE_WATCHER: multiple_watcher_import = self._variables[ 'multiple_watcher_import' ] return multiple_watcher_import.GetNumSeeds() elif self._management_type == MANAGEMENT_TYPE_IMPORT_URLS: urls_import = self._variables[ 'urls_import' ] return urls_import.GetNumSeeds() except KeyError: return 0 return 0 def GetPageName( self ): return self._page_name def GetType( self ): return self._management_type def GetValueRange( self ): if self.IsImporter(): try: if self._management_type == MANAGEMENT_TYPE_IMPORT_HDD: importer = self._variables[ 'hdd_import' ] elif self._management_type == MANAGEMENT_TYPE_IMPORT_SIMPLE_DOWNLOADER: importer = self._variables[ 'simple_downloader_import' ] elif self._management_type == MANAGEMENT_TYPE_IMPORT_MULTIPLE_GALLERY: importer = self._variables[ 'multiple_gallery_import' ] elif self._management_type == MANAGEMENT_TYPE_IMPORT_MULTIPLE_WATCHER: importer = self._variables[ 'multiple_watcher_import' ] elif self._management_type == MANAGEMENT_TYPE_IMPORT_URLS: importer = self._variables[ 'urls_import' ] else: raise KeyError() return importer.GetValueRange() except KeyError: return ( 0, 0 ) else: return ( 0, 0 ) def GetVariable( self, name ): return self._variables[ name ] def HasSerialisableChangesSince( self, since_timestamp ): if self.IsImporter(): if self._management_type == MANAGEMENT_TYPE_IMPORT_HDD: importer = self._variables[ 'hdd_import' ] elif self._management_type == MANAGEMENT_TYPE_IMPORT_SIMPLE_DOWNLOADER: importer = self._variables[ 'simple_downloader_import' ] elif self._management_type == MANAGEMENT_TYPE_IMPORT_MULTIPLE_GALLERY: importer = self._variables[ 'multiple_gallery_import' ] elif self._management_type == MANAGEMENT_TYPE_IMPORT_MULTIPLE_WATCHER: importer = self._variables[ 'multiple_watcher_import' ] elif self._management_type == MANAGEMENT_TYPE_IMPORT_URLS: importer = self._variables[ 'urls_import' ] if importer.HasSerialisableChangesSince( since_timestamp ): return True return self._last_serialisable_change_timestamp > since_timestamp def HasVariable( self, name ): return name in self._variables def IsImporter( self ): return self._management_type in ( MANAGEMENT_TYPE_IMPORT_HDD, MANAGEMENT_TYPE_IMPORT_SIMPLE_DOWNLOADER, MANAGEMENT_TYPE_IMPORT_MULTIPLE_GALLERY, MANAGEMENT_TYPE_IMPORT_MULTIPLE_WATCHER, MANAGEMENT_TYPE_IMPORT_URLS ) def SetPageName( self, name ): if name != self._page_name: self._page_name = name self._SerialisableChangeMade() def SetType( self, management_type ): self._management_type = management_type self._InitialiseDefaults() self._SerialisableChangeMade() def SetVariable( self, name, value ): if name in self._variables: if type( value ) == type( self._variables[ name ] ): if isinstance( value, HydrusSerialisable.SerialisableBase ): if value.GetSerialisableTuple() == self._variables[ name ].GetSerialisableTuple(): return elif value == self._variables[ name ]: return self._variables[ name ] = value self._SerialisableChangeMade() HydrusSerialisable.SERIALISABLE_TYPES_TO_OBJECT_TYPES[ HydrusSerialisable.SERIALISABLE_TYPE_MANAGEMENT_CONTROLLER ] = ManagementController class ListBoxTagsMediaManagementPanel( ClientGUIListBoxes.ListBoxTagsMedia ): def __init__( self, parent, management_controller: ManagementController, page_key, tag_display_type = ClientTags.TAG_DISPLAY_SELECTION_LIST, tag_autocomplete: typing.Optional[ ClientGUIACDropdown.AutoCompleteDropdownTagsRead ] = None ): ClientGUIListBoxes.ListBoxTagsMedia.__init__( self, parent, tag_display_type, include_counts = True ) self._management_controller = management_controller self._minimum_height_num_chars = 15 self._page_key = page_key self._tag_autocomplete = tag_autocomplete def _Activate( self, ctrl_down, shift_down ) -> bool: predicates = self._GetPredicatesFromTerms( self._selected_terms ) if len( predicates ) > 0: if ctrl_down: predicates = [ predicate.GetInverseCopy() for predicate in predicates ] if shift_down and len( predicates ) > 1: predicates = ( ClientSearch.Predicate( ClientSearch.PREDICATE_TYPE_OR_CONTAINER, value = predicates ), ) HG.client_controller.pub( 'enter_predicates', self._page_key, predicates ) return True return False def _CanProvideCurrentPagePredicates( self ): return self._tag_autocomplete is not None def _GetCurrentLocationContext( self ): return self._management_controller.GetVariable( 'location_context' ) def _GetCurrentPagePredicates( self ) -> typing.Set[ ClientSearch.Predicate ]: if self._tag_autocomplete is None: return set() else: return self._tag_autocomplete.GetPredicates() def _ProcessMenuPredicateEvent( self, command ): ( predicates, or_predicate, inverse_predicates, namespace_predicate, inverse_namespace_predicate ) = self._GetSelectedPredicatesAndInverseCopies() p = None permit_remove = True permit_add = True if command == 'add_predicates': p = predicates permit_remove = False elif command == 'add_or_predicate': p = ( or_predicate, ) permit_remove = False elif command == 'remove_predicates': p = predicates permit_add = False elif command == 'add_inverse_predicates': p = inverse_predicates permit_remove = False elif command == 'add_namespace_predicate': p = ( namespace_predicate, ) permit_remove = False elif command == 'add_inverse_namespace_predicate': p = ( inverse_namespace_predicate, ) permit_remove = False if p is not None: HG.client_controller.pub( 'enter_predicates', self._page_key, p, permit_remove = permit_remove, permit_add = permit_add ) class ManagementPanel( QW.QScrollArea ): locationChanged = QC.Signal( ClientLocation.LocationContext ) SHOW_COLLECT = True def __init__( self, parent, page, controller, management_controller ): QW.QScrollArea.__init__( self, parent ) self.setFrameShape( QW.QFrame.NoFrame ) self.setWidget( QW.QWidget( self ) ) self.setWidgetResizable( True ) #self.setFrameStyle( QW.QFrame.Panel | QW.QFrame.Sunken ) #self.setLineWidth( 2 ) #self.setHorizontalScrollBarPolicy( QC.Qt.ScrollBarAlwaysOff ) self.setVerticalScrollBarPolicy( QC.Qt.ScrollBarAsNeeded ) self._controller = controller self._management_controller = management_controller self._page = page self._page_key = self._management_controller.GetVariable( 'page_key' ) self._current_selection_tags_list = None self._media_sort = ClientGUIResultsSortCollect.MediaSortControl( self, management_controller = self._management_controller ) silent_collect = not self.SHOW_COLLECT self._media_collect = ClientGUIResultsSortCollect.MediaCollectControl( self, management_controller = self._management_controller, silent = silent_collect ) self._media_collect.ListenForNewOptions() if not self.SHOW_COLLECT: self._media_collect.hide() def _GetDefaultEmptyPageStatusOverride( self ) -> str: return 'empty page' def _SetLocationContext( self, location_context: ClientLocation.LocationContext ): current_location_context = self._management_controller.GetVariable( 'location_context' ) if location_context != current_location_context: self._management_controller.SetVariable( 'location_context', location_context ) self.locationChanged.emit( location_context ) def ConnectMediaPanelSignals( self, media_panel: ClientGUIResults.MediaPanel ): if self._current_selection_tags_list is not None: media_panel.selectedMediaTagPresentationChanged.connect( self._current_selection_tags_list.SetTagsByMediaFromMediaPanel ) media_panel.selectedMediaTagPresentationIncremented.connect( self._current_selection_tags_list.IncrementTagsByMedia ) self._media_sort.sortChanged.connect( media_panel.Sort ) media_panel.PublishSelectionChange() def GetMediaCollect( self ): if self.SHOW_COLLECT: return self._media_collect.GetValue() else: return ClientMedia.MediaCollect() def GetMediaSort( self ): return self._media_sort.GetSort() def _MakeCurrentSelectionTagsBox( self, sizer, tag_display_type = ClientTags.TAG_DISPLAY_SELECTION_LIST ): self._current_selection_tags_box = ClientGUIListBoxes.StaticBoxSorterForListBoxTags( self, 'selection tags' ) self._current_selection_tags_list = ListBoxTagsMediaManagementPanel( self._current_selection_tags_box, self._management_controller, self._page_key, tag_display_type = tag_display_type ) self._current_selection_tags_box.SetTagsBox( self._current_selection_tags_list ) QP.AddToLayout( sizer, self._current_selection_tags_box, CC.FLAGS_EXPAND_BOTH_WAYS ) def CheckAbleToClose( self ): pass def CleanBeforeClose( self ): pass def CleanBeforeDestroy( self ): pass def GetDefaultEmptyMediaPanel( self ) -> ClientGUIResults.MediaPanel: location_context = self._management_controller.GetVariable( 'location_context' ) media_panel = ClientGUIResults.MediaPanelThumbnails( self._page, self._page_key, location_context, [] ) status = self._GetDefaultEmptyPageStatusOverride() media_panel.SetEmptyPageStatusOverride( status ) return media_panel def PageHidden( self ): pass def PageShown( self ): if self._controller.new_options.GetBoolean( 'set_search_focus_on_page_change' ): self.SetSearchFocus() def RefreshQuery( self ): pass def SetSearchFocus( self ): pass def Start( self ): pass def REPEATINGPageUpdate( self ): pass def CreateManagementPanel( parent, page, controller, management_controller ) -> ManagementPanel: management_type = management_controller.GetType() management_class = management_panel_types_to_classes[ management_type ] management_panel = management_class( parent, page, controller, management_controller ) return management_panel class ManagementPanelDuplicateFilter( ManagementPanel ): SHOW_COLLECT = False def __init__( self, parent, page, controller, management_controller ): ManagementPanel.__init__( self, parent, page, controller, management_controller ) self._duplicates_manager = ClientDuplicates.DuplicatesManager.instance() self._similar_files_maintenance_status = None self._duplicates_manager_is_fetching_maintenance_numbers = False self._potential_file_search_currently_happening = False self._maintenance_numbers_need_redrawing = True self._potential_duplicates_count = 0 self._have_done_first_maintenance_numbers_show = False new_options = self._controller.new_options self._dupe_count_numbers_dirty = True self._currently_refreshing_dupe_count_numbers = False # self._main_notebook = ClientGUICommon.BetterNotebook( self ) self._main_left_panel = QW.QWidget( self._main_notebook ) self._main_right_panel = QW.QWidget( self._main_notebook ) # self._refresh_maintenance_status = ClientGUICommon.BetterStaticText( self._main_left_panel, ellipsize_end = True ) self._refresh_maintenance_button = ClientGUICommon.BetterBitmapButton( self._main_left_panel, CC.global_pixmaps().refresh, self._duplicates_manager.RefreshMaintenanceNumbers ) menu_items = [] menu_items.append( ( 'normal', 'reset potential duplicates', 'This will delete all the potential duplicate pairs found so far and reset their files\' search status.', self._ResetUnknown ) ) menu_items.append( ( 'separator', 0, 0, 0 ) ) check_manager = ClientGUICommon.CheckboxManagerOptions( 'maintain_similar_files_duplicate_pairs_during_idle' ) menu_items.append( ( 'check', 'search for duplicate pairs at the current distance during normal db maintenance', 'Tell the client to find duplicate pairs in its normal db maintenance cycles, whether you have that set to idle or shutdown time.', check_manager ) ) self._cog_button = ClientGUIMenuButton.MenuBitmapButton( self._main_left_panel, CC.global_pixmaps().cog, menu_items ) menu_items = [] page_func = HydrusData.Call( ClientPaths.LaunchPathInWebBrowser, os.path.join( HC.HELP_DIR, 'duplicates.html' ) ) menu_items.append( ( 'normal', 'open the html duplicates help', 'Open the help page for duplicates processing in your web browser.', page_func ) ) self._help_button = ClientGUIMenuButton.MenuBitmapButton( self._main_left_panel, CC.global_pixmaps().help, menu_items ) # self._searching_panel = ClientGUICommon.StaticBox( self._main_left_panel, 'finding potential duplicates' ) self._eligible_files = ClientGUICommon.BetterStaticText( self._searching_panel, ellipsize_end = True ) menu_items = [] menu_items.append( ( 'normal', 'exact match', 'Search for exact matches.', HydrusData.Call( self._SetSearchDistance, CC.HAMMING_EXACT_MATCH ) ) ) menu_items.append( ( 'normal', 'very similar', 'Search for very similar files.', HydrusData.Call( self._SetSearchDistance, CC.HAMMING_VERY_SIMILAR ) ) ) menu_items.append( ( 'normal', 'similar', 'Search for similar files.', HydrusData.Call( self._SetSearchDistance, CC.HAMMING_SIMILAR ) ) ) menu_items.append( ( 'normal', 'speculative', 'Search for files that are probably similar.', HydrusData.Call( self._SetSearchDistance, CC.HAMMING_SPECULATIVE ) ) ) self._max_hamming_distance_for_potential_discovery_button = ClientGUIMenuButton.MenuButton( self._searching_panel, 'similarity', menu_items ) self._max_hamming_distance_for_potential_discovery_spinctrl = ClientGUICommon.BetterSpinBox( self._searching_panel, min=0, max=64, width = 50 ) self._max_hamming_distance_for_potential_discovery_spinctrl.setSingleStep( 2 ) self._num_searched = ClientGUICommon.TextAndGauge( self._searching_panel ) self._search_button = ClientGUICommon.BetterBitmapButton( self._searching_panel, CC.global_pixmaps().play, self._duplicates_manager.StartPotentialsSearch ) # menu_items = [] menu_items.append( ( 'normal', 'edit duplicate metadata merge options for \'this is better\'', 'edit what content is merged when you filter files', HydrusData.Call( self._EditMergeOptions, HC.DUPLICATE_BETTER ) ) ) menu_items.append( ( 'normal', 'edit duplicate metadata merge options for \'same quality\'', 'edit what content is merged when you filter files', HydrusData.Call( self._EditMergeOptions, HC.DUPLICATE_SAME_QUALITY ) ) ) if new_options.GetBoolean( 'advanced_mode' ): menu_items.append( ( 'normal', 'edit duplicate metadata merge options for \'alternates\' (advanced!)', 'edit what content is merged when you filter files', HydrusData.Call( self._EditMergeOptions, HC.DUPLICATE_ALTERNATE ) ) ) self._edit_merge_options = ClientGUIMenuButton.MenuButton( self._main_right_panel, 'edit default duplicate metadata merge options', menu_items ) # self._filtering_panel = ClientGUICommon.StaticBox( self._main_right_panel, 'duplicate filter' ) file_search_context_1 = management_controller.GetVariable( 'file_search_context_1' ) file_search_context_2 = management_controller.GetVariable( 'file_search_context_2' ) file_search_context_1.FixMissingServices( HG.client_controller.services_manager.FilterValidServiceKeys ) file_search_context_2.FixMissingServices( HG.client_controller.services_manager.FilterValidServiceKeys ) if self._management_controller.HasVariable( 'synchronised' ): synchronised = self._management_controller.GetVariable( 'synchronised' ) else: synchronised = True self._tag_autocomplete_1 = ClientGUIACDropdown.AutoCompleteDropdownTagsRead( self._filtering_panel, self._page_key, file_search_context_1, media_sort_widget = self._media_sort, media_collect_widget = self._media_collect, allow_all_known_files = False, synchronised = synchronised, force_system_everything = True ) self._tag_autocomplete_2 = ClientGUIACDropdown.AutoCompleteDropdownTagsRead( self._filtering_panel, self._page_key, file_search_context_2, media_sort_widget = self._media_sort, media_collect_widget = self._media_collect, allow_all_known_files = False, synchronised = synchronised, force_system_everything = True ) self._dupe_search_type = ClientGUICommon.BetterChoice( self._filtering_panel ) self._dupe_search_type.addItem( 'at least one file matches the search', CC.DUPE_SEARCH_ONE_FILE_MATCHES_ONE_SEARCH ) self._dupe_search_type.addItem( 'both files match the search', CC.DUPE_SEARCH_BOTH_FILES_MATCH_ONE_SEARCH ) self._dupe_search_type.addItem( 'both files match different searches', CC.DUPE_SEARCH_BOTH_FILES_MATCH_DIFFERENT_SEARCHES ) self._pixel_dupes_preference = ClientGUICommon.BetterChoice( self._filtering_panel ) for p in ( CC.SIMILAR_FILES_PIXEL_DUPES_REQUIRED, CC.SIMILAR_FILES_PIXEL_DUPES_ALLOWED, CC.SIMILAR_FILES_PIXEL_DUPES_EXCLUDED ): self._pixel_dupes_preference.addItem( CC.similar_files_pixel_dupes_string_lookup[ p ], p ) self._max_hamming_distance_for_filter = ClientGUICommon.BetterSpinBox( self._filtering_panel, min = 0, max = 64 ) self._max_hamming_distance_for_filter.setSingleStep( 2 ) self._num_potential_duplicates = ClientGUICommon.BetterStaticText( self._filtering_panel, ellipsize_end = True ) self._refresh_dupe_counts_button = ClientGUICommon.BetterBitmapButton( self._filtering_panel, CC.global_pixmaps().refresh, self.RefreshDuplicateNumbers ) self._launch_filter = ClientGUICommon.BetterButton( self._filtering_panel, 'launch the filter', self._LaunchFilter ) # random_filtering_panel = ClientGUICommon.StaticBox( self._main_right_panel, 'quick and dirty processing' ) self._show_some_dupes = ClientGUICommon.BetterButton( random_filtering_panel, 'show some random potential pairs', self._ShowRandomPotentialDupes ) self._set_random_as_same_quality_button = ClientGUICommon.BetterButton( random_filtering_panel, 'set current media as duplicates of the same quality', self._SetCurrentMediaAs, HC.DUPLICATE_SAME_QUALITY ) self._set_random_as_alternates_button = ClientGUICommon.BetterButton( random_filtering_panel, 'set current media as all related alternates', self._SetCurrentMediaAs, HC.DUPLICATE_ALTERNATE ) self._set_random_as_false_positives_button = ClientGUICommon.BetterButton( random_filtering_panel, 'set current media as not related/false positive', self._SetCurrentMediaAs, HC.DUPLICATE_FALSE_POSITIVE ) # self._main_notebook.addTab( self._main_left_panel, 'preparation' ) self._main_notebook.addTab( self._main_right_panel, 'filtering' ) self._main_notebook.setCurrentWidget( self._main_right_panel ) # self._max_hamming_distance_for_potential_discovery_spinctrl.setValue( new_options.GetInteger( 'similar_files_duplicate_pairs_search_distance' ) ) self._dupe_search_type.SetValue( management_controller.GetVariable( 'dupe_search_type' ) ) if not management_controller.HasVariable( 'pixel_dupes_preference' ): management_controller.SetVariable( 'pixel_dupes_preference', CC.SIMILAR_FILES_PIXEL_DUPES_ALLOWED ) self._pixel_dupes_preference.SetValue( management_controller.GetVariable( 'pixel_dupes_preference' ) ) self._pixel_dupes_preference.currentIndexChanged.connect( self.FilterSearchDomainChanged ) if not management_controller.HasVariable( 'max_hamming_distance' ): management_controller.SetVariable( 'max_hamming_distance', 4 ) self._max_hamming_distance_for_filter.setValue( management_controller.GetVariable( 'max_hamming_distance' ) ) self._max_hamming_distance_for_filter.valueChanged.connect( self.FilterSearchDomainChanged ) # self._UpdateFilterSearchControls() # self._media_sort.hide() distance_hbox = QP.HBoxLayout() QP.AddToLayout( distance_hbox, ClientGUICommon.BetterStaticText(self._searching_panel,label='search distance: '), CC.FLAGS_CENTER_PERPENDICULAR ) QP.AddToLayout( distance_hbox, self._max_hamming_distance_for_potential_discovery_button, CC.FLAGS_EXPAND_BOTH_WAYS ) QP.AddToLayout( distance_hbox, self._max_hamming_distance_for_potential_discovery_spinctrl, CC.FLAGS_CENTER_PERPENDICULAR ) gridbox_2 = QP.GridLayout( cols = 2 ) gridbox_2.setColumnStretch( 0, 1 ) QP.AddToLayout( gridbox_2, self._num_searched, CC.FLAGS_EXPAND_SIZER_PERPENDICULAR ) QP.AddToLayout( gridbox_2, self._search_button, CC.FLAGS_CENTER_PERPENDICULAR ) self._searching_panel.Add( self._eligible_files, CC.FLAGS_EXPAND_PERPENDICULAR ) self._searching_panel.Add( distance_hbox, CC.FLAGS_EXPAND_SIZER_PERPENDICULAR ) self._searching_panel.Add( gridbox_2, CC.FLAGS_EXPAND_SIZER_PERPENDICULAR ) # hbox = QP.HBoxLayout() QP.AddToLayout( hbox, self._refresh_maintenance_status, CC.FLAGS_CENTER_PERPENDICULAR_EXPAND_DEPTH ) QP.AddToLayout( hbox, self._refresh_maintenance_button, CC.FLAGS_CENTER_PERPENDICULAR ) QP.AddToLayout( hbox, self._cog_button, CC.FLAGS_CENTER_PERPENDICULAR ) QP.AddToLayout( hbox, self._help_button, CC.FLAGS_CENTER_PERPENDICULAR ) vbox = QP.VBoxLayout() QP.AddToLayout( vbox, hbox, CC.FLAGS_EXPAND_PERPENDICULAR ) QP.AddToLayout( vbox, self._searching_panel, CC.FLAGS_EXPAND_PERPENDICULAR ) vbox.addStretch( 1 ) self._main_left_panel.setLayout( vbox ) # text_and_button_hbox = QP.HBoxLayout() QP.AddToLayout( text_and_button_hbox, self._num_potential_duplicates, CC.FLAGS_CENTER_PERPENDICULAR_EXPAND_DEPTH ) QP.AddToLayout( text_and_button_hbox, self._refresh_dupe_counts_button, CC.FLAGS_CENTER_PERPENDICULAR ) rows = [] rows.append( ( 'maximum search distance of pair: ', self._max_hamming_distance_for_filter ) ) gridbox = ClientGUICommon.WrapInGrid( self._filtering_panel, rows ) self._filtering_panel.Add( self._dupe_search_type, CC.FLAGS_EXPAND_PERPENDICULAR ) self._filtering_panel.Add( self._tag_autocomplete_1, CC.FLAGS_EXPAND_PERPENDICULAR ) self._filtering_panel.Add( self._tag_autocomplete_2, CC.FLAGS_EXPAND_PERPENDICULAR ) self._filtering_panel.Add( gridbox, CC.FLAGS_EXPAND_SIZER_PERPENDICULAR ) self._filtering_panel.Add( self._pixel_dupes_preference, CC.FLAGS_EXPAND_PERPENDICULAR ) self._filtering_panel.Add( text_and_button_hbox, CC.FLAGS_EXPAND_PERPENDICULAR ) self._filtering_panel.Add( self._launch_filter, CC.FLAGS_EXPAND_PERPENDICULAR ) random_filtering_panel.Add( self._show_some_dupes, CC.FLAGS_EXPAND_PERPENDICULAR ) random_filtering_panel.Add( self._set_random_as_same_quality_button, CC.FLAGS_EXPAND_PERPENDICULAR ) random_filtering_panel.Add( self._set_random_as_alternates_button, CC.FLAGS_EXPAND_PERPENDICULAR ) random_filtering_panel.Add( self._set_random_as_false_positives_button, CC.FLAGS_EXPAND_PERPENDICULAR ) vbox = QP.VBoxLayout() QP.AddToLayout( vbox, self._edit_merge_options, CC.FLAGS_EXPAND_PERPENDICULAR ) QP.AddToLayout( vbox, self._filtering_panel, CC.FLAGS_EXPAND_PERPENDICULAR ) QP.AddToLayout( vbox, random_filtering_panel, CC.FLAGS_EXPAND_PERPENDICULAR ) self._MakeCurrentSelectionTagsBox( vbox ) self._main_right_panel.setLayout( vbox ) # vbox = QP.VBoxLayout() QP.AddToLayout( vbox, self._main_notebook, CC.FLAGS_EXPAND_BOTH_WAYS ) self.widget().setLayout( vbox ) self._controller.sub( self, 'NotifyNewMaintenanceNumbers', 'new_similar_files_maintenance_numbers' ) self._controller.sub( self, 'NotifyNewPotentialsSearchNumbers', 'new_similar_files_potentials_search_numbers' ) self._tag_autocomplete_1.searchChanged.connect( self.Search1Changed ) self._tag_autocomplete_2.searchChanged.connect( self.Search2Changed ) self._dupe_search_type.currentIndexChanged.connect( self.FilterDupeSearchTypeChanged ) self._max_hamming_distance_for_potential_discovery_spinctrl.valueChanged.connect( self.MaxHammingDistanceForPotentialDiscoveryChanged ) def _EditMergeOptions( self, duplicate_type ): new_options = HG.client_controller.new_options duplicate_content_merge_options = new_options.GetDuplicateContentMergeOptions( duplicate_type ) with ClientGUITopLevelWindowsPanels.DialogEdit( self, 'edit duplicate merge options' ) as dlg: panel = ClientGUIScrolledPanelsEdit.EditDuplicateContentMergeOptionsPanel( dlg, duplicate_type, duplicate_content_merge_options ) dlg.SetPanel( panel ) if dlg.exec() == QW.QDialog.Accepted: duplicate_content_merge_options = panel.GetValue() new_options.SetDuplicateContentMergeOptions( duplicate_type, duplicate_content_merge_options ) def _FilterSearchDomainUpdated( self ): ( file_search_context_1, file_search_context_2, dupe_search_type, pixel_dupes_preference, max_hamming_distance ) = self._GetDuplicateFileSearchData( optimise_for_search = False ) self._management_controller.SetVariable( 'file_search_context_1', file_search_context_1 ) self._management_controller.SetVariable( 'file_search_context_2', file_search_context_2 ) synchronised = self._tag_autocomplete_1.IsSynchronised() self._management_controller.SetVariable( 'synchronised', synchronised ) self._management_controller.SetVariable( 'dupe_search_type', dupe_search_type ) self._management_controller.SetVariable( 'pixel_dupes_preference', pixel_dupes_preference ) self._management_controller.SetVariable( 'max_hamming_distance', max_hamming_distance ) self._SetLocationContext( file_search_context_1.GetLocationContext() ) self._UpdateFilterSearchControls() if self._tag_autocomplete_1.IsSynchronised(): self._dupe_count_numbers_dirty = True def _GetDuplicateFileSearchData( self, optimise_for_search = True ) -> typing.Tuple[ ClientSearch.FileSearchContext, ClientSearch.FileSearchContext, int, int, int ]: file_search_context_1 = self._tag_autocomplete_1.GetFileSearchContext() file_search_context_2 = self._tag_autocomplete_2.GetFileSearchContext() dupe_search_type = self._dupe_search_type.GetValue() if optimise_for_search: if dupe_search_type == CC.DUPE_SEARCH_BOTH_FILES_MATCH_ONE_SEARCH and ( file_search_context_1.IsJustSystemEverything() or file_search_context_1.HasNoPredicates() ): dupe_search_type = CC.DUPE_SEARCH_ONE_FILE_MATCHES_ONE_SEARCH elif dupe_search_type == CC.DUPE_SEARCH_BOTH_FILES_MATCH_DIFFERENT_SEARCHES: if file_search_context_1.IsJustSystemEverything() or file_search_context_1.HasNoPredicates(): f = file_search_context_1 file_search_context_1 = file_search_context_2 file_search_context_2 = f dupe_search_type = CC.DUPE_SEARCH_ONE_FILE_MATCHES_ONE_SEARCH elif file_search_context_2.IsJustSystemEverything() or file_search_context_2.HasNoPredicates(): dupe_search_type = CC.DUPE_SEARCH_ONE_FILE_MATCHES_ONE_SEARCH pixel_dupes_preference = self._pixel_dupes_preference.GetValue() max_hamming_distance = self._max_hamming_distance_for_filter.value() return ( file_search_context_1, file_search_context_2, dupe_search_type, pixel_dupes_preference, max_hamming_distance ) def _LaunchFilter( self ): ( file_search_context_1, file_search_context_2, dupe_search_type, pixel_dupes_preference, max_hamming_distance ) = self._GetDuplicateFileSearchData() canvas_frame = ClientGUICanvasFrame.CanvasFrame( self.window() ) canvas_window = ClientGUICanvas.CanvasFilterDuplicates( canvas_frame, file_search_context_1, file_search_context_2, dupe_search_type, pixel_dupes_preference, max_hamming_distance ) canvas_window.showPairInPage.connect( self._ShowPairInPage ) canvas_frame.SetCanvas( canvas_window ) def _RefreshDuplicateCounts( self ): def qt_code( potential_duplicates_count ): if not self or not QP.isValid( self ): return self._currently_refreshing_dupe_count_numbers = False self._dupe_count_numbers_dirty = False self._refresh_dupe_counts_button.setEnabled( True ) self._UpdatePotentialDuplicatesCount( potential_duplicates_count ) def thread_do_it( file_search_context_1, file_search_context_2, dupe_search_type, pixel_dupes_preference, max_hamming_distance ): potential_duplicates_count = HG.client_controller.Read( 'potential_duplicates_count', file_search_context_1, file_search_context_2, dupe_search_type, pixel_dupes_preference, max_hamming_distance ) QP.CallAfter( qt_code, potential_duplicates_count ) if not self._currently_refreshing_dupe_count_numbers: self._currently_refreshing_dupe_count_numbers = True self._refresh_dupe_counts_button.setEnabled( False ) self._num_potential_duplicates.setText( 'updating\u2026' ) ( file_search_context_1, file_search_context_2, dupe_search_type, pixel_dupes_preference, max_hamming_distance ) = self._GetDuplicateFileSearchData() HG.client_controller.CallToThread( thread_do_it, file_search_context_1, file_search_context_2, dupe_search_type, pixel_dupes_preference, max_hamming_distance ) def _ResetUnknown( self ): text = 'This will delete all the potential duplicate pairs and reset their files\' search status.' text += os.linesep * 2 text += 'This can be useful if you have accidentally searched too broadly and are now swamped with too many false positives.' result = ClientGUIDialogsQuick.GetYesNo( self, text ) if result == QW.QDialog.Accepted: self._controller.Write( 'delete_potential_duplicate_pairs' ) self._duplicates_manager.RefreshMaintenanceNumbers() def _SetCurrentMediaAs( self, duplicate_type ): media_panel = self._page.GetMediaPanel() change_made = media_panel.SetDuplicateStatusForAll( duplicate_type ) if change_made: self._dupe_count_numbers_dirty = True if self._potential_duplicates_count > 1: self._ShowRandomPotentialDupes() else: self._ShowPotentialDupes( [] ) def _SetSearchDistance( self, value ): self._max_hamming_distance_for_potential_discovery_spinctrl.setValue( value ) self._UpdateMaintenanceStatus() def _ShowPairInPage( self, media: typing.Collection[ ClientMedia.MediaSingleton ] ): media_results = [ m.GetMediaResult() for m in media ] self._page.GetMediaPanel().AddMediaResults( self._page_key, media_results ) def _ShowPotentialDupes( self, hashes ): ( file_search_context_1, file_search_context_2, dupe_search_type, pixel_dupes_preference, max_hamming_distance ) = self._GetDuplicateFileSearchData() location_context = file_search_context_1.GetLocationContext() self._SetLocationContext( location_context ) if len( hashes ) > 0: media_results = self._controller.Read( 'media_results', hashes, sorted = True ) else: media_results = [] panel = ClientGUIResults.MediaPanelThumbnails( self._page, self._page_key, location_context, media_results ) panel.SetEmptyPageStatusOverride( 'no dupes found' ) self._page.SwapMediaPanel( panel ) def _ShowRandomPotentialDupes( self ): ( file_search_context_1, file_search_context_2, dupe_search_type, pixel_dupes_preference, max_hamming_distance ) = self._GetDuplicateFileSearchData() hashes = self._controller.Read( 'random_potential_duplicate_hashes', file_search_context_1, file_search_context_2, dupe_search_type, pixel_dupes_preference, max_hamming_distance ) if len( hashes ) == 0: HydrusData.ShowText( 'No files were found. Try refreshing the count, and if this keeps happening, please let hydrus_dev know.' ) self._ShowPotentialDupes( hashes ) def _UpdateMaintenanceStatus( self ): self._refresh_maintenance_button.setEnabled( not ( self._duplicates_manager_is_fetching_maintenance_numbers or self._potential_file_search_currently_happening ) ) if self._similar_files_maintenance_status is None: self._search_button.setEnabled( False ) return searched_distances_to_count = self._similar_files_maintenance_status self._cog_button.setEnabled( True ) total_num_files = sum( searched_distances_to_count.values() ) self._eligible_files.setText( '{} eligible files in the system.'.format(HydrusData.ToHumanInt(total_num_files)) ) self._max_hamming_distance_for_potential_discovery_button.setEnabled( True ) self._max_hamming_distance_for_potential_discovery_spinctrl.setEnabled( True ) options_search_distance = self._controller.new_options.GetInteger( 'similar_files_duplicate_pairs_search_distance' ) if self._max_hamming_distance_for_potential_discovery_spinctrl.value() != options_search_distance: self._max_hamming_distance_for_potential_discovery_spinctrl.setValue( options_search_distance ) search_distance = self._max_hamming_distance_for_potential_discovery_spinctrl.value() if search_distance in CC.hamming_string_lookup: button_label = CC.hamming_string_lookup[ search_distance ] else: button_label = 'custom' self._max_hamming_distance_for_potential_discovery_button.setText( button_label ) num_searched = sum( ( count for ( value, count ) in searched_distances_to_count.items() if value is not None and value >= search_distance ) ) not_all_files_searched = num_searched < total_num_files we_can_start_work = not_all_files_searched and not self._potential_file_search_currently_happening self._search_button.setEnabled( we_can_start_work ) if not_all_files_searched: if num_searched == 0: self._num_searched.SetValue( 'Have not yet searched at this distance.', 0, total_num_files ) else: self._num_searched.SetValue( 'Searched ' + HydrusData.ConvertValueRangeToPrettyString( num_searched, total_num_files ) + ' files at this distance.', num_searched, total_num_files ) page_name = 'preparation (needs work)' if not self._have_done_first_maintenance_numbers_show: self._main_notebook.SelectPage( self._main_left_panel ) else: self._num_searched.SetValue( 'All potential duplicates found at this distance.', total_num_files, total_num_files ) page_name = 'preparation' self._main_notebook.setTabText( 0, page_name ) self._have_done_first_maintenance_numbers_show = True def _UpdatePotentialDuplicatesCount( self, potential_duplicates_count ): self._potential_duplicates_count = potential_duplicates_count self._num_potential_duplicates.setText( '{} potential pairs.'.format( HydrusData.ToHumanInt( potential_duplicates_count ) ) ) if self._potential_duplicates_count > 0: self._show_some_dupes.setEnabled( True ) self._launch_filter.setEnabled( True ) else: self._show_some_dupes.setEnabled( False ) self._launch_filter.setEnabled( False ) def _UpdateFilterSearchControls( self ): ( file_search_context_1, file_search_context_2, dupe_search_type, pixel_dupes_preference, max_hamming_distance ) = self._GetDuplicateFileSearchData( optimise_for_search = False ) self._tag_autocomplete_2.setVisible( dupe_search_type == CC.DUPE_SEARCH_BOTH_FILES_MATCH_DIFFERENT_SEARCHES ) self._max_hamming_distance_for_filter.setEnabled( self._pixel_dupes_preference.GetValue() != CC.SIMILAR_FILES_PIXEL_DUPES_REQUIRED ) def FilterDupeSearchTypeChanged( self ): self._FilterSearchDomainUpdated() def FilterSearchDomainChanged( self ): self._FilterSearchDomainUpdated() def MaxHammingDistanceForPotentialDiscoveryChanged( self ): search_distance = self._max_hamming_distance_for_potential_discovery_spinctrl.value() self._controller.new_options.SetInteger( 'similar_files_duplicate_pairs_search_distance', search_distance ) self._controller.pub( 'new_similar_files_maintenance_numbers' ) self._UpdateMaintenanceStatus() def NotifyNewMaintenanceNumbers( self ): self._maintenance_numbers_need_redrawing = True def NotifyNewPotentialsSearchNumbers( self ): self._dupe_count_numbers_dirty = True def PageHidden( self ): ManagementPanel.PageHidden( self ) self._tag_autocomplete_1.SetForceDropdownHide( True ) def PageShown( self ): ManagementPanel.PageShown( self ) self._tag_autocomplete_1.SetForceDropdownHide( False ) def RefreshDuplicateNumbers( self ): self._dupe_count_numbers_dirty = True def RefreshQuery( self ): self._FilterSearchDomainUpdated() def REPEATINGPageUpdate( self ): if self._maintenance_numbers_need_redrawing: ( self._similar_files_maintenance_status, self._duplicates_manager_is_fetching_maintenance_numbers, self._potential_file_search_currently_happening ) = self._duplicates_manager.GetMaintenanceNumbers() self._maintenance_numbers_need_redrawing = False self._UpdateMaintenanceStatus() if self._dupe_count_numbers_dirty: self._RefreshDuplicateCounts() def Search1Changed( self, file_search_context: ClientSearch.FileSearchContext ): self._tag_autocomplete_2.blockSignals( True ) self._tag_autocomplete_2.SetLocationContext( self._tag_autocomplete_1.GetLocationContext() ) self._tag_autocomplete_2.SetSynchronised( self._tag_autocomplete_1.IsSynchronised() ) self._tag_autocomplete_2.blockSignals( False ) self._FilterSearchDomainUpdated() def Search2Changed( self, file_search_context: ClientSearch.FileSearchContext ): self._tag_autocomplete_1.blockSignals( True ) self._tag_autocomplete_1.SetLocationContext( self._tag_autocomplete_2.GetLocationContext() ) self._tag_autocomplete_1.SetSynchronised( self._tag_autocomplete_2.IsSynchronised() ) self._tag_autocomplete_1.blockSignals( False ) self._FilterSearchDomainUpdated() management_panel_types_to_classes[ MANAGEMENT_TYPE_DUPLICATE_FILTER ] = ManagementPanelDuplicateFilter class ManagementPanelImporter( ManagementPanel ): def __init__( self, parent, page, controller, management_controller ): ManagementPanel.__init__( self, parent, page, controller, management_controller ) def _UpdateImportStatus( self ): raise NotImplementedError() def PageShown( self ): ManagementPanel.PageShown( self ) self._UpdateImportStatus() def RefreshQuery( self ): self._media_sort.BroadcastSort() def REPEATINGPageUpdate( self ): self._UpdateImportStatus() class ManagementPanelImporterHDD( ManagementPanelImporter ): def __init__( self, parent, page, controller, management_controller ): ManagementPanelImporter.__init__( self, parent, page, controller, management_controller ) self._import_queue_panel = ClientGUICommon.StaticBox( self, 'imports' ) self._current_action = ClientGUICommon.BetterStaticText( self._import_queue_panel, ellipsize_end = True ) self._file_seed_cache_control = ClientGUIFileSeedCache.FileSeedCacheStatusControl( self._import_queue_panel, self._controller, self._page_key ) self._pause_button = ClientGUICommon.BetterBitmapButton( self._import_queue_panel, CC.global_pixmaps().file_pause, self.Pause ) self._pause_button.setToolTip( 'pause/play imports' ) self._hdd_import = self._management_controller.GetVariable( 'hdd_import' ) file_import_options = self._hdd_import.GetFileImportOptions() show_downloader_options = False allow_default_selection = True self._import_options_button = ClientGUIImportOptions.ImportOptionsButton( self, show_downloader_options, allow_default_selection ) self._import_options_button.SetFileImportOptions( file_import_options ) # vbox = QP.VBoxLayout() QP.AddToLayout( vbox, self._media_sort, CC.FLAGS_EXPAND_PERPENDICULAR ) QP.AddToLayout( vbox, self._media_collect, CC.FLAGS_EXPAND_PERPENDICULAR ) hbox = QP.HBoxLayout() QP.AddToLayout( hbox, self._current_action, CC.FLAGS_CENTER_PERPENDICULAR_EXPAND_DEPTH ) QP.AddToLayout( hbox, self._pause_button, CC.FLAGS_CENTER_PERPENDICULAR ) self._import_queue_panel.Add( hbox, CC.FLAGS_EXPAND_SIZER_PERPENDICULAR ) self._import_queue_panel.Add( self._file_seed_cache_control, CC.FLAGS_EXPAND_PERPENDICULAR ) self._import_queue_panel.Add( self._import_options_button, CC.FLAGS_EXPAND_PERPENDICULAR ) QP.AddToLayout( vbox, self._import_queue_panel, CC.FLAGS_EXPAND_PERPENDICULAR ) self._MakeCurrentSelectionTagsBox( vbox ) self.widget().setLayout( vbox ) # file_seed_cache = self._hdd_import.GetFileSeedCache() self._file_seed_cache_control.SetFileSeedCache( file_seed_cache ) self._UpdateImportStatus() self._import_options_button.fileImportOptionsChanged.connect( self._hdd_import.SetFileImportOptions ) def _UpdateImportStatus( self ): ( current_action, paused ) = self._hdd_import.GetStatus() if paused: ClientGUIFunctions.SetBitmapButtonBitmap( self._pause_button, CC.global_pixmaps().file_play ) else: ClientGUIFunctions.SetBitmapButtonBitmap( self._pause_button, CC.global_pixmaps().file_pause ) self._current_action.setText( current_action ) def CheckAbleToClose( self ): if self._hdd_import.CurrentlyWorking(): raise HydrusExceptions.VetoException( 'This page is still importing.' ) def Pause( self ): self._hdd_import.PausePlay() self._UpdateImportStatus() def Start( self ): self._hdd_import.Start( self._page_key ) management_panel_types_to_classes[ MANAGEMENT_TYPE_IMPORT_HDD ] = ManagementPanelImporterHDD class ManagementPanelImporterMultipleGallery( ManagementPanelImporter ): def __init__( self, parent, page, controller, management_controller ): ManagementPanelImporter.__init__( self, parent, page, controller, management_controller ) self._last_time_imports_changed = 0 self._next_update_time = 0 self._multiple_gallery_import = self._management_controller.GetVariable( 'multiple_gallery_import' ) self._highlighted_gallery_import = self._multiple_gallery_import.GetHighlightedGalleryImport() # self._gallery_downloader_panel = ClientGUICommon.StaticBox( self, 'gallery downloader' ) # self._gallery_importers_status_st_top = ClientGUICommon.BetterStaticText( self._gallery_downloader_panel, ellipsize_end = True ) self._gallery_importers_status_st_bottom = ClientGUICommon.BetterStaticText( self._gallery_downloader_panel, ellipsize_end = True ) self._gallery_importers_listctrl_panel = ClientGUIListCtrl.BetterListCtrlPanel( self._gallery_downloader_panel ) self._gallery_importers_listctrl = ClientGUIListCtrl.BetterListCtrl( self._gallery_importers_listctrl_panel, CGLC.COLUMN_LIST_GALLERY_IMPORTERS.ID, 4, self._ConvertDataToListCtrlTuples, delete_key_callback = self._RemoveGalleryImports, activation_callback = self._HighlightSelectedGalleryImport ) self._gallery_importers_listctrl_panel.SetListCtrl( self._gallery_importers_listctrl ) self._gallery_importers_listctrl_panel.AddBitmapButton( CC.global_pixmaps().highlight, self._HighlightSelectedGalleryImport, tooltip = 'highlight', enabled_check_func = self._CanHighlight ) self._gallery_importers_listctrl_panel.AddBitmapButton( CC.global_pixmaps().clear_highlight, self._ClearExistingHighlightAndPanel, tooltip = 'clear highlight', enabled_check_func = self._CanClearHighlight ) self._gallery_importers_listctrl_panel.AddBitmapButton( CC.global_pixmaps().file_pause, self._PausePlayFiles, tooltip = 'pause/play files', enabled_only_on_selection = True ) self._gallery_importers_listctrl_panel.AddBitmapButton( CC.global_pixmaps().gallery_pause, self._PausePlayGallery, tooltip = 'pause/play search', enabled_only_on_selection = True ) self._gallery_importers_listctrl_panel.AddBitmapButton( CC.global_pixmaps().trash, self._RemoveGalleryImports, tooltip = 'remove selected', enabled_only_on_selection = True ) self._gallery_importers_listctrl_panel.NewButtonRow() self._gallery_importers_listctrl_panel.AddButton( 'retry failed', self._RetryFailed, enabled_check_func = self._CanRetryFailed ) self._gallery_importers_listctrl_panel.AddButton( 'retry ignored', self._RetryIgnored, enabled_check_func = self._CanRetryIgnored ) self._gallery_importers_listctrl_panel.NewButtonRow() self._gallery_importers_listctrl_panel.AddButton( 'set options to queries', self._SetOptionsToGalleryImports, enabled_only_on_selection = True ) self._gallery_importers_listctrl.Sort() # self._query_input = ClientGUIControls.TextAndPasteCtrl( self._gallery_downloader_panel, self._PendQueries ) self._cog_button = ClientGUICommon.BetterBitmapButton( self._gallery_downloader_panel, CC.global_pixmaps().cog, self._ShowCogMenu ) self._gug_key_and_name = ClientGUIImport.GUGKeyAndNameSelector( self._gallery_downloader_panel, self._multiple_gallery_import.GetGUGKeyAndName(), update_callable = self._SetGUGKeyAndName ) self._file_limit = ClientGUICommon.NoneableSpinCtrl( self._gallery_downloader_panel, 'stop after this many files', min = 1, none_phrase = 'no limit' ) self._file_limit.valueChanged.connect( self.EventFileLimit ) self._file_limit.setToolTip( 'per query, stop searching the gallery once this many files has been reached' ) file_import_options = self._multiple_gallery_import.GetFileImportOptions() tag_import_options = self._multiple_gallery_import.GetTagImportOptions() note_import_options = self._multiple_gallery_import.GetNoteImportOptions() file_limit = self._multiple_gallery_import.GetFileLimit() show_downloader_options = True allow_default_selection = True self._import_options_button = ClientGUIImportOptions.ImportOptionsButton( self, show_downloader_options, allow_default_selection ) self._import_options_button.SetFileImportOptions( file_import_options ) self._import_options_button.SetTagImportOptions( tag_import_options ) self._import_options_button.SetNoteImportOptions( note_import_options ) # input_hbox = QP.HBoxLayout() QP.AddToLayout( input_hbox, self._query_input, CC.FLAGS_EXPAND_BOTH_WAYS ) QP.AddToLayout( input_hbox, self._cog_button, CC.FLAGS_CENTER_PERPENDICULAR ) self._gallery_downloader_panel.Add( self._gallery_importers_status_st_top, CC.FLAGS_EXPAND_PERPENDICULAR ) self._gallery_downloader_panel.Add( self._gallery_importers_status_st_bottom, CC.FLAGS_EXPAND_PERPENDICULAR ) self._gallery_downloader_panel.Add( self._gallery_importers_listctrl_panel, CC.FLAGS_EXPAND_BOTH_WAYS ) self._gallery_downloader_panel.Add( input_hbox, CC.FLAGS_EXPAND_SIZER_PERPENDICULAR ) self._gallery_downloader_panel.Add( self._gug_key_and_name, CC.FLAGS_EXPAND_PERPENDICULAR ) self._gallery_downloader_panel.Add( self._file_limit, CC.FLAGS_EXPAND_PERPENDICULAR ) self._gallery_downloader_panel.Add( self._import_options_button, CC.FLAGS_EXPAND_PERPENDICULAR ) # self._highlighted_gallery_import_panel = ClientGUIImport.GalleryImportPanel( self, self._page_key, name = 'highlighted query' ) self._highlighted_gallery_import_panel.SetGalleryImport( self._highlighted_gallery_import ) # vbox = QP.VBoxLayout() QP.AddToLayout( vbox, self._media_sort, CC.FLAGS_EXPAND_PERPENDICULAR ) QP.AddToLayout( vbox, self._media_collect, CC.FLAGS_EXPAND_PERPENDICULAR ) QP.AddToLayout( vbox, self._gallery_downloader_panel, CC.FLAGS_EXPAND_BOTH_WAYS ) QP.AddToLayout( vbox, self._highlighted_gallery_import_panel, CC.FLAGS_EXPAND_PERPENDICULAR ) self._MakeCurrentSelectionTagsBox( vbox ) self.widget().setLayout( vbox ) # initial_search_text = self._multiple_gallery_import.GetInitialSearchText() self._query_input.setPlaceholderText( initial_search_text ) self._file_limit.SetValue( file_limit ) self._UpdateImportStatus() self._gallery_importers_listctrl.AddMenuCallable( self._GetListCtrlMenu ) self._import_options_button.fileImportOptionsChanged.connect( self._multiple_gallery_import.SetFileImportOptions ) self._import_options_button.noteImportOptionsChanged.connect( self._multiple_gallery_import.SetNoteImportOptions ) self._import_options_button.tagImportOptionsChanged.connect( self._multiple_gallery_import.SetTagImportOptions ) def _CanClearHighlight( self ): return self._highlighted_gallery_import is not None def _CanHighlight( self ): selected = self._gallery_importers_listctrl.GetData( only_selected = True ) if len( selected ) != 1: return False gallery_import = selected[0] return gallery_import != self._highlighted_gallery_import def _CanRetryFailed( self ): for gallery_import in self._gallery_importers_listctrl.GetData( only_selected = True ): if gallery_import.CanRetryFailed(): return True return False def _CanRetryIgnored( self ): for gallery_import in self._gallery_importers_listctrl.GetData( only_selected = True ): if gallery_import.CanRetryIgnored(): return True return False def _ClearExistingHighlight( self ): if self._highlighted_gallery_import is not None: self._highlighted_gallery_import.PublishToPage( False ) self._highlighted_gallery_import = None self._multiple_gallery_import.ClearHighlightedGalleryImport() self._gallery_importers_listctrl_panel.UpdateButtons() self._highlighted_gallery_import_panel.SetGalleryImport( None ) def _ClearExistingHighlightAndPanel( self ): if self._highlighted_gallery_import is None: return self._ClearExistingHighlight() media_results = [] location_context = ClientLocation.LocationContext.STATICCreateSimple( CC.COMBINED_LOCAL_MEDIA_SERVICE_KEY ) self._SetLocationContext( location_context ) panel = ClientGUIResults.MediaPanelThumbnails( self._page, self._page_key, location_context, media_results ) panel.SetEmptyPageStatusOverride( 'no highlighted query' ) self._page.SwapMediaPanel( panel ) self._gallery_importers_listctrl.UpdateDatas() def _ConvertDataToListCtrlTuples( self, gallery_import ): query_text = gallery_import.GetQueryText() pretty_query_text = query_text if gallery_import == self._highlighted_gallery_import: pretty_query_text = '* ' + pretty_query_text source = gallery_import.GetSourceName() pretty_source = source files_finished = gallery_import.FilesFinished() files_paused = gallery_import.FilesPaused() if files_finished: pretty_files_paused = HG.client_controller.new_options.GetString( 'stop_character' ) sort_files_paused = -1 elif files_paused: pretty_files_paused = HG.client_controller.new_options.GetString( 'pause_character' ) sort_files_paused = 0 else: pretty_files_paused = '' sort_files_paused = 1 gallery_finished = gallery_import.GalleryFinished() gallery_paused = gallery_import.GalleryPaused() if gallery_finished: pretty_gallery_paused = HG.client_controller.new_options.GetString( 'stop_character' ) sort_gallery_paused = -1 elif gallery_paused: pretty_gallery_paused = HG.client_controller.new_options.GetString( 'pause_character' ) sort_gallery_paused = 0 else: pretty_gallery_paused = '' sort_gallery_paused = 1 ( status_enum, pretty_status ) = gallery_import.GetSimpleStatus() sort_status = ClientImporting.downloader_enum_sort_lookup[ status_enum ] file_seed_cache_status = gallery_import.GetFileSeedCache().GetStatus() ( num_done, num_total ) = file_seed_cache_status.GetValueRange() progress = ( num_total, num_done ) pretty_progress = file_seed_cache_status.GetStatusText( simple = True ) added = gallery_import.GetCreationTime() pretty_added = ClientData.TimestampToPrettyTimeDelta( added, show_seconds = False ) display_tuple = ( pretty_query_text, pretty_source, pretty_files_paused, pretty_gallery_paused, pretty_status, pretty_progress, pretty_added ) sort_tuple = ( query_text, pretty_source, sort_files_paused, sort_gallery_paused, sort_status, progress, added ) return ( display_tuple, sort_tuple ) def _CopySelectedQueries( self ): gallery_importers = self._gallery_importers_listctrl.GetData( only_selected = True ) if len( gallery_importers ) > 0: text = os.linesep.join( ( gallery_importer.GetQueryText() for gallery_importer in gallery_importers ) ) HG.client_controller.pub( 'clipboard', 'text', text ) def _GetDefaultEmptyPageStatusOverride( self ) -> str: return 'no highlighted query' def _GetListCtrlMenu( self ): selected_importers = self._gallery_importers_listctrl.GetData( only_selected = True ) if len( selected_importers ) == 0: raise HydrusExceptions.DataMissing() menu = QW.QMenu() ClientGUIMenus.AppendMenuItem( menu, 'copy queries', 'Copy all the selected downloaders\' queries to clipboard.', self._CopySelectedQueries ) ClientGUIMenus.AppendSeparator( menu ) single_selected_presentation_import_options = None if len( selected_importers ) == 1: ( importer, ) = selected_importers fio = importer.GetFileImportOptions() single_selected_presentation_import_options = FileImportOptions.GetRealPresentationImportOptions( fio, FileImportOptions.IMPORT_TYPE_LOUD ) AddPresentationSubmenu( menu, 'downloader', single_selected_presentation_import_options, self._ShowSelectedImportersFiles ) ClientGUIMenus.AppendSeparator( menu ) if len( selected_importers ) == 1: ( importer, ) = selected_importers file_seed_cache = importer.GetFileSeedCache() submenu = QW.QMenu( menu ) ClientGUIMenus.AppendMenuItem( submenu, 'show file log', 'Show the file log windows for the selected query.', self._ShowSelectedImportersFileSeedCaches ) ClientGUIMenus.AppendSeparator( submenu ) ClientGUIFileSeedCache.PopulateFileSeedCacheMenu( self, submenu, file_seed_cache ) ClientGUIMenus.AppendMenu( menu, submenu, 'file log' ) gallery_seed_log = importer.GetGallerySeedLog() submenu = QW.QMenu( menu ) ClientGUIMenus.AppendMenuItem( submenu, 'show search log', 'Show the search log windows for the selected query.', self._ShowSelectedImportersGallerySeedLogs ) ClientGUIMenus.AppendSeparator( submenu ) ClientGUIGallerySeedLog.PopulateGallerySeedLogButton( self, submenu, gallery_seed_log, False, True, 'search' ) ClientGUIMenus.AppendMenu( menu, submenu, 'search log' ) else: ClientGUIMenus.AppendMenuItem( menu, 'show file logs', 'Show the file log windows for the selected queries.', self._ShowSelectedImportersFileSeedCaches ) ClientGUIMenus.AppendMenuItem( menu, 'show search log', 'Show the search log windows for the selected query.', self._ShowSelectedImportersGallerySeedLogs ) ClientGUIMenus.AppendSeparator( menu ) ClientGUIMenus.AppendMenuItem( menu, 'remove', 'Remove the selected queries.', self._RemoveGalleryImports ) ClientGUIMenus.AppendSeparator( menu ) ClientGUIMenus.AppendMenuItem( menu, 'pause/play files', 'Pause/play all the selected downloaders\' file queues.', self._PausePlayFiles ) ClientGUIMenus.AppendMenuItem( menu, 'pause/play search', 'Pause/play all the selected downloaders\' gallery searches.', self._PausePlayGallery ) return menu def _HighlightGalleryImport( self, new_highlight ): if new_highlight == self._highlighted_gallery_import: self._ClearExistingHighlightAndPanel() else: self._ClearExistingHighlight() self._highlighted_gallery_import = new_highlight self._multiple_gallery_import.SetHighlightedGalleryImport( self._highlighted_gallery_import ) self._highlighted_gallery_import.PublishToPage( True ) hashes = self._highlighted_gallery_import.GetPresentedHashes() if len( hashes ) > 0: media_results = HG.client_controller.Read( 'media_results', hashes, sorted = True ) else: media_results = [] location_context = self._highlighted_gallery_import.GetFileImportOptions().GetDestinationLocationContext() self._SetLocationContext( location_context ) panel = ClientGUIResults.MediaPanelThumbnails( self._page, self._page_key, location_context, media_results ) panel.SetEmptyPageStatusOverride( 'no files for this query and its publishing settings' ) self._page.SwapMediaPanel( panel ) self._gallery_importers_listctrl_panel.UpdateButtons() self._gallery_importers_listctrl.UpdateDatas() self._highlighted_gallery_import_panel.SetGalleryImport( self._highlighted_gallery_import ) def _HighlightSelectedGalleryImport( self ): selected = self._gallery_importers_listctrl.GetData( only_selected = True ) if len( selected ) == 1: new_highlight = selected[0] self._HighlightGalleryImport( new_highlight ) def _PausePlayFiles( self ): for gallery_import in self._gallery_importers_listctrl.GetData( only_selected = True ): gallery_import.PausePlayFiles() self._gallery_importers_listctrl.UpdateDatas() def _PausePlayGallery( self ): for gallery_import in self._gallery_importers_listctrl.GetData( only_selected = True ): gallery_import.PausePlayGallery() self._gallery_importers_listctrl.UpdateDatas() def _PendQueries( self, queries ): results = self._multiple_gallery_import.PendQueries( queries ) if len( results ) > 0 and self._highlighted_gallery_import is None and HG.client_controller.new_options.GetBoolean( 'highlight_new_query' ): first_result = results[ 0 ] self._HighlightGalleryImport( first_result ) self._UpdateImportStatusNow() def _RemoveGalleryImports( self ): removees = list( self._gallery_importers_listctrl.GetData( only_selected = True ) ) if len( removees ) == 0: return num_working = 0 for gallery_import in removees: if gallery_import.CurrentlyWorking(): num_working += 1 message = 'Remove the ' + HydrusData.ToHumanInt( len( removees ) ) + ' selected queries?' if num_working > 0: message += os.linesep * 2 message += HydrusData.ToHumanInt( num_working ) + ' are still working.' if self._highlighted_gallery_import is not None and self._highlighted_gallery_import in removees: message += os.linesep * 2 message += 'The currently highlighted query will be removed, and the media panel cleared.' result = ClientGUIDialogsQuick.GetYesNo( self, message ) if result == QW.QDialog.Accepted: highlight_was_included = False for gallery_import in removees: if self._highlighted_gallery_import is not None and gallery_import == self._highlighted_gallery_import: highlight_was_included = True self._multiple_gallery_import.RemoveGalleryImport( gallery_import.GetGalleryImportKey() ) if highlight_was_included: self._ClearExistingHighlightAndPanel() self._UpdateImportStatusNow() def _RetryFailed( self ): for gallery_import in self._gallery_importers_listctrl.GetData( only_selected = True ): gallery_import.RetryFailed() def _RetryIgnored( self ): try: ignored_regex = ClientGUIFileSeedCache.GetRetryIgnoredParam( self ) except HydrusExceptions.CancelledException: return for gallery_import in self._gallery_importers_listctrl.GetData( only_selected = True ): gallery_import.RetryIgnored( ignored_regex = ignored_regex ) def _SetGUGKeyAndName( self, gug_key_and_name ): current_initial_search_text = self._multiple_gallery_import.GetInitialSearchText() current_input_value = self._query_input.GetValue() should_initialise_new_text = current_input_value in ( current_initial_search_text, '' ) self._multiple_gallery_import.SetGUGKeyAndName( gug_key_and_name ) if should_initialise_new_text: new_initial_search_text = self._multiple_gallery_import.GetInitialSearchText() self._query_input.setPlaceholderText( new_initial_search_text ) self._query_input.setFocus( QC.Qt.OtherFocusReason ) def _SetOptionsToGalleryImports( self ): gallery_imports = self._gallery_importers_listctrl.GetData( only_selected = True ) if len( gallery_imports ) == 0: return message = 'Set the current file limit, file import, and tag import options to all the selected queries? (by default, these options are only applied to new queries)' result = ClientGUIDialogsQuick.GetYesNo( self, message ) if result == QW.QDialog.Accepted: file_limit = self._file_limit.GetValue() file_import_options = self._import_options_button.GetFileImportOptions() tag_import_options = self._import_options_button.GetTagImportOptions() note_import_options = self._import_options_button.GetNoteImportOptions() for gallery_import in gallery_imports: gallery_import.SetFileLimit( file_limit ) gallery_import.SetFileImportOptions( file_import_options ) gallery_import.SetTagImportOptions( tag_import_options ) gallery_import.SetNoteImportOptions( note_import_options ) def _ShowCogMenu( self ): menu = QW.QMenu() ( start_file_queues_paused, start_gallery_queues_paused, merge_simultaneous_pends_to_one_importer ) = self._multiple_gallery_import.GetQueueStartSettings() ClientGUIMenus.AppendMenuCheckItem( menu, 'start new importers\' files paused', 'Start any new importers in a file import-paused state.', start_file_queues_paused, self._multiple_gallery_import.SetQueueStartSettings, not start_file_queues_paused, start_gallery_queues_paused, merge_simultaneous_pends_to_one_importer ) ClientGUIMenus.AppendMenuCheckItem( menu, 'start new importers\' search paused', 'Start any new importers in a gallery search-paused state.', start_gallery_queues_paused, self._multiple_gallery_import.SetQueueStartSettings, start_file_queues_paused, not start_gallery_queues_paused, merge_simultaneous_pends_to_one_importer ) ClientGUIMenus.AppendSeparator( menu ) ClientGUIMenus.AppendMenuCheckItem( menu, 'bundle multiple pasted queries into one importer (advanced)', 'If you are pasting many small queries at once (such as md5 lookups), check this to smooth out the workflow.', merge_simultaneous_pends_to_one_importer, self._multiple_gallery_import.SetQueueStartSettings, start_file_queues_paused, start_gallery_queues_paused, not merge_simultaneous_pends_to_one_importer ) CGC.core().PopupMenu( self._cog_button, menu ) def _ShowSelectedImportersFileSeedCaches( self ): gallery_imports = self._gallery_importers_listctrl.GetData( only_selected = True ) if len( gallery_imports ) == 0: return gallery_import = gallery_imports[0] file_seed_cache = gallery_import.GetFileSeedCache() title = 'file log' frame_key = 'file_import_status' frame = ClientGUITopLevelWindowsPanels.FrameThatTakesScrollablePanel( self, title, frame_key ) panel = ClientGUIFileSeedCache.EditFileSeedCachePanel( frame, HG.client_controller, file_seed_cache ) frame.SetPanel( panel ) def _ShowSelectedImportersFiles( self, presentation_import_options = None ): gallery_imports = self._gallery_importers_listctrl.GetData( only_selected = True ) if len( gallery_imports ) == 0: return hashes = list() seen_hashes = set() for gallery_import in gallery_imports: gallery_hashes = gallery_import.GetPresentedHashes( presentation_import_options = presentation_import_options ) new_hashes = [ hash for hash in gallery_hashes if hash not in seen_hashes ] hashes.extend( new_hashes ) seen_hashes.update( new_hashes ) if len( hashes ) > 0: self._ClearExistingHighlightAndPanel() media_results = self._controller.Read( 'media_results', hashes, sorted = True ) location_context = ClientLocation.LocationContext.STATICCreateSimple( CC.COMBINED_LOCAL_MEDIA_SERVICE_KEY ) self._SetLocationContext( location_context ) panel = ClientGUIResults.MediaPanelThumbnails( self._page, self._page_key, location_context, media_results ) self._page.SwapMediaPanel( panel ) else: QW.QMessageBox.warning( self, 'Warning', 'No presented files for that selection!' ) def _ShowSelectedImportersGallerySeedLogs( self ): gallery_imports = self._gallery_importers_listctrl.GetData( only_selected = True ) if len( gallery_imports ) == 0: return gallery_import = gallery_imports[0] gallery_seed_log = gallery_import.GetGallerySeedLog() title = 'search log' frame_key = 'gallery_import_log' read_only = False can_generate_more_pages = True frame = ClientGUITopLevelWindowsPanels.FrameThatTakesScrollablePanel( self, title, frame_key ) panel = ClientGUIGallerySeedLog.EditGallerySeedLogPanel( frame, HG.client_controller, read_only, can_generate_more_pages, 'search', gallery_seed_log ) frame.SetPanel( panel ) def _UpdateImportStatus( self ): if HydrusData.TimeHasPassed( self._next_update_time ): num_items = len( self._gallery_importers_listctrl.GetData() ) update_period = max( 1, int( ( num_items / 10 ) ** 0.33 ) ) self._next_update_time = HydrusData.GetNow() + update_period # last_time_imports_changed = self._multiple_gallery_import.GetLastTimeImportsChanged() num_gallery_imports = self._multiple_gallery_import.GetNumGalleryImports() # if num_gallery_imports == 0: text_top = 'waiting for new queries' text_bottom = '' else: file_seed_cache_status = self._multiple_gallery_import.GetTotalStatus() ( num_done, num_total ) = file_seed_cache_status.GetValueRange() text_top = '{} queries - {}'.format( HydrusData.ToHumanInt( num_gallery_imports ), HydrusData.ConvertValueRangeToPrettyString( num_done, num_total ) ) text_bottom = file_seed_cache_status.GetStatusText() self._gallery_importers_status_st_top.setText( text_top ) self._gallery_importers_status_st_bottom.setText( text_bottom ) # if self._last_time_imports_changed != last_time_imports_changed: self._last_time_imports_changed = last_time_imports_changed gallery_imports = self._multiple_gallery_import.GetGalleryImports() self._gallery_importers_listctrl.SetData( gallery_imports ) ideal_rows = len( gallery_imports ) ideal_rows = max( 4, ideal_rows ) ideal_rows = min( ideal_rows, 24 ) self._gallery_importers_listctrl.ForceHeight( ideal_rows ) else: sort_data_has_changed = self._gallery_importers_listctrl.UpdateDatas() if sort_data_has_changed: self._gallery_importers_listctrl.Sort() def _UpdateImportStatusNow( self ): self._next_update_time = 0 self._UpdateImportStatus() def CheckAbleToClose( self ): num_working = 0 for gallery_import in self._multiple_gallery_import.GetGalleryImports(): if gallery_import.CurrentlyWorking(): num_working += 1 if num_working > 0: raise HydrusExceptions.VetoException( HydrusData.ToHumanInt( num_working ) + ' queries are still importing.' ) def EventFileLimit( self ): self._multiple_gallery_import.SetFileLimit( self._file_limit.GetValue() ) def PendSubscriptionGapDownloader( self, gug_key_and_name, query_text, file_import_options, tag_import_options, note_import_options, file_limit ): new_query = self._multiple_gallery_import.PendSubscriptionGapDownloader( gug_key_and_name, query_text, file_import_options, tag_import_options, note_import_options, file_limit ) if new_query is not None and self._highlighted_gallery_import is None and HG.client_controller.new_options.GetBoolean( 'highlight_new_query' ): self._HighlightGalleryImport( new_query ) def SetSearchFocus( self ): ClientGUIFunctions.SetFocusLater( self._query_input ) def Start( self ): self._multiple_gallery_import.Start( self._page_key ) management_panel_types_to_classes[ MANAGEMENT_TYPE_IMPORT_MULTIPLE_GALLERY ] = ManagementPanelImporterMultipleGallery class ManagementPanelImporterMultipleWatcher( ManagementPanelImporter ): def __init__( self, parent, page, controller, management_controller ): ManagementPanelImporter.__init__( self, parent, page, controller, management_controller ) self._last_time_watchers_changed = 0 self._next_update_time = 0 self._multiple_watcher_import = self._management_controller.GetVariable( 'multiple_watcher_import' ) self._highlighted_watcher = self._multiple_watcher_import.GetHighlightedWatcher() checker_options = self._multiple_watcher_import.GetCheckerOptions() file_import_options = self._multiple_watcher_import.GetFileImportOptions() tag_import_options = self._multiple_watcher_import.GetTagImportOptions() note_import_options = self._multiple_watcher_import.GetNoteImportOptions() # self._watchers_panel = ClientGUICommon.StaticBox( self, 'watchers' ) self._watchers_status_st_top = ClientGUICommon.BetterStaticText( self._watchers_panel, ellipsize_end = True ) self._watchers_status_st_bottom = ClientGUICommon.BetterStaticText( self._watchers_panel, ellipsize_end = True ) self._watchers_listctrl_panel = ClientGUIListCtrl.BetterListCtrlPanel( self._watchers_panel ) self._watchers_listctrl = ClientGUIListCtrl.BetterListCtrl( self._watchers_listctrl_panel, CGLC.COLUMN_LIST_WATCHERS.ID, 4, self._ConvertDataToListCtrlTuples, delete_key_callback = self._RemoveWatchers, activation_callback = self._HighlightSelectedWatcher ) self._watchers_listctrl_panel.SetListCtrl( self._watchers_listctrl ) self._watchers_listctrl_panel.AddBitmapButton( CC.global_pixmaps().highlight, self._HighlightSelectedWatcher, tooltip = 'highlight', enabled_check_func = self._CanHighlight ) self._watchers_listctrl_panel.AddBitmapButton( CC.global_pixmaps().clear_highlight, self._ClearExistingHighlightAndPanel, tooltip = 'clear highlight', enabled_check_func = self._CanClearHighlight ) self._watchers_listctrl_panel.AddBitmapButton( CC.global_pixmaps().file_pause, self._PausePlayFiles, tooltip = 'pause/play files', enabled_only_on_selection = True ) self._watchers_listctrl_panel.AddBitmapButton( CC.global_pixmaps().gallery_pause, self._PausePlayChecking, tooltip = 'pause/play checking', enabled_only_on_selection = True ) self._watchers_listctrl_panel.AddBitmapButton( CC.global_pixmaps().trash, self._RemoveWatchers, tooltip = 'remove selected', enabled_only_on_selection = True ) self._watchers_listctrl_panel.AddButton( 'check now', self._CheckNow, enabled_only_on_selection = True ) self._watchers_listctrl_panel.NewButtonRow() self._watchers_listctrl_panel.AddButton( 'retry failed', self._RetryFailed, enabled_check_func = self._CanRetryFailed ) self._watchers_listctrl_panel.AddButton( 'retry ignored', self._RetryIgnored, enabled_check_func = self._CanRetryIgnored ) self._watchers_listctrl_panel.NewButtonRow() self._watchers_listctrl_panel.AddButton( 'set options to watchers', self._SetOptionsToWatchers, enabled_only_on_selection = True ) self._watchers_listctrl.Sort() self._watcher_url_input = ClientGUIControls.TextAndPasteCtrl( self._watchers_panel, self._AddURLs ) self._watcher_url_input.setPlaceholderText( 'watcher url' ) self._checker_options = ClientGUIImport.CheckerOptionsButton( self._watchers_panel, checker_options ) show_downloader_options = True allow_default_selection = True self._import_options_button = ClientGUIImportOptions.ImportOptionsButton( self, show_downloader_options, allow_default_selection ) self._import_options_button.SetFileImportOptions( file_import_options ) self._import_options_button.SetTagImportOptions( tag_import_options ) self._import_options_button.SetNoteImportOptions( note_import_options ) # suck up watchers from elsewhere in the program (presents a checkboxlistdialog) # self._highlighted_watcher_panel = ClientGUIImport.WatcherReviewPanel( self, self._page_key, name = 'highlighted watcher' ) self._highlighted_watcher_panel.SetWatcher( self._highlighted_watcher ) # self._watchers_panel.Add( self._watchers_status_st_top, CC.FLAGS_EXPAND_PERPENDICULAR ) self._watchers_panel.Add( self._watchers_status_st_bottom, CC.FLAGS_EXPAND_PERPENDICULAR ) self._watchers_panel.Add( self._watchers_listctrl_panel, CC.FLAGS_EXPAND_BOTH_WAYS ) self._watchers_panel.Add( self._watcher_url_input, CC.FLAGS_EXPAND_PERPENDICULAR ) self._watchers_panel.Add( self._checker_options, CC.FLAGS_EXPAND_PERPENDICULAR ) self._watchers_panel.Add( self._import_options_button, CC.FLAGS_EXPAND_PERPENDICULAR ) # vbox = QP.VBoxLayout() QP.AddToLayout( vbox, self._media_sort, CC.FLAGS_EXPAND_PERPENDICULAR ) QP.AddToLayout( vbox, self._media_collect, CC.FLAGS_EXPAND_PERPENDICULAR ) QP.AddToLayout( vbox, self._watchers_panel, CC.FLAGS_EXPAND_BOTH_WAYS ) QP.AddToLayout( vbox, self._highlighted_watcher_panel, CC.FLAGS_EXPAND_PERPENDICULAR ) self._MakeCurrentSelectionTagsBox( vbox ) self.widget().setLayout( vbox ) # self._watchers_listctrl.AddMenuCallable( self._GetListCtrlMenu ) self._UpdateImportStatus() HG.client_controller.sub( self, '_ClearExistingHighlightAndPanel', 'clear_multiwatcher_highlights' ) self._import_options_button.fileImportOptionsChanged.connect( self._OptionsUpdated ) self._import_options_button.noteImportOptionsChanged.connect( self._OptionsUpdated ) self._import_options_button.tagImportOptionsChanged.connect( self._OptionsUpdated ) self._checker_options.valueChanged.connect( self._OptionsUpdated ) def _AddURLs( self, urls, filterable_tags = None, additional_service_keys_to_tags = None ): if filterable_tags is None: filterable_tags = set() if additional_service_keys_to_tags is None: additional_service_keys_to_tags = ClientTags.ServiceKeysToTags() first_result = None for url in urls: result = self._multiple_watcher_import.AddURL( url, filterable_tags = filterable_tags, additional_service_keys_to_tags = additional_service_keys_to_tags ) if result is not None and first_result is None: first_result = result if first_result is not None and self._highlighted_watcher is None and HG.client_controller.new_options.GetBoolean( 'highlight_new_watcher' ): self._HighlightWatcher( first_result ) self._UpdateImportStatusNow() def _CanClearHighlight( self ): return self._highlighted_watcher is not None def _CanHighlight( self ): selected = self._watchers_listctrl.GetData( only_selected = True ) if len( selected ) != 1: return False watcher = selected[0] return watcher != self._highlighted_watcher def _CanRetryFailed( self ): for watcher in self._watchers_listctrl.GetData( only_selected = True ): if watcher.CanRetryFailed(): return True return False def _CanRetryIgnored( self ): for watcher in self._watchers_listctrl.GetData( only_selected = True ): if watcher.CanRetryIgnored(): return True return False def _CheckNow( self ): for watcher in self._watchers_listctrl.GetData( only_selected = True ): watcher.CheckNow() def _ClearExistingHighlight( self ): if self._highlighted_watcher is not None: self._highlighted_watcher.PublishToPage( False ) self._highlighted_watcher = None self._multiple_watcher_import.ClearHighlightedWatcher() self._watchers_listctrl_panel.UpdateButtons() self._highlighted_watcher_panel.SetWatcher( None ) def _ClearExistingHighlightAndPanel( self ): if self._highlighted_watcher is None: return self._ClearExistingHighlight() location_context = ClientLocation.LocationContext.STATICCreateSimple( CC.COMBINED_LOCAL_MEDIA_SERVICE_KEY ) media_results = [] self._SetLocationContext( location_context ) panel = ClientGUIResults.MediaPanelThumbnails( self._page, self._page_key, location_context, media_results ) panel.SetEmptyPageStatusOverride( 'no highlighted watcher' ) self._page.SwapMediaPanel( panel ) self._watchers_listctrl.UpdateDatas() def _ConvertDataToListCtrlTuples( self, watcher: ClientImportWatchers.WatcherImport ): subject = watcher.GetSubject() pretty_subject = subject if watcher == self._highlighted_watcher: pretty_subject = '* ' + pretty_subject files_paused = watcher.FilesPaused() if files_paused: pretty_files_paused = HG.client_controller.new_options.GetString( 'pause_character' ) else: pretty_files_paused = '' checking_dead = watcher.IsDead() checking_paused = watcher.CheckingPaused() if checking_dead: pretty_checking_paused = HG.client_controller.new_options.GetString( 'stop_character' ) sort_checking_paused = -1 elif checking_paused: pretty_checking_paused = HG.client_controller.new_options.GetString( 'pause_character' ) sort_checking_paused = 0 else: pretty_checking_paused = '' sort_checking_paused = 1 file_seed_cache_status = watcher.GetFileSeedCache().GetStatus() ( num_done, num_total ) = file_seed_cache_status.GetValueRange() progress = ( num_total, num_done ) pretty_progress = file_seed_cache_status.GetStatusText( simple = True ) added = watcher.GetCreationTime() pretty_added = ClientData.TimestampToPrettyTimeDelta( added, show_seconds = False ) ( status_enum, pretty_watcher_status ) = self._multiple_watcher_import.GetWatcherSimpleStatus( watcher ) checking_status = watcher.GetCheckingStatus() if checking_status == ClientImporting.CHECKER_STATUS_OK: next_check_time = watcher.GetNextCheckTime() if next_check_time is None: next_check_time = 0 sort_watcher_status = ( ClientImporting.downloader_enum_sort_lookup[ status_enum ], next_check_time ) else: # this lets 404 and DEAD sort different sort_watcher_status = ( ClientImporting.downloader_enum_sort_lookup[ status_enum ], checking_status ) display_tuple = ( pretty_subject, pretty_files_paused, pretty_checking_paused, pretty_watcher_status, pretty_progress, pretty_added ) sort_tuple = ( subject, files_paused, sort_checking_paused, sort_watcher_status, progress, added ) return ( display_tuple, sort_tuple ) def _CopySelectedSubjects( self ): watchers = self._watchers_listctrl.GetData( only_selected = True ) if len( watchers ) > 0: text = os.linesep.join( ( watcher.GetSubject() for watcher in watchers ) ) HG.client_controller.pub( 'clipboard', 'text', text ) def _CopySelectedURLs( self ): watchers = self._watchers_listctrl.GetData( only_selected = True ) if len( watchers ) > 0: text = os.linesep.join( ( watcher.GetURL() for watcher in watchers ) ) HG.client_controller.pub( 'clipboard', 'text', text ) def _GetDefaultEmptyPageStatusOverride( self ) -> str: return 'no highlighted watcher' def _GetListCtrlMenu( self ): selected_watchers = self._watchers_listctrl.GetData( only_selected = True ) if len( selected_watchers ) == 0: raise HydrusExceptions.DataMissing() menu = QW.QMenu() ClientGUIMenus.AppendMenuItem( menu, 'copy urls', 'Copy all the selected watchers\' urls to clipboard.', self._CopySelectedURLs ) ClientGUIMenus.AppendMenuItem( menu, 'open urls', 'Open all the selected watchers\' urls in your browser.', self._OpenSelectedURLs ) ClientGUIMenus.AppendSeparator( menu ) ClientGUIMenus.AppendMenuItem( menu, 'copy subjects', 'Copy all the selected watchers\' subjects to clipboard.', self._CopySelectedSubjects ) ClientGUIMenus.AppendSeparator( menu ) single_selected_presentation_import_options = None if len( selected_watchers ) == 1: ( watcher, ) = selected_watchers fio = watcher.GetFileImportOptions() single_selected_presentation_import_options = FileImportOptions.GetRealPresentationImportOptions( fio, FileImportOptions.IMPORT_TYPE_LOUD ) AddPresentationSubmenu( menu, 'watcher', single_selected_presentation_import_options, self._ShowSelectedImportersFiles ) ClientGUIMenus.AppendSeparator( menu ) if len( selected_watchers ) == 1: ( watcher, ) = selected_watchers file_seed_cache = watcher.GetFileSeedCache() submenu = QW.QMenu( menu ) ClientGUIMenus.AppendMenuItem( submenu, 'show file log', 'Show the file log windows for the selected watcher.', self._ShowSelectedImportersFileSeedCaches ) ClientGUIMenus.AppendSeparator( submenu ) ClientGUIFileSeedCache.PopulateFileSeedCacheMenu( self, submenu, file_seed_cache ) ClientGUIMenus.AppendMenu( menu, submenu, 'file log' ) gallery_seed_log = watcher.GetGallerySeedLog() submenu = QW.QMenu( menu ) ClientGUIMenus.AppendMenuItem( submenu, 'show check log', 'Show the check log windows for the selected watcher.', self._ShowSelectedImportersGallerySeedLogs ) ClientGUIMenus.AppendSeparator( submenu ) ClientGUIGallerySeedLog.PopulateGallerySeedLogButton( self, submenu, gallery_seed_log, True, False, 'check' ) ClientGUIMenus.AppendMenu( menu, submenu, 'check log' ) else: ClientGUIMenus.AppendMenuItem( menu, 'show file logs', 'Show the file log windows for the selected queries.', self._ShowSelectedImportersFileSeedCaches ) ClientGUIMenus.AppendMenuItem( menu, 'show check log', 'Show the checker log windows for the selected watcher.', self._ShowSelectedImportersGallerySeedLogs ) if self._CanRetryFailed() or self._CanRetryIgnored(): ClientGUIMenus.AppendSeparator( menu ) if self._CanRetryFailed(): ClientGUIMenus.AppendMenuItem( menu, 'retry failed', 'Retry all the failed downloads.', self._RetryFailed ) if self._CanRetryIgnored(): ClientGUIMenus.AppendMenuItem( menu, 'retry ignored', 'Retry all the ignored downloads.', self._RetryIgnored ) ClientGUIMenus.AppendSeparator( menu ) ClientGUIMenus.AppendMenuItem( menu, 'remove selected', 'Remove the selected watchers.', self._RemoveWatchers ) ClientGUIMenus.AppendSeparator( menu ) ClientGUIMenus.AppendMenuItem( menu, 'pause/play files', 'Pause/play all the selected watchers\' file queues.', self._PausePlayFiles ) ClientGUIMenus.AppendMenuItem( menu, 'pause/play checking', 'Pause/play all the selected watchers\' checking routines.', self._PausePlayChecking ) return menu def _HighlightWatcher( self, new_highlight ): if new_highlight == self._highlighted_watcher: self._ClearExistingHighlightAndPanel() else: self._ClearExistingHighlight() self._highlighted_watcher = new_highlight hashes = self._highlighted_watcher.GetPresentedHashes() if len( hashes ) > 0: media_results = HG.client_controller.Read( 'media_results', hashes, sorted = True ) else: media_results = [] location_context = self._highlighted_watcher.GetFileImportOptions().GetDestinationLocationContext() self._SetLocationContext( location_context ) panel = ClientGUIResults.MediaPanelThumbnails( self._page, self._page_key, location_context, media_results ) panel.SetEmptyPageStatusOverride( 'no files for this watcher and its publishing settings' ) self._page.SwapMediaPanel( panel ) self._multiple_watcher_import.SetHighlightedWatcher( self._highlighted_watcher ) self._highlighted_watcher.PublishToPage( True ) self._watchers_listctrl_panel.UpdateButtons() self._watchers_listctrl.UpdateDatas() self._highlighted_watcher_panel.SetWatcher( self._highlighted_watcher ) def _HighlightSelectedWatcher( self ): selected = self._watchers_listctrl.GetData( only_selected = True ) if len( selected ) == 1: new_highlight = selected[0] self._HighlightWatcher( new_highlight ) def _OpenSelectedURLs( self ): watchers = self._watchers_listctrl.GetData( only_selected = True ) if len( watchers ) > 0: if len( watchers ) > 10: message = 'You have many watchers selected--are you sure you want to open them all?' result = ClientGUIDialogsQuick.GetYesNo( self, message ) if result != QW.QDialog.Accepted: return for watcher in watchers: ClientPaths.LaunchURLInWebBrowser( watcher.GetURL() ) def _OptionsUpdated( self, *args, **kwargs ): self._multiple_watcher_import.SetCheckerOptions( self._checker_options.GetValue() ) self._multiple_watcher_import.SetFileImportOptions( self._import_options_button.GetFileImportOptions() ) self._multiple_watcher_import.SetNoteImportOptions( self._import_options_button.GetNoteImportOptions() ) self._multiple_watcher_import.SetTagImportOptions( self._import_options_button.GetTagImportOptions() ) def _PausePlayChecking( self ): for watcher in self._watchers_listctrl.GetData( only_selected = True ): watcher.PausePlayChecking() self._watchers_listctrl.UpdateDatas() def _PausePlayFiles( self ): for watcher in self._watchers_listctrl.GetData( only_selected = True ): watcher.PausePlayFiles() self._watchers_listctrl.UpdateDatas() def _RemoveWatchers( self ): removees = list( self._watchers_listctrl.GetData( only_selected = True ) ) if len( removees ) == 0: return num_working = 0 num_alive = 0 for watcher in removees: if watcher.CurrentlyWorking(): num_working += 1 if watcher.CurrentlyAlive(): num_alive += 1 message = 'Remove the ' + HydrusData.ToHumanInt( len( removees ) ) + ' selected watchers?' if num_working > 0: message += os.linesep * 2 message += HydrusData.ToHumanInt( num_working ) + ' are still working.' if num_alive > 0: message += os.linesep * 2 message += HydrusData.ToHumanInt( num_alive ) + ' are not yet DEAD.' if self._highlighted_watcher is not None and self._highlighted_watcher in removees: message += os.linesep * 2 message += 'The currently highlighted watcher will be removed, and the media panel cleared.' result = ClientGUIDialogsQuick.GetYesNo( self, message ) if result == QW.QDialog.Accepted: highlight_was_included = False for watcher in removees: if self._highlighted_watcher is not None and watcher == self._highlighted_watcher: highlight_was_included = True self._multiple_watcher_import.RemoveWatcher( watcher.GetWatcherKey() ) if highlight_was_included: self._ClearExistingHighlightAndPanel() self._UpdateImportStatusNow() def _RetryFailed( self ): for watcher in self._watchers_listctrl.GetData( only_selected = True ): watcher.RetryFailed() def _RetryIgnored( self ): try: ignored_regex = ClientGUIFileSeedCache.GetRetryIgnoredParam( self ) except HydrusExceptions.CancelledException: return for watcher in self._watchers_listctrl.GetData( only_selected = True ): watcher.RetryIgnored( ignored_regex = ignored_regex ) def _SetOptionsToWatchers( self ): watchers = self._watchers_listctrl.GetData( only_selected = True ) if len( watchers ) == 0: return message = 'Set the current checker, file import, and tag import options to all the selected watchers? (by default, these options are only applied to new watchers)' result = ClientGUIDialogsQuick.GetYesNo( self, message ) if result == QW.QDialog.Accepted: checker_options = self._checker_options.GetValue() file_import_options = self._import_options_button.GetFileImportOptions() tag_import_options = self._import_options_button.GetTagImportOptions() for watcher in watchers: watcher.SetCheckerOptions( checker_options ) watcher.SetFileImportOptions( file_import_options ) watcher.SetTagImportOptions( tag_import_options ) def _ShowSelectedImportersFileSeedCaches( self ): watchers = self._watchers_listctrl.GetData( only_selected = True ) if len( watchers ) == 0: return watcher = watchers[0] file_seed_cache = watcher.GetFileSeedCache() title = 'file log' frame_key = 'file_import_status' frame = ClientGUITopLevelWindowsPanels.FrameThatTakesScrollablePanel( self, title, frame_key ) panel = ClientGUIFileSeedCache.EditFileSeedCachePanel( frame, HG.client_controller, file_seed_cache ) frame.SetPanel( panel ) def _ShowSelectedImportersFiles( self, presentation_import_options = None ): watchers = self._watchers_listctrl.GetData( only_selected = True ) if len( watchers ) == 0: return hashes = list() seen_hashes = set() for watcher in watchers: watcher_hashes = watcher.GetPresentedHashes( presentation_import_options = presentation_import_options ) new_hashes = [ hash for hash in watcher_hashes if hash not in seen_hashes ] hashes.extend( new_hashes ) seen_hashes.update( new_hashes ) if len( hashes ) > 0: self._ClearExistingHighlightAndPanel() media_results = self._controller.Read( 'media_results', hashes, sorted = True ) location_context = ClientLocation.LocationContext.STATICCreateSimple( CC.COMBINED_LOCAL_MEDIA_SERVICE_KEY ) self._SetLocationContext( location_context ) panel = ClientGUIResults.MediaPanelThumbnails( self._page, self._page_key, location_context, media_results ) self._page.SwapMediaPanel( panel ) else: QW.QMessageBox.warning( self, 'Warning', 'No presented files for that selection!' ) def _ShowSelectedImportersGallerySeedLogs( self ): watchers = self._watchers_listctrl.GetData( only_selected = True ) if len( watchers ) == 0: return watcher = watchers[0] gallery_seed_log = watcher.GetGallerySeedLog() title = 'check log' frame_key = 'gallery_import_log' read_only = True can_generate_more_pages = False frame = ClientGUITopLevelWindowsPanels.FrameThatTakesScrollablePanel( self, title, frame_key ) panel = ClientGUIGallerySeedLog.EditGallerySeedLogPanel( frame, HG.client_controller, read_only, can_generate_more_pages, 'check', gallery_seed_log ) frame.SetPanel( panel ) def _UpdateImportStatus( self ): if HydrusData.TimeHasPassed( self._next_update_time ): num_items = len( self._watchers_listctrl.GetData() ) update_period = max( 1, int( ( num_items / 10 ) ** 0.33 ) ) self._next_update_time = HydrusData.GetNow() + update_period # last_time_watchers_changed = self._multiple_watcher_import.GetLastTimeWatchersChanged() num_watchers = self._multiple_watcher_import.GetNumWatchers() # if num_watchers == 0: text_top = 'waiting for new watchers' text_bottom = '' else: num_dead = self._multiple_watcher_import.GetNumDead() if num_dead == 0: num_dead_text = '' else: num_dead_text = HydrusData.ToHumanInt( num_dead ) + ' DEAD - ' file_seed_cache_status = self._multiple_watcher_import.GetTotalStatus() ( num_done, num_total ) = file_seed_cache_status.GetValueRange() text_top = '{} watchers - {}'.format( HydrusData.ToHumanInt( num_watchers ), HydrusData.ConvertValueRangeToPrettyString( num_done, num_total ) ) text_bottom = file_seed_cache_status.GetStatusText() self._watchers_status_st_top.setText( text_top ) self._watchers_status_st_bottom.setText( text_bottom ) # if self._last_time_watchers_changed != last_time_watchers_changed: self._last_time_watchers_changed = last_time_watchers_changed watchers = self._multiple_watcher_import.GetWatchers() self._watchers_listctrl.SetData( watchers ) ideal_rows = len( watchers ) ideal_rows = max( 4, ideal_rows ) ideal_rows = min( ideal_rows, 24 ) self._watchers_listctrl.ForceHeight( ideal_rows ) else: sort_data_has_changed = self._watchers_listctrl.UpdateDatas() if sort_data_has_changed: self._watchers_listctrl.Sort() def _UpdateImportStatusNow( self ): self._next_update_time = 0 self._UpdateImportStatus() def CheckAbleToClose( self ): num_working = 0 for watcher in self._multiple_watcher_import.GetWatchers(): if watcher.CurrentlyWorking(): num_working += 1 if num_working > 0: raise HydrusExceptions.VetoException( HydrusData.ToHumanInt( num_working ) + ' watchers are still importing.' ) def PendURL( self, url, filterable_tags = None, additional_service_keys_to_tags = None ): if filterable_tags is None: filterable_tags = set() if additional_service_keys_to_tags is None: additional_service_keys_to_tags = ClientTags.ServiceKeysToTags() self._AddURLs( ( url, ), filterable_tags = filterable_tags, additional_service_keys_to_tags = additional_service_keys_to_tags ) def SetSearchFocus( self ): ClientGUIFunctions.SetFocusLater( self._watcher_url_input ) def Start( self ): self._multiple_watcher_import.Start( self._page_key ) management_panel_types_to_classes[ MANAGEMENT_TYPE_IMPORT_MULTIPLE_WATCHER ] = ManagementPanelImporterMultipleWatcher class ManagementPanelImporterSimpleDownloader( ManagementPanelImporter ): def __init__( self, parent, page, controller, management_controller ): ManagementPanelImporter.__init__( self, parent, page, controller, management_controller ) self._simple_downloader_import = self._management_controller.GetVariable( 'simple_downloader_import' ) # self._simple_downloader_panel = ClientGUICommon.StaticBox( self, 'simple downloader' ) # self._import_queue_panel = ClientGUICommon.StaticBox( self._simple_downloader_panel, 'imports' ) self._pause_files_button = ClientGUICommon.BetterBitmapButton( self._import_queue_panel, CC.global_pixmaps().file_pause, self.PauseFiles ) self._pause_files_button.setToolTip( 'pause/play files' ) self._current_action = ClientGUICommon.BetterStaticText( self._import_queue_panel, ellipsize_end = True ) self._file_seed_cache_control = ClientGUIFileSeedCache.FileSeedCacheStatusControl( self._import_queue_panel, self._controller, self._page_key ) self._file_download_control = ClientGUINetworkJobControl.NetworkJobControl( self._import_queue_panel ) # # self._simple_parsing_jobs_panel = ClientGUICommon.StaticBox( self._simple_downloader_panel, 'parsing' ) self._pause_queue_button = ClientGUICommon.BetterBitmapButton( self._simple_parsing_jobs_panel, CC.global_pixmaps().gallery_pause, self.PauseQueue ) self._pause_queue_button.setToolTip( 'pause/play queue' ) self._parser_status = ClientGUICommon.BetterStaticText( self._simple_parsing_jobs_panel, ellipsize_end = True ) self._gallery_seed_log_control = ClientGUIGallerySeedLog.GallerySeedLogStatusControl( self._simple_parsing_jobs_panel, self._controller, True, False, 'parsing', self._page_key ) self._page_download_control = ClientGUINetworkJobControl.NetworkJobControl( self._simple_parsing_jobs_panel ) self._pending_jobs_listbox = ClientGUIListBoxes.BetterQListWidget( self._simple_parsing_jobs_panel ) self._pending_jobs_listbox.setSelectionMode( QW.QAbstractItemView.ExtendedSelection ) self._advance_button = QW.QPushButton( '\u2191', self._simple_parsing_jobs_panel ) self._advance_button.clicked.connect( self.EventAdvance ) self._delete_button = QW.QPushButton( 'X', self._simple_parsing_jobs_panel ) self._delete_button.clicked.connect( self.EventDelete ) self._delay_button = QW.QPushButton( '\u2193', self._simple_parsing_jobs_panel ) self._delay_button.clicked.connect( self.EventDelay ) self._page_url_input = ClientGUIControls.TextAndPasteCtrl( self._simple_parsing_jobs_panel, self._PendPageURLs ) self._page_url_input.setPlaceholderText( 'url to be parsed by the selected formula' ) self._formulae = ClientGUICommon.BetterChoice( self._simple_parsing_jobs_panel ) formulae_width = ClientGUIFunctions.ConvertTextToPixelWidth( self._formulae, 10 ) self._formulae.setMinimumWidth( formulae_width ) menu_items = [] menu_items.append( ( 'normal', 'edit formulae', 'Edit these parsing formulae.', self._EditFormulae ) ) self._formula_cog = ClientGUIMenuButton.MenuBitmapButton( self._simple_parsing_jobs_panel, CC.global_pixmaps().cog, menu_items ) self._RefreshFormulae() file_import_options = self._simple_downloader_import.GetFileImportOptions() show_downloader_options = True allow_default_selection = True self._import_options_button = ClientGUIImportOptions.ImportOptionsButton( self, show_downloader_options, allow_default_selection ) self._import_options_button.SetFileImportOptions( file_import_options ) # hbox = QP.HBoxLayout() QP.AddToLayout( hbox, self._current_action, CC.FLAGS_CENTER_PERPENDICULAR_EXPAND_DEPTH ) QP.AddToLayout( hbox, self._pause_files_button, CC.FLAGS_CENTER_PERPENDICULAR ) self._import_queue_panel.Add( hbox, CC.FLAGS_EXPAND_SIZER_PERPENDICULAR ) self._import_queue_panel.Add( self._file_seed_cache_control, CC.FLAGS_EXPAND_PERPENDICULAR ) self._import_queue_panel.Add( self._file_download_control, CC.FLAGS_EXPAND_PERPENDICULAR ) queue_buttons_vbox = QP.VBoxLayout() QP.AddToLayout( queue_buttons_vbox, self._advance_button, CC.FLAGS_CENTER_PERPENDICULAR ) QP.AddToLayout( queue_buttons_vbox, self._delete_button, CC.FLAGS_CENTER_PERPENDICULAR ) QP.AddToLayout( queue_buttons_vbox, self._delay_button, CC.FLAGS_CENTER_PERPENDICULAR ) queue_hbox = QP.HBoxLayout() QP.AddToLayout( queue_hbox, self._pending_jobs_listbox, CC.FLAGS_EXPAND_BOTH_WAYS ) QP.AddToLayout( queue_hbox, queue_buttons_vbox, CC.FLAGS_CENTER_PERPENDICULAR ) formulae_hbox = QP.HBoxLayout() QP.AddToLayout( formulae_hbox, self._formulae, CC.FLAGS_EXPAND_BOTH_WAYS ) QP.AddToLayout( formulae_hbox, self._formula_cog, CC.FLAGS_CENTER_PERPENDICULAR ) hbox = QP.HBoxLayout() QP.AddToLayout( hbox, self._parser_status, CC.FLAGS_CENTER_PERPENDICULAR_EXPAND_DEPTH ) QP.AddToLayout( hbox, self._pause_queue_button, CC.FLAGS_CENTER_PERPENDICULAR ) self._simple_parsing_jobs_panel.Add( hbox, CC.FLAGS_EXPAND_SIZER_PERPENDICULAR ) self._simple_parsing_jobs_panel.Add( self._gallery_seed_log_control, CC.FLAGS_EXPAND_PERPENDICULAR ) self._simple_parsing_jobs_panel.Add( self._page_download_control, CC.FLAGS_EXPAND_PERPENDICULAR ) self._simple_parsing_jobs_panel.Add( queue_hbox, CC.FLAGS_EXPAND_SIZER_BOTH_WAYS ) self._simple_parsing_jobs_panel.Add( self._page_url_input, CC.FLAGS_EXPAND_PERPENDICULAR ) self._simple_parsing_jobs_panel.Add( formulae_hbox, CC.FLAGS_EXPAND_PERPENDICULAR ) # self._simple_downloader_panel.Add( self._import_queue_panel, CC.FLAGS_EXPAND_PERPENDICULAR ) self._simple_downloader_panel.Add( self._simple_parsing_jobs_panel, CC.FLAGS_EXPAND_PERPENDICULAR ) self._simple_downloader_panel.Add( self._import_options_button, CC.FLAGS_EXPAND_PERPENDICULAR ) # vbox = QP.VBoxLayout() QP.AddToLayout( vbox, self._media_sort, CC.FLAGS_EXPAND_PERPENDICULAR ) QP.AddToLayout( vbox, self._media_collect, CC.FLAGS_EXPAND_PERPENDICULAR ) QP.AddToLayout( vbox, self._simple_downloader_panel, CC.FLAGS_EXPAND_PERPENDICULAR ) self._MakeCurrentSelectionTagsBox( vbox ) self.widget().setLayout( vbox ) # self._formulae.currentIndexChanged.connect( self.EventFormulaChanged ) file_seed_cache = self._simple_downloader_import.GetFileSeedCache() self._file_seed_cache_control.SetFileSeedCache( file_seed_cache ) gallery_seed_log = self._simple_downloader_import.GetGallerySeedLog() self._gallery_seed_log_control.SetGallerySeedLog( gallery_seed_log ) self._UpdateImportStatus() self._import_options_button.fileImportOptionsChanged.connect( self._simple_downloader_import.SetFileImportOptions ) def _EditFormulae( self ): def data_to_pretty_callable( data ): simple_downloader_formula = data return simple_downloader_formula.GetName() def edit_callable( data ): simple_downloader_formula = data name = simple_downloader_formula.GetName() with ClientGUIDialogs.DialogTextEntry( dlg, 'edit name', default = name ) as dlg_2: if dlg_2.exec() == QW.QDialog.Accepted: name = dlg_2.GetValue() else: raise HydrusExceptions.VetoException() with ClientGUITopLevelWindowsPanels.DialogEdit( dlg, 'edit formula' ) as dlg_3: panel = ClientGUIScrolledPanels.EditSingleCtrlPanel( dlg_3 ) formula = simple_downloader_formula.GetFormula() control = ClientGUIParsingFormulae.EditFormulaPanel( panel, formula, lambda: ClientParsing.ParsingTestData( {}, ( '', ) ) ) panel.SetControl( control ) dlg_3.SetPanel( panel ) if dlg_3.exec() == QW.QDialog.Accepted: formula = control.GetValue() simple_downloader_formula = ClientParsing.SimpleDownloaderParsingFormula( name = name, formula = formula ) return simple_downloader_formula else: raise HydrusExceptions.VetoException() def add_callable(): data = ClientParsing.SimpleDownloaderParsingFormula() return edit_callable( data ) formulae = list( self._controller.new_options.GetSimpleDownloaderFormulae() ) formulae.sort( key = lambda o: o.GetName() ) with ClientGUITopLevelWindowsPanels.DialogEdit( self, 'edit simple downloader formulae' ) as dlg: panel = ClientGUIScrolledPanels.EditSingleCtrlPanel( dlg ) height_num_chars = 20 control = ClientGUIListBoxes.AddEditDeleteListBoxUniqueNamedObjects( panel, height_num_chars, data_to_pretty_callable, add_callable, edit_callable ) control.AddSeparator() control.AddImportExportButtons( ( ClientParsing.SimpleDownloaderParsingFormula, ) ) control.AddSeparator() control.AddDefaultsButton( ClientDefaults.GetDefaultSimpleDownloaderFormulae ) control.AddDatas( formulae ) panel.SetControl( control ) dlg.SetPanel( panel ) if dlg.exec() == QW.QDialog.Accepted: formulae = control.GetData() self._controller.new_options.SetSimpleDownloaderFormulae( formulae ) self._RefreshFormulae() def _PendPageURLs( self, urls ): urls = [ url for url in urls if url.startswith( 'http' ) ] simple_downloader_formula = self._formulae.GetValue() for url in urls: job = ( url, simple_downloader_formula ) self._simple_downloader_import.PendJob( job ) self._UpdateImportStatus() def _RefreshFormulae( self ): self._formulae.blockSignals( True ) self._formulae.clear() to_select = None select_name = self._simple_downloader_import.GetFormulaName() simple_downloader_formulae = list( self._controller.new_options.GetSimpleDownloaderFormulae() ) simple_downloader_formulae.sort( key = lambda o: o.GetName() ) for ( i, simple_downloader_formula ) in enumerate( simple_downloader_formulae ): name = simple_downloader_formula.GetName() self._formulae.addItem( name, simple_downloader_formula ) if name == select_name: to_select = i self._formulae.blockSignals( False ) if to_select is not None: self._formulae.setCurrentIndex( to_select ) def _UpdateImportStatus( self ): ( pending_jobs, parser_status, current_action, queue_paused, files_paused ) = self._simple_downloader_import.GetStatus() current_pending_jobs = self._pending_jobs_listbox.GetData() if current_pending_jobs != pending_jobs: selected_jobs = set( self._pending_jobs_listbox.GetData( only_selected = True ) ) self._pending_jobs_listbox.clear() for job in pending_jobs: ( url, simple_downloader_formula ) = job pretty_job = simple_downloader_formula.GetName() + ': ' + url self._pending_jobs_listbox.Append( pretty_job, job ) self._pending_jobs_listbox.SelectData( selected_jobs ) self._parser_status.setText( parser_status ) self._current_action.setText( current_action ) if files_paused: ClientGUIFunctions.SetBitmapButtonBitmap( self._pause_files_button, CC.global_pixmaps().file_play ) else: ClientGUIFunctions.SetBitmapButtonBitmap( self._pause_files_button, CC.global_pixmaps().file_pause ) if queue_paused: ClientGUIFunctions.SetBitmapButtonBitmap( self._pause_queue_button, CC.global_pixmaps().gallery_play ) else: ClientGUIFunctions.SetBitmapButtonBitmap( self._pause_queue_button, CC.global_pixmaps().gallery_pause ) ( file_network_job, page_network_job ) = self._simple_downloader_import.GetNetworkJobs() if file_network_job is None: self._file_download_control.ClearNetworkJob() else: self._file_download_control.SetNetworkJob( file_network_job ) if page_network_job is None: self._page_download_control.ClearNetworkJob() else: self._page_download_control.SetNetworkJob( page_network_job ) def CheckAbleToClose( self ): if self._simple_downloader_import.CurrentlyWorking(): raise HydrusExceptions.VetoException( 'This page is still importing.' ) def EventAdvance( self ): selected_jobs = self._pending_jobs_listbox.GetData( only_selected = True ) for job in selected_jobs: self._simple_downloader_import.AdvanceJob( job ) if len( selected_jobs ) > 0: self._UpdateImportStatus() def EventDelay( self ): selected_jobs = list( self._pending_jobs_listbox.GetData( only_selected = True ) ) selected_jobs.reverse() for job in selected_jobs: self._simple_downloader_import.DelayJob( job ) if len( selected_jobs ) > 0: self._UpdateImportStatus() def EventDelete( self ): selected_jobs = self._pending_jobs_listbox.GetData( only_selected = True ) message = 'Delete {} jobs?'.format( HydrusData.ToHumanInt( len( selected_jobs ) ) ) result = ClientGUIDialogsQuick.GetYesNo( self, message ) if result != QW.QDialog.Accepted: return for job in selected_jobs: self._simple_downloader_import.DeleteJob( job ) if len( selected_jobs ) > 0: self._UpdateImportStatus() def EventFormulaChanged( self ): formula = self._formulae.GetValue() formula_name = formula.GetName() self._simple_downloader_import.SetFormulaName( formula_name ) self._controller.new_options.SetString( 'favourite_simple_downloader_formula', formula_name ) def PauseQueue( self ): self._simple_downloader_import.PausePlayQueue() self._UpdateImportStatus() def PauseFiles( self ): self._simple_downloader_import.PausePlayFiles() self._UpdateImportStatus() def SetSearchFocus( self ): ClientGUIFunctions.SetFocusLater( self._page_url_input ) def Start( self ): self._simple_downloader_import.Start( self._page_key ) management_panel_types_to_classes[ MANAGEMENT_TYPE_IMPORT_SIMPLE_DOWNLOADER ] = ManagementPanelImporterSimpleDownloader class ManagementPanelImporterURLs( ManagementPanelImporter ): def __init__( self, parent, page, controller, management_controller ): ManagementPanelImporter.__init__( self, parent, page, controller, management_controller ) # self._url_panel = ClientGUICommon.StaticBox( self, 'url downloader' ) # self._import_queue_panel = ClientGUICommon.StaticBox( self._url_panel, 'imports' ) self._pause_button = ClientGUICommon.BetterBitmapButton( self._import_queue_panel, CC.global_pixmaps().file_pause, self.Pause ) self._pause_button.setToolTip( 'pause/play files' ) self._file_download_control = ClientGUINetworkJobControl.NetworkJobControl( self._import_queue_panel ) self._urls_import = self._management_controller.GetVariable( 'urls_import' ) self._file_seed_cache_control = ClientGUIFileSeedCache.FileSeedCacheStatusControl( self._import_queue_panel, self._controller, page_key = self._page_key ) # self._gallery_panel = ClientGUICommon.StaticBox( self._url_panel, 'search' ) self._gallery_download_control = ClientGUINetworkJobControl.NetworkJobControl( self._gallery_panel ) self._gallery_seed_log_control = ClientGUIGallerySeedLog.GallerySeedLogStatusControl( self._gallery_panel, self._controller, False, False, 'search', page_key = self._page_key ) # self._url_input = ClientGUIControls.TextAndPasteCtrl( self._url_panel, self._PendURLs ) self._url_input.setPlaceholderText( 'any url hydrus recognises, or a raw file url' ) file_import_options = self._urls_import.GetFileImportOptions() tag_import_options = self._urls_import.GetTagImportOptions() note_import_options = self._urls_import.GetNoteImportOptions() show_downloader_options = True allow_default_selection = True self._import_options_button = ClientGUIImportOptions.ImportOptionsButton( self, show_downloader_options, allow_default_selection ) self._import_options_button.SetFileImportOptions( file_import_options ) self._import_options_button.SetTagImportOptions( tag_import_options ) self._import_options_button.SetNoteImportOptions( note_import_options ) # self._import_queue_panel.Add( self._pause_button, CC.FLAGS_ON_RIGHT ) self._import_queue_panel.Add( self._file_seed_cache_control, CC.FLAGS_EXPAND_PERPENDICULAR ) self._import_queue_panel.Add( self._file_download_control, CC.FLAGS_EXPAND_PERPENDICULAR ) self._gallery_panel.Add( self._gallery_seed_log_control, CC.FLAGS_EXPAND_PERPENDICULAR ) self._gallery_panel.Add( self._gallery_download_control, CC.FLAGS_EXPAND_PERPENDICULAR ) self._url_panel.Add( self._import_queue_panel, CC.FLAGS_EXPAND_PERPENDICULAR ) self._url_panel.Add( self._gallery_panel, CC.FLAGS_EXPAND_PERPENDICULAR ) self._url_panel.Add( self._url_input, CC.FLAGS_EXPAND_PERPENDICULAR ) self._url_panel.Add( self._import_options_button, CC.FLAGS_EXPAND_PERPENDICULAR ) # vbox = QP.VBoxLayout() QP.AddToLayout( vbox, self._media_sort, CC.FLAGS_EXPAND_PERPENDICULAR ) QP.AddToLayout( vbox, self._media_collect, CC.FLAGS_EXPAND_PERPENDICULAR ) QP.AddToLayout( vbox, self._url_panel, CC.FLAGS_EXPAND_PERPENDICULAR ) self._MakeCurrentSelectionTagsBox( vbox ) self.widget().setLayout( vbox ) # file_seed_cache = self._urls_import.GetFileSeedCache() self._file_seed_cache_control.SetFileSeedCache( file_seed_cache ) gallery_seed_log = self._urls_import.GetGallerySeedLog() self._gallery_seed_log_control.SetGallerySeedLog( gallery_seed_log ) self._UpdateImportStatus() self._import_options_button.fileImportOptionsChanged.connect( self._urls_import.SetFileImportOptions ) self._import_options_button.noteImportOptionsChanged.connect( self._urls_import.SetNoteImportOptions ) self._import_options_button.tagImportOptionsChanged.connect( self._urls_import.SetTagImportOptions ) def _PendURLs( self, urls, filterable_tags = None, additional_service_keys_to_tags = None ): if filterable_tags is None: filterable_tags = set() if additional_service_keys_to_tags is None: additional_service_keys_to_tags = ClientTags.ServiceKeysToTags() urls = [ url for url in urls if url.startswith( 'http' ) ] self._urls_import.PendURLs( urls, filterable_tags = filterable_tags, additional_service_keys_to_tags = additional_service_keys_to_tags ) self._UpdateImportStatus() def _UpdateImportStatus( self ): paused = self._urls_import.IsPaused() if paused: ClientGUIFunctions.SetBitmapButtonBitmap( self._pause_button, CC.global_pixmaps().file_play ) else: ClientGUIFunctions.SetBitmapButtonBitmap( self._pause_button, CC.global_pixmaps().file_pause ) ( file_network_job, gallery_network_job ) = self._urls_import.GetNetworkJobs() if file_network_job is None: self._file_download_control.ClearNetworkJob() else: self._file_download_control.SetNetworkJob( file_network_job ) if gallery_network_job is None: self._gallery_download_control.ClearNetworkJob() else: self._gallery_download_control.SetNetworkJob( gallery_network_job ) def CheckAbleToClose( self ): if self._urls_import.CurrentlyWorking(): raise HydrusExceptions.VetoException( 'This page is still importing.' ) def Pause( self ): self._urls_import.PausePlay() self._UpdateImportStatus() def PendURL( self, url, filterable_tags = None, additional_service_keys_to_tags = None ): if filterable_tags is None: filterable_tags = set() if additional_service_keys_to_tags is None: additional_service_keys_to_tags = ClientTags.ServiceKeysToTags() self._PendURLs( ( url, ), filterable_tags = filterable_tags, additional_service_keys_to_tags = additional_service_keys_to_tags ) def SetSearchFocus( self ): ClientGUIFunctions.SetFocusLater( self._url_input ) def Start( self ): self._urls_import.Start( self._page_key ) management_panel_types_to_classes[ MANAGEMENT_TYPE_IMPORT_URLS ] = ManagementPanelImporterURLs class ManagementPanelPetitions( ManagementPanel ): TAG_DISPLAY_TYPE = ClientTags.TAG_DISPLAY_STORAGE def __init__( self, parent, page, controller, management_controller ): self._petition_service_key = management_controller.GetVariable( 'petition_service_key' ) ManagementPanel.__init__( self, parent, page, controller, management_controller ) self._service = self._controller.services_manager.GetService( self._petition_service_key ) self._can_ban = self._service.HasPermission( HC.CONTENT_TYPE_ACCOUNTS, HC.PERMISSION_ACTION_MODERATE ) service_type = self._service.GetServiceType() self._num_petition_info = None self._current_petition = None self._last_petition_type_fetched = None self._last_fetched_subject_account_key = None # self._petitions_info_panel = ClientGUICommon.StaticBox( self, 'petitions info' ) self._petition_account_key = QW.QLineEdit( self._petitions_info_panel ) self._petition_account_key.setPlaceholderText( 'account id filter' ) self._refresh_num_petitions_button = ClientGUICommon.BetterButton( self._petitions_info_panel, 'refresh counts', self._FetchNumPetitions ) self._petition_types_to_controls = {} content_type_hboxes = [] petition_types = [] if service_type == HC.FILE_REPOSITORY: petition_types.append( ( HC.CONTENT_TYPE_FILES, HC.CONTENT_STATUS_PETITIONED ) ) elif service_type == HC.TAG_REPOSITORY: petition_types.append( ( HC.CONTENT_TYPE_MAPPINGS, HC.CONTENT_STATUS_PETITIONED ) ) petition_types.append( ( HC.CONTENT_TYPE_TAG_PARENTS, HC.CONTENT_STATUS_PENDING ) ) petition_types.append( ( HC.CONTENT_TYPE_TAG_PARENTS, HC.CONTENT_STATUS_PETITIONED ) ) petition_types.append( ( HC.CONTENT_TYPE_TAG_SIBLINGS, HC.CONTENT_STATUS_PENDING ) ) petition_types.append( ( HC.CONTENT_TYPE_TAG_SIBLINGS, HC.CONTENT_STATUS_PETITIONED ) ) for ( content_type, status ) in petition_types: func = HydrusData.Call( self._FetchPetition, content_type, status ) st = ClientGUICommon.BetterStaticText( self._petitions_info_panel ) button = ClientGUICommon.BetterButton( self._petitions_info_panel, 'fetch ' + HC.content_status_string_lookup[ status ] + ' ' + HC.content_type_string_lookup[ content_type ] + ' petition', func ) button.setEnabled( False ) self._petition_types_to_controls[ ( content_type, status ) ] = ( st, button ) hbox = QP.HBoxLayout() QP.AddToLayout( hbox, st, CC.FLAGS_CENTER_PERPENDICULAR_EXPAND_DEPTH ) QP.AddToLayout( hbox, button, CC.FLAGS_CENTER_PERPENDICULAR ) content_type_hboxes.append( hbox ) # self._petition_panel = ClientGUICommon.StaticBox( self, 'petition' ) self._num_files_to_show = ClientGUICommon.NoneableSpinCtrl( self._petition_panel, message = 'number of files to show', min = 1 ) self._num_files_to_show.SetValue( 256 ) self._action_text = ClientGUICommon.BetterStaticText( self._petition_panel, label = '' ) self._reason_text = QW.QTextEdit( self._petition_panel ) self._reason_text.setReadOnly( True ) ( min_width, min_height ) = ClientGUIFunctions.ConvertTextToPixels( self._reason_text, ( 16, 6 ) ) self._reason_text.setFixedHeight( min_height ) check_all = ClientGUICommon.BetterButton( self._petition_panel, 'check all', self._CheckAll ) flip_selected = ClientGUICommon.BetterButton( self._petition_panel, 'flip selected', self._FlipSelected ) check_none = ClientGUICommon.BetterButton( self._petition_panel, 'check none', self._CheckNone ) self._sort_by_left = ClientGUICommon.BetterButton( self._petition_panel, 'sort by left', self._SortBy, 'left' ) self._sort_by_right = ClientGUICommon.BetterButton( self._petition_panel, 'sort by right', self._SortBy, 'right' ) self._sort_by_left.setEnabled( False ) self._sort_by_right.setEnabled( False ) self._contents_add = ClientGUICommon.BetterCheckBoxList( self._petition_panel ) self._contents_add.itemDoubleClicked.connect( self.ContentsAddDoubleClick ) ( min_width, min_height ) = ClientGUIFunctions.ConvertTextToPixels( self._contents_add, ( 16, 20 ) ) self._contents_add.setFixedHeight( min_height ) self._contents_delete = ClientGUICommon.BetterCheckBoxList( self._petition_panel ) self._contents_delete.itemDoubleClicked.connect( self.ContentsDeleteDoubleClick ) ( min_width, min_height ) = ClientGUIFunctions.ConvertTextToPixels( self._contents_delete, ( 16, 20 ) ) self._contents_delete.setFixedHeight( min_height ) self._process = QW.QPushButton( 'process', self._petition_panel ) self._process.clicked.connect( self.EventProcess ) self._process.setObjectName( 'HydrusAccept' ) self._copy_account_key_button = ClientGUICommon.BetterButton( self._petition_panel, 'copy petitioner account id', self._CopyAccountKey ) self._modify_petitioner = QW.QPushButton( 'modify petitioner', self._petition_panel ) self._modify_petitioner.clicked.connect( self.EventModifyPetitioner ) self._modify_petitioner.setEnabled( False ) if not self._can_ban: self._modify_petitioner.setVisible( False ) # self._petitions_info_panel.Add( self._petition_account_key, CC.FLAGS_EXPAND_PERPENDICULAR ) self._petitions_info_panel.Add( self._refresh_num_petitions_button, CC.FLAGS_EXPAND_PERPENDICULAR ) for hbox in content_type_hboxes: self._petitions_info_panel.Add( hbox, CC.FLAGS_EXPAND_SIZER_PERPENDICULAR ) check_hbox = QP.HBoxLayout() QP.AddToLayout( check_hbox, check_all, CC.FLAGS_CENTER_PERPENDICULAR_EXPAND_DEPTH ) QP.AddToLayout( check_hbox, flip_selected, CC.FLAGS_CENTER_PERPENDICULAR_EXPAND_DEPTH ) QP.AddToLayout( check_hbox, check_none, CC.FLAGS_CENTER_PERPENDICULAR_EXPAND_DEPTH ) sort_hbox = QP.HBoxLayout() QP.AddToLayout( sort_hbox, self._sort_by_left, CC.FLAGS_CENTER_PERPENDICULAR_EXPAND_DEPTH ) QP.AddToLayout( sort_hbox, self._sort_by_right, CC.FLAGS_CENTER_PERPENDICULAR_EXPAND_DEPTH ) self._petition_panel.Add( ClientGUICommon.BetterStaticText( self._petition_panel, label = 'Double-click a petition to see its files, if it has them.' ), CC.FLAGS_EXPAND_PERPENDICULAR ) self._petition_panel.Add( self._num_files_to_show, CC.FLAGS_EXPAND_PERPENDICULAR ) self._petition_panel.Add( self._action_text, CC.FLAGS_EXPAND_PERPENDICULAR ) self._petition_panel.Add( self._reason_text, CC.FLAGS_EXPAND_PERPENDICULAR ) self._petition_panel.Add( check_hbox, CC.FLAGS_EXPAND_SIZER_PERPENDICULAR ) self._petition_panel.Add( sort_hbox, CC.FLAGS_EXPAND_SIZER_PERPENDICULAR ) self._petition_panel.Add( self._contents_add, CC.FLAGS_EXPAND_PERPENDICULAR ) self._petition_panel.Add( self._contents_delete, CC.FLAGS_EXPAND_PERPENDICULAR ) self._petition_panel.Add( self._process, CC.FLAGS_EXPAND_PERPENDICULAR ) self._petition_panel.Add( self._copy_account_key_button, CC.FLAGS_EXPAND_PERPENDICULAR ) self._petition_panel.Add( self._modify_petitioner, CC.FLAGS_EXPAND_PERPENDICULAR ) vbox = QP.VBoxLayout() QP.AddToLayout( vbox, self._media_sort, CC.FLAGS_EXPAND_PERPENDICULAR ) QP.AddToLayout( vbox, self._media_collect, CC.FLAGS_EXPAND_PERPENDICULAR ) QP.AddToLayout( vbox, self._petitions_info_panel, CC.FLAGS_EXPAND_PERPENDICULAR ) QP.AddToLayout( vbox, self._petition_panel, CC.FLAGS_EXPAND_PERPENDICULAR ) if service_type == HC.TAG_REPOSITORY: tag_display_type = ClientTags.TAG_DISPLAY_STORAGE else: tag_display_type = ClientTags.TAG_DISPLAY_SELECTION_LIST self._MakeCurrentSelectionTagsBox( vbox, tag_display_type = tag_display_type ) self.widget().setLayout( vbox ) self._contents_add.rightClicked.connect( self.EventAddRowRightClick ) self._contents_delete.rightClicked.connect( self.EventDeleteRowRightClick ) self._petition_account_key.textChanged.connect( self._UpdateAccountKey ) self._UpdateAccountKey() self._DrawCurrentPetition() def _CheckAll( self ): for i in range( self._contents_add.count() ): self._contents_add.Check( i, True ) for i in range( self._contents_delete.count() ): self._contents_delete.Check( i, True ) def _CheckNone( self ): for i in range( self._contents_add.count() ): self._contents_add.Check( i, False ) for i in range( self._contents_delete.count() ): self._contents_delete.Check( i, False ) def _CopyAccountKey( self ): if self._current_petition is None: return account_key = self._current_petition.GetPetitionerAccount().GetAccountKey() HG.client_controller.pub( 'clipboard', 'text', account_key.hex() ) def _DrawCurrentPetition( self ): if self._current_petition is None: self._action_text.clear() self._action_text.setProperty( 'hydrus_text', 'default' ) self._reason_text.clear() self._reason_text.setProperty( 'hydrus_text', 'default' ) self._contents_add.clear() self._contents_delete.clear() self._contents_add.hide() self._contents_delete.hide() self._process.setEnabled( False ) self._copy_account_key_button.setEnabled( False ) self._sort_by_left.setEnabled( False ) self._sort_by_right.setEnabled( False ) if self._can_ban: self._modify_petitioner.setEnabled( False ) else: add_contents = self._current_petition.GetContents( HC.CONTENT_UPDATE_PEND ) delete_contents = self._current_petition.GetContents( HC.CONTENT_UPDATE_PETITION ) have_add = len( add_contents ) > 0 have_delete = len( delete_contents ) > 0 action_text = 'UNKNOWN' hydrus_text = 'default' object_name = 'normal' if have_add or have_delete: if have_add and have_delete: action_text = 'REPLACE' elif have_add: action_text = 'ADD' hydrus_text = 'valid' object_name = 'HydrusValid' else: action_text = 'DELETE' hydrus_text = 'invalid' object_name = 'HydrusInvalid' self._action_text.setText( action_text ) self._action_text.setObjectName( object_name ) #self._action_text.setProperty( 'hydrus_text', hydrus_text ) reason = self._current_petition.GetReason() self._reason_text.setPlainText( reason ) self._reason_text.setObjectName( object_name ) #self._reason_text.setProperty( 'hydrus_text', hydrus_text ) if self._last_petition_type_fetched[0] in ( HC.CONTENT_TYPE_TAG_SIBLINGS, HC.CONTENT_TYPE_TAG_PARENTS ): self._sort_by_left.setEnabled( True ) self._sort_by_right.setEnabled( True ) else: self._sort_by_left.setEnabled( False ) self._sort_by_right.setEnabled( False ) self._contents_add.setVisible( have_add ) self._contents_delete.setVisible( have_delete ) contents_and_checks = [ ( c, True ) for c in add_contents ] self._SetContentsAndChecks( HC.CONTENT_UPDATE_PEND, contents_and_checks, 'right' ) contents_and_checks = [ ( c, True ) for c in delete_contents ] self._SetContentsAndChecks( HC.CONTENT_UPDATE_PETITION, contents_and_checks, 'right' ) self._process.setEnabled( True ) self._copy_account_key_button.setEnabled( True ) if self._can_ban: self._modify_petitioner.setEnabled( True ) self._action_text.style().polish( self._action_text ) self._reason_text.style().polish( self._reason_text ) def _DrawNumPetitions( self ): if self._num_petition_info is None: for ( petition_type, ( st, button ) ) in self._petition_types_to_controls.items(): st.setText( '0 petitions' ) button.setEnabled( False ) else: for ( content_type, status, count ) in self._num_petition_info: petition_type = ( content_type, status ) if petition_type in self._petition_types_to_controls: ( st, button ) = self._petition_types_to_controls[ petition_type ] st.setText( HydrusData.ToHumanInt( count )+' petitions' ) if count > 0: button.setEnabled( True ) else: button.setEnabled( False ) def _FetchBestPetition( self ): top_petition_type_with_count = None for ( content_type, status, count ) in self._num_petition_info: if count == 0: continue petition_type = ( content_type, status ) if top_petition_type_with_count is None: top_petition_type_with_count = petition_type if self._last_petition_type_fetched is not None and self._last_petition_type_fetched == petition_type: self._FetchPetition( content_type, status ) return if top_petition_type_with_count is not None: ( content_type, status ) = top_petition_type_with_count self._FetchPetition( content_type, status ) def _FetchNumPetitions( self ): def do_it( service, subject_account_key = None ): def qt_draw( n_p_i ): if not self or not QP.isValid( self ): return self._num_petition_info = n_p_i self._DrawNumPetitions() if self._current_petition is None: self._FetchBestPetition() def qt_reset(): if not self or not QP.isValid( self ): return self._refresh_num_petitions_button.setText( 'refresh counts' ) try: if subject_account_key is None: response = service.Request( HC.GET, 'num_petitions' ) else: try: response = service.Request( HC.GET, 'num_petitions', { 'subject_account_key' : subject_account_key } ) except HydrusExceptions.NotFoundException: HydrusData.ShowText( 'That account id was not found!' ) QP.CallAfter( qt_draw, None ) return num_petition_info = response[ 'num_petitions' ] QP.CallAfter( qt_draw, num_petition_info ) finally: QP.CallAfter( qt_reset ) self._refresh_num_petitions_button.setText( 'Fetching\u2026' ) subject_account_key = self._GetSubjectAccountKey() self._last_fetched_subject_account_key = subject_account_key self._controller.CallToThread( do_it, self._service, subject_account_key ) def _FetchPetition( self, content_type, status ): self._last_petition_type_fetched = ( content_type, status ) ( st, button ) = self._petition_types_to_controls[ ( content_type, status ) ] def qt_setpet( petition ): if not self or not QP.isValid( self ): return self._current_petition = petition self._DrawCurrentPetition() self._ShowHashes( [] ) def qt_done(): if not self or not QP.isValid( self ): return button.setEnabled( True ) button.setText( 'fetch {} {} petition'.format( HC.content_status_string_lookup[ status ], HC.content_type_string_lookup[ content_type ] ) ) def do_it( service, subject_account_key = None ): try: if subject_account_key is None: response = service.Request( HC.GET, 'petition', { 'content_type' : content_type, 'status' : status } ) else: response = service.Request( HC.GET, 'petition', { 'content_type' : content_type, 'status' : status, 'subject_account_key' : subject_account_key } ) QP.CallAfter( qt_setpet, response['petition'] ) except HydrusExceptions.NotFoundException: job_key = ClientThreading.JobKey() job_key.SetVariable( 'popup_text_1', 'Hey, the server did not have a petition after all. Please hit refresh counts.' ) job_key.Delete( 5 ) HG.client_controller.pub( 'message', job_key ) finally: QP.CallAfter( qt_done ) if self._current_petition is not None: self._current_petition = None self._DrawCurrentPetition() self._ShowHashes( [] ) button.setEnabled( False ) button.setText( 'Fetching\u2026' ) subject_account_key = self._GetSubjectAccountKey() self._controller.CallToThread( do_it, self._service, subject_account_key ) def _FlipSelected( self ): for i in self._contents_add.GetSelectedIndices(): flipped_state = not self._contents_add.IsChecked( i ) self._contents_add.Check( i, flipped_state ) for i in self._contents_delete.GetSelectedIndices(): flipped_state = not self._contents_delete.IsChecked( i ) self._contents_delete.Check( i, flipped_state ) def _GetContentsAndChecks( self, action ): if action == HC.CONTENT_UPDATE_PEND: contents = self._contents_add else: contents = self._contents_delete contents_and_checks = [] for i in range( contents.count() ): content = contents.GetData( i ) check = contents.IsChecked( i ) contents_and_checks.append( ( content, check ) ) return contents_and_checks def _GetSubjectAccountKey( self ): account_key_hex = self._petition_account_key.text() if len( account_key_hex ) == 0: return None else: try: account_key_bytes = bytes.fromhex( account_key_hex ) if len( account_key_bytes ) != 32: raise Exception() return account_key_bytes except Exception as e: return None def _SetContentsAndChecks( self, action, contents_and_checks, sort_type ): def key( c_and_s ): ( c, s ) = c_and_s if c.GetContentType() in ( HC.CONTENT_TYPE_TAG_SIBLINGS, HC.CONTENT_TYPE_TAG_PARENTS ): ( left, right ) = c.GetContentData() if sort_type == 'left': ( part_one, part_two ) = ( HydrusTags.SplitTag( left ), HydrusTags.SplitTag( right ) ) elif sort_type == 'right': ( part_one, part_two ) = ( HydrusTags.SplitTag( right ), HydrusTags.SplitTag( left ) ) elif c.GetContentType() == HC.CONTENT_TYPE_MAPPINGS: ( tag, hashes ) = c.GetContentData() part_one = HydrusTags.SplitTag( tag ) part_two = None else: part_one = None part_two = None return ( -c.GetVirtualWeight(), part_one, part_two ) contents_and_checks.sort( key = key ) if action == HC.CONTENT_UPDATE_PEND: contents = self._contents_add string_template = 'ADD: {}' else: contents = self._contents_delete string_template = 'DELETE: {}' contents.clear() for ( i, ( content, check ) ) in enumerate( contents_and_checks ): content_string = string_template.format( content.ToString() ) contents.Append( content_string, content, starts_checked = check ) if contents.count() > 0: ideal_height_in_rows = min( 20, len( contents_and_checks ) ) pixels_per_row = contents.sizeHintForRow( 0 ) ideal_height_in_pixels = ( ideal_height_in_rows * pixels_per_row ) + ( contents.frameWidth() * 2 ) contents.setFixedHeight( ideal_height_in_pixels ) def _ShowHashes( self, hashes ): location_context = self._management_controller.GetVariable( 'location_context' ) with ClientGUICommon.BusyCursor(): media_results = self._controller.Read( 'media_results', hashes ) panel = ClientGUIResults.MediaPanelThumbnails( self._page, self._page_key, location_context, media_results ) panel.Collect( self._page_key, self._media_collect.GetValue() ) panel.Sort( self._media_sort.GetSort() ) self._page.SwapMediaPanel( panel ) def _SortBy( self, sort_type ): for action in [ HC.CONTENT_UPDATE_PEND, HC.CONTENT_UPDATE_PETITION ]: contents_and_checks = self._GetContentsAndChecks( action ) self._SetContentsAndChecks( action, contents_and_checks, sort_type ) def _UpdateAccountKey( self ): account_key_hex = self._petition_account_key.text() if len( account_key_hex ) == 0: valid = True else: try: account_key_bytes = bytes.fromhex( account_key_hex ) if len( account_key_bytes ) != 32: raise Exception() valid = True except Exception as e: valid = False if valid: self._petition_account_key.setObjectName( 'HydrusValid' ) if self._GetSubjectAccountKey() != self._last_fetched_subject_account_key: self._FetchNumPetitions() else: self._petition_account_key.setObjectName( 'HydrusInvalid' ) self._petition_account_key.style().polish( self._petition_account_key ) def ContentsAddDoubleClick( self, item ): selected_indices = self._contents_add.GetSelectedIndices() if len( selected_indices ) > 0: selection = selected_indices[0] content = self._contents_add.GetData( selection ) self.EventContentsDoubleClick( content ) def ContentsDeleteDoubleClick( self, item ): selected_indices = self._contents_delete.GetSelectedIndices() if len( selected_indices ) > 0: selection = selected_indices[0] content = self._contents_delete.GetData( selection ) self.EventContentsDoubleClick( content ) def EventContentsDoubleClick( self, content ): if content.HasHashes(): hashes = content.GetHashes() num_files_to_show = self._num_files_to_show.GetValue() if num_files_to_show is not None and len( hashes ) > num_files_to_show: hashes = random.sample( hashes, num_files_to_show ) self._ShowHashes( hashes ) def EventProcess( self ): def break_contents_into_chunks( some_contents ): chunks_of_some_contents = [] chunk_of_some_contents = [] weight = 0 for content in some_contents: for content_chunk in content.IterateUploadableChunks(): # break 20K-strong mappings petitions into smaller bits to POST back chunk_of_some_contents.append( content_chunk ) weight += content.GetVirtualWeight() if weight > 50: chunks_of_some_contents.append( chunk_of_some_contents ) chunk_of_some_contents = [] weight = 0 if len( chunk_of_some_contents ) > 0: chunks_of_some_contents.append( chunk_of_some_contents ) return chunks_of_some_contents def do_it( controller, service, petition_service_key, add_approved_contents, add_denied_contents, delete_approved_contents, delete_denied_contents, petition ): jobs = [ ( HC.CONTENT_UPDATE_PEND, True, add_approved_contents ), ( HC.CONTENT_UPDATE_PEND, False, add_denied_contents ), ( HC.CONTENT_UPDATE_PETITION, True, delete_approved_contents ), ( HC.CONTENT_UPDATE_PETITION, False, delete_denied_contents ), ] num_done = 0 num_to_do = 0 for ( action, approved, contents ) in jobs: num_to_do += len( contents ) if num_to_do > 1: job_key = ClientThreading.JobKey( cancellable = True ) job_key.SetStatusTitle( 'committing petitions' ) HG.client_controller.pub( 'message', job_key ) else: job_key = None reason = petition.GetReason() try: for ( action, approved, contents ) in jobs: if len( contents ) == 0: continue chunks_of_contents = break_contents_into_chunks( contents ) num_to_do += len( chunks_of_contents ) - 1 for chunk_of_contents in chunks_of_contents: if job_key is not None: ( i_paused, should_quit ) = job_key.WaitIfNeeded() if should_quit: return job_key.SetVariable( 'popup_gauge_1', ( num_done, num_to_do ) ) content_updates = [] if approved: ( update, content_updates ) = petition.GetApproval( action, chunk_of_contents, reason ) else: update = petition.GetDenial( action, chunk_of_contents, reason ) service.Request( HC.POST, 'update', { 'client_to_server_update' : update } ) if len( content_updates ) > 0: controller.WriteSynchronous( 'content_updates', { petition_service_key : content_updates } ) num_done += 1 finally: if job_key is not None: job_key.Delete() def qt_fetch(): if not self or not QP.isValid( self ): return self._FetchNumPetitions() QP.CallAfter( qt_fetch ) add_approved_contents = [] add_denied_contents = [] delete_approved_contents = [] delete_denied_contents = [] jobs = [ ( self._contents_add, add_approved_contents, add_denied_contents ), ( self._contents_delete, delete_approved_contents, delete_denied_contents ) ] for ( contents, approved_contents, denied_contents ) in jobs: for index in range( contents.count() ): content = contents.GetData( index ) if contents.IsChecked( index ): approved_contents.append( content ) else: denied_contents.append( content ) HG.client_controller.CallToThread( do_it, self._controller, self._service, self._petition_service_key, add_approved_contents, add_denied_contents, delete_approved_contents, delete_denied_contents, self._current_petition ) self._current_petition = None self._DrawCurrentPetition() self._ShowHashes( [] ) def EventModifyPetitioner( self ): subject_account_key = self._current_petition.GetPetitionerAccount().GetAccountKey() subject_account_identifiers = [ HydrusNetwork.AccountIdentifier( account_key = subject_account_key ) ] frame = ClientGUITopLevelWindowsPanels.FrameThatTakesScrollablePanel( self, 'manage accounts' ) panel = ClientGUIHydrusNetwork.ModifyAccountsPanel( frame, self._petition_service_key, subject_account_identifiers ) frame.SetPanel( panel ) def EventAddRowRightClick( self ): selected_indices = self._contents_add.GetSelectedIndices() selected_contents = [] for i in selected_indices: content = self._contents_add.GetData( i ) selected_contents.append( content ) self.EventContentsRightClick( selected_contents ) def EventDeleteRowRightClick( self ): selected_indices = self._contents_delete.GetSelectedIndices() selected_contents = [] for i in selected_indices: content = self._contents_delete.GetData( i ) selected_contents.append( content ) self.EventContentsRightClick( selected_contents ) def EventContentsRightClick( self, contents ): copyable_items_a = [] copyable_items_b = [] for content in contents: content_type = content.GetContentType() if content_type == HC.CONTENT_TYPE_MAPPINGS: ( tag, hashes ) = content.GetContentData() copyable_items_a.append( tag ) elif content_type in ( HC.CONTENT_TYPE_TAG_SIBLINGS, HC.CONTENT_TYPE_TAG_PARENTS ): ( tag_a, tag_b ) = content.GetContentData() copyable_items_a.append( tag_a ) copyable_items_b.append( tag_b ) copyable_items_a = HydrusData.DedupeList( copyable_items_a ) copyable_items_b = HydrusData.DedupeList( copyable_items_b ) if len( copyable_items_a ) + len( copyable_items_b ) > 0: menu = QW.QMenu() for copyable_items in [ copyable_items_a, copyable_items_b ]: if len( copyable_items ) > 0: if len( copyable_items ) == 1: tag = copyable_items[0] ClientGUIMenus.AppendMenuItem( menu, 'copy {}'.format( tag ), 'Copy this tag.', HG.client_controller.pub, 'clipboard', 'text', tag ) else: text = os.linesep.join( copyable_items ) ClientGUIMenus.AppendMenuItem( menu, 'copy {} tags'.format( HydrusData.ToHumanInt( len( copyable_items ) ) ), 'Copy this tag.', HG.client_controller.pub, 'clipboard', 'text', text ) CGC.core().PopupMenu( self, menu ) def RefreshQuery( self ): self._DrawCurrentPetition() def Start( self ): QP.CallAfter( self._FetchNumPetitions ) management_panel_types_to_classes[ MANAGEMENT_TYPE_PETITIONS ] = ManagementPanelPetitions class ManagementPanelQuery( ManagementPanel ): def __init__( self, parent, page, controller, management_controller ): ManagementPanel.__init__( self, parent, page, controller, management_controller ) file_search_context = self._management_controller.GetVariable( 'file_search_context' ) file_search_context.FixMissingServices( HG.client_controller.services_manager.FilterValidServiceKeys ) self._search_enabled = self._management_controller.GetVariable( 'search_enabled' ) self._query_job_key = ClientThreading.JobKey( cancellable = True ) self._query_job_key.Finish() if self._search_enabled: self._search_panel = ClientGUICommon.StaticBox( self, 'search' ) synchronised = self._management_controller.GetVariable( 'synchronised' ) self._tag_autocomplete = ClientGUIACDropdown.AutoCompleteDropdownTagsRead( self._search_panel, self._page_key, file_search_context, media_sort_widget = self._media_sort, media_collect_widget = self._media_collect, media_callable = self._page.GetMedia, synchronised = synchronised ) self._tag_autocomplete.searchCancelled.connect( self._CancelSearch ) self._search_panel.Add( self._tag_autocomplete, CC.FLAGS_EXPAND_BOTH_WAYS ) vbox = QP.VBoxLayout() QP.AddToLayout( vbox, self._media_sort, CC.FLAGS_EXPAND_PERPENDICULAR ) QP.AddToLayout( vbox, self._media_collect, CC.FLAGS_EXPAND_PERPENDICULAR ) if self._search_enabled: QP.AddToLayout( vbox, self._search_panel, CC.FLAGS_EXPAND_PERPENDICULAR ) self._MakeCurrentSelectionTagsBox( vbox ) self.widget().setLayout( vbox ) if self._search_enabled: self._tag_autocomplete.searchChanged.connect( self.SearchChanged ) self._tag_autocomplete.locationChanged.connect( self.SetLocationContext ) def _CancelSearch( self ): if self._search_enabled: self._query_job_key.Cancel() file_search_context = self._tag_autocomplete.GetFileSearchContext() location_context = file_search_context.GetLocationContext() self._SetLocationContext( location_context ) panel = ClientGUIResults.MediaPanelThumbnails( self._page, self._page_key, location_context, [] ) panel.SetEmptyPageStatusOverride( 'search cancelled!' ) self._page.SwapMediaPanel( panel ) self._UpdateCancelButton() def _GetDefaultEmptyPageStatusOverride( self ) -> str: return 'no search done yet' def _MakeCurrentSelectionTagsBox( self, sizer ): self._current_selection_tags_box = ClientGUIListBoxes.StaticBoxSorterForListBoxTags( self, 'selection tags' ) if self._search_enabled: self._current_selection_tags_list = ListBoxTagsMediaManagementPanel( self._current_selection_tags_box, self._management_controller, self._page_key, tag_autocomplete = self._tag_autocomplete ) else: self._current_selection_tags_list = ListBoxTagsMediaManagementPanel( self._current_selection_tags_box, self._management_controller, self._page_key ) self._current_selection_tags_box.SetTagsBox( self._current_selection_tags_list ) if self._search_enabled: file_search_context = self._management_controller.GetVariable( 'file_search_context' ) file_search_context.FixMissingServices( HG.client_controller.services_manager.FilterValidServiceKeys ) tag_service_key = file_search_context.GetTagContext().service_key self._current_selection_tags_box.SetTagServiceKey( tag_service_key ) self._tag_autocomplete.tagServiceChanged.connect( self._current_selection_tags_box.SetTagServiceKey ) QP.AddToLayout( sizer, self._current_selection_tags_box, CC.FLAGS_EXPAND_BOTH_WAYS ) def _RefreshQuery( self ): self._controller.ResetIdleTimer() if self._search_enabled: file_search_context = self._tag_autocomplete.GetFileSearchContext() location_context = file_search_context.GetLocationContext() synchronised = self._tag_autocomplete.IsSynchronised() # a query refresh now undoes paused sync if not synchronised: # this will trigger a refresh of search self._tag_autocomplete.SetSynchronised( True ) return interrupting_current_search = not self._query_job_key.IsDone() self._query_job_key.Cancel() if len( file_search_context.GetPredicates() ) > 0: self._query_job_key = ClientThreading.JobKey() sort_by = self._media_sort.GetSort() self._controller.CallToThread( self.THREADDoQuery, self._controller, self._page_key, self._query_job_key, file_search_context, sort_by ) panel = ClientGUIResults.MediaPanelLoading( self._page, self._page_key, location_context ) else: panel = ClientGUIResults.MediaPanelThumbnails( self._page, self._page_key, location_context, [] ) panel.SetEmptyPageStatusOverride( 'no search' ) self._page.SwapMediaPanel( panel ) else: self._media_sort.BroadcastSort() def _UpdateCancelButton( self ): if self._search_enabled: if self._query_job_key.IsDone(): self._tag_autocomplete.ShowCancelSearchButton( False ) else: # don't show it immediately to save on flickeriness on short queries WAIT_PERIOD = 3.0 search_is_lagging = HydrusData.TimeHasPassedFloat( self._query_job_key.GetCreationTime() + WAIT_PERIOD ) self._tag_autocomplete.ShowCancelSearchButton( search_is_lagging ) def ConnectMediaPanelSignals( self, media_panel: ClientGUIResults.MediaPanel ): ManagementPanel.ConnectMediaPanelSignals( self, media_panel ) media_panel.newMediaAdded.connect( self.PauseSearching ) def SetLocationContext( self, location_context: ClientLocation.LocationContext ): self._SetLocationContext( location_context ) def CleanBeforeClose( self ): ManagementPanel.CleanBeforeClose( self ) if self._search_enabled: self._tag_autocomplete.CancelCurrentResultsFetchJob() self._query_job_key.Cancel() def CleanBeforeDestroy( self ): ManagementPanel.CleanBeforeDestroy( self ) if self._search_enabled: self._tag_autocomplete.CancelCurrentResultsFetchJob() self._query_job_key.Cancel() def GetPredicates( self ): if self._search_enabled: return self._tag_autocomplete.GetPredicates() else: return [] def PageHidden( self ): ManagementPanel.PageHidden( self ) if self._search_enabled: self._tag_autocomplete.SetForceDropdownHide( True ) def PageShown( self ): ManagementPanel.PageShown( self ) if self._search_enabled: self._tag_autocomplete.SetForceDropdownHide( False ) def PauseSearching( self ): if self._search_enabled: self._tag_autocomplete.SetSynchronised( False ) def RefreshQuery( self ): self._RefreshQuery() def SearchChanged( self, file_search_context: ClientSearch.FileSearchContext ): if self._search_enabled: file_search_context = self._tag_autocomplete.GetFileSearchContext() self._management_controller.SetVariable( 'file_search_context', file_search_context.Duplicate() ) location_context = file_search_context.GetLocationContext() self._SetLocationContext( location_context ) synchronised = self._tag_autocomplete.IsSynchronised() self._management_controller.SetVariable( 'synchronised', synchronised ) if synchronised: self._RefreshQuery() else: interrupting_current_search = not self._query_job_key.IsDone() if interrupting_current_search: self._CancelSearch() def SetSearchFocus( self ): if self._search_enabled: ClientGUIFunctions.SetFocusLater( self._tag_autocomplete ) def ShowFinishedQuery( self, query_job_key, media_results ): if query_job_key == self._query_job_key: location_context = self._management_controller.GetVariable( 'location_context' ) panel = ClientGUIResults.MediaPanelThumbnails( self._page, self._page_key, location_context, media_results ) panel.SetEmptyPageStatusOverride( 'no files found for this search' ) panel.Collect( self._page_key, self._media_collect.GetValue() ) panel.Sort( self._media_sort.GetSort() ) self._page.SwapMediaPanel( panel ) def Start( self ): file_search_context = self._management_controller.GetVariable( 'file_search_context' ) file_search_context.FixMissingServices( HG.client_controller.services_manager.FilterValidServiceKeys ) initial_predicates = file_search_context.GetPredicates() if len( initial_predicates ) > 0 and not file_search_context.IsComplete(): QP.CallAfter( self.RefreshQuery ) def THREADDoQuery( self, controller, page_key, query_job_key, file_search_context: ClientSearch.FileSearchContext, sort_by ): def qt_code(): query_job_key.Finish() if not self or not QP.isValid( self ): return self.ShowFinishedQuery( query_job_key, media_results ) QUERY_CHUNK_SIZE = 256 HG.client_controller.file_viewing_stats_manager.Flush() query_hash_ids = controller.Read( 'file_query_ids', file_search_context, job_key = query_job_key, limit_sort_by = sort_by ) if query_job_key.IsCancelled(): return media_results = [] for sub_query_hash_ids in HydrusData.SplitListIntoChunks( query_hash_ids, QUERY_CHUNK_SIZE ): if query_job_key.IsCancelled(): return more_media_results = controller.Read( 'media_results_from_ids', sub_query_hash_ids ) media_results.extend( more_media_results ) controller.pub( 'set_num_query_results', page_key, len( media_results ), len( query_hash_ids ) ) controller.WaitUntilViewFree() file_search_context.SetComplete() self._management_controller.SetVariable( 'file_search_context', file_search_context.Duplicate() ) QP.CallAfter( qt_code ) def REPEATINGPageUpdate( self ): self._UpdateCancelButton() management_panel_types_to_classes[ MANAGEMENT_TYPE_QUERY ] = ManagementPanelQuery