run black skipping string normalization

Author: gonzalocasas

src/roslibpy/__init__.py

@@ -98,22 +98,10 @@ class and are passed around via :class:`Topics <Topic>` using a **publish/subscr
     __license__,
     __title__,
     __url__,
-    __version__
-)
-from .core import (
-    Header,
-    Message,
-    Param,
-    Service,
-    ServiceRequest,
-    ServiceResponse,
-    Time,
-    Topic
-)
-from .ros import (
-    set_rosapi_timeout,
-    Ros
+    __version__,
 )
+from .core import Header, Message, Param, Service, ServiceRequest, ServiceResponse, Time, Topic
+from .ros import set_rosapi_timeout, Ros
 
 __all__ = [
     '__author__',
@@ -124,7 +112,6 @@ class and are passed around via :class:`Topics <Topic>` using a **publish/subscr
     '__title__',
     '__url__',
     '__version__',
-
     'Header',
     'Message',
     'Param',
@@ -133,7 +120,6 @@ class and are passed around via :class:`Topics <Topic>` using a **publish/subscr
     'ServiceResponse',
     'Time',
     'Topic',
-
     'set_rosapi_timeout',
     'Ros',
 ]

src/roslibpy/actionlib.py

@@ -53,6 +53,7 @@ def _is_earlier(t1, t2):
 
 class GoalStatus:
     """Valid goal statuses."""
+
     PENDING = 0
     ACTIVE = 1
     PREEMPTED = 2
@@ -93,16 +94,9 @@ def __init__(self, action_client, goal_message):
         self.status = None
         self.feedback = None
 
-        self.goal_message = Message({
-            'goal_id': {
-                'stamp': {
-                    'secs': 0,
-                    'nsecs': 0
-                },
-                'id': self.goal_id
-            },
-            'goal': dict(self.goal_message)
-        })
+        self.goal_message = Message(
+            {'goal_id': {'stamp': {'secs': 0, 'nsecs': 0}, 'id': self.goal_id}, 'goal': dict(self.goal_message)}
+        )
 
         self.action_client.add_goal(self)
 
@@ -167,8 +161,7 @@ def _set_feedback(self, feedback):
     def is_active(self):
         if self.status is None:
             return False
-        return (self.status['status'] == GoalStatus.ACTIVE or
-                self.status['status'] == GoalStatus.PENDING)
+        return self.status['status'] == GoalStatus.ACTIVE or self.status['status'] == GoalStatus.PENDING
 
     @property
     def is_finished(self):
@@ -190,8 +183,9 @@ class ActionClient(EventEmitterMixin):
         timeout (:obj:`int`): **Deprecated.** Connection timeout, expressed in seconds.
     """
 
-    def __init__(self, ros, server_name, action_name, timeout=None,
-                 omit_feedback=False, omit_status=False, omit_result=False):
+    def __init__(
+        self, ros, server_name, action_name, timeout=None, omit_feedback=False, omit_status=False, omit_result=False
+    ):
         super(ActionClient, self).__init__()
         self.ros = ros
         self.server_name = server_name
@@ -226,7 +220,8 @@ def __init__(self, ros, server_name, action_name, timeout=None,
 
         if timeout:
             LOGGER.warn(
-                'Deprecation warning: timeout parameter is ignored, and replaced by the DEFAULT_CONNECTION_TIMEOUT constant.')
+                'Deprecation warning: timeout parameter is ignored, and replaced by the DEFAULT_CONNECTION_TIMEOUT constant.'
+            )
 
         self.wait_status = threading.Event()
 
@@ -295,7 +290,8 @@ class SimpleActionServer(EventEmitterMixin):
         server_name (:obj:`str`): Action server name, e.g. ``/fibonacci``.
         action_name (:obj:`str`): Action message name, e.g. ``actionlib_tutorials/FibonacciAction``.
     """
-    STATUS_PUBLISH_INTERVAL = 0.5   # In seconds
+
+    STATUS_PUBLISH_INTERVAL = 0.5  # In seconds
 
     def __init__(self, ros, server_name, action_name):
         super(SimpleActionServer, self).__init__()
@@ -318,17 +314,11 @@ def __init__(self, ros, server_name, action_name):
         self.result_publisher.advertise()
 
         # Track the goals and their status in order to publish status
-        self.status_message = Message(dict(
-            header=dict(
-                stamp=dict(secs=0, nsecs=100),
-                frame_id=''
-            ),
-            status_list=[]
-        ))
+        self.status_message = Message(dict(header=dict(stamp=dict(secs=0, nsecs=100), frame_id=''), status_list=[]))
 
         # Needed for handling preemption prompted by a new goal being received
-        self.current_goal = None    # currently tracked goal
-        self.next_goal = None       # the one that'll be preempting
+        self.current_goal = None  # currently tracked goal
+        self.next_goal = None  # the one that'll be preempting
         self.preempt_request = False
 
         self.goal_listener.subscribe(self._on_goal_message)
@@ -381,8 +371,7 @@ def _on_goal_message(self, message):
                 # needs to happen AFTER rest is set up
                 will_cancel = True
             else:
-                self.status_message['status_list'] = [
-                    dict(goal_id=message['goal_id'], status=GoalStatus.ACTIVE)]
+                self.status_message['status_list'] = [dict(goal_id=message['goal_id'], status=GoalStatus.ACTIVE)]
                 self.current_goal = message
                 will_emit_goal = message['goal']
 
@@ -435,17 +424,12 @@ def set_succeeded(self, result):
         Args:
             result (:obj:`dict`): Dictionary of key/values to set as the result of the action.
         """
-        LOGGER.info(
-            'Action server {} setting current goal to SUCCEEDED'.format(self.server_name))
+        LOGGER.info('Action server {} setting current goal to SUCCEEDED'.format(self.server_name))
 
         with self._lock:
-            result_message = Message({
-                'status': {
-                    'goal_id': self.current_goal['goal_id'],
-                    'status': GoalStatus.SUCCEEDED
-                },
-                'result': result
-            })
+            result_message = Message(
+                {'status': {'goal_id': self.current_goal['goal_id'], 'status': GoalStatus.SUCCEEDED}, 'result': result}
+            )
 
             self.result_publisher.publish(result_message)
 
@@ -469,13 +453,9 @@ def send_feedback(self, feedback):
         Args:
             feedback (:obj:`dict`): Dictionary of key/values of the feedback message.
         """
-        feedback_message = Message({
-            'status': {
-                'goal_id': self.current_goal['goal_id'],
-                'status': GoalStatus.ACTIVE
-            },
-            'feedback': feedback
-        })
+        feedback_message = Message(
+            {'status': {'goal_id': self.current_goal['goal_id'], 'status': GoalStatus.ACTIVE}, 'feedback': feedback}
+        )
 
         self.feedback_publisher.publish(feedback_message)
 
@@ -485,12 +465,9 @@ def set_preempted(self):
 
         with self._lock:
             self.status_message['status_list'] = []
-            result_message = Message({
-                'status': {
-                    'goal_id': self.current_goal['goal_id'],
-                    'status': GoalStatus.PREEMPTED
-                }
-            })
+            result_message = Message(
+                {'status': {'goal_id': self.current_goal['goal_id'], 'status': GoalStatus.PREEMPTED}}
+            )
 
             self.result_publisher.publish(result_message)
 

src/roslibpy/comm/comm.py

@@ -12,6 +12,7 @@
 
 class RosBridgeException(Exception):
     """Exception raised on the ROS bridge communication."""
+
     pass
 
 
@@ -33,8 +34,7 @@ def on_message(self, payload):
         message = Message(json.loads(payload.decode('utf8')))
         handler = self._message_handlers.get(message['op'], None)
         if not handler:
-            raise RosBridgeException(
-                'No handler registered for operation "%s"' % message['op'])
+            raise RosBridgeException('No handler registered for operation "%s"' % message['op'])
 
         handler(message)
 
@@ -62,8 +62,7 @@ def register_message_handlers(self, operation, handler):
             handler: Callback to handle the message.
         """
         if operation in self._message_handlers:
-            raise RosBridgeException(
-                'Only one handler can be registered per operation')
+            raise RosBridgeException('Only one handler can be registered per operation')
 
         self._message_handlers[operation] = handler
 
@@ -91,8 +90,7 @@ def _handle_service_response(self, message):
         service_handlers = self._pending_service_requests.get(request_id, None)
 
         if not service_handlers:
-            raise RosBridgeException(
-                'No handler registered for service request ID: "%s"' % request_id)
+            raise RosBridgeException('No handler registered for service request ID: "%s"' % request_id)
 
         callback, errback = service_handlers
         del self._pending_service_requests[request_id]
@@ -106,7 +104,6 @@ def _handle_service_response(self, message):
 
     def _handle_service_request(self, message):
         if 'service' not in message:
-            raise ValueError(
-                'Expected service name missing in service request')
+            raise ValueError('Expected service name missing in service request')
 
         self.factory.emit(message['service'], message)

src/roslibpy/comm/comm_autobahn.py

@@ -38,14 +38,18 @@ def onMessage(self, payload, isBinary):
         try:
             self.on_message(payload)
         except Exception:
-            LOGGER.exception('Exception on start_listening while trying to handle message received.' +
-                             'It could indicate a bug in user code on message handlers. Message skipped.')
+            LOGGER.exception(
+                'Exception on start_listening while trying to handle message received.'
+                + 'It could indicate a bug in user code on message handlers. Message skipped.'
+            )
 
     def onClose(self, wasClean, code, reason):
         LOGGER.info('WebSocket connection closed: Code=%s, Reason=%s', str(code), reason)
 
     def send_message(self, payload):
-        return reactor.callFromThread(self.sendMessage, payload, isBinary=False, fragmentSize=None, sync=False, doNotCompress=False)
+        return reactor.callFromThread(
+            self.sendMessage, payload, isBinary=False, fragmentSize=None, sync=False, doNotCompress=False
+        )
 
     def send_close(self):
         self._manual_disconnect = True
@@ -54,6 +58,7 @@ def send_close(self):
 
 class AutobahnRosBridgeClientFactory(EventEmitterMixin, ReconnectingClientFactory, WebSocketClientFactory):
     """Factory to create instances of the ROS Bridge protocol built on top of Autobahn/Twisted."""
+
     protocol = AutobahnRosBridgeProtocol
 
     def __init__(self, *args, **kwargs):
@@ -100,8 +105,7 @@ def clientConnectionLost(self, connector, reason):
 
     def clientConnectionFailed(self, connector, reason):
         LOGGER.debug('Connection failed. Reason: %s', reason)
-        ReconnectingClientFactory.clientConnectionFailed(
-            self, connector, reason)
+        ReconnectingClientFactory.clientConnectionFailed(self, connector, reason)
         self._proto = None
 
     @property
@@ -159,6 +163,7 @@ class TwistedEventLoopManager(object):
     event loop handlers that might be more fitting for different
     execution environments.
     """
+
     def __init__(self):
         self._log_observer = log.PythonLoggingObserver()
         self._log_observer.start()
@@ -238,8 +243,10 @@ def get_inner_callback(self, result_placeholder):
         Returns:
             A callable which provides result_placeholder with the result in the case of success.
         """
+
         def inner_callback(result):
             result_placeholder.callback({'result': result})
+
         return inner_callback
 
     def get_inner_errback(self, result_placeholder):
@@ -251,8 +258,10 @@ def get_inner_errback(self, result_placeholder):
         Returns:
             A callable which provides result_placeholder with the error in the case of failure.
         """
+
         def inner_errback(error):
             result_placeholder.callback({'exception': error})
+
         return inner_errback
 
     def terminate(self):