"""Build OSC messages for client applications.""" try: import builtins except ImportError: # for python 2.x import __builtin__ as builtins from pythonosc import osc_message from pythonosc.parsing import osc_types class BuildError(Exception): """Error raised when an incomplete message is trying to be built.""" class OscMessageBuilder(object): """Builds arbitrary OscMessage instances.""" ARG_TYPE_FLOAT = "f" ARG_TYPE_INT = "i" ARG_TYPE_STRING = "s" ARG_TYPE_BLOB = "b" ARG_TYPE_TRUE = "T" ARG_TYPE_FALSE = "F" _SUPPORTED_ARG_TYPES = ( ARG_TYPE_FLOAT, ARG_TYPE_INT, ARG_TYPE_BLOB, ARG_TYPE_STRING, ARG_TYPE_TRUE, ARG_TYPE_FALSE) def __init__(self, address=None): """Initialize a new builder for a message. Args: - address: The osc address to send this message to. """ self._address = address self._args = [] @property def address(self): """Returns the OSC address this message will be sent to.""" return self._address @address.setter def address(self, value): """Sets the OSC address this message will be sent to.""" self._address = value @property def args(self): """Returns the (type, value) arguments list of this message.""" return self._args def add_arg(self, arg_value, arg_type=None): """Add a typed argument to this message. Args: - arg_value: The corresponding value for the argument. - arg_type: A value in ARG_TYPE_* defined in this class, if none then the type will be guessed. Raises: - ValueError: if the type is not supported. """ if arg_type and arg_type not in self._SUPPORTED_ARG_TYPES: raise ValueError( 'arg_type must be one of {}'.format(self._SUPPORTED_ARG_TYPES)) if not arg_type: builtin_type = type(arg_value) if builtin_type == builtins.str: arg_type = self.ARG_TYPE_STRING elif builtin_type == builtins.bytes: arg_type = self.ARG_TYPE_BLOB elif builtin_type == builtins.int: arg_type = self.ARG_TYPE_INT elif builtin_type == builtins.float: arg_type = self.ARG_TYPE_FLOAT elif builtin_type == builtins.bool and arg_value: arg_type = self.ARG_TYPE_TRUE elif builtin_type == builtins.bool and not arg_value: arg_type = self.ARG_TYPE_FALSE self._args.append((arg_type, arg_value)) def build(self): """Builds an OscMessage from the current state of this builder. Raises: - BuildError: if the message could not be build or if the address was empty. Returns: - an osc_message.OscMessage instance. """ if not self._address: raise BuildError('OSC addresses cannot be empty') dgram = b'' try: # Write the address. dgram += osc_types.write_string(self._address) if not self._args: return osc_message.OscMessage(dgram) # Write the parameters. arg_types = "".join([arg[0] for arg in self._args]) dgram += osc_types.write_string(',' + arg_types) for arg_type, value in self._args: if arg_type == self.ARG_TYPE_STRING: dgram += osc_types.write_string(value) elif arg_type == self.ARG_TYPE_INT: dgram += osc_types.write_int(value) elif arg_type == self.ARG_TYPE_FLOAT: dgram += osc_types.write_float(value) elif arg_type == self.ARG_TYPE_BLOB: dgram += osc_types.write_blob(value) elif arg_type == self.ARG_TYPE_TRUE or arg_type == self.ARG_TYPE_FALSE: continue else: raise BuildError('Incorrect parameter type found {}'.format( arg_type)) return osc_message.OscMessage(dgram) except osc_types.BuildError as be: raise BuildError('Could not build the message: {}'.format(be))