def test_SERIALISABLE_TYPE_APPLICATION_COMMAND(self):
def test(obj, dupe_obj):
self.assertEqual(obj.GetCommandType(), dupe_obj.GetCommandType())
self.assertEqual(obj.GetData(), dupe_obj.GetData())
acs = []
acs.append(
(CAC.ApplicationCommand(CAC.APPLICATION_COMMAND_TYPE_SIMPLE,
CAC.SIMPLE_ARCHIVE_FILE), 'archive file'))
acs.append((CAC.ApplicationCommand(
CAC.APPLICATION_COMMAND_TYPE_CONTENT,
(HydrusData.GenerateKey(), HC.CONTENT_TYPE_MAPPINGS,
HC.CONTENT_UPDATE_FLIP, 'test')),
'flip on/off mappings "test" for unknown service!'))
acs.append((CAC.ApplicationCommand(
CAC.APPLICATION_COMMAND_TYPE_CONTENT,
(CC.DEFAULT_LOCAL_TAG_SERVICE_KEY, HC.CONTENT_TYPE_MAPPINGS,
HC.CONTENT_UPDATE_FLIP, 'test')),
'flip on/off mappings "test" for my tags'))
acs.append(
(CAC.ApplicationCommand(
CAC.APPLICATION_COMMAND_TYPE_CONTENT,
(HydrusData.GenerateKey(), HC.CONTENT_TYPE_RATINGS,
HC.CONTENT_UPDATE_SET, 0.4)),
'set ratings uncertain rating, "0.4" for unknown service!'))
for (ac, s) in acs:
self._dump_and_load_and_test(ac, test)
self.assertEqual(ac.ToString(), s)
def test_services( self ):
def test_service( service, key, service_type, name ):
self.assertEqual( service.GetServiceKey(), key )
self.assertEqual( service.GetServiceType(), service_type )
self.assertEqual( service.GetName(), name )
repo_key = HydrusData.GenerateKey()
repo_type = HC.TAG_REPOSITORY
repo_name = 'test tag repo'
repo = ClientServices.GenerateService( repo_key, repo_type, repo_name )
other_key = HydrusData.GenerateKey()
other = ClientServices.GenerateService( other_key, HC.LOCAL_BOORU, 'booru' )
services = []
services.append( repo )
services.append( other )
HG.test_controller.SetRead( 'services', services )
services_manager = ClientManagers.ServicesManager( HG.client_controller )
#
service = services_manager.GetService( repo_key )
test_service( service, repo_key, repo_type, repo_name )
service = services_manager.GetService( other_key )
#
services = services_manager.GetServices( ( HC.TAG_REPOSITORY, ) )
self.assertEqual( len( services ), 1 )
self.assertEqual( services[0].GetServiceKey(), repo_key )
#
services = []
services.append( repo )
HG.test_controller.SetRead( 'services', services )
services_manager.RefreshServices()
self.assertRaises( Exception, services_manager.GetService, other_key )
def setUpClass( cls ):
cls._access_key = HydrusData.GenerateKey()
cls._serverside_file_service = HydrusNetwork.GenerateService( HydrusData.GenerateKey(), HC.FILE_REPOSITORY, 'file repo', HC.DEFAULT_SERVICE_PORT + 1 )
cls._serverside_tag_service = HydrusNetwork.GenerateService( HydrusData.GenerateKey(), HC.TAG_REPOSITORY, 'tag repo', HC.DEFAULT_SERVICE_PORT )
cls._serverside_admin_service = HydrusNetwork.GenerateService( HydrusData.GenerateKey(), HC.SERVER_ADMIN, 'server admin', HC.DEFAULT_SERVER_ADMIN_PORT )
cls._clientside_file_service = ClientServices.GenerateService( HydrusData.GenerateKey(), HC.FILE_REPOSITORY, 'file repo' )
cls._clientside_tag_service = ClientServices.GenerateService( HydrusData.GenerateKey(), HC.TAG_REPOSITORY, 'tag repo' )
cls._clientside_admin_service = ClientServices.GenerateService( HydrusData.GenerateKey(), HC.SERVER_ADMIN, 'server admin' )
cls._clientside_file_service.SetCredentials( HydrusNetwork.Credentials( '127.0.0.1', HC.DEFAULT_SERVICE_PORT + 1, cls._access_key ) )
cls._clientside_tag_service.SetCredentials( HydrusNetwork.Credentials( '127.0.0.1', HC.DEFAULT_SERVICE_PORT, cls._access_key ) )
cls._clientside_admin_service.SetCredentials( HydrusNetwork.Credentials( '127.0.0.1', HC.DEFAULT_SERVER_ADMIN_PORT, cls._access_key ) )
cls._local_booru = ClientServices.GenerateService( CC.LOCAL_BOORU_SERVICE_KEY, HC.LOCAL_BOORU, 'local booru' )
services_manager = HG.test_controller.services_manager
services_manager._keys_to_services[ cls._clientside_file_service.GetServiceKey() ] = cls._clientside_file_service
services_manager._keys_to_services[ cls._clientside_tag_service.GetServiceKey() ] = cls._clientside_tag_service
services_manager._keys_to_services[ cls._clientside_admin_service.GetServiceKey() ] = cls._clientside_admin_service
permissions = [ HC.GET_DATA, HC.POST_DATA, HC.POST_PETITIONS, HC.RESOLVE_PETITIONS, HC.MANAGE_USERS, HC.GENERAL_ADMIN, HC.EDIT_SERVICES ]
account_key = HydrusData.GenerateKey()
account_type = HydrusNetwork.AccountType.GenerateAdminAccountType( HC.SERVER_ADMIN )
created = HydrusData.GetNow() - 100000
expires = None
cls._account = HydrusNetwork.Account( account_key, account_type, created, expires )
cls._file_hash = HydrusData.GenerateKey()
def TWISTEDSetup():
cls._ssl_cert_path = os.path.join( TestController.DB_DIR, 'server.crt' )
cls._ssl_key_path = os.path.join( TestController.DB_DIR, 'server.key' )
# if db test ran, this is still hanging around and read-only, so don't bother to fail overwriting
if not os.path.exists( cls._ssl_cert_path ):
HydrusEncryption.GenerateOpenSSLCertAndKeyFile( cls._ssl_cert_path, cls._ssl_key_path )
context_factory = twisted.internet.ssl.DefaultOpenSSLContextFactory( cls._ssl_key_path, cls._ssl_cert_path )
reactor.listenSSL( HC.DEFAULT_SERVER_ADMIN_PORT, ServerServer.HydrusServiceAdmin( cls._serverside_admin_service ), context_factory )
reactor.listenSSL( HC.DEFAULT_SERVICE_PORT + 1, ServerServer.HydrusServiceRepositoryFile( cls._serverside_file_service ), context_factory )
reactor.listenSSL( HC.DEFAULT_SERVICE_PORT, ServerServer.HydrusServiceRepositoryTag( cls._serverside_tag_service ), context_factory )
reactor.listenTCP( 45866, ClientLocalServer.HydrusServiceBooru( cls._local_booru, allow_non_local_connections = False ) )
reactor.callFromThread( TWISTEDSetup )
time.sleep( 3 )
def test_undo( self ):
hash_1 = HydrusData.GenerateKey()
hash_2 = HydrusData.GenerateKey()
hash_3 = HydrusData.GenerateKey()
command_1 = { CC.COMBINED_LOCAL_FILE_SERVICE_KEY : [ HydrusData.ContentUpdate( HC.CONTENT_TYPE_FILES, HC.CONTENT_UPDATE_ARCHIVE, { hash_1 } ) ] }
command_2 = { CC.COMBINED_LOCAL_FILE_SERVICE_KEY : [ HydrusData.ContentUpdate( HC.CONTENT_TYPE_FILES, HC.CONTENT_UPDATE_INBOX, { hash_2 } ) ] }
command_3 = { CC.COMBINED_LOCAL_FILE_SERVICE_KEY : [ HydrusData.ContentUpdate( HC.CONTENT_TYPE_FILES, HC.CONTENT_UPDATE_ARCHIVE, { hash_1, hash_3 } ) ] }
command_1_inverted = { CC.COMBINED_LOCAL_FILE_SERVICE_KEY : [ HydrusData.ContentUpdate( HC.CONTENT_TYPE_FILES, HC.CONTENT_UPDATE_INBOX, { hash_1 } ) ] }
command_2_inverted = { CC.COMBINED_LOCAL_FILE_SERVICE_KEY : [ HydrusData.ContentUpdate( HC.CONTENT_TYPE_FILES, HC.CONTENT_UPDATE_ARCHIVE, { hash_2 } ) ] }
undo_manager = ClientManagers.UndoManager( HG.client_controller )
#
HG.test_controller.ClearWrites( 'content_updates' )
undo_manager.AddCommand( 'content_updates', command_1 )
self.assertEqual( ( 'undo archive 1 files', None ), undo_manager.GetUndoRedoStrings() )
undo_manager.AddCommand( 'content_updates', command_2 )
self.assertEqual( ( 'undo inbox 1 files', None ), undo_manager.GetUndoRedoStrings() )
undo_manager.Undo()
self.assertEqual( ( 'undo archive 1 files', 'redo inbox 1 files' ), undo_manager.GetUndoRedoStrings() )
self.assertEqual( HG.test_controller.GetWrite( 'content_updates' ), [ ( ( command_2_inverted, ), {} ) ] )
undo_manager.Redo()
self.assertEqual( HG.test_controller.GetWrite( 'content_updates' ), [ ( ( command_2, ), {} ) ] )
self.assertEqual( ( 'undo inbox 1 files', None ), undo_manager.GetUndoRedoStrings() )
undo_manager.Undo()
self.assertEqual( HG.test_controller.GetWrite( 'content_updates' ), [ ( ( command_2_inverted, ), {} ) ] )
undo_manager.Undo()
self.assertEqual( HG.test_controller.GetWrite( 'content_updates' ), [ ( ( command_1_inverted, ), {} ) ] )
self.assertEqual( ( None, 'redo archive 1 files' ), undo_manager.GetUndoRedoStrings() )
undo_manager.AddCommand( 'content_updates', command_3 )
self.assertEqual( ( 'undo archive 2 files', None ), undo_manager.GetUndoRedoStrings() )
def _GetTracker( self, network_context: ClientNetworkingContexts.NetworkContext, making_it_dirty = False ):
if network_context not in self._network_contexts_to_tracker_containers:
bandwidth_tracker = HydrusNetworking.BandwidthTracker()
tracker_container_name = HydrusData.GenerateKey().hex()
tracker_container = NetworkBandwidthManagerTrackerContainer( tracker_container_name, network_context = network_context, bandwidth_tracker = bandwidth_tracker )
self._tracker_container_names_to_tracker_containers[ tracker_container_name ] = tracker_container
self._network_contexts_to_tracker_containers[ network_context ] = tracker_container
# note this discards ephemeral network contexts, which have temporary identifiers that are generally invisible to the user
if not network_context.IsEphemeral():
self._tracker_container_names.add( tracker_container_name )
self._dirty_tracker_container_names.add( tracker_container_name )
self._SetDirty()
tracker_container = self._network_contexts_to_tracker_containers[ network_context ]
if making_it_dirty and not network_context.IsEphemeral():
self._dirty_tracker_container_names.add( tracker_container.GetName() )
return tracker_container.bandwidth_tracker
def __init__( self, name = 'new api permissions', access_key = None, basic_permissions = None, search_tag_filter = None ):
if access_key is None:
access_key = HydrusData.GenerateKey()
if basic_permissions is None:
basic_permissions = set()
if search_tag_filter is None:
search_tag_filter = HydrusTags.TagFilter()
HydrusSerialisable.SerialisableBaseNamed.__init__( self, name )
self._access_key = access_key
self._basic_permissions = set( basic_permissions )
self._search_tag_filter = search_tag_filter
self._last_search_results = None
self._search_results_timeout = 0
self._lock = threading.Lock()
def _test_content_creation(self):
tag = 'character:samus aran'
hash = HydrusData.GenerateKey()
mappings_content = HydrusNetwork.Content(HC.CONTENT_TYPE_MAPPINGS,
(tag, (hash, )))
mapping_content = HydrusNetwork.Content(HC.CONTENT_TYPE_MAPPING,
(tag, hash))
client_to_server_update = HydrusNetwork.ClientToServerUpdate()
client_to_server_update.AddContent(HC.CONTENT_UPDATE_PEND,
mappings_content)
self._write('update', self._tag_service_key,
self._tag_service_regular_account, client_to_server_update,
HydrusData.GetNow())
# can extend this to generate and fetch an actual update given a timespan
#
result = self._read('account_from_content', self._tag_service_key,
mapping_content)
self.assertEqual(result.GetAccountKey(),
self._tag_service_regular_account.GetAccountKey())
def __init__(self):
HydrusSerialisable.SerialisableBase.__init__(self)
file_import_options = HG.client_controller.new_options.GetDefaultFileImportOptions(
'loud')
self._pending_jobs = []
self._gallery_seed_log = ClientImportGallerySeeds.GallerySeedLog()
self._file_seed_cache = ClientImportFileSeeds.FileSeedCache()
self._file_import_options = file_import_options
self._formula_name = 'all files linked by images in page'
self._queue_paused = False
self._files_paused = False
self._downloader_key = HydrusData.GenerateKey()
self._parser_status = ''
self._current_action = ''
self._lock = threading.Lock()
self._have_started = False
self._files_network_job = None
self._page_network_job = None
self._files_repeating_job = None
self._queue_repeating_job = None
self._last_serialisable_change_timestamp = 0
HG.client_controller.sub(self, 'NotifyFileSeedsUpdated',
'file_seed_cache_file_seeds_updated')
def __init__(self, url=None, can_generate_more_pages=True):
if url is None:
url = 'https://nostrils-central.cx/index.php?post=s&tag=hyper_nostrils&page=3'
else:
try:
url = HG.client_controller.network_engine.domain_manager.NormaliseURL(
url)
except HydrusExceptions.URLClassException:
pass
HydrusSerialisable.SerialisableBase.__init__(self)
self.url = url
self._can_generate_more_pages = can_generate_more_pages
self._fixed_service_keys_to_tags = ClientTags.ServiceKeysToTags()
self.created = HydrusData.GetNow()
self.modified = self.created
self.status = CC.STATUS_UNKNOWN
self.note = ''
self._referral_url = None
self._force_next_page_url_generation = False
self._run_token = HydrusData.GenerateKey()
def __init__( self ):
HydrusSerialisable.SerialisableBase.__init__( self )
self._gallery_seed_log = ClientImportGallerySeeds.GallerySeedLog()
self._file_seed_cache = ClientImportFileSeeds.FileSeedCache()
self._file_import_options = HG.client_controller.new_options.GetDefaultFileImportOptions( 'loud' )
self._tag_import_options = TagImportOptions.TagImportOptions( is_default = True )
self._paused = False
self._no_work_until = 0
self._no_work_until_reason = ''
self._page_key = b'initialising page key'
self._downloader_key = HydrusData.GenerateKey()
self._lock = threading.Lock()
self._have_started = False
self._files_status = ''
self._gallery_status = ''
self._files_network_job = None
self._gallery_network_job = None
self._files_repeating_job = None
self._gallery_repeating_job = None
self._last_serialisable_change_timestamp = 0
HG.client_controller.sub( self, 'NotifyFileSeedsUpdated', 'file_seed_cache_file_seeds_updated' )
HG.client_controller.sub( self, 'NotifyGallerySeedsUpdated', 'gallery_seed_log_gallery_seeds_updated' )
def __init__(self, parent: QW.QWidget, predicate: ClientSearch.Predicate):
QW.QWidget.__init__(self, parent)
from hydrus.client.gui.search import ClientGUIACDropdown
if predicate.GetType() != ClientSearch.PREDICATE_TYPE_OR_CONTAINER:
raise Exception(
'Launched an ORPredicateControl without an OR Pred!')
predicates = predicate.GetValue()
page_key = HydrusData.GenerateKey()
file_search_context = ClientSearch.FileSearchContext(
file_service_key=CC.LOCAL_FILE_SERVICE_KEY, predicates=predicates)
self._search_control = ClientGUIACDropdown.AutoCompleteDropdownTagsRead(
self,
page_key,
file_search_context,
hide_favourites_edit_actions=True)
vbox = QP.VBoxLayout()
QP.AddToLayout(vbox, self._search_control, CC.FLAGS_EXPAND_BOTH_WAYS)
self.setLayout(vbox)
def _test_server_admin(self, service):
# init
access_key = HydrusData.GenerateKey()
HG.test_controller.SetRead('access_key', access_key)
response = service.Request(HC.GET, 'access_key',
{'registration_key': b'init'})
self.assertEqual(response['access_key'], access_key)
#
response = service.Request(HC.GET, 'busy')
self.assertEqual(response, b'0')
response = service.Request(HC.POST, 'lock_on')
response = service.Request(HC.GET, 'busy')
self.assertEqual(response, b'1')
response = service.Request(HC.POST, 'lock_off')
response = service.Request(HC.GET, 'busy')
self.assertEqual(response, b'0')
#
response = service.Request(HC.POST, 'backup')
response = service.Request(HC.POST, 'vacuum')
def __init__(self):
HydrusSerialisable.SerialisableBase.__init__(self)
self._gallery_seed_log = ClientImportGallerySeeds.GallerySeedLog()
self._file_seed_cache = ClientImportFileSeeds.FileSeedCache()
self._file_import_options = HG.client_controller.new_options.GetDefaultFileImportOptions(
'loud')
self._tag_import_options = ClientImportOptions.TagImportOptions(
is_default=True)
self._paused = False
self._downloader_key = HydrusData.GenerateKey()
self._lock = threading.Lock()
self._files_network_job = None
self._gallery_network_job = None
self._files_repeating_job = None
self._gallery_repeating_job = None
HG.client_controller.sub(self, 'NotifyFileSeedsUpdated',
'file_seed_cache_file_seeds_updated')
HG.client_controller.sub(self, 'NotifyGallerySeedsUpdated',
'gallery_seed_log_gallery_seeds_updated')
def _Add(self, service_type):
service_key = HydrusData.GenerateKey()
port = self._GetNextPort()
name = 'new service'
dictionary = HydrusNetwork.GenerateDefaultServiceDictionary(
service_type)
service = HydrusNetwork.GenerateService(service_key, service_type,
name, port, dictionary)
with ClientGUITopLevelWindowsPanels.DialogEdit(
self, 'edit serverside service') as dlg_edit:
panel = EditServersideService(dlg_edit, service)
dlg_edit.SetPanel(panel)
if dlg_edit.exec() == QW.QDialog.Accepted:
new_service = panel.GetValue()
self._services_listctrl.SetNonDupeName(new_service)
self._SetNonDupePort(new_service)
self._services_listctrl.AddDatas((new_service, ))
def ConvertLegacyToNewBandwidth(
legacy_bandwidth_manager: NetworkBandwidthManagerLegacy):
tracker_containers = []
(network_contexts_to_bandwidth_trackers,
network_contexts_to_bandwidth_rules) = legacy_bandwidth_manager.GetData()
for (network_context,
bandwidth_tracker) in network_contexts_to_bandwidth_trackers.items():
tracker_container_name = HydrusData.GenerateKey().hex()
tracker_container = ClientNetworkingBandwidth.NetworkBandwidthManagerTrackerContainer(
tracker_container_name,
network_context=network_context,
bandwidth_tracker=bandwidth_tracker)
tracker_containers.append(tracker_container)
bandwidth_manager = ClientNetworkingBandwidth.NetworkBandwidthManager()
for (network_context,
bandwidth_rules) in network_contexts_to_bandwidth_rules.items():
bandwidth_manager.SetRules(network_context, bandwidth_rules)
bandwidth_manager.SetTrackerContainers(tracker_containers,
set_all_trackers_dirty=True)
bandwidth_manager.SetDirty()
return bandwidth_manager
def _test_service_creation(self):
self._tag_service_key = HydrusData.GenerateKey()
self._file_service_key = HydrusData.GenerateKey()
current_services = self._read('services')
self._tag_service = HydrusNetwork.GenerateService(
self._tag_service_key, HC.TAG_REPOSITORY, 'tag repo', 100)
self._file_service = HydrusNetwork.GenerateService(
self._file_service_key, HC.FILE_REPOSITORY, 'file repo', 101)
new_services = list(current_services)
new_services.append(self._tag_service)
new_services.append(self._file_service)
service_keys_to_access_keys = self._write('services',
self._admin_account,
new_services)
self.assertEqual(set(service_keys_to_access_keys.keys()),
{self._tag_service_key, self._file_service_key})
self._tag_service_access_key = service_keys_to_access_keys[
self._tag_service_key]
self._file_service_access_key = service_keys_to_access_keys[
self._file_service_key]
self._tag_service_account_key = self._read(
'account_key_from_access_key', self._tag_service_key,
self._tag_service_access_key)
self._file_service_account_key = self._read(
'account_key_from_access_key', self._file_service_key,
self._file_service_access_key)
self._tag_service_account = self._read('account',
self._tag_service_key,
self._tag_service_account_key)
self._file_service_account = self._read('account',
self._file_service_key,
self._file_service_account_key)
self.assertEqual(self._tag_service_account.GetAccountKey(),
self._tag_service_account_key)
self.assertEqual(self._file_service_account.GetAccountKey(),
self._file_service_account_key)
def GenerateSessionKey( self, access_key ):
session_key = HydrusData.GenerateKey()
with self._lock:
self._session_keys_to_access_keys_and_expirys[ session_key ] = ( access_key, HydrusData.GetNow() + SESSION_EXPIRY )
return session_key
def _PopulateTagIdsToTagsCache( self, tag_ids ):
if len( self._tag_ids_to_tags_cache ) > 100000:
if not isinstance( tag_ids, set ):
tag_ids = set( tag_ids )
self._tag_ids_to_tags_cache = { tag_id : tag for ( tag_id, tag ) in self._tag_ids_to_tags_cache.items() if tag_id in tag_ids }
uncached_tag_ids = { tag_id for tag_id in tag_ids if tag_id not in self._tag_ids_to_tags_cache }
if len( uncached_tag_ids ) > 0:
if len( uncached_tag_ids ) == 1:
( uncached_tag_id, ) = uncached_tag_ids
rows = self._c.execute( 'SELECT tag_id, namespace, subtag FROM tags NATURAL JOIN namespaces NATURAL JOIN subtags WHERE tag_id = ?;', ( uncached_tag_id, ) ).fetchall()
else:
with HydrusDB.TemporaryIntegerTable( self._c, uncached_tag_ids, 'tag_id' ) as temp_table_name:
# temp tag_ids to tags to subtags and namespaces
rows = self._c.execute( 'SELECT tag_id, namespace, subtag FROM {} CROSS JOIN tags USING ( tag_id ) CROSS JOIN subtags USING ( subtag_id ) CROSS JOIN namespaces USING ( namespace_id );'.format( temp_table_name ) ).fetchall()
uncached_tag_ids_to_tags = { tag_id : HydrusTags.CombineTag( namespace, subtag ) for ( tag_id, namespace, subtag ) in rows }
if len( uncached_tag_ids_to_tags ) < len( uncached_tag_ids ):
for tag_id in uncached_tag_ids:
if tag_id not in uncached_tag_ids_to_tags:
tag = 'unknown tag:' + HydrusData.GenerateKey().hex()
( namespace, subtag ) = HydrusTags.SplitTag( tag )
namespace_id = self.GetNamespaceId( namespace )
subtag_id = self.GetSubtagId( subtag )
self._c.execute( 'REPLACE INTO tags ( tag_id, namespace_id, subtag_id ) VALUES ( ?, ?, ? );', ( tag_id, namespace_id, subtag_id ) )
uncached_tag_ids_to_tags[ tag_id ] = tag
self._tag_ids_to_tags_cache.update( uncached_tag_ids_to_tags )
def _do_fake_imports(self):
self._md5_to_sha256 = {}
self._sha256_to_md5 = {}
self._sha256_to_sha1 = {}
self._my_files_sha256 = set()
self._hashes_to_current_tags = {}
self._hashes_to_pending_tags = {}
self._hashes_to_deleted_tags = {}
(size, mime, width, height, duration, num_frames, has_audio,
num_words) = (65535, HC.IMAGE_JPEG, 640, 480, None, None, False, None)
file_import_options = HG.client_controller.new_options.GetDefaultFileImportOptions(
'loud')
for i in range(100):
hash = HydrusData.GenerateKey()
md5 = os.urandom(16)
sha1 = os.urandom(20)
sha512 = os.urandom(64)
self._md5_to_sha256[md5] = hash
self._sha256_to_md5[hash] = md5
self._sha256_to_sha1[hash] = sha1
self._hashes_to_current_tags[hash] = set(
random.sample(current_tag_pool, 3))
self._hashes_to_pending_tags[hash] = set(
random.sample(pending_tag_pool, 3))
self._hashes_to_deleted_tags[hash] = set(
random.sample(deleted_tag_pool, 3))
if i < 50:
fake_file_import_job = ClientImportFiles.FileImportJob(
'fake path', file_import_options)
fake_file_import_job._pre_import_file_status = ClientImportFiles.FileImportStatus(
CC.STATUS_UNKNOWN, hash)
fake_file_import_job._file_info = (size, mime, width, height,
duration, num_frames,
has_audio, num_words)
fake_file_import_job._extra_hashes = (md5, sha1, sha512)
fake_file_import_job._perceptual_hashes = [os.urandom(8)]
fake_file_import_job._file_import_options = FileImportOptions.FileImportOptions(
)
self.WriteSynchronous('import_file', fake_file_import_job)
self._my_files_sha256.add(hash)
def __init__(self):
HydrusSerialisable.SerialisableBase.__init__(self)
self._page_key = 'initialising page key'
self._publish_to_page = False
self._url = ''
self._gallery_seed_log = ClientImportGallerySeeds.GallerySeedLog()
self._file_seed_cache = ClientImportFileSeeds.FileSeedCache()
self._fixed_service_keys_to_tags = ClientTags.ServiceKeysToTags()
self._checker_options = HG.client_controller.new_options.GetDefaultWatcherCheckerOptions(
)
self._file_import_options = HG.client_controller.new_options.GetDefaultFileImportOptions(
'loud')
self._tag_import_options = ClientImportOptions.TagImportOptions(
is_default=True)
self._last_check_time = 0
self._checking_status = ClientImporting.CHECKER_STATUS_OK
self._subject = 'unknown subject'
self._next_check_time = None
self._file_network_job = None
self._checker_network_job = None
self._check_now = False
self._files_paused = False
self._checking_paused = False
self._no_work_until = 0
self._no_work_until_reason = ''
self._creation_time = HydrusData.GetNow()
self._file_velocity_status = ''
self._file_status = ''
self._watcher_status = ''
self._watcher_key = HydrusData.GenerateKey()
self._lock = threading.Lock()
self._last_pubbed_page_name = ''
self._files_repeating_job = None
self._checker_repeating_job = None
HG.client_controller.sub(self, 'NotifyFileSeedsUpdated',
'file_seed_cache_file_seeds_updated')
def test_SERIALISABLE_TYPE_SUBSCRIPTION( self ):
def test( obj, dupe_obj ):
self.assertEqual( obj.GetName(), dupe_obj.GetName() )
self.assertEqual( obj._gug_key_and_name, dupe_obj._gug_key_and_name )
self.assertEqual( len( obj._queries ), len( dupe_obj._queries ) )
self.assertEqual( obj._initial_file_limit, dupe_obj._initial_file_limit )
self.assertEqual( obj._periodic_file_limit, dupe_obj._periodic_file_limit )
self.assertEqual( obj._paused, dupe_obj._paused )
self.assertEqual( obj._file_import_options.GetSerialisableTuple(), dupe_obj._file_import_options.GetSerialisableTuple() )
self.assertEqual( obj._tag_import_options.GetSerialisableTuple(), dupe_obj._tag_import_options.GetSerialisableTuple() )
self.assertEqual( obj._no_work_until, dupe_obj._no_work_until )
sub = ClientImportSubscriptions.Subscription( 'test sub' )
self._dump_and_load_and_test( sub, test )
gug_key_and_name = ( HydrusData.GenerateKey(), 'muh test gug' )
queries = [ ClientImportSubscriptionQuery.SubscriptionQuery( 'test query' ), ClientImportSubscriptionQuery.SubscriptionQuery( 'test query 2' ) ]
checker_options = ClientImportOptions.CheckerOptions()
initial_file_limit = 100
periodic_file_limit = 50
paused = False
file_import_options = ClientImportOptions.FileImportOptions()
service_tag_import_options = ClientImportOptions.ServiceTagImportOptions( get_tags = False, additional_tags = { 'test additional tag', 'and another' } )
tag_import_options = ClientImportOptions.TagImportOptions( service_keys_to_service_tag_import_options = { HydrusData.GenerateKey() : service_tag_import_options } )
no_work_until = HydrusData.GetNow() - 86400 * 20
sub.SetTuple( gug_key_and_name, checker_options, initial_file_limit, periodic_file_limit, paused, file_import_options, tag_import_options, no_work_until )
sub.SetQueries( queries )
self.assertEqual( sub.GetGUGKeyAndName(), gug_key_and_name )
self.assertEqual( sub.GetTagImportOptions(), tag_import_options )
self.assertEqual( sub.GetQueries(), queries )
self.assertEqual( sub._paused, False )
sub.PauseResume()
self.assertEqual( sub._paused, True )
sub.PauseResume()
self.assertEqual( sub._paused, False )
self._dump_and_load_and_test( sub, test )
def test_basics(self):
def test(obj, dupe_obj):
self.assertEqual(len(list(obj.items())),
len(list(dupe_obj.items())))
for (key, value) in list(obj.items()):
self.assertEqual(value, dupe_obj[key])
#
d = HydrusSerialisable.SerialisableDictionary()
d[1] = 2
d[3] = 'test1'
d['test2'] = 4
d['test3'] = 5
d[6] = HydrusSerialisable.SerialisableDictionary(
{i: 'test' + str(i)
for i in range(20)})
d[ClientSearch.Predicate(ClientSearch.PREDICATE_TYPE_TAG,
'test pred 1')] = 56
d[ClientSearch.Predicate(
ClientSearch.PREDICATE_TYPE_TAG,
'test pred 2')] = HydrusSerialisable.SerialisableList([
ClientSearch.Predicate(ClientSearch.PREDICATE_TYPE_TAG,
'test' + str(i)) for i in range(10)
])
self.assertEqual(len(list(d.keys())), 7)
for (key, value) in list(d.items()):
self.assertEqual(d[key], value)
self._dump_and_load_and_test(d, test)
#
db = HydrusSerialisable.SerialisableBytesDictionary()
db[HydrusData.GenerateKey()] = HydrusData.GenerateKey()
db[HydrusData.GenerateKey()] = [
HydrusData.GenerateKey() for i in range(10)
]
db[1] = HydrusData.GenerateKey()
db[2] = [HydrusData.GenerateKey() for i in range(10)]
self.assertEqual(len(list(db.keys())), 4)
for (key, value) in list(db.items()):
self.assertEqual(db[key], value)
self._dump_and_load_and_test(db, test)
def test_SERIALISABLE_TYPE_APPLICATION_COMMAND(self):
def test(obj, dupe_obj):
self.assertEqual(obj.GetCommandType(), dupe_obj.GetCommandType())
self.assertSequenceEqual(tuple(obj._data), tuple(dupe_obj._data))
acs = []
acs.append((CAC.ApplicationCommand.STATICCreateSimpleCommand(
CAC.SIMPLE_ARCHIVE_FILE), 'archive file'))
acs.append((CAC.ApplicationCommand.STATICCreateSimpleCommand(
CAC.SIMPLE_MEDIA_SEEK_DELTA,
simple_data=(-1, 2500)), 'seek media (back 2.5 seconds)'))
acs.append((CAC.ApplicationCommand.STATICCreateSimpleCommand(
CAC.SIMPLE_MEDIA_SEEK_DELTA,
simple_data=(1, 800)), 'seek media (forwards 800 milliseconds)'))
acs.append((CAC.ApplicationCommand(
CAC.APPLICATION_COMMAND_TYPE_CONTENT,
(HydrusData.GenerateKey(), HC.CONTENT_TYPE_MAPPINGS,
HC.CONTENT_UPDATE_FLIP, 'test')),
'flip on/off mappings "test" for unknown service!'))
acs.append((CAC.ApplicationCommand(
CAC.APPLICATION_COMMAND_TYPE_CONTENT,
(CC.DEFAULT_LOCAL_TAG_SERVICE_KEY, HC.CONTENT_TYPE_MAPPINGS,
HC.CONTENT_UPDATE_FLIP, 'test')),
'flip on/off mappings "test" for my tags'))
acs.append(
(CAC.ApplicationCommand(
CAC.APPLICATION_COMMAND_TYPE_CONTENT,
(HydrusData.GenerateKey(), HC.CONTENT_TYPE_RATINGS,
HC.CONTENT_UPDATE_SET, 0.4)),
'set ratings uncertain rating, "0.4" for unknown service!'))
for (ac, s) in acs:
self._dump_and_load_and_test(ac, test)
self.assertEqual(ac.ToString(), s)
def __init__( self ):
HydrusSerialisable.SerialisableBase.__init__( self )
self._gallery_seeds = HydrusSerialisable.SerialisableList()
self._gallery_seeds_to_indices = {}
self._gallery_seed_log_key = HydrusData.GenerateKey()
self._status_cache = None
self._status_dirty = True
self._lock = threading.Lock()
def ConvertGalleryIdentifierToGUGKeyAndName(gallery_identifier):
gug_name = ConvertGalleryIdentifierToGUGName(gallery_identifier)
from hydrus.client import ClientDefaults
gugs = ClientDefaults.GetDefaultGUGs()
for gug in gugs:
if gug.GetName() == gug_name:
return gug.GetGUGKeyAndName()
return (HydrusData.GenerateKey(), gug_name)
def __init__(self,
pausable=False,
cancellable=False,
maintenance_mode=HC.MAINTENANCE_FORCED,
only_start_if_unbusy=False,
stop_time=None,
cancel_on_shutdown=True):
self._key = HydrusData.GenerateKey()
self._creation_time = HydrusData.GetNowFloat()
self._pausable = pausable
self._cancellable = cancellable
self._maintenance_mode = maintenance_mode
self._only_start_if_unbusy = only_start_if_unbusy
self._stop_time = stop_time
self._cancel_on_shutdown = cancel_on_shutdown
self._start_time = HydrusData.GetNow()
self._deleted = threading.Event()
self._deletion_time = None
self._begun = threading.Event()
self._done = threading.Event()
self._cancelled = threading.Event()
self._paused = threading.Event()
self._ui_update_pause_period = 0.1
self._next_ui_update_pause = HydrusData.GetNowFloat(
) + self._ui_update_pause_period
self._yield_pause_period = 10
self._next_yield_pause = HydrusData.GetNow() + self._yield_pause_period
self._bigger_pause_period = 100
self._next_bigger_pause = HydrusData.GetNow(
) + self._bigger_pause_period
self._longer_pause_period = 1000
self._next_longer_pause = HydrusData.GetNow(
) + self._longer_pause_period
self._exception = None
self._urls = []
self._variable_lock = threading.Lock()
self._variables = dict()
def test_SERIALISABLE_TYPE_SHORTCUT_SET( self ):
def test( obj, dupe_obj ):
for ( shortcut, command ) in obj:
self.assertEqual( dupe_obj.GetCommand( shortcut ).GetData(), command.GetData() )
default_shortcuts = ClientDefaults.GetDefaultShortcuts()
for shortcuts in default_shortcuts:
self._dump_and_load_and_test( shortcuts, test )
command_1 = CAC.ApplicationCommand( CAC.APPLICATION_COMMAND_TYPE_SIMPLE, CAC.SIMPLE_ARCHIVE_FILE )
command_2 = CAC.ApplicationCommand( CAC.APPLICATION_COMMAND_TYPE_CONTENT, ( HydrusData.GenerateKey(), HC.CONTENT_TYPE_MAPPINGS, HC.CONTENT_UPDATE_FLIP, 'test' ) )
command_3 = CAC.ApplicationCommand( CAC.APPLICATION_COMMAND_TYPE_CONTENT, ( CC.DEFAULT_LOCAL_TAG_SERVICE_KEY, HC.CONTENT_TYPE_MAPPINGS, HC.CONTENT_UPDATE_FLIP, 'test' ) )
k_shortcut_1 = ClientGUIShortcuts.Shortcut( ClientGUIShortcuts.SHORTCUT_TYPE_KEYBOARD_SPECIAL, ClientGUIShortcuts.SHORTCUT_KEY_SPECIAL_SPACE, ClientGUIShortcuts.SHORTCUT_PRESS_TYPE_PRESS, [] )
k_shortcut_2 = ClientGUIShortcuts.Shortcut( ClientGUIShortcuts.SHORTCUT_TYPE_KEYBOARD_CHARACTER, ord( 'a' ), ClientGUIShortcuts.SHORTCUT_PRESS_TYPE_PRESS, [ ClientGUIShortcuts.SHORTCUT_MODIFIER_CTRL ] )
k_shortcut_3 = ClientGUIShortcuts.Shortcut( ClientGUIShortcuts.SHORTCUT_TYPE_KEYBOARD_CHARACTER, ord( 'A' ), ClientGUIShortcuts.SHORTCUT_PRESS_TYPE_PRESS, [ ClientGUIShortcuts.SHORTCUT_MODIFIER_CTRL ] )
k_shortcut_4 = ClientGUIShortcuts.Shortcut( ClientGUIShortcuts.SHORTCUT_TYPE_KEYBOARD_SPECIAL, ClientGUIShortcuts.SHORTCUT_KEY_SPECIAL_HOME, ClientGUIShortcuts.SHORTCUT_PRESS_TYPE_PRESS, [ ClientGUIShortcuts.SHORTCUT_MODIFIER_ALT, ClientGUIShortcuts.SHORTCUT_MODIFIER_CTRL ] )
m_shortcut_1 = ClientGUIShortcuts.Shortcut( ClientGUIShortcuts.SHORTCUT_TYPE_MOUSE, ClientGUIShortcuts.SHORTCUT_MOUSE_LEFT, ClientGUIShortcuts.SHORTCUT_PRESS_TYPE_PRESS, [] )
m_shortcut_2 = ClientGUIShortcuts.Shortcut( ClientGUIShortcuts.SHORTCUT_TYPE_MOUSE, ClientGUIShortcuts.SHORTCUT_MOUSE_MIDDLE, ClientGUIShortcuts.SHORTCUT_PRESS_TYPE_PRESS, [ ClientGUIShortcuts.SHORTCUT_MODIFIER_CTRL ] )
m_shortcut_3 = ClientGUIShortcuts.Shortcut( ClientGUIShortcuts.SHORTCUT_TYPE_MOUSE, ClientGUIShortcuts.SHORTCUT_MOUSE_SCROLL_DOWN, ClientGUIShortcuts.SHORTCUT_PRESS_TYPE_PRESS, [ ClientGUIShortcuts.SHORTCUT_MODIFIER_ALT, ClientGUIShortcuts.SHORTCUT_MODIFIER_SHIFT ] )
shortcut_set = ClientGUIShortcuts.ShortcutSet( 'test' )
shortcut_set.SetCommand( k_shortcut_1, command_1 )
shortcut_set.SetCommand( k_shortcut_2, command_2 )
shortcut_set.SetCommand( k_shortcut_3, command_2 )
shortcut_set.SetCommand( k_shortcut_4, command_3 )
shortcut_set.SetCommand( m_shortcut_1, command_1 )
shortcut_set.SetCommand( m_shortcut_2, command_2 )
shortcut_set.SetCommand( m_shortcut_3, command_3 )
self._dump_and_load_and_test( shortcut_set, test )
self.assertEqual( shortcut_set.GetCommand( k_shortcut_1 ).GetData(), command_1.GetData() )
shortcut_set.SetCommand( k_shortcut_1, command_3 )
self.assertEqual( shortcut_set.GetCommand( k_shortcut_1 ).GetData(), command_3.GetData() )
def _set_up_services( self ):
self._test_tag_repo_service_keys = {}
services = self.Read( 'services' )
for i in range( 20 ):
service_key = HydrusData.GenerateKey()
services.append( ClientServices.GenerateService( service_key, HC.TAG_REPOSITORY, 'test repo {}'.format( i ) ) )
self._test_tag_repo_service_keys[ i ] = service_key
self.WriteSynchronous( 'update_services', services )
self.services_manager = ClientManagers.ServicesManager( self )
def AddSession( self, service_key, access_key ):
with self._lock:
account_key = self._GetAccountKeyFromAccessKey( service_key, access_key )
account = self._GetAccountFromAccountKey( service_key, account_key )
session_key = HydrusData.GenerateKey()
now = HydrusData.GetNow()
expires = now + HYDRUS_SESSION_LIFETIME
HG.controller.Write( 'session', session_key, service_key, account_key, expires )
self._service_keys_to_session_keys_to_sessions[ service_key ][ session_key ] = ( account_key, expires )
return ( session_key, expires )
def _InitialiseSessionContainer( self, network_context ):
session = requests.Session()
if network_context.context_type == CC.NETWORK_CONTEXT_HYDRUS:
session.verify = False
session_container_name = HydrusData.GenerateKey().hex()
session_container = NetworkSessionManagerSessionContainer( session_container_name, network_context = network_context, session = session )
self._session_container_names_to_session_containers[ session_container_name ] = session_container
self._network_contexts_to_session_containers[ network_context ] = session_container
self._session_container_names.add( session_container_name )
self._dirty_session_container_names.add( session_container_name )
self._SetDirty()
