import bisect import collections import ClientConstants as CC import ClientData import ClientFiles import ClientRatings import ClientSearch import ClientTags import HydrusConstants as HC import HydrusTags import os import random import time import traceback import wx import HydrusData import HydrusFileHandling import HydrusExceptions import HydrusGlobals as HG import HydrusSerialisable import itertools def FlattenMedia( media_list ): flat_media = [] for media in media_list: if media.IsCollection(): flat_media.extend( media.GetFlatMedia() ) else: flat_media.append( media ) return flat_media def GetDuplicateComparisonStatements( shown_media, comparison_media ): statements = [] score = 0 # size s_size = shown_media.GetSize() c_size = comparison_media.GetSize() size_ratio = float( s_size ) / float( c_size ) if size_ratio > 2.0: statements.append( 'This has a much larger filesize.' ) score += 2 elif size_ratio > 1.05: statements.append( 'This has a larger filesize.' ) score += 0.5 elif size_ratio < 0.5: statements.append( 'This has a much smaller filesize.' ) score -= 2 elif size_ratio < 0.95: statements.append( 'This has a smaller filesize.' ) score -= 0.5 # higher/same res s_resolution = shown_media.GetResolution() c_resolution = comparison_media.GetResolution() if s_resolution is not None and c_resolution is not None: ( s_w, s_h ) = shown_media.GetResolution() ( c_w, c_h ) = comparison_media.GetResolution() resolution_ratio = float( s_w * s_h ) / float( c_w * c_h ) if resolution_ratio == 1.0: if s_resolution != c_resolution: statements.append( 'The files have the same number of pixels but different resolution.' ) elif resolution_ratio > 2.0: statements.append( 'This has much higher resolution.' ) score += 2 elif resolution_ratio > 1.0: statements.append( 'This has higher resolution.' ) score += 1 elif resolution_ratio < 0.5: statements.append( 'This has much lower resolution.' ) score -= 2 elif resolution_ratio < 1.0: statements.append( 'This has lower resolution.' ) score -= 1 # same/diff mime s_mime = shown_media.GetMime() c_mime = comparison_media.GetMime() if s_mime != c_mime: statements.append( 'This is ' + HC.mime_string_lookup[ s_mime ] + ', the other is ' + HC.mime_string_lookup[ c_mime ] + '.' ) # more tags s_num_tags = len( shown_media.GetTagsManager().GetCurrent() ) c_num_tags = len( comparison_media.GetTagsManager().GetCurrent() ) if s_num_tags > 0 and c_num_tags > 0: if s_num_tags > c_num_tags: statements.append( 'This has more tags.' ) score += 1 elif s_num_tags < c_num_tags: statements.append( 'This has fewer tags.' ) score += 1 elif s_num_tags > 0: statements.append( 'This has tags, the other does not.' ) elif c_num_tags > 0: statements.append( 'This has no tags, the other does.' ) # older s_ts = shown_media.GetLocationsManager().GetTimestamp( CC.COMBINED_LOCAL_FILE_SERVICE_KEY ) c_ts = comparison_media.GetLocationsManager().GetTimestamp( CC.COMBINED_LOCAL_FILE_SERVICE_KEY ) if s_ts is not None and c_ts is not None: if s_ts < c_ts - 86400 * 30: statements.append( 'This is older.' ) score += 0.5 elif c_ts < s_ts - 86400 * 30: statements.append( 'This is newer.' ) score -= 0.5 return ( statements, score ) def MergeTagsManagers( tags_managers ): def CurrentAndPendingFilter( items ): for ( service_key, statuses_to_tags ) in items: filtered = { status : tags for ( status, tags ) in statuses_to_tags.items() if status in ( HC.CONTENT_STATUS_CURRENT, HC.CONTENT_STATUS_PENDING ) } yield ( service_key, filtered ) # [[( service_key, statuses_to_tags )]] s_k_s_t_t_tupled = ( CurrentAndPendingFilter( tags_manager.GetServiceKeysToStatusesToTags().items() ) for tags_manager in tags_managers ) # [(service_key, statuses_to_tags)] flattened_s_k_s_t_t = itertools.chain.from_iterable( s_k_s_t_t_tupled ) # service_key : [ statuses_to_tags ] s_k_s_t_t_dict = HydrusData.BuildKeyToListDict( flattened_s_k_s_t_t ) # now let's merge so we have service_key : statuses_to_tags merged_service_keys_to_statuses_to_tags = collections.defaultdict( HydrusData.default_dict_set ) for ( service_key, several_statuses_to_tags ) in s_k_s_t_t_dict.items(): # [[( status, tags )]] s_t_t_tupled = ( s_t_t.items() for s_t_t in several_statuses_to_tags ) # [( status, tags )] flattened_s_t_t = itertools.chain.from_iterable( s_t_t_tupled ) statuses_to_tags = HydrusData.default_dict_set() for ( status, tags ) in flattened_s_t_t: statuses_to_tags[ status ].update( tags ) merged_service_keys_to_statuses_to_tags[ service_key ] = statuses_to_tags return TagsManager( merged_service_keys_to_statuses_to_tags ) class DuplicatesManager( object ): def __init__( self, service_keys_to_dupe_statuses_to_counts ): self._service_keys_to_dupe_statuses_to_counts = service_keys_to_dupe_statuses_to_counts def Duplicate( self ): service_keys_to_dupe_statuses_to_counts = collections.defaultdict( collections.Counter ) return DuplicatesManager( service_keys_to_dupe_statuses_to_counts ) def GetDupeStatusesToCounts( self, service_key ): return self._service_keys_to_dupe_statuses_to_counts[ service_key ] class FileInfoManager( object ): def __init__( self, hash, size = None, mime = None, width = None, height = None, duration = None, num_frames = None, num_words = None ): if mime is None: mime = HC.APPLICATION_UNKNOWN self.hash = hash self.size = size self.mime = mime self.width = width self.height = height self.duration = duration self.num_frames = num_frames self.num_words = num_words def Duplicate( self ): return FileInfoManager( self.hash, self.size, self.mime, self.width, self.height, self.duration, self.num_frames, self.num_words ) def ToTuple( self ): return ( self.hash, self.size, self.mime, self.width, self.height, self.duration, self.num_frames, self.num_words ) class LocationsManager( object ): LOCAL_LOCATIONS = { CC.LOCAL_FILE_SERVICE_KEY, CC.TRASH_SERVICE_KEY, CC.COMBINED_LOCAL_FILE_SERVICE_KEY } def __init__( self, current, deleted, pending, petitioned, inbox = False, urls = None, service_keys_to_filenames = None, current_to_timestamps = None ): self._current = current self._deleted = deleted self._pending = pending self._petitioned = petitioned self._inbox = inbox if urls is None: urls = set() self._urls = urls if service_keys_to_filenames is None: service_keys_to_filenames = {} self._service_keys_to_filenames = service_keys_to_filenames if current_to_timestamps is None: current_to_timestamps = {} self._current_to_timestamps = current_to_timestamps def DeletePending( self, service_key ): self._pending.discard( service_key ) self._petitioned.discard( service_key ) def Duplicate( self ): current = set( self._current ) deleted = set( self._deleted ) pending = set( self._pending ) petitioned = set( self._petitioned ) urls = set( self._urls ) service_keys_to_filenames = dict( self._service_keys_to_filenames ) current_to_timestamps = dict( self._current_to_timestamps ) return LocationsManager( current, deleted, pending, petitioned, self._inbox, urls, service_keys_to_filenames, current_to_timestamps ) def GetCDPP( self ): return ( self._current, self._deleted, self._pending, self._petitioned ) def GetCurrent( self ): return self._current def GetCurrentRemote( self ): return self._current - self.LOCAL_LOCATIONS def GetDeleted( self ): return self._deleted def GetDeletedRemote( self ): return self._deleted - self.LOCAL_LOCATIONS def GetInbox( self ): return self._inbox def GetPending( self ): return self._pending def GetPendingRemote( self ): return self._pending - self.LOCAL_LOCATIONS def GetPetitioned( self ): return self._petitioned def GetPetitionedRemote( self ): return self._petitioned - self.LOCAL_LOCATIONS def GetRemoteLocationStrings( self ): current = self.GetCurrentRemote() pending = self.GetPendingRemote() petitioned = self.GetPetitionedRemote() remote_services = HG.client_controller.services_manager.GetServices( ( HC.FILE_REPOSITORY, HC.IPFS ) ) remote_services = list( remote_services ) def key( s ): return s.GetName() remote_services.sort( key = key ) remote_service_strings = [] for remote_service in remote_services: name = remote_service.GetName() service_key = remote_service.GetServiceKey() if service_key in pending: remote_service_strings.append( name + ' (+)' ) elif service_key in current: if service_key in petitioned: remote_service_strings.append( name + ' (-)' ) else: remote_service_strings.append( name ) return remote_service_strings def GetTimestamp( self, service_key ): if service_key in self._current_to_timestamps: return self._current_to_timestamps[ service_key ] else: return None def GetURLs( self ): return self._urls def IsDownloading( self ): return CC.COMBINED_LOCAL_FILE_SERVICE_KEY in self._pending def IsLocal( self ): return CC.COMBINED_LOCAL_FILE_SERVICE_KEY in self._current def IsRemote( self ): return CC.COMBINED_LOCAL_FILE_SERVICE_KEY not in self._current def IsTrashed( self ): return CC.TRASH_SERVICE_KEY in self._current def ProcessContentUpdate( self, service_key, content_update ): ( data_type, action, row ) = content_update.ToTuple() if data_type == HC.CONTENT_TYPE_FILES: if action == HC.CONTENT_UPDATE_ARCHIVE: self._inbox = False elif action == HC.CONTENT_UPDATE_INBOX: self._inbox = True elif action == HC.CONTENT_UPDATE_ADD: self._current.add( service_key ) self._deleted.discard( service_key ) self._pending.discard( service_key ) if service_key == CC.LOCAL_FILE_SERVICE_KEY: self._current.discard( CC.TRASH_SERVICE_KEY ) self._pending.discard( CC.COMBINED_LOCAL_FILE_SERVICE_KEY ) if CC.COMBINED_LOCAL_FILE_SERVICE_KEY not in self._current: self._inbox = True self._current.add( CC.COMBINED_LOCAL_FILE_SERVICE_KEY ) self._current_to_timestamps[ CC.COMBINED_LOCAL_FILE_SERVICE_KEY ] = HydrusData.GetNow() self._current_to_timestamps[ service_key ] = HydrusData.GetNow() elif action == HC.CONTENT_UPDATE_DELETE: self._deleted.add( service_key ) self._current.discard( service_key ) self._petitioned.discard( service_key ) if service_key == CC.LOCAL_FILE_SERVICE_KEY: self._current.add( CC.TRASH_SERVICE_KEY ) self._current_to_timestamps[ CC.TRASH_SERVICE_KEY ] = HydrusData.GetNow() elif service_key == CC.TRASH_SERVICE_KEY: self._inbox = False self._current.discard( CC.COMBINED_LOCAL_FILE_SERVICE_KEY ) elif action == HC.CONTENT_UPDATE_UNDELETE: self._current.discard( CC.TRASH_SERVICE_KEY ) self._deleted.discard( CC.LOCAL_FILE_SERVICE_KEY ) self._current.add( CC.LOCAL_FILE_SERVICE_KEY ) elif action == HC.CONTENT_UPDATE_PEND: if service_key not in self._current: self._pending.add( service_key ) elif action == HC.CONTENT_UPDATE_PETITION: if service_key not in self._deleted: self._petitioned.add( service_key ) elif action == HC.CONTENT_UPDATE_RESCIND_PEND: self._pending.discard( service_key ) elif action == HC.CONTENT_UPDATE_RESCIND_PETITION: self._petitioned.discard( service_key ) elif data_type == HC.CONTENT_TYPE_URLS: if action == HC.CONTENT_UPDATE_ADD: ( hash, urls ) = row self._urls.update( urls ) elif action == HC.CONTENT_UPDATE_DELETE: ( hash, urls ) = row self._urls.difference_update( urls ) def ResetService( self, service_key ): self._current.discard( service_key ) self._pending.discard( service_key ) self._deleted.discard( service_key ) self._petitioned.discard( service_key ) def ShouldHaveThumbnail( self ): return len( self._current ) > 0 class Media( object ): def __init__( self ): self._id = HydrusData.GenerateKey() self._id_hash = self._id.__hash__() def __eq__( self, other ): return self.__hash__() == other.__hash__() def __hash__( self ): return self._id_hash def __ne__( self, other ): return self.__hash__() != other.__hash__() class MediaList( object ): def __init__( self, file_service_key, media_results ): self._file_service_key = file_service_key self._hashes = set() self._hashes_to_singleton_media = {} self._hashes_to_collected_media = {} self._media_sort = MediaSort( ( 'system', CC.SORT_FILES_BY_FILESIZE ), CC.SORT_ASC ) self._collect_by = [] self._collect_map_singletons = {} self._collect_map_collected = {} self._sorted_media = SortedList( [ self._GenerateMediaSingleton( media_result ) for media_result in media_results ] ) self._singleton_media = set( self._sorted_media ) self._collected_media = set() self._RecalcHashes() def __len__( self ): return len( self._singleton_media ) + sum( map( len, self._collected_media ) ) def _CalculateCollectionKeysToMedias( self, collect_by, medias ): keys_to_medias = collections.defaultdict( list ) namespaces_to_collect_by = [ data for ( collect_by_type, data ) in collect_by if collect_by_type == 'namespace' ] ratings_to_collect_by = [ data for ( collect_by_type, data ) in collect_by if collect_by_type == 'rating' ] services_manager = HG.client_controller.services_manager for media in medias: if len( namespaces_to_collect_by ) > 0: namespace_key = media.GetTagsManager().GetNamespaceSlice( namespaces_to_collect_by ) else: namespace_key = None if len( ratings_to_collect_by ) > 0: rating_key = media.GetRatingsManager().GetRatingSlice( ratings_to_collect_by ) else: rating_key = None keys_to_medias[ ( namespace_key, rating_key ) ].append( media ) return keys_to_medias def _GenerateMediaCollection( self, media_results ): return MediaCollection( self._file_service_key, media_results ) def _GenerateMediaSingleton( self, media_result ): return MediaSingleton( media_result ) def _GetFirst( self ): return self._sorted_media[ 0 ] def _GetLast( self ): return self._sorted_media[ -1 ] def _GetMedia( self, hashes, discriminator = None ): if hashes.isdisjoint( self._hashes ): return [] medias = [] if discriminator is None or discriminator == 'singletons': medias.extend( ( self._hashes_to_singleton_media[ hash ] for hash in hashes if hash in self._hashes_to_singleton_media ) ) if discriminator is None or discriminator == 'collections': medias.extend( { self._hashes_to_collected_media[ hash ] for hash in hashes if hash in self._hashes_to_collected_media } ) return medias ''' if discriminator is None: medias = self._sorted_media elif discriminator == 'singletons': medias = self._singleton_media elif discriminator == 'collections': medias = self._collected_media return [ media for media in medias if media.HasAnyOfTheseHashes( hashes ) ] ''' def _GetNext( self, media ): if media is None: return None next_index = self._sorted_media.index( media ) + 1 if next_index == len( self._sorted_media ): return self._GetFirst() else: return self._sorted_media[ next_index ] def _GetPrevious( self, media ): if media is None: return None previous_index = self._sorted_media.index( media ) - 1 if previous_index == -1: return self._GetLast() else: return self._sorted_media[ previous_index ] def _HasHashes( self, hashes ): for hash in hashes: if hash in self._hashes: return True return False def _RecalcHashes( self ): self._hashes = set() self._hashes_to_singleton_media = {} self._hashes_to_collected_media = {} for media in self._collected_media: hashes = media.GetHashes() self._hashes.update( hashes ) for hash in hashes: self._hashes_to_collected_media[ hash ] = media for media in self._singleton_media: hash = media.GetHash() self._hashes.add( hash ) self._hashes_to_singleton_media[ hash ] = media def _RemoveMediaByHashes( self, hashes ): if not isinstance( hashes, set ): hashes = set( hashes ) affected_singleton_media = self._GetMedia( hashes, discriminator = 'singletons' ) for media in self._collected_media: media._RemoveMediaByHashes( hashes ) affected_collected_media = [ media for media in self._collected_media if media.HasNoMedia() ] self._RemoveMediaDirectly( affected_singleton_media, affected_collected_media ) def _RemoveMediaDirectly( self, singleton_media, collected_media ): if not isinstance( singleton_media, set ): singleton_media = set( singleton_media ) if not isinstance( collected_media, set ): collected_media = set( collected_media ) self._singleton_media.difference_update( singleton_media ) self._collected_media.difference_update( collected_media ) keys_to_remove = [ key for ( key, media ) in self._collect_map_singletons if media in singleton_media ] for key in keys_to_remove: del self._collect_map_singletons[ key ] keys_to_remove = [ key for ( key, media ) in self._collect_map_collected if media in collected_media ] for key in keys_to_remove: del self._collect_map_collected[ key ] self._sorted_media.remove_items( singleton_media.union( collected_media ) ) self._RecalcHashes() def AddMedia( self, new_media, append = True ): if append: for media in new_media: hash = media.GetHash() self._hashes.add( hash ) self._hashes_to_singleton_media[ hash ] = media self._singleton_media.update( new_media ) self._sorted_media.append_items( new_media ) else: if self._collect_by is not None: keys_to_medias = self._CalculateCollectionKeysToMedias( self._collect_by, new_media ) new_media = [] for ( key, medias ) in keys_to_medias.items(): if key in self._collect_map_singletons: singleton_media = self._collect_map_singletons[ key ] self._sorted_media.remove_items( singleton_media ) self._singleton_media.discard( singleton_media ) del self._collect_map_singletons[ key ] medias.append( singleton_media ) collected_media = self._GenerateMediaCollection( [ media.GetMediaResult() for media in medias ] ) collected_media.Sort( self._media_sort ) self._collected_media.add( collected_media ) self._collect_map_collected[ key ] = collected_media new_media.append( collected_media ) elif key in self._collect_map_collected: collected_media = self._collect_map_collected[ key ] self._sorted_media.remove_items( collected_media ) collected_media.AddMedia( medias ) collected_media.Sort( self._media_sort ) new_media.append( collected_media ) elif len( medias ) == 1: ( singleton_media, ) = medias self._singleton_media.add( singleton_media ) self._collect_map_singletons[ key ] = singleton_media else: collected_media = self._GenerateMediaCollection( [ media.GetMediaResult() for media in medias ] ) collected_media.Sort( self._media_sort ) self._collected_media.add( collected_media ) self._collect_map_collected[ key ] = collected_media new_media.append( collected_media ) self._sorted_media.insert_items( new_media ) self._RecalcHashes() return new_media def Collect( self, collect_by = None ): if collect_by == None: collect_by = self._collect_by self._collect_by = collect_by for media in self._collected_media: self._singleton_media.update( [ self._GenerateMediaSingleton( media_result ) for media_result in media.GenerateMediaResults() ] ) self._collected_media = set() self._collect_map_singletons = {} self._collect_map_collected = {} if len( collect_by ) > 0: keys_to_medias = self._CalculateCollectionKeysToMedias( collect_by, self._singleton_media ) self._collect_map_singletons = { key : medias[0] for ( key, medias ) in keys_to_medias.items() if len( medias ) == 1 } self._collect_map_collected = { key : self._GenerateMediaCollection( [ media.GetMediaResult() for media in medias ] ) for ( key, medias ) in keys_to_medias.items() if len( medias ) > 1 } self._singleton_media = set( self._collect_map_singletons.values() ) self._collected_media = set( self._collect_map_collected.values() ) self._sorted_media = SortedList( list( self._singleton_media ) + list( self._collected_media ) ) self._RecalcHashes() def DeletePending( self, service_key ): for media in self._collected_media: media.DeletePending( service_key ) def GenerateMediaResults( self, has_location = None, discriminant = None, selected_media = None, unrated = None, for_media_viewer = False ): media_results = [] for media in self._sorted_media: if has_location is not None: locations_manager = media.GetLocationsManager() if has_location not in locations_manager.GetCurrent(): continue if selected_media is not None and media not in selected_media: continue if media.IsCollection(): media_results.extend( media.GenerateMediaResults( has_location = has_location, discriminant = discriminant, selected_media = selected_media, unrated = unrated, for_media_viewer = True ) ) else: if discriminant is not None: locations_manager = media.GetLocationsManager() if discriminant == CC.DISCRIMINANT_INBOX: p = media.HasInbox() elif discriminant == CC.DISCRIMINANT_ARCHIVE: p = not media.HasInbox() elif discriminant == CC.DISCRIMINANT_LOCAL: p = locations_manager.IsLocal() elif discriminant == CC.DISCRIMINANT_LOCAL_BUT_NOT_IN_TRASH: p = locations_manager.IsLocal() and not locations_manager.IsTrashed() elif discriminant == CC.DISCRIMINANT_NOT_LOCAL: p = not locations_manager.IsLocal() elif discriminant == CC.DISCRIMINANT_DOWNLOADING: p = locations_manager.IsDownloading() if not p: continue if unrated is not None: ratings_manager = media.GetRatingsManager() if ratings_manager.GetRating( unrated ) is not None: continue if for_media_viewer: new_options = HG.client_controller.new_options media_show_action = new_options.GetMediaShowAction( media.GetMime() ) if media_show_action in ( CC.MEDIA_VIEWER_ACTION_DO_NOT_SHOW_ON_ACTIVATION_OPEN_EXTERNALLY, CC.MEDIA_VIEWER_ACTION_DO_NOT_SHOW ): continue media_results.append( media.GetMediaResult() ) return media_results def GetFirst( self ): return self._GetFirst() def GetFlatMedia( self ): flat_media = [] for media in self._sorted_media: if media.IsCollection(): flat_media.extend( media.GetFlatMedia() ) else: flat_media.append( media ) return flat_media def GetLast( self ): return self._GetLast() def GetMediaIndex( self, media ): return self._sorted_media.index( media ) def GetNext( self, media ): return self._GetNext( media ) def GetNumFiles( self ): return len( self._hashes ) def GetPrevious( self, media ): return self._GetPrevious( media ) def GetSortedMedia( self ): return self._sorted_media def HasAnyOfTheseHashes( self, hashes ): return not hashes.isdisjoint( self._hashes ) def HasMedia( self, media ): if media is None: return False if media in self._singleton_media: return True elif media in self._collected_media: return True else: for media_collection in self._collected_media: if media_collection.HasMedia( media ): return True return False def HasNoMedia( self ): return len( self._sorted_media ) == 0 def ProcessContentUpdate( self, service_key, content_update ): ( data_type, action, row ) = content_update.ToTuple() hashes = content_update.GetHashes() for media in self._GetMedia( hashes, 'collections' ): media.ProcessContentUpdate( service_key, content_update ) if data_type == HC.CONTENT_TYPE_FILES: if action == HC.CONTENT_UPDATE_DELETE: local_file_domains = HG.client_controller.services_manager.GetServiceKeys( ( HC.LOCAL_FILE_DOMAIN, ) ) non_trash_local_file_services = list( local_file_domains ) + [ CC.COMBINED_LOCAL_FILE_SERVICE_KEY ] local_file_services = list( non_trash_local_file_services ) + [ CC.TRASH_SERVICE_KEY ] deleted_from_trash_and_local_view = service_key == CC.TRASH_SERVICE_KEY and self._file_service_key in local_file_services trashed_and_non_trash_local_view = HC.options[ 'remove_trashed_files' ] and service_key in non_trash_local_file_services and self._file_service_key in non_trash_local_file_services deleted_from_repo_and_repo_view = service_key not in local_file_services and self._file_service_key == service_key if deleted_from_trash_and_local_view or trashed_and_non_trash_local_view or deleted_from_repo_and_repo_view: self._RemoveMediaByHashes( hashes ) def ProcessContentUpdates( self, service_keys_to_content_updates ): for ( service_key, content_updates ) in service_keys_to_content_updates.items(): for content_update in content_updates: self.ProcessContentUpdate( service_key, content_update ) def ProcessServiceUpdates( self, service_keys_to_service_updates ): for ( service_key, service_updates ) in service_keys_to_service_updates.items(): for service_update in service_updates: ( action, row ) = service_update.ToTuple() if action == HC.SERVICE_UPDATE_DELETE_PENDING: self.DeletePending( service_key ) elif action == HC.SERVICE_UPDATE_RESET: self.ResetService( service_key ) def ResetService( self, service_key ): if service_key == self._file_service_key: self._RemoveMediaDirectly( self._singleton_media, self._collected_media ) else: for media in self._collected_media: media.ResetService( service_key ) def Sort( self, media_sort = None ): for media in self._collected_media: media.Sort( media_sort ) if media_sort is None: media_sort = self._media_sort self._media_sort = media_sort media_sort_fallback = HG.client_controller.new_options.GetFallbackSort() ( sort_key, reverse ) = media_sort_fallback.GetSortKeyAndReverse( self._file_service_key ) self._sorted_media.sort( sort_key, reverse = reverse ) # this is a stable sort, so the fallback order above will remain for equal items ( sort_key, reverse ) = self._media_sort.GetSortKeyAndReverse( self._file_service_key ) self._sorted_media.sort( sort_key = sort_key, reverse = reverse ) class ListeningMediaList( MediaList ): def __init__( self, file_service_key, media_results ): MediaList.__init__( self, file_service_key, media_results ) self._file_query_result = ClientSearch.FileQueryResult( media_results ) HG.client_controller.sub( self, 'ProcessContentUpdates', 'content_updates_gui' ) HG.client_controller.sub( self, 'ProcessServiceUpdates', 'service_updates_gui' ) def AddMediaResults( self, media_results, append = True ): self._file_query_result.AddMediaResults( media_results ) new_media = [] for media_result in media_results: hash = media_result.GetHash() if hash in self._hashes: continue new_media.append( self._GenerateMediaSingleton( media_result ) ) self.AddMedia( new_media, append = append ) return new_media class MediaCollection( MediaList, Media ): def __init__( self, file_service_key, media_results ): Media.__init__( self ) MediaList.__init__( self, file_service_key, media_results ) self._archive = True self._inbox = False self._size = 0 self._size_definite = True self._width = None self._height = None self._duration = None self._num_frames = None self._num_words = None self._tags_manager = None self._locations_manager = None self._RecalcInternals() def _RecalcInternals( self ): self._RecalcHashes() self._archive = True in ( media.HasArchive() for media in self._sorted_media ) self._inbox = True in ( media.HasInbox() for media in self._sorted_media ) self._size = sum( [ media.GetSize() for media in self._sorted_media ] ) self._size_definite = not False in ( media.IsSizeDefinite() for media in self._sorted_media ) duration_sum = sum( [ media.GetDuration() for media in self._sorted_media if media.HasDuration() ] ) if duration_sum > 0: self._duration = duration_sum else: self._duration = None tags_managers = [ m.GetTagsManager() for m in self._sorted_media ] self._tags_manager = MergeTagsManagers( tags_managers ) # horrible compromise if len( self._sorted_media ) > 0: self._ratings_manager = self._sorted_media[0].GetRatingsManager() else: self._ratings_manager = ClientRatings.RatingsManager( {} ) all_locations_managers = [ media.GetLocationsManager() for media in self._sorted_media ] current = HydrusData.IntelligentMassIntersect( [ locations_manager.GetCurrent() for locations_manager in all_locations_managers ] ) deleted = HydrusData.IntelligentMassIntersect( [ locations_manager.GetDeleted() for locations_manager in all_locations_managers ] ) pending = HydrusData.IntelligentMassIntersect( [ locations_manager.GetPending() for locations_manager in all_locations_managers ] ) petitioned = HydrusData.IntelligentMassIntersect( [ locations_manager.GetPetitioned() for locations_manager in all_locations_managers ] ) self._locations_manager = LocationsManager( current, deleted, pending, petitioned ) def AddMedia( self, new_media, append = True ): MediaList.AddMedia( self, new_media, append = True ) self._RecalcInternals() def DeletePending( self, service_key ): MediaList.DeletePending( self, service_key ) self._RecalcInternals() def GetDisplayMedia( self ): return self._GetFirst().GetDisplayMedia() def GetDuration( self ): return self._duration def GetHash( self ): return self.GetDisplayMedia().GetHash() def GetHashes( self, has_location = None, discriminant = None, not_uploaded_to = None, ordered = False ): if has_location is None and discriminant is None and not_uploaded_to is None and not ordered: return self._hashes else: if ordered: result = [] for media in self._sorted_media: result.extend( media.GetHashes( has_location, discriminant, not_uploaded_to, ordered ) ) else: result = set() for media in self._sorted_media: result.update( media.GetHashes( has_location, discriminant, not_uploaded_to, ordered ) ) return result def GetLocationsManager( self ): return self._locations_manager def GetMime( self ): return HC.APPLICATION_HYDRUS_CLIENT_COLLECTION def GetNumFiles( self ): return len( self._hashes ) def GetNumInbox( self ): return sum( ( media.GetNumInbox() for media in self._sorted_media ) ) def GetNumFrames( self ): return sum( ( media.GetNumFrames() for media in self._sorted_media ) ) def GetNumWords( self ): return sum( ( media.GetNumWords() for media in self._sorted_media ) ) def GetPrettyInfoLines( self ): size = HydrusData.ConvertIntToBytes( self._size ) mime = HC.mime_string_lookup[ HC.APPLICATION_HYDRUS_CLIENT_COLLECTION ] info_string = size + ' ' + mime info_string += ' (' + HydrusData.ConvertIntToPrettyString( self.GetNumFiles() ) + ' files)' return [ info_string ] def GetRatingsManager( self ): return self._ratings_manager def GetResolution( self ): return ( self._width, self._height ) def GetSingletonsTagsManagers( self ): tags_managers = [ m.GetTagsManager() for m in self._singleton_media ] for m in self._collected_media: tags_managers.extend( m.GetSingletonsTagsManagers() ) return tags_managers def GetSize( self ): return self._size def GetTagsManager( self ): return self._tags_manager def GetTimestamp( self, service_key ): return None def HasArchive( self ): return self._archive def HasDuration( self ): return self._duration is not None def HasImages( self ): return True in ( media.HasImages() for media in self._sorted_media ) def HasInbox( self ): return self._inbox def IsCollection( self ): return True def IsImage( self ): return False def IsNoisy( self ): return self.GetDisplayMedia().GetMime() in HC.NOISY_MIMES def IsSizeDefinite( self ): return self._size_definite def ProcessContentUpdate( self, service_key, content_update ): MediaList.ProcessContentUpdate( self, service_key, content_update ) self._RecalcInternals() def RefreshFileInfo( self ): for media in self._sorted_media: media.RefreshFileInfo() self._RecalcInternals() def ResetService( self, service_key ): MediaList.ResetService( self, service_key ) self._RecalcInternals() class MediaSingleton( Media ): def __init__( self, media_result ): Media.__init__( self ) self._media_result = media_result def Duplicate( self ): return MediaSingleton( self._media_result.Duplicate() ) def GetDisplayMedia( self ): return self def GetDuration( self ): return self._media_result.GetDuration() def GetHash( self ): return self._media_result.GetHash() def MatchesDiscriminant( self, has_location = None, discriminant = None, not_uploaded_to = None ): if discriminant is not None: inbox = self._media_result.GetInbox() locations_manager = self._media_result.GetLocationsManager() if discriminant == CC.DISCRIMINANT_INBOX: p = inbox elif discriminant == CC.DISCRIMINANT_ARCHIVE: p = not inbox elif discriminant == CC.DISCRIMINANT_LOCAL: p = locations_manager.IsLocal() elif discriminant == CC.DISCRIMINANT_LOCAL_BUT_NOT_IN_TRASH: p = locations_manager.IsLocal() and not locations_manager.IsTrashed() elif discriminant == CC.DISCRIMINANT_NOT_LOCAL: p = not locations_manager.IsLocal() elif discriminant == CC.DISCRIMINANT_DOWNLOADING: p = locations_manager.IsDownloading() if not p: return False if has_location is not None: locations_manager = self._media_result.GetLocationsManager() if has_location not in locations_manager.GetCurrent(): return False if not_uploaded_to is not None: locations_manager = self._media_result.GetLocationsManager() if not_uploaded_to in locations_manager.GetCurrentRemote(): return False return True def GetHashes( self, has_location = None, discriminant = None, not_uploaded_to = None, ordered = False ): if self.MatchesDiscriminant( has_location = has_location, discriminant = discriminant, not_uploaded_to = not_uploaded_to ): if ordered: return [ self._media_result.GetHash() ] else: return { self._media_result.GetHash() } else: if ordered: return [] else: return set() def GetLocationsManager( self ): return self._media_result.GetLocationsManager() def GetMediaResult( self ): return self._media_result def GetMime( self ): return self._media_result.GetMime() def GetNumFiles( self ): return 1 def GetNumFrames( self ): return self._media_result.GetNumFrames() def GetNumInbox( self ): if self.HasInbox(): return 1 else: return 0 def GetNumWords( self ): return self._media_result.GetNumWords() def GetTimestamp( self, service_key ): return self._media_result.GetLocationsManager().GetTimestamp( service_key ) def GetPrettyInfoLines( self ): file_info_manager = self._media_result.GetFileInfoManager() locations_manager = self._media_result.GetLocationsManager() ( hash, size, mime, width, height, duration, num_frames, num_words ) = file_info_manager.ToTuple() info_string = HydrusData.ConvertIntToBytes( size ) + ' ' + HC.mime_string_lookup[ mime ] if width is not None and height is not None: info_string += ' (' + HydrusData.ConvertIntToPrettyString( width ) + 'x' + HydrusData.ConvertIntToPrettyString( height ) + ')' if duration is not None: info_string += ', ' + HydrusData.ConvertMillisecondsToPrettyTime( duration ) if num_frames is not None: info_string += ' (' + HydrusData.ConvertIntToPrettyString( num_frames ) + ' frames)' if num_words is not None: info_string += ' (' + HydrusData.ConvertIntToPrettyString( num_words ) + ' words)' lines = [ info_string ] locations_manager = self._media_result.GetLocationsManager() current_service_keys = locations_manager.GetCurrent() if CC.COMBINED_LOCAL_FILE_SERVICE_KEY in current_service_keys: timestamp = locations_manager.GetTimestamp( CC.COMBINED_LOCAL_FILE_SERVICE_KEY ) lines.append( 'imported ' + HydrusData.ConvertTimestampToPrettyAgo( timestamp ) + ' ago' ) if CC.TRASH_SERVICE_KEY in current_service_keys: timestamp = locations_manager.GetTimestamp( CC.TRASH_SERVICE_KEY ) lines.append( 'trashed ' + HydrusData.ConvertTimestampToPrettyAgo( timestamp ) + ' ago' ) for service_key in current_service_keys: if service_key in ( CC.COMBINED_LOCAL_FILE_SERVICE_KEY, CC.LOCAL_FILE_SERVICE_KEY, CC.TRASH_SERVICE_KEY ): continue timestamp = locations_manager.GetTimestamp( service_key ) service = HG.client_controller.services_manager.GetService( service_key ) service_type = service.GetServiceType() if service_type == HC.IPFS: status = 'pinned ' else: status = 'uploaded ' lines.append( status + 'to ' + service.GetName() + ' ' + HydrusData.ConvertTimestampToPrettyAgo( timestamp ) + ' ago' ) return lines def GetRatingsManager( self ): return self._media_result.GetRatingsManager() def GetResolution( self ): ( width, height ) = self._media_result.GetResolution() if width is None: return ( 0, 0 ) else: return ( width, height ) def GetSize( self ): size = self._media_result.GetSize() if size is None: return 0 else: return size def GetTagsManager( self ): return self._media_result.GetTagsManager() def GetTitleString( self ): namespace_info = [] namespace_info.append( ( 'creator', '', ', ' ) ) namespace_info.append( ( 'series', '', ', ' ) ) namespace_info.append( ( 'title', '', ', ' ) ) namespace_info.append( ( 'volume', 'v', '-' ) ) namespace_info.append( ( 'chapter', 'c', '-' ) ) namespace_info.append( ( 'page', 'p', '-' ) ) tags_summary_generator = ClientTags.TagSummaryGenerator( namespace_info, ' - ' ) tags = self.GetTagsManager().GetCurrent( CC.COMBINED_TAG_SERVICE_KEY ) siblings_manager = HG.client_controller.GetManager( 'tag_siblings' ) tags = siblings_manager.CollapseTags( CC.COMBINED_TAG_SERVICE_KEY, tags ) summary = tags_summary_generator.GenerateSummary( tags ) return summary def HasAnyOfTheseHashes( self, hashes ): return self._media_result.GetHash() in hashes def HasArchive( self ): return not self._media_result.GetInbox() def HasDuration( self ): return self._media_result.GetDuration() is not None and self._media_result.GetNumFrames() > 1 def HasImages( self ): return self.IsImage() def HasInbox( self ): return self._media_result.GetInbox() def IsCollection( self ): return False def IsImage( self ): return self._media_result.GetMime() in HC.IMAGES def IsNoisy( self ): return self._media_result.GetMime() in HC.NOISY_MIMES def IsSizeDefinite( self ): return self._media_result.GetSize() is not None def RefreshFileInfo( self ): self._media_result.RefreshFileInfo() class MediaResult( object ): def __init__( self, file_info_manager, tags_manager, locations_manager, ratings_manager ): self._file_info_manager = file_info_manager self._tags_manager = tags_manager self._locations_manager = locations_manager self._ratings_manager = ratings_manager def DeletePending( self, service_key ): service = HG.client_controller.services_manager.GetService( service_key ) service_type = service.GetServiceType() if service_type in HC.TAG_SERVICES: self._tags_manager.DeletePending( service_key ) elif service_type in HC.FILE_SERVICES: self._locations_manager.DeletePending( service_key ) def Duplicate( self ): file_info_manager = self._file_info_manager.Duplicate() tags_manager = self._tags_manager.Duplicate() locations_manager = self._locations_manager.Duplicate() ratings_manager = self._ratings_manager.Duplicate() return MediaResult( file_info_manager, tags_manager, locations_manager, ratings_manager ) def GetDuration( self ): return self._file_info_manager.duration def GetFileInfoManager( self ): return self._file_info_manager def GetHash( self ): return self._file_info_manager.hash def GetInbox( self ): return self._locations_manager.GetInbox() def GetLocationsManager( self ): return self._locations_manager def GetMime( self ): return self._file_info_manager.mime def GetNumFrames( self ): return self._file_info_manager.num_frames def GetNumWords( self ): return self._file_info_manager.num_words def GetRatingsManager( self ): return self._ratings_manager def GetResolution( self ): return ( self._file_info_manager.width, self._file_info_manager.height ) def GetSize( self ): return self._file_info_manager.size def GetTagsManager( self ): return self._tags_manager def ProcessContentUpdate( self, service_key, content_update ): ( data_type, action, row ) = content_update.ToTuple() service = HG.client_controller.services_manager.GetService( service_key ) service_type = service.GetServiceType() if service_type in HC.TAG_SERVICES: self._tags_manager.ProcessContentUpdate( service_key, content_update ) elif service_type in HC.FILE_SERVICES: self._locations_manager.ProcessContentUpdate( service_key, content_update ) elif service_type in HC.RATINGS_SERVICES: self._ratings_manager.ProcessContentUpdate( service_key, content_update ) def RefreshFileInfo( self ): media_results = HG.client_controller.Read( 'media_results', ( self._file_info_manager.hash, ) ) if len( media_results ) > 0: media_result = media_results[0] self._file_info_manager = media_result._file_info_manager def ResetService( self, service_key ): self._tags_manager.ResetService( service_key ) self._locations_manager.ResetService( service_key ) def ToTuple( self ): return ( self._file_info_manager, self._tags_manager, self._locations_manager, self._ratings_manager ) class MediaSort( HydrusSerialisable.SerialisableBase ): SERIALISABLE_TYPE = HydrusSerialisable.SERIALISABLE_TYPE_MEDIA_SORT SERIALISABLE_NAME = 'Media Sort' SERIALISABLE_VERSION = 1 def __init__( self, sort_type = None, sort_asc = None ): if sort_type is None: sort_type = ( 'system', CC.SORT_FILES_BY_FILESIZE ) if sort_asc is None: sort_asc = CC.SORT_ASC self.sort_type = sort_type self.sort_asc = sort_asc def _GetSerialisableInfo( self ): ( sort_metatype, sort_data ) = self.sort_type if sort_metatype == 'system': serialisable_sort_data = sort_data elif sort_metatype == 'namespaces': serialisable_sort_data = sort_data elif sort_metatype == 'rating': service_key = sort_data serialisable_sort_data = service_key.encode( 'hex' ) return ( sort_metatype, serialisable_sort_data, self.sort_asc ) def _InitialiseFromSerialisableInfo( self, serialisable_info ): ( sort_metatype, serialisable_sort_data, self.sort_asc ) = serialisable_info if sort_metatype == 'system': sort_data = serialisable_sort_data elif sort_metatype == 'namespaces': sort_data = tuple( serialisable_sort_data ) elif sort_metatype == 'rating': sort_data = serialisable_sort_data.decode( 'hex' ) self.sort_type = ( sort_metatype, sort_data ) def CanAsc( self ): ( sort_metatype, sort_data ) = self.sort_type if sort_metatype == 'system': if sort_data in ( CC.SORT_FILES_BY_MIME, CC.SORT_FILES_BY_RANDOM ): return False elif sort_metatype == 'namespaces': return False return True def GetSortKeyAndReverse( self, file_service_key ): reverse = False ( sort_metadata, sort_data ) = self.sort_type def deal_with_none( x ): if x is None: return -1 else: return x if sort_metadata == 'system': if sort_data == CC.SORT_FILES_BY_RANDOM: def sort_key( x ): return random.random() elif sort_data == CC.SORT_FILES_BY_FILESIZE: def sort_key( x ): return deal_with_none( x.GetSize() ) elif sort_data == CC.SORT_FILES_BY_DURATION: def sort_key( x ): return deal_with_none( x.GetDuration() ) elif sort_data == CC.SORT_FILES_BY_IMPORT_TIME: file_service = HG.client_controller.services_manager.GetService( file_service_key ) file_service_type = file_service.GetServiceType() if file_service_type == HC.LOCAL_FILE_DOMAIN: file_service_key = CC.COMBINED_LOCAL_FILE_SERVICE_KEY def sort_key( x ): return deal_with_none( x.GetTimestamp( file_service_key ) ) elif sort_data == CC.SORT_FILES_BY_HEIGHT: def sort_key( x ): return deal_with_none( x.GetResolution()[1] ) elif sort_data == CC.SORT_FILES_BY_WIDTH: def sort_key( x ): return deal_with_none( x.GetResolution()[0] ) elif sort_data == CC.SORT_FILES_BY_RATIO: def sort_key( x ): ( width, height ) = x.GetResolution() if width is None or height is None or width == 0 or height == 0: return -1 else: return float( width ) / float( height ) elif sort_data == CC.SORT_FILES_BY_NUM_PIXELS: def sort_key( x ): ( width, height ) = x.GetResolution() if width is None or height is None: return -1 else: return width * height elif sort_data == CC.SORT_FILES_BY_NUM_TAGS: def sort_key( x ): tags_manager = x.GetTagsManager() return( len( tags_manager.GetCurrent() ) + len( tags_manager.GetPending() ) ) elif sort_data == CC.SORT_FILES_BY_MIME: def sort_key( x ): return x.GetMime() elif sort_metadata == 'namespaces': namespaces = sort_data def sort_key( x ): x_tags_manager = x.GetTagsManager() return [ x_tags_manager.GetComparableNamespaceSlice( ( namespace, ) ) for namespace in namespaces ] elif sort_metadata == 'rating': service_key = sort_data def sort_key( x ): x_ratings_manager = x.GetRatingsManager() rating = deal_with_none( x_ratings_manager.GetRating( service_key ) ) return rating return ( sort_key, self.sort_asc ) def GetSortTypeString( self ): ( sort_metatype, sort_data ) = self.sort_type sort_string = 'sort by ' if sort_metatype == 'system': sort_string_lookup = {} sort_string_lookup[ CC.SORT_FILES_BY_FILESIZE ] = 'filesize' sort_string_lookup[ CC.SORT_FILES_BY_DURATION ] = 'duration' sort_string_lookup[ CC.SORT_FILES_BY_IMPORT_TIME ] = 'time imported' sort_string_lookup[ CC.SORT_FILES_BY_MIME ] = 'mime' sort_string_lookup[ CC.SORT_FILES_BY_RANDOM ] = 'random' sort_string_lookup[ CC.SORT_FILES_BY_WIDTH ] = 'width' sort_string_lookup[ CC.SORT_FILES_BY_HEIGHT ] = 'height' sort_string_lookup[ CC.SORT_FILES_BY_RATIO ] = 'resolution ratio' sort_string_lookup[ CC.SORT_FILES_BY_NUM_PIXELS ] = 'number of pixels' sort_string_lookup[ CC.SORT_FILES_BY_NUM_TAGS ] = 'number of tags' sort_string += sort_string_lookup[ sort_data ] elif sort_metatype == 'namespaces': namespaces = sort_data sort_string += '-'.join( namespaces ) elif sort_metatype == 'rating': service_key = sort_data service = HG.client_controller.services_manager.GetService( service_key ) sort_string += service.GetName() return sort_string def GetSortAscStrings( self ): ( sort_metatype, sort_data ) = self.sort_type if sort_metatype == 'system': sort_string_lookup = {} sort_string_lookup[ CC.SORT_FILES_BY_FILESIZE ] = ( 'smallest first', 'largest first' ) sort_string_lookup[ CC.SORT_FILES_BY_DURATION ] = ( 'shortest first', 'longest first' ) sort_string_lookup[ CC.SORT_FILES_BY_IMPORT_TIME ] = ( 'oldest first', 'newest first' ) sort_string_lookup[ CC.SORT_FILES_BY_MIME ] = ( 'mime', 'mime' ) sort_string_lookup[ CC.SORT_FILES_BY_RANDOM ] = ( 'random', 'random' ) sort_string_lookup[ CC.SORT_FILES_BY_WIDTH ] = ( 'slimmest first', 'widest first' ) sort_string_lookup[ CC.SORT_FILES_BY_HEIGHT ] = ( 'shortest first', 'tallest first' ) sort_string_lookup[ CC.SORT_FILES_BY_RATIO ] = ( 'tallest first', 'widest first' ) sort_string_lookup[ CC.SORT_FILES_BY_NUM_PIXELS ] = ( 'ascending', 'descending' ) sort_string_lookup[ CC.SORT_FILES_BY_NUM_TAGS ] = ( 'ascending', 'descending' ) return sort_string_lookup[ sort_data ] else: return ( 'ascending', 'descending' ) HydrusSerialisable.SERIALISABLE_TYPES_TO_OBJECT_TYPES[ HydrusSerialisable.SERIALISABLE_TYPE_MEDIA_SORT ] = MediaSort class SortedList( object ): def __init__( self, initial_items = None ): if initial_items is None: initial_items = [] self._sort_key = None self._sort_reverse = False self._sorted_list = list( initial_items ) self._items_to_indices = None def __contains__( self, item ): return self._items_to_indices.__contains__( item ) def __getitem__( self, value ): return self._sorted_list.__getitem__( value ) def __iter__( self ): return iter( self._sorted_list ) def __len__( self ): return len( self._sorted_list ) def _DirtyIndices( self ): self._items_to_indices = None def _RecalcIndices( self ): self._items_to_indices = { item : index for ( index, item ) in enumerate( self._sorted_list ) } def append_items( self, items ): if self._items_to_indices is None: self._RecalcIndices() for ( i, item ) in enumerate( items, start = len( self._sorted_list ) ): self._items_to_indices[ item ] = i self._sorted_list.extend( items ) def index( self, item ): if self._items_to_indices is None: self._RecalcIndices() try: result = self._items_to_indices[ item ] except KeyError: raise HydrusExceptions.DataMissing() return result def insert_items( self, items ): self.append_items( items ) self.sort() def remove_items( self, items ): deletee_indices = [ self.index( item ) for item in items ] deletee_indices.sort() deletee_indices.reverse() for index in deletee_indices: del self._sorted_list[ index ] self._DirtyIndices() def sort( self, sort_key = None, reverse = False ): if sort_key is None: sort_key = self._sort_key reverse = self._sort_reverse else: self._sort_key = sort_key self._sort_reverse = reverse self._sorted_list.sort( key = sort_key, reverse = reverse ) self._DirtyIndices() class TagsManagerSimple( object ): def __init__( self, service_keys_to_statuses_to_tags ): self._service_keys_to_statuses_to_tags = service_keys_to_statuses_to_tags self._combined_namespaces_cache = None def _RecalcCombinedIfNeeded( self ): pass def Duplicate( self ): dupe_service_keys_to_statuses_to_tags = collections.defaultdict( HydrusData.default_dict_set ) for ( service_key, statuses_to_tags ) in self._service_keys_to_statuses_to_tags.items(): dupe_statuses_to_tags = HydrusData.default_dict_set() for ( status, tags ) in statuses_to_tags.items(): dupe_statuses_to_tags[ status ] = set( tags ) dupe_service_keys_to_statuses_to_tags[ service_key ] = dupe_statuses_to_tags return TagsManagerSimple( dupe_service_keys_to_statuses_to_tags ) def GetCombinedNamespaces( self, namespaces ): self._RecalcCombinedIfNeeded() if self._combined_namespaces_cache is None: combined_statuses_to_tags = self._service_keys_to_statuses_to_tags[ CC.COMBINED_TAG_SERVICE_KEY ] combined_current = combined_statuses_to_tags[ HC.CONTENT_STATUS_CURRENT ] combined_pending = combined_statuses_to_tags[ HC.CONTENT_STATUS_PENDING ] pairs = ( HydrusTags.SplitTag( tag ) for tag in combined_current.union( combined_pending ) ) self._combined_namespaces_cache = HydrusData.BuildKeyToSetDict( ( namespace, subtag ) for ( namespace, subtag ) in pairs if namespace != '' ) result = { namespace : self._combined_namespaces_cache[ namespace ] for namespace in namespaces } return result def GetComparableNamespaceSlice( self, namespaces ): self._RecalcCombinedIfNeeded() combined_statuses_to_tags = self._service_keys_to_statuses_to_tags[ CC.COMBINED_TAG_SERVICE_KEY ] combined_current = combined_statuses_to_tags[ HC.CONTENT_STATUS_CURRENT ] combined_pending = combined_statuses_to_tags[ HC.CONTENT_STATUS_PENDING ] combined = combined_current.union( combined_pending ) pairs = [ HydrusTags.SplitTag( tag ) for tag in combined ] slice = [] for desired_namespace in namespaces: subtags = [ HydrusTags.ConvertTagToSortable( subtag ) for ( namespace, subtag ) in pairs if namespace == desired_namespace ] subtags.sort() slice.append( tuple( subtags ) ) return tuple( slice ) def GetCurrent( self, service_key = CC.COMBINED_TAG_SERVICE_KEY ): if service_key == CC.COMBINED_TAG_SERVICE_KEY: self._RecalcCombinedIfNeeded() statuses_to_tags = self._service_keys_to_statuses_to_tags[ service_key ] return set( statuses_to_tags[ HC.CONTENT_STATUS_CURRENT ] ) def GetDeleted( self, service_key = CC.COMBINED_TAG_SERVICE_KEY ): if service_key == CC.COMBINED_TAG_SERVICE_KEY: self._RecalcCombinedIfNeeded() statuses_to_tags = self._service_keys_to_statuses_to_tags[ service_key ] return set( statuses_to_tags[ HC.CONTENT_STATUS_DELETED ] ) def GetNamespaceSlice( self, namespaces ): self._RecalcCombinedIfNeeded() combined_statuses_to_tags = self._service_keys_to_statuses_to_tags[ CC.COMBINED_TAG_SERVICE_KEY ] combined_current = combined_statuses_to_tags[ HC.CONTENT_STATUS_CURRENT ] combined_pending = combined_statuses_to_tags[ HC.CONTENT_STATUS_PENDING ] combined = combined_current.union( combined_pending ) slice = { tag for tag in combined if True in ( tag.startswith( namespace + ':' ) for namespace in namespaces ) } slice = frozenset( slice ) return slice def GetPending( self, service_key = CC.COMBINED_TAG_SERVICE_KEY ): if service_key == CC.COMBINED_TAG_SERVICE_KEY: self._RecalcCombinedIfNeeded() statuses_to_tags = self._service_keys_to_statuses_to_tags[ service_key ] return set( statuses_to_tags[ HC.CONTENT_STATUS_PENDING ] ) def GetPetitioned( self, service_key = CC.COMBINED_TAG_SERVICE_KEY ): if service_key == CC.COMBINED_TAG_SERVICE_KEY: self._RecalcCombinedIfNeeded() statuses_to_tags = self._service_keys_to_statuses_to_tags[ service_key ] return set( statuses_to_tags[ HC.CONTENT_STATUS_PETITIONED ] ) class TagsManager( TagsManagerSimple ): def __init__( self, service_keys_to_statuses_to_tags ): TagsManagerSimple.__init__( self, service_keys_to_statuses_to_tags ) self._combined_is_calculated = False HG.client_controller.sub( self, 'NewSiblings', 'notify_new_siblings_data' ) def _RecalcCombinedIfNeeded( self ): if not self._combined_is_calculated: # Combined tags are pre-collapsed by siblings siblings_manager = HG.client_controller.GetManager( 'tag_siblings' ) combined_statuses_to_tags = collections.defaultdict( set ) for ( service_key, statuses_to_tags ) in self._service_keys_to_statuses_to_tags.items(): if service_key == CC.COMBINED_TAG_SERVICE_KEY: continue statuses_to_tags = siblings_manager.CollapseStatusesToTags( service_key, statuses_to_tags ) combined_statuses_to_tags[ HC.CONTENT_STATUS_CURRENT ].update( statuses_to_tags[ HC.CONTENT_STATUS_CURRENT ] ) combined_statuses_to_tags[ HC.CONTENT_STATUS_PENDING ].update( statuses_to_tags[ HC.CONTENT_STATUS_PENDING ] ) combined_statuses_to_tags[ HC.CONTENT_STATUS_PETITIONED ].update( statuses_to_tags[ HC.CONTENT_STATUS_PETITIONED ] ) combined_statuses_to_tags[ HC.CONTENT_STATUS_DELETED ].update( statuses_to_tags[ HC.CONTENT_STATUS_DELETED ] ) self._service_keys_to_statuses_to_tags[ CC.COMBINED_TAG_SERVICE_KEY ] = combined_statuses_to_tags self._combined_namespaces_cache = None self._combined_is_calculated = True def DeletePending( self, service_key ): statuses_to_tags = self._service_keys_to_statuses_to_tags[ service_key ] if len( statuses_to_tags[ HC.CONTENT_STATUS_PENDING ] ) + len( statuses_to_tags[ HC.CONTENT_STATUS_PETITIONED ] ) > 0: statuses_to_tags[ HC.CONTENT_STATUS_PENDING ] = set() statuses_to_tags[ HC.CONTENT_STATUS_PETITIONED ] = set() self._combined_is_calculated = False def Duplicate( self ): dupe_service_keys_to_statuses_to_tags = collections.defaultdict( HydrusData.default_dict_set ) for ( service_key, statuses_to_tags ) in self._service_keys_to_statuses_to_tags.items(): dupe_statuses_to_tags = HydrusData.default_dict_set() for ( status, tags ) in statuses_to_tags.items(): dupe_statuses_to_tags[ status ] = set( tags ) dupe_service_keys_to_statuses_to_tags[ service_key ] = dupe_statuses_to_tags return TagsManager( dupe_service_keys_to_statuses_to_tags ) def GetNumTags( self, service_key, include_current_tags = True, include_pending_tags = False ): if service_key == CC.COMBINED_TAG_SERVICE_KEY: self._RecalcCombinedIfNeeded() num_tags = 0 statuses_to_tags = self.GetStatusesToTags( service_key ) if include_current_tags: num_tags += len( statuses_to_tags[ HC.CONTENT_STATUS_CURRENT ] ) if include_pending_tags: num_tags += len( statuses_to_tags[ HC.CONTENT_STATUS_PENDING ] ) return num_tags def GetServiceKeysToStatusesToTags( self ): self._RecalcCombinedIfNeeded() return self._service_keys_to_statuses_to_tags def GetStatusesToTags( self, service_key ): if service_key == CC.COMBINED_TAG_SERVICE_KEY: self._RecalcCombinedIfNeeded() return self._service_keys_to_statuses_to_tags[ service_key ] def HasTag( self, tag ): self._RecalcCombinedIfNeeded() combined_statuses_to_tags = self._service_keys_to_statuses_to_tags[ CC.COMBINED_TAG_SERVICE_KEY ] return tag in combined_statuses_to_tags[ HC.CONTENT_STATUS_CURRENT ] or tag in combined_statuses_to_tags[ HC.CONTENT_STATUS_PENDING ] def NewSiblings( self ): self._combined_is_calculated = False def ProcessContentUpdate( self, service_key, content_update ): statuses_to_tags = self._service_keys_to_statuses_to_tags[ service_key ] ( data_type, action, row ) = content_update.ToTuple() if action == HC.CONTENT_UPDATE_PETITION: ( tag, hashes, reason ) = row else: ( tag, hashes ) = row if action == HC.CONTENT_UPDATE_ADD: statuses_to_tags[ HC.CONTENT_STATUS_CURRENT ].add( tag ) statuses_to_tags[ HC.CONTENT_STATUS_DELETED ].discard( tag ) statuses_to_tags[ HC.CONTENT_STATUS_PENDING ].discard( tag ) elif action == HC.CONTENT_UPDATE_DELETE: statuses_to_tags[ HC.CONTENT_STATUS_DELETED ].add( tag ) statuses_to_tags[ HC.CONTENT_STATUS_CURRENT ].discard( tag ) statuses_to_tags[ HC.CONTENT_STATUS_PETITIONED ].discard( tag ) elif action == HC.CONTENT_UPDATE_PEND: if tag not in statuses_to_tags[ HC.CONTENT_STATUS_CURRENT ]: statuses_to_tags[ HC.CONTENT_STATUS_PENDING ].add( tag ) elif action == HC.CONTENT_UPDATE_RESCIND_PEND: statuses_to_tags[ HC.CONTENT_STATUS_PENDING ].discard( tag ) elif action == HC.CONTENT_UPDATE_PETITION: if tag in statuses_to_tags[ HC.CONTENT_STATUS_CURRENT ]: statuses_to_tags[ HC.CONTENT_STATUS_PETITIONED ].add( tag ) elif action == HC.CONTENT_UPDATE_RESCIND_PETITION: statuses_to_tags[ HC.CONTENT_STATUS_PETITIONED ].discard( tag ) self._combined_is_calculated = False def ResetService( self, service_key ): if service_key in self._service_keys_to_statuses_to_tags: del self._service_keys_to_statuses_to_tags[ service_key ] self._combined_is_calculated = False