import collections import os import time import traceback 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 HydrusPaths from hydrus.core import HydrusTags from hydrus.client import ClientConstants as CC from hydrus.client import ClientExporting from hydrus.client import ClientLocation from hydrus.client import ClientSearch from hydrus.client import ClientThreading from hydrus.client.gui import ClientGUIDialogsQuick from hydrus.client.gui import ClientGUIFunctions from hydrus.client.gui import ClientGUIScrolledPanels from hydrus.client.gui import ClientGUITags from hydrus.client.gui import ClientGUITime from hydrus.client.gui import ClientGUITopLevelWindowsPanels from hydrus.client.gui import QtPorting as QP 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.search import ClientGUIACDropdown from hydrus.client.gui.widgets import ClientGUICommon from hydrus.client.metadata import ClientTags class EditExportFoldersPanel( ClientGUIScrolledPanels.EditPanel ): def __init__( self, parent, export_folders ): ClientGUIScrolledPanels.EditPanel.__init__( self, parent ) self._export_folders_panel = ClientGUIListCtrl.BetterListCtrlPanel( self ) self._export_folders = ClientGUIListCtrl.BetterListCtrl( self._export_folders_panel, CGLC.COLUMN_LIST_EXPORT_FOLDERS.ID, 6, self._ConvertExportFolderToListCtrlTuples, use_simple_delete = True, activation_callback = self._Edit ) self._export_folders_panel.SetListCtrl( self._export_folders ) self._export_folders_panel.AddButton( 'add', self._AddFolder ) self._export_folders_panel.AddButton( 'edit', self._Edit, enabled_only_on_selection = True ) self._export_folders_panel.AddDeleteButton() # self._export_folders.AddDatas( export_folders ) self._export_folders.Sort() vbox = QP.VBoxLayout() intro = 'Here you can set the client to regularly export a certain query to a particular location.' QP.AddToLayout( vbox, ClientGUICommon.BetterStaticText(self,intro), CC.FLAGS_EXPAND_PERPENDICULAR ) QP.AddToLayout( vbox, self._export_folders_panel, CC.FLAGS_EXPAND_BOTH_WAYS ) self.widget().setLayout( vbox ) def _AddFolder( self ): new_options = HG.client_controller.new_options phrase = new_options.GetString( 'export_phrase' ) name = 'export folder' path = '' export_type = HC.EXPORT_FOLDER_TYPE_REGULAR delete_from_client_after_export = False default_location_context = HG.client_controller.new_options.GetDefaultLocalLocationContext() file_search_context = ClientSearch.FileSearchContext( location_context = default_location_context ) period = 15 * 60 export_folder = ClientExporting.ExportFolder( name, path, export_type = export_type, delete_from_client_after_export = delete_from_client_after_export, file_search_context = file_search_context, period = period, phrase = phrase ) with ClientGUITopLevelWindowsPanels.DialogEdit( self, 'edit export folder' ) as dlg: panel = EditExportFolderPanel( dlg, export_folder ) dlg.SetPanel( panel ) if dlg.exec() == QW.QDialog.Accepted: export_folder = panel.GetValue() export_folder.SetNonDupeName( self._GetExistingNames() ) self._export_folders.AddDatas( ( export_folder, ) ) def _ConvertExportFolderToListCtrlTuples( self, export_folder: ClientExporting.ExportFolder ): ( name, path, export_type, delete_from_client_after_export, file_search_context, run_regularly, period, phrase, last_checked, paused, run_now ) = export_folder.ToTuple() if export_type == HC.EXPORT_FOLDER_TYPE_REGULAR: pretty_export_type = 'regular' elif export_type == HC.EXPORT_FOLDER_TYPE_SYNCHRONISE: pretty_export_type = 'synchronise' if delete_from_client_after_export: pretty_export_type += ' and deleting from the client!' pretty_file_search_context = ', '.join( predicate.ToString( with_count = False ) for predicate in file_search_context.GetPredicates() ) if run_regularly: pretty_period = HydrusData.TimeDeltaToPrettyTimeDelta( period ) else: pretty_period = 'not running regularly' if run_now: pretty_period += ' (running after dialog ok)' if paused: pretty_paused = 'yes' else: pretty_paused = '' pretty_phrase = phrase last_error = export_folder.GetLastError() display_tuple = ( name, path, pretty_export_type, pretty_file_search_context, pretty_paused, pretty_period, pretty_phrase, last_error ) sort_tuple = ( name, path, pretty_export_type, pretty_file_search_context, paused, period, phrase, last_error ) return ( display_tuple, sort_tuple ) def _Edit( self ): export_folders = self._export_folders.GetData( only_selected = True ) edited_datas = [] for export_folder in export_folders: with ClientGUITopLevelWindowsPanels.DialogEdit( self, 'edit export folder' ) as dlg: panel = EditExportFolderPanel( dlg, export_folder ) dlg.SetPanel( panel ) if dlg.exec() == QW.QDialog.Accepted: edited_export_folder = panel.GetValue() self._export_folders.DeleteDatas( ( export_folder, ) ) edited_export_folder.SetNonDupeName( self._GetExistingNames() ) self._export_folders.AddDatas( ( edited_export_folder, ) ) edited_datas.append( edited_export_folder ) else: return self._export_folders.SelectDatas( edited_datas ) def _GetExistingNames( self ): existing_names = { export_folder.GetName() for export_folder in self._export_folders.GetData() } return existing_names def GetValue( self ): export_folders = self._export_folders.GetData() return export_folders class EditExportFolderPanel( ClientGUIScrolledPanels.EditPanel ): def __init__( self, parent, export_folder: ClientExporting.ExportFolder ): ClientGUIScrolledPanels.EditPanel.__init__( self, parent ) self._export_folder = export_folder ( name, path, export_type, delete_from_client_after_export, file_search_context, run_regularly, period, phrase, self._last_checked, paused, run_now ) = self._export_folder.ToTuple() self._path_box = ClientGUICommon.StaticBox( self, 'name and location' ) self._name = QW.QLineEdit( self._path_box ) self._path = QP.DirPickerCtrl( self._path_box ) # self._type_box = ClientGUICommon.StaticBox( self, 'type of export' ) self._type = ClientGUICommon.BetterChoice( self._type_box ) self._type.addItem( 'regular', HC.EXPORT_FOLDER_TYPE_REGULAR ) self._type.addItem( 'synchronise', HC.EXPORT_FOLDER_TYPE_SYNCHRONISE ) self._delete_from_client_after_export = QW.QCheckBox( self._type_box ) # self._query_box = ClientGUICommon.StaticBox( self, 'query to export' ) self._page_key = 'export folders placeholder' self._tag_autocomplete = ClientGUIACDropdown.AutoCompleteDropdownTagsRead( self._query_box, self._page_key, file_search_context, allow_all_known_files = False, force_system_everything = True ) # self._period_box = ClientGUICommon.StaticBox( self, 'export period' ) self._period = ClientGUITime.TimeDeltaButton( self._period_box, min = 3 * 60, days = True, hours = True, minutes = True ) self._run_regularly = QW.QCheckBox( self._period_box ) self._paused = QW.QCheckBox( self._period_box ) self._run_now = QW.QCheckBox( self._period_box ) # self._phrase_box = ClientGUICommon.StaticBox( self, 'filenames' ) self._pattern = QW.QLineEdit( self._phrase_box ) self._examples = ClientGUICommon.ExportPatternButton( self._phrase_box ) # self._name.setText( name ) self._path.SetPath( path ) self._type.SetValue( export_type ) self._delete_from_client_after_export.setChecked( delete_from_client_after_export ) self._period.SetValue( period ) self._run_regularly.setChecked( run_regularly ) self._paused.setChecked( paused ) self._run_now.setChecked( run_now ) self._pattern.setText( phrase ) # rows = [] rows.append( ( 'name: ', self._name ) ) rows.append( ( 'folder path: ', self._path ) ) gridbox = ClientGUICommon.WrapInGrid( self._path_box, rows ) self._path_box.Add( gridbox, CC.FLAGS_EXPAND_SIZER_PERPENDICULAR ) # text = '''regular - try to export the files to the directory, overwriting if the filesize if different synchronise - try to export the files to the directory, overwriting if the filesize if different, and delete anything else in the directory If you select synchronise, be careful!''' st = ClientGUICommon.BetterStaticText( self._type_box, label = text ) st.setWordWrap( True ) self._type_box.Add( st, CC.FLAGS_EXPAND_PERPENDICULAR ) self._type_box.Add( self._type, CC.FLAGS_EXPAND_PERPENDICULAR ) rows = [] rows.append( ( 'delete files from client after export: ', self._delete_from_client_after_export ) ) gridbox = ClientGUICommon.WrapInGrid( self._type_box, rows ) self._type_box.Add( gridbox, CC.FLAGS_EXPAND_SIZER_PERPENDICULAR ) self._query_box.Add( self._tag_autocomplete ) self._period_box.Add( self._period, CC.FLAGS_EXPAND_PERPENDICULAR ) rows = [] rows.append( ( 'run regularly?: ', self._run_regularly ) ) rows.append( ( 'paused: ', self._paused ) ) rows.append( ( 'run on dialog ok: ', self._run_now ) ) gridbox = ClientGUICommon.WrapInGrid( self._period_box, rows ) self._period_box.Add( gridbox, CC.FLAGS_EXPAND_SIZER_PERPENDICULAR ) phrase_hbox = QP.HBoxLayout() QP.AddToLayout( phrase_hbox, self._pattern, CC.FLAGS_EXPAND_BOTH_WAYS ) QP.AddToLayout( phrase_hbox, self._examples, CC.FLAGS_CENTER_PERPENDICULAR ) self._phrase_box.Add( phrase_hbox, CC.FLAGS_EXPAND_SIZER_PERPENDICULAR ) vbox = QP.VBoxLayout() QP.AddToLayout( vbox, self._path_box, CC.FLAGS_EXPAND_PERPENDICULAR ) QP.AddToLayout( vbox, self._type_box, CC.FLAGS_EXPAND_PERPENDICULAR ) QP.AddToLayout( vbox, self._query_box, CC.FLAGS_EXPAND_BOTH_WAYS ) QP.AddToLayout( vbox, self._period_box, CC.FLAGS_EXPAND_PERPENDICULAR ) QP.AddToLayout( vbox, self._phrase_box, CC.FLAGS_EXPAND_PERPENDICULAR ) self.widget().setLayout( vbox ) self._UpdateTypeDeleteUI() self._type.currentIndexChanged.connect( self._UpdateTypeDeleteUI ) self._delete_from_client_after_export.clicked.connect( self.EventDeleteFilesAfterExport ) def _UpdateTypeDeleteUI( self ): if self._type.GetValue() == HC.EXPORT_FOLDER_TYPE_SYNCHRONISE: self._delete_from_client_after_export.setEnabled( False ) if self._delete_from_client_after_export.isChecked(): self._delete_from_client_after_export.setChecked( False ) else: self._delete_from_client_after_export.setEnabled( True ) def UserIsOKToOK( self ): if self._delete_from_client_after_export.isChecked(): message = 'You have set this export folder to delete the files from the client after export! Are you absolutely sure this is what you want?' result = ClientGUIDialogsQuick.GetYesNo( self, message ) if result != QW.QDialog.Accepted: return False return True def EventDeleteFilesAfterExport( self ): if self._delete_from_client_after_export.isChecked(): QW.QMessageBox.warning( self, 'Warning', 'This will delete the exported files from your client after the export! If you do not know what this means, uncheck it!' ) def GetValue( self ): name = self._name.text() path = self._path.GetPath() export_type = self._type.GetValue() delete_from_client_after_export = self._delete_from_client_after_export.isChecked() file_search_context = self._tag_autocomplete.GetFileSearchContext() run_regularly = self._run_regularly.isChecked() period = self._period.GetValue() if self._path.GetPath() in ( '', None ): raise HydrusExceptions.VetoException( 'You must enter a folder path to export to!' ) phrase = self._pattern.text() try: ClientExporting.ParseExportPhrase( phrase ) except Exception as e: raise HydrusExceptions.VetoException( 'Could not parse that export phrase! ' + str( e ) ) run_now = self._run_now.isChecked() paused = self._paused.isChecked() last_error = self._export_folder.GetLastError() export_folder = ClientExporting.ExportFolder( name, path = path, export_type = export_type, delete_from_client_after_export = delete_from_client_after_export, file_search_context = file_search_context, run_regularly = run_regularly, period = period, phrase = phrase, last_checked = self._last_checked, paused = paused, run_now = run_now, last_error = last_error ) return export_folder class EditSidecarExporterPanel( ClientGUIScrolledPanels.EditPanel ): def __init__( self, parent, sidecar_exporter: ClientExporting.SidecarExporter ): ClientGUIScrolledPanels.EditPanel.__init__( self, parent ) self._service_keys_to_tag_data = dict( sidecar_exporter.GetTagData() ) # # ok, I guess a multi-column list of services, then tag filter and display type options # open it, you make a new edit panel type # add (with test for remaining services), edit, delete # # populate that lad # vbox = QP.VBoxLayout() #QP.AddToLayout( vbox, self._tag_data_listctrl, CC.FLAGS_EXPAND_PERPENDICULAR ) self.widget().setLayout( vbox ) def GetValue( self ): sidecar_exporter = ClientExporting.SidecarExporter( service_keys_to_tag_data = self._service_keys_to_tag_data ) return sidecar_exporter class EditSidecarExporterTagDataPanel( ClientGUIScrolledPanels.EditPanel ): def __init__( self, parent, tag_filter: HydrusTags.TagFilter, tag_display_type: int ): ClientGUIScrolledPanels.EditPanel.__init__( self, parent ) # message = 'Filter the tags you want to export here. Anything that passes this filter is exported.' self._tag_filter = ClientGUITags.TagFilterButton( self, message, tag_filter ) self._tag_display_type = ClientGUICommon.BetterChoice( self ) self._tag_display_type.addItem( 'with siblings and parents applied', ClientTags.TAG_DISPLAY_ACTUAL ) self._tag_display_type.addItem( 'as the tags are actually stored', ClientTags.TAG_DISPLAY_STORAGE ) # self._tag_display_type.SetValue( tag_display_type ) # vbox = QP.VBoxLayout() rows = [] rows.append( ( 'Tags to export: ', self._tag_filter ) ) rows.append( ( 'Type to export: ', self._tag_display_type ) ) gridbox = ClientGUICommon.WrapInGrid( self, rows ) QP.AddToLayout( vbox, gridbox, CC.FLAGS_EXPAND_SIZER_PERPENDICULAR ) self.widget().setLayout( vbox ) def GetValue( self ): tag_filter = self._tag_filter.GetValue() tag_display_type = self._tag_display_type.GetValue() return ( tag_filter, tag_display_type ) class ReviewExportFilesPanel( ClientGUIScrolledPanels.ReviewPanel ): def __init__( self, parent, flat_media, do_export_and_then_quit = False ): ClientGUIScrolledPanels.ReviewPanel.__init__( self, parent ) new_options = HG.client_controller.new_options self._media_to_paths = {} self._existing_filenames = set() self._last_phrase_used = '' self._last_dir_used = '' self._tags_box = ClientGUIListBoxes.StaticBoxSorterForListBoxTags( self, 'files\' tags' ) services_manager = HG.client_controller.services_manager self._neighbouring_txt_tag_service_keys = services_manager.FilterValidServiceKeys( new_options.GetKeyList( 'default_neighbouring_txt_tag_service_keys' ) ) t = ClientGUIListBoxes.ListBoxTagsMedia( self._tags_box, ClientTags.TAG_DISPLAY_ACTUAL, include_counts = True ) self._tags_box.SetTagsBox( t ) self._tags_box.setMinimumSize( QC.QSize( 220, 300 ) ) self._paths = ClientGUIListCtrl.BetterListCtrl( self, CGLC.COLUMN_LIST_EXPORT_FILES.ID, 24, self._ConvertDataToListCtrlTuples, use_simple_delete = True ) self._paths.Sort() self._export_path_box = ClientGUICommon.StaticBox( self, 'export path' ) self._directory_picker = QP.DirPickerCtrl( self._export_path_box ) self._directory_picker.dirPickerChanged.connect( self._RefreshPaths ) self._open_location = QW.QPushButton( 'open this location', self._export_path_box ) self._open_location.clicked.connect( self.EventOpenLocation ) self._filenames_box = ClientGUICommon.StaticBox( self, 'filenames' ) self._pattern = QW.QLineEdit( self._filenames_box ) self._update = QW.QPushButton( 'update', self._filenames_box ) self._update.clicked.connect( self._RefreshPaths ) self._examples = ClientGUICommon.ExportPatternButton( self._filenames_box ) self._delete_files_after_export = QW.QCheckBox( 'delete files from client after export?', self ) self._delete_files_after_export.setObjectName( 'HydrusWarning' ) self._export_symlinks = QW.QCheckBox( 'EXPERIMENTAL: export symlinks', self ) self._export_symlinks.setObjectName( 'HydrusWarning' ) text = 'This will export all the files\' tags, newline separated, into .txts beside the files themselves.' self._export_tag_txts_services_button = ClientGUICommon.BetterButton( self, 'set .txt services', self._SetTxtServices ) self._export_tag_txts = QW.QCheckBox( 'export tags to .txt files?', self ) self._export_tag_txts.setToolTip( text ) self._export_tag_txts.clicked.connect( self.EventExportTagTxtsChanged ) self._export = QW.QPushButton( 'export', self ) self._export.clicked.connect( self._DoExport ) # export_path = ClientExporting.GetExportPath() if export_path is not None: self._directory_picker.SetPath( export_path ) phrase = new_options.GetString( 'export_phrase' ) self._pattern.setText( phrase ) if len( self._neighbouring_txt_tag_service_keys ) > 0: self._export_tag_txts.setChecked( True ) self._paths.SetData( list( enumerate( flat_media ) ) ) self._delete_files_after_export.setChecked( HG.client_controller.new_options.GetBoolean( 'delete_files_after_export' ) ) self._delete_files_after_export.clicked.connect( self.EventDeleteFilesChanged ) if not HG.client_controller.new_options.GetBoolean( 'advanced_mode' ): self._export_symlinks.setVisible( False ) # top_hbox = QP.HBoxLayout() QP.AddToLayout( top_hbox, self._tags_box, CC.FLAGS_EXPAND_PERPENDICULAR ) QP.AddToLayout( top_hbox, self._paths, CC.FLAGS_EXPAND_BOTH_WAYS ) hbox = QP.HBoxLayout() QP.AddToLayout( hbox, self._directory_picker, CC.FLAGS_EXPAND_BOTH_WAYS ) QP.AddToLayout( hbox, self._open_location, CC.FLAGS_CENTER_PERPENDICULAR ) self._export_path_box.Add( hbox, CC.FLAGS_EXPAND_SIZER_PERPENDICULAR ) hbox = QP.HBoxLayout() QP.AddToLayout( hbox, self._pattern, CC.FLAGS_EXPAND_BOTH_WAYS ) QP.AddToLayout( hbox, self._update, CC.FLAGS_CENTER_PERPENDICULAR ) QP.AddToLayout( hbox, self._examples, CC.FLAGS_CENTER_PERPENDICULAR ) self._filenames_box.Add( hbox, CC.FLAGS_EXPAND_SIZER_PERPENDICULAR ) txt_hbox = QP.HBoxLayout() QP.AddToLayout( txt_hbox, self._export_tag_txts_services_button, CC.FLAGS_CENTER_PERPENDICULAR ) QP.AddToLayout( txt_hbox, self._export_tag_txts, CC.FLAGS_CENTER_PERPENDICULAR ) vbox = QP.VBoxLayout() QP.AddToLayout( vbox, top_hbox, CC.FLAGS_EXPAND_SIZER_BOTH_WAYS ) QP.AddToLayout( vbox, self._export_path_box, CC.FLAGS_EXPAND_PERPENDICULAR ) QP.AddToLayout( vbox, self._filenames_box, CC.FLAGS_EXPAND_PERPENDICULAR ) QP.AddToLayout( vbox, self._delete_files_after_export, CC.FLAGS_ON_RIGHT ) QP.AddToLayout( vbox, self._export_symlinks, CC.FLAGS_ON_RIGHT ) QP.AddToLayout( vbox, txt_hbox, CC.FLAGS_ON_RIGHT ) QP.AddToLayout( vbox, self._export, CC.FLAGS_ON_RIGHT ) self.widget().setLayout( vbox ) self._RefreshTags() self._UpdateTxtButton() ClientGUIFunctions.SetFocusLater( self._export ) self._paths.itemSelectionChanged.connect( self._RefreshTags ) if do_export_and_then_quit: HG.client_controller.CallAfterQtSafe( self, 'doing export before dialog quit', self._DoExport, True ) def _ConvertDataToListCtrlTuples( self, data ): directory = self._directory_picker.GetPath() ( ordering_index, media ) = data number = ordering_index mime = media.GetMime() try: path = self._GetPath( media ) except Exception as e: path = str( e ) pretty_number = HydrusData.ToHumanInt( ordering_index + 1 ) pretty_mime = HC.mime_string_lookup[ mime ] pretty_path = path if not path.startswith( directory ): pretty_path = 'INVALID, above destination directory: ' + path display_tuple = ( pretty_number, pretty_mime, pretty_path ) sort_tuple = ( number, pretty_mime, path ) return ( display_tuple, sort_tuple ) def _DoExport( self, quit_afterwards = False ): delete_afterwards = self._delete_files_after_export.isChecked() export_symlinks = self._export_symlinks.isChecked() and not delete_afterwards if quit_afterwards: message = 'Export as shown?' if delete_afterwards: message += os.linesep * 2 message += 'THE FILES WILL BE DELETED FROM THE CLIENT AFTERWARDS' result = ClientGUIDialogsQuick.GetYesNo( self, message ) if result != QW.QDialog.Accepted: self.parentWidget().close() return elif delete_afterwards: message = 'THE FILES WILL BE DELETED FROM THE CLIENT AFTERWARDS' result = ClientGUIDialogsQuick.GetYesNo( self, message ) if result != QW.QDialog.Accepted: return self._RefreshPaths() export_tag_txts = self._export_tag_txts.isChecked() if self._export_tag_txts.isChecked(): neighbouring_txt_tag_service_keys = self._neighbouring_txt_tag_service_keys else: neighbouring_txt_tag_service_keys = [] directory = self._directory_picker.GetPath() HydrusPaths.MakeSureDirectoryExists( directory ) pattern = self._pattern.text() HG.client_controller.new_options.SetString( 'export_phrase', pattern ) try: terms = ClientExporting.ParseExportPhrase( pattern ) except Exception as e: QW.QMessageBox.critical( self, 'Error', str(e) ) return client_files_manager = HG.client_controller.client_files_manager self._export.setEnabled( False ) to_do = self._paths.GetData() to_do = [ ( ordering_index, media, self._GetPath( media ) ) for ( ordering_index, media ) in to_do ] num_to_do = len( to_do ) def qt_update_label( text ): if not QP.isValid( self ) or not QP.isValid( self._export ) or not self._export: return self._export.setText( text ) def qt_done( quit_afterwards ): if not QP.isValid( self ) or not QP.isValid( self._export ) or not self._export: return self._export.setEnabled( True ) if quit_afterwards: QP.CallAfter( self.parentWidget().close ) def do_it( directory, neighbouring_txt_tag_service_keys, delete_afterwards, export_symlinks, quit_afterwards ): job_key = ClientThreading.JobKey( cancellable = True ) job_key.SetStatusTitle( 'file export' ) HG.client_controller.pub( 'message', job_key ) pauser = HydrusData.BigJobPauser() for ( index, ( ordering_index, media, path ) ) in enumerate( to_do ): if job_key.IsCancelled(): break try: x_of_y = HydrusData.ConvertValueRangeToPrettyString( index + 1, num_to_do ) job_key.SetVariable( 'popup_text_1', 'Done {}'.format( x_of_y ) ) job_key.SetVariable( 'popup_gauge_1', ( index + 1, num_to_do ) ) QP.CallAfter( qt_update_label, x_of_y ) hash = media.GetHash() mime = media.GetMime() path = os.path.normpath( path ) if not path.startswith( directory ): raise Exception( 'It seems a destination path was above the main export directory! The file was "{}" and its destination path was "{}".'.format( hash.hex(), path ) ) path_dir = os.path.dirname( path ) HydrusPaths.MakeSureDirectoryExists( path_dir ) if export_tag_txts: tags_manager = media.GetTagsManager() tags = set() for service_key in neighbouring_txt_tag_service_keys: current_tags = tags_manager.GetCurrent( service_key, ClientTags.TAG_DISPLAY_ACTUAL ) tags.update( current_tags ) tags = sorted( tags ) txt_path = path + '.txt' with open( txt_path, 'w', encoding = 'utf-8' ) as f: f.write( '\n'.join( tags ) ) source_path = client_files_manager.GetFilePath( hash, mime, check_file_exists = False ) if export_symlinks: os.symlink( source_path, path ) else: HydrusPaths.MirrorFile( source_path, path ) HydrusPaths.TryToGiveFileNicePermissionBits( path ) except: QP.CallAfter( QW.QMessageBox.information, self, 'Information', 'Encountered a problem while attempting to export file with index '+str(ordering_index+1)+':'+os.linesep*2+traceback.format_exc() ) break pauser.Pause() if not job_key.IsCancelled() and delete_afterwards: QP.CallAfter( qt_update_label, 'deleting' ) delete_lock_for_archived_files = HG.client_controller.new_options.GetBoolean( 'delete_lock_for_archived_files' ) if delete_lock_for_archived_files: deletee_medias = { media for ( ordering_index, media, path ) in to_do if not media.HasArchive() } else: deletee_medias = { media for ( ordering_index, media, path ) in to_do } chunks_of_deletee_medias = HydrusData.SplitListIntoChunks( list( deletee_medias ), 64 ) for chunk_of_deletee_medias in chunks_of_deletee_medias: reason = 'Deleted after manual export to "{}".'.format( directory ) service_keys_to_hashes = collections.defaultdict( set ) for media in chunk_of_deletee_medias: for service_key in media.GetLocationsManager().GetCurrent(): service_keys_to_hashes[ service_key ].add( media.GetHash() ) for service_key in ClientLocation.ValidLocalDomainsFilter( service_keys_to_hashes.keys() ): content_update = HydrusData.ContentUpdate( HC.CONTENT_TYPE_FILES, HC.CONTENT_UPDATE_DELETE, service_keys_to_hashes[ service_key ], reason = reason ) HG.client_controller.WriteSynchronous( 'content_updates', { service_key : [ content_update ] } ) job_key.DeleteVariable( 'popup_gauge_1' ) job_key.SetVariable( 'popup_text_1', 'Done!' ) job_key.Finish() job_key.Delete( 5 ) QP.CallAfter( qt_update_label, 'done!' ) time.sleep( 1 ) QP.CallAfter( qt_update_label, 'export' ) QP.CallAfter( qt_done, quit_afterwards ) HG.client_controller.CallToThread( do_it, directory, neighbouring_txt_tag_service_keys, delete_afterwards, export_symlinks, quit_afterwards ) def _GetPath( self, media ): if media in self._media_to_paths: return self._media_to_paths[ media ] directory = self._directory_picker.GetPath() pattern = self._pattern.text() terms = ClientExporting.ParseExportPhrase( pattern ) filename = ClientExporting.GenerateExportFilename( directory, media, terms, do_not_use_filenames = self._existing_filenames ) path = os.path.join( directory, filename ) path = os.path.normpath( path ) self._existing_filenames.add( filename ) self._media_to_paths[ media ] = path return path def _RefreshPaths( self ): pattern = self._pattern.text() dir_path = self._directory_picker.GetPath() if pattern == self._last_phrase_used and dir_path == self._last_dir_used: return self._last_phrase_used = pattern self._last_dir_used = dir_path HG.client_controller.new_options.SetString( 'export_phrase', pattern ) self._existing_filenames = set() self._media_to_paths = {} self._paths.UpdateDatas() def _RefreshTags( self ): data = self._paths.GetData( only_selected = True ) if len( data ) == 0: data = self._paths.GetData() all_media = [ media for ( ordering_index, media ) in data ] self._tags_box.SetTagsByMedia( all_media ) def _SetTxtServices( self ): services_manager = HG.client_controller.services_manager tag_services = services_manager.GetServices( HC.REAL_TAG_SERVICES ) choice_tuples = [ ( service.GetName(), service.GetServiceKey(), service.GetServiceKey() in self._neighbouring_txt_tag_service_keys ) for service in tag_services ] try: neighbouring_txt_tag_service_keys = ClientGUIDialogsQuick.SelectMultipleFromList( self, 'select tag services', choice_tuples ) except HydrusExceptions.CancelledException: return self._neighbouring_txt_tag_service_keys = neighbouring_txt_tag_service_keys HG.client_controller.new_options.SetKeyList( 'default_neighbouring_txt_tag_service_keys', self._neighbouring_txt_tag_service_keys ) if len( self._neighbouring_txt_tag_service_keys ) == 0: self._export_tag_txts.setChecked( False ) self._UpdateTxtButton() def _UpdateTxtButton( self ): if self._export_tag_txts.isChecked(): self._export_tag_txts_services_button.setEnabled( True ) else: self._export_tag_txts_services_button.setEnabled( False ) if len( self._neighbouring_txt_tag_service_keys ) == 0: tt = 'No services set.' else: names = [ HG.client_controller.services_manager.GetName( service_key ) for service_key in self._neighbouring_txt_tag_service_keys ] tt = ', '.join( names ) self._export_tag_txts_services_button.setToolTip( tt ) def EventExport( self, event ): self._DoExport() def EventDeleteFilesChanged( self ): value = self._delete_files_after_export.isChecked() HG.client_controller.new_options.SetBoolean( 'delete_files_after_export', value ) if value: self._export_symlinks.setChecked( False ) def EventExportTagTxtsChanged( self ): turning_on = self._export_tag_txts.isChecked() self._UpdateTxtButton() if turning_on: self._SetTxtServices() else: HG.client_controller.new_options.SetKeyList( 'default_neighbouring_txt_tag_service_keys', [] ) def EventOpenLocation( self ): directory = self._directory_picker.GetPath() if directory is not None and directory != '': HydrusPaths.LaunchDirectory( directory )