def connect(self): """ Initialize routing keys, publisher, and subscriber """ self._validate_metrics() if self._input_metrics is not None: # Sources have no input metrics for input_metric_key, input_metric_name in self._input_metrics.items(): self.routing_keys[input_metric_key] = _ROUTING_KEY % ( self.user_id, self.device_type, input_metric_name) for input_metric_key in self._input_metrics.keys(): sub = PikaSubscriber(self.rmq_address, self.rmq_user, self.rmq_pwd) sub.connect() sub.register(self.routing_keys[input_metric_key]) self.subscribers[input_metric_key] = sub if self._output_metrics is not None: # Sinks have no input metrics for output_metric_key, output_metric_name in self._output_metrics.items(): self.routing_keys[output_metric_key] = _ROUTING_KEY % ( self.user_id, self.device_type, output_metric_name) for output_metric_key in self._output_metrics.keys(): pub = PikaPublisher(self.rmq_address, self.rmq_user, self.rmq_pwd) pub.connect() pub.register(self.routing_keys[output_metric_key]) self.publishers[output_metric_key] = pub
def initialize(self): """ Initialize classifier, publisher (classification), and subscribers (mu and tag) """ self.classifiers["left"] = HTMClassifier(network_config, _TRAINING_DATA, _CATEGORIES) self.classifiers["right"] = HTMClassifier(network_config, _TRAINING_DATA, _CATEGORIES) for classifier in self.classifiers.values(): classifier.initialize() if _PRE_TRAIN: classifier.train(_TRAIN_SET_SIZE, partitions) self.tag_subscriber = PikaSubscriber(self.rmq_address, self.rmq_user, self.rmq_pwd) self.tag_publisher = PikaPublisher(self.rmq_address, self.rmq_user, self.rmq_pwd) self.mu_subscriber = PikaSubscriber(self.rmq_address, self.rmq_user, self.rmq_pwd) self.classification_publisher = PikaPublisher(self.rmq_address, self.rmq_user, self.rmq_pwd) self.tag_subscriber.connect() self.tag_publisher.connect() self.mu_subscriber.connect() self.classification_publisher.connect() self.tag_subscriber.subscribe(self.routing_keys["tag"]) self.tag_publisher.register(self.routing_keys["tag"]) self.mu_subscriber.subscribe(self.routing_keys["mu"]) self.classification_publisher.register(self.routing_keys["classification"])
def connect(self): """Initialize publisher and subscribers""" self.routing_keys = { self.input_metric: _ROUTING_KEY % (self.user_id, self.device_type, self.input_metric), self.output_metric: _ROUTING_KEY % (self.user_id, self.device_type, self.output_metric), self.tag_metric: _ROUTING_KEY % (self.user_id, self.device_type, self.tag_metric), } self.tag_subscriber = PikaSubscriber(self.rmq_address, self.rmq_user, self.rmq_pwd) self.classification_publisher = PikaPublisher(self.rmq_address, self.rmq_user, self.rmq_pwd) self.input_metric_subscriber = PikaSubscriber(self.rmq_address, self.rmq_user, self.rmq_pwd) self.output_metric_publisher = PikaPublisher(self.rmq_address, self.rmq_user, self.rmq_pwd) self.tag_subscriber.connect() self.classification_publisher.connect() self.input_metric_subscriber.connect() self.output_metric_publisher.connect() self.tag_subscriber.register(self.routing_keys[self.tag_metric]) self.classification_publisher.register(self.routing_keys[self.tag_metric]) self.input_metric_subscriber.register(self.routing_keys[self.input_metric]) self.output_metric_publisher.register(self.routing_keys[self.output_metric])
def connect(self): """ Initialize EEG preprocessor, publisher, and subscriber """ if self.step_size is None: raise ValueError("Step size can't be none. " "Use configure() to set it.") if self.electrodes_placement is None: raise ValueError("Electrode placement can't be none. " "Use configure() to set it.") if self.input_metric is None: raise ValueError("Input metric can't be none. " "Use configure() to set it.") if self.output_metric is None: raise ValueError("Output metric can't be none. " "Use configure() to set it.") self.routing_keys = { self.input_metric: _ROUTING_KEY % (self.user_id, self.device_type, self.input_metric), self.output_metric: _ROUTING_KEY % (self.user_id, self.device_type, self.output_metric) } self.mu_publisher = PikaPublisher(self.rmq_address, self.rmq_user, self.rmq_pwd) self.eeg_subscriber = PikaSubscriber(self.rmq_address, self.rmq_user, self.rmq_pwd) self.eeg_subscriber.connect() self.mu_publisher.connect() self.mu_publisher.register(self.routing_keys[self.output_metric]) self.eeg_subscriber.register(self.routing_keys[self.input_metric])
def initialize(self): """ Initialize EEG preprocessor, publisher, and subscriber """ self.mu_publisher = PikaPublisher(self.rmq_address, self.rmq_user, self.rmq_pwd) self.eeg_subscriber = PikaSubscriber(self.rmq_address, self.rmq_user, self.rmq_pwd) self.eeg_subscriber.connect() self.mu_publisher.connect() self.mu_publisher.register(self.routing_keys[_MU]) self.eeg_subscriber.subscribe(self.routing_keys[_EEG])
import json from brainsquared.subscribers.PikaSubscriber import PikaSubscriber host = "rabbitmq.cloudbrain.rocks" username = "******" pwd = "cloudbrain" user = "******" device = "openbci" metric = "classification" routing_key = "%s:%s:%s" % (user, device, metric) sub = PikaSubscriber(host, username, pwd) sub.connect() sub.subscribe(routing_key) def _print_message(ch, method, properties, body): print body while 1: try: (a,c,b) = sub.get_one_message(routing_key) if b: print json.loads(b) except KeyboardInterrupt: sub.disconnect()
class HTMMotorImageryModule(object): def __init__(self, user_id, module_id, device_type, rmq_address, rmq_user, rmq_pwd): self.stats = { "left": {"min": None, "max": None}, "right": {"min": None, "max": None} } self.module_id = module_id self.user_id = user_id self.device_type = device_type self.rmq_address = rmq_address self.rmq_user = rmq_user self.rmq_pwd = rmq_pwd self.classification_publisher = None self.mu_subscriber = None self.tag_subscriber = None self.tag_publisher = None self.routing_keys = { "mu": _ROUTING_KEY % (user_id, device_type, _MU), "tag": _ROUTING_KEY % (user_id, module_id, _TAG), "classification": _ROUTING_KEY % (user_id, module_id, _CLASSIFICATION) } self.start_time = int(time.time() * 1000) # in ms self.last_tag = {"timestamp": self.start_time, "value": _CATEGORIES[1]} self.classifiers = {"left": None, "right": None} self.numRecords = 0 self.learning_mode = True def initialize(self): """ Initialize classifier, publisher (classification), and subscribers (mu and tag) """ self.classifiers["left"] = HTMClassifier(network_config, _TRAINING_DATA, _CATEGORIES) self.classifiers["right"] = HTMClassifier(network_config, _TRAINING_DATA, _CATEGORIES) for classifier in self.classifiers.values(): classifier.initialize() if _PRE_TRAIN: classifier.train(_TRAIN_SET_SIZE, partitions) self.tag_subscriber = PikaSubscriber(self.rmq_address, self.rmq_user, self.rmq_pwd) self.tag_publisher = PikaPublisher(self.rmq_address, self.rmq_user, self.rmq_pwd) self.mu_subscriber = PikaSubscriber(self.rmq_address, self.rmq_user, self.rmq_pwd) self.classification_publisher = PikaPublisher(self.rmq_address, self.rmq_user, self.rmq_pwd) self.tag_subscriber.connect() self.tag_publisher.connect() self.mu_subscriber.connect() self.classification_publisher.connect() self.tag_subscriber.subscribe(self.routing_keys["tag"]) self.tag_publisher.register(self.routing_keys["tag"]) self.mu_subscriber.subscribe(self.routing_keys["mu"]) self.classification_publisher.register(self.routing_keys["classification"]) def start(self): _LOGGER.info("[Module %s] Starting Motor Imagery module. Routing keys: %s" % (self.module_id, self.routing_keys)) self.mu_subscriber.consume_messages(self.routing_keys["mu"], self._tag_and_classify) def _update_last_tag(self, last_tag): """Consume all tags in the queue and keep the last one (i.e. the most up to date)""" while 1: (meth_frame, header_frame, body) = self.tag_subscriber.get_one_message( self.routing_keys["tag"]) if body: last_tag = json.loads(body) else: return last_tag def _tag_and_classify(self, ch, method, properties, body): """Tag data and runs it through the classifier""" self.numRecords += 1 print self.numRecords if self.numRecords > 1000: self.learning_mode = False print "=======LEARNING DISABLED!!!=========" self.last_tag = self._update_last_tag(self.last_tag) _LOGGER.debug("[Module %s] mu: %s | last_tag: %s" % (self.module_id, body, self.last_tag)) mu = json.loads(body) mu_timestamp = mu["timestamp"] tag_timestamp = self.last_tag["timestamp"] results = {} for (hemisphere, classifier) in self.classifiers.items(): mu_value = mu[hemisphere] tag_value = self.last_tag["value"] mu_clipped = np.clip(mu_value, _MU_MIN, _MU_MAX) results[hemisphere] = classifier.classify(input_data=mu_clipped, target=tag_value, learning_is_on=self.learning_mode) self._update_stats(hemisphere, mu_value) #_LOGGER.debug(self.stats) _LOGGER.debug("Raw results: %s" % results) classification_result = _reconcile_results(results['left'], results['right']) buffer = [{"timestamp": mu_timestamp, "value": classification_result}] self.classification_publisher.publish(self.routing_keys["classification"], buffer) def _update_stats(self, hemisphere, mu_value): """ Update stats. self.stats = { "left": {"min": None, "max": None}, "right": {"min": None, "max": None} } """ min_val = self.stats[hemisphere]["min"] max_val = self.stats[hemisphere]["max"] if not min_val: self.stats[hemisphere]["min"] = mu_value if not max_val: self.stats[hemisphere]["max"] = mu_value if mu_value < min_val: self.stats[hemisphere]["min"] = mu_value if mu_value > max_val: self.stats[hemisphere]["max"] = mu_value
self.row_counter += 1 if now > _RECORDING_TIME + self.start_time: sys.exit(1) if __name__ == "__main__": opts = get_opts() host = opts.server username = opts.login pwd = opts.pwd user = opts.user device = opts.device metric = opts.metric channels = json.loads(opts.channels) tag = int(opts.tag) convert_to_nupic = bool(opts.nupic) routing_key = _ROUTING_KEY % (user, device, metric) sub = PikaSubscriber(host, username, pwd) sub.connect() sub.register(routing_key) _LOGGER.info("Consuming messages from queue '%s' at '%s'" % (routing_key, host)) csv_writer = CSVWriter(tag, channels, convert_to_nupic) sub.subscribe(routing_key, csv_writer.write_csv_files)
class HTMClassifier(object): def __init__(self, user_id, device_type, rmq_address, rmq_user, rmq_pwd, input_metrics, output_metrics): """ Motor Imagery Module. Metrics conventions: - Data to classify: {"timestamp": <int>, "channel_0": <float>} - Data label: {"timestamp": <int>, "channel_0": <int>} - Classification result: {"timestamp": <int>, "channel_0": <int>} @param user_id: (string) ID of the user using the device. @param device_type: (string) type of the device publishing to this module. @param rmq_address: (string) address of the RabbitMQ server. @param rmq_user: (string) login for RabbitMQ connection. @param rmq_pwd: (string) password for RabbitMQ connection. @param input_metrics: (list) name of the input metric. @param output_metrics (list) name of the output metric. """ self.module_id = HTMClassifier.__name__ self.user_id = user_id self.device_type = device_type self.rmq_address = rmq_address self.rmq_user = rmq_user self.rmq_pwd = rmq_pwd self.input_metrics = input_metrics self.output_metrics = output_metrics self.input_metric = None self.output_metric = None self.tag_metric = None self.last_tag = {"timestamp": None, "channel_0": None} self.output_metric_publisher = None self.input_metric_subscriber = None self.tag_subscriber = None self.routing_keys = None # Set when configure() is called. self.categories = None self.network_config = None self.trained_network_path = None self.minval = None self.maxval = None # Module specific self._network = None def _validate_metrics(self): """ Validate input and output metrics and initialize them accordingly. This module must have the following signature for input and output metrics: input_metrics = {"metric_to_classify": <string>, "label_metric": <string>} output_metrics = {"result_metric": <string>} """ if "label_metric" in self.input_metrics: self.tag_metric = self.input_metrics["label_metric"] else: raise KeyError("The input metric 'label_metric' is not set!") if "metric_to_classify" in self.input_metrics: self.input_metric = self.input_metrics["metric_to_classify"] else: raise KeyError("The input metric 'metric_to_classify' is not set!") if "result_metric" in self.output_metrics: self.output_metric = self.output_metrics["result_metric"] else: raise KeyError("The output metric 'result_metric' is not set!") def configure(self, categories, network_config, trained_network_path, minval, maxval): """Configure the module""" self._validate_metrics() self.categories = categories self.network_config = network_config self.trained_network_path = trained_network_path self.minval = minval self.maxval = maxval self.network_config["sensorRegionConfig"]["encoders"]["scalarEncoder"][ "minval"] = minval # Init tag with first category self.last_tag["channel_0"] = self.categories[0] self.last_tag["timestamp"] = int(time.time() * 1000) def connect(self): """Initialize publisher and subscribers""" self.routing_keys = { self.input_metric: _ROUTING_KEY % (self.user_id, self.device_type, self.input_metric), self.output_metric: _ROUTING_KEY % (self.user_id, self.device_type, self.output_metric), self.tag_metric: _ROUTING_KEY % (self.user_id, self.device_type, self.tag_metric), } self.tag_subscriber = PikaSubscriber(self.rmq_address, self.rmq_user, self.rmq_pwd) self.classification_publisher = PikaPublisher(self.rmq_address, self.rmq_user, self.rmq_pwd) self.input_metric_subscriber = PikaSubscriber(self.rmq_address, self.rmq_user, self.rmq_pwd) self.output_metric_publisher = PikaPublisher(self.rmq_address, self.rmq_user, self.rmq_pwd) self.tag_subscriber.connect() self.classification_publisher.connect() self.input_metric_subscriber.connect() self.output_metric_publisher.connect() self.tag_subscriber.register(self.routing_keys[self.tag_metric]) self.classification_publisher.register(self.routing_keys[self.tag_metric]) self.input_metric_subscriber.register(self.routing_keys[self.input_metric]) self.output_metric_publisher.register(self.routing_keys[self.output_metric]) def train(self, training_file, num_records): """Create a network and training it on a CSV data source""" dataSource = FileRecordStream(streamID=training_file) dataSource.setAutoRewind(True) self._network = configureNetwork(dataSource, self.network_config) for i in xrange(num_records): # Equivalent to: network.run(num_records) self._network.run(1) self._network.save(self.trained_network_path) def start(self): """Get data from rabbitMQ and classify input data""" if self._network is None: self._network = Network(self.trained_network_path) regionNames = self._get_all_regions_names() setNetworkLearningMode(self._network, regionNames, False) _LOGGER.info("[Module %s] Starting Motor Imagery module. Routing keys: %s" % (self.module_id, self.routing_keys)) self.input_metric_subscriber.subscribe( self.routing_keys[self.input_metric], self._tag_and_classify) def _get_all_regions_names(self): region_names = [] for region_config_key, region_config in self.network_config.items(): region_names.append(region_config["regionName"]) return region_names def _tag_and_classify(self, ch, method, properties, body): """Tag data and runs it through the classifier""" self._update_last_tag() input_data = simplejson.loads(body) timestamp = input_data["timestamp"] if self.maxval is not None and self.minval is not None: value = np.clip(input_data["channel_0"], self.minval, self.maxval) else: value = input_data["channel_0"] classificationResults = classifyNextRecord(self._network, self.network_config, timestamp, value, self.last_tag["channel_0"]) inferredCategory = classificationResults["bestInference"] _LOGGER.debug("Raw results: %s" % classificationResults) buffer = [{"timestamp": timestamp, "channel_0": inferredCategory}] self.output_metric_publisher.publish(self.routing_keys[self.output_metric], buffer) def _update_last_tag(self): """ Consume all tags in the queue and keep the last one (i.e. the most up to date) A tag is a dict with the following format: tag = {"timestamp": <int>, "channel_0": <float>} """ while 1: (meth_frame, header_frame, body) = self.tag_subscriber.get_one_message( self.routing_keys[self.tag_metric]) if body: self.last_tag = simplejson.loads(body) else: _LOGGER.info("Last tag: {}".format(self.last_tag)) return
"channel_1", "channel_2", "channel_3", "channel_4", "channel_5", "channel_6", "channel_7", "tag", ] if not os.path.exists(data_dir): os.makedirs(data_dir) file_name = "{}/test_{}.csv".format(data_dir, int(time.time())) tag_subscriber = PikaSubscriber(host, username, pwd) tag_subscriber.connect() tag_subscriber.register(tag_routing_key) eeg_subscriber = PikaSubscriber(host, username, pwd) eeg_subscriber.connect() eeg_subscriber.register(eeg_routing_key) f_out = open(file_name, "w") writer = csv.DictWriter(f_out, fieldnames=fieldnames) writer.writeheader() tag = 0 t1 = threading.Thread(target=tag_subscriber.subscribe, args=(tag_routing_key, consume_tag)) t2 = threading.Thread(target=eeg_subscriber.subscribe, args=(eeg_routing_key, consume_eeg))
def _print_message(ch, method, properties, body): buffer = json.loads(body) for data in buffer: print data if __name__ == "__main__": host = "127.0.0.1" username = "******" pwd = "guest" user = "******" device = "neurosky" metric = "attention" routing_key = "%s:%s:%s" % (user, device, metric) sub = PikaSubscriber(host, username, pwd) sub.connect() sub.register(routing_key) print "[DEBUG] Consuming messages from queue '%s' at '%s'" % (routing_key, host) while 1: try: sub.subscribe(routing_key, _print_message) except KeyboardInterrupt: sub.disconnect()
class PreprocessingModule(object): def __init__(self, user_id, device_type, rmq_address, rmq_user, rmq_pwd, input_metrics, output_metrics): self.module_id = str(uuid.uuid4()) self.user_id = user_id self.device_type = device_type self.rmq_address = rmq_address self.rmq_user = rmq_user self.rmq_pwd = rmq_pwd self.input_metrics = None self.output_metrics = None self.eeg_subscriber = None self.mu_publisher = None self.routing_keys = None self.preprocessor = None self.num_channels = get_num_channels(self.device_type, "eeg") self.eeg_data = np.zeros((0, self.num_channels)) self.count = 0 self.eyeblinks_remover = EyeBlinksFilter() self.step_size = None self.electrodes_placement = None self.enable_ica = False self.started_fit = False def configure(self, step_size, electrodes_placement, enable_ica=False): """ Module specific params. @param step_size: (int) STFT step size @param electrodes_placement: (dict) dict with the electrode placement for optional Laplacian filtering. E.g: { "channel_2": { "main": "channel_2", "artifact": ["channel_0", "channel_3", "channel_5"] }, "channel_4": { "main": "channel_4", "artifact": ["channel_1", "channel_3", "channel_6"] }, } If you don't want any Laplacian filtering then set this to: { "channel_2": { "main": "channel_2", "artifact": [] }, "channel_4": { "main": "channel_4", "artifact": [] }, } More about Laplacian filtering: http://sccn.ucsd.edu/wiki/Flt_laplace @param input_metric: (string) name of the input metric. @param output_metric: (string) name of the output metric. @param enable_ica: (boolean) if 1, enable ICA pre-processing. This will remove eye blinks. """ self.step_size = step_size self.electrodes_placement = electrodes_placement self.input_metric = input_metric self.output_metric = output_metric self.enable_ica = enable_ica def connect(self): """ Initialize EEG preprocessor, publisher, and subscriber """ if self.step_size is None: raise ValueError("Step size can't be none. " "Use configure() to set it.") if self.electrodes_placement is None: raise ValueError("Electrode placement can't be none. " "Use configure() to set it.") if self.input_metric is None: raise ValueError("Input metric can't be none. " "Use configure() to set it.") if self.output_metric is None: raise ValueError("Output metric can't be none. " "Use configure() to set it.") self.routing_keys = { self.input_metric: _ROUTING_KEY % (self.user_id, self.device_type, self.input_metric), self.output_metric: _ROUTING_KEY % (self.user_id, self.device_type, self.output_metric) } self.mu_publisher = PikaPublisher(self.rmq_address, self.rmq_user, self.rmq_pwd) self.eeg_subscriber = PikaSubscriber(self.rmq_address, self.rmq_user, self.rmq_pwd) self.eeg_subscriber.connect() self.mu_publisher.connect() self.mu_publisher.register(self.routing_keys[self.output_metric]) self.eeg_subscriber.register(self.routing_keys[self.input_metric]) def start(self): _LOGGER.info("[Module %s] Starting Preprocessing. Routing " "keys: %s" % (self.module_id, self.routing_keys)) self.eeg_subscriber.subscribe(self.routing_keys[self.input_metric], self._preprocess) def refit_ica(self): t = Thread(target=self.eyeblinks_remover.fit, args=(self.eeg_data,)) t.start() def _preprocess(self, ch, method, properties, body): eeg = json.loads(body) self.eeg_data = np.vstack([self.eeg_data, get_raw(eeg, self.num_channels)]) self.count += self.step_size timestamp = eeg[-1]["timestamp"] if self.enable_ica: eeg = from_raw(self.eyeblinks_remover.transform( get_raw(eeg, self.num_channels)), self.num_channels) if ((self.count >= 5000 and not self.started_fit) or self.count % 10000 == 0): _LOGGER.info('refitting...') self.started_fit = True self.refit_ica() processed_data = preprocess_stft(eeg, self.electrodes_placement) data = {"timestamp": timestamp} for key, value in processed_data.items(): data[key] = processed_data[key][-1] _LOGGER.debug("--> output: %s" % data) self.mu_publisher.publish(self.routing_keys[self.output_metric], data)
class PreprocessingModule(object): def __init__(self, user_id, module_id, device_type, rmq_address, rmq_user, rmq_pwd, step_size): self.user_id = user_id self.module_id = module_id self.device_type = device_type self.rmq_address = rmq_address self.rmq_user = rmq_user self.rmq_pwd = rmq_pwd self.eeg_subscriber = None self.mu_publisher = None self.routing_keys = { _EEG: _ROUTING_KEY % (user_id, device_type, _EEG), _MU: _ROUTING_KEY % (user_id, device_type, _MU), } self.preprocessor = None self.eeg_data = np.zeros((0, 8)) self.count = 0 self.eyeblinks_remover = EyeBlinksRemover() self.step_size = step_size self.started_fit = False def initialize(self): """ Initialize EEG preprocessor, publisher, and subscriber """ self.mu_publisher = PikaPublisher(self.rmq_address, self.rmq_user, self.rmq_pwd) self.eeg_subscriber = PikaSubscriber(self.rmq_address, self.rmq_user, self.rmq_pwd) self.eeg_subscriber.connect() self.mu_publisher.connect() self.mu_publisher.register(self.routing_keys[_MU]) self.eeg_subscriber.subscribe(self.routing_keys[_EEG]) def start(self): _LOGGER.info("[Module %s] Starting Preprocessing. Routing " "keys: %s" % (self.module_id, self.routing_keys)) self.eeg_subscriber.consume_messages(self.routing_keys[_EEG], self._preprocess) def refit_ica(self): t = Thread(target=self.eyeblinks_remover.fit, args=(self.eeg_data[1000:],)) t.start() # self.eyeblinks_remover.fit(self.eeg_data[1000:]) def _preprocess(self, ch, method, properties, body): eeg = json.loads(body) self.eeg_data = np.vstack([self.eeg_data, get_raw(eeg)]) # self.count += len(eeg) self.count += self.step_size print(self.count) if (self.count >= 5000 and not self.started_fit) or self.count % 10000 == 0: _LOGGER.info("refitting...") self.started_fit = True self.refit_ica() timestamp = eeg[-1]["timestamp"] eeg = from_raw(self.eyeblinks_remover.transform(get_raw(eeg))) process = preprocess_stft(eeg, _METADATA) mu_left = process["left"][-1] mu_right = process["right"][-1] data = {"timestamp": timestamp, "left": mu_left, "right": mu_right} _LOGGER.debug("--> mu: %s" % data) if self.eyeblinks_remover.fitted: self.mu_publisher.publish(self.routing_keys[_MU], data)
import json from brainsquared.subscribers.PikaSubscriber import PikaSubscriber host = "rabbitmq.cloudbrain.rocks" username = "******" pwd = "cloudbrain" user = "******" device = "openbci" metric = "classification" routing_key = "%s:%s:%s" % (user, device, metric) sub = PikaSubscriber(host, username, pwd) sub.connect() sub.register(routing_key) def _print_message(ch, method, properties, body): print body while 1: try: (a,c,b) = sub.get_one_message(routing_key) if b: print json.loads(b) except KeyboardInterrupt: sub.disconnect()