From f6163609be4f31ffdd97354aa1521337722d8e70 Mon Sep 17 00:00:00 2001
From: Hydrus Network Developer <hydrus.admin@gmail.com>
Date: Wed, 2 May 2018 15:45:20 -0500
Subject: [PATCH] Version 305

---
 help/changelog.html                           |   37 +
 include/ClientConstants.py                    |    2 +-
 include/ClientDB.py                           |   58 +-
 include/ClientDownloading.py                  |    9 +-
 include/ClientGUI.py                          |   48 +-
 include/ClientGUIManagement.py                |  157 +-
 include/ClientGUIMedia.py                     |   47 +-
 include/ClientGUIPages.py                     |  136 +-
 include/ClientGUIParsing.py                   |   30 +-
 include/ClientImporting.py                    | 1380 ++++++++++-------
 include/ClientMedia.py                        |    5 +-
 include/ClientParsing.py                      |   71 +-
 include/HydrusConstants.py                    |    2 +-
 include/TestDB.py                             |   25 -
 include/TestHydrusServer.py                   |   50 +-
 .../parsers/danbooru file page parser.png     |  Bin 0 -> 2715 bytes
 .../default/parsers/e621 file page parser.png |  Bin 0 -> 2787 bytes
 .../parsers/pixiv single file page parser.png |  Bin 0 -> 2885 bytes
 .../parsers/safebooru file page parser.png    |  Bin 0 -> 2925 bytes
 .../default/parsers/yiff.party api parser.png |  Bin 0 -> 2856 bytes
 .../default/url_classes/pixiv file page.png   |  Bin 2147 -> 2122 bytes
 .../url_classes/yiff.party creator page.png   |  Bin 0 -> 2267 bytes
 .../yiff.party file attachment.png            |  Bin 0 -> 2426 bytes
 .../url_classes/yiff.party file post.png      |  Bin 0 -> 2236 bytes
 .../url_classes/yiff.party json api.png       |  Bin 0 -> 2156 bytes
 25 files changed, 1320 insertions(+), 737 deletions(-)
 create mode 100644 static/default/parsers/danbooru file page parser.png
 create mode 100644 static/default/parsers/e621 file page parser.png
 create mode 100644 static/default/parsers/pixiv single file page parser.png
 create mode 100644 static/default/parsers/safebooru file page parser.png
 create mode 100644 static/default/parsers/yiff.party api parser.png
 create mode 100644 static/default/url_classes/yiff.party creator page.png
 create mode 100644 static/default/url_classes/yiff.party file attachment.png
 create mode 100644 static/default/url_classes/yiff.party file post.png
 create mode 100644 static/default/url_classes/yiff.party json api.png

diff --git a/help/changelog.html b/help/changelog.html
index df510544..6d15bce8 100755
--- a/help/changelog.html
+++ b/help/changelog.html
@@ -8,6 +8,43 @@
 		<div class="content">
 			<h3>changelog</h3>
 			<ul>
+				<li><h3>version 305</h3></li>
+				<ul>
+					<li>fixed the pixiv url class, which was unintentionally removing a parameter</li>
+					<li>wrote a pixiv parser in the new system, fixing a whole bunch of tag parsing along the way, and also parses 'source time'! by default, pixiv now fetches the translated/romaji versions of tags</li>
+					<li>finished a safebooru parser that also handles source time and source urls</li>
+					<li>finished an e621 parser that also handles source time and source urls and hash!</li>
+					<li>wrote a danbooru parser that also handles source time and source urls and hash!</li>
+					<li>as a result, danbooru, safebooru, e621, and pixiv post urls are now drag-and-droppable onto the client!</li>
+					<li>finished up a full yiff.party watcher from another contribution by @cuddlebear on the discord, including url classes and a full parser, meaning yiff.party artist urls are now droppable onto the client and will spawn thread watchers (I expect to add some kind of subscription support for watchers in the future). inline links are supported, and there is source time and limited filename: and hash parsing</li>
+					<li>fixed some thread watcher tag association problems in the new system</li>
+					<li>when pages put an (x) number after their name for number of files, they will now also put an (x/y) import total (if appropriate and not complete) as well. this also sums up through page of pages!</li>
+					<li>if a call to close a page of pages or the application would present more than one page's 'I am still importing' complaint, all the complaints are now summarised in a single yes/no dialog</li>
+					<li>url downloader pages now run a 'are you sure you want to close this page' when their import queues are unfinished and unpaused</li>
+					<li>if the subscriptions for 'manage subscriptions' take more than a second to load, a popup will come up with load progress. the popup is cancellable</li>
+					<li>added a prototype 'open in web browser' to the thumbnail right-click share menu. it will only appear in windows if you are in advanced mode, as atm it mostly just launches the file in the default program, not browser. I will keep working on this</li>
+					<li>harmonised more old download code into a single location in the new system</li>
+					<li>created a neater network job factory system for generalised network requests at the import job level</li>
+					<li>created a neater presentation context factory system for generalised and reliable set/clear network job ui presentation at the import job level</li>
+					<li>moved the new downloader simple-file-download-and-import to the new file object and harmonised all downloader code to call this single location where possible</li>
+					<li>did the same thing with download-post-and-then-fetch-tags-and-file job and added hooks for in the subscription and gallery downloader loops (where a parser match for the url is found)</li>
+					<li>the simple downloader and urls downloader now use 'downloader instance' network jobs, so they obey a couple more bandwidth rules</li>
+					<li>harmonised how imported media is then presented to pages as thumbnails through the new main import object</li>
+					<li>the new post downloader sets up referral urls for the file download (which are needed for pixiv and anything else picky) automatically</li>
+					<li>improved file download/import error reporting a little</li>
+					<li>entering an invalid regex phrase in the stringmatch panel (as happens all the time as you type it) will now present the error in the status area rather than spamming popups</li>
+					<li>fixed a bug in the new parsing gui that was prohibiting editing a date decode string transformation</li>
+					<li>fixed enabling of additional date decode controls in the string transformations edit panel</li>
+					<li>added a hyperlink to date decoding controls that links to python date decoding explainer</li>
+					<li>if a source time in the new parsing system suggests a time in the future, it will now clip to 30s ago</li>
+					<li>misc downloader refactoring and cleanup</li>
+					<li>fixed an issue where new file lookup scripts were initialising with bad string transformation rows and breaking the whole dialog in subsequent calls, fugg</li>
+					<li>hid the 'find similar files' menu entry for images that have duration (gifs and apngs), which are not yet supported</li>
+					<li>added 'flip_debug_force_idle_mode_do_not_set_this' to main_gui shortcut set. only set it if you are an advanced user and prepared for the potential consequences</li>
+					<li>silenced a problem with newgrounds gallery parser--will fix it properly next week</li>
+					<li>fixed some old busted unit test code</li>
+					<li>rejiggered some thumb dupe menu entry layout</li>
+				</ul>
 				<li><h3>version 304</h3></li>
 				<ul>
 					<li>renamed the new 'tagcensor' object to 'tagfilter' (since it will end up doing a bunch of non-censoring jobs) and refactored it into clienttags</li>
diff --git a/include/ClientConstants.py b/include/ClientConstants.py
index 050bad00..f78a2dc9 100755
--- a/include/ClientConstants.py
+++ b/include/ClientConstants.py
@@ -339,7 +339,7 @@ SHORTCUTS_RESERVED_NAMES = [ 'archive_delete_filter', 'duplicate_filter', 'media
 SHORTCUTS_MEDIA_ACTIONS = [ 'manage_file_tags', 'manage_file_ratings', 'manage_file_urls', 'manage_file_notes', 'archive_file', 'inbox_file', 'delete_file', 'export_files', 'remove_file_from_view', 'open_file_in_external_program', 'open_selection_in_new_page', 'launch_the_archive_delete_filter', 'copy_bmp', 'copy_file', 'copy_path', 'copy_sha256_hash', 'get_similar_to_exact', 'get_similar_to_very_similar', 'get_similar_to_similar', 'get_similar_to_speculative', 'duplicate_media_remove_relationships', 'duplicate_media_reset_to_potential', 'duplicate_media_set_alternate', 'duplicate_media_set_custom', 'duplicate_media_set_focused_better', 'duplicate_media_set_not_duplicate', 'duplicate_media_set_same_quality' ]
 SHORTCUTS_MEDIA_VIEWER_ACTIONS = [ 'move_animation_to_previous_frame', 'move_animation_to_next_frame', 'switch_between_fullscreen_borderless_and_regular_framed_window', 'pan_up', 'pan_down', 'pan_left', 'pan_right', 'zoom_in', 'zoom_out', 'switch_between_100_percent_and_canvas_zoom', 'flip_darkmode' ]
 SHORTCUTS_MEDIA_VIEWER_BROWSER_ACTIONS = [ 'view_next', 'view_first', 'view_last', 'view_previous' ]
-SHORTCUTS_MAIN_GUI_ACTIONS = [ 'refresh', 'new_page', 'new_page_of_pages', 'new_duplicate_filter_page', 'new_url_downloader_page', 'new_simple_downloader_page', 'new_watcher_downloader_page', 'synchronised_wait_switch', 'set_media_focus', 'show_hide_splitters', 'set_search_focus', 'unclose_page', 'close_page', 'redo', 'undo', 'flip_darkmode', 'check_all_import_folders' ]
+SHORTCUTS_MAIN_GUI_ACTIONS = [ 'refresh', 'new_page', 'new_page_of_pages', 'new_duplicate_filter_page', 'new_url_downloader_page', 'new_simple_downloader_page', 'new_watcher_downloader_page', 'synchronised_wait_switch', 'set_media_focus', 'show_hide_splitters', 'set_search_focus', 'unclose_page', 'close_page', 'redo', 'undo', 'flip_darkmode', 'check_all_import_folders', 'flip_debug_force_idle_mode_do_not_set_this' ]
 SHORTCUTS_DUPLICATE_FILTER_ACTIONS = [ 'duplicate_filter_this_is_better', 'duplicate_filter_exactly_the_same', 'duplicate_filter_alternates', 'duplicate_filter_not_dupes', 'duplicate_filter_custom_action', 'duplicate_filter_skip', 'duplicate_filter_back' ]
 SHORTCUTS_ARCHIVE_DELETE_FILTER_ACTIONS = [ 'archive_delete_filter_keep', 'archive_delete_filter_delete', 'archive_delete_filter_skip', 'archive_delete_filter_back' ]
 
diff --git a/include/ClientDB.py b/include/ClientDB.py
index 35331aa3..8cd97eda 100755
--- a/include/ClientDB.py
+++ b/include/ClientDB.py
@@ -9933,11 +9933,11 @@ class DB( HydrusDB.HydrusDB ):
                 
                 new_yiff_sdf = [ sdf for sdf in default_sdf if 'yiff' in sdf.GetName() ]
                 
-                existing_sdf = new_options.GetSimpleDownloaderFormulae()
+                existing_sdf = list( new_options.GetSimpleDownloaderFormulae() )
                 
                 existing_sdf.extend( new_yiff_sdf )
                 
-                new_options.SetSimpleDownloaderFormulae( ClientDefaults.GetDefaultSimpleDownloaderFormulae() )
+                new_options.SetSimpleDownloaderFormulae( existing_sdf )
                 
                 self._SetJSONDump( new_options )
                 
@@ -10032,6 +10032,60 @@ class DB( HydrusDB.HydrusDB ):
                 
             
         
+        if version == 304:
+            
+            try:
+                
+                domain_manager = self._GetJSONDump( HydrusSerialisable.SERIALISABLE_TYPE_NETWORK_DOMAIN_MANAGER )
+                
+                domain_manager.Initialise()
+                
+                #
+                
+                url_matches = ClientDefaults.GetDefaultURLMatches()
+                
+                url_matches = [ url_match for url_match in url_matches if 'pixiv file page' in url_match.GetName() or 'yiff.party' in url_match.GetName() ]
+                
+                existing_url_matches = [ url_match for url_match in domain_manager.GetURLMatches() if 'pixiv file page' not in url_match.GetName() and 'yiff.party' not in url_match.GetName() ]
+                
+                url_matches.extend( existing_url_matches )
+                
+                domain_manager.SetURLMatches( url_matches )
+                
+                #
+                
+                existing_parsers = domain_manager.GetParsers()
+                
+                existing_names = { parser.GetName() for parser in existing_parsers }
+                
+                new_parsers = list( existing_parsers )
+                
+                default_parsers = ClientDefaults.GetDefaultParsers()
+                
+                interesting_new_parsers = [ parser for parser in default_parsers if parser.GetName() not in existing_names ] # add it
+                
+                new_parsers.extend( interesting_new_parsers )
+                
+                domain_manager.SetParsers( new_parsers )
+                
+                #
+                
+                domain_manager.TryToLinkURLMatchesAndParsers()
+                
+                #
+                
+                self._SetJSONDump( domain_manager )
+                
+            except Exception as e:
+                
+                HydrusData.PrintException( e )
+                
+                message = 'Trying to update pixiv url class failed! Please let hydrus dev know!'
+                
+                self.pub_initial_message( message )
+                
+            
+        
         self._controller.pub( 'splash_set_title_text', 'updated db to v' + str( version + 1 ) )
         
         self._c.execute( 'UPDATE version SET version = ?;', ( version + 1, ) )
diff --git a/include/ClientDownloading.py b/include/ClientDownloading.py
index 4d0a85e7..056e3d93 100644
--- a/include/ClientDownloading.py
+++ b/include/ClientDownloading.py
@@ -1387,7 +1387,14 @@ class GalleryNewgrounds( Gallery ):
         
         fatcol = soup.find( 'div', class_ = 'fatcol' )
         
-        links = fatcol.find_all( 'a' )
+        if fatcol is not None:
+            
+            links = fatcol.find_all( 'a' )
+            
+        else:
+            
+            links = []
+            
         
         urls_set = set()
         
diff --git a/include/ClientGUI.py b/include/ClientGUI.py
index 56b450ab..3f6927bd 100755
--- a/include/ClientGUI.py
+++ b/include/ClientGUI.py
@@ -2444,7 +2444,43 @@ class FrameGUI( ClientGUITopLevelWindows.FrameThatResizes ):
                             
                         
                     
-                    subscriptions = HG.client_controller.Read( 'serialisable_named', HydrusSerialisable.SERIALISABLE_TYPE_SUBSCRIPTION )
+                    job_key = ClientThreading.JobKey( cancellable = True )
+                    
+                    job_key.SetVariable( 'popup_title', 'loading subscriptions' )
+                    
+                    subscription_names = HG.client_controller.Read( 'serialisable_names', HydrusSerialisable.SERIALISABLE_TYPE_SUBSCRIPTION )
+                    
+                    pubbed_it = False
+                    started = HydrusData.GetNowFloat()
+                    num_to_do = len( subscription_names )
+                    
+                    subscriptions = []
+                    
+                    for ( i, name ) in enumerate( subscription_names ):
+                        
+                        if job_key.IsCancelled():
+                            
+                            job_key.Delete()
+                            
+                            return
+                            
+                        
+                        if not pubbed_it and HydrusData.TimeHasPassedFloat( started + 1.0 ):
+                            
+                            self._controller.pub( 'message', job_key )
+                            
+                            pubbed_it = True
+                            
+                        
+                        job_key.SetVariable( 'popup_text_1', HydrusData.ConvertValueRangeToPrettyString( i + 1, num_to_do ) + ': ' + name )
+                        job_key.SetVariable( 'popup_gauge_1', ( i + 1, num_to_do ) )
+                        
+                        subscription = HG.client_controller.Read( 'serialisable_named', HydrusSerialisable.SERIALISABLE_TYPE_SUBSCRIPTION, name )
+                        
+                        subscriptions.append( subscription )
+                        
+                    
+                    job_key.Delete()
                     
                     controller.CallBlockingToWx( wx_do_it, subscriptions, original_pause_status )
                     
@@ -3728,7 +3764,7 @@ The password is cleartext here but obscured in the entry dialog. Enter a blank p
                 
                 self._notebook.TestAbleToClose()
                 
-            except HydrusExceptions.PermissionException:
+            except HydrusExceptions.VetoException:
                 
                 return False
                 
@@ -4157,6 +4193,14 @@ The password is cleartext here but obscured in the entry dialog. Enter a blank p
                 
                 self._controller.pub( 'undo' )
                 
+            elif action == 'flip_debug_force_idle_mode_do_not_set_this':
+                
+                self._SwitchBoolean( 'force_idle_mode' )
+                
+                self._DirtyMenu( 'help' )
+                
+                self._menu_updater.Update()
+                
             else:
                 
                 command_processed = False
diff --git a/include/ClientGUIManagement.py b/include/ClientGUIManagement.py
index 814d0ead..e3ba29a3 100755
--- a/include/ClientGUIManagement.py
+++ b/include/ClientGUIManagement.py
@@ -693,6 +693,49 @@ class ManagementController( HydrusSerialisable.SerialisableBase ):
         return self._management_type
         
     
+    def GetValueRange( self ):
+        
+        try:
+            
+            if self._management_type == MANAGEMENT_TYPE_IMPORT_GALLERY:
+                
+                gallery_import = self._serialisables[ 'gallery_import' ]
+                
+                return gallery_import.GetValueRange()
+                
+            elif self._management_type == MANAGEMENT_TYPE_IMPORT_HDD:
+                
+                hdd_import = self._serialisables[ 'hdd_import' ]
+                
+                return hdd_import.GetValueRange()
+                
+            elif self._management_type == MANAGEMENT_TYPE_IMPORT_SIMPLE_DOWNLOADER:
+                
+                simple_downloader_import = self._serialisables[ 'simple_downloader_import' ]
+                
+                return simple_downloader_import.GetValueRange()
+                
+            elif self._management_type == MANAGEMENT_TYPE_IMPORT_THREAD_WATCHER:
+                
+                thread_watcher_import = self._serialisables[ 'thread_watcher_import' ]
+                
+                return thread_watcher_import.GetValueRange()
+                
+            elif self._management_type == MANAGEMENT_TYPE_IMPORT_URLS:
+                
+                urls_import = self._serialisables[ 'urls_import' ]
+                
+                return urls_import.GetValueRange()
+                
+            
+        except KeyError:
+            
+            return ( 0 , 0 )
+            
+        
+        return ( 0, 0 )
+        
+    
     def GetVariable( self, name ):
         
         if name in self._simples:
@@ -719,6 +762,8 @@ class ManagementController( HydrusSerialisable.SerialisableBase ):
             return thread_watcher_import.IsDead()
             
         
+        return False
+        
     
     def IsImporter( self ):
         
@@ -790,6 +835,11 @@ class ManagementPanel( wx.lib.scrolledpanel.ScrolledPanel ):
         sizer.Add( tags_box, CC.FLAGS_EXPAND_BOTH_WAYS )
         
     
+    def CheckAbleToClose( self ):
+        
+        pass
+        
+    
     def CleanBeforeDestroy( self ):
         
         pass
@@ -815,11 +865,6 @@ class ManagementPanel( wx.lib.scrolledpanel.ScrolledPanel ):
         pass
         
     
-    def TestAbleToClose( self ):
-        
-        pass
-        
-    
     def TIMERPageUpdate( self ):
         
         pass
@@ -1571,6 +1616,14 @@ class ManagementPanelImporterGallery( ManagementPanelImporter ):
         self._current_action.SetLabelText( current_action )
         
     
+    def CheckAbleToClose( self ):
+        
+        if self._gallery_import.CurrentlyWorking():
+            
+            raise HydrusExceptions.VetoException( 'This page is still importing.' )
+            
+        
+    
     def EventAdvance( self, event ):
         
         selected_indices = self._pending_queries_listbox.GetSelections()
@@ -1656,20 +1709,6 @@ class ManagementPanelImporterGallery( ManagementPanelImporter ):
         self._gallery_import.Start( self._page_key )
         
     
-    def TestAbleToClose( self ):
-        
-        if self._gallery_import.CurrentlyWorking():
-            
-            with ClientGUIDialogs.DialogYesNo( self, 'This page is still importing. Are you sure you want to close it?' ) as dlg:
-                
-                if dlg.ShowModal() == wx.ID_NO:
-                    
-                    raise HydrusExceptions.PermissionException()
-                    
-                
-            
-        
-    
 management_panel_types_to_classes[ MANAGEMENT_TYPE_IMPORT_GALLERY ] = ManagementPanelImporterGallery
 
 class ManagementPanelImporterHDD( ManagementPanelImporter ):
@@ -1748,6 +1787,14 @@ class ManagementPanelImporterHDD( ManagementPanelImporter ):
         self._current_action.SetLabelText( current_action )
         
     
+    def CheckAbleToClose( self ):
+        
+        if self._hdd_import.CurrentlyWorking():
+            
+            raise HydrusExceptions.VetoException( 'This page is still importing.' )
+            
+        
+    
     def EventPause( self, event ):
         
         self._hdd_import.PausePlay()
@@ -1760,20 +1807,6 @@ class ManagementPanelImporterHDD( ManagementPanelImporter ):
         self._hdd_import.Start( self._page_key )
         
     
-    def TestAbleToClose( self ):
-        
-        if self._hdd_import.CurrentlyWorking():
-            
-            with ClientGUIDialogs.DialogYesNo( self, 'This page is still importing. Are you sure you want to close it?' ) as dlg:
-                
-                if dlg.ShowModal() == wx.ID_NO:
-                    
-                    raise HydrusExceptions.PermissionException()
-                    
-                
-            
-        
-    
 management_panel_types_to_classes[ MANAGEMENT_TYPE_IMPORT_HDD ] = ManagementPanelImporterHDD
 
 class ManagementPanelImporterSimpleDownloader( ManagementPanelImporter ):
@@ -2118,6 +2151,14 @@ class ManagementPanelImporterSimpleDownloader( ManagementPanelImporter ):
             
         
     
+    def CheckAbleToClose( self ):
+        
+        if self._simple_downloader_import.CurrentlyWorking():
+            
+            raise HydrusExceptions.VetoException( 'This page is still importing.' )
+            
+        
+    
     def EventAdvance( self, event ):
         
         selection = self._pending_jobs_listbox.GetSelection()
@@ -2201,20 +2242,6 @@ class ManagementPanelImporterSimpleDownloader( ManagementPanelImporter ):
         self._simple_downloader_import.Start( self._page_key )
         
     
-    def TestAbleToClose( self ):
-        
-        if self._simple_downloader_import.CurrentlyWorking():
-            
-            with ClientGUIDialogs.DialogYesNo( self, 'This page is still importing. Are you sure you want to close it?' ) as dlg:
-                
-                if dlg.ShowModal() == wx.ID_NO:
-                    
-                    raise HydrusExceptions.PermissionException()
-                    
-                
-            
-        
-    
 management_panel_types_to_classes[ MANAGEMENT_TYPE_IMPORT_SIMPLE_DOWNLOADER ] = ManagementPanelImporterSimpleDownloader
 
 class ManagementPanelImporterThreadWatcher( ManagementPanelImporter ):
@@ -2463,6 +2490,17 @@ class ManagementPanelImporterThreadWatcher( ManagementPanelImporter ):
             
         
     
+    def CheckAbleToClose( self ):
+        
+        if self._thread_watcher_import.HasThread():
+            
+            if self._thread_watcher_import.CurrentlyWorking():
+                
+                raise HydrusExceptions.VetoException( 'This page is still importing.' )
+                
+            
+        
+    
     def EventCheckNow( self, event ):
         
         self._thread_watcher_import.CheckNow()
@@ -2527,23 +2565,6 @@ class ManagementPanelImporterThreadWatcher( ManagementPanelImporter ):
             
         
     
-    def TestAbleToClose( self ):
-        
-        if self._thread_watcher_import.HasThread():
-            
-            if self._thread_watcher_import.CurrentlyWorking():
-                
-                with ClientGUIDialogs.DialogYesNo( self, 'This page is still importing. Are you sure you want to close it?' ) as dlg:
-                    
-                    if dlg.ShowModal() == wx.ID_NO:
-                        
-                        raise HydrusExceptions.PermissionException()
-                        
-                    
-                
-            
-        
-    
 management_panel_types_to_classes[ MANAGEMENT_TYPE_IMPORT_THREAD_WATCHER ] = ManagementPanelImporterThreadWatcher
 
 class ManagementPanelImporterURLs( ManagementPanelImporter ):
@@ -2661,6 +2682,14 @@ class ManagementPanelImporterURLs( ManagementPanelImporter ):
             
         
     
+    def CheckAbleToClose( self ):
+        
+        if self._urls_import.CurrentlyWorking():
+            
+            raise HydrusExceptions.VetoException( 'This page is still importing.' )
+            
+        
+    
     def EventPause( self, event ):
         
         self._urls_import.PausePlay()
diff --git a/include/ClientGUIMedia.py b/include/ClientGUIMedia.py
index 6720ecd4..be465d29 100755
--- a/include/ClientGUIMedia.py
+++ b/include/ClientGUIMedia.py
@@ -1095,6 +1095,26 @@ class MediaPanel( ClientMedia.ListeningMediaList, wx.ScrolledWindow ):
             
         
     
+    def _OpenFileInWebBrowser( self ):
+        
+        if self._focussed_media is not None:
+            
+            if self._focussed_media.GetLocationsManager().IsLocal():
+                
+                hash = self._focussed_media.GetHash()
+                mime = self._focussed_media.GetMime()
+                
+                client_files_manager = HG.client_controller.client_files_manager
+                
+                path = client_files_manager.GetFilePath( hash, mime )
+                
+                self._SetFocussedMedia( None )
+                
+                webbrowser.open( 'file://' + path )
+                
+            
+        
+    
     def _OpenFileLocation( self ):
         
         if self._focussed_media is not None:
@@ -3348,13 +3368,24 @@ class MediaPanelThumbnails( MediaPanel ):
             
             #
             
-            if advanced_mode:
+            if focussed_is_local:
                 
-                if not HC.PLATFORM_LINUX and focussed_is_local:
+                show_open_in_web = not HC.PLATFORM_WINDOWS or advanced_mode # let's turn it on for any Winlads who wants to try
+                show_open_in_explorer = advanced_mode and not HC.PLATFORM_LINUX
+                
+                if show_open_in_web or show_open_in_explorer:
                     
                     open_menu = wx.Menu()
                     
-                    ClientGUIMenus.AppendMenuItem( self, open_menu, 'in file browser', 'Show this file in your OS\'s file browser.', self._OpenFileLocation )
+                    if show_open_in_web:
+                        
+                        ClientGUIMenus.AppendMenuItem( self, open_menu, 'in web browser (prototype)', 'Show this file in your OS\'s web browser.', self._OpenFileInWebBrowser )
+                        
+                    
+                    if show_open_in_explorer:
+                        
+                        ClientGUIMenus.AppendMenuItem( self, open_menu, 'in file browser', 'Show this file in your OS\'s file browser.', self._OpenFileLocation )
+                        
                     
                     ClientGUIMenus.AppendMenu( share_menu, open_menu, 'open' )
                     
@@ -3547,6 +3578,8 @@ class MediaPanelThumbnails( MediaPanel ):
             
             if advanced_mode:
                 
+                ClientGUIMenus.AppendSeparator( menu )
+                
                 duplicates_menu = menu # this is important to make the menu flexible if not multiple selected
                 
                 focussed_hash = self._focussed_media.GetDisplayMedia().GetHash()
@@ -3625,13 +3658,8 @@ class MediaPanelThumbnails( MediaPanel ):
                         
                     
                 
-            
-            if advanced_mode:
-                
                 if self._focussed_media.HasImages():
                     
-                    ClientGUIMenus.AppendSeparator( menu )
-                    
                     similar_menu = wx.Menu()
                     
                     ClientGUIMenus.AppendMenuItem( self, similar_menu, 'exact match', 'Search the database for files that look precisely like this one.', self._GetSimilarTo, HC.HAMMING_EXACT_MATCH )
@@ -3642,8 +3670,7 @@ class MediaPanelThumbnails( MediaPanel ):
                     ClientGUIMenus.AppendMenu( menu, similar_menu, 'find similar files' )
                     
                 
-            
-            if advanced_mode:
+                ClientGUIMenus.AppendSeparator( menu )
                 
                 ClientGUIMenus.AppendMenuItem( self, menu, 'reparse files and regenerate thumbnails', 'Refresh this file\'s metadata and regenerate its thumbnails.', self._ReparseFile )
                 
diff --git a/include/ClientGUIPages.py b/include/ClientGUIPages.py
index e7d984c1..213b4f59 100755
--- a/include/ClientGUIPages.py
+++ b/include/ClientGUIPages.py
@@ -10,6 +10,7 @@ import ClientGUICanvas
 import ClientDownloading
 import ClientSearch
 import ClientThreading
+import collections
 import hashlib
 import HydrusData
 import HydrusExceptions
@@ -475,6 +476,11 @@ class Page( wx.SplitterWindow ):
         self._controller.pub( 'refresh_page_name', self._page_key )
         
     
+    def CheckAbleToClose( self ):
+        
+        self._management_panel.CheckAbleToClose()
+        
+    
     def CleanBeforeDestroy( self ):
         
         self._management_panel.CleanBeforeDestroy()
@@ -550,17 +556,26 @@ class Page( wx.SplitterWindow ):
         return self._management_controller.GetPageName()
         
     
-    def GetNumFiles( self ):
+    def GetNumFileSummary( self ):
         
         if self._initialised:
             
-            return self._media_panel.GetNumFiles()
+            num_files = self._media_panel.GetNumFiles()
             
         else:
             
-            return len( self._initial_hashes )
+            num_files = len( self._initial_hashes )
             
         
+        ( num_value, num_range ) = self._management_controller.GetValueRange()
+        
+        if num_value == num_range:
+            
+            ( num_value, num_range ) = ( 0, 0 )
+            
+        
+        return ( num_files, ( num_value, num_range ) )
+        
     
     def GetPageKey( self ):
         
@@ -751,7 +766,22 @@ class Page( wx.SplitterWindow ):
     
     def TestAbleToClose( self ):
         
-        self._management_panel.TestAbleToClose()
+        try:
+            
+            self._management_panel.CheckAbleToClose()
+            
+        except HydrusExceptions.VetoException as e:
+            
+            reason = HydrusData.ToUnicode( e )
+            
+            with ClientGUIDialogs.DialogYesNo( self, reason + ' Are you sure you want to close it?' ) as dlg:
+                
+                if dlg.ShowModal() == wx.ID_NO:
+                    
+                    raise HydrusExceptions.VetoException()
+                    
+                
+            
         
     
     def THREADLoadInitialMediaResults( self, controller, initial_hashes ):
@@ -912,7 +942,7 @@ class PagesNotebook( wx.Notebook ):
                 
                 page.TestAbleToClose()
                 
-            except HydrusExceptions.PermissionException:
+            except HydrusExceptions.VetoException:
                 
                 return False
                 
@@ -1252,9 +1282,16 @@ class PagesNotebook( wx.Notebook ):
         
         if page_file_count_display == CC.PAGE_FILE_COUNT_DISPLAY_ALL or ( page_file_count_display == CC.PAGE_FILE_COUNT_DISPLAY_ONLY_IMPORTERS and page.IsImporter() ):
             
-            num_files = page.GetNumFiles()
+            ( num_files, ( num_value, num_range ) ) = page.GetNumFileSummary()
             
-            page_name += ' (' + HydrusData.ConvertIntToPrettyString( num_files ) + ')'
+            num_string = HydrusData.ConvertIntToPrettyString( num_files )
+            
+            if num_range > 0 and num_value != num_range:
+                
+                num_string += ', ' + HydrusData.ConvertValueRangeToPrettyString( num_value, num_range )
+                
+            
+            page_name += ' (' + num_string + ')'
             
         
         safe_page_name = self.EscapeMnemonics( page_name )
@@ -1847,9 +1884,22 @@ class PagesNotebook( wx.Notebook ):
         return self._name
         
     
-    def GetNumFiles( self ):
+    def GetNumFileSummary( self ):
         
-        return sum( page.GetNumFiles() for page in self._GetPages() )
+        total_num_files = 0
+        total_num_value = 0
+        total_num_range = 0
+        
+        for page in self._GetPages():
+            
+            ( num_files, ( num_value, num_range ) ) = page.GetNumFileSummary()
+            
+            total_num_files += num_files
+            total_num_value += num_value
+            total_num_range += num_range
+            
+        
+        return ( total_num_files, ( total_num_value, total_num_range ) )
         
     
     def GetNumPages( self, only_my_level = False ):
@@ -1912,7 +1962,16 @@ class PagesNotebook( wx.Notebook ):
     
     def GetPrettyStatus( self ):
         
-        return HydrusData.ConvertIntToPrettyString( self.GetPageCount() ) + ' pages, ' + HydrusData.ConvertIntToPrettyString( self.GetNumFiles() ) + ' files'
+        ( num_files, ( num_value, num_range ) ) = self.GetNumFileSummary()
+        
+        num_string = HydrusData.ConvertIntToPrettyString( num_files )
+        
+        if num_range > 0 and num_value != num_range:
+            
+            num_string += ', ' + HydrusData.ConvertValueRangeToPrettyString( num_value, num_range )
+            
+        
+        return HydrusData.ConvertIntToPrettyString( self.GetPageCount() ) + ' pages, ' + num_string + ' files'
         
     
     def HasPage( self, page ):
@@ -1978,7 +2037,7 @@ class PagesNotebook( wx.Notebook ):
                 
                 self.TestAbleToClose()
                 
-            except HydrusExceptions.PermissionException:
+            except HydrusExceptions.VetoException:
                 
                 return
                 
@@ -2700,9 +2759,60 @@ class PagesNotebook( wx.Notebook ):
     
     def TestAbleToClose( self ):
         
-        for page in self._GetPages():
+        count = collections.Counter()
+        
+        for page in self._GetMediaPages( False ):
             
-            page.TestAbleToClose()
+            try:
+                
+                page.CheckAbleToClose()
+                
+            except HydrusExceptions.VetoException as e:
+                
+                reason = HydrusData.ToUnicode( e )
+                
+                count[ reason ] += 1
+                
+            
+        
+        if len( count ) > 0:
+            
+            total_problems = sum( count.values() )
+            
+            message = ''
+            
+            for ( reason, c ) in count.items():
+                
+                if c == 1:
+                    
+                    message = '1 page says: ' + reason
+                    
+                else:
+                    
+                    message = HydrusData.ConvertIntToPrettyString( c ) + ' pages say:' + reason
+                    
+                
+                message += os.linesep
+                
+            
+            message += os.linesep
+            
+            if total_problems == 1:
+                
+                message += 'Are you sure you want to close it?'
+                
+            else:
+                
+                message += 'Are you sure you want to close them?'
+                
+            
+            with ClientGUIDialogs.DialogYesNo( self, message ) as dlg:
+                
+                if dlg.ShowModal() == wx.ID_NO:
+                    
+                    raise HydrusExceptions.VetoException()
+                    
+                
             
         
     
diff --git a/include/ClientGUIParsing.py b/include/ClientGUIParsing.py
index f7cf74d4..be007057 100644
--- a/include/ClientGUIParsing.py
+++ b/include/ClientGUIParsing.py
@@ -1433,8 +1433,8 @@ class EditContentParserPanel( ClientGUIScrolledPanels.EditPanel ):
         
         self._url_type = ClientGUICommon.BetterChoice( self._urls_panel )
         
-        self._url_type.Append( 'actual file', HC.URL_TYPE_FILE )
-        self._url_type.Append( 'post page', HC.URL_TYPE_POST )
+        self._url_type.Append( 'file url', HC.URL_TYPE_FILE )
+        self._url_type.Append( 'post url', HC.URL_TYPE_POST )
         self._url_type.Append( 'next gallery page', HC.URL_TYPE_NEXT )
         
         self._file_priority = wx.SpinCtrl( self._urls_panel, min = 0, max = 100 )
@@ -3663,6 +3663,7 @@ class EditStringConverterPanel( ClientGUIScrolledPanels.EditPanel ):
             self._data_encoding = ClientGUICommon.BetterChoice( self )
             self._data_regex_pattern = wx.TextCtrl( self )
             self._data_regex_repl = wx.TextCtrl( self )
+            self._data_date_link = wx.adv.HyperlinkCtrl( self, label = 'link to date info', url = 'https://docs.python.org/2/library/datetime.html#strftime-strptime-behavior' )
             self._data_timezone = ClientGUICommon.BetterChoice( self )
             self._data_timezone_offset = wx.SpinCtrl( self, min = -86400, max = 86400 )
             
@@ -3699,7 +3700,7 @@ class EditStringConverterPanel( ClientGUIScrolledPanels.EditPanel ):
                 ( phrase, timezone_type, timezone_offset ) = data
                 
                 self._data_text.SetValue( phrase )
-                self._data_timezone.SetValue( timezone_type )
+                self._data_timezone.SelectClientData( timezone_type )
                 self._data_timezone_offset.SetValue( timezone_offset )
                 
             elif data is not None:
@@ -3723,6 +3724,7 @@ class EditStringConverterPanel( ClientGUIScrolledPanels.EditPanel ):
             rows.append( ( 'encoding data: ', self._data_encoding ) )
             rows.append( ( 'regex pattern: ', self._data_regex_pattern ) )
             rows.append( ( 'regex replacement: ', self._data_regex_repl ) )
+            rows.append( ( 'date info: ', self._data_date_link ) )
             rows.append( ( 'date timezone: ', self._data_timezone ) )
             rows.append( ( 'timezone offset: ', self._data_timezone_offset ) )
             
@@ -3761,20 +3763,20 @@ class EditStringConverterPanel( ClientGUIScrolledPanels.EditPanel ):
                 
                 self._data_text.Enable()
                 
+                if transformation_type == ClientParsing.STRING_TRANSFORMATION_DATE_DECODE:
+                    
+                    self._data_timezone.Enable()
+                    
+                    if self._data_timezone.GetChoice() == HC.TIMEZONE_OFFSET:
+                        
+                        self._data_timezone_offset.Enable()
+                        
+                    
+                
             elif transformation_type in ( ClientParsing.STRING_TRANSFORMATION_REMOVE_TEXT_FROM_BEGINNING, ClientParsing.STRING_TRANSFORMATION_REMOVE_TEXT_FROM_END, ClientParsing.STRING_TRANSFORMATION_CLIP_TEXT_FROM_BEGINNING, ClientParsing.STRING_TRANSFORMATION_CLIP_TEXT_FROM_END ):
                 
                 self._data_number.Enable()
                 
-            elif transformation_type == ClientParsing.STRING_TRANSFORMATION_DATE_DECODE:
-                
-                self._data_text.Enable()
-                self._data_timezone.Enable()
-                
-                if self._data_timezone.GetChoice() == HC.TIMEZONE_OFFSET:
-                    
-                    self._data_timezone_offset.Enable()
-                    
-                
             elif transformation_type == ClientParsing.STRING_TRANSFORMATION_REGEX_SUB:
                 
                 self._data_regex_pattern.Enable()
@@ -4162,7 +4164,7 @@ class ManageParsingScriptsPanel( ClientGUIScrolledPanels.ManagePanel ):
         url = ''
         query_type = HC.GET
         file_identifier_type = ClientParsing.FILE_IDENTIFIER_TYPE_MD5
-        file_identifier_string_converter = ClientParsing.StringConverter( [ ClientParsing.STRING_TRANSFORMATION_ENCODE, 'hex' ], 'some hash bytes' )
+        file_identifier_string_converter = ClientParsing.StringConverter( ( [ ClientParsing.STRING_TRANSFORMATION_ENCODE, 'hex' ] ), 'some hash bytes' )
         file_identifier_arg_name = 'md5'
         static_args = {}
         children = []
diff --git a/include/ClientImporting.py b/include/ClientImporting.py
index 646a8c76..8056c024 100644
--- a/include/ClientImporting.py
+++ b/include/ClientImporting.py
@@ -41,6 +41,60 @@ CHECKER_STATUS_404 = 2
 
 DID_SUBSTANTIAL_FILE_WORK_MINIMUM_SLEEP_TIME = 0.1
 
+def GenerateDownloaderNetworkJobFactory( page_key ):
+    
+    def network_job_factory( *args, **kwargs ):
+        
+        network_job = ClientNetworkingJobs.NetworkJobDownloader( page_key, *args, **kwargs )
+        
+        return network_job
+        
+    
+    return network_job_factory
+    
+def GenerateSubscriptionNetworkJobFactory( subscription_key ):
+    
+    def network_job_factory( *args, **kwargs ):
+        
+        network_job = ClientNetworkingJobs.NetworkJobSubscription( subscription_key, *args, **kwargs )
+        
+        network_job.OverrideBandwidth( 30 )
+        
+        return network_job
+        
+    
+    return network_job_factory
+    
+def GenerateSubscriptionNetworkJobPresentationContextFactory( job_key ):
+    
+    def network_job_presentation_context_factory( network_job ):
+        
+        def enter_call():
+            
+            job_key.SetVariable( 'popup_network_job', network_job )
+            
+        
+        def exit_call():
+            
+            pass
+            
+        
+        return NetworkJobPresentationContext( enter_call, exit_call )
+        
+    
+    return network_job_presentation_context_factory
+    
+def GenerateWatcherNetworkJobFactory( thread_key ):
+    
+    def network_job_factory( *args, **kwargs ):
+        
+        network_job = ClientNetworkingJobs.NetworkJobWatcherPage( thread_key, *args, **kwargs )
+        
+        return network_job
+        
+    
+    return network_job_factory
+    
 def THREADDownloadURL( job_key, url, url_string ):
     
     job_key.SetVariable( 'popup_title', url_string )
@@ -75,27 +129,27 @@ def THREADDownloadURL( job_key, url, url_string ):
         
         file_import_job = FileImportJob( temp_path )
         
-        ( result, hash ) = HG.client_controller.client_files_manager.ImportFile( file_import_job )
+        ( status, hash ) = HG.client_controller.client_files_manager.ImportFile( file_import_job )
         
     finally:
         
         HydrusPaths.CleanUpTempPath( os_file_handle, temp_path )
         
     
-    if result in ( CC.STATUS_SUCCESSFUL_AND_NEW, CC.STATUS_SUCCESSFUL_BUT_REDUNDANT ):
+    if status in CC.SUCCESSFUL_IMPORT_STATES:
         
-        if result == CC.STATUS_SUCCESSFUL_AND_NEW:
+        if status == CC.STATUS_SUCCESSFUL_AND_NEW:
             
             job_key.SetVariable( 'popup_text_1', 'successful!' )
             
-        else:
+        elif status == CC.STATUS_SUCCESSFUL_BUT_REDUNDANT:
             
             job_key.SetVariable( 'popup_text_1', 'was already in the database!' )
             
         
         job_key.SetVariable( 'popup_files', ( [ hash ], 'download' ) )
         
-    elif result == CC.STATUS_DELETED:
+    elif status == CC.STATUS_DELETED:
         
         job_key.SetVariable( 'popup_text_1', 'had already been deleted!' )
         
@@ -154,7 +208,7 @@ def THREADDownloadURLs( job_key, urls, title ):
                 
                 file_import_job = FileImportJob( temp_path )
                 
-                ( result, hash ) = HG.client_controller.client_files_manager.ImportFile( file_import_job )
+                ( status, hash ) = HG.client_controller.client_files_manager.ImportFile( file_import_job )
                 
             except Exception as e:
                 
@@ -173,13 +227,13 @@ def THREADDownloadURLs( job_key, urls, title ):
             HydrusPaths.CleanUpTempPath( os_file_handle, temp_path )
             
         
-        if result in ( CC.STATUS_SUCCESSFUL_AND_NEW, CC.STATUS_SUCCESSFUL_BUT_REDUNDANT ):
+        if status in CC.SUCCESSFUL_IMPORT_STATES:
             
-            if result == CC.STATUS_SUCCESSFUL_AND_NEW:
+            if status == CC.STATUS_SUCCESSFUL_AND_NEW:
                 
                 num_successful += 1
                 
-            else:
+            elif status == CC.STATUS_SUCCESSFUL_BUT_REDUNDANT:
                 
                 num_redundant += 1
                 
@@ -191,7 +245,7 @@ def THREADDownloadURLs( job_key, urls, title ):
             
             presentation_hashes_fast.add( hash )
             
-        elif result == CC.STATUS_DELETED:
+        elif status == CC.STATUS_DELETED:
             
             num_deleted += 1
             
@@ -244,7 +298,7 @@ def UpdateSeedCacheWithAllParseResults( seed_cache, all_parse_results, source_ur
     
     for parse_results in all_parse_results:
         
-        parsed_urls = ClientParsing.GetURLsFromParseResults( parse_results, ( HC.URL_TYPE_FILE, HC.URL_TYPE_POST ) )
+        parsed_urls = ClientParsing.GetURLsFromParseResults( parse_results, ( HC.URL_TYPE_FILE, HC.URL_TYPE_POST ), only_get_top_priority = True )
         
         for url in parsed_urls:
             
@@ -533,6 +587,33 @@ class GalleryImport( HydrusSerialisable.SerialisableBase ):
         self._seed_cache = HydrusSerialisable.CreateFromSerialisableTuple( serialisable_seed_cache )
         
     
+    def _FileNetworkJobPresentationContextFactory( self, network_job ):
+        
+        def enter_call():
+            
+            with self._lock:
+                
+                if self._download_control_file_set is not None:
+                    
+                    wx.CallAfter( self._download_control_file_set, network_job )
+                    
+                
+            
+        
+        def exit_call():
+            
+            with self._lock:
+                
+                if self._download_control_file_clear is not None:
+                    
+                    wx.CallAfter( self._download_control_file_clear )
+                    
+                
+            
+        
+        return NetworkJobPresentationContext( enter_call, exit_call )
+        
+    
     def _SetGalleryStatus( self, status, timeout = None ):
         
         if HydrusData.TimeHasPassed( self._gallery_status_can_change_timestamp ):
@@ -569,8 +650,6 @@ class GalleryImport( HydrusSerialisable.SerialisableBase ):
         
         did_substantial_work = False
         
-        url = seed.seed_data
-        
         def network_job_factory( method, url, **kwargs ):
             
             network_job = ClientNetworkingJobs.NetworkJobDownloader( page_key, method, url, **kwargs )
@@ -603,75 +682,94 @@ class GalleryImport( HydrusSerialisable.SerialisableBase ):
         
         try:
             
-            with self._lock:
+            if seed.WorksInNewSystem():
                 
-                self._current_action = 'reviewing file'
-                
-            
-            ( status, hash ) = seed.GeneratePreImportStatus( self._file_import_options )
-            
-            if status == CC.STATUS_SUCCESSFUL_BUT_REDUNDANT:
-                
-                if self._tag_import_options.ShouldFetchTagsEvenIfURLKnownAndFileAlreadyInDB() and self._tag_import_options.WorthFetchingTags():
-                    
-                    downloaded_tags = gallery.GetTags( url )
-                    
-                    seed.AddTags( downloaded_tags )
-                    
-                
-            elif status == CC.STATUS_UNKNOWN:
-                
-                ( os_file_handle, temp_path ) = HydrusPaths.GetTempPath()
-                
-                try:
+                def status_hook( text ):
                     
                     with self._lock:
                         
-                        self._current_action = 'downloading file'
+                        self._current_action = text
                         
                     
-                    if self._tag_import_options.WorthFetchingTags():
-                        
-                        downloaded_tags = gallery.GetFileAndTags( temp_path, url )
-                        
-                        seed.AddTags( downloaded_tags )
-                        
-                    else:
-                        
-                        gallery.GetFile( temp_path, url )
-                        
+                
+                did_substantial_work = seed.WorkOnPostURL( self._file_import_options, self._tag_import_options, status_hook, GenerateDownloaderNetworkJobFactory( page_key ), self._FileNetworkJobPresentationContextFactory )
+                
+                if seed.ShouldPresent( self._file_import_options ):
                     
-                    seed.CheckPreFetchMetadata( self._tag_import_options )
-                    
-                    file_import_job = FileImportJob( temp_path, self._file_import_options )
-                    
-                    with self._lock:
-                        
-                        self._current_action = 'importing file'
-                        
-                    
-                    ( status, hash ) = HG.client_controller.client_files_manager.ImportFile( file_import_job )
-                    
-                    seed.SetStatus( status )
-                    seed.SetHash( hash )
+                    seed.PresentToPage( page_key )
                     
                     did_substantial_work = True
                     
-                finally:
+                
+            else:
+                
+                with self._lock:
                     
-                    HydrusPaths.CleanUpTempPath( os_file_handle, temp_path )
+                    self._current_action = 'reviewing file'
                     
                 
-            
-            did_substantial_work = seed.WriteContentUpdates( self._tag_import_options )
-            
-            if seed.ShouldPresent( self._file_import_options ):
+                seed.PredictPreImportStatus( self._file_import_options )
                 
-                ( media_result, ) = HG.client_controller.Read( 'media_results', ( hash, ) )
+                status = seed.status
                 
-                HG.client_controller.pub( 'add_media_results', page_key, ( media_result, ) )
+                url = seed.seed_data
                 
-                did_substantial_work = True
+                if status == CC.STATUS_SUCCESSFUL_BUT_REDUNDANT:
+                    
+                    if self._tag_import_options.ShouldFetchTagsEvenIfURLKnownAndFileAlreadyInDB() and self._tag_import_options.WorthFetchingTags():
+                        
+                        downloaded_tags = gallery.GetTags( url )
+                        
+                        seed.AddTags( downloaded_tags )
+                        
+                    
+                elif status == CC.STATUS_UNKNOWN:
+                    
+                    ( os_file_handle, temp_path ) = HydrusPaths.GetTempPath()
+                    
+                    try:
+                        
+                        with self._lock:
+                            
+                            self._current_action = 'downloading file'
+                            
+                        
+                        if self._tag_import_options.WorthFetchingTags():
+                            
+                            downloaded_tags = gallery.GetFileAndTags( temp_path, url )
+                            
+                            seed.AddTags( downloaded_tags )
+                            
+                        else:
+                            
+                            gallery.GetFile( temp_path, url )
+                            
+                        
+                        seed.CheckPreFetchMetadata( self._tag_import_options )
+                        
+                        with self._lock:
+                            
+                            self._current_action = 'importing file'
+                            
+                        
+                        seed.Import( temp_path, self._file_import_options )
+                        
+                        did_substantial_work = True
+                        
+                    finally:
+                        
+                        HydrusPaths.CleanUpTempPath( os_file_handle, temp_path )
+                        
+                    
+                
+                did_substantial_work = seed.WriteContentUpdates( self._tag_import_options )
+                
+                if seed.ShouldPresent( self._file_import_options ):
+                    
+                    seed.PresentToPage( page_key )
+                    
+                    did_substantial_work = True
+                    
                 
             
         except HydrusExceptions.VetoException as e:
@@ -708,6 +806,8 @@ class GalleryImport( HydrusSerialisable.SerialisableBase ):
             
             self._seed_cache.NotifySeedsUpdated( ( seed, ) )
             
+            HG.client_controller.pub( 'refresh_page_name', page_key )
+            
             wx.CallAfter( self._download_control_file_clear )
             
         
@@ -909,6 +1009,8 @@ class GalleryImport( HydrusSerialisable.SerialisableBase ):
             
         finally:
             
+            HG.client_controller.pub( 'refresh_page_name', page_key )
+            
             wx.CallAfter( self._download_control_gallery_clear )
             
         
@@ -1105,6 +1207,14 @@ class GalleryImport( HydrusSerialisable.SerialisableBase ):
             
         
     
+    def GetValueRange( self ):
+        
+        with self._lock:
+            
+            return self._seed_cache.GetValueRange()
+            
+        
+    
     def PausePlayFiles( self ):
         
         with self._lock:
@@ -1287,40 +1397,16 @@ class HDDImport( HydrusSerialisable.SerialisableBase ):
             
             with self._lock:
                 
-                self._current_action = 'preparing to import'
+                self._current_action = 'importing'
                 
             
-            ( os_file_handle, temp_path ) = HydrusPaths.GetTempPath()
+            seed.ImportPath( self._file_import_options )
             
-            try:
-                
-                copied = HydrusPaths.MirrorFile( path, temp_path )
-                
-                if not copied:
-                    
-                    raise Exception( 'File failed to copy--see log for error.' )
-                    
-                
-                with self._lock:
-                    
-                    self._current_action = 'importing'
-                    
-                
-                file_import_job = FileImportJob( temp_path, self._file_import_options )
-                
-                ( status, hash ) = HG.client_controller.client_files_manager.ImportFile( file_import_job )
-                
-                seed.SetStatus( status )
-                seed.SetHash( hash )
-                
-                did_substantial_work = True
-                
-            finally:
-                
-                HydrusPaths.CleanUpTempPath( os_file_handle, temp_path )
-                
+            did_substantial_work = True
             
-            if status in ( CC.STATUS_SUCCESSFUL_AND_NEW, CC.STATUS_SUCCESSFUL_BUT_REDUNDANT ):
+            if seed.status in CC.SUCCESSFUL_IMPORT_STATES:
+                
+                hash = seed.GetHash()
                 
                 service_keys_to_content_updates = ClientData.ConvertServiceKeysToTagsToServiceKeysToContentUpdates( { hash }, service_keys_to_tags )
                 
@@ -1333,9 +1419,7 @@ class HDDImport( HydrusSerialisable.SerialisableBase ):
                 
                 if seed.ShouldPresent( self._file_import_options ):
                     
-                    ( media_result, ) = HG.client_controller.Read( 'media_results', ( hash, ) )
-                    
-                    HG.client_controller.pub( 'add_media_results', page_key, ( media_result, ) )
+                    seed.PresentToPage( page_key )
                     
                     did_substantial_work = True
                     
@@ -1387,6 +1471,8 @@ class HDDImport( HydrusSerialisable.SerialisableBase ):
             
             self._seed_cache.NotifySeedsUpdated( ( seed, ) )
             
+            HG.client_controller.pub( 'refresh_page_name', page_key )
+            
             with self._lock:
                 
                 self._current_action = ''
@@ -1460,6 +1546,14 @@ class HDDImport( HydrusSerialisable.SerialisableBase ):
             
         
     
+    def GetValueRange( self ):
+        
+        with self._lock:
+            
+            return self._seed_cache.GetValueRange()
+            
+        
+    
     def PausePlay( self ):
         
         with self._lock:
@@ -1771,32 +1865,9 @@ class ImportFolder( HydrusSerialisable.SerialisableBaseNamed ):
                 
                 if mime in self._mimes:
                     
-                    ( os_file_handle, temp_path ) = HydrusPaths.GetTempPath()
+                    seed.ImportPath( self._file_import_options )
                     
-                    try:
-                        
-                        copied = HydrusPaths.MirrorFile( path, temp_path )
-                        
-                        if not copied:
-                            
-                            raise Exception( 'File failed to copy--see log for error.' )
-                            
-                        
-                        file_import_job = FileImportJob( temp_path, self._file_import_options )
-                        
-                        client_files_manager = HG.client_controller.client_files_manager
-                        
-                        ( status, hash ) = client_files_manager.ImportFile( file_import_job )
-                        
-                        seed.SetStatus( status )
-                        seed.SetHash( hash )
-                        
-                    finally:
-                        
-                        HydrusPaths.CleanUpTempPath( os_file_handle, temp_path )
-                        
-                    
-                    if status in ( CC.STATUS_SUCCESSFUL_AND_NEW, CC.STATUS_SUCCESSFUL_BUT_REDUNDANT ):
+                    if seed.status in CC.SUCCESSFUL_IMPORT_STATES:
                         
                         downloaded_tags = []
                         
@@ -2125,6 +2196,24 @@ class ImportFolder( HydrusSerialisable.SerialisableBaseNamed ):
     
 HydrusSerialisable.SERIALISABLE_TYPES_TO_OBJECT_TYPES[ HydrusSerialisable.SERIALISABLE_TYPE_IMPORT_FOLDER ] = ImportFolder
 
+class NetworkJobPresentationContext( object ):
+    
+    def __init__( self, enter_call, exit_call ):
+        
+        self._enter_call = enter_call
+        self._exit_call = exit_call
+        
+    
+    def __enter__( self ):
+        
+        self._enter_call()
+        
+    
+    def __exit__( self, exc_type, exc_val, exc_tb ):
+        
+        self._exit_call()
+        
+    
 SEED_TYPE_HDD = 0
 SEED_TYPE_URL = 1
 
@@ -2236,6 +2325,8 @@ class Seed( HydrusSerialisable.SerialisableBase ):
         
         source_timestamp = ClientParsing.GetTimestampFromParseResults( parse_results, HC.TIMESTAMP_TYPE_SOURCE )
         
+        source_timestamp = min( HydrusData.GetNow() - 30, source_timestamp )
+        
         if source_timestamp is not None:
             
             self.source_time = source_timestamp
@@ -2265,7 +2356,51 @@ class Seed( HydrusSerialisable.SerialisableBase ):
         self._CheckTagsBlacklist( self._tags, tag_import_options )
         
     
-    def GeneratePreImportStatus( self, file_import_options ):
+    def DownloadAndImportRawFile( self, file_url, file_import_options, network_job_factory, network_job_presentation_context_factory ):
+        
+        self.AddURL( file_url )
+        
+        ( os_file_handle, temp_path ) = HydrusPaths.GetTempPath()
+        
+        try:
+            
+            if self.seed_data != file_url:
+                
+                referral_url = self.seed_data
+                
+            else:
+                
+                referral_url = None
+                
+            
+            network_job = network_job_factory( 'GET', file_url, temp_path = temp_path, referral_url = referral_url )
+            
+            HG.client_controller.network_engine.AddJob( network_job )
+            
+            with network_job_presentation_context_factory( network_job ) as njpc:
+                
+                network_job.WaitUntilDone()
+                
+            
+            self.Import( temp_path, file_import_options )
+            
+        finally:
+            
+            HydrusPaths.CleanUpTempPath( os_file_handle, temp_path )
+            
+        
+    
+    def FetchPageMetadata( self, tag_import_options ):
+        
+        pass
+        
+    
+    def PredictPreImportStatus( self, file_import_options ):
+        
+        if self.status != CC.STATUS_UNKNOWN:
+            
+            return
+            
         
         UNKNOWN_DEFAULT = ( CC.STATUS_UNKNOWN, None, '' )
         
@@ -2402,8 +2537,6 @@ class Seed( HydrusSerialisable.SerialisableBase ):
         
         self._UpdateModified()
         
-        return ( status, hash )
-        
     
     def GetHash( self ):
         
@@ -2431,6 +2564,44 @@ class Seed( HydrusSerialisable.SerialisableBase ):
         return search_seeds
         
     
+    def Import( self, temp_path, file_import_options ):
+        
+        file_import_job = FileImportJob( temp_path, file_import_options )
+        
+        ( status, hash ) = HG.client_controller.client_files_manager.ImportFile( file_import_job )
+        
+        self.SetStatus( status )
+        self.SetHash( hash )
+        
+    
+    def ImportPath( self, file_import_options ):
+        
+        if self.seed_type != SEED_TYPE_HDD:
+            
+            raise Exception( 'Attempted to import as a path, but I do not think I am a path!' )
+            
+        
+        ( os_file_handle, temp_path ) = HydrusPaths.GetTempPath()
+        
+        try:
+            
+            path = self.seed_data
+            
+            copied = HydrusPaths.MirrorFile( path, temp_path )
+            
+            if not copied:
+                
+                raise Exception( 'File failed to copy to temp path--see log for error.' )
+                
+            
+            self.Import( temp_path, file_import_options )
+            
+        finally:
+            
+            HydrusPaths.CleanUpTempPath( os_file_handle, temp_path )
+            
+        
+    
     def Normalise( self ):
         
         if self.seed_type == SEED_TYPE_URL:
@@ -2439,6 +2610,18 @@ class Seed( HydrusSerialisable.SerialisableBase ):
             
         
     
+    def PresentToPage( self, page_key ):
+        
+        hash = self.GetHash()
+        
+        if hash is not None:
+            
+            ( media_result, ) = HG.client_controller.Read( 'media_results', ( hash, ) )
+            
+            HG.client_controller.pub( 'add_media_results', page_key, ( media_result, ) )
+            
+        
+    
     def SetHash( self, hash ):
         
         self._hashes[ 'sha256' ] = hash
@@ -2464,6 +2647,11 @@ class Seed( HydrusSerialisable.SerialisableBase ):
         self._UpdateModified()
         
     
+    def ShouldDownloadFile( self ):
+        
+        return self.status == CC.STATUS_UNKNOWN
+        
+    
     def ShouldFetchPageMetadata( self, tag_import_options ):
         
         if self.status == CC.STATUS_UNKNOWN:
@@ -2491,7 +2679,7 @@ class Seed( HydrusSerialisable.SerialisableBase ):
         
         hash = self._hashes[ 'sha256' ]
         
-        if self.status in ( CC.STATUS_SUCCESSFUL_AND_NEW, CC.STATUS_SUCCESSFUL_BUT_REDUNDANT ):
+        if self.status in CC.SUCCESSFUL_IMPORT_STATES:
             
             if file_import_options.ShouldPresentIgnorantOfInbox( self.status ):
                 
@@ -2509,6 +2697,207 @@ class Seed( HydrusSerialisable.SerialisableBase ):
         return False
         
     
+    def WorkOnFileURL( self, file_import_options, status_hook, network_job_factory, network_job_presentation_context_factory, tag_import_options = None ):
+        
+        did_substantial_work = False
+        
+        try:
+            
+            status_hook( 'checking url status' )
+            
+            self.PredictPreImportStatus( file_import_options )
+            
+            if self.status == CC.STATUS_UNKNOWN:
+                
+                file_url = self.seed_data
+                
+                status_hook( 'downloading file' )
+                
+                self.DownloadAndImportRawFile( file_url, file_import_options, network_job_factory, network_job_presentation_context_factory )
+                
+                did_substantial_work = True
+                
+            
+            did_substantial_work |= self.WriteContentUpdates( tag_import_options )
+            
+        except HydrusExceptions.ShutdownException:
+            
+            return False
+            
+        except HydrusExceptions.VetoException as e:
+            
+            status = CC.STATUS_VETOED
+            
+            note = HydrusData.ToUnicode( e )
+            
+            self.SetStatus( status, note = note )
+            
+            if isinstance( e, HydrusExceptions.CancelledException ):
+                
+                status_hook( 'cancelled!' )
+                
+                time.sleep( 2 )
+                
+            
+        except HydrusExceptions.NotFoundException:
+            
+            status = CC.STATUS_VETOED
+            note = '404'
+            
+            self.SetStatus( status, note = note )
+            
+            status_hook( '404' )
+            
+            time.sleep( 2 )
+            
+        except Exception as e:
+            
+            status = CC.STATUS_ERROR
+            
+            self.SetStatus( status, exception = e )
+            
+            status_hook( 'error!' )
+            
+            time.sleep( 3 )
+            
+        
+        return did_substantial_work
+        
+    
+    def WorkOnPostURL( self, file_import_options, tag_import_options, status_hook, network_job_factory, network_job_presentation_context_factory ):
+        
+        did_substantial_work = False
+        
+        try:
+            
+            status_hook( 'checking url status' )
+            
+            self.PredictPreImportStatus( file_import_options )
+            
+            if self.ShouldFetchPageMetadata( tag_import_options ):
+                
+                post_url = self.seed_data
+                
+                ( url_to_check, parser ) = HG.client_controller.network_engine.domain_manager.GetURLToFetchAndParser( post_url )
+                
+                if parser is None:
+                    
+                    raise HydrusExceptions.ParseException( 'Could not find a parser for the given URL!' )
+                    
+                
+                status_hook( 'downloading page' )
+                
+                network_job = network_job_factory( 'GET', url_to_check )
+                
+                HG.client_controller.network_engine.AddJob( network_job )
+                
+                with network_job_presentation_context_factory( network_job ) as njpc:
+                    
+                    network_job.WaitUntilDone()
+                    
+                
+                data = network_job.GetContent()
+                
+                parsing_context = {}
+                
+                parsing_context[ 'post_url' ] = post_url
+                parsing_context[ 'url' ] = url_to_check
+                
+                all_parse_results = parser.Parse( parsing_context, data )
+                
+                if len( all_parse_results ) == 0:
+                    
+                    raise HydrusExceptions.VetoException( 'Could not parse any data!' )
+                    
+                
+                parse_results = all_parse_results[0]
+                
+                self.AddParseResults( parse_results )
+                
+                self.CheckPreFetchMetadata( tag_import_options )
+                
+                self.PredictPreImportStatus( file_import_options )
+                
+                if self.ShouldDownloadFile():
+                    
+                    file_urls = ClientParsing.GetURLsFromParseResults( parse_results, ( HC.URL_TYPE_FILE, ), only_get_top_priority = True )
+                    
+                    if len( file_urls ) == 0:
+                        
+                        raise HydrusExceptions.VetoException( 'Could not file a file URL!' )
+                        
+                    
+                    file_url = file_urls[0]
+                    
+                    status_hook( 'downloading file' )
+                    
+                    self.DownloadAndImportRawFile( file_url, file_import_options, network_job_factory, network_job_presentation_context_factory )
+                    
+                    did_substantial_work = True
+                    
+                
+            
+            did_substantial_work |= self.WriteContentUpdates( tag_import_options )
+            
+        except HydrusExceptions.ShutdownException:
+            
+            return False
+            
+        except HydrusExceptions.VetoException as e:
+            
+            status = CC.STATUS_VETOED
+            
+            note = HydrusData.ToUnicode( e )
+            
+            self.SetStatus( status, note = note )
+            
+            if isinstance( e, HydrusExceptions.CancelledException ):
+                
+                status_hook( 'cancelled!' )
+                
+                time.sleep( 2 )
+                
+            
+        except HydrusExceptions.NotFoundException:
+            
+            status = CC.STATUS_VETOED
+            note = '404'
+            
+            self.SetStatus( status, note = note )
+            
+            status_hook( '404' )
+            
+            time.sleep( 2 )
+            
+        except Exception as e:
+            
+            status = CC.STATUS_ERROR
+            
+            self.SetStatus( status, exception = e )
+            
+            status_hook( 'error!' )
+            
+            time.sleep( 3 )
+            
+        
+        return did_substantial_work
+        
+    
+    def WorksInNewSystem( self ):
+        
+        if self.seed_type == SEED_TYPE_URL:
+            
+            ( url_type, match_name, can_parse ) = HG.client_controller.network_engine.domain_manager.GetURLParseCapability( self.seed_data )
+            
+            if url_type == HC.URL_TYPE_POST and can_parse:
+                
+                return True
+                
+            
+        
+        return False
+        
+    
     def WriteContentUpdates( self, tag_import_options = None ):
         
         did_work = False
@@ -3146,6 +3535,21 @@ class SeedCache( HydrusSerialisable.SerialisableBase ):
             
         
     
+    def GetValueRange( self ):
+        
+        with self._lock:
+            
+            if self._dirty:
+                
+                self._GenerateStatus()
+                
+            
+            ( status, ( total_processed, total ) ) = self._status_cache
+            
+            return ( total_processed, total )
+            
+        
+    
     def HasSeed( self, seed ):
         
         with self._lock:
@@ -3204,7 +3608,7 @@ class SeedCache( HydrusSerialisable.SerialisableBase ):
         
         with self._lock:
             
-            seeds_to_delete = [ seed for seed in self._seeds if seed.status in ( CC.STATUS_SUCCESSFUL_AND_NEW, CC.STATUS_SUCCESSFUL_BUT_REDUNDANT ) ]
+            seeds_to_delete = [ seed for seed in self._seeds if seed.status in CC.SUCCESSFUL_IMPORT_STATES ]
             
         
         self.RemoveSeeds( seeds_to_delete )
@@ -3275,6 +3679,33 @@ class SimpleDownloaderImport( HydrusSerialisable.SerialisableBase ):
         self._new_page_event = threading.Event()
         
     
+    def _FileNetworkJobPresentationContextFactory( self, network_job ):
+        
+        def enter_call():
+            
+            with self._lock:
+                
+                if self._download_control_file_set is not None:
+                    
+                    wx.CallAfter( self._download_control_file_set, network_job )
+                    
+                
+            
+        
+        def exit_call():
+            
+            with self._lock:
+                
+                if self._download_control_file_clear is not None:
+                    
+                    wx.CallAfter( self._download_control_file_clear )
+                    
+                
+            
+        
+        return NetworkJobPresentationContext( enter_call, exit_call )
+        
+    
     def _GetSerialisableInfo( self ):
         
         serialisable_pending_jobs = [ ( url, simple_downloader_formula.GetSerialisableTuple() ) for ( url, simple_downloader_formula ) in self._pending_jobs ]
@@ -3295,6 +3726,33 @@ class SimpleDownloaderImport( HydrusSerialisable.SerialisableBase ):
         self._file_import_options = HydrusSerialisable.CreateFromSerialisableTuple( serialisable_file_options )
         
     
+    def _PageNetworkJobPresentationContextFactory( self, network_job ):
+        
+        def enter_call():
+            
+            with self._lock:
+                
+                if self._download_control_page_set is not None:
+                    
+                    wx.CallAfter( self._download_control_page_set, network_job )
+                    
+                
+            
+        
+        def exit_call():
+            
+            with self._lock:
+                
+                if self._download_control_page_clear is not None:
+                    
+                    wx.CallAfter( self._download_control_page_clear )
+                    
+                
+            
+        
+        return NetworkJobPresentationContext( enter_call, exit_call )
+        
+    
     def _UpdateSerialisableInfo( self, version, old_serialisable_info ):
         
         if version == 1:
@@ -3349,105 +3807,23 @@ class SimpleDownloaderImport( HydrusSerialisable.SerialisableBase ):
         
         try:
             
-            with self._lock:
+            def status_hook( text ):
                 
-                self._current_action = 'reviewing file'
-                
-            
-            ( status, hash ) = seed.GeneratePreImportStatus( self._file_import_options )
-            
-            if status == CC.STATUS_UNKNOWN:
-                
-                ( os_file_handle, temp_path ) = HydrusPaths.GetTempPath()
-                
-                try:
+                with self._lock:
                     
-                    with self._lock:
-                        
-                        self._current_action = 'downloading file'
-                        
-                    
-                    network_job = ClientNetworkingJobs.NetworkJob( 'GET', file_url, temp_path = temp_path )
-                    
-                    HG.client_controller.network_engine.AddJob( network_job )
-                    
-                    with self._lock:
-                        
-                        if self._download_control_file_set is not None:
-                            
-                            wx.CallAfter( self._download_control_file_set, network_job )
-                            
-                        
-                    
-                    try:
-                        
-                        network_job.WaitUntilDone()
-                        
-                    finally:
-                        
-                        if self._download_control_file_clear is not None:
-                            
-                            wx.CallAfter( self._download_control_file_clear )
-                            
-                        
-                    
-                    with self._lock:
-                        
-                        self._current_action = 'importing file'
-                        
-                    
-                    file_import_job = FileImportJob( temp_path, self._file_import_options )
-                    
-                    ( status, hash ) = HG.client_controller.client_files_manager.ImportFile( file_import_job )
-                    
-                    seed.SetStatus( status )
-                    seed.SetHash( hash )
-                    
-                    did_substantial_work = True
-                    
-                finally:
-                    
-                    HydrusPaths.CleanUpTempPath( os_file_handle, temp_path )
+                    self._current_action = text
                     
                 
             
-            did_substantial_work = seed.WriteContentUpdates()
+            did_substantial_work = seed.WorkOnFileURL( self._file_import_options, status_hook, GenerateDownloaderNetworkJobFactory( page_key ), self._FileNetworkJobPresentationContextFactory )
             
             if seed.ShouldPresent( self._file_import_options ):
                 
-                ( media_result, ) = HG.client_controller.Read( 'media_results', ( hash, ) )
-                
-                HG.client_controller.pub( 'add_media_results', page_key, ( media_result, ) )
+                seed.PresentToPage( page_key )
                 
                 did_substantial_work = True
                 
             
-        except HydrusExceptions.ShutdownException:
-            
-            return
-            
-        except HydrusExceptions.VetoException as e:
-            
-            status = CC.STATUS_VETOED
-            
-            note = HydrusData.ToUnicode( e )
-            
-            seed.SetStatus( status, note = note )
-            
-            if isinstance( e, HydrusExceptions.CancelledException ):
-                
-                time.sleep( 2 )
-                
-            
-        except HydrusExceptions.NotFoundException:
-            
-            status = CC.STATUS_VETOED
-            note = '404'
-            
-            seed.SetStatus( status, note = note )
-            
-            time.sleep( 2 )
-            
         except Exception as e:
             
             status = CC.STATUS_ERROR
@@ -3460,6 +3836,8 @@ class SimpleDownloaderImport( HydrusSerialisable.SerialisableBase ):
             
             self._seed_cache.NotifySeedsUpdated( ( seed, ) )
             
+            HG.client_controller.pub( 'refresh_page_name', page_key )
+            
             with self._lock:
                 
                 self._current_action = ''
@@ -3487,31 +3865,16 @@ class SimpleDownloaderImport( HydrusSerialisable.SerialisableBase ):
             
             try:
                 
-                network_job = ClientNetworkingJobs.NetworkJob( 'GET', url )
+                network_job = ClientNetworkingJobs.NetworkJobDownloader( page_key, 'GET', url )
                 
                 network_job.OverrideBandwidth()
                 
                 HG.client_controller.network_engine.AddJob( network_job )
                 
-                with self._lock:
-                    
-                    if self._download_control_page_set is not None:
-                        
-                        wx.CallAfter( self._download_control_page_set, network_job )
-                        
-                    
-                
-                try:
+                with self._PageNetworkJobPresentationContextFactory( network_job ):
                     
                     network_job.WaitUntilDone()
                     
-                finally:
-                    
-                    if self._download_control_page_clear is not None:
-                        
-                        wx.CallAfter( self._download_control_page_clear )
-                        
-                    
                 
                 data = network_job.GetContent()
                 
@@ -3564,6 +3927,10 @@ class SimpleDownloaderImport( HydrusSerialisable.SerialisableBase ):
                 
                 parser_status = HydrusData.ToUnicode( e )
                 
+            finally:
+                
+                HG.client_controller.pub( 'refresh_page_name', page_key )
+                
             
             with self._lock:
                 
@@ -3744,6 +4111,14 @@ class SimpleDownloaderImport( HydrusSerialisable.SerialisableBase ):
             
         
     
+    def GetValueRange( self ):
+        
+        with self._lock:
+            
+            return self._seed_cache.GetValueRange()
+            
+        
+    
     def PausePlayFiles( self ):
         
         with self._lock:
@@ -4114,8 +4489,6 @@ class Subscription( HydrusSerialisable.SerialisableBaseNamed ):
                     break
                     
                 
-                url = seed.seed_data
-                
                 if job_key.IsCancelled():
                     
                     self._DelayWork( 300, 'recently cancelled' )
@@ -4143,89 +4516,109 @@ class Subscription( HydrusSerialisable.SerialisableBaseNamed ):
                     
                     x_out_of_y = 'file ' + HydrusData.ConvertValueRangeToPrettyString( num_done, num_urls ) + ': '
                     
-                    job_key.SetVariable( 'popup_text_2', x_out_of_y + 'checking url status' )
                     job_key.SetVariable( 'popup_gauge_2', ( num_done, num_urls ) )
                     
-                    ( status, hash ) = seed.GeneratePreImportStatus( self._file_import_options )
-                    
-                    if status == CC.STATUS_SUCCESSFUL_BUT_REDUNDANT:
+                    if seed.WorksInNewSystem():
                         
-                        if self._tag_import_options.ShouldFetchTagsEvenIfURLKnownAndFileAlreadyInDB() and self._tag_import_options.WorthFetchingTags():
+                        def status_hook( text ):
                             
-                            job_key.SetVariable( 'popup_text_2', x_out_of_y + 'found file in db, fetching tags' )
+                            job_key.SetVariable( 'popup_text_2', x_out_of_y + text )
                             
-                            downloaded_tags = gallery.GetTags( url )
-                            
-                            seed.AddTags( downloaded_tags )
                             
                         
-                    elif status == CC.STATUS_UNKNOWN:
+                        seed.WorkOnPostURL( self._file_import_options, self._tag_import_options, status_hook, GenerateSubscriptionNetworkJobFactory( self._GetNetworkJobSubscriptionKey( query ) ), GenerateSubscriptionNetworkJobPresentationContextFactory( job_key ) )
                         
-                        ( os_file_handle, temp_path ) = HydrusPaths.GetTempPath()
-                        
-                        try:
+                        if seed.ShouldPresent( self._file_import_options ):
                             
-                            job_key.SetVariable( 'popup_text_2', x_out_of_y + 'downloading file' )
-                            
-                            if self._tag_import_options.WorthFetchingTags():
-                                
-                                downloaded_tags = gallery.GetFileAndTags( temp_path, url )
-                                
-                                seed.AddTags( downloaded_tags )
-                                
-                            else:
-                                
-                                gallery.GetFile( temp_path, url )
-                                
-                            
-                            seed.CheckPreFetchMetadata( self._tag_import_options )
-                            
-                            job_key.SetVariable( 'popup_text_2', x_out_of_y + 'importing file' )
-                            
-                            file_import_job = FileImportJob( temp_path, self._file_import_options )
-                            
-                            ( status, hash ) = HG.client_controller.client_files_manager.ImportFile( file_import_job )
-                            
-                            seed.SetStatus( status )
-                            seed.SetHash( hash )
-                            
-                            if status == CC.STATUS_SUCCESSFUL_AND_NEW:
-                                
-                                job_key.SetVariable( 'popup_text_2', x_out_of_y + 'import successful' )
-                                
-                            elif status == CC.STATUS_DELETED:
-                                
-                                job_key.SetVariable( 'popup_text_2', x_out_of_y + 'previously deleted' )
-                                
-                            elif status == CC.STATUS_SUCCESSFUL_BUT_REDUNDANT:
-                                
-                                job_key.SetVariable( 'popup_text_2', x_out_of_y + 'already in db' )
-                                
+                            hash = seed.GetHash()
                             
                             if hash not in presentation_hashes_fast:
                                 
-                                if seed.ShouldPresent( self._file_import_options ):
+                                if hash not in all_presentation_hashes_fast:
                                     
-                                    if hash not in all_presentation_hashes_fast:
-                                        
-                                        all_presentation_hashes.append( hash )
-                                        
-                                        all_presentation_hashes_fast.add( hash )
-                                        
+                                    all_presentation_hashes.append( hash )
                                     
-                                    presentation_hashes.append( hash )
-                                    
-                                    presentation_hashes_fast.add( hash )
+                                    all_presentation_hashes_fast.add( hash )
                                     
                                 
-                            
-                        finally:
-                            
-                            HydrusPaths.CleanUpTempPath( os_file_handle, temp_path )
+                                presentation_hashes.append( hash )
+                                
+                                presentation_hashes_fast.add( hash )
+                                
                             
                         
-                    
-                    seed.WriteContentUpdates( self._tag_import_options )
+                    else:
+                        
+                        job_key.SetVariable( 'popup_text_2', x_out_of_y + 'checking url status' )
+                        
+                        seed.PredictPreImportStatus( self._file_import_options )
+                        
+                        status = seed.status
+                        url = seed.seed_data
+                        
+                        if status == CC.STATUS_SUCCESSFUL_BUT_REDUNDANT:
+                            
+                            if self._tag_import_options.ShouldFetchTagsEvenIfURLKnownAndFileAlreadyInDB() and self._tag_import_options.WorthFetchingTags():
+                                
+                                job_key.SetVariable( 'popup_text_2', x_out_of_y + 'found file in db, fetching tags' )
+                                
+                                downloaded_tags = gallery.GetTags( url )
+                                
+                                seed.AddTags( downloaded_tags )
+                                
+                            
+                        elif status == CC.STATUS_UNKNOWN:
+                            
+                            ( os_file_handle, temp_path ) = HydrusPaths.GetTempPath()
+                            
+                            try:
+                                
+                                job_key.SetVariable( 'popup_text_2', x_out_of_y + 'downloading file' )
+                                
+                                if self._tag_import_options.WorthFetchingTags():
+                                    
+                                    downloaded_tags = gallery.GetFileAndTags( temp_path, url )
+                                    
+                                    seed.AddTags( downloaded_tags )
+                                    
+                                else:
+                                    
+                                    gallery.GetFile( temp_path, url )
+                                    
+                                
+                                seed.CheckPreFetchMetadata( self._tag_import_options )
+                                
+                                job_key.SetVariable( 'popup_text_2', x_out_of_y + 'importing file' )
+                                
+                                seed.Import( temp_path, self._file_import_options )
+                                
+                                hash = seed.GetHash()
+                                
+                                if hash not in presentation_hashes_fast:
+                                    
+                                    if seed.ShouldPresent( self._file_import_options ):
+                                        
+                                        if hash not in all_presentation_hashes_fast:
+                                            
+                                            all_presentation_hashes.append( hash )
+                                            
+                                            all_presentation_hashes_fast.add( hash )
+                                            
+                                        
+                                        presentation_hashes.append( hash )
+                                        
+                                        presentation_hashes_fast.add( hash )
+                                        
+                                    
+                                
+                            finally:
+                                
+                                HydrusPaths.CleanUpTempPath( os_file_handle, temp_path )
+                                
+                            
+                        
+                        seed.WriteContentUpdates( self._tag_import_options )
+                        
                     
                 except HydrusExceptions.CancelledException as e:
                     
@@ -5219,25 +5612,10 @@ class ThreadWatcherImport( HydrusSerialisable.SerialisableBase ):
             
             HG.client_controller.network_engine.AddJob( network_job )
             
-            with self._lock:
-                
-                if self._download_control_thread_set is not None:
-                    
-                    wx.CallAfter( self._download_control_thread_set, network_job )
-                    
-                
-            
-            try:
+            with self._ThreadNetworkJobPresentationContextFactory( network_job ):
                 
                 network_job.WaitUntilDone()
                 
-            finally:
-                
-                if self._download_control_thread_clear is not None:
-                    
-                    wx.CallAfter( self._download_control_thread_clear )
-                    
-                
             
             data = network_job.GetContent()
             
@@ -5319,6 +5697,33 @@ class ThreadWatcherImport( HydrusSerialisable.SerialisableBase ):
         self._no_work_until_reason = reason
         
     
+    def _FileNetworkJobPresentationContextFactory( self, network_job ):
+        
+        def enter_call():
+            
+            with self._lock:
+                
+                if self._download_control_file_set is not None:
+                    
+                    wx.CallAfter( self._download_control_file_set, network_job )
+                    
+                
+            
+        
+        def exit_call():
+            
+            with self._lock:
+                
+                if self._download_control_file_clear is not None:
+                    
+                    wx.CallAfter( self._download_control_file_clear )
+                    
+                
+            
+        
+        return NetworkJobPresentationContext( enter_call, exit_call )
+        
+    
     def _FinishCheck( self, page_key, watcher_status, error_occurred, watcher_status_should_stick ):
         
         if error_occurred:
@@ -5363,6 +5768,8 @@ class ThreadWatcherImport( HydrusSerialisable.SerialisableBase ):
                 
             
         
+        HG.client_controller.pub( 'refresh_page_name', page_key )
+        
     
     def _GetSerialisableInfo( self ):
         
@@ -5379,6 +5786,16 @@ class ThreadWatcherImport( HydrusSerialisable.SerialisableBase ):
         return self._thread_url != ''
         
     
+    def _InitialiseFromSerialisableInfo( self, serialisable_info ):
+        
+        ( self._thread_url, serialisable_seed_cache, self._urls_to_filenames, self._urls_to_md5_base64, serialisable_checker_options, serialisable_file_options, serialisable_tag_options, self._last_check_time, self._files_paused, self._thread_paused, self._thread_status, self._thread_subject, self._no_work_until, self._no_work_until_reason ) = serialisable_info
+        
+        self._seed_cache = HydrusSerialisable.CreateFromSerialisableTuple( serialisable_seed_cache )
+        self._checker_options = HydrusSerialisable.CreateFromSerialisableTuple( serialisable_checker_options )
+        self._file_import_options = HydrusSerialisable.CreateFromSerialisableTuple( serialisable_file_options )
+        self._tag_import_options = HydrusSerialisable.CreateFromSerialisableTuple( serialisable_tag_options )
+        
+    
     def _PublishPageName( self, page_key ):
         
         new_options = HG.client_controller.new_options
@@ -5435,14 +5852,31 @@ class ThreadWatcherImport( HydrusSerialisable.SerialisableBase ):
         
         
     
-    def _InitialiseFromSerialisableInfo( self, serialisable_info ):
+    def _ThreadNetworkJobPresentationContextFactory( self, network_job ):
         
-        ( self._thread_url, serialisable_seed_cache, self._urls_to_filenames, self._urls_to_md5_base64, serialisable_checker_options, serialisable_file_options, serialisable_tag_options, self._last_check_time, self._files_paused, self._thread_paused, self._thread_status, self._thread_subject, self._no_work_until, self._no_work_until_reason ) = serialisable_info
+        def enter_call():
+            
+            with self._lock:
+                
+                if self._download_control_thread_set is not None:
+                    
+                    wx.CallAfter( self._download_control_thread_set, network_job )
+                    
+                
+            
         
-        self._seed_cache = HydrusSerialisable.CreateFromSerialisableTuple( serialisable_seed_cache )
-        self._checker_options = HydrusSerialisable.CreateFromSerialisableTuple( serialisable_checker_options )
-        self._file_import_options = HydrusSerialisable.CreateFromSerialisableTuple( serialisable_file_options )
-        self._tag_import_options = HydrusSerialisable.CreateFromSerialisableTuple( serialisable_tag_options )
+        def exit_call():
+            
+            with self._lock:
+                
+                if self._download_control_thread_clear is not None:
+                    
+                    wx.CallAfter( self._download_control_thread_clear )
+                    
+                
+            
+        
+        return NetworkJobPresentationContext( enter_call, exit_call )
         
     
     def _UpdateFileVelocityStatus( self ):
@@ -5537,77 +5971,19 @@ class ThreadWatcherImport( HydrusSerialisable.SerialisableBase ):
         
         try:
             
-            with self._lock:
-                
-                self._current_action = 'reviewing file'
-                
-            
-            ( status, hash ) = seed.GeneratePreImportStatus( self._file_import_options )
-            
-            if status == CC.STATUS_UNKNOWN:
-                
-                seed.CheckPreFetchMetadata( self._tag_import_options )
+            def status_hook( text ):
                 
                 with self._lock:
                     
-                    self._current_action = 'downloading file'
-                    
-                
-                ( os_file_handle, temp_path ) = HydrusPaths.GetTempPath()
-                
-                try:
-                    
-                    network_job = ClientNetworkingJobs.NetworkJobWatcherPage( self._thread_key, 'GET', file_url, temp_path = temp_path )
-                    
-                    HG.client_controller.network_engine.AddJob( network_job )
-                    
-                    with self._lock:
-                        
-                        if self._download_control_file_set is not None:
-                            
-                            wx.CallAfter( self._download_control_file_set, network_job )
-                            
-                        
-                    
-                    try:
-                        
-                        network_job.WaitUntilDone()
-                        
-                    finally:
-                        
-                        if self._download_control_file_clear is not None:
-                            
-                            wx.CallAfter( self._download_control_file_clear )
-                            
-                        
-                    
-                    with self._lock:
-                        
-                        self._current_action = 'importing file'
-                        
-                    
-                    file_import_job = FileImportJob( temp_path, self._file_import_options )
-                    
-                    did_substantial_work = True
-                    
-                    ( status, hash ) = HG.client_controller.client_files_manager.ImportFile( file_import_job )
-                    
-                    seed.SetStatus( status )
-                    seed.SetHash( hash )
-                    
-                finally:
-                    
-                    HydrusPaths.CleanUpTempPath( os_file_handle, temp_path )
+                    self._current_action = text
                     
                 
             
-            did_substantial_work = seed.WriteContentUpdates( self._tag_import_options )
+            did_substantial_work = seed.WorkOnFileURL( self._file_import_options, status_hook, GenerateWatcherNetworkJobFactory( self._thread_key ), self._FileNetworkJobPresentationContextFactory, tag_import_options = self._tag_import_options )
             
             if seed.ShouldPresent( self._file_import_options ):
                 
-                ( media_result, ) = HG.client_controller.Read( 'media_results', ( hash, ) )
-                
-                HG.client_controller.pub( 'add_media_results', page_key, ( media_result, ) )
+                seed.PresentToPage( page_key )
                 
                 did_substantial_work = True
                 
@@ -5648,6 +6024,8 @@ class ThreadWatcherImport( HydrusSerialisable.SerialisableBase ):
             
             self._seed_cache.NotifySeedsUpdated( ( seed, ) )
             
+            HG.client_controller.pub( 'refresh_page_name', page_key )
+            
             with self._lock:
                 
                 self._current_action = ''
@@ -5809,6 +6187,14 @@ class ThreadWatcherImport( HydrusSerialisable.SerialisableBase ):
             
         
     
+    def GetValueRange( self ):
+        
+        with self._lock:
+            
+            return self._seed_cache.GetValueRange()
+            
+        
+    
     def HasThread( self ):
         
         with self._lock:
@@ -5977,6 +6363,33 @@ class URLsImport( HydrusSerialisable.SerialisableBase ):
         self._file_import_options = HydrusSerialisable.CreateFromSerialisableTuple( serialisable_file_options )
         
     
+    def _NetworkJobPresentationContextFactory( self, network_job ):
+        
+        def enter_call():
+            
+            with self._lock:
+                
+                if self._download_control_file_set is not None:
+                    
+                    wx.CallAfter( self._download_control_file_set, network_job )
+                    
+                
+            
+        
+        def exit_call():
+            
+            with self._lock:
+                
+                if self._download_control_file_clear is not None:
+                    
+                    wx.CallAfter( self._download_control_file_clear )
+                    
+                
+            
+        
+        return NetworkJobPresentationContext( enter_call, exit_call )
+        
+    
     def _RegenerateSeedCacheStatus( self ):
         
         new_seed_cache_status = self._seed_cache.GetStatus()
@@ -6020,7 +6433,7 @@ class URLsImport( HydrusSerialisable.SerialisableBase ):
             
             if url_type in ( HC.URL_TYPE_UNKNOWN, HC.URL_TYPE_FILE ):
                 
-                did_substantial_work = self._WorkOnFilesRawURL( page_key, seed, seed.seed_data )
+                did_substantial_work = self._WorkOnFilesRawURL( page_key, seed )
                 
             elif url_type == HC.URL_TYPE_POST:
                 
@@ -6031,32 +6444,6 @@ class URLsImport( HydrusSerialisable.SerialisableBase ):
                 raise NotImplementedError( 'Unfortunately, galleries and watchable urls do not work here yet!' )
                 
             
-        except HydrusExceptions.ShutdownException:
-            
-            return
-            
-        except HydrusExceptions.VetoException as e:
-            
-            status = CC.STATUS_VETOED
-            
-            note = HydrusData.ToUnicode( e )
-            
-            seed.SetStatus( status, note = note )
-            
-            if isinstance( e, HydrusExceptions.CancelledException ):
-                
-                time.sleep( 2 )
-                
-            
-        except HydrusExceptions.NotFoundException:
-            
-            status = CC.STATUS_VETOED
-            note = '404'
-            
-            seed.SetStatus( status, note = note )
-            
-            time.sleep( 2 )
-            
         except Exception as e:
             
             status = CC.STATUS_ERROR
@@ -6069,6 +6456,8 @@ class URLsImport( HydrusSerialisable.SerialisableBase ):
             
             self._seed_cache.NotifySeedsUpdated( ( seed, ) )
             
+            HG.client_controller.pub( 'refresh_page_name', page_key )
+            
             with self._lock:
                 
                 self._RegenerateSeedCacheStatus()
@@ -6085,90 +6474,15 @@ class URLsImport( HydrusSerialisable.SerialisableBase ):
         
         url = seed.seed_data
         
-        seed.GeneratePreImportStatus( self._file_import_options )
-        
         tag_import_options = HG.client_controller.network_engine.domain_manager.GetDefaultTagImportOptionsForURL( url )
         
-        file_url = None
+        status_hook = lambda s: s # do nothing for now
         
-        if seed.ShouldFetchPageMetadata( tag_import_options ):
-            
-            ( url_to_check, parser ) = HG.client_controller.network_engine.domain_manager.GetURLToFetchAndParser( url )
-            
-            if parser is None:
-                
-                raise HydrusExceptions.ParseException( 'Could not find a parser for the given URL!' )
-                
-            
-            network_job = ClientNetworkingJobs.NetworkJob( 'GET', url_to_check )
-            
-            HG.client_controller.network_engine.AddJob( network_job )
-            
-            with self._lock:
-                
-                if self._download_control_file_set is not None:
-                    
-                    wx.CallAfter( self._download_control_file_set, network_job )
-                    
-                
-            
-            try:
-                
-                network_job.WaitUntilDone()
-                
-            finally:
-                
-                with self._lock:
-                    
-                    if self._download_control_file_clear is not None:
-                        
-                        wx.CallAfter( self._download_control_file_clear )
-                        
-                    
-                
-            
-            data = network_job.GetContent()
-            
-            parsing_context = {}
-            
-            parsing_context[ 'post_url' ] = url
-            parsing_context[ 'url' ] = url_to_check
-            
-            all_parse_results = parser.Parse( parsing_context, data )
-            
-            if len( all_parse_results ) == 0:
-                
-                raise HydrusExceptions.ParseException( 'Could not parse any data!' )
-                
-            
-            parse_results = all_parse_results[0]
-            
-            seed.AddParseResults( parse_results )
-            
-            seed.CheckPreFetchMetadata( tag_import_options )
-            
-            file_urls = ClientParsing.GetURLsFromParseResults( parse_results, ( HC.URL_TYPE_FILE, ) )
-            
-            if len( file_urls ) == 0:
-                
-                raise HydrusExceptions.ParseException( 'Could not file a file URL!' )
-                
-            
-            file_url = file_urls[0]
-            
-            self._DownloadAndImportRawFile( seed, file_url )
-            
-            
-        
-        did_substantial_work = seed.WriteContentUpdates( tag_import_options )
+        did_substantial_work = seed.WorkOnPostURL( self._file_import_options, tag_import_options, status_hook, GenerateDownloaderNetworkJobFactory( page_key ), self._NetworkJobPresentationContextFactory )
         
         if seed.ShouldPresent( self._file_import_options ):
             
-            hash = seed.GetHash()
-            
-            ( media_result, ) = HG.client_controller.Read( 'media_results', ( hash, ) )
-            
-            HG.client_controller.pub( 'add_media_results', page_key, ( media_result, ) )
+            seed.PresentToPage( page_key )
             
             did_substantial_work = True
             
@@ -6176,79 +6490,21 @@ class URLsImport( HydrusSerialisable.SerialisableBase ):
         return did_substantial_work
         
     
-    def _DownloadAndImportRawFile( self, seed, file_url ):
+    def _WorkOnFilesRawURL( self, page_key, seed ):
         
-        ( os_file_handle, temp_path ) = HydrusPaths.GetTempPath()
+        status_hook = lambda s: s # do nothing for now
         
-        try:
-            
-            network_job = ClientNetworkingJobs.NetworkJob( 'GET', file_url, temp_path = temp_path )
-            
-            HG.client_controller.network_engine.AddJob( network_job )
-            
-            with self._lock:
-                
-                if self._download_control_file_set is not None:
-                    
-                    wx.CallAfter( self._download_control_file_set, network_job )
-                    
-                
-            
-            try:
-                
-                network_job.WaitUntilDone()
-                
-            finally:
-                
-                with self._lock:
-                    
-                    if self._download_control_file_clear is not None:
-                        
-                        wx.CallAfter( self._download_control_file_clear )
-                        
-                    
-                
-            
-            file_import_job = FileImportJob( temp_path, self._file_import_options )
-            
-            ( status, hash ) = HG.client_controller.client_files_manager.ImportFile( file_import_job )
-            
-            seed.AddURL( file_url )
-            seed.SetStatus( status )
-            seed.SetHash( hash )
-            
-            did_substantial_work = True
-            
-        finally:
-            
-            HydrusPaths.CleanUpTempPath( os_file_handle, temp_path )
-            
-        
-    
-    def _WorkOnFilesRawURL( self, page_key, seed, file_url ):
-        
-        ( status, hash ) = seed.GeneratePreImportStatus( self._file_import_options )
-        
-        if status == CC.STATUS_UNKNOWN:
-            
-            self._DownloadAndImportRawFile( seed, file_url )
-            
-            did_substantial_work = True
-            
-        
-        did_substantial_work = seed.WriteContentUpdates()
+        did_substantial_work = seed.WorkOnFileURL( self._file_import_options, status_hook, GenerateDownloaderNetworkJobFactory( page_key ), self._NetworkJobPresentationContextFactory )
         
         if seed.ShouldPresent( self._file_import_options ):
             
-            hash = seed.GetHash()
-            
-            ( media_result, ) = HG.client_controller.Read( 'media_results', ( hash, ) )
-            
-            HG.client_controller.pub( 'add_media_results', page_key, ( media_result, ) )
+            seed.PresentToPage( page_key )
             
             did_substantial_work = True
             
         
+        return did_substantial_work
+        
     
     def _THREADWork( self, page_key ):
         
@@ -6285,6 +6541,16 @@ class URLsImport( HydrusSerialisable.SerialisableBase ):
             
         
     
+    def CurrentlyWorking( self ):
+        
+        with self._lock:
+            
+            finished = not self._seed_cache.WorkToDo()
+            
+            return not finished and not self._paused
+            
+        
+    
     def GetSeedCache( self ):
         
         return self._seed_cache
@@ -6306,6 +6572,14 @@ class URLsImport( HydrusSerialisable.SerialisableBase ):
             
         
     
+    def GetValueRange( self ):
+        
+        with self._lock:
+            
+            return self._seed_cache.GetValueRange()
+            
+        
+    
     def PausePlay( self ):
         
         with self._lock:
diff --git a/include/ClientMedia.py b/include/ClientMedia.py
index 7366d699..95ff8bf5 100644
--- a/include/ClientMedia.py
+++ b/include/ClientMedia.py
@@ -1664,7 +1664,10 @@ class MediaSingleton( Media ):
     
     def IsCollection( self ): return False
     
-    def IsImage( self ): return self._media_result.GetMime() in HC.IMAGES
+    def IsImage( self ):
+        
+        return self._media_result.GetMime() in HC.IMAGES and not self.HasDuration()
+        
     
     def IsNoisy( self ): return self._media_result.GetMime() in HC.NOISY_MIMES
     
diff --git a/include/ClientParsing.py b/include/ClientParsing.py
index 46c80367..1783af5b 100644
--- a/include/ClientParsing.py
+++ b/include/ClientParsing.py
@@ -293,6 +293,11 @@ def GetTimestampFromParseResults( results, desired_timestamp_type ):
                     continue
                     
                 
+                if timestamp_type == HC.TIMESTAMP_TYPE_SOURCE:
+                    
+                    timestamp = min( HydrusData.GetNow() - 30, timestamp )
+                    
+                
                 timestamp_results.append( timestamp )
                 
             
@@ -337,7 +342,7 @@ def GetTitleFromAllParseResults( all_parse_results ):
         return None
         
     
-def GetURLsFromParseResults( results, desired_url_types ):
+def GetURLsFromParseResults( results, desired_url_types, only_get_top_priority = False ):
     
     url_results = collections.defaultdict( list )
     
@@ -354,24 +359,36 @@ def GetURLsFromParseResults( results, desired_url_types ):
             
         
     
-    # ( priority, url_list ) pairs
-    
-    url_results = list( url_results.items() )
-    
-    # ordered by descending priority
-    
-    url_results.sort( reverse = True )
-    
-    # url_lists of descending priority
-    
-    if len( url_results ) > 0:
+    if only_get_top_priority:
         
-        ( priority, url_list ) = url_results[0]
+        # ( priority, url_list ) pairs
+        
+        url_results = list( url_results.items() )
+        
+        # ordered by descending priority
+        
+        url_results.sort( reverse = True )
+        
+        # url_lists of descending priority
+        
+        if len( url_results ) > 0:
+            
+            ( priority, url_list ) = url_results[0]
+            
+        else:
+            
+            url_list = []
+            
         
     else:
         
         url_list = []
         
+        for u_l in url_results.values():
+            
+            url_list.extend( u_l )
+            
+        
     
     return url_list
     
@@ -1866,6 +1883,8 @@ class PageParser( HydrusSerialisable.SerialisableBaseNamed ):
             
         except HydrusExceptions.VetoException as e:
             
+            all_parse_results = [ 1 ]
+            
             pretty_parse_result_text = 'veto: ' + HydrusData.ToUnicode( e )
             
         
@@ -2404,14 +2423,21 @@ class StringConverter( HydrusSerialisable.SerialisableBase ):
         
         self.transformations = []
         
-        for ( transformation_type, data ) in serialisable_transformations:
+        try: # I initialised this bad one time and broke a dialog on subsequent loads, fugg
             
-            if isinstance( data, list ):
+            for ( transformation_type, data ) in serialisable_transformations:
                 
-                data = tuple( data ) # convert from list to tuple thing
+                if isinstance( data, list ):
+                    
+                    data = tuple( data ) # convert from list to tuple thing
+                    
+                
+                self.transformations.append( ( transformation_type, data ) )
                 
             
-            self.transformations.append( ( transformation_type, data ) )
+        except:
+            
+            pass
             
         
     
@@ -2705,7 +2731,16 @@ class StringMatch( HydrusSerialisable.SerialisableBase ):
                 fail_reason = ' did not match "' + r + '"'
                 
             
-            if re.search( r, text, flags = re.UNICODE ) is None:
+            try:
+                
+                result = re.search( r, text, flags = re.UNICODE )
+                
+            except Exception as e:
+                
+                raise HydrusExceptions.StringMatchException( 'That regex did not work! ' + HydrusData.ToUnicode( e ) )
+                
+            
+            if result is None:
                 
                 raise HydrusExceptions.StringMatchException( presentation_text + fail_reason )
                 
diff --git a/include/HydrusConstants.py b/include/HydrusConstants.py
index 49c234aa..ffd14d75 100755
--- a/include/HydrusConstants.py
+++ b/include/HydrusConstants.py
@@ -49,7 +49,7 @@ options = {}
 # Misc
 
 NETWORK_VERSION = 18
-SOFTWARE_VERSION = 304
+SOFTWARE_VERSION = 305
 
 UNSCALED_THUMBNAIL_DIMENSIONS = ( 200, 200 )
 
diff --git a/include/TestDB.py b/include/TestDB.py
index c969acb1..df12b3f9 100644
--- a/include/TestDB.py
+++ b/include/TestDB.py
@@ -1384,31 +1384,6 @@ class TestServerDB( unittest.TestCase ):
         
         self.assertEqual( set( result ), { self._tag_service_key, self._file_service_key } )
         
-        #
-        
-        result = self._read( 'services_info' )
-        
-        services_info = { service_key : ( service_type, options ) for ( service_key, service_type, options ) in result }
-        
-        self.assertEqual( services_info[ HC.SERVER_ADMIN_KEY ], ( 99, { 'max_monthly_data' : None, 'message' : 'hydrus server administration service', 'max_storage' : None, 'upnp' : None, 'port' : 45870 } ) )
-        self.assertEqual( services_info[ self._tag_service_key ], ( HC.TAG_REPOSITORY, t_options ) )
-        self.assertEqual( services_info[ self._file_service_key ], ( HC.FILE_REPOSITORY, f_options ) )
-        
-        #
-        
-        f_options_modified = dict( f_options )
-        f_options_modified[ 'port' ] = 102
-        
-        edit_log = [ ( HC.EDIT, ( self._file_service_key, HC.FILE_REPOSITORY, f_options_modified ) ) ]
-        
-        self._write( 'services', self._admin_account_key, edit_log )
-        
-        result = self._read( 'services_info' )
-        
-        services_info = { service_key : ( service_type, options ) for ( service_key, service_type, options ) in result }
-        
-        self.assertEqual( services_info[ self._file_service_key ], ( HC.FILE_REPOSITORY, f_options_modified ) )
-        
     
     def test_server( self ):
         
diff --git a/include/TestHydrusServer.py b/include/TestHydrusServer.py
index c252a85b..431667c6 100644
--- a/include/TestHydrusServer.py
+++ b/include/TestHydrusServer.py
@@ -322,7 +322,7 @@ class TestServer( unittest.TestCase ):
         
         # num_petitions
         
-        num_petitions = [ ( HC.CONTENT_TYPE_MAPPINGS, HC.CONTENT_STATUS_PETITIONED, 23 ), ( HC.CONTENT_TYPE_TAG_PARENTS, HC.CONTENT_STATUS_PENDING, 0 ) ]
+        num_petitions = [ [ HC.CONTENT_TYPE_MAPPINGS, HC.CONTENT_STATUS_PETITIONED, 23 ], [ HC.CONTENT_TYPE_TAG_PARENTS, HC.CONTENT_STATUS_PENDING, 0 ] ]
         
         HG.test_controller.SetRead( 'num_petitions', num_petitions )
         
@@ -341,7 +341,7 @@ class TestServer( unittest.TestCase ):
         
         HG.test_controller.SetRead( 'petition', petition )
         
-        response = service.Request( HC.GET, 'petition' )
+        response = service.Request( HC.GET, 'petition', { 'content_type' : HC.CONTENT_TYPE_FILES, 'status' : HC.CONTENT_UPDATE_PETITION } )
         
         self.assertEqual( response[ 'petition' ].GetSerialisableTuple(), petition.GetSerialisableTuple() )
         
@@ -361,7 +361,12 @@ class TestServer( unittest.TestCase ):
         
         path = ServerFiles.GetExpectedFilePath( definitions_update_hash )
         
-        with open( path, 'wb' ) as f: f.write( definitions_update_network_string )
+        HydrusPaths.MakeSureDirectoryExists( path )
+        
+        with open( path, 'wb' ) as f:
+            
+            f.write( definitions_update_network_string )
+            
         
         response = service.Request( HC.GET, 'update', { 'update_hash' : definitions_update_hash } )
         
@@ -475,25 +480,24 @@ class TestServer( unittest.TestCase ):
         
         # account_types
         
-        account_types = { 'message' : 'hello' }
+        account_types = [ HydrusNetwork.AccountType.GenerateAdminAccountType( service.GetServiceType() ) ]
         
         HG.test_controller.SetRead( 'account_types', account_types )
         
         response = service.Request( HC.GET, 'account_types' )
         
-        self.assertEqual( response[ 'account_types' ], account_types )
+        self.assertEqual( response[ 'account_types' ][0].GetAccountTypeKey(), account_types[0].GetAccountTypeKey() )
         
-        edit_log = 'blah'
-        
-        service.Request( HC.POST, 'account_types', { 'edit_log' : edit_log } )
+        service.Request( HC.POST, 'account_types', { 'account_types' : account_types, 'deletee_account_type_keys_to_new_account_type_keys' : {} } )
         
         written = HG.test_controller.GetWrite( 'account_types' )
         
         [ ( args, kwargs ) ] = written
         
-        ( written_service_key, written_edit_log ) = args
+        ( written_service_key, written_account, written_account_types, written_deletee_account_type_keys_to_new_account_type_keys ) = args
         
-        self.assertEqual( edit_log, written_edit_log )
+        self.assertEqual( written_account_types[0].GetAccountTypeKey(), account_types[0].GetAccountTypeKey() )
+        self.assertEqual( written_deletee_account_type_keys_to_new_account_type_keys, {} )
         
         # registration_keys
         
@@ -514,37 +518,19 @@ class TestServer( unittest.TestCase ):
         
         HG.test_controller.SetRead( 'access_key', access_key )
         
-        response = service.Request( HC.GET, 'access_key', 'init' )
+        response = service.Request( HC.GET, 'access_key', { 'registration_key' : 'init' } )
         
         self.assertEqual( response[ 'access_key' ], access_key )
         
         #
         
-        # backup
+        ## backup
         
         response = service.Request( HC.POST, 'backup' )
         
-        # services
+        #
         
-        services_info = { 'message' : 'hello' }
-        
-        HG.test_controller.SetRead( 'services_info', services_info )
-        
-        response = service.Request( HC.GET, 'services_info' )
-        
-        self.assertEqual( response[ 'services_info' ], services_info )
-        
-        edit_log = 'blah'
-        
-        registration_keys = service.Request( HC.POST, 'services', { 'edit_log' : edit_log } )
-        
-        written = HG.test_controller.GetWrite( 'services' )
-        
-        [ ( args, kwargs ) ] = written
-        
-        ( written_service_key, written_edit_log ) = args
-        
-        self.assertEqual( edit_log, written_edit_log )
+        # add some new services info
         
     
     def _test_tag_repo( self, service ):
diff --git a/static/default/parsers/danbooru file page parser.png b/static/default/parsers/danbooru file page parser.png
new file mode 100644
index 0000000000000000000000000000000000000000..2ae51dc8e560d5b093d6cb7d368c78fba8895fd9
GIT binary patch
literal 2715
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
VhY(~P5^Mkf002ovPDHLkV1oPy9o_%{

literal 0
HcmV?d00001

diff --git a/static/default/parsers/e621 file page parser.png b/static/default/parsers/e621 file page parser.png
new file mode 100644
index 0000000000000000000000000000000000000000..1f041db51cadca522b890a18bbe225a1d4759d7b
GIT binary patch
literal 2787
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

literal 0
HcmV?d00001

diff --git a/static/default/parsers/pixiv single file page parser.png b/static/default/parsers/pixiv single file page parser.png
new file mode 100644
index 0000000000000000000000000000000000000000..31ada9df2c3e72918546742a64ff2aa9f694b666
GIT binary patch
literal 2885
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
b>I?+Lohw>RnIZZA`yXqm>#0?!JPrO2o|9{o

literal 0
HcmV?d00001

diff --git a/static/default/parsers/safebooru file page parser.png b/static/default/parsers/safebooru file page parser.png
new file mode 100644
index 0000000000000000000000000000000000000000..cb940cb773dc1ba31a9ac71f723913ef5c0798a5
GIT binary patch
literal 2925
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
E0YhnQy#N3J

literal 0
HcmV?d00001

diff --git a/static/default/parsers/yiff.party api parser.png b/static/default/parsers/yiff.party api parser.png
new file mode 100644
index 0000000000000000000000000000000000000000..9f4bc613d4913716dca34600522b3b20c0c004de
GIT binary patch
literal 2856
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

literal 0
HcmV?d00001

diff --git a/static/default/url_classes/pixiv file page.png b/static/default/url_classes/pixiv file page.png
index 22c375c638264c85a3d75aa38bc689c251952a8c..c13752368dda05e3c6c449be324446d1dbedd536 100644
GIT binary patch
delta 2079
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
JPDHLkV1imb*+BpR

delta 2113
zcmV-H2)_5q5aSS#B!4PNL_t(|+U;FyOjJh{p6f2|;sQ}xpoLW0U4>eV8c@UsDy^hi
zyR=KO3b9QDH43#V(2CK@`ixqwuWGc0RSaSx2u4$AW2qDnU8|;A(TGAKX{ms3mw4BG
z_0G)Qhq4Q`M%?9|?*}t?cII5T=bJO<%-uOK=#ydu5H1)CJbwd0qZd2^AOHXe01zs~
z@CXEhGXW;5aw9H8ZP7pgVId$06F}5p89+*~078SwWMYuH&r0*52fdI5nScPogGAbH
z_BNY)%UBkC00E-6_VVbVX0z9olkbc$K@=c7m;*D)a9RFEkQu^2A$kF!gXqq0*c&Dw
zfB?am&5UCS1b+}50~oRgVDJ)IfB*u7rO%*KNF+kF!}=hI0)&XiOA^=IHm$i{!h!`5
zqy>01__X|H>ws!G3l>0-E`WvgO|CFcd!R?cbpmS`#<!JL*-&duC>DT0M$`TKCX@Y(
zKs|y0Y^d~1=M4_}kL{vE&xJ@N>Ln8Ezsc2$xr#_6$bTikxB=y=IRXfA0cfM|fBaB0
zp+nnSbX5@6LuedsXb7|!its!33xPs-K0ufZoIybo0MHW%fc<wilwp{IHgCR$ckZ(o
zHEqBZ-tSMeE&%?DyXSqZ9qiCBR#8snW1$>)DaHh@t~Ms{Ze)kCo)#H+Bp&tmIn|H+
z{wjLaVt=vZp<J$Bjax`VL%&EJ>70oQ`C$!oOfEly{^Sb8H@lE;P$FC1D&s??MC*L4
zXTf6$Ac?}yJP%>zTGh#^#Gtfk)<9KcCxXL;BLO(|;x<mPg)Zb9l!as{md9xv_pU|=
zUpX5K1n3q5@N+KDHsR^y&m)?!ngkW?;xIj(5PzT=QG!&{?oQ<MAcFF2y)gltjrA;e
ztP|*yPKpWrZnRsQ#%7is%vL4ax}@|!&MoxDBYam^C`H*MFc{w7E~<lk>=2~kN*&)j
zM(KJiIDy@VVBdQClV1~*V%TN>Oq!&tK<M<b_)cSe<296m{W!+EslMHX{4DN6Yj26-
zzkiMe0(3XTL!Z3P=vTx|Qc2G9%GG>FEPNh>f$oR1O%5A7`;X1h&2{*&|JbrKY;i<H
z=d2lMbKo8ZI+brcBGH!ETJ#Nc@?Yq3ED+#D0$X>o2rF#_s7X`p&Mb8Z$;BV*%L<#a
zyV&}RKt-L)H(v016RZ3PRe2H54A)~}AAg`bq5v}YGLhYz=YxNT0G}&|#L-$OQ2-y<
zSqw>9=kmE&PlY4C(Krg=B0jPlNTM8q!Y9T;7}z}<L2D_2?NMJQ%6%#>#BEP)(KsQ1
zb!!Jnv@YaVlUn39{swfpp}P!D#zGj_JxIf9@o7o6duowik=U<PZSSN)k`KC+B!6!u
zAzkF{XczLw;;QN#T}o21&L!I9&c=EWJoI(&i++*YwR|?br79YEKHzQO{|-NhX9xrk
zD2y9Wd>{}&fMCP$TVPgk?D_YX++*_$RQin2kEG?^Xap8OfRLUbfnTI9xo7-6kSJ2%
z01E&F00031KmY&`000C40096%0Dk}w000C40096%000mG00aO40eUjB)Ib0a)?T8m
zs9~(>I%*s;fM~1<JR1EIpGmSUM@XZ;Ee#01g__R`q6PxE8%XYklnx17HqxWJI|ezl
zX`;G3&%3h7DvcZ<!QTPOn#|SI^iB=i)Ib0?M2zz4Q!SGo){zN)O#f_>)_+Fhqyt3=
zH3#tL3u}IGI4&Tcc@YTU5%5-$f0R-<csy^;eOrwQY3F@78-Oi3HU%1c0@=<`n&t3a
zaO1ThKma$y{u3QCf@ElLs*rN>MedV7SuAtrijU?+>dwhD6SWpYJVGm)ERX!>I`spJ
zry^8;-iN_S!PsI&0woN_>3<XHKma!brzobW<57M2RGccLkt7QEjI-;i<8-#OEA~bs
z@j4k&sgX3-S(X<zJc?WTQ#lV{=Sb`f%wA?Ogp6w^cZ$sl1Om996PUNoNg8Ms=LVMY
zi2^ulAImqNz4IQeU|SwWv%HWrfL1rM#(SnUHAE_Q22c)1m@Un9<bO_v^HJ?U0JlSG
z#=MSdiILYeUQD2&-3}dp-rG6EM|p=I`}`BNc1J$~TZnM365N|63872?0=#TQ5PMG6
zYJxSlzU`>h1?wuu$mpamm!W#TIoPYBGs&7t$5Y>Rp)zR_4ltS@D_|qYjgUgTx23Np
z@YmAZO&$ID;g|NO+kbT4n9W;!`OG=3$e828kh3eS*=2G$ftnqh51Fy;ATll-MQLGN
z7#slvc=?bv7`auuvPx!W#N>9Q3wmO!PMR};dTjEIDa=&7#K*)1MYV6*8pL=>T_zDC
zIpDbP5DQz-#Hn3=HiPksETQhEm-w9LXC8;6VFCxd3<3fGfRh6U5|auC3xDXrVDJmU
zoYd`#Dcb`MUmrfc@W7H8i_~c8<U7Y-naG@7yyUg%;k$PGP1?FI_VsOXv)bmUcivR3
zYQA^7<@=D|belI<y&v~$YVf_F6BEZx7&E2n>OYsi{4-m*x?n-U-}_Q$6>Pcwb5hxW
zmS1$uArI1G=T%D2EIUxHsDGU|tnIH+b)N?%y}R|tRnw>SLd(~0mMPx8JGXHD2EW>b
zLF3{#=|>FN_`q*Ve*UUk4}bS5zm_rEpdA>pE^TqtM^_GitxZ^PiuG5te(F^cmBu_;
zIbzTHF_-U8yMAc?xV8CyA)#CLRow7h-gl@Tr4P<B%#23o@^$OC7BU>YydfSvj=41B
rblmDieQ)0y`NzBRJ++k;0w%z}5My%yg)ea|00000NkvXXu0mjfEnnen

diff --git a/static/default/url_classes/yiff.party creator page.png b/static/default/url_classes/yiff.party creator page.png
new file mode 100644
index 0000000000000000000000000000000000000000..7c574fd6e26d51c2ac5410423ad4d664ece2964b
GIT binary patch
literal 2267
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

literal 0
HcmV?d00001

diff --git a/static/default/url_classes/yiff.party file attachment.png b/static/default/url_classes/yiff.party file attachment.png
new file mode 100644
index 0000000000000000000000000000000000000000..ddfc0c88b2ab57e5b81aea3c55c72c64dabe34f3
GIT binary patch
literal 2426
zcmaiz`9IT-1IOQ(BX`Lvu{KwhYvex4d?tq6`Fv8Y@sXPuxtSwZ<t}H*5q-#=>Qm%4
z_kAqaOvJL$7+MYAzW>1Y`^)R`{NeR@{`7jKT3Hwi@QU#Q03d)iLD>KR`)>s7c>bFc
zIpf;^a0-b=A??EEX^yd0b_5C1hQu;iLIc63s>Y_T0Pnof4OfT1>B%pUzM2U!6{)8S
zHMCsunk+*%T12?;s?S($t(nWh^Q`Y7M0vS<ZxYVu<0b7W)9@D29UZ63Z;HzV#3OQl
zO)N!6hVCp$ESBc$hLgs$sF4Ao*FPQ}G?R|DmuZ8gGb21u$3RFJcXpq67$+0}cmU|F
zezK?u*S&1Vs2p81^kX(RdnP#BHWhI97?Tu>=gbtlt8^}Taqs?np^RZ9WR0E8M2L4i
zUw4`Iye3GigF6%Y_28J+DB~Zx_#j6}F|<>`AR@5Jjun?ka54|+R<lZTGPt49zFV}9
z=L12Jf&QA8`H?`jEnqwc$ga9Wgz+G9LEch=yK1mEMGw>rz*l1zOudsGTk;&lUD%|(
z*!-2Q)iN{utn>QVzy{e$ctTdgLE^7}v#@7}EL=1RGDHx0SOue{>XCx$8~DV-*8!{A
z+8c9JIuVM)m;mYg>lfx7IA723dYD^t8paG5%I1t@4G^5KJ{qDwFb9`|JD6tf-yc=}
z=t^0)l}N`%c)u1j))mRFKb9m>pTOcfnS0!n-Y0+UvE}A@xzOwbz)7deCUm^cx?xyT
z<wfxa2Uz2QgsjV-9M3mjGk9t$J}NE+<v|GKvZfJ*uX+-$8l9UA_phu;*87TbkWbKD
zD@RX{1Y^|Nn26xD!Qy<Mdek?a<L>jQM7=2U+>)bSPlK3imVh5e`Cd|)BwY7Ko&F1_
zwe;Ldw}IQYKr*S5eEsDqn-2K2o&%MLi8Rx0>6VHtHd|-I;t#74g;j|eDl;VZQYkn6
zQw(-x1-w1gnD>kLg<$&$lJcu_Unrxk7B=(&pXxtyr7e_0_z>0=o9mHWTNbY^BSElB
z_2XhcET&9?)F;ET=Zf>Aos~%={Benp5`h<*hQG@w9Ymwx<M_cJUKgGzpY0>Jstvq#
za!{6t?y{Zw76LQ6fVN7FH$78zD0=25>QBJQ>?Wxvm;HN7@@QV3$F4dovcRwl4jO+D
zwyVTelBr<@biG&V;X3`>AmUly{`5(!!FNA51N16G1%{W?jT@TGSZIjTKXbp2aOSM6
z6XXl+3ZeF%isd4^tNeWRYR+ENr?^hzi<og2Z0)AwNnw0hnnh*aqaw=E)oEJ;ZEg4Y
ze`Qg>Z3sTAy2cWy$o^%iyOn6O_bJX_z)H(H180?04L5*E9Ed*qForF~lVc?VCn%?S
zH1-8N&UKXbU9gmY#$6_LDgkJin@!B5-<S#Bb*Z;psU8Dd!{*@+6GQL|1`)^DqVj^m
zVUxhw!k0l1YsT9}2y8pfX=CgiN>8*_%U|cKt{oZ*koh8JKJB~?@gY9Z!4N4a4i!Pi
z59X~mvKFAj$eYN=dYrWgi(|hxkqWy)=gXvp@kAe=qXJ?EAL5hv^}lB?NlIb$?{BY}
zQ7>ZMa{0L{+~ol>PxxDgy&`&BVLuvq-ehRgQ!Z_)>Tt>U6X@6rMN&+XgTEiO0po*4
znCWmmjYZ0)na$j3=j!KLE4zPM%M*H|4_f71T`?tv-ZK0!`IZD}f&z_w3RbZ{NiUTX
z+-Rwq97Hjg@n*br%@yr@uT1RB$&IcFcTgkDh$dDw#Npw|*BrAY?Zzi_Z;Wni-t?C*
z8~V5VxV|6t#z_a9_N8tjgnYOs`7;V;%3FtH2p>sd6o$YtVxydadSN5QsyT^(v(Uo`
zfk$(XtBJD3GbulXS3Cu`8jT8sL4lXatn?5wQ*)6n;XrO=Ol`q0Qw5QD&i7M1jIVAP
zf%iEC(?EOxzy=rqfG_}n{uefb?^Gj!Q0&%|AMySlgmQdg6tMWpy)sLL0$OGYBYQEP
z*}6pS%I@JsWHpF^gngiq^pA{W_Djuecl&%hujXh_>xw0AKB|qpRZqB!^rTDxKFsXl
z$QmS|k|Jt!!V|VTEvG-yJ8|ure&q+f#9jF!Vee>JA+N#jy)I2FhaQDZdr<sGcDfPc
zx~bP)mZC?mi0|m?ezdnQM~dI&%8p<@!lVv2go~{QDi{oUCTQa-Nk|ee*X^^2S)=<B
z<pO;ATS{yT8vIJa&XkJPY<NueWyTob;G-lQ*KINE!NX|p(a;qtC4B^nKhN<w*-KzK
zr5>&yw=iTVB=A=<?ZdVfX+c7LX9LEx5S_dw^^zRKQ`JF#0nYeQm}7}8*w=E?J^&7)
zkA$6VI(><F#INFxq-U@L*R6(&#6dxUj@ji%{{7EBz9Od^*Kf1DR7NrNTb8XSKU9Md
zJx?cN!({~<;V5l7uL)WtdR|4?V7RmuV;k7~dYo}*^xU4UZuzt8o7gk`3;89MVllUr
zu?)q>0X3OXmO{4nf>%X%^%IVu_)V$gd7O^D?X=U9=wh|<4waRZw!<LUZAwNKgF`V_
zJZv`tUn#B}U1;{)8c-0%KaU7l*irO2H0>_xJZ3euLx@x#+>pHoUH$KizWuk=Q(>Xg
z4M?eIZH+6VmtL+zIXpBje5P|SPVqp$SrtADo8D%WoO)py5y3z4haQVheX!ba*=>qC
zi+kyw;!F>#zE2%-t_s2qqIK2u$%>t_0rGY@>@M!g;Lj%Yj8Jw;&PRy`b@Nrca>D<e
zpofYUYv*|9spdbkGt!zw`D7cr>*8Sw6Sw?hTPe)m9Y{EhJHy}aLvdT1V(OjcDUF6$
z%YpJ=#_iQ(tjQhaqq6UtUB5{3CT%|#%4_DmhtsmxvX}w1qqV;N#{#&by`1a1$6f91
z%%6)Sb@8^sT~mrF?b5>3qm!ujdr@P9WnZ%wLsiW#sm26;qe|u3pRg9CC;`QTj&nyf
zAB4bOkZ~oye-?_=vh-OZLvJ&T7Y;9y!oBKy+i(L1TPNy%)pr|CEWcHSO8B#mJD)c>
zK27LXr61ajzF~B~Gk$)@R*l%$ROwCWZ&v0Ppz1~k)Hb(!gwJjzx9c^yM7<<WXPk>=
zU``I3oOA+LK0j#pVltjfC>E6vgUK$mSG6(L+v%3zvtWpMU@YyAIS7p~_%3~2^BqgO
kPO}^rGWB4o`3`WxU0EShrK^(k`|ALJHnKp~8M?&(2MfxG4FCWD

literal 0
HcmV?d00001

diff --git a/static/default/url_classes/yiff.party file post.png b/static/default/url_classes/yiff.party file post.png
new file mode 100644
index 0000000000000000000000000000000000000000..a0f1826194f5d15ac2c3a7db041dd429a0d964ba
GIT binary patch
literal 2236
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
KMNUMnLSTYx=@be8

literal 0
HcmV?d00001

diff --git a/static/default/url_classes/yiff.party json api.png b/static/default/url_classes/yiff.party json api.png
new file mode 100644
index 0000000000000000000000000000000000000000..2d25e726518773ac46e1c138d36661c1be114ef3
GIT binary patch
literal 2156
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

literal 0
HcmV?d00001