Merge lp:~nataliabidart/magicicada-client/fix-lint-tests into lp:magicicada-client

[Natalia Bidart]

- Fixed lint issues on ubuntuone/ folder.

[Natalia Bidart (nataliabidart)]

Ran 2773 tests in 189.908s

PASSED (skips=43, successes=2730)

review: Approve

=== modified file 'Makefile'
--- Makefile	2015-09-19 21:11:52 +0000
+++ Makefile	2015-09-19 23:19:46 +0000
@@ -27,8 +27,8 @@
 #
 # For further info, check  http://launchpad.net/magicicada-client
 
-ENV = $(CURDIR)/env
-PROTOCOL_DIR = .protocol
+ENV = $(CURDIR)/.env
+PROTOCOL_DIR = $(CURDIR)/.protocol
 PROTOCOL_LINK = ubuntuone/storageprotocol
 
 deps:
@@ -39,7 +39,7 @@
 	bzr branch lp:magicicada-protocol $(PROTOCOL_DIR)
 
 $(PROTOCOL_LINK): $(PROTOCOL_DIR)
-	ln -s ../$(PROTOCOL_DIR)/$(PROTOCOL_LINK) $(PROTOCOL_LINK)
+	ln -s $(PROTOCOL_DIR)/$(PROTOCOL_LINK) $(PROTOCOL_LINK)
 
 update-protocol:
 	cd $(PROTOCOL_DIR) && bzr pull && python setup.py build
@@ -49,11 +49,14 @@
 lint:
 	virtualenv $(ENV)
 	$(ENV)/bin/pip install flake8
-	$(ENV)/bin/flake8 --filename='*.py' ubuntuone tests
+	$(ENV)/bin/flake8 --filename='*.py' --exclude='u1fsfsm.py' ubuntuone
 
-test:
+test: lint
 	./run-tests
 
 clean:
-	rm -rf _trial_temp $(PROTOCOL_DIR) $(PROTOCOL_LINK)
+	rm -rf build _trial_temp $(PROTOCOL_DIR) $(PROTOCOL_LINK) $(ENV)
 	find -name '*.pyc' -delete
+
+.PHONY:
+	deps update-protocol bootstrap lint test clean

=== modified file 'dependencies.txt'
--- dependencies.txt	2015-09-19 20:49:35 +0000
+++ dependencies.txt	2015-09-19 23:19:46 +0000
@@ -4,4 +4,5 @@
 python-gi
 python-protobuf
 python-pyinotify
+python-qt4reactor
 python-twisted

=== modified file 'run-tests'
--- run-tests	2015-09-19 20:49:35 +0000
+++ run-tests	2015-09-19 23:19:46 +0000
@@ -43,12 +43,6 @@
     MODULE="tests"
 fi
 
-style_check() {
-    u1lint -i "$LINT_IGNORES"
-    # Don't run pep8 yet, as there are a LOT of warnings to fix
-    # pep8 --exclude '.bzr,.pc,build' . bin/*
-}
-
 SYSNAME=`uname -s`
 
 if [ "$SYSNAME" == "Darwin" ]; then
@@ -73,5 +67,3 @@
 rm -rf build
 
 $PYTHON contrib/check-reactor-import
-
-style_check

=== modified file 'tests/platform/credentials/__init__.py'
--- tests/platform/credentials/__init__.py	2012-05-14 19:04:43 +0000
+++ tests/platform/credentials/__init__.py	2015-09-19 23:19:46 +0000
@@ -24,4 +24,5 @@
 # do not wish to do so, delete this exception statement from your
 # version.  If you delete this exception statement from all source
 # files in the program, then also delete it here.
+
 """Credentials test code."""

=== modified file 'ubuntuone/logger.py'
--- ubuntuone/logger.py	2012-04-09 20:07:05 +0000
+++ ubuntuone/logger.py	2015-09-19 23:19:46 +0000
@@ -225,8 +225,8 @@
             return sum(slave.handle(record) for slave in self.slaves)
         if record.levelno == logging.DEBUG:
             return logging.Handler.handle(self, record)
-        elif self.on_error and record.levelno >= logging.ERROR and \
-            record.levelno != NOTE:
+        elif (self.on_error and record.levelno >= logging.ERROR and
+                record.levelno != NOTE):
             # if it's >= ERROR keep it, but mark the dirty falg
             self.dirty = True
             return logging.Handler.handle(self, record)
@@ -243,8 +243,8 @@
         if exc_type is not None:
             self.emit_debug()
             self.on_error = False
-            self.logger.error('unhandled exception', exc_info=(exc_type,
-                exc_value, traceback))
+            self.logger.error('unhandled exception',
+                              exc_info=(exc_type, exc_value, traceback))
         elif self.dirty:
             # emit all debug messages collected after the error
             self.emit_debug()
@@ -292,13 +292,13 @@
     return middle
 
 
-### configure the thing ###
+# configure the thing #
 LOGBACKUP = 5  # the number of log files to keep around
 
-basic_formatter = logging.Formatter(fmt="%(asctime)s - %(name)s - " \
-                                    "%(levelname)s - %(message)s")
-debug_formatter = logging.Formatter(fmt="%(asctime)s %(name)s %(module)s " \
-                                    "%(lineno)s %(funcName)s %(message)s")
+basic_formatter = logging.Formatter(
+    fmt="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+debug_formatter = logging.Formatter(
+    fmt="%(asctime)s %(name)s %(module)s %(lineno)s %(funcName)s %(message)s")
 
 # a constant to change the default DEBUG level value
 _DEBUG_LOG_LEVEL = logging.DEBUG

=== modified file 'ubuntuone/platform/__init__.py'
--- ubuntuone/platform/__init__.py	2013-05-29 13:45:19 +0000
+++ ubuntuone/platform/__init__.py	2015-09-19 23:19:46 +0000
@@ -55,8 +55,8 @@
     except UnicodeDecodeError:
         raise AssertionError('The path %r must be encoded in utf-8' % path)
     tilde = '~'
-    if not path.startswith(tilde) or \
-    (len(path) > 1 and path[1:2] != os.path.sep):
+    if (not path.startswith(tilde) or
+            (len(path) > 1 and path[1:2] != os.path.sep)):
         return path
     result = path.replace('~', user_home, 1)
 

=== modified file 'ubuntuone/platform/credentials/__init__.py'
--- ubuntuone/platform/credentials/__init__.py	2015-09-17 02:20:40 +0000
+++ ubuntuone/platform/credentials/__init__.py	2015-09-19 23:19:46 +0000
@@ -26,6 +26,7 @@
 # do not wish to do so, delete this exception statement from your
 # version.  If you delete this exception statement from all source
 # files in the program, then also delete it here.
+
 """Common code for the credentials management."""
 
 import gettext
@@ -179,12 +180,13 @@
         sig = proxy.connect_to_signal('CredentialsFound', d.callback)
         self._cleanup_signals.append(sig)
 
-        sig = proxy.connect_to_signal('CredentialsNotFound',
-                    partial(self.callback, result={}, deferred=d))
+        sig = proxy.connect_to_signal(
+            'CredentialsNotFound',
+            partial(self.callback, result={}, deferred=d))
         self._cleanup_signals.append(sig)
 
-        sig = proxy.connect_to_signal('CredentialsError',
-                    partial(self.errback, deferred=d))
+        sig = proxy.connect_to_signal(
+            'CredentialsError', partial(self.errback, deferred=d))
         self._cleanup_signals.append(sig)
 
         done = defer.Deferred()
@@ -212,12 +214,13 @@
 
         proxy = yield self.get_creds_proxy()
 
-        sig = proxy.connect_to_signal('CredentialsCleared',
-                    partial(self.callback, result=None, deferred=d))
+        sig = proxy.connect_to_signal(
+            'CredentialsCleared',
+            partial(self.callback, result=None, deferred=d))
         self._cleanup_signals.append(sig)
 
-        sig = proxy.connect_to_signal('CredentialsError',
-                    partial(self.errback, deferred=d))
+        sig = proxy.connect_to_signal(
+            'CredentialsError', partial(self.errback, deferred=d))
         self._cleanup_signals.append(sig)
 
         done = defer.Deferred()
@@ -248,16 +251,18 @@
 
         proxy = yield self.get_creds_proxy()
 
-        sig = proxy.connect_to_signal('CredentialsStored',
-                    partial(self.callback, result=None, deferred=d))
+        sig = proxy.connect_to_signal(
+            'CredentialsStored',
+            partial(self.callback, result=None, deferred=d))
         self._cleanup_signals.append(sig)
 
-        sig = proxy.connect_to_signal('CredentialsError',
-                    partial(self.errback, deferred=d))
+        sig = proxy.connect_to_signal(
+            'CredentialsError', partial(self.errback, deferred=d))
         self._cleanup_signals.append(sig)
 
         done = defer.Deferred()
-        proxy.store_credentials(token,
+        proxy.store_credentials(
+            token,
             reply_handler=partial(self.callback, result=None, deferred=done),
             error_handler=partial(self.errback, deferred=done))
 
@@ -295,16 +300,18 @@
         sig = proxy.connect_to_signal('CredentialsFound', d.callback)
         self._cleanup_signals.append(sig)
 
-        sig = proxy.connect_to_signal('AuthorizationDenied',
-                    partial(self.callback, result=None, deferred=d))
+        sig = proxy.connect_to_signal(
+            'AuthorizationDenied',
+            partial(self.callback, result=None, deferred=d))
         self._cleanup_signals.append(sig)
 
-        sig = proxy.connect_to_signal('CredentialsError',
-                    partial(self.errback, deferred=d))
+        sig = proxy.connect_to_signal(
+            'CredentialsError', partial(self.errback, deferred=d))
         self._cleanup_signals.append(sig)
 
         done = defer.Deferred()
-        proxy.register({'window_id': str(window_id)},
+        proxy.register(
+            {'window_id': str(window_id)},
             reply_handler=partial(self.callback, result=None, deferred=done),
             error_handler=partial(self.errback, deferred=done))
 
@@ -344,16 +351,18 @@
         sig = proxy.connect_to_signal('CredentialsFound', d.callback)
         self._cleanup_signals.append(sig)
 
-        sig = proxy.connect_to_signal('AuthorizationDenied',
-                    partial(self.callback, result=None, deferred=d))
+        sig = proxy.connect_to_signal(
+            'AuthorizationDenied',
+            partial(self.callback, result=None, deferred=d))
         self._cleanup_signals.append(sig)
 
-        sig = proxy.connect_to_signal('CredentialsError',
-                    partial(self.errback, deferred=d))
+        sig = proxy.connect_to_signal(
+            'CredentialsError', partial(self.errback, deferred=d))
         self._cleanup_signals.append(sig)
 
         done = defer.Deferred()
-        proxy.login({'window_id': str(window_id)},
+        proxy.login(
+            {'window_id': str(window_id)},
             reply_handler=partial(self.callback, result=None, deferred=done),
             error_handler=partial(self.errback, deferred=done))
 
@@ -384,12 +393,13 @@
         sig = proxy.connect_to_signal('CredentialsFound', d.callback)
         self._cleanup_signals.append(sig)
 
-        sig = proxy.connect_to_signal('CredentialsError',
-                    partial(self.errback, deferred=d))
+        sig = proxy.connect_to_signal(
+            'CredentialsError', partial(self.errback, deferred=d))
         self._cleanup_signals.append(sig)
 
         done = defer.Deferred()
-        proxy.login_email_password({'email': email, 'password': password},
+        proxy.login_email_password(
+            {'email': email, 'password': password},
             reply_handler=partial(self.callback, result=None, deferred=done),
             error_handler=partial(self.errback, deferred=done))
 

=== modified file 'ubuntuone/platform/credentials/dbus_service.py'
--- ubuntuone/platform/credentials/dbus_service.py	2015-09-17 02:20:40 +0000
+++ ubuntuone/platform/credentials/dbus_service.py	2015-09-19 23:19:46 +0000
@@ -71,7 +71,7 @@
                      member, app_name)
 
         if app_name != APP_NAME:
-            logger.info('Received %r but app_name %r does not match %r, ' \
+            logger.info('Received %r but app_name %r does not match %r, '
                         'exiting.', member, app_name, APP_NAME)
             return
 
@@ -89,9 +89,9 @@
         """Get the SSO dbus proxy."""
         bus = dbus.SessionBus()
         # register signal handlers for each kind of error
-        self.sso_match = bus.add_signal_receiver(self._signal_handler,
-                            member_keyword='member',
-                            dbus_interface=ubuntu_sso.DBUS_CREDENTIALS_IFACE)
+        self.sso_match = bus.add_signal_receiver(
+            self._signal_handler, member_keyword='member',
+            dbus_interface=ubuntu_sso.DBUS_CREDENTIALS_IFACE)
         try:
             obj = bus.get_object(ubuntu_sso.DBUS_BUS_NAME,
                                  ubuntu_sso.DBUS_CREDENTIALS_PATH,
@@ -133,7 +133,6 @@
             self.shutdown_func()
 
     # Operator not preceded by a space (fails with dbus decorators)
-    # pylint: disable=C0322
 
     @dbus.service.signal(DBUS_CREDENTIALS_IFACE)
     def AuthorizationDenied(self):
@@ -182,8 +181,8 @@
     def find_credentials(self, reply_handler=NO_OP, error_handler=NO_OP):
         """Ask the Magicicada credentials."""
         self.ref_count += 1
-        self.sso_proxy.find_credentials(APP_NAME,
-                                        dbus.Dictionary({}, signature='ss'),
+        self.sso_proxy.find_credentials(
+            APP_NAME, dbus.Dictionary({}, signature='ss'),
             reply_handler=reply_handler, error_handler=error_handler)
 
     @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
@@ -218,8 +217,8 @@
     def clear_credentials(self, reply_handler=NO_OP, error_handler=NO_OP):
         """Clear the Magicicada credentials."""
         self.ref_count += 1
-        self.sso_proxy.clear_credentials(APP_NAME,
-                                         dbus.Dictionary({}, signature='ss'),
+        self.sso_proxy.clear_credentials(
+            APP_NAME, dbus.Dictionary({}, signature='ss'),
             reply_handler=reply_handler, error_handler=error_handler)
 
     @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
@@ -229,7 +228,8 @@
                           reply_handler=NO_OP, error_handler=NO_OP):
         """Store the token for Magicicada application."""
         self.ref_count += 1
-        self.sso_proxy.store_credentials(APP_NAME, credentials,
+        self.sso_proxy.store_credentials(
+            APP_NAME, credentials,
             reply_handler=reply_handler, error_handler=error_handler)
 
     @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
@@ -240,7 +240,8 @@
         self.ref_count += 1
         params = dict(UI_PARAMS)
         params.update(args)
-        self.sso_proxy.register(APP_NAME, params,
+        self.sso_proxy.register(
+            APP_NAME, params,
             reply_handler=reply_handler, error_handler=error_handler)
 
     @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
@@ -251,7 +252,8 @@
         self.ref_count += 1
         params = dict(UI_PARAMS)
         params.update(args)
-        self.sso_proxy.login(APP_NAME, params,
+        self.sso_proxy.login(
+            APP_NAME, params,
             reply_handler=reply_handler, error_handler=error_handler)
 
     @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
@@ -263,7 +265,8 @@
         self.ref_count += 1
         params = dict(UI_PARAMS)
         params.update(args)
-        self.sso_proxy.login_email_password(APP_NAME, params,
+        self.sso_proxy.login_email_password(
+            APP_NAME, params,
             reply_handler=reply_handler, error_handler=error_handler)
 
 

=== modified file 'ubuntuone/platform/credentials/ipc_service.py'
--- ubuntuone/platform/credentials/ipc_service.py	2015-09-17 02:20:40 +0000
+++ ubuntuone/platform/credentials/ipc_service.py	2015-09-19 23:19:46 +0000
@@ -58,7 +58,7 @@
 
         if app_name != APP_NAME:
             # This fixed bug #818190: filter signals not related to APP_NAME
-            logger.info('Received %r but app_name %r does not match %r, ' \
+            logger.info('Received %r but app_name %r does not match %r, '
                         'exiting.', self.signal_name, app_name, APP_NAME)
             return
 

=== modified file 'ubuntuone/platform/filesystem_notifications/monitor/__init__.py'
--- ubuntuone/platform/filesystem_notifications/monitor/__init__.py	2012-09-19 17:39:26 +0000
+++ ubuntuone/platform/filesystem_notifications/monitor/__init__.py	2015-09-19 23:19:46 +0000
@@ -34,8 +34,8 @@
 from twisted.internet import defer
 
 DEFAULT_MONITOR = 'default'
-logger = logging.getLogger('ubuntuone.SyncDaemon.platform.' +
-            'filesystem_notifications.monitor')
+logger = logging.getLogger(
+    'ubuntuone.SyncDaemon.platform.filesystem_notifications.monitor')
 
 
 class NoAvailableMonitorError(Exception):

=== modified file 'ubuntuone/platform/filesystem_notifications/monitor/common.py'
--- ubuntuone/platform/filesystem_notifications/monitor/common.py	2013-01-16 00:08:52 +0000
+++ ubuntuone/platform/filesystem_notifications/monitor/common.py	2015-09-19 23:19:46 +0000
@@ -104,8 +104,9 @@
         # platform watch used to deal with the platform details
         self.platform_watch = PlatformWatch(self.path, self.process_events)
 
-        self.log = logging.getLogger('ubuntuone.SyncDaemon.platform.common.' +
-            'filesystem_notifications.Watch')
+        self.log = logging.getLogger(
+            'ubuntuone.SyncDaemon.platform.common.filesystem_notifications.'
+            'Watch')
         self.log.setLevel(TRACE)
 
     def process_events(self, action, file_name, cookie, syncdaemon_path):
@@ -249,8 +250,9 @@
 
     def __init__(self, processor):
         """Init the manager to keep trak of the different watches."""
-        self.log = logging.getLogger('ubuntuone.SyncDaemon.platform.common.'
-            + 'filesystem_notifications.WatchManager')
+        self.log = logging.getLogger(
+            'ubuntuone.SyncDaemon.platform.common.filesystem_notifications.'
+            'WatchManager')
         self.log.setLevel(TRACE)
         self._processor = processor
         # use the platform manager to perform the actual actions
@@ -388,8 +390,8 @@
         """Add watch to a dir."""
         # the logic to check if the watch is already set
         # is all in WatchManager.add_watch
-        return self._watch_manager.add_watch(dirpath,
-            self.filesystem_monitor_mask)
+        return self._watch_manager.add_watch(
+            dirpath, self.filesystem_monitor_mask)
 
     def add_watches_to_udf_ancestors(self, volume):
         """Add a inotify watch to volume's ancestors if it's an UDF."""

=== modified file 'ubuntuone/platform/filesystem_notifications/monitor/darwin/fsevents_client.py'
--- ubuntuone/platform/filesystem_notifications/monitor/darwin/fsevents_client.py	2013-01-14 21:42:39 +0000
+++ ubuntuone/platform/filesystem_notifications/monitor/darwin/fsevents_client.py	2015-09-19 23:19:46 +0000
@@ -78,8 +78,8 @@
         self.watching = False
         self.ignore_paths = []
         # Create stream with folder to watch
-        self.stream = fsevents.Stream(self._process_events,
-            path, file_events=True)
+        self.stream = fsevents.Stream(
+            self._process_events, path, file_events=True)
 
     def _process_events(self, event):
         """Receive the filesystem event and move it to the main thread."""
@@ -90,8 +90,8 @@
         action, cookie, file_name = (event.mask, event.cookie, event.name)
 
         syncdaemon_path = os.path.join(self.path, file_name)
-        self.process_events(action, file_name, cookie,
-                syncdaemon_path)
+        self.process_events(
+            action, file_name, cookie, syncdaemon_path)
 
     def start_watching(self):
         """Start watching."""

=== modified file 'ubuntuone/platform/filesystem_notifications/monitor/darwin/fsevents_daemon.py'
--- ubuntuone/platform/filesystem_notifications/monitor/darwin/fsevents_daemon.py	2012-09-18 23:46:47 +0000
+++ ubuntuone/platform/filesystem_notifications/monitor/darwin/fsevents_daemon.py	2015-09-19 23:19:46 +0000
@@ -137,8 +137,8 @@
 class PyInotifyEventsFactory(fseventsd.FsEventsFactory):
     """Factory that process events and converts them in pyinotify ones."""
 
-    def __init__(self, processor,
-            ignored_events=DARWIN_IGNORED_ACTIONS):
+    def __init__(
+            self, processor, ignored_events=DARWIN_IGNORED_ACTIONS):
         """Create a new instance."""
         # old style class
         fseventsd.FsEventsFactory.__init__(self)
@@ -157,9 +157,9 @@
     def path_is_not_interesting(self, path):
         """Return if the factory is interested in the path."""
         is_watched = any(path.startswith(watched_path)
-                             for watched_path in self.watched_paths)
+                         for watched_path in self.watched_paths)
         is_ignored = any(path.startswith(ignored_path)
-                             for ignored_path in self.ignored_paths)
+                         for ignored_path in self.ignored_paths)
         return not is_watched or (is_watched and is_ignored)
 
     def is_create(self, event):
@@ -233,8 +233,9 @@
                 # path of the event. A delete means that we moved from a
                 # watched path for a not watched one and we care about the
                 # FIRST path of the event
-                path = event.event_paths[1] if is_create\
-                            else event.event_paths[0]
+                path = (
+                    event.event_paths[1] if is_create else event.event_paths[0]
+                )
                 path = get_syncdaemon_valid_path(path)
                 head, tail = os.path.split(path)
                 event_raw_data = {
@@ -287,7 +288,8 @@
         if not path[-1] == os.path.sep:
             path += os.path.sep
 
-        is_ignored_child = any(ignored in path for ignored in self.ignored_paths)
+        is_ignored_child = any(
+            ignored in path for ignored in self.ignored_paths)
         return path in self.ignored_paths or is_ignored_child
 
     def process_event(self, event):
@@ -400,9 +402,11 @@
         if not dirpath[-1] == os.path.sep:
             dirpath = dirpath + os.path.sep
 
-        # if we are watching a parent dir we can just ensure that it is not ignored
-        if any(dirpath.startswith(watched_path) for watched_path in
-                self._factory.watched_paths):
+        # if we are watching a parent dir we can just ensure that it is not
+        # ignored
+        parent_watched = any(dirpath.startswith(watched_path)
+                             for watched_path in self._factory.watched_paths)
+        if parent_watched:
             if dirpath in self._factory.ignored_paths:
                 self._factory.ignored_paths.remove(dirpath)
             defer.returnValue(True)

=== modified file 'ubuntuone/platform/filesystem_notifications/monitor/linux.py'
--- ubuntuone/platform/filesystem_notifications/monitor/linux.py	2012-07-18 09:05:26 +0000
+++ ubuntuone/platform/filesystem_notifications/monitor/linux.py	2015-09-19 23:19:46 +0000
@@ -98,8 +98,9 @@
         if event.mask & pyinotify.IN_ISDIR:
             unsubscribed_udfs = set()
             for udf in self._get_udfs(event.pathname):
-                self.log.info("Got MOVED_FROM on path %r, unsubscribing "
-                               "udf %s", event.pathname, udf)
+                self.log.info(
+                    "Got MOVED_FROM on path %r, unsubscribing udf %s",
+                    event.pathname, udf)
                 self.monitor.fs.vm.unsubscribe_udf(udf.volume_id)
                 unsubscribed_udfs.add(udf)
             self._unwatch_ancestors(unsubscribed_udfs)
@@ -109,8 +110,9 @@
         if event.mask & pyinotify.IN_ISDIR:
             deleted_udfs = set()
             for udf in self._get_udfs(event.pathname):
-                self.log.info("Got DELETE on path %r, deleting udf %s",
-                               event.pathname, udf)
+                self.log.info(
+                    "Got DELETE on path %r, deleting udf %s",
+                    event.pathname, udf)
                 self.monitor.fs.vm.delete_volume(udf.volume_id)
                 deleted_udfs.add(udf)
             self._unwatch_ancestors(deleted_udfs)
@@ -124,8 +126,8 @@
 
         # collect the ancestors of all the still subscribed UDFs except
         # the received ones
-        sub_udfs = (u for u in self.monitor.fs.vm.udfs.itervalues() \
-                    if u.subscribed)
+        sub_udfs = (
+            u for u in self.monitor.fs.vm.udfs.itervalues() if u.subscribed)
         udf_remain = set(sub_udfs) - udfs
         ancestors_to_keep = set()
         for udf in udf_remain:
@@ -150,7 +152,7 @@
         self._processor = notify_processor.NotifyProcessor(self, ignore_config)
         self._inotify_notifier_gral = pyinotify.Notifier(wm, self._processor)
         self._inotify_reader_gral = self._hook_inotify_to_twisted(
-                                            wm, self._inotify_notifier_gral)
+            wm, self._inotify_notifier_gral)
         self._general_watchs = {}
 
         # ancestors inotify
@@ -158,7 +160,7 @@
         antr_processor = _AncestorsINotifyProcessor(self)
         self._inotify_notifier_antr = pyinotify.Notifier(wm, antr_processor)
         self._inotify_reader_antr = self._hook_inotify_to_twisted(
-                                            wm, self._inotify_notifier_antr)
+            wm, self._inotify_notifier_antr)
         self._ancestors_watchs = {}
 
     @classmethod
@@ -180,11 +182,10 @@
 
         class MyReader(abstract.FileDescriptor):
             """Chain between inotify and twisted."""
-            # will never pass a fd to write, pylint: disable-msg=W0223
+            # will never pass a fd to write
 
             def fileno(self):
                 """Returns the fileno to select()."""
-                # pylint: disable-msg=W0212
                 return wm._fd
 
             def doRead(self):

=== modified file 'ubuntuone/platform/filesystem_notifications/monitor/windows.py'
--- ubuntuone/platform/filesystem_notifications/monitor/windows.py	2013-01-14 21:42:39 +0000
+++ ubuntuone/platform/filesystem_notifications/monitor/windows.py	2015-09-19 23:19:46 +0000
@@ -120,8 +120,9 @@
         self.path = os.path.abspath(path)
         self.process_events = process_events
         self.watching = False
-        self.log = logging.getLogger('ubuntuone.SyncDaemon.platform.windows.' +
-            'filesystem_notifications.Watch')
+        self.log = logging.getLogger(
+            'ubuntuone.SyncDaemon.platform.windows.filesystem_notifications.'
+            'Watch')
         self.log.setLevel(logging.DEBUG)
         self._buf_size = buf_size
         self._mask = mask
@@ -143,9 +144,9 @@
         # and then use the proc_fun
         for action, file_name in events:
             syncdaemon_path = get_syncdaemon_valid_path(
-                                        os.path.join(self.path, file_name))
-            self.process_events(action, file_name, str(uuid4()),
-                    syncdaemon_path)
+                os.path.join(self.path, file_name))
+            self.process_events(
+                action, file_name, str(uuid4()), syncdaemon_path)
 
     def _call_deferred(self, f, *args):
         """Executes the deferred call avoiding possible race conditions."""
@@ -156,9 +157,10 @@
         """Wrap _watch, and errback on any unhandled error."""
         try:
             self._watch()
-        except Exception:
-            reactor.callFromThread(self._call_deferred,
-                self._watch_started_deferred.errback, Failure())
+        except Exception as e:
+            reactor.callFromThread(
+                self._call_deferred, self._watch_started_deferred.errback,
+                Failure(e))
 
     def _watch(self):
         """Watch a path that is a directory."""
@@ -201,13 +203,13 @@
                 self._overlapped,
             )
             if not self._watch_started_deferred.called:
-                reactor.callFromThread(self._call_deferred,
-                    self._watch_started_deferred.callback, True)
+                reactor.callFromThread(
+                    self._call_deferred, self._watch_started_deferred.callback,
+                    True)
             # wait for an event and ensure that we either stop or read the
             # data
-            rc = WaitForMultipleObjects((self._wait_stop,
-                                         self._overlapped.hEvent),
-                                         0, INFINITE)
+            rc = WaitForMultipleObjects(
+                (self._wait_stop, self._overlapped.hEvent), 0, INFINITE)
             if rc == WAIT_OBJECT_0:
                 # Stop event
                 break
@@ -215,9 +217,9 @@
             data = GetOverlappedResult(handle, self._overlapped, True)
             # lets ead the data and store it in the results
             events = FILE_NOTIFY_INFORMATION(buf, data)
-            self.log.debug('Got from ReadDirectoryChangesW %r.',
-                    [(ACTIONS_NAMES[action], path) \
-                    for action, path in events])
+            self.log.debug(
+                'Got from ReadDirectoryChangesW %r.',
+                [(ACTIONS_NAMES[action], path) for action, path in events])
             reactor.callFromThread(self._process_events, events)
 
     def start_watching(self):

=== modified file 'ubuntuone/platform/filesystem_notifications/notify_processor/common.py'
--- ubuntuone/platform/filesystem_notifications/notify_processor/common.py	2012-07-13 11:26:31 +0000
+++ ubuntuone/platform/filesystem_notifications/notify_processor/common.py	2015-09-19 23:19:46 +0000
@@ -99,8 +99,8 @@
     """
 
     def __init__(self, monitor, ignore_config=None):
-        self.general_processor = GeneralINotifyProcessor(monitor,
-            self.handle_dir_delete, NAME_TRANSLATIONS,
+        self.general_processor = GeneralINotifyProcessor(
+            monitor, self.handle_dir_delete, NAME_TRANSLATIONS,
             path_is_ignored, IN_IGNORED, ignore_config=ignore_config)
         self.held_event = None
 
@@ -130,10 +130,10 @@
         # on someplatforms we just get IN_MODIFY, lets always fake
         # an OPEN & CLOSE_WRITE couple
         raw_open = raw_close = {
-           'wd': event.wd,
-           'dir': event.dir,
-           'name': event.name,
-           'path': event.path}
+            'wd': event.wd,
+            'dir': event.dir,
+            'name': event.name,
+            'path': event.path}
         # caculate the open mask
         raw_open['mask'] = IN_OPEN
         # create the event using the raw data, then fix the pathname param
@@ -165,7 +165,7 @@
         self.general_processor.eq_push(evtname + "CREATE", path=event.pathname)
         if not event.dir:
             self.general_processor.eq_push('FS_FILE_CLOSE_WRITE',
-                                            path=event.pathname)
+                                           path=event.pathname)
 
     def _fake_delete_create_event(self, event):
         """Fake the deletion and the creation."""
@@ -182,7 +182,7 @@
         self.general_processor.eq_push(evtname + "CREATE", path=event.pathname)
         if not event.dir:
             self.general_processor.eq_push('FS_FILE_CLOSE_WRITE',
-                                            path=event.pathname)
+                                           path=event.pathname)
 
     def process_IN_MOVED_TO(self, event):
         """Capture the MOVED_TO to maybe syntethize FILE_MOVED."""
@@ -206,7 +206,8 @@
                             evtname = "FS_DIR_"
                         else:
                             evtname = "FS_FILE_"
-                        self.general_processor.eq_push(evtname + "MOVE",
+                        self.general_processor.eq_push(
+                            evtname + "MOVE",
                             path_from=self.held_event.pathname,
                             path_to=event.pathname)
                 elif is_to_forreal:
@@ -223,7 +224,7 @@
             # We should never get here, I really do not know how we
             # got here
             self.general_processor.log.warn(
-                            'Cookie does not match the previoues held event!')
+                'Cookie does not match the previoues held event!')
             self.general_processor.log.warn('Ignoring %s', event)
 
     def process_default(self, event):
@@ -240,8 +241,8 @@
         self.general_processor.rm_watch(fullpath)
 
         # handle the case of move a dir to a non-watched directory
-        paths = self.general_processor.get_paths_starting_with(fullpath,
-            include_base=False)
+        paths = self.general_processor.get_paths_starting_with(
+            fullpath, include_base=False)
 
         paths.sort(reverse=True)
         for path, is_dir in paths:

=== modified file 'ubuntuone/platform/filesystem_notifications/notify_processor/linux.py'
--- ubuntuone/platform/filesystem_notifications/notify_processor/linux.py	2012-07-13 11:26:31 +0000
+++ ubuntuone/platform/filesystem_notifications/notify_processor/linux.py	2015-09-19 23:19:46 +0000
@@ -79,10 +79,10 @@
             event.name.decode("utf8")
         except UnicodeDecodeError:
             dirname = event.path.decode("utf8")
-            self.general_processor.invnames_log.info("%s in %r: path %r",
-                event.maskname, dirname, event.name)
-            self.general_processor.monitor.eq.push('FS_INVALID_NAME',
-                                 dirname=dirname, filename=event.name)
+            self.general_processor.invnames_log.info(
+                "%s in %r: path %r", event.maskname, dirname, event.name)
+            self.general_processor.monitor.eq.push(
+                'FS_INVALID_NAME', dirname=dirname, filename=event.name)
         else:
             real_func(self, event)
     return func
@@ -95,8 +95,8 @@
     FS_(DIR|FILE)_MOVE event when possible.
     """
     def __init__(self, monitor, ignore_config=None):
-        self.general_processor = GeneralINotifyProcessor(monitor,
-            self.handle_dir_delete, NAME_TRANSLATIONS,
+        self.general_processor = GeneralINotifyProcessor(
+            monitor, self.handle_dir_delete, NAME_TRANSLATIONS,
             self.platform_is_ignored, pyinotify.IN_IGNORED,
             ignore_config=ignore_config)
         self.held_event = None
@@ -218,12 +218,13 @@
                                                            path=t_path)
                             if not event.dir:
                                 self.general_processor.eq_push(
-                                            'FS_FILE_CLOSE_WRITE', path=t_path)
+                                    'FS_FILE_CLOSE_WRITE', path=t_path)
                         else:
                             self.general_processor.monitor.inotify_watch_fix(
-                                                                f_path, t_path)
-                            self.general_processor.eq_push(evtname + "MOVE",
-                                         path_from=f_path, path_to=t_path)
+                                f_path, t_path)
+                            self.general_processor.eq_push(
+                                evtname + "MOVE", path_from=f_path,
+                                path_to=t_path)
                     elif is_to_forreal:
                         # this is the case of a MOVE from something ignored
                         # to a valid filename
@@ -235,7 +236,7 @@
                                                        path=t_path)
                         if not event.dir:
                             self.general_processor.eq_push(
-                                            'FS_FILE_CLOSE_WRITE', path=t_path)
+                                'FS_FILE_CLOSE_WRITE', path=t_path)
 
                     else:
                         # this is the case of a MOVE from something valid
@@ -259,8 +260,8 @@
             self.general_processor.push_event(event)
             if not event.dir:
                 t_path = os.path.join(event.path, event.name)
-                self.general_processor.eq_push('FS_FILE_CLOSE_WRITE',
-                    path=t_path)
+                self.general_processor.eq_push(
+                    'FS_FILE_CLOSE_WRITE', path=t_path)
 
     @validate_filename
     def process_default(self, event):
@@ -293,8 +294,8 @@
         self.general_processor.rm_watch(fullpath)
 
         # handle the case of move a dir to a non-watched directory
-        paths = self.general_processor.get_paths_starting_with(fullpath,
-            include_base=False)
+        paths = self.general_processor.get_paths_starting_with(
+            fullpath, include_base=False)
 
         paths.sort(reverse=True)
         for path, is_dir in paths:

=== modified file 'ubuntuone/platform/filesystem_notifications/pyinotify_agnostic.py'
--- ubuntuone/platform/filesystem_notifications/pyinotify_agnostic.py	2012-07-02 09:10:10 +0000
+++ ubuntuone/platform/filesystem_notifications/pyinotify_agnostic.py	2015-09-19 23:19:46 +0000
@@ -18,16 +18,20 @@
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
+
 """Platform agnostic code grabed from pyinotify."""
+
 import logging
 import os
 import sys
 
+
 COMPATIBILITY_MODE = False
+IN_ISDIR = '???'
+
 
 class PyinotifyError(Exception):
     """Indicates exceptions raised by a Pyinotify class."""
-    pass
 
 
 class RawOutputFormat:
@@ -121,36 +125,34 @@
     # The idea here is 'configuration-as-code' - this way, we get
     # our nice class constants, but we also get nice human-friendly text
     # mappings to do lookups against as well, for free:
-    FLAG_COLLECTIONS = {'OP_FLAGS': {
-        'IN_ACCESS'        : 0x00000001,  # File was accessed
-        'IN_MODIFY'        : 0x00000002,  # File was modified
-        'IN_ATTRIB'        : 0x00000004,  # Metadata changed
-        'IN_CLOSE_WRITE'   : 0x00000008,  # Writable file was closed
-        'IN_CLOSE_NOWRITE' : 0x00000010,  # Unwritable file closed
-        'IN_OPEN'          : 0x00000020,  # File was opened
-        'IN_MOVED_FROM'    : 0x00000040,  # File was moved from X
-        'IN_MOVED_TO'      : 0x00000080,  # File was moved to Y
-        'IN_CREATE'        : 0x00000100,  # Subfile was created
-        'IN_DELETE'        : 0x00000200,  # Subfile was deleted
-        'IN_DELETE_SELF'   : 0x00000400,  # Self (watched item itself)
-                                          # was deleted
-        'IN_MOVE_SELF'     : 0x00000800,  # Self(watched item itself) was moved
-        },
-                        'EVENT_FLAGS': {
-        'IN_UNMOUNT'       : 0x00002000,  # Backing fs was unmounted
-        'IN_Q_OVERFLOW'    : 0x00004000,  # Event queued overflowed
-        'IN_IGNORED'       : 0x00008000,  # File was ignored
-        },
-                        'SPECIAL_FLAGS': {
-        'IN_ONLYDIR'       : 0x01000000,  # only watch the path if it is a
-                                          # directory
-        'IN_DONT_FOLLOW'   : 0x02000000,  # don't follow a symlink
-        'IN_MASK_ADD'      : 0x20000000,  # add to the mask of an already
-                                          # existing watch
-        'IN_ISDIR'         : 0x40000000,  # event occurred against dir
-        'IN_ONESHOT'       : 0x80000000,  # only send event once
-        },
-                        }
+    FLAG_COLLECTIONS = {
+        'OP_FLAGS': {
+            'IN_ACCESS': 0x00000001,  # File was accessed
+            'IN_MODIFY': 0x00000002,  # File was modified
+            'IN_ATTRIB': 0x00000004,  # Metadata changed
+            'IN_CLOSE_WRITE': 0x00000008,  # Writable file was closed
+            'IN_CLOSE_NOWRITE': 0x00000010,  # Unwritable file closed
+            'IN_OPEN': 0x00000020,  # File was opened
+            'IN_MOVED_FROM': 0x00000040,  # File was moved from X
+            'IN_MOVED_TO': 0x00000080,  # File was moved to Y
+            'IN_CREATE': 0x00000100,  # Subfile was created
+            'IN_DELETE': 0x00000200,  # Subfile was deleted
+            'IN_DELETE_SELF': 0x00000400,  # Self was deleted
+            'IN_MOVE_SELF': 0x00000800,  # Self was moved
+        },
+        'EVENT_FLAGS': {
+            'IN_UNMOUNT': 0x00002000,  # Backing fs was unmounted
+            'IN_Q_OVERFLOW': 0x00004000,  # Event queued overflowed
+            'IN_IGNORED': 0x00008000,  # File was ignored
+        },
+        'SPECIAL_FLAGS': {
+            'IN_ONLYDIR': 0x01000000,  # only watch the path if it is a dir
+            'IN_DONT_FOLLOW': 0x02000000,  # don't follow a symlink
+            'IN_MASK_ADD': 0x20000000,  # add to the mask of an existing watch
+            'IN_ISDIR': 0x40000000,  # event occurred against dir
+            'IN_ONESHOT': 0x80000000,  # only send event once
+        },
+    }
 
     def maskname(mask):
         """

=== modified file 'ubuntuone/platform/ipc/ipc_client.py'
--- ubuntuone/platform/ipc/ipc_client.py	2012-10-25 14:54:57 +0000
+++ ubuntuone/platform/ipc/ipc_client.py	2015-09-19 23:19:46 +0000
@@ -127,11 +127,11 @@
                 for current_key, current_index in callbacks_names:
                     try:
                         kwargs[current_key] = RemoteHandler(
-                                                        kwargs[current_key])
+                            kwargs[current_key])
                     except KeyError:
                         if len(args) >= current_index + 1:
                             fixed_args[current_index] = RemoteHandler(
-                                                        args[current_index])
+                                args[current_index])
             fixed_args = tuple(fixed_args)
             return function(*fixed_args, **kwargs)
         return callbacks_wrapper
@@ -778,7 +778,6 @@
     @defer.inlineCallbacks
     def connect(self):
         """Connect to the syncdaemon service."""
-        # pylint: disable=W0702
         yield self.connection_lock.acquire()
         try:
             if self.client is None:
@@ -789,12 +788,11 @@
                 yield self._request_remote_objects(root)
                 yield self.register_to_signals()
             defer.returnValue(self)
-        except Exception, e:
+        except Exception as e:
             raise SyncDaemonClientConnectionError(
-                            'Could not connect to the syncdaemon ipc.', e)
+                'Could not connect to the syncdaemon ipc.', e)
         finally:
             self.connection_lock.release()
-        # pylint: disable=W0702
 
     @defer.inlineCallbacks
     def reconnect(self):
@@ -804,9 +802,9 @@
             yield self._request_remote_objects(root)
             yield self.register_to_signals()
             defer.returnValue(self)
-        except Exception, e:
+        except Exception as e:
             raise SyncDaemonClientConnectionError(
-                            'Could not reconnect to the syncdaemon ipc.', e)
+                'Could not reconnect to the syncdaemon ipc.', e)
 
     def is_connected(self):
         """Return if the client is connected."""

=== modified file 'ubuntuone/platform/ipc/linux.py'
--- ubuntuone/platform/ipc/linux.py	2012-10-22 13:31:02 +0000
+++ ubuntuone/platform/ipc/linux.py	2015-09-19 23:19:46 +0000
@@ -44,7 +44,6 @@
 )
 
 # Disable the "Invalid Name" check here, as we have lots of DBus style names
-# pylint: disable-msg=C0103
 
 DBUS_IFACE_NAME = 'com.ubuntuone.SyncDaemon'
 DBUS_IFACE_SYNC_NAME = DBUS_IFACE_NAME + '.SyncDaemon'
@@ -391,8 +390,7 @@
                          in_signature='ss', out_signature='a{ss}')
     def get_metadata_by_node(self, share_id, node_id):
         """Return the metadata (as a dict) for the specified share/node."""
-        return self.service.file_system.get_metadata_by_node(share_id,
-                                                               node_id)
+        return self.service.file_system.get_metadata_by_node(share_id, node_id)
 
     @dbus.service.method(DBUS_IFACE_FS_NAME,
                          in_signature='s', out_signature='a{ss}')
@@ -403,7 +401,7 @@
 
         """
         return self.service.file_system.get_metadata_and_quick_tree_synced(
-                                                                        path)
+            path)
 
     @dbus.service.method(DBUS_IFACE_FS_NAME,
                          in_signature='', out_signature='aa{ss}')
@@ -851,7 +849,7 @@
         """Report an error in changing the public access of a file."""
 
     @dbus.service.signal(DBUS_IFACE_PUBLIC_FILES_NAME,
-                        signature='aa{ss}')
+                         signature='aa{ss}')
     def PublicFilesList(self, files):
         """Notify the list of public files."""
 

=== modified file 'ubuntuone/platform/ipc/perspective_broker.py'
--- ubuntuone/platform/ipc/perspective_broker.py	2012-10-22 13:31:02 +0000
+++ ubuntuone/platform/ipc/perspective_broker.py	2015-09-19 23:19:46 +0000
@@ -179,8 +179,8 @@
         for current_client in self.clients_per_signal[signal_name]:
             try:
                 d = current_client.callRemote(signal_name, *args, **kwargs)
-                d.addErrback(self._ignore_no_such_method, signal_name,
-                                                          current_client)
+                d.addErrback(
+                    self._ignore_no_such_method, signal_name, current_client)
                 d.addErrback(self._other_failure, signal_name, current_client)
             except DeadReferenceError:
                 dead_clients.add(current_client)
@@ -500,8 +500,7 @@
 
     def get_metadata_by_node(self, share_id, node_id):
         """Return the metadata (as a dict) for the specified share/node."""
-        return self.service.file_system.get_metadata_by_node(share_id,
-                                                               node_id)
+        return self.service.file_system.get_metadata_by_node(share_id, node_id)
 
     def get_metadata_and_quick_tree_synced(self, path):
         """Return the metadata (as a dict) for the specified path.
@@ -510,7 +509,7 @@
 
         """
         return self.service.file_system.get_metadata_and_quick_tree_synced(
-                                                                        path)
+            path)
 
     def get_dirty_nodes(self):
         """Return a list of dirty nodes."""
@@ -528,16 +527,16 @@
 
     # calls that will be accessible remotely
     remote_calls = [
-       'get_shares',
-       'accept_share',
-       'reject_share',
-       'delete_share',
-       'subscribe',
-       'unsubscribe',
-       'create_share',
-       'create_shares',
-       'refresh_shares',
-       'get_shared',
+        'get_shares',
+        'accept_share',
+        'reject_share',
+        'delete_share',
+        'subscribe',
+        'unsubscribe',
+        'create_share',
+        'create_shares',
+        'refresh_shares',
+        'get_shared',
     ]
 
     signal_mapping = {

=== modified file 'ubuntuone/platform/notification/linux.py'
--- ubuntuone/platform/notification/linux.py	2015-09-17 02:20:40 +0000
+++ ubuntuone/platform/notification/linux.py	2015-09-19 23:19:46 +0000
@@ -46,11 +46,9 @@
 class Notification(AbstractNotification):
     """Notification of the end user."""
 
-    # pylint: disable=W0231
     def __init__(self, application_name=APPLICATION_NAME):
         self.application_name = application_name
         self.notification = None
-    # pylint: enable=W0231
 
     def send_notification(self, title, message, icon=ICON_NAME, append=False):
         """Send a notification using the underlying library."""

=== modified file 'ubuntuone/platform/notification/windows.py'
--- ubuntuone/platform/notification/windows.py	2015-09-17 02:20:40 +0000
+++ ubuntuone/platform/notification/windows.py	2015-09-19 23:19:46 +0000
@@ -38,10 +38,8 @@
 class Notification(AbstractNotification):
     """Notification of the end user."""
 
-    # pylint: disable=W0231
     def __init__(self, application_name=APPLICATION_NAME):
         self.application_name = application_name
-    # pylint: enable=W0231
 
     def send_notification(self, title, message, icon=None, append=False):
         """Send a notification using the underlying library."""

=== modified file 'ubuntuone/platform/os_helper/windows.py'
--- ubuntuone/platform/os_helper/windows.py	2013-02-10 22:54:07 +0000
+++ ubuntuone/platform/os_helper/windows.py	2015-09-19 23:19:46 +0000
@@ -76,8 +76,7 @@
 from comtypes.client import CreateObject
 from comtypes.persist import IPersistFile
 
-# ugly trick to stop pylint for complaining about
-# WindowsError on Linux
+# ugly trick to stop pylint for complaining about WindowsError on Linux
 if sys.platform != 'win32':
     WindowsError = None
 
@@ -161,7 +160,7 @@
         'unicode_path': 'Path %r should be unicode.',
         'long_path': 'Path %r should start with the LONG_PATH_PREFIX.',
         'illegal_path': '%r should not contain any character from' +
-                         ' WINDOWS_ILLEGAL_CHARS_MAP.',
+                        ' WINDOWS_ILLEGAL_CHARS_MAP.',
     }
     messages = _add_method_info(messages, method_name)
 
@@ -171,8 +170,8 @@
 
     path = path.replace(LONG_PATH_PREFIX, u'')
     drive, path = os.path.splitdrive(path)
-    assert not any(c in WINDOWS_ILLEGAL_CHARS_MAP for c in path), \
-                   messages['illegal_path'] % path
+    assert not any(c in WINDOWS_ILLEGAL_CHARS_MAP for c in path), (
+        messages['illegal_path'] % path)
 
 
 def assert_syncdaemon_path(path, method_name=None):
@@ -465,9 +464,9 @@
     for group_sid, attributes in groups:
         # set the attributes of the group only if not null
         if attributes:
-            dacl.AddAccessAllowedAceEx(ACL_REVISION,
-                CONTAINER_INHERIT_ACE | OBJECT_INHERIT_ACE, attributes,
-                group_sid)
+            dacl.AddAccessAllowedAceEx(
+                ACL_REVISION, CONTAINER_INHERIT_ACE | OBJECT_INHERIT_ACE,
+                attributes, group_sid)
     # the dacl has all the info of the diff groups passed in the parameters
     security_descriptor.SetSecurityDescriptorDacl(1, dacl, 0)
     SetFileSecurity(path, DACL_SECURITY_INFORMATION, security_descriptor)
@@ -625,9 +624,8 @@
     # function from win32 which will allow to replace the destination path if
     # exists and the user has the proper rights. For further information, see:
     # http://msdn.microsoft.com/en-us/library/aa365240(v=vs.85).aspx
-    flag = MOVEFILE_COPY_ALLOWED | \
-           MOVEFILE_WRITE_THROUGH | \
-           MOVEFILE_REPLACE_EXISTING
+    flag = (MOVEFILE_COPY_ALLOWED | MOVEFILE_WRITE_THROUGH |
+            MOVEFILE_REPLACE_EXISTING)
     try:
         MoveFileExW(path_from, path_to, flag)
     except PyWinError, e:
@@ -757,8 +755,10 @@
     # return those paths that are system paths. Those paths are the ones that
     # we do not want to work with.
 
-    return map(_unicode_to_bytes, [p for p in os.listdir(directory) if not
-        native_is_system_path(os.path.join(directory, p))])
+    return map(
+        _unicode_to_bytes,
+        [p for p in os.listdir(directory)
+         if not native_is_system_path(os.path.join(directory, p))])
 
 
 @windowspath()
@@ -780,10 +780,14 @@
         dirpath = _unicode_to_bytes(dirpath.replace(LONG_PATH_PREFIX, u''))
         if native_is_system_path(dirpath):
             continue
-        dirnames = map(_unicode_to_bytes, [p for p in dirnames if
-             not native_is_system_path(os.path.join(dirpath, p))])
-        filenames = map(_unicode_to_bytes, [p for p in filenames if not
-                native_is_system_path(os.path.join(dirpath, p))])
+        dirnames = map(
+            _unicode_to_bytes,
+            [p for p in dirnames
+             if not native_is_system_path(os.path.join(dirpath, p))])
+        filenames = map(
+            _unicode_to_bytes,
+            [p for p in filenames
+             if not native_is_system_path(os.path.join(dirpath, p))])
         yield dirpath, dirnames, filenames
 
 
@@ -807,8 +811,9 @@
         ace = dacl.GetAce(index)
         if _has_read_mask(ace[1]):
             sids.append(ace[2])
-    return (USER_SID in sids or EVERYONE_SID in sids) and\
-            os.access(path, os.R_OK)
+    return (
+        (USER_SID in sids or EVERYONE_SID in sids) and os.access(path, os.R_OK)
+    )
 
 
 @windowspath()
@@ -831,8 +836,9 @@
         ace = dacl.GetAce(index)
         if _has_read_mask(ace[1]):
             sids.append(ace[2])
-    return (USER_SID in sids or EVERYONE_SID in sids) and\
-            os.access(path, os.R_OK)
+    return (
+        (USER_SID in sids or EVERYONE_SID in sids) and os.access(path, os.R_OK)
+    )
 
 
 @windowspath()
@@ -863,8 +869,8 @@
     # the shell code does not know how to deal with long paths, lets
     # try to move it to the trash if it is short enough, else we remove it
     no_prefix_path = path.replace(LONG_PATH_PREFIX, u'')
-    flags = shellcon.FOF_ALLOWUNDO | shellcon.FOF_NOCONFIRMATION | \
-            shellcon.FOF_NOERRORUI | shellcon.FOF_SILENT
+    flags = (shellcon.FOF_ALLOWUNDO | shellcon.FOF_NOCONFIRMATION |
+             shellcon.FOF_NOERRORUI | shellcon.FOF_SILENT)
     result = shell.SHFileOperation((0, shellcon.FO_DELETE,
                                     no_prefix_path, None, flags))
 

=== modified file 'ubuntuone/platform/sync_menu/linux.py'
--- ubuntuone/platform/sync_menu/linux.py	2015-09-17 02:20:40 +0000
+++ ubuntuone/platform/sync_menu/linux.py	2015-09-19 23:19:46 +0000
@@ -89,40 +89,42 @@
         self.open_u1 = Dbusmenu.Menuitem()
         self.open_u1.property_set(Dbusmenu.MENUITEM_PROP_LABEL, OPEN_U1)
         self.open_u1_folder = Dbusmenu.Menuitem()
-        self.open_u1_folder.property_set(Dbusmenu.MENUITEM_PROP_LABEL,
-            OPEN_U1_FOLDER)
+        self.open_u1_folder.property_set(
+            Dbusmenu.MENUITEM_PROP_LABEL, OPEN_U1_FOLDER)
         self.share_file = Dbusmenu.Menuitem()
-        self.share_file.property_set(Dbusmenu.MENUITEM_PROP_LABEL,
-            SHARE_A_FILE)
+        self.share_file.property_set(
+            Dbusmenu.MENUITEM_PROP_LABEL, SHARE_A_FILE)
 
         self.go_to_web = Dbusmenu.Menuitem()
-        self.go_to_web.property_set(Dbusmenu.MENUITEM_PROP_LABEL,
-            GO_TO_WEB)
+        self.go_to_web.property_set(
+            Dbusmenu.MENUITEM_PROP_LABEL, GO_TO_WEB)
 
         self.transfers = TransfersMenu(status)
-        self.transfers.property_set(Dbusmenu.MENUITEM_PROP_LABEL,
-            TRANSFERS)
+        self.transfers.property_set(
+            Dbusmenu.MENUITEM_PROP_LABEL, TRANSFERS)
 
         self.more_storage = Dbusmenu.Menuitem()
-        self.more_storage.property_set(Dbusmenu.MENUITEM_PROP_LABEL,
-            MORE_STORAGE)
+        self.more_storage.property_set(
+            Dbusmenu.MENUITEM_PROP_LABEL, MORE_STORAGE)
 
         self.get_help = Dbusmenu.Menuitem()
-        self.get_help.property_set(Dbusmenu.MENUITEM_PROP_LABEL,
-            GET_HELP)
+        self.get_help.property_set(
+            Dbusmenu.MENUITEM_PROP_LABEL, GET_HELP)
 
         # Connect signals
-        self.open_u1.connect(Dbusmenu.MENUITEM_SIGNAL_ITEM_ACTIVATED,
-            self.open_control_panel)
-        self.open_u1_folder.connect(Dbusmenu.MENUITEM_SIGNAL_ITEM_ACTIVATED,
+        self.open_u1.connect(
+            Dbusmenu.MENUITEM_SIGNAL_ITEM_ACTIVATED, self.open_control_panel)
+        self.open_u1_folder.connect(
+            Dbusmenu.MENUITEM_SIGNAL_ITEM_ACTIVATED,
             self.open_ubuntu_one_folder)
-        self.share_file.connect(Dbusmenu.MENUITEM_SIGNAL_ITEM_ACTIVATED,
-            self.open_share_file_tab)
-        self.go_to_web.connect(Dbusmenu.MENUITEM_SIGNAL_ITEM_ACTIVATED,
-            self.open_go_to_web)
-        self.get_help.connect(Dbusmenu.MENUITEM_SIGNAL_ITEM_ACTIVATED,
-            self.open_web_help)
-        self.more_storage.connect(Dbusmenu.MENUITEM_SIGNAL_ITEM_ACTIVATED,
+        self.share_file.connect(
+            Dbusmenu.MENUITEM_SIGNAL_ITEM_ACTIVATED, self.open_share_file_tab)
+        self.go_to_web.connect(
+            Dbusmenu.MENUITEM_SIGNAL_ITEM_ACTIVATED, self.open_go_to_web)
+        self.get_help.connect(
+            Dbusmenu.MENUITEM_SIGNAL_ITEM_ACTIVATED, self.open_web_help)
+        self.more_storage.connect(
+            Dbusmenu.MENUITEM_SIGNAL_ITEM_ACTIVATED,
             self.open_get_more_storage)
 
         # Add items
@@ -172,11 +174,12 @@
     def _open_uri(self, uri, timestamp=0):
         """Open an uri Using the default handler and the action timestamp"""
         try:
-            Gio.AppInfo.launch_default_for_uri(uri, self._get_launch_context(timestamp))
+            Gio.AppInfo.launch_default_for_uri(
+                uri, self._get_launch_context(timestamp))
         except glib.GError as e:
-            logger.warning('Failed to open the uri %s: %s.' % (uri, e))
+            logger.warning('Failed to open the uri %s: %s.', uri, e)
 
-    def _open_control_panel_by_command_line(self, timestamp, args = ''):
+    def _open_control_panel_by_command_line(self, timestamp, args=''):
         """Open the control panel by command line"""
         flags = Gio.AppInfoCreateFlags.SUPPORTS_STARTUP_NOTIFICATION
         command_line = CLIENT_COMMAND_LINE
@@ -184,7 +187,8 @@
             command_line += ' ' + args
 
         try:
-            app = Gio.AppInfo.create_from_commandline(command_line, 'Magicicada', flags)
+            app = Gio.AppInfo.create_from_commandline(
+                command_line, 'Magicicada', flags)
 
             if app:
                 app.launch([], self._get_launch_context(timestamp))
@@ -205,11 +209,13 @@
 
     def open_ubuntu_one_folder(self, menuitem=None, timestamp=0):
         """Open the Magicicada folder."""
-        self._open_uri("file://" + self._syncdaemon_service.get_rootdir(), timestamp)
+        self._open_uri(
+            "file://" + self._syncdaemon_service.get_rootdir(), timestamp)
 
     def open_share_file_tab(self, menuitem=None, timestamp=0):
         """Open the Control Panel in the Share Tab."""
-        self._open_control_panel_by_command_line(timestamp, "--switch-to share_links")
+        self._open_control_panel_by_command_line(
+            timestamp, "--switch-to share_links")
 
     def open_go_to_web(self, menuitem=None, timestamp=0):
         """Open the Magicicada Help Page"""
@@ -234,7 +240,7 @@
         if not self.timer:
             logger.debug("Updating Transfers.")
             delay = int(max(0, min(DELAY_BETWEEN_UPDATES,
-                self.next_update - time.time())))
+                                   self.next_update - time.time())))
             self.timer = status.aggregator.Timer(delay)
             self.timer.addCallback(self._timeout)
 
@@ -268,16 +274,16 @@
                 self.child_delete(self._transfers_items[item_transfer])
             for item in recent_transfers:
                 recent_file = Dbusmenu.Menuitem()
-                recent_file.property_set(Dbusmenu.MENUITEM_PROP_LABEL,
-                    item.replace('_', '__'))
+                recent_file.property_set(
+                    Dbusmenu.MENUITEM_PROP_LABEL, item.replace('_', '__'))
                 self.child_add_position(recent_file, 0)
                 temp_transfers[item] = recent_file
             self._transfers_items = temp_transfers
 
         if self.separator is None:
             self.separator = Dbusmenu.Menuitem()
-            self.separator.property_set(Dbusmenu.MENUITEM_PROP_TYPE,
-                Dbusmenu.CLIENT_TYPES_SEPARATOR)
+            self.separator.property_set(
+                Dbusmenu.MENUITEM_PROP_TYPE, Dbusmenu.CLIENT_TYPES_SEPARATOR)
             self.child_append(self.separator)
 
         items_added = 0
@@ -290,7 +296,8 @@
                 upload_item.property_set_int(
                     SyncMenu.PROGRESS_MENUITEM_PROP_PERCENT_DONE,
                     percentage)
-                logger.debug("Current transfer %s progress update: %r",
+                logger.debug(
+                    "Current transfer %s progress update: %r",
                     item, percentage)
                 items_added += 1
             else:
@@ -304,9 +311,10 @@
                     size, written = uploading_data[item]
                     percentage = written * 100 / size
                     uploading_file = Dbusmenu.Menuitem()
-                    uploading_file.property_set(Dbusmenu.MENUITEM_PROP_LABEL,
-                        item.replace('_', '__'))
-                    uploading_file.property_set(Dbusmenu.MENUITEM_PROP_TYPE,
+                    uploading_file.property_set(
+                        Dbusmenu.MENUITEM_PROP_LABEL, item.replace('_', '__'))
+                    uploading_file.property_set(
+                        Dbusmenu.MENUITEM_PROP_TYPE,
                         SyncMenu.PROGRESS_MENUITEM_TYPE)
                     uploading_file.property_set_int(
                         SyncMenu.PROGRESS_MENUITEM_PROP_PERCENT_DONE,
@@ -321,4 +329,3 @@
     UbuntuOneSyncMenu = UbuntuOneSyncMenuLinux
 else:
     UbuntuOneSyncMenu = DummySyncMenu
-

=== modified file 'ubuntuone/platform/tools/__init__.py'
--- ubuntuone/platform/tools/__init__.py	2013-01-12 00:28:17 +0000
+++ ubuntuone/platform/tools/__init__.py	2015-09-19 23:19:46 +0000
@@ -99,7 +99,7 @@
             self.proxy.wait_connected()
             self.log.debug('wait_connected: Done!')
             d.callback(True)
-        except Exception, e:  # catch all errors, pylint: disable=W0703
+        except Exception as e:
             self.log.debug('Not connected: %s', e)
             d.errback()
 
@@ -202,7 +202,7 @@
             try:
                 if success_filter(*args):
                     d.callback(args)
-            except Exception, e:
+            except Exception as e:
                 logger.exception('wait_for_signals: success_handler failed:')
                 d.errback(IPCError(e.__class__.__name__, args, e.message))
 
@@ -211,7 +211,7 @@
             try:
                 if error_filter(*args):
                     d.errback(IPCError(signal_error, args))
-            except Exception, e:
+            except Exception as e:
                 logger.exception('wait_for_signals: error_handler failed:')
                 d.errback(IPCError(e.__class__.__name__, args, e.message))
 
@@ -278,8 +278,9 @@
     @log_call(logger.debug)
     def accept_share(self, share_id):
         """Accept the share with id: share_id."""
-        d = self.wait_for_signals(signal_ok='ShareAnswerResponse',
-                success_filter=lambda info: info['volume_id'] == share_id)
+        d = self.wait_for_signals(
+            signal_ok='ShareAnswerResponse',
+            success_filter=lambda info: info['volume_id'] == share_id)
         self.proxy.call_method('shares', 'accept_share', share_id)
         result, = yield d
         defer.returnValue(result)
@@ -288,8 +289,9 @@
     @log_call(logger.debug)
     def reject_share(self, share_id):
         """Reject the share with id: share_id."""
-        d = self.wait_for_signals(signal_ok='ShareAnswerResponse',
-                success_filter=lambda info: info['volume_id'] == share_id)
+        d = self.wait_for_signals(
+            signal_ok='ShareAnswerResponse',
+            success_filter=lambda info: info['volume_id'] == share_id)
         self.proxy.call_method('shares', 'reject_share', share_id)
         result, = yield d
         defer.returnValue(result)
@@ -298,9 +300,10 @@
     @log_call(logger.debug)
     def subscribe_share(self, share_id):
         """Subscribe to a share given its id."""
-        d = self.wait_for_signals('ShareSubscribed', 'ShareSubscribeError',
-                success_filter=lambda info: info['volume_id'] == share_id,
-                error_filter=lambda info, _: info['volume_id'] == share_id)
+        d = self.wait_for_signals(
+            'ShareSubscribed', 'ShareSubscribeError',
+            success_filter=lambda info: info['volume_id'] == share_id,
+            error_filter=lambda info, _: info['volume_id'] == share_id)
         self.proxy.call_method('shares', 'subscribe', share_id)
         result, = yield d
         defer.returnValue(result)
@@ -309,9 +312,10 @@
     @log_call(logger.debug)
     def unsubscribe_share(self, share_id):
         """Unsubscribe from a share given its id."""
-        d = self.wait_for_signals('ShareUnSubscribed', 'ShareUnSubscribeError',
-                success_filter=lambda info: info['volume_id'] == share_id,
-                error_filter=lambda info, _: info['volume_id'] == share_id)
+        d = self.wait_for_signals(
+            'ShareUnSubscribed', 'ShareUnSubscribeError',
+            success_filter=lambda info: info['volume_id'] == share_id,
+            error_filter=lambda info, _: info['volume_id'] == share_id)
         self.proxy.call_method('shares', 'unsubscribe', share_id)
         result, = yield d
         defer.returnValue(result)
@@ -333,8 +337,8 @@
     @log_call(logger.debug)
     def offer_share(self, path, username, name, access_level):
         """Offer a share at the specified path to user with id: username."""
-        return self.proxy.call_method('shares', 'create_share', path,
-                                             username, name, access_level)
+        return self.proxy.call_method(
+            'shares', 'create_share', path, username, name, access_level)
 
     @defer.inlineCallbacks
     @log_call(logger.debug)
@@ -349,9 +353,10 @@
     @log_call(logger.debug)
     def create_folder(self, path):
         """Create a user defined folder in the specified path."""
-        d = self.wait_for_signals('FolderCreated', 'FolderCreateError',
-                success_filter=lambda info: info['path'] == path,
-                error_filter=lambda info, _: info['path'] == path)
+        d = self.wait_for_signals(
+            'FolderCreated', 'FolderCreateError',
+            success_filter=lambda info: info['path'] == path,
+            error_filter=lambda info, _: info['path'] == path)
 
         self.proxy.call_method('folders', 'create', path)
 
@@ -362,9 +367,10 @@
     @log_call(logger.info)
     def delete_folder(self, folder_id):
         """Delete a user defined folder given its id."""
-        d = self.wait_for_signals('FolderDeleted', 'FolderDeleteError',
-                success_filter=lambda info: info['volume_id'] == folder_id,
-                error_filter=lambda info, _: info['volume_id'] == folder_id)
+        d = self.wait_for_signals(
+            'FolderDeleted', 'FolderDeleteError',
+            success_filter=lambda info: info['volume_id'] == folder_id,
+            error_filter=lambda info, _: info['volume_id'] == folder_id)
 
         self.proxy.call_method('folders', 'delete', folder_id)
 
@@ -375,9 +381,10 @@
     @log_call(logger.debug)
     def subscribe_folder(self, folder_id):
         """Subscribe to a user defined folder given its id."""
-        d = self.wait_for_signals('FolderSubscribed', 'FolderSubscribeError',
-                success_filter=lambda info: info['volume_id'] == folder_id,
-                error_filter=lambda info, _: info['volume_id'] == folder_id)
+        d = self.wait_for_signals(
+            'FolderSubscribed', 'FolderSubscribeError',
+            success_filter=lambda info: info['volume_id'] == folder_id,
+            error_filter=lambda info, _: info['volume_id'] == folder_id)
 
         self.proxy.call_method('folders', 'subscribe', folder_id)
 
@@ -389,9 +396,9 @@
     def unsubscribe_folder(self, folder_id):
         """Unsubscribe from a user defined folder given its id."""
         d = self.wait_for_signals(
-                'FolderUnSubscribed', 'FolderUnSubscribeError',
-                success_filter=lambda info: info['volume_id'] == folder_id,
-                error_filter=lambda info, _: info['volume_id'] == folder_id)
+            'FolderUnSubscribed', 'FolderUnSubscribeError',
+            success_filter=lambda info: info['volume_id'] == folder_id,
+            error_filter=lambda info, _: info['volume_id'] == folder_id)
 
         self.proxy.call_method('folders', 'unsubscribe', folder_id)
 
@@ -524,8 +531,8 @@
     @log_call(logger.debug)
     def set_throttling_limits(self, read_limit, write_limit):
         """Set the read and write limits."""
-        return self.proxy.call_method('config', 'set_throttling_limits',
-                                             read_limit, write_limit)
+        return self.proxy.call_method(
+            'config', 'set_throttling_limits', read_limit, write_limit)
 
     def is_setting_enabled(self, setting_name):
         """Return whether 'setting_name' is enabled."""
@@ -665,8 +672,8 @@
     else:
         out.write("Shared list:\n")
     for share in shares:
-        msg_template = '  id=%s name=%s accepted=%s ' + \
-                'access_level=%s to=%s path=%s\n'
+        msg_template = (
+            '  id=%s name=%s accepted=%s access_level=%s to=%s path=%s\n')
         out.write(msg_template % (share['volume_id'], share['name'],
                                   bool(share['accepted']),
                                   share['access_level'],
@@ -730,8 +737,8 @@
         out.write("Current uploads: 0\n")
     for upload in uploads:
         out.write("  path: %s\n" % upload['path'])
-        out.write("    deflated size: %s\n" % \
-                  upload.get('deflated_size', 'N/A'))
+        out.write(
+            "    deflated size: %s\n" % upload.get('deflated_size', 'N/A'))
         out.write("    bytes written: %s\n" % upload['n_bytes_written'])
 
 
@@ -743,8 +750,8 @@
         out.write("Current downloads: 0\n")
     for download in downloads:
         out.write("  path: %s\n" % download['path'])
-        out.write("    deflated size: %s\n" % \
-                  download.get('deflated_size', 'N/A'))
+        out.write(
+            "    deflated size: %s\n" % download.get('deflated_size', 'N/A'))
         out.write("    bytes read: %s\n" % download['n_bytes_read'])
 
 
@@ -802,8 +809,9 @@
 def show_waiting_content(waiting_ops, out):
     """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'"
+    value_tpl = (
+        "operation='%(operation)s' node_id='%(node)s' share_id='%(share)s' "
+        "path='%(path)s'")
     for value in waiting_ops:
         str_value = value_tpl % value
         out.write("%s\n" % str_value)
@@ -822,8 +830,9 @@
     if not nodes:
         out.write(" No dirty nodes.\n")
         return
-    node_line_tpl = "mdid: %(mdid)s volume_id: %(share_id)s " + \
-            "node_id: %(node_id)s is_dir: %(is_dir)s path: %(path)s\n"
+    node_line_tpl = (
+        "mdid: %(mdid)s volume_id: %(share_id)s node_id: %(node_id)s "
+        "is_dir: %(is_dir)s path: %(path)s\n")
     out.write(" Dirty nodes:\n")
     for node in nodes:
         assert isinstance(node['path'], unicode)

=== modified file 'ubuntuone/platform/tools/perspective_broker.py'
--- ubuntuone/platform/tools/perspective_broker.py	2012-12-27 02:10:00 +0000
+++ ubuntuone/platform/tools/perspective_broker.py	2015-09-19 23:19:46 +0000
@@ -119,8 +119,8 @@
             return attr
 
     def __init__(self, bus=None):
-        self.log = logging.getLogger('ubuntuone.platform.tools.' +
-            'perspective_broker')
+        self.log = logging.getLogger(
+            'ubuntuone.platform.tools.perspective_broker')
         self.client = UbuntuOneClient()
         self.connected = None
         self.connected_signals = defaultdict(set)
@@ -167,8 +167,8 @@
             # may happen in the case we reconnected and the server side objects
             # for gc
             yield self._reconnect_client()
-            result = yield self.call_method(client_kind, method_name,
-                    *args, **kwargs)
+            result = yield self.call_method(
+                client_kind, method_name, *args, **kwargs)
         except RemoteError as e:
             # Wrap RemoteErrors in IPCError to match DBus interface's
             # behavior:
@@ -191,9 +191,8 @@
         client_kind, callback = self._SIGNAL_MAPPING[signal_name]
         client = getattr(self.client, client_kind)
         if len(self.connected_signals[signal_name]) == 0:
-            setattr(client, callback,
-                lambda *args, **kwargs:
-                    self._handler(signal_name, *args, **kwargs))
+            f = lambda *args, **kw: self._handler(signal_name, *args, **kw)
+            setattr(client, callback, f)
         # do remember the connected signal in case we need to reconnect
         self.connected_signals[signal_name].add(handler)
         return handler

=== modified file 'ubuntuone/proxy/tunnel_client.py'
--- ubuntuone/proxy/tunnel_client.py	2015-09-17 02:20:40 +0000
+++ ubuntuone/proxy/tunnel_client.py	2015-09-19 23:19:46 +0000
@@ -135,8 +135,8 @@
         """A connectSSL going thru the tunnel."""
         logger.info("Connecting (SSL) to %r:%r via tunnel at %r:%r",
                     host, port, self.tunnel_host, self.tunnel_port)
-        tunnel_factory = TunnelClientFactory(host, port, factory, self.cookie,
-                                      contextFactory)
+        tunnel_factory = TunnelClientFactory(
+            host, port, factory, self.cookie, contextFactory)
         return reactor.connectTCP(self.tunnel_host, self.tunnel_port,
                                   tunnel_factory, *args, **kwargs)
 
@@ -175,7 +175,8 @@
         self.finish_timeout()
         logger.info("Tunnel process exit status %r.", status)
         if not self.client_d.called:
-            logger.debug("Tunnel process exited before TunnelClient created. Falling back to reactor")
+            logger.debug("Tunnel process exited before TunnelClient created. "
+                         "Falling back to reactor")
             self.client_d.callback(reactor)
 
     def outReceived(self, data):

=== modified file 'ubuntuone/proxy/tunnel_server.py'
--- ubuntuone/proxy/tunnel_server.py	2015-09-17 02:20:40 +0000
+++ ubuntuone/proxy/tunnel_server.py	2015-09-19 23:19:46 +0000
@@ -260,7 +260,7 @@
                     raise
 
                 credentials = yield Keyring().get_credentials(
-                                                str(self.proxy_domain))
+                    str(self.proxy_domain))
                 if "username" in credentials:
                     self.proxy_credentials = credentials
                 logger.info("Connecting again with keyring credentials")

=== modified file 'ubuntuone/status/aggregator.py'
--- ubuntuone/status/aggregator.py	2015-09-17 02:20:40 +0000
+++ ubuntuone/status/aggregator.py	2015-09-19 23:19:46 +0000
@@ -51,8 +51,9 @@
 Q_ = lambda string: gettext.dgettext(GETTEXT_PACKAGE, string)
 
 UBUNTUONE_TITLE = Q_("Magicicada")
-UBUNTUONE_END = Q_("Magicicada file services will be "
-                   "shutting down on June 1st, 2014.\nThanks for your support.")
+UBUNTUONE_END = Q_(
+    "Magicicada file services will be shutting down on June 1st, 2014.\n"
+    "Thanks for your support.")
 NEW_UDFS_SENDER = Q_("New cloud folder(s) available")
 FINAL_COMPLETED = Q_("File synchronization completed.")
 
@@ -373,9 +374,8 @@
     def __init__(self, *args):
         """Initialize this instance."""
         super(FileDiscoveryGatheringState, self).__init__(*args)
-        self.timer = DeadlineTimer(self.initial_delay,
-                                 self.initial_timeout,
-                                 clock=self.clock)
+        self.timer = DeadlineTimer(
+            self.initial_delay, self.initial_timeout, clock=self.clock)
         self.timer.addCallback(self._timeout)
 
     def _timeout(self, result):
@@ -624,7 +624,6 @@
         """Create a new toggleable notification object."""
         return self.notification_switch.get_notification()
 
-    # pylint: disable=W0201
     def reset(self):
         """Reset all counters and notifications."""
         self.download_done = 0
@@ -647,7 +646,6 @@
         self.final_status_bubble = FinalStatusBubble(self)
         self.progress = {}
         self.to_do = {}
-    # pylint: enable=W0201
 
     def register_progress_listener(self, listener):
         """Register a callable object to be notified."""
@@ -736,11 +734,9 @@
         if command.deflated_size is not None:
             self.to_do[
                 (command.share_id, command.node_id)] = command.deflated_size
-        # pylint: disable=W0201
         if not self.downloading_filename:
             self.downloading_filename = os.path.basename(
                 self.files_downloading[0].path)
-        # pylint: enable=W0201
         self.update_progressbar()
         logger.debug(
             "queueing command (total: %d): %s",
@@ -770,11 +766,9 @@
         if command.deflated_size is not None:
             self.to_do[
                 (command.share_id, command.node_id)] = command.deflated_size
-        # pylint: disable=W0201
         if not self.uploading_filename:
             self.uploading_filename = os.path.basename(
                 self.files_uploading[0].path)
-        # pylint: enable=W0201
         self.update_progressbar()
         logger.debug(
             "queueing command (total: %d): %s", len(self.to_do),
@@ -839,8 +833,8 @@
     def start_sync_menu(self):
         """Create the sync menu and register the progress listener."""
         if self.syncdaemon_service is not None:
-            self.sync_menu = sync_menu.UbuntuOneSyncMenu(self,
-                self.syncdaemon_service)
+            self.sync_menu = sync_menu.UbuntuOneSyncMenu(
+                self, self.syncdaemon_service)
             self.aggregator.register_connection_listener(
                 self.sync_menu.sync_status_changed)
             self.aggregator.register_progress_listener(
@@ -855,8 +849,9 @@
         uploading = []
         for upload in self.aggregator.files_uploading:
             if upload.deflated_size not in (0, None):
-                uploading.append((upload.path, upload.deflated_size,
-                    upload.n_bytes_written))
+                uploading.append(
+                    (upload.path, upload.deflated_size, upload.n_bytes_written)
+                )
         return uploading
 
     def files_downloading(self):
@@ -874,7 +869,7 @@
         self.notification.send_notification(
             UBUNTUONE_TITLE, status_event.one())
 
-    def file_unpublished(self, public_url):  # pylint: disable=W0613
+    def file_unpublished(self, public_url):
         """A file was unpublished."""
         self.notification.send_notification(
             UBUNTUONE_TITLE, FileUnpublishingStatus().one())

=== modified file 'ubuntuone/syncdaemon/__init__.py'
--- ubuntuone/syncdaemon/__init__.py	2015-09-17 02:20:40 +0000
+++ ubuntuone/syncdaemon/__init__.py	2015-09-19 23:19:46 +0000
@@ -29,16 +29,12 @@
 """Client module."""
 
 # required capabilities
-REQUIRED_CAPS = frozenset(["no-content",
-                           "account-info",
-                           "resumable-uploads",
-                           "fix462230",
-                           "volumes",
-                           "generations",
-                          ])
-
-
-#Sync Menu data constants
+REQUIRED_CAPS = frozenset(
+    ["no-content", "account-info", "resumable-uploads", "fix462230", "volumes",
+     "generations"])
+
+
+# Sync Menu data constants
 RECENT_TRANSFERS = 'recent-transfers'
 UPLOADING = 'uploading'
 DOWNLOADING = 'downloading'

=== modified file 'ubuntuone/syncdaemon/action_queue.py'
--- ubuntuone/syncdaemon/action_queue.py	2015-09-17 02:20:40 +0000
+++ ubuntuone/syncdaemon/action_queue.py	2015-09-19 23:19:46 +0000
@@ -543,7 +543,7 @@
             upload.deflated_size = tempfile.tell()
 
             upload.magic_hash = magic_hasher.content_hash()
-        except Exception, e:  # pylint: disable-msg=W0703
+        except Exception as e:
             failed = True
             if tempfile is not None:
                 tempfile.close()
@@ -564,7 +564,7 @@
         try:
             try:
                 fileobj = fileobj_factory()
-            except StandardError, e:
+            except StandardError as e:
                 # maybe the user deleted the file before we got to upload it
                 upload.log.warn("Unable to build fileobj (%s: '%s') so "
                                 "cancelling the upload.", type(e), e)
@@ -884,7 +884,6 @@
         def on_lookup_ok(results):
             """Get a random host from the SRV result."""
             logger.debug('SRV lookup done, choosing a server.')
-            # pylint: disable-msg=W0612
             records, auth, add = results
             if not records:
                 raise ValueError('No available records.')
@@ -1312,7 +1311,6 @@
     """Base of all the action queue commands."""
 
     # the info used in the protocol errors is hidden, but very useful!
-    # pylint: disable-msg=W0212
     suppressed_error_messages = (
         [x for x in protocol_errors._error_mapping.values()
          if x is not protocol_errors.InternalError] +
@@ -1393,7 +1391,7 @@
         for (name, marker, deferred) in waiting_structure:
             try:
                 value = yield deferred
-            except Exception, e:
+            except Exception as e:
                 # on first failure, errback the marker resolved flag, and
                 # quit waiting for other deferreds
                 self.log.error("failed %r", marker)
@@ -2487,8 +2485,8 @@
         """A streaming decompressor."""
         self.n_bytes_read += len(bytes)
         self.fileobj.write(self.gunzip.decompress(bytes))
-        self.fileobj.flush()     # not strictly necessary but nice to
-                                 # see the downloaded size
+        # not strictly necessary but nice to see the downloaded size
+        self.fileobj.flush()
         self.progress_hook()
 
     def progress_hook(self):
@@ -2608,7 +2606,8 @@
     def cleanup(self):
         """Cleanup: stop the producer."""
         self.log.debug('cleanup')
-        if self.upload_req is not None and self.upload_req.producer is not None:
+        if (self.upload_req is not None and
+                self.upload_req.producer is not None):
             self.log.debug('stopping the producer')
             self.upload_req.producer.stopProducing()
 

=== modified file 'ubuntuone/syncdaemon/config.py'
--- ubuntuone/syncdaemon/config.py	2015-09-19 21:04:46 +0000
+++ ubuntuone/syncdaemon/config.py	2015-09-19 23:19:46 +0000
@@ -260,7 +260,7 @@
             # override the default in the new setting
             current.value = old.value
             cp.set('logging', 'level', current)
-    #else, we ignore the setting as we have a non-default
+    # else, we ignore the setting as we have a non-default
     # value in logging-level (newer setting wins)
     logger.warning("Found deprecated config option 'log_level'"
                    " in section: MAIN")

=== modified file 'ubuntuone/syncdaemon/event_queue.py'
--- ubuntuone/syncdaemon/event_queue.py	2012-08-08 13:21:13 +0000
+++ ubuntuone/syncdaemon/event_queue.py	2015-09-19 23:19:46 +0000
@@ -105,7 +105,7 @@
     'AQ_DELTA_ERROR': ('volume_id', 'error'),
     'AQ_DELTA_NOT_POSSIBLE': ('volume_id',),
     'AQ_RESCAN_FROM_SCRATCH_OK': ('volume_id', 'delta_content',
-        'end_generation', 'free_bytes'),  # must always be full
+                                  'end_generation', 'free_bytes'),
     'AQ_RESCAN_FROM_SCRATCH_ERROR': ('volume_id', 'error'),
 
     'SV_SHARE_CHANGED': ('info',),

=== modified file 'ubuntuone/syncdaemon/events_nanny.py'
--- ubuntuone/syncdaemon/events_nanny.py	2012-04-09 20:07:05 +0000
+++ ubuntuone/syncdaemon/events_nanny.py	2015-09-19 23:19:46 +0000
@@ -41,7 +41,7 @@
     """
     def __init__(self, fsm, eq, hq):
         self.logger = logging.getLogger(
-                                'ubuntuone.SyncDaemon.DownloadFinishedNanny')
+            'ubuntuone.SyncDaemon.DownloadFinishedNanny')
         self.fsm = fsm
         self.eq = eq
         self.hq = hq

=== modified file 'ubuntuone/syncdaemon/file_shelf.py'
--- ubuntuone/syncdaemon/file_shelf.py	2012-04-09 20:07:05 +0000
+++ ubuntuone/syncdaemon/file_shelf.py	2015-09-19 23:19:46 +0000
@@ -108,7 +108,6 @@
 
     def keys(self):
         """ returns a iterator over the keys """
-        # pylint: disable-msg=W0612
         splitext = os.path.splitext
         for dirpath, dirnames, filenames in walk(self._path):
             for filename in filenames:
@@ -125,7 +124,6 @@
 
     def __contains__(self, key):
         """ returns if the file storage has that key """
-        # this method surely has some effect! pylint: disable-msg=W0104
         try:
             self[key]
         except KeyError:
@@ -205,7 +203,6 @@
         To get len(keys) we need to iterate over the full key set.
         """
         counter = 0
-        # pylint: disable-msg=W0612
         for key in self.keys():
             counter += 1
         return counter
@@ -343,9 +340,8 @@
                     self._queue.append(k)
                 else:
                     self._refcount[k] -= 1
-            if not (len(self._queue) == len(self._cache) \
-                    == len(self._refcount) \
-                    == sum(self._refcount.itervalues())):
+            if (not (len(self._queue) == len(self._cache) ==
+                     len(self._refcount) == sum(self._refcount.itervalues()))):
                 # create a custom exception for this error
                 raise CacheInconsistencyError(len(self._queue),
                                               len(self._cache),
@@ -357,5 +353,6 @@
     """Exception representing a inconsistency in the cache"""
 
     def __str__(self):
-        return "Inconsistency in the cache: queue: %d cache: %d refcount: %d" \
-                " sum(refcount.values): %d" % self.args
+        return (
+            "Inconsistency in the cache: queue: %d cache: %d refcount: %d "
+            "sum(refcount.values): %d" % self.args)

=== modified file 'ubuntuone/syncdaemon/filesystem_manager.py'
--- ubuntuone/syncdaemon/filesystem_manager.py	2015-09-17 02:20:40 +0000
+++ ubuntuone/syncdaemon/filesystem_manager.py	2015-09-19 23:19:46 +0000
@@ -198,7 +198,7 @@
 
 class ShareNodeDict(dict):
     """Cache for node_id and share."""
-    # pylint: disable-msg=W0612
+
     def __getitem__(self, key):
         share_id, node_id = key
         if node_id is None:
@@ -337,8 +337,8 @@
             # ensure that we can write in the partials_dir
             set_dir_readwrite(self.partials_dir)
         self.fs = TritcaskShelf(FSM_ROW_TYPE, db)
-        self.old_fs = file_shelf.CachedFileShelf(fsmdir, cache_size=1500,
-                                             cache_compact_threshold=4)
+        self.old_fs = file_shelf.CachedFileShelf(
+            fsmdir, cache_size=1500, cache_compact_threshold=4)
         self.trash = TrashTritcaskShelf(TRASH_ROW_TYPE, db)
         self.move_limbo = TrashTritcaskShelf(MOVE_LIMBO_ROW_TYPE, db)
         self.shares = {}
@@ -415,8 +415,8 @@
            base_path.endswith('Magicicada/Shared With Me'):
             realpath = os.path.realpath(mdobj['path'])
             mdobj['path'] = realpath
-        if base_path.startswith('/') and \
-            base_path.endswith('Magicicada') and name == 'My Files':
+        if (base_path.startswith('/') and base_path.endswith('Magicicada')
+                and name == 'My Files'):
             mdobj['path'] = base_path
 
     def _migrate_trash_to_tritcask(self):
@@ -766,7 +766,7 @@
         for _, v in self.fs.items():
             if v['node_id']:
                 all_data.append(
-                        (v['share_id'], v['node_id'], v['server_hash']))
+                    (v['share_id'], v['node_id'], v['server_hash']))
         return all_data
 
     def get_for_server_rescan_by_path(self, base_path):
@@ -842,7 +842,6 @@
         from_context = self._enable_share_write(mdobj['share_id'], path_from)
         to_context = self._enable_share_write(new_share_id, path_to)
 
-        # pylint: disable-msg=W0704
         if mdobj["is_dir"]:
             expected_event = "FS_DIR_MOVE"
         else:
@@ -866,7 +865,7 @@
         path_to = normpath(path_to)
         mdid = self._idx_path.pop(path_from)
         log_debug("move_file: mdid=%r path_from=%r path_to=%r",
-                                                    mdid, path_from, path_to)
+                  mdid, path_from, path_to)
 
         # if the move overwrites other file, send it to trash
         if path_to in self._idx_path:
@@ -887,7 +886,6 @@
         mdobj["info"]["last_moved_from"] = path_from
         mdobj["info"]["last_moved_time"] = time.time()
         # we try to stat, if we fail, so what?
-        #pylint: disable-msg=W0704
         try:
             mdobj["stat"] = stat_path(path_to)  # needed if not the same FS
         except OSError:
@@ -968,8 +966,8 @@
                     # not empty, need to check if we can delete it
                     subtree = self._delete_dir_tree(path=path)
                     for p, is_dir in subtree:
-                        filter_name = "FS_DIR_DELETE" if is_dir \
-                                                      else "FS_FILE_DELETE"
+                        filter_name = (
+                            "FS_DIR_DELETE" if is_dir else "FS_FILE_DELETE")
                         self.eq.add_to_mute_filter(filter_name, path=p)
                         self.delete_metadata(p)
 
@@ -1031,7 +1029,7 @@
                     raise
 
         for p, is_dir in self.get_paths_starting_with(
-        path, include_base=False):
+                path, include_base=False):
             if is_dir:
                 # remove inotify watch
                 try:
@@ -1180,7 +1178,6 @@
         log_debug("remove_partial: path=%r mdid=%r share_id=%r node_id=%r",
                   path, mdid, share_id, node_id)
         partial_path = self._get_partial_path(mdobj)
-        #pylint: disable-msg=W0704
         try:
             # don't alert EQ, partials are in other directory, not watched
             remove_file(partial_path)
@@ -1289,8 +1286,8 @@
             for p, m in self._idx_path.iteritems():
                 if os.path.dirname(p) == path and p != path:
                     mdobj = self.fs[m]
-                    yield (os.path.basename(p), mdobj["is_dir"],
-                                                            mdobj["node_id"])
+                    yield (
+                        os.path.basename(p), mdobj["is_dir"], mdobj["node_id"])
 
         return sorted(_get_all())
 
@@ -1309,7 +1306,6 @@
         if path == share.path:
             # the relaitve path is the fullpath
             return share.path
-        # pylint: disable-msg=W0612
         head, sep, tail = path.rpartition(share.path)
         if sep == '':
             raise ValueError("'%s' isn't a child of '%s'" % (path, share.path))
@@ -1375,10 +1371,9 @@
                 mdobj = self.fs[m]
                 # ignore shares that are not root (root is id='')
                 # and ignore files not present on the server
-                if ((ignore_shares and
-                    mdobj["share_id"] != '' and
-                    mdobj["share_id"] in self.vm.shares)
-                    or not mdobj["server_hash"]):
+                if ((ignore_shares and mdobj["share_id"] != '' and
+                        mdobj["share_id"] in self.vm.shares) or
+                        not mdobj["server_hash"]):
                     continue
                 if pattern.search(p):
                     yield p

=== modified file 'ubuntuone/syncdaemon/filesystem_notifications.py'
--- ubuntuone/syncdaemon/filesystem_notifications.py	2012-07-17 11:36:12 +0000
+++ ubuntuone/syncdaemon/filesystem_notifications.py	2015-09-19 23:19:46 +0000
@@ -43,9 +43,9 @@
     """Processor that takes care of dealing with the events."""
 
     def __init__(self, monitor, handle_dir_delete, name_translations,
-            platform_is_ignored, ignore_mask, ignore_config=None):
-        self.log = logging.getLogger('ubuntuone.SyncDaemon.'
-            + 'filesystem_notifications.GeneralProcessor')
+                 platform_is_ignored, ignore_mask, ignore_config=None):
+        self.log = logging.getLogger(
+            'ubuntuone.SyncDaemon.filesystem_notifications.GeneralProcessor')
         self.log.setLevel(TRACE)
         self.invnames_log = logging.getLogger(
             'ubuntuone.SyncDaemon.InvalidNames')
@@ -97,8 +97,8 @@
 
     def get_paths_starting_with(self, path, include_base=True):
         """Return all the paths that start with the given one."""
-        return self.monitor.fs.get_paths_starting_with(path,
-            include_base=False)
+        return self.monitor.fs.get_paths_starting_with(
+            path, include_base=False)
 
     def rm_watch(self, path):
         """Remove the watch for the given path."""
@@ -185,8 +185,8 @@
         else:
             - push the here received events, return False
         """
-        self.log.trace("Freeze commit: %r (%d events)",
-            self.frozen_path, len(events))
+        self.log.trace(
+            "Freeze commit: %r (%d events)", self.frozen_path, len(events))
         if self.frozen_evts:
             # ouch! we're dirty!
             self.log.debug("Dirty by %s", self.frozen_evts)

=== modified file 'ubuntuone/syncdaemon/fsm/fsm.py'
--- ubuntuone/syncdaemon/fsm/fsm.py	2012-04-09 20:07:05 +0000
+++ ubuntuone/syncdaemon/fsm/fsm.py	2015-09-19 23:19:46 +0000
@@ -83,7 +83,6 @@
     """
     items = varlist.items()
     keys = [x[0] for x in items]
-    # pylint: disable-msg=W0631
     values = [x[1] for x in items]
 
     possible_states = [dict(zip(keys, state))
@@ -150,7 +149,6 @@
         elif af == "pass":
             self.log.debug("passing")
         else:
-            # pylint: disable-msg=W0703
             self.log.info("Calling %s (got %s:%s)",
                           action_func_name, event_name, parameters)
             try:
@@ -165,19 +163,18 @@
         try:
             out_state = self.get_state()
         except KeyError:
-            self.log.error("from state %s on %s:%s, "
-                "cant find current out state: %s" % (
-                    enter_state.values, event_name, parameters,
-                    self.get_state_values()))
+            self.log.error(
+                "from state %s on %s:%s, cant find current out state: %s",
+                enter_state.values, event_name, parameters,
+                self.get_state_values())
             self.on_error(event_name, parameters)
             raise KeyError("unknown out state")
 
         if out_state.values != transition.target:
             self.log.error(
-                "in state %s with event %s:%s, out state is:"
-                "%s and should be %s" % (
-                enter_state.values, event_name, parameters,
-                out_state.values, transition.target))
+                "in state %s with event %s:%s, out state is: %s and should "
+                "be %s", enter_state.values, event_name, parameters,
+                out_state.values, transition.target)
             raise ValueError("Incorrect out state")
         self.log.debug("Called %s", action_func_name)
         return action_func_name
@@ -218,8 +215,6 @@
                 spec = fsm_parser.parse(input_data)
             elif input_data.endswith(".py"):
                 result = {}
-                # pylint doesnt like exec
-                # pylint: disable-msg=W0122
                 exec open(input_data) in result
                 spec = result["state_machine"]
             else:
@@ -250,9 +245,10 @@
                 try:
                     value = state[kind][name]
                 except KeyError:
-                    self.errors.append(ValidationError(
-                        "variable name '%s' not found in section %s" % (
-                           name, kind)))
+                    err = ValidationError(
+                        "variable name '%s' not found in section %s" %
+                        (name, kind))
+                    self.errors.append(err)
                 else:
                     if str(value).strip() == "=" and kind != "STATE_OUT":
                         self.errors.append(ValidationError(
@@ -298,7 +294,7 @@
 
         # build transitions
         for event_name, lines in self.spec["events"].items():
-            if self.event_filter and not event_name in self.event_filter:
+            if self.event_filter and event_name not in self.event_filter:
                 continue
             event = Event(event_name, lines, self)
             self.events[event_name] = event
@@ -309,18 +305,17 @@
                     state = self.states[hash_dict(transition.source)]
                 except KeyError:
                     continue
-                    # pylint: disable-msg=W0101
                     # we dont error, so * that cover invalid states still work
                     # XXX: lucio.torre:
                     # we should check that if the transition
                     # is not expanded or all the states it covers are
                     # invalid, because this is an error
                     self.errors.append(
-                        ValidationError("Transitiont on %s with %s from '%s'"
-                                          "cant find source state." % (
-                                            transition.event,
-                                            transition.parameters,
-                                            transition.source)))
+                        ValidationError(
+                            "Transitiont on %s with %s from '%s'cant find "
+                            "source state." % (transition.event,
+                                               transition.parameters,
+                                               transition.source)))
                     continue
                 s = {}
                 s.update(transition.source)
@@ -328,18 +323,18 @@
                 try:
                     tracker.remove(s)
                 except ValueError:
-                    self.errors.append(ValidationError(
-                        "For event %s, the following transition was "
-                                          "already covered: %s" % (
-                                            event, transition)))
+                    self.errors.append(
+                        ValidationError(
+                            "For event %s, the following transition was "
+                            "already covered: %s" % (event, transition)))
                 else:
                     state.add_transition(transition)
             if tracker.empty():
                 for s in tracker.pending:
-                    self.errors.append(ValidationError(
-                        "The following state x parameters where "
-                                      "not covered for '%s': %s" % (
-                                        event, s)))
+                    self.errors.append(
+                        ValidationError(
+                            "The following state x parameters where not "
+                            "covered for '%s': %s" % (event, s)))
 
     def get_state(self, vars_dict):
         """Get a state instance from a dict with {varname:value}"""
@@ -394,7 +389,7 @@
                     if k in invalid:
                         invalid.remove(k)
 
-        #remove invalids from lines
+        # remove invalids from lines
         for line in lines:
             for inv in invalid:
                 if inv in line["PARAMETERS"]:
@@ -418,7 +413,7 @@
                         if sxp[k] != v:
                             break
                     else:
-                        if not sxp in toremove:
+                        if sxp not in toremove:
                             toremove.append(sxp)
 
         map(self.state_x_params.remove, toremove)
@@ -506,7 +501,7 @@
     def __str__(self):
         """___str___"""
         return "<Transition: %s: %s x %s>" % (
-                self.event, self.source, self.parameters)
+            self.event, self.source, self.parameters)
 
 
 class State(object):

=== modified file 'ubuntuone/syncdaemon/fsm/fsm_parser.py'
--- ubuntuone/syncdaemon/fsm/fsm_parser.py	2013-02-20 22:47:25 +0000
+++ ubuntuone/syncdaemon/fsm/fsm_parser.py	2015-09-19 23:19:46 +0000
@@ -78,7 +78,6 @@
 if "HAS_OOFFICE" in os.environ:
     # we have to do this because python-uno breaks mocker
     import uno
-    # pylint: disable-msg=F0401
     from com.sun.star.connection import NoConnectException
     from com.sun.star.lang import IndexOutOfBoundsException
     from com.sun.star.container import NoSuchElementException
@@ -100,7 +99,7 @@
             """Create a reader"""
             local = uno.getComponentContext()
             resolver = local.ServiceManager.createInstanceWithContext(
-                                "com.sun.star.bridge.UnoUrlResolver", local)
+                "com.sun.star.bridge.UnoUrlResolver", local)
 
             try:
                 context = resolver.resolve(
@@ -110,11 +109,11 @@
                 raise Exception(CONNECT_MSG)
 
             desktop = context.ServiceManager.createInstanceWithContext(
-                                        "com.sun.star.frame.Desktop", context)
+                "com.sun.star.frame.Desktop", context)
 
             cwd = systemPathToFileUrl(os.getcwd())
-            file_url = absolutize(cwd, systemPathToFileUrl(
-                    os.path.join(os.getcwd(), filename)))
+            file_url = absolutize(
+                cwd, systemPathToFileUrl(os.path.join(os.getcwd(), filename)))
             in_props = PropertyValue("Hidden", 0, True, 0),
             document = desktop.loadComponentFromURL(
                 file_url, "_blank", 0, in_props)
@@ -184,7 +183,7 @@
             while True:
                 cells = [
                     self.invalid.getCellByPosition(x, iter_line).getFormula()
-                                            for x in xrange(line_length)]
+                    for x in xrange(line_length)]
                 if not any(cells):
                     break
 
@@ -283,12 +282,12 @@
                 afunc = row[action_func_idx]
                 p += 1
                 states.append(dict(STATE=st, STATE_OUT=st_out, PARAMETERS=vars,
-                                ACTION=act, COMMENTS=comm, ACTION_FUNC=afunc))
+                              ACTION=act, COMMENTS=comm, ACTION_FUNC=afunc))
             events[event_name] = states
 
         # build invalid state list
         invalid = ods.get_invalid()
-        invalid = [dict(zip(invalid[0], row)) for row in invalid[1:]]
+        invalid = [dict(zip(invalid[0], r)) for r in invalid[1:]]
 
         return dict(events=events, state_vars=state_vars,
                     parameters=parameters, invalid=invalid)
@@ -311,9 +310,7 @@
         if options.output:
             f = open(options.output, "w")
             data = pprint.pformat(result)
-            f.write("\"\"\"This is a generated python file\"\"\"\n"
-                    "# make pylint accept this\n"
-                    "# pylint: disable-msg=C0301\n"
+            f.write("\"\"\"This is a generated python file.\"\"\"\n"
                     "state_machine = %s""" % data)
             f.close()
         else:

=== modified file 'ubuntuone/syncdaemon/hash_queue.py'
--- ubuntuone/syncdaemon/hash_queue.py	2012-04-09 20:07:05 +0000
+++ ubuntuone/syncdaemon/hash_queue.py	2015-09-19 23:19:46 +0000
@@ -130,8 +130,9 @@
             except (IOError, OSError), e:
                 m = "Hasher: hash error %s  (path %r  mdid %s)"
                 self.logger.debug(m, e, path, mdid)
-                reactor.callLater(.1, reactor.callFromThread, self.eq.push,
-                                                    "HQ_HASH_ERROR", mdid=mdid)
+                reactor.callLater(
+                    .1, reactor.callFromThread, self.eq.push,
+                    "HQ_HASH_ERROR", mdid=mdid)
             except StopHashing, e:
                 self.logger.debug(str(e))
             else:

=== modified file 'ubuntuone/syncdaemon/interfaces.py'
--- ubuntuone/syncdaemon/interfaces.py	2012-04-09 20:08:42 +0000
+++ ubuntuone/syncdaemon/interfaces.py	2015-09-19 23:19:46 +0000
@@ -30,8 +30,6 @@
 
 from zope.interface import Interface, Attribute
 
-# pylint: disable-msg=W0232,E0213,E0211
-
 
 class IContentQueue(Interface):
     """

=== modified file 'ubuntuone/syncdaemon/local_rescan.py'
--- ubuntuone/syncdaemon/local_rescan.py	2012-08-31 17:15:53 +0000
+++ ubuntuone/syncdaemon/local_rescan.py	2015-09-19 23:19:46 +0000
@@ -112,8 +112,8 @@
         for vol in to_scan:
             # check that the path exists in disk
             if not path_exists(vol.path):
-                log_warning('Volume dissapeared: %r - %r',
-                    vol.volume_id, vol.path)
+                log_warning(
+                    'Volume dissapeared: %r - %r', vol.volume_id, vol.path)
                 if isinstance(vol, volume_manager.Share):
                     log_debug('Removing %r metadata', vol.volume_id)
                     self.vm.share_deleted(vol.volume_id)
@@ -149,7 +149,7 @@
         """
         try:
             partials = listdir(self.fsm.partials_dir)
-        except OSError, e:
+        except OSError as e:
             if e.errno != errno.ENOENT:
                 raise
             # no partials dir at all
@@ -164,8 +164,8 @@
         """Process the FSM limbos and send corresponding AQ orders."""
         log_info("processing trash")
         trash_log = "share_id=%r  parent_id=%r  node_id=%r  path=%r"
-        for share_id, node_id, parent_id, path, is_dir in \
-                                                self.fsm.get_iter_trash():
+        for item in self.fsm.get_iter_trash():
+            share_id, node_id, parent_id, path, is_dir = item
             datalog = trash_log % (share_id, parent_id, node_id, path)
             if IMarker.providedBy(node_id) or IMarker.providedBy(parent_id):
                 # situation where the node is not in the server
@@ -181,7 +181,7 @@
         for data in self.fsm.get_iter_move_limbo():
             to_log = move_log % data
             (share_id, node_id, old_parent_id, new_parent_id, new_name,
-                                                    path_from, path_to) = data
+             path_from, path_to) = data
             maybe_markers = (share_id, node_id, old_parent_id, new_parent_id)
             if any(IMarker.providedBy(x) for x in maybe_markers):
                 # situation where the move was not ready
@@ -190,7 +190,7 @@
                 continue
             log_info("generating Move from limbo: " + to_log)
             self.aq.move(share_id, node_id, old_parent_id,
-                    new_parent_id, new_name, path_from, path_to)
+                         new_parent_id, new_name, path_from, path_to)
 
     def _process_ro_shares(self):
         """Process ro shares and reschedule interrupted downloads."""
@@ -205,8 +205,8 @@
                     if mdobj.is_dir:
                         # old state, no sense now with generations
                         # but required for the migration path.
-                        log_warning("Found a directory in SERVER: %r",
-                            fullname)
+                        log_warning(
+                            "Found a directory in SERVER: %r", fullname)
                         mdobj = self.fsm.get_by_path(fullname)
                         self.fsm.set_by_mdid(mdobj.mdid,
                                              server_hash=mdobj.local_hash)
@@ -262,7 +262,6 @@
             log_error(m)
             raise ValueError(m)
 
-        # No, 'share' is surely defined; pylint: disable-msg=W0631
         self._queue.appendleft((share, direct, mdid, udfmode))
         return self._queue_scan()
 
@@ -307,8 +306,7 @@
                         return
 
                 self._scan_tree(*scan_info)
-            # pylint: disable-msg=W0703
-            except Exception, e:
+            except Exception as e:
                 self._previous_deferred.errback(e)
 
         reactor.callLater(0, safe_scan)
@@ -337,7 +335,7 @@
             if failure.check(ScanTransactionDirty):
                 reason = failure.getErrorMessage()
                 log_debug("re queue, transaction dirty for %r, reason: %s",
-                                                                  path, reason)
+                          path, reason)
                 self._queue.appendleft((share, path, mdid, udfmode))
             elif failure.check(OSError, IOError):
                 reason = failure.getErrorMessage()
@@ -410,7 +408,6 @@
             # if asked, remove metadata por children
             if also_children:
                 log_debug("Removing metadata for %r children", fullname)
-                # pylint: disable-msg=W0612
                 children = self.fsm.get_paths_starting_with(fullname, False)
                 for path, is_dir in children:
                     self.fsm.delete_metadata(path)
@@ -426,7 +423,7 @@
                 try:
                     log_info("Also remove %r", also_remove)
                     remove_file(also_remove)
-                except OSError, e:
+                except OSError as e:
                     if e.errno != errno.ENOENT:
                         raise
 
@@ -555,8 +552,8 @@
                 to_inform = []
 
                 # get all the info inside that dir
-                objs = self.fsm.get_mdobjs_by_share_id(share.volume_id,
-                    fullname)
+                objs = self.fsm.get_mdobjs_by_share_id(
+                    share.volume_id, fullname)
                 for obj in objs:
                     shrpath = obj.path
                     qparts = len(shrpath.split(os.path.sep))

=== modified file 'ubuntuone/syncdaemon/logger.py'
--- ubuntuone/syncdaemon/logger.py	2012-08-28 14:34:26 +0000
+++ ubuntuone/syncdaemon/logger.py	2015-09-19 23:19:46 +0000
@@ -52,7 +52,6 @@
 TRACE = logger.TRACE
 
 
-# pylint: disable=C0103
 class mklog(object):
     """
     Create a logger that keeps track of the method where it's being
@@ -67,7 +66,8 @@
         all_args = []
         for arg in args:
             all_args.append(
-              repr(arg).decode('ascii', 'replace').encode('ascii', 'replace'))
+                repr(arg).decode('ascii', 'replace').encode('ascii', 'replace')
+            )
         for k, v in kwargs.items():
             v = repr(v).decode('ascii', 'replace').encode('ascii', 'replace')
             all_args.append("%s=%r" % (k, v))
@@ -137,13 +137,12 @@
             return failure
         return callback, errback
 
-# pylint: enable=C0103
 LOGFILENAME = os.path.join(ubuntuone_log_dir, 'syncdaemon.log')
 EXLOGFILENAME = os.path.join(ubuntuone_log_dir, 'syncdaemon-exceptions.log')
-INVALIDLOGFILENAME = os.path.join(ubuntuone_log_dir,
-    'syncdaemon-invalid-names.log')
-BROKENLOGFILENAME = os.path.join(ubuntuone_log_dir,
-    'syncdaemon-broken-nodes.log')
+INVALIDLOGFILENAME = os.path.join(
+    ubuntuone_log_dir, 'syncdaemon-invalid-names.log')
+BROKENLOGFILENAME = os.path.join(
+    ubuntuone_log_dir, 'syncdaemon-broken-nodes.log')
 
 
 root_logger = logging.getLogger("ubuntuone.SyncDaemon")
@@ -305,7 +304,6 @@
 def rotate_logs():
     """do a rollover of the three handlers"""
     # ignore the missing file error on a failed rollover
-    # pylint: disable-msg=W0704
     try:
         root_handler.doRollover()
     except OSError:

=== modified file 'ubuntuone/syncdaemon/offload_queue.py'
--- ubuntuone/syncdaemon/offload_queue.py	2012-04-09 20:08:42 +0000
+++ ubuntuone/syncdaemon/offload_queue.py	2015-09-19 23:19:46 +0000
@@ -44,7 +44,7 @@
 
     # limits for file rotation...
     # after the soft limit, we'll rotate if queue is short enough
-    _rotation_soft_limit =  2 * 1024 ** 3
+    _rotation_soft_limit = 2 * 1024 ** 3
     # if the queue is shorter than this, we'll rotate after the soft limit
     _rotation_too_big_size = 50 * 1024 ** 2
     # rotate if file gets larger than this, no matter the queue size
@@ -69,7 +69,7 @@
         # fallback to memory if something goes wrong when using disk
         self._in_memory = False
 
-    def  __len__(self):
+    def __len__(self):
         return self._len
 
     def push(self, item):
@@ -91,7 +91,7 @@
         self._tempfile_size += len(data) + STRUCT_SIZE
         self._rotate()
 
-    def  _handle_bad_write(self, data):
+    def _handle_bad_write(self, data):
         """Support a bad write, go to memory and continue."""
         self.log.exception("Crashed while writing")
 
@@ -135,7 +135,7 @@
         # the file is big, let's check if we would need to copy too much data
         if queuesize > self._rotation_too_big_size:
             # avoid rotation only if file size is still below the hard limit
-             if filesize < self._rotation_hard_limit:
+            if filesize < self._rotation_hard_limit:
                 return
 
         # rotate to a new file

=== modified file 'ubuntuone/syncdaemon/states.py'
--- ubuntuone/syncdaemon/states.py	2012-04-09 20:07:05 +0000
+++ ubuntuone/syncdaemon/states.py	2015-09-19 23:19:46 +0000
@@ -143,7 +143,7 @@
             self.log.debug("Setting up the 'waiting' timer on %d secs",
                            self.waiting_timeout)
             self._waiting_timer = reactor.callLater(self.waiting_timeout,
-                                                   self._waiting_timeout)
+                                                    self._waiting_timeout)
 
         elif new_node in self._handshake_nodes:
             self.log.debug("Setting up the 'handshake' timer on %d secs",
@@ -215,8 +215,8 @@
 
     def __repr__(self):
         return "<Node %s (%s) error=%s connected=%s online=%s" % (
-                self.name, self.description, self.is_error,
-                self.is_connected, self.is_online)
+            self.name, self.description, self.is_error, self.is_connected,
+            self.is_online)
 
 
 class StateInfo(Node):
@@ -227,9 +227,11 @@
         self.connection_state = conn.state
 
     def __repr__(self):
-        return "%s (error=%s connected=%s online=%s)  Queue: %s  "\
-               "Connection: %s" % (self.name, self.is_error, self.is_connected,
-               self.is_online, self.queue_state, self.connection_state)
+        return (
+            "%s (error=%s connected=%s online=%s)  Queue: %s  Connection: "
+            "%s" % (self.name, self.is_error, self.is_connected,
+                    self.is_online, self.queue_state, self.connection_state))
+
     __str__ = __repr__
 
 
@@ -362,23 +364,19 @@
             (self.READY, 'SYS_CONNECTION_MADE'): _from_ready,
             (self.READY, 'SYS_CONNECTION_FAILED'): self.WAITING,
             (self.WAITING, 'SYS_CONNECTION_RETRY'): self.READY,
-
-            (self.CHECK_VERSION, 'SYS_PROTOCOL_VERSION_OK'):
-                                                    self.SET_CAPABILITIES,
-            (self.CHECK_VERSION, 'SYS_PROTOCOL_VERSION_ERROR'):
-                                                    self.BAD_VERSION,
+            (self.CHECK_VERSION,
+             'SYS_PROTOCOL_VERSION_OK'): self.SET_CAPABILITIES,
+            (self.CHECK_VERSION,
+             'SYS_PROTOCOL_VERSION_ERROR'): self.BAD_VERSION,
             (self.CHECK_VERSION, 'SYS_SERVER_ERROR'): self.STANDOFF,
-
-            (self.SET_CAPABILITIES, 'SYS_SET_CAPABILITIES_OK'):
-                                                    self.AUTHENTICATE,
-            (self.SET_CAPABILITIES, 'SYS_SET_CAPABILITIES_ERROR'):
-                                                    self.CAPABILITIES_MISMATCH,
+            (self.SET_CAPABILITIES,
+             'SYS_SET_CAPABILITIES_OK'): self.AUTHENTICATE,
+            (self.SET_CAPABILITIES,
+             'SYS_SET_CAPABILITIES_ERROR'): self.CAPABILITIES_MISMATCH,
             (self.SET_CAPABILITIES, 'SYS_SERVER_ERROR'): self.STANDOFF,
-
             (self.AUTHENTICATE, 'SYS_AUTH_OK'): self.SERVER_RESCAN,
             (self.AUTHENTICATE, 'SYS_AUTH_ERROR'): self.AUTH_FAILED,
             (self.AUTHENTICATE, 'SYS_SERVER_ERROR'): self.STANDOFF,
-
             (self.SERVER_RESCAN, 'SYS_SERVER_RESCAN_DONE'): self.QUEUE_MANAGER,
             (self.SERVER_RESCAN, 'SYS_SERVER_ERROR'): self.STANDOFF,
         }
@@ -497,8 +495,8 @@
         self.eq.push('SYS_STATE_CHANGED', state=info)
 
     def __str__(self):
-        return "<State: %r  (queues %s  connection %r)>" % (self.state.name,
-                                self.queues.state.name, self.connection.state)
+        return "<State: %r  (queues %s  connection %r)>" % (
+            self.state.name, self.queues.state.name, self.connection.state)
 
     def shutdown(self):
         """Finish all pending work."""

=== modified file 'ubuntuone/syncdaemon/status_listener.py'
--- ubuntuone/syncdaemon/status_listener.py	2012-10-24 08:54:12 +0000
+++ ubuntuone/syncdaemon/status_listener.py	2015-09-19 23:19:46 +0000
@@ -58,7 +58,7 @@
         return None
 
 
-#TODO: hookup the shutdown of the listener to the cleanup in the aggregator
+# TODO: hookup the shutdown of the listener to the cleanup in the aggregator
 class StatusListener(object):
     """SD listener for EQ events that turns them into status updates."""
 
@@ -94,7 +94,6 @@
     show_all_notifications = property(get_show_all_notifications,
                                       set_show_all_notifications)
 
-    # pylint: disable=W0613
     def handle_AQ_CHANGE_PUBLIC_ACCESS_OK(self, share_id, node_id, is_public,
                                           public_url):
         """The status of a published resource changed."""
@@ -114,7 +113,6 @@
         """Progress has been made on an upload."""
         self.status_frontend.progress_made(
             share_id, node_id, n_bytes_read, deflated_size)
-    # pylint: enable=W0613
 
     def handle_SYS_QUEUE_ADDED(self, command):
         """A command has been added to the queue."""

=== modified file 'ubuntuone/syncdaemon/sync.py'
--- ubuntuone/syncdaemon/sync.py	2012-10-03 19:35:40 +0000
+++ ubuntuone/syncdaemon/sync.py	2015-09-19 23:19:46 +0000
@@ -68,15 +68,13 @@
         if self.mdid is not None:
             return self.mdid
         if len(self.keys) == 1 and "path" in self.keys:
-            # pylint: disable-msg=W0212
             mdid = self.fs._idx_path[self.keys["path"]]
         elif len(self.keys) == 1 and "mdid" in self.keys:
             mdid = self.keys["mdid"]
-        elif len(self.keys) == 2 and "node_id" in self.keys \
-                    and "share_id" in self.keys:
-            # pylint: disable-msg=W0212
-            mdid = self.fs._idx_node_id[self.keys["share_id"],
-                                                        self.keys["node_id"]]
+        elif (len(self.keys) == 2 and "node_id" in self.keys and
+                "share_id" in self.keys):
+            k = (self.keys["share_id"], self.keys["node_id"])
+            mdid = self.fs._idx_node_id[k]
         else:
             raise KeyError("Incorrect keys: %s" % self.keys)
         if mdid is None:
@@ -194,7 +192,6 @@
 
     def remove_partial(self):
         """Remove a partial file."""
-        # pylint: disable-msg=W0704
         try:
             self.fs.remove_partial(self["node_id"], self["share_id"])
         except ValueError:
@@ -208,7 +205,6 @@
     def safe_get(self, key, default='^_^'):
         """Safe version of self.get, to be used in the FileLogger."""
         # catch all errors as we are here to help logging
-        # pylint: disable-msg=W0703
         try:
             return self.get(key)
         except Exception:
@@ -256,12 +252,10 @@
                  "[%(share_id)r::%(node_id)r] '%(path)r' | %(message)s"
         exc_info = sys.exc_info
         if self.key.has_metadata() == "T":
-            # catch all errors as we are logging, pylint: disable-msg=W0703
+            # catch all errors as we are logging
             try:
-                # pylint: disable-msg=W0212
                 base = os.path.split(self.key.fs._get_share(
                     self.key['share_id']).path)[1]
-                # pylint: disable-msg=W0212
                 path = os.path.join(base, self.key.fs._share_relative_path(
                     self.key['share_id'], self.key['path']))
             except Exception:
@@ -312,15 +306,14 @@
 
     def on_event(self, *args, **kwargs):
         """Override on_event to capture the debug log"""
-        in_state = '%(hasmd)s:%(changed)s:%(isdir)s' % \
-                dict(hasmd=self.key.has_metadata(),
-                     isdir=self.key.is_directory(),
-                     changed=self.key.changed())
+        kw = dict(
+            hasmd=self.key.has_metadata(), isdir=self.key.is_directory(),
+            changed=self.key.changed())
+        in_state = '%(hasmd)s:%(changed)s:%(isdir)s' % kw
         is_debug = self.log.logger.isEnabledFor(logging.DEBUG)
         with DebugCapture(self.log.logger):
             func_name = super(SyncStateMachineRunner, self).on_event(*args,
                                                                      **kwargs)
-
             if not is_debug:
                 self.log.info("Called %s (In: %s)" % (func_name, in_state))
 
@@ -394,7 +387,7 @@
 
         if volume.generation is None or new_generation is None:
             self.log.debug("Client not ready for generations! vol gen: %r, "
-                             "new gen: %r", volume.generation, new_generation)
+                           "new gen: %r", volume.generation, new_generation)
             return
 
         if new_generation <= volume.generation:
@@ -447,7 +440,7 @@
         """This file is in conflict."""
         self.key.move_to_conflict()
         self.m.action_q.cancel_upload(share_id=self.key['share_id'],
-                            node_id=self.key['node_id'])
+                                      node_id=self.key['node_id'])
         self.get_file(event, params, hash)
 
     def new_file(self, event, params, share_id, node_id, parent_id, name):
@@ -482,7 +475,7 @@
         self.key.set(server_hash=hash)
         self.key.sync()
         self.m.action_q.cancel_download(share_id=self.key['share_id'],
-                            node_id=self.key['node_id'])
+                                        node_id=self.key['node_id'])
         self.key.remove_partial()
         self.get_file(event, params, hash)
 
@@ -519,7 +512,7 @@
         self.key.set(server_hash=hash)
         self.key.sync()
         self.m.action_q.cancel_download(share_id=self.key['share_id'],
-                            node_id=self.key['node_id'])
+                                        node_id=self.key['node_id'])
         self.key.remove_partial()
 
     def commit_file(self, event, params, hash):
@@ -618,7 +611,8 @@
         node_id = self.key['node_id']
         previous_hash = self.key['server_hash']
         upload_id = self.key.get('upload_id')
-        self.key.set(local_hash=current_hash, stat=stat, crc32=crc32, size=size)
+        self.key.set(
+            local_hash=current_hash, stat=stat, crc32=crc32, size=size)
         self.key.sync()
 
         self.m.action_q.upload(share_id, node_id, previous_hash, current_hash,
@@ -627,7 +621,7 @@
     def converges_to_server(self, event, params, hash, crc32, size, stat):
         """the local changes now match the server"""
         self.m.action_q.cancel_download(share_id=self.key['share_id'],
-                    node_id=self.key['node_id'])
+                                        node_id=self.key['node_id'])
         self.key.remove_partial()
         self.key.set(local_hash=hash, stat=stat)
         self.key.sync()
@@ -635,7 +629,7 @@
     def reput_file_from_ok(self, event, param, hash):
         """put the file again, mark upload as ok"""
         self.m.action_q.cancel_upload(share_id=self.key['share_id'],
-                            node_id=self.key['node_id'])
+                                      node_id=self.key['node_id'])
         self.key.set(local_hash=hash)
         self.key.set(server_hash=hash)
         self.key.sync()
@@ -644,14 +638,14 @@
     def reput_file(self, event, param, current_hash, crc32, size, stat):
         """Put the file again."""
         self.m.action_q.cancel_upload(share_id=self.key['share_id'],
-                            node_id=self.key['node_id'])
+                                      node_id=self.key['node_id'])
         previous_hash = self.key['server_hash']
 
         share_id = self.key['share_id']
         node_id = self.key['node_id']
         upload_id = self.key.get('upload_id')
         self.key.set(local_hash=current_hash, stat=stat,
-                      crc32=crc32, size=size)
+                     crc32=crc32, size=size)
         self.key.sync()
         mdid = self.key.get_mdid()
         self.m.action_q.upload(share_id, node_id, previous_hash, current_hash,
@@ -660,7 +654,7 @@
     def server_file_now_matches(self, event, params, hash):
         """We got a server hash that matches local hash"""
         self.m.action_q.cancel_upload(share_id=self.key['share_id'],
-                            node_id=self.key['node_id'])
+                                      node_id=self.key['node_id'])
         self.key.set(server_hash=hash)
         self.key.sync()
 
@@ -671,7 +665,7 @@
     def cancel_and_commit(self, event, params, hash):
         """Finish an upload."""
         self.m.action_q.cancel_download(share_id=self.key['share_id'],
-                            node_id=self.key['node_id'])
+                                        node_id=self.key['node_id'])
         self.key.remove_partial()
         self.key.upload_finished(hash)
 
@@ -698,7 +692,7 @@
     def file_gone_wile_downloading(self, event, params):
         """a file we were downloading is gone."""
         self.m.action_q.cancel_download(share_id=self.key['share_id'],
-                            node_id=self.key['node_id'])
+                                        node_id=self.key['node_id'])
         self.key.remove_partial()
         self.delete_file(event, params)
 
@@ -762,10 +756,10 @@
         self.key.move_file(new_share_id, new_parent_id, new_name)
 
     def server_moved_dirty(self, event, params, share_id, node_id,
-                     new_share_id, new_parent_id, new_name):
+                           new_share_id, new_parent_id, new_name):
         """file was moved on the server while downloading it"""
         self.m.action_q.cancel_download(share_id=self.key['share_id'],
-                            node_id=self.key['node_id'])
+                                        node_id=self.key['node_id'])
         self.key.remove_partial()
         self.key.move_file(new_share_id, new_parent_id, new_name)
         self.get_file(event, params, self.key['server_hash'])
@@ -773,7 +767,7 @@
     def moved_dirty_local(self, event, params, path_from, path_to):
         """file was moved while uploading it"""
         self.m.action_q.cancel_upload(share_id=self.key['share_id'],
-                            node_id=self.key['node_id'])
+                                      node_id=self.key['node_id'])
         self.key.set(local_hash=self.key['server_hash'])
         self.key.sync()
         self.client_moved(event, params, path_from, path_to)
@@ -783,16 +777,15 @@
         self.client_moved(event, params, path_from, path_to)
 
         self.m.action_q.cancel_download(share_id=self.key['share_id'],
-                            node_id=self.key['node_id'])
+                                        node_id=self.key['node_id'])
         self.key.remove_partial()
         self.key.set(server_hash=self.key['local_hash'])
         self.key.sync()
 
-    # pylint: disable-msg=C0103
     def DESPAIR(self, event, params, *args, **kwargs):
         """if we got here, we are in trouble"""
         self.log.error("DESPAIR on event=%s params=%s args=%s kwargs=%s",
-                                                event, params, args, kwargs)
+                       event, params, args, kwargs)
 
     def save_stat(self, event, params, hash, crc32, size, stat):
         """Save the stat"""
@@ -820,7 +813,7 @@
         # now that the DebugCapture is enabled
         self.logger = logging.getLogger('ubuntuone.SyncDaemon.sync')
         self.broken_logger = logging.getLogger(
-                                            'ubuntuone.SyncDaemon.BrokenNodes')
+            'ubuntuone.SyncDaemon.BrokenNodes')
         if Sync.fsm is None:
             Sync.fsm = StateMachine(u1fsfsm.state_machine)
         self.m = main
@@ -1094,7 +1087,7 @@
         ssmr.signal_event_with_error_and_hash("AQ_UPLOAD_ERROR", error, hash)
 
     def _handle_SV_MOVED(self, share_id, node_id, new_share_id, new_parent_id,
-                        new_name):
+                         new_name):
         """on SV_MOVED"""
         key = FSKey(self.m.fs, share_id=share_id, node_id=node_id)
         log = FileLogger(self.logger, key)
@@ -1228,7 +1221,7 @@
                 # if its a file, we only care about the hash
                 if not is_dir:
                     self._handle_SV_HASH_NEW(dt.share_id, dt.node_id,
-                                        dt.content_hash)
+                                             dt.content_hash)
 
                 # node updated, update generation
                 self.m.fs.set_by_mdid(node.mdid, generation=dt.generation)
@@ -1285,7 +1278,7 @@
             if node_id is None:
                 continue
 
-            if not node_id in live_nodes:
+            if node_id not in live_nodes:
                 self._handle_SV_FILE_DELETED(volume_id, node_id, node.is_dir)
                 deletes += 1
 

=== modified file 'ubuntuone/syncdaemon/tritcask.py'
--- ubuntuone/syncdaemon/tritcask.py	2013-02-12 23:21:50 +0000
+++ ubuntuone/syncdaemon/tritcask.py	2015-09-19 23:19:46 +0000
@@ -100,8 +100,9 @@
     """A Exception for Bad header value."""
 
 
-TritcaskEntry = namedtuple('TritcaskEntry', ['crc32', 'tstamp', 'key_sz',
-                         'value_sz', 'row_type', 'key', 'value', 'value_pos'])
+TritcaskEntry = namedtuple(
+    'TritcaskEntry', ['crc32', 'tstamp', 'key_sz', 'value_sz', 'row_type',
+                      'key', 'value', 'value_pos'])
 
 
 _HintEntry = namedtuple('_HintEntry', ['tstamp', 'key_sz', 'row_type',
@@ -329,7 +330,7 @@
         try:
             crc32 = crc32_struct.unpack(crc32_bytes)[0]
             tstamp, key_sz, value_sz, row_type = header_struct.unpack(header)
-        except struct.error, e:
+        except struct.error as e:
             raise BadHeader(e)
         key = fmmap[current_pos:current_pos + key_sz]
         current_pos += key_sz
@@ -430,8 +431,8 @@
         """raise NotImplementedError."""
         raise NotImplementedError
 
-    _open = close = read = write = make_immutable = make_zombie = \
-            __getitem__ = iter_entries = _not_implemented
+    _open = close = read = write = make_immutable = _not_implemented
+    make_zombie = __getitem__ = iter_entries = _not_implemented
 
 
 class TempDataFile(DataFile):
@@ -449,8 +450,8 @@
         new_name = self.filename.replace(self.temp_name, INACTIVE)
         rename(self.filename, new_name)
         if self.has_hint:
-            new_hint_name = self.hint_filename.replace(self.temp_name,
-                INACTIVE)
+            new_hint_name = self.hint_filename.replace(
+                self.temp_name, INACTIVE)
             rename(self.hint_filename, new_hint_name)
         return ImmutableDataFile(*os.path.split(new_name))
 
@@ -487,8 +488,8 @@
                 current_pos += hint_header_size
                 if header == '':
                     raise StopIteration
-                tstamp, key_sz, row_type, value_sz, value_pos = \
-                        hint_header_struct.unpack(header)
+                result = hint_header_struct.unpack(header)
+                tstamp, key_sz, row_type, value_sz, value_pos = result
                 key = fmap[current_pos:current_pos + key_sz]
                 current_pos += key_sz
                 yield HintEntry(tstamp, key_sz, row_type,
@@ -545,11 +546,11 @@
                 # update those stats too!
                 old_stats = self._stats[old_entry.file_id]
                 old_stats['live_entries'] -= 1
-                old_stats['live_bytes'] -= len(key[1]) + old_entry.value_sz \
-                        + header_size + crc32_size
-
-                new_bytes = len(key[1]) + entry.value_sz \
-                        + header_size + crc32_size
+                old_stats['live_bytes'] -= (
+                    len(key[1]) + old_entry.value_sz + header_size + crc32_size
+                )
+                new_bytes = (
+                    len(key[1]) + entry.value_sz + header_size + crc32_size)
                 # update the live entries in this file_id stats
                 live_entries = stats.get('live_entries', 0)
                 stats['live_entries'] = live_entries + 1
@@ -557,8 +558,8 @@
                 new_bytes = entry.value_sz - old_entry.value_sz
         except KeyError:
             # a new entry
-            new_bytes = len(key[1]) + entry.value_sz \
-                    + header_size + crc32_size
+            new_bytes = (
+                len(key[1]) + entry.value_sz + header_size + crc32_size)
             live_entries = stats.get('live_entries', 0)
             stats['live_entries'] = live_entries + 1
         live_bytes = stats.get('live_bytes', 0)
@@ -571,14 +572,14 @@
         # remove it from the keydir and update the stats
         entry = self.pop(key, None)
         # return if we don't have that key
-        if entry == None:
+        if entry is None:
             return
         try:
             stats = self._stats[entry.file_id]
-            stats['live_bytes'] -= len(key[1]) + entry.value_sz \
-                    + header_size + crc32_size
+            stats['live_bytes'] -= (
+                len(key[1]) + entry.value_sz + header_size + crc32_size)
             stats['live_entries'] -= 1
-        except KeyError, e:
+        except KeyError as e:
             logger.warning('Failed to update stats while removing %s with: %s',
                            key, e)
 
@@ -681,8 +682,8 @@
             # no info for the live file
             return False
         else:
-            return (live_file_stats['live_bytes'] / self.live_file.size) \
-                    < self.dead_bytes_threshold
+            return ((live_file_stats['live_bytes'] / self.live_file.size) <
+                    self.dead_bytes_threshold)
 
     def should_merge(self, immutable_files):
         """Check if the immutable_files should be merged."""
@@ -749,7 +750,7 @@
                     # it's an immutable file
                     data_file = ImmutableDataFile(self.base_path, filename)
                     self._immutable[data_file.file_id] = data_file
-            except IOError, e:
+            except IOError as e:
                 # oops, failed to open the file..discard it
                 broken_files += 1
                 orig = os.path.join(self.base_path, filename)
@@ -835,8 +836,8 @@
                 self._keydir.remove((entry.row_type, entry.key))
                 # add the tombstone entry to the hint
                 if build_hint:
-                    hint_entry = HintEntry.from_tritcask_entry(entry,
-                        dead=True)
+                    hint_entry = HintEntry.from_tritcask_entry(
+                        entry, dead=True)
                     hint_idx[hint_entry.key] = hint_entry
             else:
                 kd_entry = KeydirEntry.from_tritcask_entry(data_file.file_id,
@@ -866,8 +867,8 @@
             raise ValueError('key must be a str instance.')
         if not isinstance(value, str):
             raise ValueError('value must be a str instance.')
-        tstamp, value_pos, value_sz = self.live_file.write(row_type,
-            key, value)
+        tstamp, value_pos, value_sz = self.live_file.write(
+            row_type, key, value)
         if value != TOMBSTONE:
             kd_entry = KeydirEntry(self.live_file.file_id, tstamp,
                                    value_sz, value_pos)
@@ -977,7 +978,6 @@
     def __len__(self):
         """The len of the shelf."""
         counter = 0
-        # pylint: disable-msg=W0612
         for key in self.keys():
             counter += 1
         return counter

=== modified file 'ubuntuone/syncdaemon/u1fsfsm.py'
--- ubuntuone/syncdaemon/u1fsfsm.py	2011-10-14 20:02:23 +0000
+++ ubuntuone/syncdaemon/u1fsfsm.py	2015-09-19 23:19:46 +0000
@@ -1,6 +1,6 @@
 """This is a generated python file"""
-# make pylint accept this
-# pylint: disable-msg=C0301
+# make pylflakes accept this
+# noqa
 state_machine = {'events': {u'AQ_DIR_DELETE_ERROR': [{'ACTION': u'md.create(path=path, uuid=uuid, type=type) aq.query(uuid=uuid)',
                                       'ACTION_FUNC': u'',
                                       'COMMENTS': u'the user deleted something we couldnt delete from the server. Re create.',

=== modified file 'ubuntuone/syncdaemon/volume_manager.py'
--- ubuntuone/syncdaemon/volume_manager.py	2015-09-17 02:20:40 +0000
+++ ubuntuone/syncdaemon/volume_manager.py	2015-09-19 23:19:46 +0000
@@ -314,7 +314,8 @@
     def from_volume(cls, volume):
         """Create a Root instance from a RootVolume."""
         # TODO: include the generation and the volume_id(?)
-        return cls(node_id=str(volume.node_id),
+        return cls(
+            node_id=str(volume.node_id),
             free_bytes=volume.free_bytes, generation=volume.generation)
 
     def __repr__(self):
@@ -720,8 +721,9 @@
                 except KeyError:
                     # we don't have the file/md of this shared node_id yet
                     # for the moment ignore this share
-                    self.log.warning("we got a share with 'from_me' direction,"
-                            " but don't have the node_id in the metadata yet")
+                    self.log.warning(
+                        "we got a share with 'from_me' direction, "
+                        "but don't have the node_id in the metadata yet")
                     path = None
                 share = Shared.from_response(a_share, path)
                 shared.append(share.volume_id)
@@ -757,8 +759,9 @@
     def _cleanup_shares(self, to_keep):
         """Cleanup not-yet accepted Shares from the shares shelf."""
         self.log.debug('deleting dead shares')
-        for share in ifilter(lambda item: item and item not in to_keep and \
-                             not self.shares[item].accepted, self.shares):
+        shares = (
+            lambda i: i and i not in to_keep and not self.shares[i].accepted)
+        for share in ifilter(shares, self.shares):
             self.log.debug('deleting shares: id=%s', share)
             self.share_deleted(share)
 
@@ -1022,7 +1025,6 @@
         # XXX: partially implemented, this should be moved into fsm?.
         # should delete all the files in the share?
         # delete all the metadata but dont touch the files/folders
-        # pylint: disable-msg=W0612
         for a_path, _ in self.m.fs.get_paths_starting_with(path):
             self.m.fs.delete_metadata(a_path)
 
@@ -1061,9 +1063,9 @@
             node_id = mdobj.node_id
         abspath = self.m.fs.get_abspath(mdobj.share_id, mdobj.path)
         share = Shared(path=abspath, volume_id=marker,
-                      name=name, access_level=access_level,
-                      other_username=username, other_visible_name=None,
-                      node_id=node_id)
+                       name=name, access_level=access_level,
+                       other_username=username, other_visible_name=None,
+                       node_id=node_id)
         self.marker_share_map[marker] = share
         # XXX: unicode boundary! username, name should be unicode
         self.m.action_q.create_share(node_id, username, name,
@@ -1133,8 +1135,9 @@
                 # don't scan the udf as we are not subscribed to it
                 d = defer.succeed(None)
 
-            d.addCallback(lambda _: self.m.event_q.push('VM_UDF_CREATED',
-                                        udf=self.get_volume(udf.volume_id)))
+            d.addCallback(
+                lambda _: self.m.event_q.push(
+                    'VM_UDF_CREATED', udf=self.get_volume(udf.volume_id)))
             return d
 
     def udf_deleted(self, udf_id):
@@ -1187,8 +1190,8 @@
 
         """
         new_path = path + os.path.sep
-        volumes = itertools.chain([self.shares[request.ROOT]],
-                                   self.udfs.values())
+        volumes = itertools.chain(
+            [self.shares[request.ROOT]], self.udfs.values())
         for volume in volumes:
             vol_path = volume.path + os.path.sep
             if new_path.startswith(vol_path) or vol_path.startswith(new_path):
@@ -1267,8 +1270,8 @@
         Also fire a local and server rescan.
 
         """
-        push_error = functools.partial(self.m.event_q.push,
-            'VM_SHARE_SUBSCRIBE_ERROR', share_id=share_id)
+        push_error = functools.partial(
+            self.m.event_q.push, 'VM_SHARE_SUBSCRIBE_ERROR', share_id=share_id)
         push_success = lambda volume: \
             self.m.event_q.push('VM_SHARE_SUBSCRIBED', share=volume)
         self.log.info('subscribe_share: %r', share_id)
@@ -1362,8 +1365,9 @@
     def unsubscribe_share(self, share_id):
         """Mark the share with share_id as unsubscribed."""
         self.log.info('unsubscribe_share: %r', share_id)
-        push_error = functools.partial(self.m.event_q.push,
-            'VM_SHARE_UNSUBSCRIBE_ERROR', share_id=share_id)
+        push_error = functools.partial(
+            self.m.event_q.push, 'VM_SHARE_UNSUBSCRIBE_ERROR',
+            share_id=share_id)
         push_success = lambda volume: \
             self.m.event_q.push('VM_SHARE_UNSUBSCRIBED', share=volume)
         self._unsubscribe_volume(share_id, push_success, push_error)
@@ -1371,8 +1375,8 @@
     def unsubscribe_udf(self, udf_id):
         """Mark the UDF with udf_id as unsubscribed."""
         self.log.info('unsubscribe_udf: %r', udf_id)
-        push_error = functools.partial(self.m.event_q.push,
-            'VM_UDF_UNSUBSCRIBE_ERROR', udf_id=udf_id)
+        push_error = functools.partial(
+            self.m.event_q.push, 'VM_UDF_UNSUBSCRIBE_ERROR', udf_id=udf_id)
         push_success = lambda volume: \
             self.m.event_q.push('VM_UDF_UNSUBSCRIBED', udf=volume)
         self._unsubscribe_volume(udf_id, push_success, push_error)
@@ -1484,8 +1488,8 @@
         """Upgrade the metadata (only if it's needed)"""
         # upgrade the metadata
         if self.md_version != VolumeManager.METADATA_VERSION:
-            upgrade_method = getattr(self, "_upgrade_metadata_%s" % \
-                                     self.md_version)
+            upgrade_method = getattr(
+                self, "_upgrade_metadata_%s" % self.md_version)
             upgrade_method(self.md_version)
 
     def _get_md_version(self):
@@ -1527,12 +1531,12 @@
            and path_exists(self._shared_md_dir):
             # we have shares and shared dirs
             # md_version >= 1
-            old_root_dir = os.path.abspath(os.path.join(self._root_dir,
-                'My Files'))
-            old_share_dir = os.path.abspath(os.path.join(self._root_dir,
-                                                 'Shared With Me'))
-            if path_exists(old_share_dir) and path_exists(old_root_dir) \
-               and not is_link(old_share_dir):
+            old_root_dir = os.path.abspath(
+                os.path.join(self._root_dir, 'My Files'))
+            old_share_dir = os.path.abspath(
+                os.path.join(self._root_dir, 'Shared With Me'))
+            if (path_exists(old_share_dir) and path_exists(old_root_dir) and
+                    not is_link(old_share_dir)):
                 # md >= 1 and <= 3
                 # we have a My Files dir, 'Shared With Me' isn't a
                 # symlink and ~/.local/share/ubuntuone/shares doesn't
@@ -1547,9 +1551,8 @@
                     target = read_link(self._shares_dir_link)
                 except OSError:
                     target = None
-                if is_link(self._shares_dir_link) \
-                and normpath(target) == os.path.abspath(
-                self._shares_dir_link):
+                if (normpath(target) == os.path.abspath(self._shares_dir_link)
+                        and is_link(self._shares_dir_link)):
                     # broken symlink, md_version = 4
                     md_version = '4'
                 else:
@@ -1583,18 +1586,16 @@
         backup = os.path.join(self._data_dir, '0.bkp')
         if not path_exists(backup):
             make_dir(backup, recursive=True)
-        # pylint: disable-msg=W0612
         # filter 'shares' and 'shared' dirs, in case we are in the case of
         # missing version but existing .version file
         filter_known_dirs = lambda d: d != os.path.basename(
-                self._shares_md_dir) and \
-                d != os.path.basename(self._shared_md_dir)
+            self._shares_md_dir) and d != os.path.basename(self._shared_md_dir)
         for dirname, dirs, files in walk(self._data_dir):
             if dirname == self._data_dir:
                 for dir in filter(filter_known_dirs, dirs):
                     if dir != os.path.basename(backup):
                         recursive_move(os.path.join(dirname, dir),
-                                    os.path.join(backup, dir))
+                                       os.path.join(backup, dir))
         # regenerate the shelf using the new layout using the backup as src
         old_shelf = LegacyShareFileShelf(backup)
         if not path_exists(self._shares_dir):
@@ -1871,8 +1872,9 @@
     """
 
     TYPE = 'type'
-    classes = dict((sub.__name__, sub) for sub in \
-                   Volume.__subclasses__() + Share.__subclasses__())
+    classes = dict(
+        (sub.__name__, sub)
+        for sub in Volume.__subclasses__() + Share.__subclasses__())
 
     def __init__(self, *args, **kwargs):
         """Create the instance."""
@@ -1955,8 +1957,9 @@
     """
 
     TYPE = 'type'
-    classes = dict((sub.__name__, sub) for sub in \
-                   Volume.__subclasses__() + Share.__subclasses__())
+    classes = dict(
+        (sub.__name__, sub)
+        for sub in Volume.__subclasses__() + Share.__subclasses__())
 
     def __init__(self, *args, **kwargs):
         """Create the instance."""