hlrc

    def __init__(self, mw_name, scope, loglevel=logging.WARNING):

	"""initialise

	:param mw_name: which mw to use, currentyl ROS and RSB are supported

	:param scope: base scope we want to listen on

	:param  loglevel: optional log level

	"""

	self.logger = logging.getLogger(__name__)

	# create nice and actually usable formatter and add it to the handler

	self.config_logger(loglevel)

	#store

	self.scope = scope

	self.mw = mw_name

	self.loglevel = loglevel

	self.middleware = None

	if (self.mw.upper() == "RSB"):

	    self.logger.info("creating new middleware connection via RSB")

	    try:

		from MiddlewareRSB import MiddlewareRSB

		except ImportError, e:

		    self.logger.error("failed to import RSB or the necessary data types: {}".format(e))

		    sys.exit(errno.EINVAL)

		    #import worked, safe to intantiate RSB mw now

		    self.middleware = MiddlewareRSB(self.scope, self.loglevel)

		    elif (self.mw.upper() == "ROS"):

			    from MiddlewareROS import MiddlewareROS

			    except ImportError, e:

				self.logger.error("failed to import ROS or the necessary data types: {}".format(e))

				sys.exit(errno.EINVAL)

				#import worked, safe to intantiate RSB mw now

				self.middleware = MiddlewareROS(self.scope, self.loglevel)

				else:

				    self.logger.error("invalid middleware requested (%s). supported: {ROS, RSB}\n\n" % (self.mw))

				    sys.exit(errno.EINVAL)

				    def __del__(self):

					"""destructor

					"""

					self.logger.debug("destructor of RobotController called")

					def config_logger(self, level):

					    """initialise a nice logger formatting

					    :param  level: log level

					    """

					    formatter = logging.Formatter('%(asctime)s %(name)-30s %(levelname)-8s > %(message)s')

					    ch = logging.StreamHandler()

					    #ch.setLevel(level)

					    ch.setFormatter(formatter)

					    self.logger.setLevel(level)

					    self.logger.addHandler(ch)

					    def set_current_emotion(self, robot_emotion, blocking = False):

						"""set the current emotion

						:param robot_emotion: a RobotEmotion object

						:param blocking: should this call block during execution?

						"""

						self.logger.debug("set_current_emotion(%s) %s" % (robot_emotion, ("BLOCKING" if blocking else "NON_BLOCKING")))

						self.middleware.set_current_emotion(robot_emotion, blocking)

						def set_default_emotion(self, robot_emotion, blocking = False):

						    """set the default emotion

						    :param robot_emotion: a RobotEmotion object

						    :param blocking: should this call block during execution?

						    """

						    self.logger.debug("set_default_emotion(%s) %s" % (robot_emotion, ("BLOCKING" if blocking else "NON_BLOCKING")))

						    self.middleware.set_default_emotion(robot_emotion, blocking)

						    def set_gaze_target(self, robot_gaze, blocking = False):

							"""set a gaze target

							:param robot_gaze: a RobotGaze object

							:param blocking: should this call block during execution?

							"""

							self.logger.debug("set_gaze_target(%s) %s" % (robot_gaze, ("BLOCKING" if blocking else "NON_BLOCKING")))

							self.middleware.set_gaze_target(robot_gaze, blocking)

							def set_mouth_target(self, robot_mouth, blocking = False):

							    """set a mouth target

							    :param robot_mouth: a RobotMouth object

							    :param blocking: should this call block during execution?

							    """

							    self.logger.debug("set_mouth_target(%s) %s" % (robot_mouth, ("BLOCKING" if blocking else "NON_BLOCKING")))

							    self.middleware.set_mouth_target(robot_mouth, blocking)

							    def set_head_animation(self, robot_animation, blocking = False):

								"""set a head animation

								:param robot_animation: a RobotAnimation object

								:param blocking: should this call block during execution?

								"""

								self.logger.debug("set_head_animation(%s) %s" % (robot_animation, ("BLOCKING" if blocking else "NON_BLOCKING")))

								self.middleware.set_head_animation(robot_animation, blocking)

								def set_speak(self, text, blocking = False):

								    """request the robot to say something using tts

								    :param text: text to synthesize

								    :param blocking: should this call block during execution?

								    """

								    self.logger.debug("set_speak(%s) %s" % (text, ("BLOCKING" if blocking else "NON_BLOCKING")))

								    self.middleware.set_speak(text, blocking)

								    #def get_gaze_target(self):

									#	result = self.middleware.get_gaze_target()

									#	self.logger.debug("get_gaze_target() returned %s" % (result))

									#	return self.middleware.get_gaze_target()