Merge lp:~nataliabidart/ubuntuone-client/tool-no-params into lp:ubuntuone-client

[Natalia Bidart]

- No mandatory creation param for SyncDaemonTool (LP: #797405).

[Alejandro J. Cura (alecu)]

Branch looks good.

A few details in the fixed docstrings:
line 419: it should be "prints"
line 446: "downloads" is spelled wrong.

review: Approve

[dobey (dobey)]

For the things alecu mentioned.

review: Needs Fixing

[lp:~nataliabidart/ubuntuone-client/tool-no-params]

1000. By Natalia Bidart on 2011-06-15

Typos.

[dobey (dobey)]

review: Approve

=== modified file 'ubuntuone/platform/linux/tools.py'
--- ubuntuone/platform/linux/tools.py	2011-06-09 10:08:57 +0000
+++ ubuntuone/platform/linux/tools.py	2011-06-15 17:24:40 +0000
@@ -15,12 +15,15 @@
 #
 # You should have received a copy of the GNU General Public License along
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
-""" SyncDaemon Tools """
-import dbus
+
+"""SyncDaemon Tools."""
+
 import logging
 import time
 import sys
 
+import dbus
+
 from ubuntuone.platform.linux.dbus_interface import (
     DBUS_IFACE_NAME,
     DBUS_IFACE_STATUS_NAME,
@@ -39,8 +42,10 @@
 
 
 def is_running(bus=None):
-    """Check if there is a syncdaemon instance running or if
-    the name is registered in the bus.
+    """Check if there is a syncdaemon instance running.
+
+    Running means the name is registered in the given bus.
+
     """
     if bus is None:
         bus = dbus.SessionBus()
@@ -52,17 +57,17 @@
 
 
 class DBusClient(object):
-    """ Low level dbus client. To help testing the DBus interface. """
+    """Low level dbus client. To help testing the DBus interface."""
 
     def __init__(self, bus, path, interface, destination=DBUS_IFACE_NAME):
-        """ create the instance """
+        """Create the instance."""
         self.bus = bus
         self.path = path
         self.interface = interface
         self.destination = destination
 
     def send_signal(self, signal, *args):
-        """ Send method with *args """
+        """Send method with *args."""
         msg = SignalMessage(self.path, self.interface,
                             signal)
         msg.set_no_reply(True)
@@ -70,7 +75,7 @@
         self.bus.send_message(msg)
 
     def call_method(self, method, *args, **kwargs):
-        """ Call method with *args and **kwargs over dbus"""
+        """Call method with *args and **kwargs over dbus."""
         msg = MethodCallMessage(self.destination, self.path, self.interface,
                                 method)
         msg.set_no_reply(True)
@@ -86,7 +91,7 @@
         assert error_handler != None
 
         def parse_reply(message):
-            """ handle the reply message"""
+            """Handle the reply message."""
             if isinstance(message, ErrorMessage):
                 return error_handler(DBusException(
                                     name=message.get_error_name(),
@@ -105,27 +110,29 @@
 
 
 class SyncDaemonTool(object):
-    """ Various utility methods to test/play with the SyncDaemon. """
+    """Various utility methods to test/play with the SyncDaemon."""
 
-    def __init__(self, bus):
+    def __init__(self, bus=None):
+        if bus is None:
+            bus = dbus.SessionBus()
         self.bus = bus
         self.last_event = 0
         self.delayed_call = None
         self.log = logging.getLogger('ubuntuone.SyncDaemon.SDTool')
 
     def _get_dict(self, a_dict):
-        """ Converts a dict returned by dbus to a dict of strings. """
+        """Converts a dict returned by dbus to a dict of strings."""
         str_dict = {}
         for key in a_dict:
             str_dict[key] = unicode(a_dict[key])
         return str_dict
 
     def wait_connected(self):
-        """ Wait until syncdaemon is connected to the server. """
+        """Wait until syncdaemon is connected to the server."""
         self.log.debug('wait_connected')
         d = defer.Deferred()
         def check_connection_status():
-            """ Check if the daemon is up and running. """
+            """Check if the daemon is up and running."""
             # check if the syncdaemon is running
             # catch all errors, pylint: disable-msg=W0703
             try:
@@ -141,12 +148,10 @@
         return d
 
     def get_current_downloads(self):
-        """ Return a deferred that 'll be called with the list
-        of current downloads
-        """
+        """Return a deferred that will be fired with the current downloads."""
         d = defer.Deferred()
         def current_downloads():
-            """ Call Status.current_downloads """
+            """Call Status.current_downloads."""
             status_client = DBusClient(self.bus, '/status',
                                        DBUS_IFACE_STATUS_NAME)
             status_client.call_method('current_downloads',
@@ -154,7 +159,7 @@
                                       error_handler=d.errback)
 
         def reply_handler(downloads):
-            """ current downloads callback """
+            """Current downloads callback."""
             downloads_str = []
             for download in downloads:
                 downloads_str.append(self._get_dict(download))
@@ -164,12 +169,14 @@
         return d
 
     def wait_all_downloads(self, verbose=False):
-        """ Wait until there is no more pending downloads """
+        """Wait until there is no more pending downloads."""
         self.log.debug('wait_all_downloads')
         d = self.get_current_downloads()
         def reply_handler(downloads):
-            """ Check if the are downloads in progress, and reschelude a
-            new check if there is at least one.
+            """Check if the are downloads in progress.
+
+            If so, reschelude a new check if there is at least one.
+
             """
             if verbose:
                 sys.stdout.write(', %s' % str(len(downloads)))
@@ -188,12 +195,10 @@
         return d
 
     def get_current_uploads(self):
-        """ Return a deferred that 'll be called with the list
-        of current uploads
-        """
+        """Return a deferred that will be called with the current uploads."""
         d = defer.Deferred()
         def current_uploads():
-            """ Call Status.current_uploads """
+            """Call Status.current_uploads."""
             status_client = DBusClient(self.bus, '/status',
                                        DBUS_IFACE_STATUS_NAME)
             status_client.call_method('current_uploads',
@@ -201,7 +206,7 @@
                                       error_handler=d.errback)
 
         def reply_handler(uploads):
-            """ reply handler """
+            """Reply handler."""
             uploads_str = []
             for upload in uploads:
                 uploads_str.append(self._get_dict(upload))
@@ -211,13 +216,15 @@
         return d
 
     def wait_all_uploads(self, verbose=False):
-        """ Wait until there is no more pending uploads """
+        """Wait until there is no more pending uploads."""
         self.log.debug('wait_all_uploads')
         d = self.get_current_uploads()
 
         def reply_handler(uploads):
-            """ Check if the are downloads in progress, and reschelude a
-            new check if there is at least one.
+            """Check if the are downloads in progress.
+
+            If so, reschelude a new check if there is at least one.
+
             """
             if verbose:
                 sys.stdout.write(', %s' % str(len(uploads)))
@@ -290,7 +297,9 @@
         return d
 
     def wait_for_nirvana(self, last_event_interval=5, verbose=False):
-        """ Wait until the syncdaemon reachs nirvana. This is when there are:
+        """Wait until the syncdaemon reachs nirvana.
+
+        This is when there are:
             - the syncdaemon is connected
             - 0 transfers inprogress
             - no more events are fired in the event queue
@@ -306,7 +315,7 @@
         return d
 
     def accept_share(self, share_id):
-        """ Accept the share with id: share_id. """
+        """Accept the share with id: share_id."""
         self.log.debug('accept_share(%s)', share_id)
         shares_client = DBusClient(self.bus, '/shares', DBUS_IFACE_SHARES_NAME)
         d = self.wait_for_signal('ShareAnswerResponse',
@@ -317,7 +326,7 @@
         return d
 
     def reject_share(self, share_id):
-        """ Reject the share with id: share_id. """
+        """Reject the share with id: share_id."""
         self.log.debug('reject_share(%s)', share_id)
         shares_client = DBusClient(self.bus, '/shares', DBUS_IFACE_SHARES_NAME)
         d = self.wait_for_signal('ShareAnswerResponse',
@@ -360,12 +369,12 @@
         yield d
 
     def get_shares(self):
-        """ Get the list of shares (accepted or not) """
+        """Get the list of shares (accepted or not)."""
         self.log.debug('get_shares')
         shares_client = DBusClient(self.bus, '/shares', DBUS_IFACE_SHARES_NAME)
         d = defer.Deferred()
         def reply_handler(results):
-            """ get_shares reply handler. """
+            """Get_shares reply handler."""
             shares = []
             for result in results:
                 shares.append(self._get_dict(result))
@@ -378,8 +387,10 @@
         return d
 
     def refresh_shares(self):
-        """ Call refresh_shares method via DBus.
+        """Call refresh_shares method via DBus.
+
         Request a refresh of share list to the server.
+
         """
         self.log.debug('refresh_shares')
         shares_client = DBusClient(self.bus, '/shares', DBUS_IFACE_SHARES_NAME)
@@ -390,7 +401,7 @@
         return d
 
     def offer_share(self, path, username, name, access_level):
-        """ Offer a share at the specified path to user with id: username. """
+        """Offer a share at the specified path to user with id: username."""
         self.log.debug('offer_share(%s, %s, %s, %s)',
                    path, username, name, access_level)
         shares_client = DBusClient(self.bus, '/shares', DBUS_IFACE_SHARES_NAME)
@@ -402,12 +413,12 @@
         return d
 
     def list_shared(self):
-        """ get the list of the shares "shared"/created/offered. """
+        """Get the list of the shares "shared"/created/offered."""
         self.log.debug('list_shared')
         shares_client = DBusClient(self.bus, '/shares', DBUS_IFACE_SHARES_NAME)
         d = defer.Deferred()
         def reply_handler(results):
-            """ get_shares reply handler. """
+            """Get_shares reply handler."""
             shares = []
             for result in results:
                 shares.append(self._get_dict(result))
@@ -420,8 +431,7 @@
 
     def wait_for_signals(self, signal_ok, signal_error,
                          dbus_iface=DBUS_IFACE_FOLDERS_NAME):
-        """wait for one of the specified DBus signals
-        this returns a deferred
+        """Wait for one of the specified DBus signals, return a deferred.
 
         @param signal_ok: this will fire the deferred's callback
         @param signal_error: the will fire the deferred's errback
@@ -500,7 +510,7 @@
                                     DBUS_IFACE_FOLDERS_NAME)
         d = defer.Deferred()
         def reply_handler(results):
-            """ get_folders reply handler. """
+            """Get_folders reply handler."""
             folders = []
             for result in results:
                 folders.append(self._get_dict(result))
@@ -522,7 +532,7 @@
         return d
 
     def get_metadata(self, path):
-        """ calls the exposed mtehod FileSystem.get_metadata using DBus. """
+        """Call the exposed mtehod FileSystem.get_metadata using DBus."""
         self.log.debug('get_metadata(%s)', path)
         fs_client = DBusClient(self.bus, '/filesystem', DBUS_IFACE_FS_NAME)
         d = defer.Deferred()
@@ -555,7 +565,7 @@
         defer.returnValue(file_info)
 
     def quit(self):
-        """quit the syncdaemon"""
+        """Quit the syncdaemon."""
         self.log.debug('quit')
         # avoid triggering dbus activation while calling quit
         if not is_running(self.bus):
@@ -566,7 +576,7 @@
                            reply_handler=d.callback,
                            error_handler=d.errback)
         def check(r):
-            """wait 0.5 sec to return, to allow syncdaemon to shutdown"""
+            """Wait 0.5 sec to return, to allow syncdaemon to shutdown."""
             d1 = defer.Deferred()
             reactor.callLater(0.5, d1.callback, r)
             return d1
@@ -574,15 +584,16 @@
         return d
 
     def wait_for_signal(self, signal_name, filter):
-        """wait for the specified DBus signal (the first received).
-        'filter' is used to fire the deferred callback.
+        """Wait for the specified DBus signal (the first received).
 
         @param signal_name: the signal name
-        @param filter: a callable to filter signal, must return True
+        @param filter: a callable to filter signal, must return True, and is
+        used to fire the deferred callback.
+
         """
         d = defer.Deferred()
         def signal_handler(result):
-            """handle the signals and fires the call/errback"""
+            """Handle the signals and fires the call/errback"""
             try:
                 if filter(result) and not d.called:
                     d.callback(result)
@@ -593,14 +604,14 @@
         match = self.bus.add_signal_receiver(signal_handler,
                                              signal_name=signal_name)
         def cleanup(result):
-            """remove the signal receiver from the bus."""
+            """Remove the signal receiver from the bus."""
             self.bus.remove_signal_receiver(match)
             return result
         d.addCallback(cleanup)
         return d
 
     def connect(self):
-        """Connect syncdaemon"""
+        """Connect syncdaemon."""
         sd_client = DBusClient(self.bus, '/', DBUS_IFACE_SYNC_NAME)
         d = defer.Deferred()
         sd_client.call_method('connect',
@@ -609,7 +620,7 @@
         return d
 
     def disconnect(self):
-        """Disconnect syncdaemon"""
+        """Disconnect syncdaemon."""
         sd_client = DBusClient(self.bus, '/', DBUS_IFACE_SYNC_NAME)
         d = defer.Deferred()
         sd_client.call_method('disconnect',
@@ -618,7 +629,7 @@
         return d
 
     def get_status(self):
-        """Get the current_status dict"""
+        """Get the current_status dict."""
         d = defer.Deferred()
         status_client = DBusClient(self.bus, '/status',
                                    DBUS_IFACE_STATUS_NAME)
@@ -655,7 +666,7 @@
         return d
 
     def waiting_content(self):
-        """Returns the waiting content queue elements."""
+        """Return the waiting content queue elements."""
         d = defer.Deferred()
         status_client = DBusClient(self.bus, '/status',
                                    DBUS_IFACE_STATUS_NAME)
@@ -665,9 +676,7 @@
         return d
 
     def start(self):
-        """Start syncdaemon using the StartServiceByName method
-        if it's not running.
-        """
+        """Start syncdaemon if it's not running."""
         if not is_running(self.bus):
             wait_d = self.wait_for_signal('StatusChanged', lambda x: x)
             d = defer.Deferred()
@@ -856,7 +865,7 @@
 # callbacks used by u1sdtool script
 
 def show_shared(shares, out):
-    """ Callback that prints the list of shared shares"""
+    """Callback that prints the list of shared shares."""
     if len(shares) == 0:
         out.write("No shared\n")
     else:
@@ -871,7 +880,7 @@
 
 
 def show_folders(folders, out):
-    """ Callback that prints the list of user defined folders"""
+    """Callback that prints the list of user defined folders."""
     if len(folders) == 0:
         out.write("No folders\n")
     else:
@@ -895,7 +904,7 @@
 
 
 def show_shares(shares, out):
-    """ Callback that print the list of shares"""
+    """Callback that prints the list of shares."""
     if len(shares) == 0:
         out.write("No shares\n")
     else:
@@ -909,7 +918,7 @@
 
 
 def show_path_info(result, path, out):
-    """ print the path info to stdout"""
+    """Print the path info to stdout."""
     out_encoding = out.encoding
     if out_encoding is None:
         out_encoding = 'utf-8'
@@ -921,7 +930,7 @@
 
 
 def show_uploads(uploads, out):
-    """ print the uploads to stdout"""
+    """Print the uploads to stdout."""
     if uploads:
         out.write("Current uploads:\n")
     else:
@@ -934,7 +943,7 @@
 
 
 def show_downloads(downloads, out):
-    """ print the downloas to stdout"""
+    """Print the downloads to stdout."""
     if downloads:
         out.write("Current downloads:\n")
     else:
@@ -993,7 +1002,7 @@
 
 
 def show_waiting_content(waiting_ops, out):
-    """Print the waiting_content result"""
+    """Print the waiting_content result."""
     out.write("Warning: this option is deprecated! Use '--waiting' instead\n")
     value_tpl = "operation='%(operation)s' node_id='%(node)s' " + \
             "share_id='%(share)s' path='%(path)s'"