gridappsd-python 2025.3.2a13__py3-none-any.whl → 2025.3.2a17__py3-none-any.whl

gridappsd/__init__.py

@@ -37,20 +37,21 @@
 # PACIFIC NORTHWEST NATIONAL LABORATORY operated by BATTELLE for the
 # UNITED STATES DEPARTMENT OF ENERGY under Contract DE-AC05-76RL01830
 # -------------------------------------------------------------------------------
-""" GridAPPSD Python Connection Library
+"""GridAPPSD Python Connection Library
 
 The :mod:`gridappsd` contains a connection class :class:`gridappsd.GridAPPSD` for connecting with the
 main GridAPPSD executable.
 
 """
+
 import pathlib
 import typing
 
 StrPath = typing.Union[str, pathlib.Path]
 
-from gridappsd.goss import GOSS
-from gridappsd.utils import ProcessStatusEnum
-from gridappsd.gridappsd import GridAPPSD
-from gridappsd.difference_builder import DifferenceBuilder
-from gridappsd.app_registration import ApplicationController
-import gridappsd.json_extension as json
+from gridappsd.goss import GOSS as GOSS
+from gridappsd.utils import ProcessStatusEnum as ProcessStatusEnum
+from gridappsd.gridappsd import GridAPPSD as GridAPPSD
+from gridappsd.difference_builder import DifferenceBuilder as DifferenceBuilder
+from gridappsd.app_registration import ApplicationController as ApplicationController
+from gridappsd import json_extension as json

gridappsd/__main__.py

@@ -48,28 +48,30 @@ from dotenv import load_dotenv
 from pathlib import Path
 
 from gridappsd import GridAPPSD
+from gridappsd.simulation import Simulation
 
 assert sys.version_info >= (3, 10), "Minimum version is python 3.10"
 
-logging.basicConfig(stream=sys.stdout,
-                    level=logging.INFO,
-                    format="'%(asctime)s: %(name)-20s - %(levelname)-6s - %(message)s")
+logging.basicConfig(
+    stream=sys.stdout, level=logging.INFO, format="'%(asctime)s: %(name)-20s - %(levelname)-6s - %(message)s"
+)
 
-logging.getLogger('stomp.py').setLevel(logging.WARNING)
+logging.getLogger("stomp.py").setLevel(logging.WARNING)
 _log = logging.getLogger("gridappsd.__main__")
 
-if __name__ == '__main__':
-
+if __name__ == "__main__":
     parser = ArgumentParser()
 
     group = parser.add_mutually_exclusive_group(required=True)
-    group.add_argument("-s",
-                       "--run-simulation",
-                       type=argparse.FileType('r'),
-                       help="Start running a simulation from a passed simulation file.")
-    group.add_argument("--env", required=False, type=str,
-                       default=".env",
-                       help="Load environment variables from a .env file.")
+    group.add_argument(
+        "-s",
+        "--run-simulation",
+        type=argparse.FileType("r"),
+        help="Start running a simulation from a passed simulation file.",
+    )
+    group.add_argument(
+        "--env", required=False, type=str, default=".env", help="Load environment variables from a .env file."
+    )
     opts = parser.parse_args()
 
     if opts.run_simulation:
@@ -91,8 +93,6 @@ if __name__ == '__main__':
         gappsd = GridAPPSD()
         run_args = yaml.safe_load(opts.run_simulation)
 
-        # if wanting to use the above next_timestep function use this
-        # instead of the one below.
-        # simulation = gappsd.run_simulation(run_args, next_timestep)
-        simulation = gappsd.run_simulation(run_args)
-        simulation.simulation_main_loop()
+        # Create and start the simulation
+        simulation = Simulation(gappsd, run_args)
+        simulation.start_simulation()

gridappsd/app_registration.py

@@ -1,17 +1,12 @@
-#import json
+# import json
 import logging
 import os
-try:
-    from queue import Queue
-except ImportError:
-    from Queue import Queue
+from queue import Queue
 import time
-import select
 import subprocess
 import threading
 import shlex
 import sys
-import os
 
 from .gridappsd import GridAPPSD
 from .topics import REQUEST_REGISTER_APP
@@ -21,12 +16,11 @@ _log = logging.getLogger(__name__)
 
 # determine OS type
 posix = False
-if os.name == 'posix':
+if os.name == "posix":
     posix = True
 
 
 class Job(threading.Thread):
-
     def __init__(self, args, out=sys.stdout, err=sys.stderr):
         threading.Thread.__init__(self)
         _log.debug("Creating job")
@@ -41,31 +35,30 @@ class Job(threading.Thread):
     def run(self):
         try:
             self.running = True
-            os.environ['GRIDAPPSD_APPLICATION_STATUS'] = 'RUNNING'
+            os.environ["GRIDAPPSD_APPLICATION_STATUS"] = "RUNNING"
 
             p = subprocess.Popen(args=self._args, shell=False, stdout=self._out, stderr=self._err)
 
             # Loop while process is executing
             while p.poll() is None and self.running:
-                os.environ['GRIDAPPSD_APPLICATION_STATUS'] = 'RUNNING'
+                os.environ["GRIDAPPSD_APPLICATION_STATUS"] = "RUNNING"
                 time.sleep(1)
 
         except Exception as e:
-            os.environ['GRIDAPPSD_APPLICATION_STATUS'] = 'ERROR'
+            os.environ["GRIDAPPSD_APPLICATION_STATUS"] = "ERROR"
             _log.error(repr(e))
         else:
-            os.environ['GRIDAPPSD_APPLICATION_STATUS'] = 'STOPPED'
+            os.environ["GRIDAPPSD_APPLICATION_STATUS"] = "STOPPED"
 
 
 class ApplicationController(object):
-
     def __init__(self, config, gridappsd=None, heatbeat_period=10):
         if not isinstance(config, dict):
             raise ValueError("Config should be dictionary")
         if not isinstance(gridappsd, GridAPPSD):
             raise ValueError("Invalid gridappsd instance passed.")
 
-        os.environ['GRIDAPPSD_APPLICATION_STATUS'] = 'STOPPED'
+        os.environ["GRIDAPPSD_APPLICATION_STATUS"] = "STOPPED"
         self._configDict = config.copy()
         self._validate_config()
         self._gapd = gridappsd
@@ -87,15 +80,16 @@ class ApplicationController(object):
         self._end_callback = None
         self._print_queue = Queue()
         self._heartbeat_thread = None
-        os.environ['GRIDAPPSD_APPLICATION_STATUS'] = 'STOPPED'
+        os.environ["GRIDAPPSD_APPLICATION_STATUS"] = "STOPPED"
 
-        if "type" not in self._configDict or self._configDict['type'] != 'REMOTE':
-            _log.warning('Setting type to REMOTE you can remove this error by putting '
-                         '"type": "REMOTE" in the app config file.')
-            self._configDict['type'] = 'REMOTE'
+        if "type" not in self._configDict or self._configDict["type"] != "REMOTE":
+            _log.warning(
+                'Setting type to REMOTE you can remove this error by putting "type": "REMOTE" in the app config file.'
+            )
+            self._configDict["type"] = "REMOTE"
 
     def _validate_config(self):
-        required = ['id', 'execution_path']
+        required = ["id", "execution_path"]
         missing = [x for x in required if x not in self._configDict]
 
         if missing:
@@ -114,30 +108,30 @@ class ApplicationController(object):
         self._gapd.get_logger().debug("Started App Registration")
 
         response = self._gapd.get_response(REQUEST_REGISTER_APP, self._configDict, 60)
-        if 'message' in response:
+        if "message" in response:
             _log.error("An error regisering the application occured")
-            _log.error(response.get('message'))
-            raise ValueError(response.get('message'))
-        self._application_id = response.get('applicationId')
-        self._heartbeat_topic = response.get('heartbeatTopic')
-        self._heartbeat_period = response.get('heartbeatPeriod', 10)
-        self._start_control_topic = response.get('startControlTopic')
-        self._stop_control_topic = response.get('stopControlTopic')
+            _log.error(response.get("message"))
+            raise ValueError(response.get("message"))
+        self._application_id = response.get("applicationId")
+        self._heartbeat_topic = response.get("heartbeatTopic")
+        self._heartbeat_period = response.get("heartbeatPeriod", 10)
+        self._start_control_topic = response.get("startControlTopic")
+        self._stop_control_topic = response.get("stopControlTopic")
 
         os.environ["GRIDAPPSD_APPLICATION_ID"] = self._application_id
-        os.environ['GRIDAPPSD_APPLICATION_STATUS'] = 'STOPPED'
+        os.environ["GRIDAPPSD_APPLICATION_STATUS"] = "STOPPED"
 
         self._gapd.subscribe(self._stop_control_topic, self.__handle_stop)
         self._gapd.subscribe(self._start_control_topic, self.__handle_start)
         self._end_callback = end_callback
 
         # TODO assuming good response start the heartbeat
-        self._heartbeat_thread = threading.Thread(target=self.__start_heartbeat,
-                                                  args=[self.__heartbeat_error])
+        self._heartbeat_thread = threading.Thread(target=self.__start_heartbeat, args=[self.__heartbeat_error])
         self._heartbeat_thread.daemon = True
         self._heartbeat_thread.start()
-        self._gapd.get_logger().debug("Heartbeat registereed for application {}".format(
-            utils.get_gridappsd_application_id()))
+        self._gapd.get_logger().debug(
+            "Heartbeat registereed for application {}".format(utils.get_gridappsd_application_id())
+        )
 
     def __heartbeat_error(self):
         self._heartbeat_thread = None
@@ -151,8 +145,7 @@ class ApplicationController(object):
                 # print("Seanding heartbeat {} {}".format(self._heartbeat_topic, self._application_id))
                 # print("Heartbeat period: {}".format(self._heartbeat_period))
                 self._gapd.send(self._heartbeat_topic, self._application_id)
-                time.sleep(self._heartbeat_period -
-                           ((time.time() - starttime) % self._heartbeat_period))
+                time.sleep(self._heartbeat_period - ((time.time() - starttime) % self._heartbeat_period))
         except:
             error_callback()
 
@@ -167,15 +160,15 @@ class ApplicationController(object):
             obj = json.loads(message)
         else:
             obj = message
-        os.environ['GRIDAPPSD_APPLICATION_STATUS'] = 'STARTING'
+        os.environ["GRIDAPPSD_APPLICATION_STATUS"] = "STARTING"
         self._gapd.get_logger().debug("Handling Start: {}\ndict:\n{}".format(headers, obj))
 
-        if 'command' not in obj:
+        if "command" not in obj:
             # Send log to gridappsd
             _log.error("Invalid message sent on start app.")
         else:
             _log.debug("CWD IS: {}".format(os.getcwd()))
-            args = shlex.split(obj['command'])
+            args = shlex.split(obj["command"])
             job = Job(args)
             job.daemon = True
             job.start()
@@ -183,12 +176,12 @@ class ApplicationController(object):
 
     def __handle_stop(self, headers, message):
         print("Handling Stop: {} {}".format(headers, message))
-        os.environ['GRIDAPPSD_APPLICATION_STATUS'] = 'STOPPING'
+        os.environ["GRIDAPPSD_APPLICATION_STATUS"] = "STOPPING"
         if self._thread:
             self._thread.join()
         if self._end_callback is not None:
             self._end_callback()
-        os.environ['GRIDAPPSD_APPLICATION_STATUS'] = 'STOPPED'
+        os.environ["GRIDAPPSD_APPLICATION_STATUS"] = "STOPPED"
 
     def shutdown(self):
         self._shutting_down = True

gridappsd/difference_builder.py

@@ -44,43 +44,46 @@ import time
 
 
 class DifferenceBuilder(object):
-    """ Automates the building of forward and reverse cim differences
-
-    """
+    """Automates the building of forward and reverse cim differences"""
 
     def __init__(self, simulation_id: str | int | None = None):
-
         self._simulation_id = simulation_id
         self._forward: list[dict] = []
         self._reverse: list[dict] = []
 
     def add_difference(self, object_id, attribute, forward_value, reverse_value):
-        """ Add forward and reverse unit for an object attribute.
+        """Add forward and reverse unit for an object attribute.
 
-         All of the parameters must be serializable for sending the GOSS message bus.
-         """
+        All of the parameters must be serializable for sending the GOSS message bus.
+        """
         forward = dict(object=object_id, attribute=attribute, value=forward_value)
         reverse = dict(object=object_id, attribute=attribute, value=reverse_value)
         self._forward.append(forward)
         self._reverse.append(reverse)
 
     def clear(self):
-        """ Clear the forward and reverse differences """
+        """Clear the forward and reverse differences"""
         self._forward = []
         self._reverse = []
 
     def get_message(self, epoch=None):
-        """ Get the message to send to the GOSS message bus
+        """Get the message to send to the GOSS message bus
 
         :param epoch: The epoch time to use for the message timestamp.  If None, the current time (GMT) is used.
         """
         if epoch is None:
             epoch = calendar.timegm(time.gmtime())
-        msg = dict(command="update",
-                   input=dict(message=dict(timestamp=epoch,
-                                           difference_mrid=str(uuid4()),
-                                           reverse_differences=self._reverse,
-                                           forward_differences=self._forward)))
+        msg = dict(
+            command="update",
+            input=dict(
+                message=dict(
+                    timestamp=epoch,
+                    difference_mrid=str(uuid4()),
+                    reverse_differences=self._reverse,
+                    forward_differences=self._forward,
+                )
+            ),
+        )
         if self._simulation_id is not None:
-            msg['input']['simulation_id'] = self._simulation_id
+            msg["input"]["simulation_id"] = self._simulation_id
         return msg.copy()

gridappsd/field_interface/__init__.py

@@ -1,32 +1,52 @@
 import logging
 import sys
+import warnings
 
 _log = logging.getLogger(__name__)
 
-try:
-    import warnings
+# These will be populated if gridappsd-field-bus is installed
+context = None
+context_managers = None
+agents = None
+field_proxy_forwarder = None
+gridappsd_field_bus = None
+interfaces = None
 
+try:
     import gridappsd_field_bus.field_interface.context as _context
     import gridappsd_field_bus.field_interface.context_managers as _context_managers
     import gridappsd_field_bus.field_interface as _field_interface
     import gridappsd_field_bus.field_interface.agents as _agents
-    import gridappsd_field_bus.field_interface.field_proxy_forwarder as _field_proxy_forwarder
     import gridappsd_field_bus.field_interface.gridappsd_field_bus as _gridappsd_field_bus
     import gridappsd_field_bus.field_interface.interfaces as _interfaces
 
-    sys.modules['gridappsd.field_interface'] = _field_interface
-    sys.modules['gridappsd.field_interface.interfaces'] = _interfaces
-    sys.modules['gridappsd.field_interface.context_managers'] = _context_managers
-    sys.modules['gridappsd_.context_managers'] = _context_managers
-    sys.modules['gridappsd.field_interface.agents'] = _agents
-    sys.modules['gridappsd.field_interface.field_proxy_forwarder'] = _field_proxy_forwarder
-    sys.modules['gridappsd.field_interface.gridappsd_field_bus'] = _gridappsd_field_bus
-
-
-
-
-
-    warnings.warn(message="gridappsd.field_interface is deprecated and will be removed in a future release. Use gridappsd_field_bus.field_interface instead.",
-                  category=DeprecationWarning)
-except ImportError:
-    _log.error("Could not import field_interface install gridappsd-field-bus to get those functions.")
+    # Expose as module attributes for `from gridappsd.field_interface import X` syntax
+    context = _context
+    context_managers = _context_managers
+    agents = _agents
+    gridappsd_field_bus = _gridappsd_field_bus
+    interfaces = _interfaces
+
+    # Also register in sys.modules for backwards compatibility
+    sys.modules["gridappsd.field_interface.interfaces"] = _interfaces
+    sys.modules["gridappsd.field_interface.context"] = _context
+    sys.modules["gridappsd.field_interface.context_managers"] = _context_managers
+    sys.modules["gridappsd.field_interface.agents"] = _agents
+    sys.modules["gridappsd.field_interface.gridappsd_field_bus"] = _gridappsd_field_bus
+
+    # field_proxy_forwarder has optional dependencies that may not be available
+    try:
+        import gridappsd_field_bus.field_interface.field_proxy_forwarder as _field_proxy_forwarder
+
+        field_proxy_forwarder = _field_proxy_forwarder
+        sys.modules["gridappsd.field_interface.field_proxy_forwarder"] = _field_proxy_forwarder
+    except ImportError:
+        _log.debug("field_proxy_forwarder not available (missing optional dependencies)")
+
+    warnings.warn(
+        message="gridappsd.field_interface is deprecated and will be removed in a future release. "
+        "Use gridappsd_field_bus.field_interface instead.",
+        category=DeprecationWarning,
+    )
+except ImportError as e:
+    _log.error(f"Could not import field_interface: {e}. Install gridappsd-field-bus to get those functions.")

gridappsd/goss.py

@@ -42,9 +42,11 @@ Created on March 1, 2018
 
 @author: Craig Allwardt
 """
+
 import base64
 import inspect
-#import json
+
+# import json
 import logging
 import os
 import random
@@ -78,22 +80,22 @@ class TimeoutError(Exception):
 
 
 class GOSS(object):
-    """ Base class providing connections to a GOSS instance via stomp protocol
-    """
-
-    def __init__(self,
-                 username=None,
-                 password=None,
-                 stomp_address='localhost',
-                 stomp_port='61613',
-                 attempt_connection=True,
-                 override_threading=None,
-                 stomp_log_level=logging.WARNING,
-                 goss_log_level=logging.INFO,
-                 use_auth_token=True):
-
-        logging.getLogger('stomp.py').setLevel(stomp_log_level)
-        logging.getLogger('goss').setLevel(goss_log_level)
+    """Base class providing connections to a GOSS instance via stomp protocol"""
+
+    def __init__(
+        self,
+        username=None,
+        password=None,
+        stomp_address="localhost",
+        stomp_port="61613",
+        attempt_connection=True,
+        override_threading=None,
+        stomp_log_level=logging.WARNING,
+        goss_log_level=logging.INFO,
+        use_auth_token=True,
+    ):
+        logging.getLogger("stomp.py").setLevel(stomp_log_level)
+        logging.getLogger("goss").setLevel(goss_log_level)
 
         self.__user__ = username
         self.__pass__ = password
@@ -154,12 +156,9 @@ class GOSS(object):
         if isinstance(message, list) or isinstance(message, dict):
             message = json.dumps(message)
         _log.debug("Sending topic: {} body: {}".format(topic, message))
-        self._conn.send(body=message,
-                        destination=topic,
-                        headers={
-                            'GOSS_HAS_SUBJECT': True,
-                            'GOSS_SUBJECT': self.__token
-                        })
+        self._conn.send(
+            body=message, destination=topic, headers={"GOSS_HAS_SUBJECT": True, "GOSS_SUBJECT": self.__token}
+        )
 
     def get_response(self, topic, message, timeout=5):
         id = datetime.now().strftime("%Y%m%d%h%M%S%f")[:-3]
@@ -168,8 +167,8 @@ class GOSS(object):
         if isinstance(message, str):
             message = json.loads(message)
 
-        if 'resultFormat' in message:
-            self.result_format = message['resultFormat']
+        if "resultFormat" in message:
+            self.result_format = message["resultFormat"]
 
         # Change message to string if we have a dictionary.
         if isinstance(message, dict):
@@ -178,17 +177,15 @@ class GOSS(object):
             message = json.dumps(message)
 
         class ResponseListener(object):
-
             def __init__(self, topic, result_format):
                 self.response = None
                 self._topic = topic
                 self.result_format = result_format
 
             def on_message(self, header, message):
-
                 _log.debug("Internal on message is: {} {}".format(header, message))
                 try:
-                    if self.result_format == 'JSON':
+                    if self.result_format == "JSON":
                         if isinstance(message, dict):
                             self.response = message
                         else:
@@ -196,9 +193,7 @@ class GOSS(object):
                     else:
                         self.response = message
                 except ValueError:
-                    self.response = dict(error="Invalid json returned",
-                                         header=header,
-                                         message=message)
+                    self.response = dict(error="Invalid json returned", header=header, message=message)
 
             def on_error(self, headers, message):
                 _log.error("ERR: {}".format(headers))
@@ -210,13 +205,11 @@ class GOSS(object):
         listener = ResponseListener(reply_to, self.result_format)
         self.subscribe(reply_to, listener)
 
-        self._conn.send(body=message,
-                        destination=topic,
-                        headers={
-                            'reply-to': reply_to,
-                            'GOSS_HAS_SUBJECT': True,
-                            'GOSS_SUBJECT': self.__token
-                        })
+        self._conn.send(
+            body=message,
+            destination=topic,
+            headers={"reply-to": reply_to, "GOSS_HAS_SUBJECT": True, "GOSS_SUBJECT": self.__token},
+        )
         count = 0
 
         while count < timeout:
@@ -255,8 +248,8 @@ class GOSS(object):
 
         self._make_connection()
 
-        if self._conn.get_listener('gridappsd') is None:
-            self._conn.set_listener('gridappsd', self._router_callback)
+        if self._conn.get_listener("gridappsd") is None:
+            self._conn.set_listener("gridappsd", self._router_callback)
 
         if callable(callback):
             self._router_callback.add_callback(topic, callback)
@@ -265,13 +258,12 @@ class GOSS(object):
             #                         CallbackWrapperListener(callback, conn_id))
         else:
             # Case where the callback is (supposedly) a class.
-            if not hasattr(callback, 'on_message'):
+            if not hasattr(callback, "on_message"):
                 m = "The given callback must have an 'on_message' method!"
                 raise AttributeError(m)
 
             if not callable(callback.on_message):
-                m = "The given callback's 'on_message' attribute must be " \
-                    "callable!"
+                m = "The given callback's 'on_message' attribute must be callable!"
                 raise TypeError(m)
 
             # Fix for https://github.com/GRIDAPPSD/GOSS-GridAPPS-D/issues/1072
@@ -284,7 +276,7 @@ class GOSS(object):
             #                         CallbackWrapperListener(callback.on_message, conn_id))
 
         _log.debug("Subscribing to {topic}".format(topic=topic))
-        self._conn.subscribe(destination=topic, ack='auto', id=conn_id)
+        self._conn.subscribe(destination=topic, ack="auto", id=conn_id)
 
         return conn_id
 
@@ -295,7 +287,6 @@ class GOSS(object):
         if self._conn is None or not self._conn.is_connected():
             _log.debug("Creating connection")
             if self.use_auth_token is True and not self.__token:
-
                 # get token
                 # get initial connection
                 dt = datetime.now()
@@ -309,13 +300,14 @@ class GOSS(object):
                 # send request to token topic
                 tokenTopic = "/topic/pnnl.goss.token.topic"
 
-                tmpConn = Connection([(self.stomp_address, self.stomp_port)], heartbeats=(self._heartbeat, self._heartbeat))
+                tmpConn = Connection(
+                    [(self.stomp_address, self.stomp_port)], heartbeats=(self._heartbeat, self._heartbeat)
+                )
                 if self._override_thread_fc is not None:
                     tmpConn.transport.override_threading(self._override_thread_fc)
                 tmpConn.connect(self.__user__, self.__pass__, wait=True)
 
-                class TokenResponseListener():
-
+                class TokenResponseListener:
                     def __init__(self):
                         self.__token = None
 
@@ -339,11 +331,9 @@ class GOSS(object):
                 listener = TokenResponseListener()
 
                 # self.subscribe(replyDest, listener)
-                tmpConn.subscribe('/queue/' + replyDest, 123)
-                tmpConn.set_listener('token_resp', listener)
-                tmpConn.send(body=base64Str,
-                             destination=tokenTopic,
-                             headers={'reply-to': replyDest})
+                tmpConn.subscribe("/queue/" + replyDest, 123)
+                tmpConn.set_listener("token_resp", listener)
+                tmpConn.send(body=base64Str, destination=tokenTopic, headers={"reply-to": replyDest})
                 # while token is null or for x iterations
                 iter = 0
                 while not self.__token and iter < 10:
@@ -352,14 +342,16 @@ class GOSS(object):
                     sleep(1)
                     iter += 1
 
-            self._conn = Connection([(self.stomp_address, self.stomp_port)], heartbeats=(self._heartbeat, self._heartbeat))
+            self._conn = Connection(
+                [(self.stomp_address, self.stomp_port)], heartbeats=(self._heartbeat, self._heartbeat)
+            )
             if self._override_thread_fc is not None:
                 self._conn.transport.override_threading(self._override_thread_fc)
             try:
                 if self.use_auth_token and self.__token is not None:
                     self._conn.connect(self.__token, "", wait=True)
                 else:
-                    self._conn.connect(self.__user__,self.__pass__, wait=True)
+                    self._conn.connect(self.__user__, self.__pass__, wait=True)
             except TypeError as e:
                 _log.error("TypeError: {e}".format(e=e))
             except NotConnectedException as e:
@@ -369,7 +361,6 @@ class GOSS(object):
 
 
 class CallbackRouter(object):
-
     def __init__(self):
         self.callbacks = {}
         self._topics_callback_map = defaultdict(list)
@@ -393,7 +384,7 @@ class CallbackRouter(object):
             sleep(0.01)
 
     def add_callback(self, topic, callback):
-        if not topic.startswith('/topic/') and not topic.startswith('/temp-queue/'):
+        if not topic.startswith("/topic/") and not topic.startswith("/temp-queue/"):
             topic = "/queue/{topic}".format(topic=topic)
         if callback in self._topics_callback_map[topic]:
             raise ValueError("Callbacks can only be used one time per topic")
@@ -409,7 +400,7 @@ class CallbackRouter(object):
                 pass
 
     def on_message(self, headers, message):
-        destination = headers['destination']
+        destination = headers["destination"]
         # _log.debug("Topic map keys are: {keys}".format(keys=self._topics_callback_map.keys()))
         if destination in self._topics_callback_map:
             self._queue_callerback.put((self._topics_callback_map[destination], headers, message))
@@ -421,13 +412,8 @@ class CallbackRouter(object):
         _log.error(header)
         _log.error(message)
 
-    def on_error(self, header, message):
-        _log.error("Error in callback router")
-        _log.error(header)
-        _log.error(message)
-
     def on_heartbeat_timeout(self):
         _log.error("Heartbeat timeout")
-        
+
     def on_disconnected(self):
         _log.info("Disconnected")