PEP8ify + pyflakes

celery/backends/database.py

@@ -1,4 +1,3 @@
-import urllib
 from datetime import datetime
 
 
@@ -74,7 +73,7 @@ class DatabaseBackend(BaseDictBackend):
         session = self.ResultSession()
         try:
             qs = session.query(TaskSet)
-            for taskset in qs.filter(TaskSet.task_id == task_id):
+            for taskset in qs.filter(TaskSet.taskset_id == taskset_id):
                 return taskset.to_dict()
         finally:
             session.close()

celery/bin/celeryd.py

@@ -117,7 +117,7 @@ OPTION_LIST = (
     optparse.make_option('--soft-time-limit',
             default=conf.CELERYD_TASK_SOFT_TIME_LIMIT,
             action="store", type="int", dest="task_soft_time_limit",
-            help="Enables a soft time limit (in seconds) for task run times.")
+            help="Enables a soft time limit for task run times."),
 )
 
 

celery/db/a805d4bd.py

@@ -29,14 +29,12 @@ class PickleType(_PickleType):
         dumps = self.pickler.dumps
         protocol = self.protocol
         if impl_processor:
-
             def process(value):
                 if value is not None:
                     value = dumps(value, protocol)
                 return impl_processor(value)
 
         else:
-
             def process(value):
                 if value is not None:
                     value = dumps(value, protocol)

celery/db/models.py

@@ -1,8 +1,7 @@
 from datetime import datetime
 
-from sqlalchemy import Column, Sequence, ForeignKey
+from sqlalchemy import Column, Sequence
 from sqlalchemy import Integer, String, Text, DateTime
-from sqlalchemy.orm import relation
 
 from celery import states
 from celery.db.session import ResultModelBase
@@ -10,7 +9,6 @@ from celery.db.session import ResultModelBase
 from celery.db.a805d4bd import PickleType
 
 
-
 class Task(ResultModelBase):
     """Task result/status."""
     __tablename__ = "celery_taskmeta"

celery/tests/test_loaders.py

@@ -10,16 +10,12 @@ from celery.loaders import default
 from celery.tests.utils import with_environ
 
 
-
 class TestLoaders(unittest.TestCase):
 
     def test_get_loader_cls(self):
 
         self.assertEqual(loaders.get_loader_cls("default"),
                           default.Loader)
-        # Execute cached branch.
-        self.assertEqual(loaders.get_loader_cls("default"),
-                          default.Loader)
 
     @with_environ("CELERY_LOADER", "default")
     def test_detect_loader_CELERY_LOADER(self):

celery/tests/test_task_cancelable.py → celery/tests/test_task_abortable.py

@@ -1,6 +1,5 @@
 import unittest2 as unittest
 
-from celery.contrib.abortable import ABORTED
 from celery.contrib.abortable import AbortableTask, AbortableAsyncResult
 
 

celery/utils/dispatch/saferef.py

@@ -135,7 +135,7 @@ class BoundMethodWeakref(object):
                 except Exception, exc:
                     try:
                         traceback.print_exc()
-                    except AttributeError, err:
+                    except AttributeError:
                         print("Exception during saferef %s cleanup function "
                               "%s: %s" % (self, function, exc))
 
@@ -193,14 +193,15 @@ class BoundMethodWeakref(object):
                 return function.__get__(target)
         return None
 
+
 class BoundNonDescriptorMethodWeakref(BoundMethodWeakref):
     """A specialized :class:`BoundMethodWeakref`, for platforms where
     instance methods are not descriptors.
 
     It assumes that the function name and the target attribute name are the
     same, instead of assuming that the function is a descriptor. This approach
-    is equally fast, but not 100% reliable because functions can be stored on an
-    attribute named differenty than the function's name such as in::
+    is equally fast, but not 100% reliable because functions can be stored on
+    an attribute named differenty than the function's name such as in::
 
         >>> class A(object):
         ...     pass
@@ -272,4 +273,5 @@ def get_bound_method_weakref(target, on_delete):
         return BoundMethodWeakref(target=target, on_delete=on_delete)
     else:
         # no luck, use the alternative implementation:
-        return BoundNonDescriptorMethodWeakref(target=target, on_delete=on_delete)
+        return BoundNonDescriptorMethodWeakref(target=target,
+                                               on_delete=on_delete)

celery/utils/dispatch/signal.py

@@ -46,8 +46,8 @@ class Signal(object):
             receive signals. Receivers must be hashable objects.
 
             if weak is ``True``, then receiver must be weak-referencable (more
-            precisely :func:`saferef.safe_ref()` must be able to create a reference
-            to the receiver).
+            precisely :func:`saferef.safe_ref()` must be able to create a
+            reference to the receiver).
 
             Receivers must be able to accept keyword arguments.
 
@@ -75,7 +75,8 @@ class Signal(object):
             lookup_key = (_make_id(receiver), _make_id(sender))
 
         if weak:
-            receiver = saferef.safe_ref(receiver, on_delete=self._remove_receiver)
+            receiver = saferef.safe_ref(receiver,
+                                        on_delete=self._remove_receiver)
 
         for r_key, _ in self.receivers:
             if r_key == lookup_key:
@@ -83,11 +84,12 @@ class Signal(object):
         else:
             self.receivers.append((lookup_key, receiver))
 
-    def disconnect(self, receiver=None, sender=None, weak=True, dispatch_uid=None):
+    def disconnect(self, receiver=None, sender=None, weak=True,
+            dispatch_uid=None):
         """Disconnect receiver from sender for signal.
 
-        If weak references are used, disconnect need not be called. The receiver
-        will be remove from dispatch automatically.
+        If weak references are used, disconnect need not be called. The
+        receiver will be removed from dispatch automatically.
 
         :keyword receiver: The registered receiver to disconnect. May be
             none if ``dispatch_uid`` is specified.
@@ -114,9 +116,9 @@ class Signal(object):
     def send(self, sender, **named):
         """Send signal from sender to all connected receivers.
 
-        If any receiver raises an error, the error propagates back through send,
-        terminating the dispatch loop, so it is quite possible to not have all
-        receivers called if a raises an error.
+        If any receiver raises an error, the error propagates back through
+        send, terminating the dispatch loop, so it is quite possible to not
+        have all receivers called if a raises an error.
 
         :param sender: The sender of the signal. Either a specific
             object or ``None``.
@@ -151,8 +153,8 @@ class Signal(object):
         :raises DispatcherKeyError:
 
         if any receiver raises an error (specifically any subclass of
-        :exc:`Exception`), the error instance is returned as the result for that
-        receiver.
+        :exc:`Exception`), the error instance is returned as the result
+        for that receiver.
 
         """
         responses = []