Merge branch 'pricingassistant-master'

rq/connections.py

@@ -61,13 +61,11 @@ def resolve_connection(connection=None):
 
     connection = get_current_connection()
     if connection is None:
-        raise NoRedisConnectionException(
+        raise NoRedisConnectionException('Could not resolve a Redis connection.')
-                'Could not resolve a Redis connection.')
     return connection
 
 
 _connection_stack = LocalStack()
 
-__all__ = ['Connection',
+__all__ = ['Connection', 'get_current_connection', 'push_connection',
-        'get_current_connection', 'push_connection', 'pop_connection',
+           'pop_connection', 'use_connection']
-        'use_connection']

rq/decorators.py

@@ -4,8 +4,8 @@ from .connections import resolve_connection
 from .worker import DEFAULT_RESULT_TTL
 from rq.compat import string_types
 
-class job(object):
 
+class job(object):
     def __init__(self, queue, connection=None, timeout=None,
                  result_ttl=DEFAULT_RESULT_TTL):
         """A decorator that adds a ``delay`` method to the decorated function,

rq/exceptions.py

@@ -15,5 +15,6 @@ class UnpickleError(Exception):
         super(UnpickleError, self).__init__(message, inner_exception)
         self.raw_data = raw_data
 
+
 class DequeueTimeout(Exception):
     pass

rq/job.py

@@ -16,7 +16,8 @@ def enum(name, *sequential, **named):
     values = dict(zip(sequential, range(len(sequential))), **named)
     return type(name, (), values)
 
-Status = enum('Status', QUEUED='queued', FINISHED='finished', FAILED='failed',
+Status = enum('Status',
+              QUEUED='queued', FINISHED='finished', FAILED='failed',
               STARTED='started')
 
 
@@ -291,11 +292,8 @@ class Job(object):
         self._status = as_text(obj.get('status') if obj.get('status') else None)
         self.meta = unpickle(obj.get('meta')) if obj.get('meta') else {}
 
-    def save(self, pipeline=None):
+    def dump(self):
-        """Persists the current job instance to its corresponding Redis key."""
+        """Returns a serialization of the current job instance"""
-        key = self.key
-        connection = pipeline if pipeline is not None else self.connection
-
         obj = {}
         obj['created_at'] = times.format(self.created_at or times.now(), 'UTC')
 
@@ -322,7 +320,14 @@ class Job(object):
         if self.meta:
             obj['meta'] = dumps(self.meta)
 
-        connection.hmset(key, obj)
+        return obj
+
+    def save(self, pipeline=None):
+        """Persists the current job instance to its corresponding Redis key."""
+        key = self.key
+        connection = pipeline if pipeline is not None else self.connection
+
+        connection.hmset(key, self.dump())
 
     def cancel(self):
         """Cancels the given job, which will prevent the job from ever being
@@ -350,7 +355,6 @@ class Job(object):
             assert self.id == _job_stack.pop()
         return self._result
 
-
     def get_ttl(self, default_ttl=None):
         """Returns ttl for a job that determines how long a job and its result
         will be persisted. In the future, this method will also be responsible
@@ -386,7 +390,6 @@ class Job(object):
             connection = pipeline if pipeline is not None else self.connection
             connection.expire(self.key, ttl)
 
-
     def __str__(self):
         return '<Job %s: %s>' % (self.id, self.description)
 

rq/local.py

@@ -119,6 +119,7 @@ class LocalStack(object):
 
     def _get__ident_func__(self):
         return self._local.__ident_func__
+
     def _set__ident_func__(self, value):  # noqa
         object.__setattr__(self._local, '__ident_func__', value)
     __ident_func__ = property(_get__ident_func__, _set__ident_func__)

rq/utils.py

@@ -16,8 +16,7 @@ def gettermsize():
     def ioctl_GWINSZ(fd):
         try:
             import fcntl, termios, struct  # noqa
-            cr = struct.unpack('hh', fcntl.ioctl(fd, termios.TIOCGWINSZ,
+            cr = struct.unpack('hh', fcntl.ioctl(fd, termios.TIOCGWINSZ, '1234'))
-        '1234'))
         except:
             return None
         return cr
@@ -139,7 +138,7 @@ class ColorizingStreamHandler(logging.StreamHandler):
 
     def __init__(self, exclude=None, *args, **kwargs):
         self.exclude = exclude
-        if is_python_version((2,6)):
+        if is_python_version((2, 6)):
             logging.StreamHandler.__init__(self, *args, **kwargs)
         else:
             super(ColorizingStreamHandler, self).__init__(*args, **kwargs)

rq/worker.py

@@ -43,8 +43,8 @@ def iterable(x):
 def compact(l):
     return [x for x in l if x is not None]
 
-_signames = dict((getattr(signal, signame), signame) \
+_signames = dict((getattr(signal, signame), signame)
-                    for signame in dir(signal) \
+                 for signame in dir(signal)
                  if signame.startswith('SIG') and '_' not in signame)
 
 
@@ -68,8 +68,8 @@ class Worker(object):
         if connection is None:
             connection = get_current_connection()
         reported_working = connection.smembers(cls.redis_workers_keys)
-        workers = [cls.find_by_key(as_text(key), connection) for key in
+        workers = [cls.find_by_key(as_text(key), connection)
-                reported_working]
+                   for key in reported_working]
         return compact(workers)
 
     @classmethod
@@ -98,7 +98,6 @@ class Worker(object):
                              for queue in queues.split(',')]
         return worker
 
-
     def __init__(self, queues, name=None,
                  default_result_ttl=DEFAULT_RESULT_TTL, connection=None,
                  exc_handler=None, default_worker_ttl=DEFAULT_WORKER_TTL):  # noqa
@@ -193,8 +192,7 @@ class Worker(object):
         self.log.debug('Registering birth of worker %s' % (self.name,))
         if self.connection.exists(self.key) and \
                 not self.connection.hexists(self.key, 'death'):
-            raise ValueError(
+            raise ValueError('There exists an active worker named \'%s\' '
-                    'There exists an active worker named \'%s\' '
                              'already.' % (self.name,))
         key = self.key
         now = time.time()
@@ -304,7 +302,7 @@ class Worker(object):
                 qnames = self.queue_names()
                 self.procline('Listening on %s' % ','.join(qnames))
                 self.log.info('')
-                self.log.info('*** Listening on %s...' % \
+                self.log.info('*** Listening on %s...' %
                               green(', '.join(qnames)))
                 timeout = None if burst else max(1, self.default_worker_ttl - 60)
                 try:
@@ -336,7 +334,6 @@ class Worker(object):
                 self.register_death()
         return did_perform_work
 
-
     def dequeue_job_and_maintain_ttl(self, timeout):
         while True:
             try:
@@ -348,7 +345,6 @@ class Worker(object):
             self.log.debug('Sending heartbeat to prevent worker timeout.')
             self.connection.expire(self.key, self.default_worker_ttl)
 
-
     def fork_and_perform_job(self, job):
         """Spawns a work horse to perform the actual work and passes it a job.
         The worker will wait for the work horse and make sure it executes
@@ -443,11 +439,9 @@ class Worker(object):
 
         return True
 
-
     def handle_exception(self, job, *exc_info):
         """Walks the exception handler stack to delegate exception handling."""
-        exc_string = ''.join(
+        exc_string = ''.join(traceback.format_exception_only(*exc_info[:2]) +
-                traceback.format_exception_only(*exc_info[:2]) +
                              traceback.format_exception(*exc_info))
         self.log.error(exc_string)