Changeset 3770

Timestamp:

08/28/08 04:40:49 (4 months ago)

Author:

andar

Message:

Implement #352 set_torrent_options method in core

Location:

trunk/deluge/core

Files:

• core.py (modified) (1 diff)
• torrent.py (modified) (14 diffs)
• torrentmanager.py (modified) (7 diffs)

trunk/deluge/core/core.py

@@ -521 +521 @@
             self.torrents[torrent_id].force_recheck()
 
+    def export_set_torrent_options(self, torrent_ids, options):
+        """Sets the torrent options for torrent_ids"""
+        for torrent_id in torrent_ids:
+            self.torrents[torrent_id].set_options(options)
+            
     def export_set_torrent_trackers(self, torrent_id, trackers):
         """Sets a torrents tracker list.  trackers will be [{"url", "tier"}]"""

trunk/deluge/core/torrent.py

@@ -42 +42 @@
 from deluge.configmanager import ConfigManager
 from deluge.log import LOG as log
+from deluge.core.preferencesmanager import DEFAULT_PREFS
 import deluge.xmlrpclib
 
 TORRENT_STATE = deluge.common.TORRENT_STATE
+
+OPTIONS = {
+    "max_download_speed": DEFAULT_PREFS["max_download_speed_per_torrent"],
+    "max_upload_speed": DEFAULT_PREFS["max_upload_speed_per_torrent"],
+    "max_connections": DEFAULT_PREFS["max_connections_per_torrent"],
+    "max_upload_slots": DEFAULT_PREFS["max_upload_slots_per_torrent"],
+    "prioritize_first_last_pieces": DEFAULT_PREFS["prioritize_first_last_pieces"],
+    "auto_managed": DEFAULT_PREFS["auto_managed"],
+    "stop_at_ratio": DEFAULT_PREFS["stop_seed_at_ratio"],
+    "stop_ratio": DEFAULT_PREFS["stop_seed_ratio"],
+    "remove_at_ratio": DEFAULT_PREFS["remove_seed_at_ratio"],
+    "move_completed": DEFAULT_PREFS["move_completed"],
+    "move_completed_path": DEFAULT_PREFS["move_completed_path"],
+    "file_priorities": [],
+    "compact_allocation": DEFAULT_PREFS["compact_allocation"],
+    "download_location": DEFAULT_PREFS["download_location"],
+    "add_paused": DEFAULT_PREFS["add_paused"]
+}
 
 class Torrent:
@@ -70 +89 @@
         # Files dictionary
         self.files = self.get_files()
-        # Set the default file priorities to normal
-        self.file_priorities = [1]* len(self.files)
-
+        
         # Default total_uploaded to 0, this may be changed by the state
         self.total_uploaded = 0
 
-        # Set default auto_managed value
-        self.auto_managed = options["auto_managed"]
-        if not handle.is_paused():
-            handle.auto_managed(self.auto_managed)
-
+        # Set the default options
+        self.options = OPTIONS
+        self.options.update(options)
+        
         # We need to keep track if the torrent is finished in the state to prevent
         # some weird things on state load.
         self.is_finished = False
 
-        # Queueing options
-        self.stop_at_ratio = False
-        self.stop_ratio = 2.00
-        self.remove_at_ratio = False
-
-        self.move_on_completed = False
-        self.move_on_completed_path = deluge.common.get_default_download_dir()
-
         # Load values from state if we have it
-        if state is not None:
+        if state:
             # This is for saving the total uploaded between sessions
             self.total_uploaded = state.total_uploaded
@@ -103 +111 @@
             self.is_finished = state.is_finished
             # Set the per-torrent queue options
-            self.set_stop_at_ratio(state.stop_at_ratio)
-            self.set_stop_ratio(state.stop_ratio)
-            self.set_remove_at_ratio(state.remove_at_ratio)
+            self.options["stop_at_ratio"] = state.stop_at_ratio
+            self.options["stop_ratio"] = state.stop_ratio
+            self.options["remove_at_ratio"] = state.remove_at_ratio
         else:
             # Tracker list
@@ -117 +125 @@
 
         # Various torrent options
-        self.set_max_connections(options["max_connections_per_torrent"])
-        self.set_max_upload_slots(options["max_upload_slots_per_torrent"])
-        self.set_max_upload_speed(options["max_upload_speed_per_torrent"])
-        self.set_max_download_speed(options["max_download_speed_per_torrent"])
-        self.set_prioritize_first_last(options["prioritize_first_last_pieces"])
         self.handle.resolve_countries(True)
-        if options.has_key("file_priorities"):
-            self.set_file_priorities(options["file_priorities"])
-
-        # Set the allocation mode
-        self.compact = options["compact_allocation"]
-        # Where the torrent is being saved to
-        self.save_path = options["download_location"]
+        self.set_options(self.options)
+        
         # Status message holds error info about the torrent
         self.statusmsg = "OK"
@@ -141 +139 @@
         log.debug("Torrent object created.")
 
-    def set_tracker_status(self, status):
-        """Sets the tracker status"""
-        self.tracker_status = status
-
+    ## Options methods ##
+    def set_options(self, options):
+        OPTIONS_FUNCS = {
+            # Functions used for setting options
+            "max_download_speed": self.set_max_download_speed,
+            "max_upload_speed": self.set_max_upload_speed,
+            "max_connections": self.handle.set_max_connections,
+            "max_upload_slots": self.handle.set_max_uploads,
+            "prioritize_first_last_pieces": self.set_prioritize_first_last,
+            "auto_managed": self.set_auto_managed,
+            "file_priorities": self.set_file_priorities,
+            "download_location": self.set_save_path,
+        }
+        for (key, value) in options.items():
+            if OPTIONS_FUNCS.has_key(key):
+                OPTIONS_FUNCS[key](value)
+        
+        self.options.update(options)
+    
+    def get_options(self):
+        return self.options
+        
     def set_max_connections(self, max_connections):
-        self.max_connections = int(max_connections)
-        self.handle.set_max_connections(self.max_connections)
+        self.options["max_connections"] = int(max_connections)
+        self.handle.set_max_connections(max_connections)
 
     def set_max_upload_slots(self, max_slots):
-        self.max_upload_slots = int(max_slots)
-        self.handle.set_max_uploads(self.max_upload_slots)
+        self.options["max_upload_slots"] = int(max_slots)
+        self.handle.set_max_uploads(max_slots)
 
     def set_max_upload_speed(self, m_up_speed):
-        self.max_upload_speed = m_up_speed
+        self.options["max_upload_speed"] = m_up_speed
         if m_up_speed < 0:
             v = -1
@@ -163 +179 @@
 
     def set_max_download_speed(self, m_down_speed):
-        self.max_download_speed = m_down_speed
+        self.options["max_download_speed"] = m_down_speed
         if m_down_speed < 0:
             v = -1
@@ -171 +187 @@
 
     def set_prioritize_first_last(self, prioritize):
-        self.prioritize_first_last = prioritize
-        if self.prioritize_first_last:
+        self.options["prioritize_first_last_pieces"] = prioritize
+        if prioritize:
             if self.handle.get_torrent_info().num_files() == 1:
                 # We only do this if one file is in the torrent
@@ -180 +196 @@
                 self.handle.prioritize_pieces(priorities)
 
-    def set_save_path(self, save_path):
-        self.save_path = save_path
-
     def set_auto_managed(self, auto_managed):
-        self.auto_managed = auto_managed
+        self.options["auto_managed"] = auto_managed
         self.handle.auto_managed(auto_managed)
         self.update_state()
 
     def set_stop_ratio(self, stop_ratio):
-        self.stop_ratio = stop_ratio
+        self.options["stop_ratio"] = stop_ratio
 
     def set_stop_at_ratio(self, stop_at_ratio):
-        self.stop_at_ratio = stop_at_ratio
+        self.options["stop_at_ratio"] = stop_at_ratio
 
     def set_remove_at_ratio(self, remove_at_ratio):
-        self.remove_at_ratio = remove_at_ratio
+        self.options["remove_at_ratio"] = remove_at_ratio
 
     def set_file_priorities(self, file_priorities):
@@ -205 +218 @@
         self.handle.prioritize_files(file_priorities)
 
-        if 0 in self.file_priorities:
+        if 0 in self.options["file_priorities"]:
             # We have previously marked a file 'Do Not Download'
             # Check to see if we have changed any 0's to >0 and change state accordingly
-            for index, priority in enumerate(self.file_priorities):
+            for index, priority in enumerate(self.options["file_priorities"]):
                 if priority == 0 and file_priorities[index] > 0:
                     # We have a changed 'Do Not Download' to a download priority
@@ -215 +228 @@
                     break
 
-        self.file_priorities = file_priorities
+        self.options["file_priorities"] = file_priorities
 
         # Set the first/last priorities if needed
-        self.set_prioritize_first_last(self.prioritize_first_last)
-
+        self.set_prioritize_first_last(self.options["prioritize_first_last_pieces"])
+        
     def set_trackers(self, trackers):
         """Sets trackers"""
@@ -244 +257 @@
             self.force_reannounce()
 
-    def set_move_on_completed(self, value):
-        self.move_on_completed = value
-
-    def set_move_on_completed_path(self, value):
-        self.move_on_completed_path = value
+    ### End Options methods ###
+
+    def set_save_path(self, save_path):
+        self.options["download_location"] = save_path
+            
+    def set_tracker_status(self, status):
+        """Sets the tracker status"""
+        self.tracker_status = status
 
     def update_state(self):
@@ -256 +272 @@
         ltstate = int(self.handle.status().state)
 
-        log.debug("set_state_based_on_ltstate: %s", ltstate)
+        log.debug("set_state_based_on_ltstate: %s", deluge.common.LT_TORRENT_STATE[ltstate])
         log.debug("session.is_paused: %s", component.get("Core").session.is_paused())
         if ltstate == LTSTATE["Queued"] or ltstate == LTSTATE["Checking"]:
@@ -453 +469 @@
             "trackers": self.trackers,
             "tracker_status": self.tracker_status,
-            "save_path": self.save_path,
+            "save_path": self.options["download_location"],
             "files": self.files,
-            "file_priorities": self.file_priorities,
-            "compact": self.compact,
-            "max_connections": self.max_connections,
-            "max_upload_slots": self.max_upload_slots,
-            "max_upload_speed": self.max_upload_speed,
-            "max_download_speed": self.max_download_speed,
-            "prioritize_first_last": self.prioritize_first_last,
+            "file_priorities": self.options["file_priorities"],
+            "compact": self.options["compact_allocation"],
+            "max_connections": self.options["max_connections"],
+            "max_upload_slots": self.options["max_upload_slots"],
+            "max_upload_speed": self.options["max_upload_speed"],
+            "max_download_speed": self.options["max_download_speed"],
+            "prioritize_first_last": self.options["prioritize_first_last_pieces"],
             "message": self.statusmsg,
             "hash": self.torrent_id,
@@ -467 +483 @@
             "seeding_time": self.status.seeding_time,
             "seed_rank": self.status.seed_rank,
-            "is_auto_managed": self.auto_managed,
-            "stop_ratio": self.stop_ratio,
-            "stop_at_ratio": self.stop_at_ratio,
-            "remove_at_ratio": self.remove_at_ratio,
-            "move_on_completed": self.move_on_completed,
-            "move_on_completed_path": self.move_on_completed_path
+            "is_auto_managed": self.options["auto_managed"],
+            "stop_ratio": self.options["stop_ratio"],
+            "stop_at_ratio": self.options["stop_at_ratio"],
+            "remove_at_ratio": self.options["remove_at_ratio"],
+            "move_on_completed": self.options["move_completed"],
+            "move_on_completed_path": self.options["move_completed_path"]
         }
 

trunk/deluge/core/torrentmanager.py

@@ -47 +47 @@
 from deluge.configmanager import ConfigManager
 from deluge.core.torrent import Torrent
+from deluge.core.torrent import OPTIONS
 import deluge.core.oldstateupgrader
 
@@ -189 +190 @@
     def update(self):
         for torrent_id, torrent in self.torrents.items():
-            if self.config["stop_seed_at_ratio"] or torrent.stop_at_ratio:
+            if self.config["stop_seed_at_ratio"] or torrent.options["stop_at_ratio"]:
                 stop_ratio = self.config["stop_seed_ratio"]
-                if torrent.stop_at_ratio:
-                    stop_ratio = torrent.stop_ratio
+                if torrent.options["stop_at_ratio"]:
+                    stop_ratio = torrent.options["stop_ratio"]
                 if torrent.get_ratio() >= stop_ratio and torrent.is_finished:
-                    if self.config["remove_seed_at_ratio"] or torrent.remove_at_ratio:
+                    if self.config["remove_seed_at_ratio"] or torrent.options["remove_at_ratio"]:
                         self.remove(torrent_id)
                         break
@@ -254 +255 @@
             except Exception, e:
                 log.error("Unable to decode torrent file!: %s", e)
-            
+
         if torrent_info is None:
             # We have no torrent_info so we need to add the torrent with information
@@ -260 +261 @@
 
             # Populate the options dict from state
-            options = {}
-            options["max_connections_per_torrent"] = state.max_connections
-            options["max_upload_slots_per_torrent"] = state.max_upload_slots
-            options["max_upload_speed_per_torrent"] = state.max_upload_speed
-            options["max_download_speed_per_torrent"] = state.max_download_speed
+            options = OPTIONS
+            options["max_connections"] = state.max_connections
+            options["max_upload_slots"] = state.max_upload_slots
+            options["max_upload_speed"] = state.max_upload_speed
+            options["max_download_speed"] = state.max_download_speed
             options["prioritize_first_last_pieces"] = state.prioritize_first_last
             options["file_priorities"] = state.file_priorities
@@ -283 +284 @@
             # We have a torrent_info object so we're not loading from state.
             # Check if options is None and load defaults
-            options_keys = [
-                "compact_allocation",
-                "max_connections_per_torrent",
-                "max_upload_slots_per_torrent",
-                "max_upload_speed_per_torrent",
-                "max_download_speed_per_torrent",
-                "prioritize_first_last_pieces",
-                "download_location",
-                "add_paused",
-                "auto_managed"
-            ]
-
             if options == None:
-                options = {}
-                for key in options_keys:
-                    options[key] = self.config[key]
+                options = OPTIONS
             else:
-                for key in options_keys:
-                    if not options.has_key(key):
-                        options[key] = self.config[key]            
+                o = OPTIONS
+                o.update(options)
+                options = o
 
             add_torrent_params["ti"] = torrent_info
@@ -506 +493 @@
                 torrent.get_status(["total_uploaded"])["total_uploaded"], 
                 torrent.trackers,
-                torrent.compact, 
+                torrent.options["compact_allocation"], 
                 paused, 
-                torrent.save_path,
-                torrent.max_connections,
-                torrent.max_upload_slots,
-                torrent.max_upload_speed,
-                torrent.max_download_speed,
-                torrent.prioritize_first_last,
-                torrent.file_priorities,
+                torrent.options["download_location"],
+                torrent.options["max_connections"],
+                torrent.options["max_upload_slots"],
+                torrent.options["max_upload_speed"],
+                torrent.options["max_download_speed"],
+                torrent.options["prioritize_first_last_pieces"],
+                torrent.options["file_priorities"],
                 torrent.get_queue_position(),
-                torrent.auto_managed,
+                torrent.options["auto_managed"],
                 torrent.is_finished,
-                torrent.stop_ratio,
-                torrent.stop_at_ratio,
-                torrent.remove_at_ratio
+                torrent.options["stop_ratio"],
+                torrent.options["stop_at_ratio"],
+                torrent.options["remove_at_ratio"]
             )
             state.torrents.append(torrent_state)
@@ -607 +594 @@
         if not torrent.is_finished:
             move_path = None
-            if torrent.move_on_completed:
-                move_path = torrent.move_on_completed_path
+            if torrent.options["move_completed"]:
+                move_path = torrent.options["move_completed_path"]
             elif self.config["move_completed"]:
                 move_path = self.config["move_completed_path"]