def EventShowMenu(self, event):
menu = wx.Menu()
seed_cache = self._seed_cache_get_callable()
num_seeds = len(seed_cache)
num_successful = seed_cache.GetSeedCount(
CC.STATUS_SUCCESSFUL_AND_NEW) + seed_cache.GetSeedCount(
CC.STATUS_SUCCESSFUL_BUT_REDUNDANT)
num_deleted_and_vetoed = seed_cache.GetSeedCount(
CC.STATUS_DELETED) + seed_cache.GetSeedCount(CC.STATUS_VETOED)
num_errors = seed_cache.GetSeedCount(CC.STATUS_ERROR)
num_skipped = seed_cache.GetSeedCount(CC.STATUS_SKIPPED)
if num_errors > 0:
ClientGUIMenus.AppendMenuItem(
self, menu,
'retry ' + HydrusData.ConvertIntToPrettyString(num_errors) +
' error failures',
'Tell this cache to reattempt all its error failures.',
self._RetryErrors)
if num_successful > 0:
num_deletees = num_successful
ClientGUIMenus.AppendMenuItem(
self, menu,
'delete ' + HydrusData.ConvertIntToPrettyString(num_deletees) +
' successful file import items from the queue',
'Tell this cache to clear out successful files, reducing the size of the queue.',
self._ClearSeeds, (CC.STATUS_SUCCESSFUL_AND_NEW,
CC.STATUS_SUCCESSFUL_BUT_REDUNDANT))
if num_deleted_and_vetoed > 0:
num_deletees = num_deleted_and_vetoed
ClientGUIMenus.AppendMenuItem(
self, menu,
'delete ' + HydrusData.ConvertIntToPrettyString(num_deletees) +
' deleted/ignored file import items from the queue',
'Tell this cache to clear out processed files, reducing the size of the queue.',
self._ClearSeeds, (CC.STATUS_DELETED, CC.STATUS_VETOED))
if num_errors + num_skipped > 0:
num_deletees = num_errors + num_skipped
ClientGUIMenus.AppendMenuItem(
self, menu,
'delete ' + HydrusData.ConvertIntToPrettyString(num_deletees) +
' error/skipped file import items from the queue',
'Tell this cache to clear out all non-unknown files, reducing the size of the queue.',
self._ClearSeeds, (CC.STATUS_ERROR, CC.STATUS_SKIPPED))
ClientGUIMenus.AppendSeparator(menu)
if len(seed_cache) > 0:
submenu = wx.Menu()
ClientGUIMenus.AppendMenuItem(
self, submenu, 'to clipboard',
'Copy all the sources in this list to the clipboard.',
self._ExportToClipboard)
ClientGUIMenus.AppendMenuItem(
self, submenu, 'to png',
'Export all the sources in this list to a png file.',
self._ExportToPng)
ClientGUIMenus.AppendMenu(menu, submenu, 'export all sources')
submenu = wx.Menu()
ClientGUIMenus.AppendMenuItem(
self, submenu, 'from clipboard',
'Import new urls or paths to this list from the clipboard.',
self._ImportFromClipboard)
ClientGUIMenus.AppendMenuItem(
self, submenu, 'from png',
'Import new urls or paths to this list from a png file.',
self._ImportFromPng)
ClientGUIMenus.AppendMenu(menu, submenu, 'import new sources')
HG.client_controller.PopupMenu(self, menu)
def Exit(self):
if HydrusGlobals.emergency_exit:
self.ShutdownView()
self.ShutdownModel()
else:
try:
self.CreateSplash()
idle_shutdown_action = self._options['idle_shutdown']
if idle_shutdown_action in (CC.IDLE_ON_SHUTDOWN,
CC.IDLE_ON_SHUTDOWN_ASK_FIRST):
if self.ThereIsIdleShutdownWorkDue():
if idle_shutdown_action == CC.IDLE_ON_SHUTDOWN_ASK_FIRST:
text = 'Is now a good time for the client to do up to ' + HydrusData.ConvertIntToPrettyString(
self._options['idle_shutdown_max_minutes']
) + ' minutes\' maintenance work?'
with ClientGUIDialogs.DialogYesNo(
self._splash, text,
title='Maintenance is due') as dlg_yn:
if dlg_yn.ShowModal() == wx.ID_YES:
HydrusGlobals.do_idle_shutdown_work = True
else:
HydrusGlobals.do_idle_shutdown_work = True
exit_thread = threading.Thread(
target=self.THREADExitEverything,
name='Application Exit Thread')
exit_thread.start()
except:
self.pub('splash_destroy')
HydrusData.DebugPrint(traceback.format_exc())
HydrusGlobals.emergency_exit = True
self.Exit()
def GetUnicode( self, with_count = True ):
count_text = u''
if with_count:
if self._min_current_count > 0:
number_text = HydrusData.ConvertIntToPrettyString( self._min_current_count )
if self._max_current_count is not None:
number_text += u'-' + HydrusData.ConvertIntToPrettyString( self._max_current_count )
count_text += u' (' + number_text + u')'
if self._min_pending_count > 0:
number_text = HydrusData.ConvertIntToPrettyString( self._min_pending_count )
if self._max_pending_count is not None:
number_text += u'-' + HydrusData.ConvertIntToPrettyString( self._max_pending_count )
count_text += u' (+' + number_text + u')'
if self._predicate_type in HC.SYSTEM_PREDICATES:
if self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_EVERYTHING: base = u'system:everything'
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_INBOX: base = u'system:inbox'
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_ARCHIVE: base = u'system:archive'
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_UNTAGGED: base = u'system:untagged'
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_LOCAL: base = u'system:local'
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_NOT_LOCAL: base = u'system:not local'
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_DIMENSIONS: base = u'system:dimensions'
elif self._predicate_type in ( HC.PREDICATE_TYPE_SYSTEM_NUM_TAGS, HC.PREDICATE_TYPE_SYSTEM_WIDTH, HC.PREDICATE_TYPE_SYSTEM_HEIGHT, HC.PREDICATE_TYPE_SYSTEM_NUM_WORDS ):
if self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_NUM_TAGS: base = u'system:number of tags'
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_WIDTH: base = u'system:width'
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_HEIGHT: base = u'system:height'
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_NUM_WORDS: base = u'system:number of words'
if self._value is not None:
( operator, value ) = self._value
base += u' ' + operator + u' ' + HydrusData.ConvertIntToPrettyString( value )
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_DURATION:
base = u'system:duration'
if self._value is not None:
( operator, value ) = self._value
base += u' ' + operator + u' ' + HydrusData.ConvertMillisecondsToPrettyTime( value )
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_RATIO:
base = u'system:ratio'
if self._value is not None:
( operator, ratio_width, ratio_height ) = self._value
base += u' ' + operator + u' ' + str( ratio_width ) + u':' + str( ratio_height )
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_SIZE:
base = u'system:size'
if self._value is not None:
( operator, size, unit ) = self._value
base += u' ' + operator + u' ' + str( size ) + HydrusData.ConvertIntToUnit( unit )
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_LIMIT:
base = u'system:limit'
if self._value is not None:
value = self._value
base += u' is ' + HydrusData.ConvertIntToPrettyString( value )
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_AGE:
base = u'system:age'
if self._value is not None:
( operator, years, months, days, hours ) = self._value
base += u' ' + operator + u' ' + str( years ) + u'y' + str( months ) + u'm' + str( days ) + u'd' + str( hours ) + u'h'
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_NUM_PIXELS:
base = u'system:num_pixels'
if self._value is not None:
( operator, num_pixels, unit ) = self._value
base += u' ' + operator + u' ' + str( num_pixels ) + ' ' + HydrusData.ConvertIntToPixels( unit )
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_HASH:
base = u'system:hash'
if self._value is not None:
( hash, hash_type ) = self._value
base = u'system:' + hash_type + ' hash is ' + hash.encode( 'hex' )
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_MIME:
base = u'system:mime'
if self._value is not None:
mimes = self._value
if set( mimes ) == set( HC.SEARCHABLE_MIMES ):
mime_text = 'anything'
elif set( mimes ) == set( HC.SEARCHABLE_MIMES ).intersection( set( HC.APPLICATIONS ) ):
mime_text = 'application'
elif set( mimes ) == set( HC.SEARCHABLE_MIMES ).intersection( set( HC.AUDIO ) ):
mime_text = 'audio'
elif set( mimes ) == set( HC.SEARCHABLE_MIMES ).intersection( set( HC.IMAGES ) ):
mime_text = 'image'
elif set( mimes ) == set( HC.SEARCHABLE_MIMES ).intersection( set( HC.VIDEO ) ):
mime_text = 'video'
else:
mime_text = ', '.join( [ HC.mime_string_lookup[ mime ] for mime in mimes ] )
base += u' is ' + mime_text
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_RATING:
base = u'system:rating'
if self._value is not None:
( operator, value, service_key ) = self._value
service = HydrusGlobals.client_controller.GetServicesManager().GetService( service_key )
base += u' for ' + service.GetName() + u' ' + operator + u' ' + HydrusData.ToUnicode( value )
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_SIMILAR_TO:
base = u'system:similar to'
if self._value is not None:
( hash, max_hamming ) = self._value
base += u' ' + hash.encode( 'hex' ) + u' using max hamming of ' + str( max_hamming )
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_FILE_SERVICE:
base = u'system:'
if self._value is None:
base += 'file service'
else:
( operator, current_or_pending, service_key ) = self._value
if operator == True: base += u'is'
else: base += u'is not'
if current_or_pending == HC.PENDING: base += u' pending to '
else: base += u' currently in '
service = HydrusGlobals.client_controller.GetServicesManager().GetService( service_key )
base += service.GetName()
base += count_text
elif self._predicate_type == HC.PREDICATE_TYPE_TAG:
tag = self._value
if not self._inclusive: base = u'-'
else: base = u''
base += HydrusTags.RenderTag( tag )
base += count_text
siblings_manager = HydrusGlobals.client_controller.GetManager( 'tag_siblings' )
sibling = siblings_manager.GetSibling( tag )
if sibling is not None: base += u' (will display as ' + HydrusTags.RenderTag( sibling ) + ')'
elif self._predicate_type == HC.PREDICATE_TYPE_PARENT:
base = ' '
tag = self._value
base += HydrusTags.RenderTag( tag )
base += count_text
elif self._predicate_type == HC.PREDICATE_TYPE_NAMESPACE:
namespace = self._value
if not self._inclusive: base = u'-'
else: base = u''
base += namespace + u':*anything*'
elif self._predicate_type == HC.PREDICATE_TYPE_WILDCARD:
wildcard = self._value
if not self._inclusive: base = u'-'
else: base = u''
base += HydrusTags.RenderTag( wildcard )
return base
def EventShowMenu(self, event):
menu = wx.Menu()
seed_cache = self._seed_cache_get_callable()
num_failures = seed_cache.GetSeedCount(CC.STATUS_FAILED)
if num_failures > 0:
ClientGUIMenus.AppendMenuItem(
self, menu,
'retry ' + HydrusData.ConvertIntToPrettyString(num_failures) +
' failures', 'Tell this cache to reattempt all its failures.',
self._RetryFailures)
num_unknown = seed_cache.GetSeedCount(CC.STATUS_UNKNOWN)
num_successful = seed_cache.GetSeedCount(
CC.STATUS_SUCCESSFUL) + seed_cache.GetSeedCount(
CC.STATUS_REDUNDANT)
if num_successful > 0:
ClientGUIMenus.AppendMenuItem(
self, menu, 'delete ' +
HydrusData.ConvertIntToPrettyString(num_successful) +
' \'successful\' file imports from the queue',
'Tell this cache to clear out successful/already in db files, reducing the size of the queue.',
self._ClearSuccessful)
num_processed = len(seed_cache) - num_unknown
if num_processed > 0 and num_processed != num_successful:
ClientGUIMenus.AppendMenuItem(
self, menu, 'delete ' +
HydrusData.ConvertIntToPrettyString(num_processed) +
' \'processed\' file imports from the queue',
'Tell this cache to clear out processed files, reducing the size of the queue.',
self._ClearProcessed)
ClientGUIMenus.AppendSeparator(menu)
if len(seed_cache) > 0:
submenu = wx.Menu()
ClientGUIMenus.AppendMenuItem(
self, submenu, 'to clipboard',
'Copy all the sources in this list to the clipboard.',
self._ExportToClipboard)
ClientGUIMenus.AppendMenuItem(
self, submenu, 'to png',
'Export all the sources in this list to a png file.',
self._ExportToPng)
ClientGUIMenus.AppendMenu(menu, submenu, 'export all sources')
submenu = wx.Menu()
ClientGUIMenus.AppendMenuItem(
self, submenu, 'from clipboard',
'Import new urls or paths to this list from the clipboard.',
self._ImportFromClipboard)
ClientGUIMenus.AppendMenuItem(
self, submenu, 'from png',
'Import new urls or paths to this list from a png file.',
self._ImportFromPng)
ClientGUIMenus.AppendMenu(menu, submenu, 'import new sources')
HG.client_controller.PopupMenu(self, menu)
def SetNamespaces(self, namespaces):
self._service_keys_to_checkbox_info = {}
self._service_keys_to_explicit_button_info = {}
self._button_ids_to_service_keys = {}
self._vbox.Clear(True)
services = HydrusGlobals.client_controller.GetServicesManager(
).GetServices(HC.TAG_SERVICES, randomised=False)
button_id = 1
if len(services) > 0:
outer_gridbox = wx.FlexGridSizer(0, 2)
outer_gridbox.AddGrowableCol(1, 1)
for service in services:
service_key = service.GetServiceKey()
self._service_keys_to_checkbox_info[service_key] = []
outer_gridbox.AddF(
wx.StaticText(self, label=service.GetName()),
CC.FLAGS_VCENTER)
vbox = wx.BoxSizer(wx.VERTICAL)
for namespace in namespaces:
if namespace == '': label = 'no namespace'
else: label = namespace
namespace_checkbox = wx.CheckBox(self, label=label)
namespace_checkbox.Bind(wx.EVT_CHECKBOX, self.EventChecked)
self._service_keys_to_checkbox_info[service_key].append(
(namespace, namespace_checkbox))
vbox.AddF(namespace_checkbox,
CC.FLAGS_EXPAND_PERPENDICULAR)
explicit_tags = set()
button_label = HydrusData.ConvertIntToPrettyString(
len(explicit_tags)) + ' explicit tags'
explicit_button = wx.Button(self,
label=button_label,
id=button_id)
explicit_button.Bind(wx.EVT_BUTTON, self.EventExplicitTags)
self._service_keys_to_explicit_button_info[service_key] = (
explicit_tags, explicit_button)
self._button_ids_to_service_keys[button_id] = service_key
button_id += 1
vbox.AddF(explicit_button, CC.FLAGS_VCENTER)
outer_gridbox.AddF(vbox, CC.FLAGS_EXPAND_SIZER_BOTH_WAYS)
self._vbox.AddF(outer_gridbox, CC.FLAGS_EXPAND_SIZER_BOTH_WAYS)
def do_it():
job_key = ClientThreading.JobKey(pausable=True, cancellable=True)
job_key.SetVariable('popup_title',
self._service.GetName() + ': immediate sync')
job_key.SetVariable('popup_text_1', 'downloading')
self._controller.pub('message', job_key)
content_update_package = self._service.Request(
HC.GET, 'immediate_content_update_package')
c_u_p_num_rows = content_update_package.GetNumRows()
c_u_p_total_weight_processed = 0
update_speed_string = ''
content_update_index_string = 'content row ' + HydrusData.ConvertValueRangeToPrettyString(
c_u_p_total_weight_processed, c_u_p_num_rows) + ': '
job_key.SetVariable(
'popup_text_1', content_update_index_string + 'committing' +
update_speed_string)
job_key.SetVariable('popup_gauge_1',
(c_u_p_total_weight_processed, c_u_p_num_rows))
for (content_updates, weight
) in content_update_package.IterateContentUpdateChunks():
(i_paused, should_quit) = job_key.WaitIfNeeded()
if should_quit:
job_key.Delete()
return
content_update_index_string = 'content row ' + HydrusData.ConvertValueRangeToPrettyString(
c_u_p_total_weight_processed, c_u_p_num_rows) + ': '
job_key.SetVariable(
'popup_text_1', content_update_index_string +
'committing' + update_speed_string)
job_key.SetVariable(
'popup_gauge_1',
(c_u_p_total_weight_processed, c_u_p_num_rows))
precise_timestamp = HydrusData.GetNowPrecise()
self._controller.WriteSynchronous(
'content_updates', {self._service_key: content_updates})
it_took = HydrusData.GetNowPrecise() - precise_timestamp
rows_s = weight / it_took
update_speed_string = ' at ' + HydrusData.ConvertIntToPrettyString(
rows_s) + ' rows/s'
c_u_p_total_weight_processed += weight
job_key.DeleteVariable('popup_gauge_1')
self._service.SyncThumbnails(job_key)
job_key.SetVariable(
'popup_text_1', 'done! ' +
HydrusData.ConvertIntToPrettyString(c_u_p_num_rows) +
' rows added.')
job_key.Finish()
def DoWork(self):
if HydrusData.TimeHasPassed(self._last_checked + self._period):
folder_path = HydrusData.ToUnicode(self._path)
if folder_path != '' and os.path.exists(
folder_path) and os.path.isdir(folder_path):
query_hash_ids = HG.client_controller.Read(
'file_query_ids', self._file_search_context)
media_results = []
i = 0
base = 256
while i < len(query_hash_ids):
if HC.options[
'pause_export_folders_sync'] or HydrusThreading.IsThreadShuttingDown(
):
return
if i == 0: (last_i, i) = (0, base)
else: (last_i, i) = (i, i + base)
sub_query_hash_ids = query_hash_ids[last_i:i]
more_media_results = HG.client_controller.Read(
'media_results_from_ids', sub_query_hash_ids)
media_results.extend(more_media_results)
#
terms = ParseExportPhrase(self._phrase)
previous_filenames = set(os.listdir(folder_path))
sync_filenames = set()
client_files_manager = HG.client_controller.client_files_manager
num_copied = 0
for media_result in media_results:
if HC.options[
'pause_export_folders_sync'] or HydrusThreading.IsThreadShuttingDown(
):
return
hash = media_result.GetHash()
mime = media_result.GetMime()
size = media_result.GetSize()
source_path = client_files_manager.GetFilePath(hash, mime)
filename = GenerateExportFilename(folder_path,
media_result, terms)
dest_path = os.path.join(folder_path, filename)
if filename not in sync_filenames:
copied = HydrusPaths.MirrorFile(source_path, dest_path)
if copied:
num_copied += 1
try:
os.chmod(dest_path,
stat.S_IWRITE | stat.S_IREAD)
except:
pass
sync_filenames.add(filename)
if num_copied > 0:
HydrusData.Print(
'Export folder ' + self._name + ' exported ' +
HydrusData.ConvertIntToPrettyString(num_copied) +
' files.')
if self._export_type == HC.EXPORT_FOLDER_TYPE_SYNCHRONISE:
deletee_filenames = previous_filenames.difference(
sync_filenames)
for deletee_filename in deletee_filenames:
deletee_path = os.path.join(folder_path,
deletee_filename)
ClientPaths.DeletePath(deletee_path)
if len(deletee_filenames) > 0:
HydrusData.Print('Export folder ' + self._name +
' deleted ' +
HydrusData.ConvertIntToPrettyString(
len(deletee_filenames)) +
' files.')
self._last_checked = HydrusData.GetNow()
HG.client_controller.WriteSynchronous('serialisable', self)
def DAEMONDownloadFiles(controller):
hashes = controller.Read('downloads')
num_downloads = len(hashes)
if num_downloads > 0:
client_files_manager = controller.client_files_manager
successful_hashes = set()
job_key = ClientThreading.JobKey()
job_key.SetVariable('popup_text_1', 'initialising downloader')
controller.pub('message', job_key)
for hash in hashes:
job_key.SetVariable(
'popup_text_1', 'downloading ' +
HydrusData.ConvertIntToPrettyString(num_downloads -
len(successful_hashes)) +
' files from repositories')
(media_result, ) = controller.Read('media_results', (hash, ))
service_keys = list(
media_result.GetLocationsManager().GetCurrent())
random.shuffle(service_keys)
for service_key in service_keys:
if service_key == CC.LOCAL_FILE_SERVICE_KEY: break
elif service_key == CC.TRASH_SERVICE_KEY: continue
try:
service = controller.services_manager.GetService(
service_key)
except:
continue
if service.GetServiceType() == HC.FILE_REPOSITORY:
file_repository = service
if file_repository.IsFunctional():
try:
(os_file_handle,
temp_path) = HydrusPaths.GetTempPath()
try:
file_repository.Request(HC.GET,
'file', {'hash': hash},
temp_path=temp_path)
controller.WaitUntilModelFree()
exclude_deleted = False # this is the important part here
allow_decompression_bombs = True
min_size = None
max_size = None
max_gif_size = None
min_resolution = None
max_resolution = None
automatic_archive = False
file_import_options = ClientImporting.FileImportOptions(
)
file_import_options.SetPreImportOptions(
exclude_deleted, allow_decompression_bombs,
min_size, max_size, max_gif_size,
min_resolution, max_resolution)
file_import_options.SetPostImportOptions(
automatic_archive)
file_import_job = ClientImporting.FileImportJob(
temp_path, file_import_options)
client_files_manager.ImportFile(
file_import_job)
successful_hashes.add(hash)
break
finally:
HydrusPaths.CleanUpTempPath(
os_file_handle, temp_path)
except HydrusExceptions.ServerBusyException:
job_key.SetVariable(
'popup_text_1',
file_repository.GetName() +
' was busy. waiting 30s before trying again')
time.sleep(30)
job_key.Delete()
controller.pub('notify_new_downloads')
return
except Exception as e:
HydrusData.ShowText('Error downloading file!')
HydrusData.ShowException(e)
elif service.GetServiceType() == HC.IPFS:
multihashes = HG.client_controller.Read(
'service_filenames', service_key, {hash})
if len(multihashes) > 0:
multihash = multihashes[0]
# this actually calls to a thread that can launch gui 'select from tree' stuff, so let's just break at this point
service.ImportFile(multihash)
break
if HydrusThreading.IsThreadShuttingDown():
return
if len(successful_hashes) > 0:
job_key.SetVariable(
'popup_text_1',
HydrusData.ConvertIntToPrettyString(len(successful_hashes)) +
' files downloaded')
job_key.Delete()
def SetNumMessages( self, num_messages_pending ):
self._text.SetLabelText( HydrusData.ConvertIntToPrettyString( num_messages_pending ) + ' more messages' )
def DAEMONDownloadFiles(controller):
hashes = controller.Read('downloads')
num_downloads = len(hashes)
if num_downloads > 0:
successful_hashes = set()
job_key = ClientThreading.JobKey()
job_key.SetVariable('popup_text_1', 'initialising downloader')
controller.pub('message', job_key)
for hash in hashes:
job_key.SetVariable(
'popup_text_1', 'downloading ' +
HydrusData.ConvertIntToPrettyString(num_downloads -
len(successful_hashes)) +
' files from repositories')
(media_result, ) = controller.Read('media_results', (hash, ))
service_keys = list(
media_result.GetLocationsManager().GetCurrent())
random.shuffle(service_keys)
for service_key in service_keys:
if service_key == CC.LOCAL_FILE_SERVICE_KEY: break
elif service_key == CC.TRASH_SERVICE_KEY: continue
try:
file_repository = controller.GetServicesManager(
).GetService(service_key)
except:
continue
if file_repository.CanDownload():
try:
request_args = {'hash': hash.encode('hex')}
(os_file_handle, temp_path) = HydrusPaths.GetTempPath()
try:
file_repository.Request(HC.GET,
'file',
request_args=request_args,
temp_path=temp_path)
controller.WaitUntilPubSubsEmpty()
controller.WriteSynchronous('import_file',
temp_path,
override_deleted=True)
successful_hashes.add(hash)
break
finally:
HydrusPaths.CleanUpTempPath(
os_file_handle, temp_path)
except HydrusExceptions.ServerBusyException:
job_key.SetVariable(
'popup_text_1',
file_repository.GetName() +
' was busy. waiting 30s before trying again')
time.sleep(30)
job_key.Delete()
controller.pub('notify_new_downloads')
return
except Exception as e:
HydrusData.ShowText('Error downloading file!')
HydrusData.ShowException(e)
if HydrusThreading.IsThreadShuttingDown():
return
if len(successful_hashes) > 0:
job_key.SetVariable(
'popup_text_1',
HydrusData.ConvertIntToPrettyString(len(successful_hashes)) +
' files downloaded')
else:
job_key.SetVariable('popup_text_1', 'all files failed to download')
job_key.Delete()
def Update( self ):
paused = self._job_key.IsPaused()
title = self._job_key.GetIfHasVariable( 'popup_title' )
if title is not None:
text = title
if self._title.GetLabelText() != text: self._title.SetLabelText( text )
self._title.Show()
else:
self._title.Hide()
popup_text_1 = self._job_key.GetIfHasVariable( 'popup_text_1' )
if popup_text_1 is not None or paused:
if paused:
text = 'paused'
else:
text = popup_text_1
if self._text_1.GetLabelText() != text:
self._text_1.SetLabelText( self._ProcessText( HydrusData.ToUnicode( text ) ) )
self._text_1.Show()
else:
self._text_1.Hide()
popup_gauge_1 = self._job_key.GetIfHasVariable( 'popup_gauge_1' )
if popup_gauge_1 is not None and not paused:
( gauge_value, gauge_range ) = popup_gauge_1
self._gauge_1.SetRange( gauge_range )
self._gauge_1.SetValue( gauge_value )
self._gauge_1.Show()
else:
self._gauge_1.Hide()
popup_text_2 = self._job_key.GetIfHasVariable( 'popup_text_2' )
if popup_text_2 is not None and not paused:
text = popup_text_2
if self._text_2.GetLabelText() != text:
self._text_2.SetLabelText( self._ProcessText( HydrusData.ToUnicode( text ) ) )
self._text_2.Show()
else:
self._text_2.Hide()
popup_gauge_2 = self._job_key.GetIfHasVariable( 'popup_gauge_2' )
if popup_gauge_2 is not None and not paused:
( gauge_value, gauge_range ) = popup_gauge_2
self._gauge_2.SetRange( gauge_range )
self._gauge_2.SetValue( gauge_value )
self._gauge_2.Show()
else:
self._gauge_2.Hide()
popup_yes_no_question = self._job_key.GetIfHasVariable( 'popup_yes_no_question' )
if popup_yes_no_question is not None and not paused:
text = popup_yes_no_question
# set and show text, yes, no buttons
if self._text_yes_no.GetLabelText() != text:
self._text_yes_no.SetLabelText( self._ProcessText( HydrusData.ToUnicode( text ) ) )
self._text_yes_no.Show()
self._yes.Show()
self._no.Show()
else:
self._text_yes_no.Hide()
self._yes.Hide()
self._no.Hide()
popup_network_job = self._job_key.GetIfHasVariable( 'popup_network_job' )
if popup_network_job is not None:
self._network_job_ctrl.SetNetworkJob( popup_network_job )
self._network_job_ctrl.Show()
else:
self._network_job_ctrl.ClearNetworkJob()
self._network_job_ctrl.Hide()
popup_clipboard = self._job_key.GetIfHasVariable( 'popup_clipboard' )
if popup_clipboard is not None:
( title, text ) = popup_clipboard
if self._copy_to_clipboard_button.GetLabelText() != title:
self._copy_to_clipboard_button.SetLabelText( title )
self._copy_to_clipboard_button.Show()
else:
self._copy_to_clipboard_button.Hide()
result = self._job_key.GetIfHasVariable( 'popup_files' )
if result is not None:
( popup_files, popup_files_name ) = result
hashes = popup_files
text = popup_files_name + ' - show ' + HydrusData.ConvertIntToPrettyString( len( hashes ) ) + ' files'
if self._show_files_button.GetLabelText() != text:
self._show_files_button.SetLabelText( text )
self._show_files_button.Show()
else:
self._show_files_button.Hide()
popup_traceback = self._job_key.GetIfHasVariable( 'popup_traceback' )
if popup_traceback is not None:
self._copy_tb_button.Show()
else:
self._copy_tb_button.Hide()
if popup_traceback is not None:
text = popup_traceback
if self._tb_text.GetLabelText() != text:
self._tb_text.SetLabelText( self._ProcessText( HydrusData.ToUnicode( text ) ) )
self._show_tb_button.Show()
else:
self._show_tb_button.Hide()
self._tb_text.Hide()
if self._job_key.IsPausable():
self._pause_button.Show()
else:
self._pause_button.Hide()
if self._job_key.IsCancellable():
self._cancel_button.Show()
else:
self._cancel_button.Hide()
def ToPrettyMultilineString(self):
pretty_strings = []
for (name, attrs, index) in self._tag_rules:
s = ''
if index is None:
s += 'get every'
else:
num = index + 1
s += 'get the ' + HydrusData.ConvertIntToPrettyOrdinalString(
num)
s += ' <' + name + '> tag'
if len(attrs) > 0:
s += ' with attributes ' + ', '.join(
key + '=' + value for (key, value) in attrs.items())
pretty_strings.append(s)
if self._content_rule is None:
pretty_strings.append('get the text content of those tags')
else:
pretty_strings.append('get the ' + self._content_rule +
' attribute of those tags')
cull_munge_strings = []
(cull_front, cull_back, prepend, append) = self._culling_and_adding
if cull_front > 0:
cull_munge_strings.append(
'the first ' +
HydrusData.ConvertIntToPrettyString(cull_front) +
' characters')
elif cull_front < 0:
cull_munge_strings.append(
'all but the last ' +
HydrusData.ConvertIntToPrettyString(abs(cull_front)) +
' characters')
if cull_back > 0:
cull_munge_strings.append(
'the last ' + HydrusData.ConvertIntToPrettyString(cull_back) +
' characters')
elif cull_back < 0:
cull_munge_strings.append(
'all but the first ' +
HydrusData.ConvertIntToPrettyString(abs(cull_back)) +
' characters')
if len(cull_munge_strings) > 0:
pretty_strings.append('remove ' + ' and '.join(cull_munge_strings))
add_munge_strings = []
if prepend != '':
add_munge_strings.append('prepend "' + prepend + '"')
if append != '':
add_munge_strings.append('append "' + append + '"')
if len(add_munge_strings) > 0:
pretty_strings.append(' and '.join(add_munge_strings))
separator = os.linesep + 'and then '
pretty_multiline_string = separator.join(pretty_strings)
return pretty_multiline_string
def Exit(self):
if HG.emergency_exit:
self.ShutdownView()
self.ShutdownModel()
HydrusData.CleanRunningFile(self.db_dir, 'client')
else:
try:
idle_shutdown_action = self.options['idle_shutdown']
if idle_shutdown_action in (CC.IDLE_ON_SHUTDOWN,
CC.IDLE_ON_SHUTDOWN_ASK_FIRST):
idle_shutdown_max_minutes = self.options[
'idle_shutdown_max_minutes']
time_to_stop = HydrusData.GetNow() + (
idle_shutdown_max_minutes * 60)
if self.ThereIsIdleShutdownWorkDue(time_to_stop):
if idle_shutdown_action == CC.IDLE_ON_SHUTDOWN_ASK_FIRST:
text = 'Is now a good time for the client to do up to ' + HydrusData.ConvertIntToPrettyString(
idle_shutdown_max_minutes
) + ' minutes\' maintenance work? (Will auto-no in 15 seconds)'
with ClientGUIDialogs.DialogYesNo(
self._splash, text,
title='Maintenance is due') as dlg_yn:
job = self.CallLaterWXSafe(
dlg_yn, 15, dlg_yn.EndModal, wx.ID_NO)
try:
if dlg_yn.ShowModal() == wx.ID_YES:
HG.do_idle_shutdown_work = True
finally:
job.Cancel()
else:
HG.do_idle_shutdown_work = True
self.CallToThreadLongRunning(self.THREADExitEverything)
except:
self._DestroySplash()
HydrusData.DebugPrint(traceback.format_exc())
HG.emergency_exit = True
self.Exit()
def GetUnicode(self,
with_count=True,
sibling_service_key=None,
render_for_user=False):
count_text = u''
if with_count:
if self._min_current_count > 0:
number_text = HydrusData.ConvertIntToPrettyString(
self._min_current_count)
if self._max_current_count is not None:
number_text += u'-' + HydrusData.ConvertIntToPrettyString(
self._max_current_count)
count_text += u' (' + number_text + u')'
if self._min_pending_count > 0:
number_text = HydrusData.ConvertIntToPrettyString(
self._min_pending_count)
if self._max_pending_count is not None:
number_text += u'-' + HydrusData.ConvertIntToPrettyString(
self._max_pending_count)
count_text += u' (+' + number_text + u')'
if self._predicate_type in HC.SYSTEM_PREDICATES:
if self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_EVERYTHING:
base = u'everything'
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_INBOX:
base = u'inbox'
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_ARCHIVE:
base = u'archive'
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_UNTAGGED:
base = u'untagged'
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_LOCAL:
base = u'local'
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_NOT_LOCAL:
base = u'not local'
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_DIMENSIONS:
base = u'dimensions'
elif self._predicate_type in (HC.PREDICATE_TYPE_SYSTEM_NUM_TAGS,
HC.PREDICATE_TYPE_SYSTEM_WIDTH,
HC.PREDICATE_TYPE_SYSTEM_HEIGHT,
HC.PREDICATE_TYPE_SYSTEM_NUM_WORDS):
if self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_NUM_TAGS:
base = u'number of tags'
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_WIDTH:
base = u'width'
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_HEIGHT:
base = u'height'
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_NUM_WORDS:
base = u'number of words'
if self._value is not None:
(operator, value) = self._value
base += u' ' + operator + u' ' + HydrusData.ConvertIntToPrettyString(
value)
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_DURATION:
base = u'duration'
if self._value is not None:
(operator, value) = self._value
base += u' ' + operator + u' ' + HydrusData.ConvertMillisecondsToPrettyTime(
value)
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_RATIO:
base = u'ratio'
if self._value is not None:
(operator, ratio_width, ratio_height) = self._value
base += u' ' + operator + u' ' + str(
ratio_width) + u':' + str(ratio_height)
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_SIZE:
base = u'size'
if self._value is not None:
(operator, size, unit) = self._value
base += u' ' + operator + u' ' + str(
size) + HydrusData.ConvertIntToUnit(unit)
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_LIMIT:
base = u'limit'
if self._value is not None:
value = self._value
base += u' is ' + HydrusData.ConvertIntToPrettyString(
value)
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_AGE:
base = u'age'
if self._value is not None:
(operator, years, months, days, hours) = self._value
base += u' ' + operator + u' ' + str(years) + u'y' + str(
months) + u'm' + str(days) + u'd' + str(hours) + u'h'
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_NUM_PIXELS:
base = u'num_pixels'
if self._value is not None:
(operator, num_pixels, unit) = self._value
base += u' ' + operator + u' ' + str(
num_pixels) + ' ' + HydrusData.ConvertIntToPixels(unit)
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_HASH:
base = u'hash'
if self._value is not None:
(hash, hash_type) = self._value
base = hash_type + ' hash is ' + hash.encode('hex')
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_MIME:
base = u'mime'
if self._value is not None:
mimes = self._value
if set(mimes) == set(HC.SEARCHABLE_MIMES):
mime_text = 'anything'
elif set(mimes) == set(HC.SEARCHABLE_MIMES).intersection(
set(HC.APPLICATIONS)):
mime_text = 'application'
elif set(mimes) == set(HC.SEARCHABLE_MIMES).intersection(
set(HC.AUDIO)):
mime_text = 'audio'
elif set(mimes) == set(HC.SEARCHABLE_MIMES).intersection(
set(HC.IMAGES)):
mime_text = 'image'
elif set(mimes) == set(HC.SEARCHABLE_MIMES).intersection(
set(HC.VIDEO)):
mime_text = 'video'
else:
mime_text = ', '.join(
[HC.mime_string_lookup[mime] for mime in mimes])
base += u' is ' + mime_text
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_RATING:
base = u'rating'
if self._value is not None:
(operator, value, service_key) = self._value
service = HG.client_controller.services_manager.GetService(
service_key)
service_type = service.GetServiceType()
pretty_value = HydrusData.ToUnicode(value)
if service_type == HC.LOCAL_RATING_LIKE:
if value == 0:
pretty_value = 'dislike'
elif value == 1:
pretty_value = 'like'
elif service_type == HC.LOCAL_RATING_NUMERICAL:
if isinstance(value, float):
allow_zero = service.AllowZero()
num_stars = service.GetNumStars()
if allow_zero:
star_range = num_stars
else:
star_range = num_stars - 1
pretty_x = int(round(value * star_range))
pretty_y = num_stars
if not allow_zero:
pretty_x += 1
pretty_value = HydrusData.ConvertValueRangeToPrettyString(
pretty_x, pretty_y)
base += u' for ' + service.GetName(
) + u' ' + operator + u' ' + pretty_value
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_SIMILAR_TO:
base = u'similar to'
if self._value is not None:
(hash, max_hamming) = self._value
base += u' ' + hash.encode(
'hex') + u' using max hamming of ' + str(max_hamming)
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_FILE_SERVICE:
if self._value is None:
base = 'file service'
else:
(operator, current_or_pending, service_key) = self._value
if operator == True: base = u'is'
else: base = u'is not'
if current_or_pending == HC.CONTENT_STATUS_PENDING:
base += u' pending to '
else:
base += u' currently in '
service = HG.client_controller.services_manager.GetService(
service_key)
base += service.GetName()
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_TAG_AS_NUMBER:
if self._value is None:
base = 'tag as number'
else:
(namespace, operator, num) = self._value
if namespace == '':
n_text = 'tag'
else:
n_text = namespace
if operator == u'\u2248':
o_text = ' about '
elif operator == '<':
o_text = ' less than '
elif operator == '>':
o_text = ' more than '
base = n_text + o_text + HydrusData.ConvertIntToPrettyString(
num)
elif self._predicate_type == HC.PREDICATE_TYPE_SYSTEM_DUPLICATE_RELATIONSHIPS:
base = 'num duplicate relationships'
if self._value is not None:
(operator, num_relationships, dupe_type) = self._value
if operator == u'\u2248':
o_text = ' about '
elif operator == '<':
o_text = ' less than '
elif operator == '>':
o_text = ' more than '
elif operator == '=':
o_text = ' '
base += u' - has' + o_text + HydrusData.ConvertIntToPrettyString(
num_relationships
) + u' ' + HC.duplicate_type_string_lookup[dupe_type]
base = HydrusTags.CombineTag('system', base)
base = ClientTags.RenderTag(base, render_for_user)
base += count_text
elif self._predicate_type == HC.PREDICATE_TYPE_TAG:
tag = self._value
if not self._inclusive: base = u'-'
else: base = u''
base += ClientTags.RenderTag(tag, render_for_user)
base += count_text
if sibling_service_key is not None:
siblings_manager = HG.client_controller.GetManager(
'tag_siblings')
sibling = siblings_manager.GetSibling(sibling_service_key, tag)
if sibling is not None:
sibling = ClientTags.RenderTag(sibling, render_for_user)
base += u' (will display as ' + sibling + ')'
elif self._predicate_type == HC.PREDICATE_TYPE_PARENT:
base = ' '
tag = self._value
base += ClientTags.RenderTag(tag, render_for_user)
base += count_text
elif self._predicate_type == HC.PREDICATE_TYPE_NAMESPACE:
namespace = self._value
if not self._inclusive: base = u'-'
else: base = u''
anything_tag = HydrusTags.CombineTag(namespace, '*anything*')
anything_tag = ClientTags.RenderTag(anything_tag, render_for_user)
base += anything_tag
elif self._predicate_type == HC.PREDICATE_TYPE_WILDCARD:
wildcard = self._value
if not self._inclusive: base = u'-'
else: base = u''
base += wildcard
return base
def Test(self, text):
text_len = len(text)
presentation_text = '"' + text + '"'
if self._min_chars is not None and text_len < self._min_chars:
raise HydrusExceptions.StringMatchException(
presentation_text + ' had fewer than ' +
HydrusData.ConvertIntToPrettyString(self._min_chars) +
' characters')
if self._max_chars is not None and text_len > self._max_chars:
raise HydrusExceptions.StringMatchException(
presentation_text + ' had more than ' +
HydrusData.ConvertIntToPrettyString(self._max_chars) +
' characters')
if self._match_type == STRING_MATCH_FIXED:
if text != self._match_value:
raise HydrusExceptions.StringMatchException(
presentation_text + ' did not exactly match "' +
self._match_value + '"')
elif self._match_type in (STRING_MATCH_FLEXIBLE, STRING_MATCH_REGEX):
if self._match_type == STRING_MATCH_FLEXIBLE:
if self._match_value == ALPHA:
r = '^[a-zA-Z]+$'
fail_reason = ' had non-alpha characters'
elif self._match_value == ALPHANUMERIC:
r = '^[a-zA-Z\d]+$'
fail_reason = ' had non-alphanumeric characters'
elif self._match_value == NUMERIC:
r = '^\d+$'
fail_reason = ' had non-numeric characters'
elif self._match_type == STRING_MATCH_REGEX:
r = self._match_value
fail_reason = ' did not match "' + r + '"'
if re.search(r, text, flags=re.UNICODE) is None:
raise HydrusExceptions.StringMatchException(presentation_text +
fail_reason)
elif self._match_type == STRING_MATCH_ANY:
pass
