""" Autogenerated python message buffer code. Source: clad/vizInterface/messageViz.clad Full command line: victor-clad/tools/message-buffers/emitters/Python_emitter.py -C vizSrc -I clad/src lib/util/source/anki/clad robot/clad/src coretech/vision/clad_src coretech/common/clad_src -o generated/cladPython clad/vizInterface/messageViz.clad """ from __future__ import absolute_import from __future__ import print_function def _modify_path(): import inspect, os, sys search_paths = [ '../..', '../../../../victor-clad/tools/message-buffers/support/python', ] currentpath = os.path.abspath(os.path.dirname(inspect.getfile(inspect.currentframe()))) for search_path in search_paths: search_path = os.path.normpath(os.path.abspath(os.path.realpath(os.path.join(currentpath, search_path)))) if search_path not in sys.path: sys.path.insert(0, search_path) _modify_path() import msgbuffers Anki = msgbuffers.Namespace() Anki.Vector = msgbuffers.Namespace() Anki.Vector.ExternalInterface = msgbuffers.Namespace() Anki.Vector.RobotInterface = msgbuffers.Namespace() Anki.Vector.VizInterface = msgbuffers.Namespace() Anki.Vision = msgbuffers.Namespace() from clad.robotInterface.messageFromAnimProcess import Anki as _Anki Anki.update(_Anki.deep_clone()) from clad.types.activeObjectAccel import Anki as _Anki Anki.update(_Anki.deep_clone()) from clad.types.cameraParams import Anki as _Anki Anki.update(_Anki.deep_clone()) from clad.types.globalVizOrigin import Anki as _Anki Anki.update(_Anki.deep_clone()) from clad.types.imageTypes import Anki as _Anki Anki.update(_Anki.deep_clone()) from clad.types.memoryMap import Anki as _Anki Anki.update(_Anki.deep_clone()) from clad.types.objectTypes import Anki as _Anki Anki.update(_Anki.deep_clone()) from clad.types.offTreadsStates import Anki as _Anki Anki.update(_Anki.deep_clone()) from clad.types.robotStatusAndActions import Anki as _Anki Anki.update(_Anki.deep_clone()) from clad.types.visionModes import Anki as _Anki Anki.update(_Anki.deep_clone()) from clad.types.vizTypes import Anki as _Anki Anki.update(_Anki.deep_clone()) class RobotStateMessage(object): "Generated message-passing message." __slots__ = ( '_state', # Anki.Vector.RobotState '_imuTemperature_degC', # float_32 '_cliffThresholds', # uint_16[4] '_videoFramePeriodMs', # uint_16 '_imageProcPeriodMs', # uint_16 '_lockedAnimTracks', # uint_8 '_animTracksInUse', # uint_8 '_batteryVolts', # float_32 '_offTreadsState', # Anki.Vector.OffTreadsState '_awaitingConfirmationTreadState', # Anki.Vector.OffTreadsState ) @property def state(self): "Anki.Vector.RobotState state struct property." return self._state @state.setter def state(self, value): self._state = msgbuffers.validate_object( 'RobotStateMessage.state', value, Anki.Vector.RobotState) @property def imuTemperature_degC(self): "float_32 imuTemperature_degC struct property." return self._imuTemperature_degC @imuTemperature_degC.setter def imuTemperature_degC(self, value): self._imuTemperature_degC = msgbuffers.validate_float( 'RobotStateMessage.imuTemperature_degC', value, 'f') @property def cliffThresholds(self): "uint_16[4] cliffThresholds struct property." return self._cliffThresholds @cliffThresholds.setter def cliffThresholds(self, value): self._cliffThresholds = msgbuffers.validate_farray( 'RobotStateMessage.cliffThresholds', value, 4, lambda name, value_inner: msgbuffers.validate_integer( name, value_inner, 0, 65535)) @property def videoFramePeriodMs(self): "uint_16 videoFramePeriodMs struct property." return self._videoFramePeriodMs @videoFramePeriodMs.setter def videoFramePeriodMs(self, value): self._videoFramePeriodMs = msgbuffers.validate_integer( 'RobotStateMessage.videoFramePeriodMs', value, 0, 65535) @property def imageProcPeriodMs(self): "uint_16 imageProcPeriodMs struct property." return self._imageProcPeriodMs @imageProcPeriodMs.setter def imageProcPeriodMs(self, value): self._imageProcPeriodMs = msgbuffers.validate_integer( 'RobotStateMessage.imageProcPeriodMs', value, 0, 65535) @property def lockedAnimTracks(self): "uint_8 lockedAnimTracks struct property." return self._lockedAnimTracks @lockedAnimTracks.setter def lockedAnimTracks(self, value): self._lockedAnimTracks = msgbuffers.validate_integer( 'RobotStateMessage.lockedAnimTracks', value, 0, 255) @property def animTracksInUse(self): "uint_8 animTracksInUse struct property." return self._animTracksInUse @animTracksInUse.setter def animTracksInUse(self, value): self._animTracksInUse = msgbuffers.validate_integer( 'RobotStateMessage.animTracksInUse', value, 0, 255) @property def batteryVolts(self): "float_32 batteryVolts struct property." return self._batteryVolts @batteryVolts.setter def batteryVolts(self, value): self._batteryVolts = msgbuffers.validate_float( 'RobotStateMessage.batteryVolts', value, 'f') @property def offTreadsState(self): "Anki.Vector.OffTreadsState offTreadsState struct property." return self._offTreadsState @offTreadsState.setter def offTreadsState(self, value): self._offTreadsState = msgbuffers.validate_integer( 'RobotStateMessage.offTreadsState', value, -128, 127) @property def awaitingConfirmationTreadState(self): "Anki.Vector.OffTreadsState awaitingConfirmationTreadState struct property." return self._awaitingConfirmationTreadState @awaitingConfirmationTreadState.setter def awaitingConfirmationTreadState(self, value): self._awaitingConfirmationTreadState = msgbuffers.validate_integer( 'RobotStateMessage.awaitingConfirmationTreadState', value, -128, 127) def __init__(self, state=Anki.Vector.RobotState(), imuTemperature_degC=0.0, cliffThresholds=(0,) * 4, videoFramePeriodMs=0, imageProcPeriodMs=0, lockedAnimTracks=0, animTracksInUse=0, batteryVolts=0.0, offTreadsState=Anki.Vector.OffTreadsState.OnTreads, awaitingConfirmationTreadState=Anki.Vector.OffTreadsState.OnTreads): self.state = state self.imuTemperature_degC = imuTemperature_degC self.cliffThresholds = cliffThresholds self.videoFramePeriodMs = videoFramePeriodMs self.imageProcPeriodMs = imageProcPeriodMs self.lockedAnimTracks = lockedAnimTracks self.animTracksInUse = animTracksInUse self.batteryVolts = batteryVolts self.offTreadsState = offTreadsState self.awaitingConfirmationTreadState = awaitingConfirmationTreadState @classmethod def unpack(cls, buffer): "Reads a new RobotStateMessage from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('RobotStateMessage.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new RobotStateMessage from the given BinaryReader." _state = reader.read_object(Anki.Vector.RobotState.unpack_from) _imuTemperature_degC = reader.read('f') _cliffThresholds = reader.read_farray('H', 4) _videoFramePeriodMs = reader.read('H') _imageProcPeriodMs = reader.read('H') _lockedAnimTracks = reader.read('B') _animTracksInUse = reader.read('B') _batteryVolts = reader.read('f') _offTreadsState = reader.read('b') _awaitingConfirmationTreadState = reader.read('b') return cls(_state, _imuTemperature_degC, _cliffThresholds, _videoFramePeriodMs, _imageProcPeriodMs, _lockedAnimTracks, _animTracksInUse, _batteryVolts, _offTreadsState, _awaitingConfirmationTreadState) def pack(self): "Writes the current RobotStateMessage, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current RobotStateMessage to the given BinaryWriter." writer.write_object(self._state) writer.write(self._imuTemperature_degC, 'f') writer.write_farray(self._cliffThresholds, 'H', 4) writer.write(self._videoFramePeriodMs, 'H') writer.write(self._imageProcPeriodMs, 'H') writer.write(self._lockedAnimTracks, 'B') writer.write(self._animTracksInUse, 'B') writer.write(self._batteryVolts, 'f') writer.write(self._offTreadsState, 'b') writer.write(self._awaitingConfirmationTreadState, 'b') def __eq__(self, other): if type(self) is type(other): return (self._state == other._state and self._imuTemperature_degC == other._imuTemperature_degC and self._cliffThresholds == other._cliffThresholds and self._videoFramePeriodMs == other._videoFramePeriodMs and self._imageProcPeriodMs == other._imageProcPeriodMs and self._lockedAnimTracks == other._lockedAnimTracks and self._animTracksInUse == other._animTracksInUse and self._batteryVolts == other._batteryVolts and self._offTreadsState == other._offTreadsState and self._awaitingConfirmationTreadState == other._awaitingConfirmationTreadState) else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size_object(self._state) + msgbuffers.size(self._imuTemperature_degC, 'f') + msgbuffers.size_farray(self._cliffThresholds, 'H', 4) + msgbuffers.size(self._videoFramePeriodMs, 'H') + msgbuffers.size(self._imageProcPeriodMs, 'H') + msgbuffers.size(self._lockedAnimTracks, 'B') + msgbuffers.size(self._animTracksInUse, 'B') + msgbuffers.size(self._batteryVolts, 'f') + msgbuffers.size(self._offTreadsState, 'b') + msgbuffers.size(self._awaitingConfirmationTreadState, 'b')) def __str__(self): return '{type}(state={state}, imuTemperature_degC={imuTemperature_degC}, cliffThresholds={cliffThresholds}, videoFramePeriodMs={videoFramePeriodMs}, imageProcPeriodMs={imageProcPeriodMs}, lockedAnimTracks={lockedAnimTracks}, animTracksInUse={animTracksInUse}, batteryVolts={batteryVolts}, offTreadsState={offTreadsState}, awaitingConfirmationTreadState={awaitingConfirmationTreadState})'.format( type=type(self).__name__, state=self._state, imuTemperature_degC=self._imuTemperature_degC, cliffThresholds=msgbuffers.shorten_sequence(self._cliffThresholds), videoFramePeriodMs=self._videoFramePeriodMs, imageProcPeriodMs=self._imageProcPeriodMs, lockedAnimTracks=self._lockedAnimTracks, animTracksInUse=self._animTracksInUse, batteryVolts=self._batteryVolts, offTreadsState=self._offTreadsState, awaitingConfirmationTreadState=self._awaitingConfirmationTreadState) def __repr__(self): return '{type}(state={state}, imuTemperature_degC={imuTemperature_degC}, cliffThresholds={cliffThresholds}, videoFramePeriodMs={videoFramePeriodMs}, imageProcPeriodMs={imageProcPeriodMs}, lockedAnimTracks={lockedAnimTracks}, animTracksInUse={animTracksInUse}, batteryVolts={batteryVolts}, offTreadsState={offTreadsState}, awaitingConfirmationTreadState={awaitingConfirmationTreadState})'.format( type=type(self).__name__, state=repr(self._state), imuTemperature_degC=repr(self._imuTemperature_degC), cliffThresholds=repr(self._cliffThresholds), videoFramePeriodMs=repr(self._videoFramePeriodMs), imageProcPeriodMs=repr(self._imageProcPeriodMs), lockedAnimTracks=repr(self._lockedAnimTracks), animTracksInUse=repr(self._animTracksInUse), batteryVolts=repr(self._batteryVolts), offTreadsState=repr(self._offTreadsState), awaitingConfirmationTreadState=repr(self._awaitingConfirmationTreadState)) Anki.Vector.VizInterface.RobotStateMessage = RobotStateMessage del RobotStateMessage class CurrentAnimation(object): "Generated message-passing message." __slots__ = ( '_tag', # uint_8 '_animName', # string[uint_8] ) @property def tag(self): "uint_8 tag struct property." return self._tag @tag.setter def tag(self, value): self._tag = msgbuffers.validate_integer( 'CurrentAnimation.tag', value, 0, 255) @property def animName(self): "string[uint_8] animName struct property." return self._animName @animName.setter def animName(self, value): self._animName = msgbuffers.validate_string( 'CurrentAnimation.animName', value, 255) def __init__(self, tag=0, animName=''): self.tag = tag self.animName = animName @classmethod def unpack(cls, buffer): "Reads a new CurrentAnimation from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('CurrentAnimation.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new CurrentAnimation from the given BinaryReader." _tag = reader.read('B') _animName = reader.read_string('B') return cls(_tag, _animName) def pack(self): "Writes the current CurrentAnimation, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current CurrentAnimation to the given BinaryWriter." writer.write(self._tag, 'B') writer.write_string(self._animName, 'B') def __eq__(self, other): if type(self) is type(other): return (self._tag == other._tag and self._animName == other._animName) else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._tag, 'B') + msgbuffers.size_string(self._animName, 'B')) def __str__(self): return '{type}(tag={tag}, animName={animName})'.format( type=type(self).__name__, tag=self._tag, animName=msgbuffers.shorten_string(self._animName)) def __repr__(self): return '{type}(tag={tag}, animName={animName})'.format( type=type(self).__name__, tag=repr(self._tag), animName=repr(self._animName)) Anki.Vector.VizInterface.CurrentAnimation = CurrentAnimation del CurrentAnimation class Object(object): "Generated message-passing message." __slots__ = ( '_objectID', # uint_32 '_objectTypeID', # Anki.Vector.VizObjectType '_color', # uint_32 '_x_size_m', # float_32 '_y_size_m', # float_32 '_z_size_m', # float_32 '_x_trans_m', # float_32 '_y_trans_m', # float_32 '_z_trans_m', # float_32 '_rot_deg', # float_32 '_rot_axis_x', # float_32 '_rot_axis_y', # float_32 '_rot_axis_z', # float_32 '_objParameters', # float_32[4] '_text', # string[uint_8] ) @property def objectID(self): "uint_32 objectID struct property." return self._objectID @objectID.setter def objectID(self, value): self._objectID = msgbuffers.validate_integer( 'Object.objectID', value, 0, 4294967295) @property def objectTypeID(self): "Anki.Vector.VizObjectType objectTypeID struct property." return self._objectTypeID @objectTypeID.setter def objectTypeID(self, value): self._objectTypeID = msgbuffers.validate_integer( 'Object.objectTypeID', value, 0, 4294967295) @property def color(self): "uint_32 color struct property." return self._color @color.setter def color(self, value): self._color = msgbuffers.validate_integer( 'Object.color', value, 0, 4294967295) @property def x_size_m(self): "float_32 x_size_m struct property." return self._x_size_m @x_size_m.setter def x_size_m(self, value): self._x_size_m = msgbuffers.validate_float( 'Object.x_size_m', value, 'f') @property def y_size_m(self): "float_32 y_size_m struct property." return self._y_size_m @y_size_m.setter def y_size_m(self, value): self._y_size_m = msgbuffers.validate_float( 'Object.y_size_m', value, 'f') @property def z_size_m(self): "float_32 z_size_m struct property." return self._z_size_m @z_size_m.setter def z_size_m(self, value): self._z_size_m = msgbuffers.validate_float( 'Object.z_size_m', value, 'f') @property def x_trans_m(self): "float_32 x_trans_m struct property." return self._x_trans_m @x_trans_m.setter def x_trans_m(self, value): self._x_trans_m = msgbuffers.validate_float( 'Object.x_trans_m', value, 'f') @property def y_trans_m(self): "float_32 y_trans_m struct property." return self._y_trans_m @y_trans_m.setter def y_trans_m(self, value): self._y_trans_m = msgbuffers.validate_float( 'Object.y_trans_m', value, 'f') @property def z_trans_m(self): "float_32 z_trans_m struct property." return self._z_trans_m @z_trans_m.setter def z_trans_m(self, value): self._z_trans_m = msgbuffers.validate_float( 'Object.z_trans_m', value, 'f') @property def rot_deg(self): "float_32 rot_deg struct property." return self._rot_deg @rot_deg.setter def rot_deg(self, value): self._rot_deg = msgbuffers.validate_float( 'Object.rot_deg', value, 'f') @property def rot_axis_x(self): "float_32 rot_axis_x struct property." return self._rot_axis_x @rot_axis_x.setter def rot_axis_x(self, value): self._rot_axis_x = msgbuffers.validate_float( 'Object.rot_axis_x', value, 'f') @property def rot_axis_y(self): "float_32 rot_axis_y struct property." return self._rot_axis_y @rot_axis_y.setter def rot_axis_y(self, value): self._rot_axis_y = msgbuffers.validate_float( 'Object.rot_axis_y', value, 'f') @property def rot_axis_z(self): "float_32 rot_axis_z struct property." return self._rot_axis_z @rot_axis_z.setter def rot_axis_z(self, value): self._rot_axis_z = msgbuffers.validate_float( 'Object.rot_axis_z', value, 'f') @property def objParameters(self): "float_32[4] objParameters struct property." return self._objParameters @objParameters.setter def objParameters(self, value): self._objParameters = msgbuffers.validate_farray( 'Object.objParameters', value, 4, lambda name, value_inner: msgbuffers.validate_float( name, value_inner, 'f')) @property def text(self): "string[uint_8] text struct property." return self._text @text.setter def text(self, value): self._text = msgbuffers.validate_string( 'Object.text', value, 255) def __init__(self, objectID=0, objectTypeID=Anki.Vector.VizObjectType.VIZ_OBJECT_ROBOT, color=0, x_size_m=0.0, y_size_m=0.0, z_size_m=0.0, x_trans_m=0.0, y_trans_m=0.0, z_trans_m=0.0, rot_deg=0.0, rot_axis_x=0.0, rot_axis_y=0.0, rot_axis_z=0.0, objParameters=(0.0,) * 4, text=''): self.objectID = objectID self.objectTypeID = objectTypeID self.color = color self.x_size_m = x_size_m self.y_size_m = y_size_m self.z_size_m = z_size_m self.x_trans_m = x_trans_m self.y_trans_m = y_trans_m self.z_trans_m = z_trans_m self.rot_deg = rot_deg self.rot_axis_x = rot_axis_x self.rot_axis_y = rot_axis_y self.rot_axis_z = rot_axis_z self.objParameters = objParameters self.text = text @classmethod def unpack(cls, buffer): "Reads a new Object from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('Object.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new Object from the given BinaryReader." _objectID = reader.read('I') _objectTypeID = reader.read('I') _color = reader.read('I') _x_size_m = reader.read('f') _y_size_m = reader.read('f') _z_size_m = reader.read('f') _x_trans_m = reader.read('f') _y_trans_m = reader.read('f') _z_trans_m = reader.read('f') _rot_deg = reader.read('f') _rot_axis_x = reader.read('f') _rot_axis_y = reader.read('f') _rot_axis_z = reader.read('f') _objParameters = reader.read_farray('f', 4) _text = reader.read_string('B') return cls(_objectID, _objectTypeID, _color, _x_size_m, _y_size_m, _z_size_m, _x_trans_m, _y_trans_m, _z_trans_m, _rot_deg, _rot_axis_x, _rot_axis_y, _rot_axis_z, _objParameters, _text) def pack(self): "Writes the current Object, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current Object to the given BinaryWriter." writer.write(self._objectID, 'I') writer.write(self._objectTypeID, 'I') writer.write(self._color, 'I') writer.write(self._x_size_m, 'f') writer.write(self._y_size_m, 'f') writer.write(self._z_size_m, 'f') writer.write(self._x_trans_m, 'f') writer.write(self._y_trans_m, 'f') writer.write(self._z_trans_m, 'f') writer.write(self._rot_deg, 'f') writer.write(self._rot_axis_x, 'f') writer.write(self._rot_axis_y, 'f') writer.write(self._rot_axis_z, 'f') writer.write_farray(self._objParameters, 'f', 4) writer.write_string(self._text, 'B') def __eq__(self, other): if type(self) is type(other): return (self._objectID == other._objectID and self._objectTypeID == other._objectTypeID and self._color == other._color and self._x_size_m == other._x_size_m and self._y_size_m == other._y_size_m and self._z_size_m == other._z_size_m and self._x_trans_m == other._x_trans_m and self._y_trans_m == other._y_trans_m and self._z_trans_m == other._z_trans_m and self._rot_deg == other._rot_deg and self._rot_axis_x == other._rot_axis_x and self._rot_axis_y == other._rot_axis_y and self._rot_axis_z == other._rot_axis_z and self._objParameters == other._objParameters and self._text == other._text) else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._objectID, 'I') + msgbuffers.size(self._objectTypeID, 'I') + msgbuffers.size(self._color, 'I') + msgbuffers.size(self._x_size_m, 'f') + msgbuffers.size(self._y_size_m, 'f') + msgbuffers.size(self._z_size_m, 'f') + msgbuffers.size(self._x_trans_m, 'f') + msgbuffers.size(self._y_trans_m, 'f') + msgbuffers.size(self._z_trans_m, 'f') + msgbuffers.size(self._rot_deg, 'f') + msgbuffers.size(self._rot_axis_x, 'f') + msgbuffers.size(self._rot_axis_y, 'f') + msgbuffers.size(self._rot_axis_z, 'f') + msgbuffers.size_farray(self._objParameters, 'f', 4) + msgbuffers.size_string(self._text, 'B')) def __str__(self): return '{type}(objectID={objectID}, objectTypeID={objectTypeID}, color={color}, x_size_m={x_size_m}, y_size_m={y_size_m}, z_size_m={z_size_m}, x_trans_m={x_trans_m}, y_trans_m={y_trans_m}, z_trans_m={z_trans_m}, rot_deg={rot_deg}, rot_axis_x={rot_axis_x}, rot_axis_y={rot_axis_y}, rot_axis_z={rot_axis_z}, objParameters={objParameters}, text={text})'.format( type=type(self).__name__, objectID=self._objectID, objectTypeID=self._objectTypeID, color=self._color, x_size_m=self._x_size_m, y_size_m=self._y_size_m, z_size_m=self._z_size_m, x_trans_m=self._x_trans_m, y_trans_m=self._y_trans_m, z_trans_m=self._z_trans_m, rot_deg=self._rot_deg, rot_axis_x=self._rot_axis_x, rot_axis_y=self._rot_axis_y, rot_axis_z=self._rot_axis_z, objParameters=msgbuffers.shorten_sequence(self._objParameters), text=msgbuffers.shorten_string(self._text)) def __repr__(self): return '{type}(objectID={objectID}, objectTypeID={objectTypeID}, color={color}, x_size_m={x_size_m}, y_size_m={y_size_m}, z_size_m={z_size_m}, x_trans_m={x_trans_m}, y_trans_m={y_trans_m}, z_trans_m={z_trans_m}, rot_deg={rot_deg}, rot_axis_x={rot_axis_x}, rot_axis_y={rot_axis_y}, rot_axis_z={rot_axis_z}, objParameters={objParameters}, text={text})'.format( type=type(self).__name__, objectID=repr(self._objectID), objectTypeID=repr(self._objectTypeID), color=repr(self._color), x_size_m=repr(self._x_size_m), y_size_m=repr(self._y_size_m), z_size_m=repr(self._z_size_m), x_trans_m=repr(self._x_trans_m), y_trans_m=repr(self._y_trans_m), z_trans_m=repr(self._z_trans_m), rot_deg=repr(self._rot_deg), rot_axis_x=repr(self._rot_axis_x), rot_axis_y=repr(self._rot_axis_y), rot_axis_z=repr(self._rot_axis_z), objParameters=repr(self._objParameters), text=repr(self._text)) Anki.Vector.VizInterface.Object = Object del Object class LineSegment(object): "Generated message-passing message." __slots__ = ( '_identifier', # string[uint_8] '_color', # uint_32 '_origin', # float_32[3] '_dest', # float_32[3] '_clearPrevious', # bool ) @property def identifier(self): "string[uint_8] identifier struct property." return self._identifier @identifier.setter def identifier(self, value): self._identifier = msgbuffers.validate_string( 'LineSegment.identifier', value, 255) @property def color(self): "uint_32 color struct property." return self._color @color.setter def color(self, value): self._color = msgbuffers.validate_integer( 'LineSegment.color', value, 0, 4294967295) @property def origin(self): "float_32[3] origin struct property." return self._origin @origin.setter def origin(self, value): self._origin = msgbuffers.validate_farray( 'LineSegment.origin', value, 3, lambda name, value_inner: msgbuffers.validate_float( name, value_inner, 'f')) @property def dest(self): "float_32[3] dest struct property." return self._dest @dest.setter def dest(self, value): self._dest = msgbuffers.validate_farray( 'LineSegment.dest', value, 3, lambda name, value_inner: msgbuffers.validate_float( name, value_inner, 'f')) @property def clearPrevious(self): "bool clearPrevious struct property." return self._clearPrevious @clearPrevious.setter def clearPrevious(self, value): self._clearPrevious = msgbuffers.validate_bool( 'LineSegment.clearPrevious', value) def __init__(self, identifier='', color=0, origin=(0.0,) * 3, dest=(0.0,) * 3, clearPrevious=False): self.identifier = identifier self.color = color self.origin = origin self.dest = dest self.clearPrevious = clearPrevious @classmethod def unpack(cls, buffer): "Reads a new LineSegment from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('LineSegment.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new LineSegment from the given BinaryReader." _identifier = reader.read_string('B') _color = reader.read('I') _origin = reader.read_farray('f', 3) _dest = reader.read_farray('f', 3) _clearPrevious = bool(reader.read('b')) return cls(_identifier, _color, _origin, _dest, _clearPrevious) def pack(self): "Writes the current LineSegment, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current LineSegment to the given BinaryWriter." writer.write_string(self._identifier, 'B') writer.write(self._color, 'I') writer.write_farray(self._origin, 'f', 3) writer.write_farray(self._dest, 'f', 3) writer.write(int(self._clearPrevious), 'b') def __eq__(self, other): if type(self) is type(other): return (self._identifier == other._identifier and self._color == other._color and self._origin == other._origin and self._dest == other._dest and self._clearPrevious == other._clearPrevious) else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size_string(self._identifier, 'B') + msgbuffers.size(self._color, 'I') + msgbuffers.size_farray(self._origin, 'f', 3) + msgbuffers.size_farray(self._dest, 'f', 3) + msgbuffers.size(self._clearPrevious, 'b')) def __str__(self): return '{type}(identifier={identifier}, color={color}, origin={origin}, dest={dest}, clearPrevious={clearPrevious})'.format( type=type(self).__name__, identifier=msgbuffers.shorten_string(self._identifier), color=self._color, origin=msgbuffers.shorten_sequence(self._origin), dest=msgbuffers.shorten_sequence(self._dest), clearPrevious=self._clearPrevious) def __repr__(self): return '{type}(identifier={identifier}, color={color}, origin={origin}, dest={dest}, clearPrevious={clearPrevious})'.format( type=type(self).__name__, identifier=repr(self._identifier), color=repr(self._color), origin=repr(self._origin), dest=repr(self._dest), clearPrevious=repr(self._clearPrevious)) Anki.Vector.VizInterface.LineSegment = LineSegment del LineSegment class Quad(object): "Generated message-passing message." __slots__ = ( '_quadType', # Anki.Vector.VizQuadType '_quadID', # uint_32 '_color', # uint_32 '_xUpperLeft', # float_32 '_yUpperLeft', # float_32 '_zUpperLeft', # float_32 '_xLowerLeft', # float_32 '_yLowerLeft', # float_32 '_zLowerLeft', # float_32 '_xUpperRight', # float_32 '_yUpperRight', # float_32 '_zUpperRight', # float_32 '_xLowerRight', # float_32 '_yLowerRight', # float_32 '_zLowerRight', # float_32 ) @property def quadType(self): "Anki.Vector.VizQuadType quadType struct property." return self._quadType @quadType.setter def quadType(self, value): self._quadType = msgbuffers.validate_integer( 'Quad.quadType', value, 0, 255) @property def quadID(self): "uint_32 quadID struct property." return self._quadID @quadID.setter def quadID(self, value): self._quadID = msgbuffers.validate_integer( 'Quad.quadID', value, 0, 4294967295) @property def color(self): "uint_32 color struct property." return self._color @color.setter def color(self, value): self._color = msgbuffers.validate_integer( 'Quad.color', value, 0, 4294967295) @property def xUpperLeft(self): "float_32 xUpperLeft struct property." return self._xUpperLeft @xUpperLeft.setter def xUpperLeft(self, value): self._xUpperLeft = msgbuffers.validate_float( 'Quad.xUpperLeft', value, 'f') @property def yUpperLeft(self): "float_32 yUpperLeft struct property." return self._yUpperLeft @yUpperLeft.setter def yUpperLeft(self, value): self._yUpperLeft = msgbuffers.validate_float( 'Quad.yUpperLeft', value, 'f') @property def zUpperLeft(self): "float_32 zUpperLeft struct property." return self._zUpperLeft @zUpperLeft.setter def zUpperLeft(self, value): self._zUpperLeft = msgbuffers.validate_float( 'Quad.zUpperLeft', value, 'f') @property def xLowerLeft(self): "float_32 xLowerLeft struct property." return self._xLowerLeft @xLowerLeft.setter def xLowerLeft(self, value): self._xLowerLeft = msgbuffers.validate_float( 'Quad.xLowerLeft', value, 'f') @property def yLowerLeft(self): "float_32 yLowerLeft struct property." return self._yLowerLeft @yLowerLeft.setter def yLowerLeft(self, value): self._yLowerLeft = msgbuffers.validate_float( 'Quad.yLowerLeft', value, 'f') @property def zLowerLeft(self): "float_32 zLowerLeft struct property." return self._zLowerLeft @zLowerLeft.setter def zLowerLeft(self, value): self._zLowerLeft = msgbuffers.validate_float( 'Quad.zLowerLeft', value, 'f') @property def xUpperRight(self): "float_32 xUpperRight struct property." return self._xUpperRight @xUpperRight.setter def xUpperRight(self, value): self._xUpperRight = msgbuffers.validate_float( 'Quad.xUpperRight', value, 'f') @property def yUpperRight(self): "float_32 yUpperRight struct property." return self._yUpperRight @yUpperRight.setter def yUpperRight(self, value): self._yUpperRight = msgbuffers.validate_float( 'Quad.yUpperRight', value, 'f') @property def zUpperRight(self): "float_32 zUpperRight struct property." return self._zUpperRight @zUpperRight.setter def zUpperRight(self, value): self._zUpperRight = msgbuffers.validate_float( 'Quad.zUpperRight', value, 'f') @property def xLowerRight(self): "float_32 xLowerRight struct property." return self._xLowerRight @xLowerRight.setter def xLowerRight(self, value): self._xLowerRight = msgbuffers.validate_float( 'Quad.xLowerRight', value, 'f') @property def yLowerRight(self): "float_32 yLowerRight struct property." return self._yLowerRight @yLowerRight.setter def yLowerRight(self, value): self._yLowerRight = msgbuffers.validate_float( 'Quad.yLowerRight', value, 'f') @property def zLowerRight(self): "float_32 zLowerRight struct property." return self._zLowerRight @zLowerRight.setter def zLowerRight(self, value): self._zLowerRight = msgbuffers.validate_float( 'Quad.zLowerRight', value, 'f') def __init__(self, quadType=Anki.Vector.VizQuadType.VIZ_QUAD_GENERIC_2D, quadID=0, color=0, xUpperLeft=0.0, yUpperLeft=0.0, zUpperLeft=0.0, xLowerLeft=0.0, yLowerLeft=0.0, zLowerLeft=0.0, xUpperRight=0.0, yUpperRight=0.0, zUpperRight=0.0, xLowerRight=0.0, yLowerRight=0.0, zLowerRight=0.0): self.quadType = quadType self.quadID = quadID self.color = color self.xUpperLeft = xUpperLeft self.yUpperLeft = yUpperLeft self.zUpperLeft = zUpperLeft self.xLowerLeft = xLowerLeft self.yLowerLeft = yLowerLeft self.zLowerLeft = zLowerLeft self.xUpperRight = xUpperRight self.yUpperRight = yUpperRight self.zUpperRight = zUpperRight self.xLowerRight = xLowerRight self.yLowerRight = yLowerRight self.zLowerRight = zLowerRight @classmethod def unpack(cls, buffer): "Reads a new Quad from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('Quad.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new Quad from the given BinaryReader." _quadType = reader.read('B') _quadID = reader.read('I') _color = reader.read('I') _xUpperLeft = reader.read('f') _yUpperLeft = reader.read('f') _zUpperLeft = reader.read('f') _xLowerLeft = reader.read('f') _yLowerLeft = reader.read('f') _zLowerLeft = reader.read('f') _xUpperRight = reader.read('f') _yUpperRight = reader.read('f') _zUpperRight = reader.read('f') _xLowerRight = reader.read('f') _yLowerRight = reader.read('f') _zLowerRight = reader.read('f') return cls(_quadType, _quadID, _color, _xUpperLeft, _yUpperLeft, _zUpperLeft, _xLowerLeft, _yLowerLeft, _zLowerLeft, _xUpperRight, _yUpperRight, _zUpperRight, _xLowerRight, _yLowerRight, _zLowerRight) def pack(self): "Writes the current Quad, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current Quad to the given BinaryWriter." writer.write(self._quadType, 'B') writer.write(self._quadID, 'I') writer.write(self._color, 'I') writer.write(self._xUpperLeft, 'f') writer.write(self._yUpperLeft, 'f') writer.write(self._zUpperLeft, 'f') writer.write(self._xLowerLeft, 'f') writer.write(self._yLowerLeft, 'f') writer.write(self._zLowerLeft, 'f') writer.write(self._xUpperRight, 'f') writer.write(self._yUpperRight, 'f') writer.write(self._zUpperRight, 'f') writer.write(self._xLowerRight, 'f') writer.write(self._yLowerRight, 'f') writer.write(self._zLowerRight, 'f') def __eq__(self, other): if type(self) is type(other): return (self._quadType == other._quadType and self._quadID == other._quadID and self._color == other._color and self._xUpperLeft == other._xUpperLeft and self._yUpperLeft == other._yUpperLeft and self._zUpperLeft == other._zUpperLeft and self._xLowerLeft == other._xLowerLeft and self._yLowerLeft == other._yLowerLeft and self._zLowerLeft == other._zLowerLeft and self._xUpperRight == other._xUpperRight and self._yUpperRight == other._yUpperRight and self._zUpperRight == other._zUpperRight and self._xLowerRight == other._xLowerRight and self._yLowerRight == other._yLowerRight and self._zLowerRight == other._zLowerRight) else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._quadType, 'B') + msgbuffers.size(self._quadID, 'I') + msgbuffers.size(self._color, 'I') + msgbuffers.size(self._xUpperLeft, 'f') + msgbuffers.size(self._yUpperLeft, 'f') + msgbuffers.size(self._zUpperLeft, 'f') + msgbuffers.size(self._xLowerLeft, 'f') + msgbuffers.size(self._yLowerLeft, 'f') + msgbuffers.size(self._zLowerLeft, 'f') + msgbuffers.size(self._xUpperRight, 'f') + msgbuffers.size(self._yUpperRight, 'f') + msgbuffers.size(self._zUpperRight, 'f') + msgbuffers.size(self._xLowerRight, 'f') + msgbuffers.size(self._yLowerRight, 'f') + msgbuffers.size(self._zLowerRight, 'f')) def __str__(self): return '{type}(quadType={quadType}, quadID={quadID}, color={color}, xUpperLeft={xUpperLeft}, yUpperLeft={yUpperLeft}, zUpperLeft={zUpperLeft}, xLowerLeft={xLowerLeft}, yLowerLeft={yLowerLeft}, zLowerLeft={zLowerLeft}, xUpperRight={xUpperRight}, yUpperRight={yUpperRight}, zUpperRight={zUpperRight}, xLowerRight={xLowerRight}, yLowerRight={yLowerRight}, zLowerRight={zLowerRight})'.format( type=type(self).__name__, quadType=self._quadType, quadID=self._quadID, color=self._color, xUpperLeft=self._xUpperLeft, yUpperLeft=self._yUpperLeft, zUpperLeft=self._zUpperLeft, xLowerLeft=self._xLowerLeft, yLowerLeft=self._yLowerLeft, zLowerLeft=self._zLowerLeft, xUpperRight=self._xUpperRight, yUpperRight=self._yUpperRight, zUpperRight=self._zUpperRight, xLowerRight=self._xLowerRight, yLowerRight=self._yLowerRight, zLowerRight=self._zLowerRight) def __repr__(self): return '{type}(quadType={quadType}, quadID={quadID}, color={color}, xUpperLeft={xUpperLeft}, yUpperLeft={yUpperLeft}, zUpperLeft={zUpperLeft}, xLowerLeft={xLowerLeft}, yLowerLeft={yLowerLeft}, zLowerLeft={zLowerLeft}, xUpperRight={xUpperRight}, yUpperRight={yUpperRight}, zUpperRight={zUpperRight}, xLowerRight={xLowerRight}, yLowerRight={yLowerRight}, zLowerRight={zLowerRight})'.format( type=type(self).__name__, quadType=repr(self._quadType), quadID=repr(self._quadID), color=repr(self._color), xUpperLeft=repr(self._xUpperLeft), yUpperLeft=repr(self._yUpperLeft), zUpperLeft=repr(self._zUpperLeft), xLowerLeft=repr(self._xLowerLeft), yLowerLeft=repr(self._yLowerLeft), zLowerLeft=repr(self._zLowerLeft), xUpperRight=repr(self._xUpperRight), yUpperRight=repr(self._yUpperRight), zUpperRight=repr(self._zUpperRight), xLowerRight=repr(self._xLowerRight), yLowerRight=repr(self._yLowerRight), zLowerRight=repr(self._zLowerRight)) Anki.Vector.VizInterface.Quad = Quad del Quad class MemoryMapMessageVizBegin(object): "Generated message-passing message." __slots__ = ( '_originId', # uint_32 '_info', # Anki.Vector.ExternalInterface.MemoryMapInfo ) @property def originId(self): "uint_32 originId struct property." return self._originId @originId.setter def originId(self, value): self._originId = msgbuffers.validate_integer( 'MemoryMapMessageVizBegin.originId', value, 0, 4294967295) @property def info(self): "Anki.Vector.ExternalInterface.MemoryMapInfo info struct property." return self._info @info.setter def info(self, value): self._info = msgbuffers.validate_object( 'MemoryMapMessageVizBegin.info', value, Anki.Vector.ExternalInterface.MemoryMapInfo) def __init__(self, originId=0, info=Anki.Vector.ExternalInterface.MemoryMapInfo()): self.originId = originId self.info = info @classmethod def unpack(cls, buffer): "Reads a new MemoryMapMessageVizBegin from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('MemoryMapMessageVizBegin.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new MemoryMapMessageVizBegin from the given BinaryReader." _originId = reader.read('I') _info = reader.read_object(Anki.Vector.ExternalInterface.MemoryMapInfo.unpack_from) return cls(_originId, _info) def pack(self): "Writes the current MemoryMapMessageVizBegin, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current MemoryMapMessageVizBegin to the given BinaryWriter." writer.write(self._originId, 'I') writer.write_object(self._info) def __eq__(self, other): if type(self) is type(other): return (self._originId == other._originId and self._info == other._info) else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._originId, 'I') + msgbuffers.size_object(self._info)) def __str__(self): return '{type}(originId={originId}, info={info})'.format( type=type(self).__name__, originId=self._originId, info=self._info) def __repr__(self): return '{type}(originId={originId}, info={info})'.format( type=type(self).__name__, originId=repr(self._originId), info=repr(self._info)) Anki.Vector.VizInterface.MemoryMapMessageVizBegin = MemoryMapMessageVizBegin del MemoryMapMessageVizBegin class MemoryMapMessageViz(object): "Generated message-passing message." __slots__ = ( '_originId', # uint_32 '_quadInfos', # MemoryMapQuadInfoFull[uint_16] ) @property def originId(self): "uint_32 originId struct property." return self._originId @originId.setter def originId(self, value): self._originId = msgbuffers.validate_integer( 'MemoryMapMessageViz.originId', value, 0, 4294967295) @property def quadInfos(self): "MemoryMapQuadInfoFull[uint_16] quadInfos struct property." return self._quadInfos @quadInfos.setter def quadInfos(self, value): self._quadInfos = msgbuffers.validate_varray( 'MemoryMapMessageViz.quadInfos', value, 65535, lambda name, value_inner: msgbuffers.validate_object( name, value_inner, Anki.Vector.ExternalInterface.MemoryMapQuadInfoFull)) def __init__(self, originId=0, quadInfos=()): self.originId = originId self.quadInfos = quadInfos @classmethod def unpack(cls, buffer): "Reads a new MemoryMapMessageViz from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('MemoryMapMessageViz.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new MemoryMapMessageViz from the given BinaryReader." _originId = reader.read('I') _quadInfos = reader.read_object_varray(Anki.Vector.ExternalInterface.MemoryMapQuadInfoFull.unpack_from, 'H') return cls(_originId, _quadInfos) def pack(self): "Writes the current MemoryMapMessageViz, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current MemoryMapMessageViz to the given BinaryWriter." writer.write(self._originId, 'I') writer.write_object_varray(self._quadInfos, 'H') def __eq__(self, other): if type(self) is type(other): return (self._originId == other._originId and self._quadInfos == other._quadInfos) else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._originId, 'I') + msgbuffers.size_object_varray(self._quadInfos, 'H')) def __str__(self): return '{type}(originId={originId}, quadInfos={quadInfos})'.format( type=type(self).__name__, originId=self._originId, quadInfos=msgbuffers.shorten_sequence(self._quadInfos)) def __repr__(self): return '{type}(originId={originId}, quadInfos={quadInfos})'.format( type=type(self).__name__, originId=repr(self._originId), quadInfos=repr(self._quadInfos)) Anki.Vector.VizInterface.MemoryMapMessageViz = MemoryMapMessageViz del MemoryMapMessageViz class MemoryMapMessageVizEnd(object): "Generated message-passing message." __slots__ = ( '_originId', # uint_32 ) @property def originId(self): "uint_32 originId struct property." return self._originId @originId.setter def originId(self, value): self._originId = msgbuffers.validate_integer( 'MemoryMapMessageVizEnd.originId', value, 0, 4294967295) def __init__(self, originId=0): self.originId = originId @classmethod def unpack(cls, buffer): "Reads a new MemoryMapMessageVizEnd from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('MemoryMapMessageVizEnd.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new MemoryMapMessageVizEnd from the given BinaryReader." _originId = reader.read('I') return cls(_originId) def pack(self): "Writes the current MemoryMapMessageVizEnd, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current MemoryMapMessageVizEnd to the given BinaryWriter." writer.write(self._originId, 'I') def __eq__(self, other): if type(self) is type(other): return self._originId == other._originId else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._originId, 'I')) def __str__(self): return '{type}(originId={originId})'.format( type=type(self).__name__, originId=self._originId) def __repr__(self): return '{type}(originId={originId})'.format( type=type(self).__name__, originId=repr(self._originId)) Anki.Vector.VizInterface.MemoryMapMessageVizEnd = MemoryMapMessageVizEnd del MemoryMapMessageVizEnd class EnabledVisionModes(object): "Generated message-passing message." __slots__ = ( '_modes', # VisionMode[uint_16] ) @property def modes(self): "VisionMode[uint_16] modes struct property." return self._modes @modes.setter def modes(self, value): self._modes = msgbuffers.validate_varray( 'EnabledVisionModes.modes', value, 65535, lambda name, value_inner: msgbuffers.validate_integer( name, value_inner, 0, 4294967295)) def __init__(self, modes=()): self.modes = modes @classmethod def unpack(cls, buffer): "Reads a new EnabledVisionModes from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('EnabledVisionModes.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new EnabledVisionModes from the given BinaryReader." _modes = reader.read_varray('I', 'H') return cls(_modes) def pack(self): "Writes the current EnabledVisionModes, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current EnabledVisionModes to the given BinaryWriter." writer.write_varray(self._modes, 'I', 'H') def __eq__(self, other): if type(self) is type(other): return self._modes == other._modes else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size_varray(self._modes, 'I', 'H')) def __str__(self): return '{type}(modes={modes})'.format( type=type(self).__name__, modes=msgbuffers.shorten_sequence(self._modes)) def __repr__(self): return '{type}(modes={modes})'.format( type=type(self).__name__, modes=repr(self._modes)) Anki.Vector.VizInterface.EnabledVisionModes = EnabledVisionModes del EnabledVisionModes class CameraQuad(object): "Generated message-passing message." __slots__ = ( '_color', # uint_32 '_topColor', # uint_32 '_xUpperLeft', # float_32 '_yUpperLeft', # float_32 '_xLowerLeft', # float_32 '_yLowerLeft', # float_32 '_xUpperRight', # float_32 '_yUpperRight', # float_32 '_xLowerRight', # float_32 '_yLowerRight', # float_32 ) @property def color(self): "uint_32 color struct property." return self._color @color.setter def color(self, value): self._color = msgbuffers.validate_integer( 'CameraQuad.color', value, 0, 4294967295) @property def topColor(self): "uint_32 topColor struct property." return self._topColor @topColor.setter def topColor(self, value): self._topColor = msgbuffers.validate_integer( 'CameraQuad.topColor', value, 0, 4294967295) @property def xUpperLeft(self): "float_32 xUpperLeft struct property." return self._xUpperLeft @xUpperLeft.setter def xUpperLeft(self, value): self._xUpperLeft = msgbuffers.validate_float( 'CameraQuad.xUpperLeft', value, 'f') @property def yUpperLeft(self): "float_32 yUpperLeft struct property." return self._yUpperLeft @yUpperLeft.setter def yUpperLeft(self, value): self._yUpperLeft = msgbuffers.validate_float( 'CameraQuad.yUpperLeft', value, 'f') @property def xLowerLeft(self): "float_32 xLowerLeft struct property." return self._xLowerLeft @xLowerLeft.setter def xLowerLeft(self, value): self._xLowerLeft = msgbuffers.validate_float( 'CameraQuad.xLowerLeft', value, 'f') @property def yLowerLeft(self): "float_32 yLowerLeft struct property." return self._yLowerLeft @yLowerLeft.setter def yLowerLeft(self, value): self._yLowerLeft = msgbuffers.validate_float( 'CameraQuad.yLowerLeft', value, 'f') @property def xUpperRight(self): "float_32 xUpperRight struct property." return self._xUpperRight @xUpperRight.setter def xUpperRight(self, value): self._xUpperRight = msgbuffers.validate_float( 'CameraQuad.xUpperRight', value, 'f') @property def yUpperRight(self): "float_32 yUpperRight struct property." return self._yUpperRight @yUpperRight.setter def yUpperRight(self, value): self._yUpperRight = msgbuffers.validate_float( 'CameraQuad.yUpperRight', value, 'f') @property def xLowerRight(self): "float_32 xLowerRight struct property." return self._xLowerRight @xLowerRight.setter def xLowerRight(self, value): self._xLowerRight = msgbuffers.validate_float( 'CameraQuad.xLowerRight', value, 'f') @property def yLowerRight(self): "float_32 yLowerRight struct property." return self._yLowerRight @yLowerRight.setter def yLowerRight(self, value): self._yLowerRight = msgbuffers.validate_float( 'CameraQuad.yLowerRight', value, 'f') def __init__(self, color=0, topColor=0, xUpperLeft=0.0, yUpperLeft=0.0, xLowerLeft=0.0, yLowerLeft=0.0, xUpperRight=0.0, yUpperRight=0.0, xLowerRight=0.0, yLowerRight=0.0): self.color = color self.topColor = topColor self.xUpperLeft = xUpperLeft self.yUpperLeft = yUpperLeft self.xLowerLeft = xLowerLeft self.yLowerLeft = yLowerLeft self.xUpperRight = xUpperRight self.yUpperRight = yUpperRight self.xLowerRight = xLowerRight self.yLowerRight = yLowerRight @classmethod def unpack(cls, buffer): "Reads a new CameraQuad from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('CameraQuad.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new CameraQuad from the given BinaryReader." _color = reader.read('I') _topColor = reader.read('I') _xUpperLeft = reader.read('f') _yUpperLeft = reader.read('f') _xLowerLeft = reader.read('f') _yLowerLeft = reader.read('f') _xUpperRight = reader.read('f') _yUpperRight = reader.read('f') _xLowerRight = reader.read('f') _yLowerRight = reader.read('f') return cls(_color, _topColor, _xUpperLeft, _yUpperLeft, _xLowerLeft, _yLowerLeft, _xUpperRight, _yUpperRight, _xLowerRight, _yLowerRight) def pack(self): "Writes the current CameraQuad, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current CameraQuad to the given BinaryWriter." writer.write(self._color, 'I') writer.write(self._topColor, 'I') writer.write(self._xUpperLeft, 'f') writer.write(self._yUpperLeft, 'f') writer.write(self._xLowerLeft, 'f') writer.write(self._yLowerLeft, 'f') writer.write(self._xUpperRight, 'f') writer.write(self._yUpperRight, 'f') writer.write(self._xLowerRight, 'f') writer.write(self._yLowerRight, 'f') def __eq__(self, other): if type(self) is type(other): return (self._color == other._color and self._topColor == other._topColor and self._xUpperLeft == other._xUpperLeft and self._yUpperLeft == other._yUpperLeft and self._xLowerLeft == other._xLowerLeft and self._yLowerLeft == other._yLowerLeft and self._xUpperRight == other._xUpperRight and self._yUpperRight == other._yUpperRight and self._xLowerRight == other._xLowerRight and self._yLowerRight == other._yLowerRight) else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._color, 'I') + msgbuffers.size(self._topColor, 'I') + msgbuffers.size(self._xUpperLeft, 'f') + msgbuffers.size(self._yUpperLeft, 'f') + msgbuffers.size(self._xLowerLeft, 'f') + msgbuffers.size(self._yLowerLeft, 'f') + msgbuffers.size(self._xUpperRight, 'f') + msgbuffers.size(self._yUpperRight, 'f') + msgbuffers.size(self._xLowerRight, 'f') + msgbuffers.size(self._yLowerRight, 'f')) def __str__(self): return '{type}(color={color}, topColor={topColor}, xUpperLeft={xUpperLeft}, yUpperLeft={yUpperLeft}, xLowerLeft={xLowerLeft}, yLowerLeft={yLowerLeft}, xUpperRight={xUpperRight}, yUpperRight={yUpperRight}, xLowerRight={xLowerRight}, yLowerRight={yLowerRight})'.format( type=type(self).__name__, color=self._color, topColor=self._topColor, xUpperLeft=self._xUpperLeft, yUpperLeft=self._yUpperLeft, xLowerLeft=self._xLowerLeft, yLowerLeft=self._yLowerLeft, xUpperRight=self._xUpperRight, yUpperRight=self._yUpperRight, xLowerRight=self._xLowerRight, yLowerRight=self._yLowerRight) def __repr__(self): return '{type}(color={color}, topColor={topColor}, xUpperLeft={xUpperLeft}, yUpperLeft={yUpperLeft}, xLowerLeft={xLowerLeft}, yLowerLeft={yLowerLeft}, xUpperRight={xUpperRight}, yUpperRight={yUpperRight}, xLowerRight={xLowerRight}, yLowerRight={yLowerRight})'.format( type=type(self).__name__, color=repr(self._color), topColor=repr(self._topColor), xUpperLeft=repr(self._xUpperLeft), yUpperLeft=repr(self._yUpperLeft), xLowerLeft=repr(self._xLowerLeft), yLowerLeft=repr(self._yLowerLeft), xUpperRight=repr(self._xUpperRight), yUpperRight=repr(self._yUpperRight), xLowerRight=repr(self._xLowerRight), yLowerRight=repr(self._yLowerRight)) Anki.Vector.VizInterface.CameraQuad = CameraQuad del CameraQuad class CameraRect(object): "Generated message-passing message." __slots__ = ( '_color', # uint_32 '_x', # float_32 '_y', # float_32 '_width', # float_32 '_height', # float_32 '_filled', # bool ) @property def color(self): "uint_32 color struct property." return self._color @color.setter def color(self, value): self._color = msgbuffers.validate_integer( 'CameraRect.color', value, 0, 4294967295) @property def x(self): "float_32 x struct property." return self._x @x.setter def x(self, value): self._x = msgbuffers.validate_float( 'CameraRect.x', value, 'f') @property def y(self): "float_32 y struct property." return self._y @y.setter def y(self, value): self._y = msgbuffers.validate_float( 'CameraRect.y', value, 'f') @property def width(self): "float_32 width struct property." return self._width @width.setter def width(self, value): self._width = msgbuffers.validate_float( 'CameraRect.width', value, 'f') @property def height(self): "float_32 height struct property." return self._height @height.setter def height(self, value): self._height = msgbuffers.validate_float( 'CameraRect.height', value, 'f') @property def filled(self): "bool filled struct property." return self._filled @filled.setter def filled(self, value): self._filled = msgbuffers.validate_bool( 'CameraRect.filled', value) def __init__(self, color=0, x=0.0, y=0.0, width=0.0, height=0.0, filled=False): self.color = color self.x = x self.y = y self.width = width self.height = height self.filled = filled @classmethod def unpack(cls, buffer): "Reads a new CameraRect from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('CameraRect.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new CameraRect from the given BinaryReader." _color = reader.read('I') _x = reader.read('f') _y = reader.read('f') _width = reader.read('f') _height = reader.read('f') _filled = bool(reader.read('b')) return cls(_color, _x, _y, _width, _height, _filled) def pack(self): "Writes the current CameraRect, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current CameraRect to the given BinaryWriter." writer.write(self._color, 'I') writer.write(self._x, 'f') writer.write(self._y, 'f') writer.write(self._width, 'f') writer.write(self._height, 'f') writer.write(int(self._filled), 'b') def __eq__(self, other): if type(self) is type(other): return (self._color == other._color and self._x == other._x and self._y == other._y and self._width == other._width and self._height == other._height and self._filled == other._filled) else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._color, 'I') + msgbuffers.size(self._x, 'f') + msgbuffers.size(self._y, 'f') + msgbuffers.size(self._width, 'f') + msgbuffers.size(self._height, 'f') + msgbuffers.size(self._filled, 'b')) def __str__(self): return '{type}(color={color}, x={x}, y={y}, width={width}, height={height}, filled={filled})'.format( type=type(self).__name__, color=self._color, x=self._x, y=self._y, width=self._width, height=self._height, filled=self._filled) def __repr__(self): return '{type}(color={color}, x={x}, y={y}, width={width}, height={height}, filled={filled})'.format( type=type(self).__name__, color=repr(self._color), x=repr(self._x), y=repr(self._y), width=repr(self._width), height=repr(self._height), filled=repr(self._filled)) Anki.Vector.VizInterface.CameraRect = CameraRect del CameraRect class CameraLine(object): "Generated message-passing message." __slots__ = ( '_color', # uint_32 '_xStart', # float_32 '_yStart', # float_32 '_xEnd', # float_32 '_yEnd', # float_32 ) @property def color(self): "uint_32 color struct property." return self._color @color.setter def color(self, value): self._color = msgbuffers.validate_integer( 'CameraLine.color', value, 0, 4294967295) @property def xStart(self): "float_32 xStart struct property." return self._xStart @xStart.setter def xStart(self, value): self._xStart = msgbuffers.validate_float( 'CameraLine.xStart', value, 'f') @property def yStart(self): "float_32 yStart struct property." return self._yStart @yStart.setter def yStart(self, value): self._yStart = msgbuffers.validate_float( 'CameraLine.yStart', value, 'f') @property def xEnd(self): "float_32 xEnd struct property." return self._xEnd @xEnd.setter def xEnd(self, value): self._xEnd = msgbuffers.validate_float( 'CameraLine.xEnd', value, 'f') @property def yEnd(self): "float_32 yEnd struct property." return self._yEnd @yEnd.setter def yEnd(self, value): self._yEnd = msgbuffers.validate_float( 'CameraLine.yEnd', value, 'f') def __init__(self, color=0, xStart=0.0, yStart=0.0, xEnd=0.0, yEnd=0.0): self.color = color self.xStart = xStart self.yStart = yStart self.xEnd = xEnd self.yEnd = yEnd @classmethod def unpack(cls, buffer): "Reads a new CameraLine from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('CameraLine.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new CameraLine from the given BinaryReader." _color = reader.read('I') _xStart = reader.read('f') _yStart = reader.read('f') _xEnd = reader.read('f') _yEnd = reader.read('f') return cls(_color, _xStart, _yStart, _xEnd, _yEnd) def pack(self): "Writes the current CameraLine, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current CameraLine to the given BinaryWriter." writer.write(self._color, 'I') writer.write(self._xStart, 'f') writer.write(self._yStart, 'f') writer.write(self._xEnd, 'f') writer.write(self._yEnd, 'f') def __eq__(self, other): if type(self) is type(other): return (self._color == other._color and self._xStart == other._xStart and self._yStart == other._yStart and self._xEnd == other._xEnd and self._yEnd == other._yEnd) else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._color, 'I') + msgbuffers.size(self._xStart, 'f') + msgbuffers.size(self._yStart, 'f') + msgbuffers.size(self._xEnd, 'f') + msgbuffers.size(self._yEnd, 'f')) def __str__(self): return '{type}(color={color}, xStart={xStart}, yStart={yStart}, xEnd={xEnd}, yEnd={yEnd})'.format( type=type(self).__name__, color=self._color, xStart=self._xStart, yStart=self._yStart, xEnd=self._xEnd, yEnd=self._yEnd) def __repr__(self): return '{type}(color={color}, xStart={xStart}, yStart={yStart}, xEnd={xEnd}, yEnd={yEnd})'.format( type=type(self).__name__, color=repr(self._color), xStart=repr(self._xStart), yStart=repr(self._yStart), xEnd=repr(self._xEnd), yEnd=repr(self._yEnd)) Anki.Vector.VizInterface.CameraLine = CameraLine del CameraLine class CameraOval(object): "Generated message-passing message." __slots__ = ( '_color', # uint_32 '_xCen', # float_32 '_yCen', # float_32 '_xRad', # float_32 '_yRad', # float_32 ) @property def color(self): "uint_32 color struct property." return self._color @color.setter def color(self, value): self._color = msgbuffers.validate_integer( 'CameraOval.color', value, 0, 4294967295) @property def xCen(self): "float_32 xCen struct property." return self._xCen @xCen.setter def xCen(self, value): self._xCen = msgbuffers.validate_float( 'CameraOval.xCen', value, 'f') @property def yCen(self): "float_32 yCen struct property." return self._yCen @yCen.setter def yCen(self, value): self._yCen = msgbuffers.validate_float( 'CameraOval.yCen', value, 'f') @property def xRad(self): "float_32 xRad struct property." return self._xRad @xRad.setter def xRad(self, value): self._xRad = msgbuffers.validate_float( 'CameraOval.xRad', value, 'f') @property def yRad(self): "float_32 yRad struct property." return self._yRad @yRad.setter def yRad(self, value): self._yRad = msgbuffers.validate_float( 'CameraOval.yRad', value, 'f') def __init__(self, color=0, xCen=0.0, yCen=0.0, xRad=0.0, yRad=0.0): self.color = color self.xCen = xCen self.yCen = yCen self.xRad = xRad self.yRad = yRad @classmethod def unpack(cls, buffer): "Reads a new CameraOval from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('CameraOval.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new CameraOval from the given BinaryReader." _color = reader.read('I') _xCen = reader.read('f') _yCen = reader.read('f') _xRad = reader.read('f') _yRad = reader.read('f') return cls(_color, _xCen, _yCen, _xRad, _yRad) def pack(self): "Writes the current CameraOval, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current CameraOval to the given BinaryWriter." writer.write(self._color, 'I') writer.write(self._xCen, 'f') writer.write(self._yCen, 'f') writer.write(self._xRad, 'f') writer.write(self._yRad, 'f') def __eq__(self, other): if type(self) is type(other): return (self._color == other._color and self._xCen == other._xCen and self._yCen == other._yCen and self._xRad == other._xRad and self._yRad == other._yRad) else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._color, 'I') + msgbuffers.size(self._xCen, 'f') + msgbuffers.size(self._yCen, 'f') + msgbuffers.size(self._xRad, 'f') + msgbuffers.size(self._yRad, 'f')) def __str__(self): return '{type}(color={color}, xCen={xCen}, yCen={yCen}, xRad={xRad}, yRad={yRad})'.format( type=type(self).__name__, color=self._color, xCen=self._xCen, yCen=self._yCen, xRad=self._xRad, yRad=self._yRad) def __repr__(self): return '{type}(color={color}, xCen={xCen}, yCen={yCen}, xRad={xRad}, yRad={yRad})'.format( type=type(self).__name__, color=repr(self._color), xCen=repr(self._xCen), yCen=repr(self._yCen), xRad=repr(self._xRad), yRad=repr(self._yRad)) Anki.Vector.VizInterface.CameraOval = CameraOval del CameraOval class CameraText(object): "Generated message-passing message." __slots__ = ( '_color', # uint_32 '_x', # int_32 '_y', # int_32 '_text', # string[uint_8] ) @property def color(self): "uint_32 color struct property." return self._color @color.setter def color(self, value): self._color = msgbuffers.validate_integer( 'CameraText.color', value, 0, 4294967295) @property def x(self): "int_32 x struct property." return self._x @x.setter def x(self, value): self._x = msgbuffers.validate_integer( 'CameraText.x', value, -2147483648, 2147483647) @property def y(self): "int_32 y struct property." return self._y @y.setter def y(self, value): self._y = msgbuffers.validate_integer( 'CameraText.y', value, -2147483648, 2147483647) @property def text(self): "string[uint_8] text struct property." return self._text @text.setter def text(self, value): self._text = msgbuffers.validate_string( 'CameraText.text', value, 255) def __init__(self, color=0, x=0, y=0, text=''): self.color = color self.x = x self.y = y self.text = text @classmethod def unpack(cls, buffer): "Reads a new CameraText from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('CameraText.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new CameraText from the given BinaryReader." _color = reader.read('I') _x = reader.read('i') _y = reader.read('i') _text = reader.read_string('B') return cls(_color, _x, _y, _text) def pack(self): "Writes the current CameraText, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current CameraText to the given BinaryWriter." writer.write(self._color, 'I') writer.write(self._x, 'i') writer.write(self._y, 'i') writer.write_string(self._text, 'B') def __eq__(self, other): if type(self) is type(other): return (self._color == other._color and self._x == other._x and self._y == other._y and self._text == other._text) else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._color, 'I') + msgbuffers.size(self._x, 'i') + msgbuffers.size(self._y, 'i') + msgbuffers.size_string(self._text, 'B')) def __str__(self): return '{type}(color={color}, x={x}, y={y}, text={text})'.format( type=type(self).__name__, color=self._color, x=self._x, y=self._y, text=msgbuffers.shorten_string(self._text)) def __repr__(self): return '{type}(color={color}, x={x}, y={y}, text={text})'.format( type=type(self).__name__, color=repr(self._color), x=repr(self._x), y=repr(self._y), text=repr(self._text)) Anki.Vector.VizInterface.CameraText = CameraText del CameraText class EraseObject(object): "Generated message-passing message." __slots__ = ( '_objectID', # uint_32 '_lower_bound_id', # uint_32 '_upper_bound_id', # uint_32 ) @property def objectID(self): "uint_32 objectID struct property." return self._objectID @objectID.setter def objectID(self, value): self._objectID = msgbuffers.validate_integer( 'EraseObject.objectID', value, 0, 4294967295) @property def lower_bound_id(self): "uint_32 lower_bound_id struct property." return self._lower_bound_id @lower_bound_id.setter def lower_bound_id(self, value): self._lower_bound_id = msgbuffers.validate_integer( 'EraseObject.lower_bound_id', value, 0, 4294967295) @property def upper_bound_id(self): "uint_32 upper_bound_id struct property." return self._upper_bound_id @upper_bound_id.setter def upper_bound_id(self, value): self._upper_bound_id = msgbuffers.validate_integer( 'EraseObject.upper_bound_id', value, 0, 4294967295) def __init__(self, objectID=0, lower_bound_id=0, upper_bound_id=0): self.objectID = objectID self.lower_bound_id = lower_bound_id self.upper_bound_id = upper_bound_id @classmethod def unpack(cls, buffer): "Reads a new EraseObject from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('EraseObject.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new EraseObject from the given BinaryReader." _objectID = reader.read('I') _lower_bound_id = reader.read('I') _upper_bound_id = reader.read('I') return cls(_objectID, _lower_bound_id, _upper_bound_id) def pack(self): "Writes the current EraseObject, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current EraseObject to the given BinaryWriter." writer.write(self._objectID, 'I') writer.write(self._lower_bound_id, 'I') writer.write(self._upper_bound_id, 'I') def __eq__(self, other): if type(self) is type(other): return (self._objectID == other._objectID and self._lower_bound_id == other._lower_bound_id and self._upper_bound_id == other._upper_bound_id) else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._objectID, 'I') + msgbuffers.size(self._lower_bound_id, 'I') + msgbuffers.size(self._upper_bound_id, 'I')) def __str__(self): return '{type}(objectID={objectID}, lower_bound_id={lower_bound_id}, upper_bound_id={upper_bound_id})'.format( type=type(self).__name__, objectID=self._objectID, lower_bound_id=self._lower_bound_id, upper_bound_id=self._upper_bound_id) def __repr__(self): return '{type}(objectID={objectID}, lower_bound_id={lower_bound_id}, upper_bound_id={upper_bound_id})'.format( type=type(self).__name__, objectID=repr(self._objectID), lower_bound_id=repr(self._lower_bound_id), upper_bound_id=repr(self._upper_bound_id)) Anki.Vector.VizInterface.EraseObject = EraseObject del EraseObject class EraseLineSegments(object): "Generated message-passing message." __slots__ = ( '_identifier', # string[uint_8] ) @property def identifier(self): "string[uint_8] identifier struct property." return self._identifier @identifier.setter def identifier(self, value): self._identifier = msgbuffers.validate_string( 'EraseLineSegments.identifier', value, 255) def __init__(self, identifier=''): self.identifier = identifier @classmethod def unpack(cls, buffer): "Reads a new EraseLineSegments from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('EraseLineSegments.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new EraseLineSegments from the given BinaryReader." _identifier = reader.read_string('B') return cls(_identifier) def pack(self): "Writes the current EraseLineSegments, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current EraseLineSegments to the given BinaryWriter." writer.write_string(self._identifier, 'B') def __eq__(self, other): if type(self) is type(other): return self._identifier == other._identifier else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size_string(self._identifier, 'B')) def __str__(self): return '{type}(identifier={identifier})'.format( type=type(self).__name__, identifier=msgbuffers.shorten_string(self._identifier)) def __repr__(self): return '{type}(identifier={identifier})'.format( type=type(self).__name__, identifier=repr(self._identifier)) Anki.Vector.VizInterface.EraseLineSegments = EraseLineSegments del EraseLineSegments class EraseQuad(object): "Generated message-passing message." __slots__ = ( '_quadType', # uint_32 '_quadID', # uint_32 ) @property def quadType(self): "uint_32 quadType struct property." return self._quadType @quadType.setter def quadType(self, value): self._quadType = msgbuffers.validate_integer( 'EraseQuad.quadType', value, 0, 4294967295) @property def quadID(self): "uint_32 quadID struct property." return self._quadID @quadID.setter def quadID(self, value): self._quadID = msgbuffers.validate_integer( 'EraseQuad.quadID', value, 0, 4294967295) def __init__(self, quadType=0, quadID=0): self.quadType = quadType self.quadID = quadID @classmethod def unpack(cls, buffer): "Reads a new EraseQuad from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('EraseQuad.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new EraseQuad from the given BinaryReader." _quadType = reader.read('I') _quadID = reader.read('I') return cls(_quadType, _quadID) def pack(self): "Writes the current EraseQuad, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current EraseQuad to the given BinaryWriter." writer.write(self._quadType, 'I') writer.write(self._quadID, 'I') def __eq__(self, other): if type(self) is type(other): return (self._quadType == other._quadType and self._quadID == other._quadID) else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._quadType, 'I') + msgbuffers.size(self._quadID, 'I')) def __str__(self): return '{type}(quadType={quadType}, quadID={quadID})'.format( type=type(self).__name__, quadType=self._quadType, quadID=self._quadID) def __repr__(self): return '{type}(quadType={quadType}, quadID={quadID})'.format( type=type(self).__name__, quadType=repr(self._quadType), quadID=repr(self._quadID)) Anki.Vector.VizInterface.EraseQuad = EraseQuad del EraseQuad class SetRobot(object): "Generated message-passing message." __slots__ = ( '_x_trans_m', # float_32 '_y_trans_m', # float_32 '_z_trans_m', # float_32 '_rot_rad', # float_32 '_rot_axis_x', # float_32 '_rot_axis_y', # float_32 '_rot_axis_z', # float_32 '_head_angle', # float_32 '_lift_angle', # float_32 ) @property def x_trans_m(self): "float_32 x_trans_m struct property." return self._x_trans_m @x_trans_m.setter def x_trans_m(self, value): self._x_trans_m = msgbuffers.validate_float( 'SetRobot.x_trans_m', value, 'f') @property def y_trans_m(self): "float_32 y_trans_m struct property." return self._y_trans_m @y_trans_m.setter def y_trans_m(self, value): self._y_trans_m = msgbuffers.validate_float( 'SetRobot.y_trans_m', value, 'f') @property def z_trans_m(self): "float_32 z_trans_m struct property." return self._z_trans_m @z_trans_m.setter def z_trans_m(self, value): self._z_trans_m = msgbuffers.validate_float( 'SetRobot.z_trans_m', value, 'f') @property def rot_rad(self): "float_32 rot_rad struct property." return self._rot_rad @rot_rad.setter def rot_rad(self, value): self._rot_rad = msgbuffers.validate_float( 'SetRobot.rot_rad', value, 'f') @property def rot_axis_x(self): "float_32 rot_axis_x struct property." return self._rot_axis_x @rot_axis_x.setter def rot_axis_x(self, value): self._rot_axis_x = msgbuffers.validate_float( 'SetRobot.rot_axis_x', value, 'f') @property def rot_axis_y(self): "float_32 rot_axis_y struct property." return self._rot_axis_y @rot_axis_y.setter def rot_axis_y(self, value): self._rot_axis_y = msgbuffers.validate_float( 'SetRobot.rot_axis_y', value, 'f') @property def rot_axis_z(self): "float_32 rot_axis_z struct property." return self._rot_axis_z @rot_axis_z.setter def rot_axis_z(self, value): self._rot_axis_z = msgbuffers.validate_float( 'SetRobot.rot_axis_z', value, 'f') @property def head_angle(self): "float_32 head_angle struct property." return self._head_angle @head_angle.setter def head_angle(self, value): self._head_angle = msgbuffers.validate_float( 'SetRobot.head_angle', value, 'f') @property def lift_angle(self): "float_32 lift_angle struct property." return self._lift_angle @lift_angle.setter def lift_angle(self, value): self._lift_angle = msgbuffers.validate_float( 'SetRobot.lift_angle', value, 'f') def __init__(self, x_trans_m=0.0, y_trans_m=0.0, z_trans_m=0.0, rot_rad=0.0, rot_axis_x=0.0, rot_axis_y=0.0, rot_axis_z=0.0, head_angle=0.0, lift_angle=0.0): self.x_trans_m = x_trans_m self.y_trans_m = y_trans_m self.z_trans_m = z_trans_m self.rot_rad = rot_rad self.rot_axis_x = rot_axis_x self.rot_axis_y = rot_axis_y self.rot_axis_z = rot_axis_z self.head_angle = head_angle self.lift_angle = lift_angle @classmethod def unpack(cls, buffer): "Reads a new SetRobot from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('SetRobot.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new SetRobot from the given BinaryReader." _x_trans_m = reader.read('f') _y_trans_m = reader.read('f') _z_trans_m = reader.read('f') _rot_rad = reader.read('f') _rot_axis_x = reader.read('f') _rot_axis_y = reader.read('f') _rot_axis_z = reader.read('f') _head_angle = reader.read('f') _lift_angle = reader.read('f') return cls(_x_trans_m, _y_trans_m, _z_trans_m, _rot_rad, _rot_axis_x, _rot_axis_y, _rot_axis_z, _head_angle, _lift_angle) def pack(self): "Writes the current SetRobot, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current SetRobot to the given BinaryWriter." writer.write(self._x_trans_m, 'f') writer.write(self._y_trans_m, 'f') writer.write(self._z_trans_m, 'f') writer.write(self._rot_rad, 'f') writer.write(self._rot_axis_x, 'f') writer.write(self._rot_axis_y, 'f') writer.write(self._rot_axis_z, 'f') writer.write(self._head_angle, 'f') writer.write(self._lift_angle, 'f') def __eq__(self, other): if type(self) is type(other): return (self._x_trans_m == other._x_trans_m and self._y_trans_m == other._y_trans_m and self._z_trans_m == other._z_trans_m and self._rot_rad == other._rot_rad and self._rot_axis_x == other._rot_axis_x and self._rot_axis_y == other._rot_axis_y and self._rot_axis_z == other._rot_axis_z and self._head_angle == other._head_angle and self._lift_angle == other._lift_angle) else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._x_trans_m, 'f') + msgbuffers.size(self._y_trans_m, 'f') + msgbuffers.size(self._z_trans_m, 'f') + msgbuffers.size(self._rot_rad, 'f') + msgbuffers.size(self._rot_axis_x, 'f') + msgbuffers.size(self._rot_axis_y, 'f') + msgbuffers.size(self._rot_axis_z, 'f') + msgbuffers.size(self._head_angle, 'f') + msgbuffers.size(self._lift_angle, 'f')) def __str__(self): return '{type}(x_trans_m={x_trans_m}, y_trans_m={y_trans_m}, z_trans_m={z_trans_m}, rot_rad={rot_rad}, rot_axis_x={rot_axis_x}, rot_axis_y={rot_axis_y}, rot_axis_z={rot_axis_z}, head_angle={head_angle}, lift_angle={lift_angle})'.format( type=type(self).__name__, x_trans_m=self._x_trans_m, y_trans_m=self._y_trans_m, z_trans_m=self._z_trans_m, rot_rad=self._rot_rad, rot_axis_x=self._rot_axis_x, rot_axis_y=self._rot_axis_y, rot_axis_z=self._rot_axis_z, head_angle=self._head_angle, lift_angle=self._lift_angle) def __repr__(self): return '{type}(x_trans_m={x_trans_m}, y_trans_m={y_trans_m}, z_trans_m={z_trans_m}, rot_rad={rot_rad}, rot_axis_x={rot_axis_x}, rot_axis_y={rot_axis_y}, rot_axis_z={rot_axis_z}, head_angle={head_angle}, lift_angle={lift_angle})'.format( type=type(self).__name__, x_trans_m=repr(self._x_trans_m), y_trans_m=repr(self._y_trans_m), z_trans_m=repr(self._z_trans_m), rot_rad=repr(self._rot_rad), rot_axis_x=repr(self._rot_axis_x), rot_axis_y=repr(self._rot_axis_y), rot_axis_z=repr(self._rot_axis_z), head_angle=repr(self._head_angle), lift_angle=repr(self._lift_angle)) Anki.Vector.VizInterface.SetRobot = SetRobot del SetRobot class AppendPathSegmentLine(object): "Generated message-passing message." __slots__ = ( '_pathID', # uint_32 '_x_start_m', # float_32 '_y_start_m', # float_32 '_z_start_m', # float_32 '_x_end_m', # float_32 '_y_end_m', # float_32 '_z_end_m', # float_32 ) @property def pathID(self): "uint_32 pathID struct property." return self._pathID @pathID.setter def pathID(self, value): self._pathID = msgbuffers.validate_integer( 'AppendPathSegmentLine.pathID', value, 0, 4294967295) @property def x_start_m(self): "float_32 x_start_m struct property." return self._x_start_m @x_start_m.setter def x_start_m(self, value): self._x_start_m = msgbuffers.validate_float( 'AppendPathSegmentLine.x_start_m', value, 'f') @property def y_start_m(self): "float_32 y_start_m struct property." return self._y_start_m @y_start_m.setter def y_start_m(self, value): self._y_start_m = msgbuffers.validate_float( 'AppendPathSegmentLine.y_start_m', value, 'f') @property def z_start_m(self): "float_32 z_start_m struct property." return self._z_start_m @z_start_m.setter def z_start_m(self, value): self._z_start_m = msgbuffers.validate_float( 'AppendPathSegmentLine.z_start_m', value, 'f') @property def x_end_m(self): "float_32 x_end_m struct property." return self._x_end_m @x_end_m.setter def x_end_m(self, value): self._x_end_m = msgbuffers.validate_float( 'AppendPathSegmentLine.x_end_m', value, 'f') @property def y_end_m(self): "float_32 y_end_m struct property." return self._y_end_m @y_end_m.setter def y_end_m(self, value): self._y_end_m = msgbuffers.validate_float( 'AppendPathSegmentLine.y_end_m', value, 'f') @property def z_end_m(self): "float_32 z_end_m struct property." return self._z_end_m @z_end_m.setter def z_end_m(self, value): self._z_end_m = msgbuffers.validate_float( 'AppendPathSegmentLine.z_end_m', value, 'f') def __init__(self, pathID=0, x_start_m=0.0, y_start_m=0.0, z_start_m=0.0, x_end_m=0.0, y_end_m=0.0, z_end_m=0.0): self.pathID = pathID self.x_start_m = x_start_m self.y_start_m = y_start_m self.z_start_m = z_start_m self.x_end_m = x_end_m self.y_end_m = y_end_m self.z_end_m = z_end_m @classmethod def unpack(cls, buffer): "Reads a new AppendPathSegmentLine from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('AppendPathSegmentLine.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new AppendPathSegmentLine from the given BinaryReader." _pathID = reader.read('I') _x_start_m = reader.read('f') _y_start_m = reader.read('f') _z_start_m = reader.read('f') _x_end_m = reader.read('f') _y_end_m = reader.read('f') _z_end_m = reader.read('f') return cls(_pathID, _x_start_m, _y_start_m, _z_start_m, _x_end_m, _y_end_m, _z_end_m) def pack(self): "Writes the current AppendPathSegmentLine, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current AppendPathSegmentLine to the given BinaryWriter." writer.write(self._pathID, 'I') writer.write(self._x_start_m, 'f') writer.write(self._y_start_m, 'f') writer.write(self._z_start_m, 'f') writer.write(self._x_end_m, 'f') writer.write(self._y_end_m, 'f') writer.write(self._z_end_m, 'f') def __eq__(self, other): if type(self) is type(other): return (self._pathID == other._pathID and self._x_start_m == other._x_start_m and self._y_start_m == other._y_start_m and self._z_start_m == other._z_start_m and self._x_end_m == other._x_end_m and self._y_end_m == other._y_end_m and self._z_end_m == other._z_end_m) else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._pathID, 'I') + msgbuffers.size(self._x_start_m, 'f') + msgbuffers.size(self._y_start_m, 'f') + msgbuffers.size(self._z_start_m, 'f') + msgbuffers.size(self._x_end_m, 'f') + msgbuffers.size(self._y_end_m, 'f') + msgbuffers.size(self._z_end_m, 'f')) def __str__(self): return '{type}(pathID={pathID}, x_start_m={x_start_m}, y_start_m={y_start_m}, z_start_m={z_start_m}, x_end_m={x_end_m}, y_end_m={y_end_m}, z_end_m={z_end_m})'.format( type=type(self).__name__, pathID=self._pathID, x_start_m=self._x_start_m, y_start_m=self._y_start_m, z_start_m=self._z_start_m, x_end_m=self._x_end_m, y_end_m=self._y_end_m, z_end_m=self._z_end_m) def __repr__(self): return '{type}(pathID={pathID}, x_start_m={x_start_m}, y_start_m={y_start_m}, z_start_m={z_start_m}, x_end_m={x_end_m}, y_end_m={y_end_m}, z_end_m={z_end_m})'.format( type=type(self).__name__, pathID=repr(self._pathID), x_start_m=repr(self._x_start_m), y_start_m=repr(self._y_start_m), z_start_m=repr(self._z_start_m), x_end_m=repr(self._x_end_m), y_end_m=repr(self._y_end_m), z_end_m=repr(self._z_end_m)) Anki.Vector.VizInterface.AppendPathSegmentLine = AppendPathSegmentLine del AppendPathSegmentLine class AppendPathSegmentArc(object): "Generated message-passing message." __slots__ = ( '_pathID', # uint_32 '_x_center_m', # float_32 '_y_center_m', # float_32 '_radius_m', # float_32 '_start_rad', # float_32 '_sweep_rad', # float_32 ) @property def pathID(self): "uint_32 pathID struct property." return self._pathID @pathID.setter def pathID(self, value): self._pathID = msgbuffers.validate_integer( 'AppendPathSegmentArc.pathID', value, 0, 4294967295) @property def x_center_m(self): "float_32 x_center_m struct property." return self._x_center_m @x_center_m.setter def x_center_m(self, value): self._x_center_m = msgbuffers.validate_float( 'AppendPathSegmentArc.x_center_m', value, 'f') @property def y_center_m(self): "float_32 y_center_m struct property." return self._y_center_m @y_center_m.setter def y_center_m(self, value): self._y_center_m = msgbuffers.validate_float( 'AppendPathSegmentArc.y_center_m', value, 'f') @property def radius_m(self): "float_32 radius_m struct property." return self._radius_m @radius_m.setter def radius_m(self, value): self._radius_m = msgbuffers.validate_float( 'AppendPathSegmentArc.radius_m', value, 'f') @property def start_rad(self): "float_32 start_rad struct property." return self._start_rad @start_rad.setter def start_rad(self, value): self._start_rad = msgbuffers.validate_float( 'AppendPathSegmentArc.start_rad', value, 'f') @property def sweep_rad(self): "float_32 sweep_rad struct property." return self._sweep_rad @sweep_rad.setter def sweep_rad(self, value): self._sweep_rad = msgbuffers.validate_float( 'AppendPathSegmentArc.sweep_rad', value, 'f') def __init__(self, pathID=0, x_center_m=0.0, y_center_m=0.0, radius_m=0.0, start_rad=0.0, sweep_rad=0.0): self.pathID = pathID self.x_center_m = x_center_m self.y_center_m = y_center_m self.radius_m = radius_m self.start_rad = start_rad self.sweep_rad = sweep_rad @classmethod def unpack(cls, buffer): "Reads a new AppendPathSegmentArc from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('AppendPathSegmentArc.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new AppendPathSegmentArc from the given BinaryReader." _pathID = reader.read('I') _x_center_m = reader.read('f') _y_center_m = reader.read('f') _radius_m = reader.read('f') _start_rad = reader.read('f') _sweep_rad = reader.read('f') return cls(_pathID, _x_center_m, _y_center_m, _radius_m, _start_rad, _sweep_rad) def pack(self): "Writes the current AppendPathSegmentArc, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current AppendPathSegmentArc to the given BinaryWriter." writer.write(self._pathID, 'I') writer.write(self._x_center_m, 'f') writer.write(self._y_center_m, 'f') writer.write(self._radius_m, 'f') writer.write(self._start_rad, 'f') writer.write(self._sweep_rad, 'f') def __eq__(self, other): if type(self) is type(other): return (self._pathID == other._pathID and self._x_center_m == other._x_center_m and self._y_center_m == other._y_center_m and self._radius_m == other._radius_m and self._start_rad == other._start_rad and self._sweep_rad == other._sweep_rad) else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._pathID, 'I') + msgbuffers.size(self._x_center_m, 'f') + msgbuffers.size(self._y_center_m, 'f') + msgbuffers.size(self._radius_m, 'f') + msgbuffers.size(self._start_rad, 'f') + msgbuffers.size(self._sweep_rad, 'f')) def __str__(self): return '{type}(pathID={pathID}, x_center_m={x_center_m}, y_center_m={y_center_m}, radius_m={radius_m}, start_rad={start_rad}, sweep_rad={sweep_rad})'.format( type=type(self).__name__, pathID=self._pathID, x_center_m=self._x_center_m, y_center_m=self._y_center_m, radius_m=self._radius_m, start_rad=self._start_rad, sweep_rad=self._sweep_rad) def __repr__(self): return '{type}(pathID={pathID}, x_center_m={x_center_m}, y_center_m={y_center_m}, radius_m={radius_m}, start_rad={start_rad}, sweep_rad={sweep_rad})'.format( type=type(self).__name__, pathID=repr(self._pathID), x_center_m=repr(self._x_center_m), y_center_m=repr(self._y_center_m), radius_m=repr(self._radius_m), start_rad=repr(self._start_rad), sweep_rad=repr(self._sweep_rad)) Anki.Vector.VizInterface.AppendPathSegmentArc = AppendPathSegmentArc del AppendPathSegmentArc class SetPathColor(object): "Generated message-passing message." __slots__ = ( '_pathID', # uint_32 '_colorID', # uint_32 ) @property def pathID(self): "uint_32 pathID struct property." return self._pathID @pathID.setter def pathID(self, value): self._pathID = msgbuffers.validate_integer( 'SetPathColor.pathID', value, 0, 4294967295) @property def colorID(self): "uint_32 colorID struct property." return self._colorID @colorID.setter def colorID(self, value): self._colorID = msgbuffers.validate_integer( 'SetPathColor.colorID', value, 0, 4294967295) def __init__(self, pathID=0, colorID=0): self.pathID = pathID self.colorID = colorID @classmethod def unpack(cls, buffer): "Reads a new SetPathColor from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('SetPathColor.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new SetPathColor from the given BinaryReader." _pathID = reader.read('I') _colorID = reader.read('I') return cls(_pathID, _colorID) def pack(self): "Writes the current SetPathColor, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current SetPathColor to the given BinaryWriter." writer.write(self._pathID, 'I') writer.write(self._colorID, 'I') def __eq__(self, other): if type(self) is type(other): return (self._pathID == other._pathID and self._colorID == other._colorID) else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._pathID, 'I') + msgbuffers.size(self._colorID, 'I')) def __str__(self): return '{type}(pathID={pathID}, colorID={colorID})'.format( type=type(self).__name__, pathID=self._pathID, colorID=self._colorID) def __repr__(self): return '{type}(pathID={pathID}, colorID={colorID})'.format( type=type(self).__name__, pathID=repr(self._pathID), colorID=repr(self._colorID)) Anki.Vector.VizInterface.SetPathColor = SetPathColor del SetPathColor class ErasePath(object): "Generated message-passing message." __slots__ = ( '_pathID', # uint_32 ) @property def pathID(self): "uint_32 pathID struct property." return self._pathID @pathID.setter def pathID(self, value): self._pathID = msgbuffers.validate_integer( 'ErasePath.pathID', value, 0, 4294967295) def __init__(self, pathID=0): self.pathID = pathID @classmethod def unpack(cls, buffer): "Reads a new ErasePath from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('ErasePath.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new ErasePath from the given BinaryReader." _pathID = reader.read('I') return cls(_pathID) def pack(self): "Writes the current ErasePath, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current ErasePath to the given BinaryWriter." writer.write(self._pathID, 'I') def __eq__(self, other): if type(self) is type(other): return self._pathID == other._pathID else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._pathID, 'I')) def __str__(self): return '{type}(pathID={pathID})'.format( type=type(self).__name__, pathID=self._pathID) def __repr__(self): return '{type}(pathID={pathID})'.format( type=type(self).__name__, pathID=repr(self._pathID)) Anki.Vector.VizInterface.ErasePath = ErasePath del ErasePath class SetLabel(object): "Generated message-passing message." __slots__ = ( '_labelID', # uint_32 '_colorID', # uint_32 '_text', # string[uint_8] ) @property def labelID(self): "uint_32 labelID struct property." return self._labelID @labelID.setter def labelID(self, value): self._labelID = msgbuffers.validate_integer( 'SetLabel.labelID', value, 0, 4294967295) @property def colorID(self): "uint_32 colorID struct property." return self._colorID @colorID.setter def colorID(self, value): self._colorID = msgbuffers.validate_integer( 'SetLabel.colorID', value, 0, 4294967295) @property def text(self): "string[uint_8] text struct property." return self._text @text.setter def text(self, value): self._text = msgbuffers.validate_string( 'SetLabel.text', value, 255) def __init__(self, labelID=0, colorID=0, text=''): self.labelID = labelID self.colorID = colorID self.text = text @classmethod def unpack(cls, buffer): "Reads a new SetLabel from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('SetLabel.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new SetLabel from the given BinaryReader." _labelID = reader.read('I') _colorID = reader.read('I') _text = reader.read_string('B') return cls(_labelID, _colorID, _text) def pack(self): "Writes the current SetLabel, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current SetLabel to the given BinaryWriter." writer.write(self._labelID, 'I') writer.write(self._colorID, 'I') writer.write_string(self._text, 'B') def __eq__(self, other): if type(self) is type(other): return (self._labelID == other._labelID and self._colorID == other._colorID and self._text == other._text) else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._labelID, 'I') + msgbuffers.size(self._colorID, 'I') + msgbuffers.size_string(self._text, 'B')) def __str__(self): return '{type}(labelID={labelID}, colorID={colorID}, text={text})'.format( type=type(self).__name__, labelID=self._labelID, colorID=self._colorID, text=msgbuffers.shorten_string(self._text)) def __repr__(self): return '{type}(labelID={labelID}, colorID={colorID}, text={text})'.format( type=type(self).__name__, labelID=repr(self._labelID), colorID=repr(self._colorID), text=repr(self._text)) Anki.Vector.VizInterface.SetLabel = SetLabel del SetLabel class DockingErrorSignal(object): "Generated message-passing message." __slots__ = ( '_x_dist', # float_32 '_y_dist', # float_32 '_z_dist', # float_32 '_angle', # float_32 ) @property def x_dist(self): "float_32 x_dist struct property." return self._x_dist @x_dist.setter def x_dist(self, value): self._x_dist = msgbuffers.validate_float( 'DockingErrorSignal.x_dist', value, 'f') @property def y_dist(self): "float_32 y_dist struct property." return self._y_dist @y_dist.setter def y_dist(self, value): self._y_dist = msgbuffers.validate_float( 'DockingErrorSignal.y_dist', value, 'f') @property def z_dist(self): "float_32 z_dist struct property." return self._z_dist @z_dist.setter def z_dist(self, value): self._z_dist = msgbuffers.validate_float( 'DockingErrorSignal.z_dist', value, 'f') @property def angle(self): "float_32 angle struct property." return self._angle @angle.setter def angle(self, value): self._angle = msgbuffers.validate_float( 'DockingErrorSignal.angle', value, 'f') def __init__(self, x_dist=0.0, y_dist=0.0, z_dist=0.0, angle=0.0): self.x_dist = x_dist self.y_dist = y_dist self.z_dist = z_dist self.angle = angle @classmethod def unpack(cls, buffer): "Reads a new DockingErrorSignal from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('DockingErrorSignal.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new DockingErrorSignal from the given BinaryReader." _x_dist = reader.read('f') _y_dist = reader.read('f') _z_dist = reader.read('f') _angle = reader.read('f') return cls(_x_dist, _y_dist, _z_dist, _angle) def pack(self): "Writes the current DockingErrorSignal, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current DockingErrorSignal to the given BinaryWriter." writer.write(self._x_dist, 'f') writer.write(self._y_dist, 'f') writer.write(self._z_dist, 'f') writer.write(self._angle, 'f') def __eq__(self, other): if type(self) is type(other): return (self._x_dist == other._x_dist and self._y_dist == other._y_dist and self._z_dist == other._z_dist and self._angle == other._angle) else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._x_dist, 'f') + msgbuffers.size(self._y_dist, 'f') + msgbuffers.size(self._z_dist, 'f') + msgbuffers.size(self._angle, 'f')) def __str__(self): return '{type}(x_dist={x_dist}, y_dist={y_dist}, z_dist={z_dist}, angle={angle})'.format( type=type(self).__name__, x_dist=self._x_dist, y_dist=self._y_dist, z_dist=self._z_dist, angle=self._angle) def __repr__(self): return '{type}(x_dist={x_dist}, y_dist={y_dist}, z_dist={z_dist}, angle={angle})'.format( type=type(self).__name__, x_dist=repr(self._x_dist), y_dist=repr(self._y_dist), z_dist=repr(self._z_dist), angle=repr(self._angle)) Anki.Vector.VizInterface.DockingErrorSignal = DockingErrorSignal del DockingErrorSignal class CameraParams(object): "Generated message-passing message." __slots__ = ( '_cameraParams', # Anki.Vision.CameraParams ) @property def cameraParams(self): "Anki.Vision.CameraParams cameraParams struct property." return self._cameraParams @cameraParams.setter def cameraParams(self, value): self._cameraParams = msgbuffers.validate_object( 'CameraParams.cameraParams', value, Anki.Vision.CameraParams) def __init__(self, cameraParams=Anki.Vision.CameraParams()): self.cameraParams = cameraParams @classmethod def unpack(cls, buffer): "Reads a new CameraParams from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('CameraParams.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new CameraParams from the given BinaryReader." _cameraParams = reader.read_object(Anki.Vision.CameraParams.unpack_from) return cls(_cameraParams) def pack(self): "Writes the current CameraParams, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current CameraParams to the given BinaryWriter." writer.write_object(self._cameraParams) def __eq__(self, other): if type(self) is type(other): return self._cameraParams == other._cameraParams else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size_object(self._cameraParams)) def __str__(self): return '{type}(cameraParams={cameraParams})'.format( type=type(self).__name__, cameraParams=self._cameraParams) def __repr__(self): return '{type}(cameraParams={cameraParams})'.format( type=type(self).__name__, cameraParams=repr(self._cameraParams)) Anki.Vector.VizInterface.CameraParams = CameraParams del CameraParams class VisionMarker(object): "Generated message-passing message." __slots__ = ( '_topLeft_x', # int_16 '_topLeft_y', # int_16 '_topRight_x', # int_16 '_topRight_y', # int_16 '_bottomRight_x', # int_16 '_bottomRight_y', # int_16 '_bottomLeft_x', # int_16 '_bottomLeft_y', # int_16 '_verified', # int_8 ) @property def topLeft_x(self): "int_16 topLeft_x struct property." return self._topLeft_x @topLeft_x.setter def topLeft_x(self, value): self._topLeft_x = msgbuffers.validate_integer( 'VisionMarker.topLeft_x', value, -32768, 32767) @property def topLeft_y(self): "int_16 topLeft_y struct property." return self._topLeft_y @topLeft_y.setter def topLeft_y(self, value): self._topLeft_y = msgbuffers.validate_integer( 'VisionMarker.topLeft_y', value, -32768, 32767) @property def topRight_x(self): "int_16 topRight_x struct property." return self._topRight_x @topRight_x.setter def topRight_x(self, value): self._topRight_x = msgbuffers.validate_integer( 'VisionMarker.topRight_x', value, -32768, 32767) @property def topRight_y(self): "int_16 topRight_y struct property." return self._topRight_y @topRight_y.setter def topRight_y(self, value): self._topRight_y = msgbuffers.validate_integer( 'VisionMarker.topRight_y', value, -32768, 32767) @property def bottomRight_x(self): "int_16 bottomRight_x struct property." return self._bottomRight_x @bottomRight_x.setter def bottomRight_x(self, value): self._bottomRight_x = msgbuffers.validate_integer( 'VisionMarker.bottomRight_x', value, -32768, 32767) @property def bottomRight_y(self): "int_16 bottomRight_y struct property." return self._bottomRight_y @bottomRight_y.setter def bottomRight_y(self, value): self._bottomRight_y = msgbuffers.validate_integer( 'VisionMarker.bottomRight_y', value, -32768, 32767) @property def bottomLeft_x(self): "int_16 bottomLeft_x struct property." return self._bottomLeft_x @bottomLeft_x.setter def bottomLeft_x(self, value): self._bottomLeft_x = msgbuffers.validate_integer( 'VisionMarker.bottomLeft_x', value, -32768, 32767) @property def bottomLeft_y(self): "int_16 bottomLeft_y struct property." return self._bottomLeft_y @bottomLeft_y.setter def bottomLeft_y(self, value): self._bottomLeft_y = msgbuffers.validate_integer( 'VisionMarker.bottomLeft_y', value, -32768, 32767) @property def verified(self): "int_8 verified struct property." return self._verified @verified.setter def verified(self, value): self._verified = msgbuffers.validate_integer( 'VisionMarker.verified', value, -128, 127) def __init__(self, topLeft_x=0, topLeft_y=0, topRight_x=0, topRight_y=0, bottomRight_x=0, bottomRight_y=0, bottomLeft_x=0, bottomLeft_y=0, verified=0): self.topLeft_x = topLeft_x self.topLeft_y = topLeft_y self.topRight_x = topRight_x self.topRight_y = topRight_y self.bottomRight_x = bottomRight_x self.bottomRight_y = bottomRight_y self.bottomLeft_x = bottomLeft_x self.bottomLeft_y = bottomLeft_y self.verified = verified @classmethod def unpack(cls, buffer): "Reads a new VisionMarker from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('VisionMarker.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new VisionMarker from the given BinaryReader." _topLeft_x = reader.read('h') _topLeft_y = reader.read('h') _topRight_x = reader.read('h') _topRight_y = reader.read('h') _bottomRight_x = reader.read('h') _bottomRight_y = reader.read('h') _bottomLeft_x = reader.read('h') _bottomLeft_y = reader.read('h') _verified = reader.read('b') return cls(_topLeft_x, _topLeft_y, _topRight_x, _topRight_y, _bottomRight_x, _bottomRight_y, _bottomLeft_x, _bottomLeft_y, _verified) def pack(self): "Writes the current VisionMarker, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current VisionMarker to the given BinaryWriter." writer.write(self._topLeft_x, 'h') writer.write(self._topLeft_y, 'h') writer.write(self._topRight_x, 'h') writer.write(self._topRight_y, 'h') writer.write(self._bottomRight_x, 'h') writer.write(self._bottomRight_y, 'h') writer.write(self._bottomLeft_x, 'h') writer.write(self._bottomLeft_y, 'h') writer.write(self._verified, 'b') def __eq__(self, other): if type(self) is type(other): return (self._topLeft_x == other._topLeft_x and self._topLeft_y == other._topLeft_y and self._topRight_x == other._topRight_x and self._topRight_y == other._topRight_y and self._bottomRight_x == other._bottomRight_x and self._bottomRight_y == other._bottomRight_y and self._bottomLeft_x == other._bottomLeft_x and self._bottomLeft_y == other._bottomLeft_y and self._verified == other._verified) else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._topLeft_x, 'h') + msgbuffers.size(self._topLeft_y, 'h') + msgbuffers.size(self._topRight_x, 'h') + msgbuffers.size(self._topRight_y, 'h') + msgbuffers.size(self._bottomRight_x, 'h') + msgbuffers.size(self._bottomRight_y, 'h') + msgbuffers.size(self._bottomLeft_x, 'h') + msgbuffers.size(self._bottomLeft_y, 'h') + msgbuffers.size(self._verified, 'b')) def __str__(self): return '{type}(topLeft_x={topLeft_x}, topLeft_y={topLeft_y}, topRight_x={topRight_x}, topRight_y={topRight_y}, bottomRight_x={bottomRight_x}, bottomRight_y={bottomRight_y}, bottomLeft_x={bottomLeft_x}, bottomLeft_y={bottomLeft_y}, verified={verified})'.format( type=type(self).__name__, topLeft_x=self._topLeft_x, topLeft_y=self._topLeft_y, topRight_x=self._topRight_x, topRight_y=self._topRight_y, bottomRight_x=self._bottomRight_x, bottomRight_y=self._bottomRight_y, bottomLeft_x=self._bottomLeft_x, bottomLeft_y=self._bottomLeft_y, verified=self._verified) def __repr__(self): return '{type}(topLeft_x={topLeft_x}, topLeft_y={topLeft_y}, topRight_x={topRight_x}, topRight_y={topRight_y}, bottomRight_x={bottomRight_x}, bottomRight_y={bottomRight_y}, bottomLeft_x={bottomLeft_x}, bottomLeft_y={bottomLeft_y}, verified={verified})'.format( type=type(self).__name__, topLeft_x=repr(self._topLeft_x), topLeft_y=repr(self._topLeft_y), topRight_x=repr(self._topRight_x), topRight_y=repr(self._topRight_y), bottomRight_x=repr(self._bottomRight_x), bottomRight_y=repr(self._bottomRight_y), bottomLeft_x=repr(self._bottomLeft_x), bottomLeft_y=repr(self._bottomLeft_y), verified=repr(self._verified)) Anki.Vector.VizInterface.VisionMarker = VisionMarker del VisionMarker class ShowObjects(object): "Generated message-passing message." __slots__ = ( '_show', # int_8 ) @property def show(self): "int_8 show struct property." return self._show @show.setter def show(self, value): self._show = msgbuffers.validate_integer( 'ShowObjects.show', value, -128, 127) def __init__(self, show=0): self.show = show @classmethod def unpack(cls, buffer): "Reads a new ShowObjects from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('ShowObjects.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new ShowObjects from the given BinaryReader." _show = reader.read('b') return cls(_show) def pack(self): "Writes the current ShowObjects, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current ShowObjects to the given BinaryWriter." writer.write(self._show, 'b') def __eq__(self, other): if type(self) is type(other): return self._show == other._show else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._show, 'b')) def __str__(self): return '{type}(show={show})'.format( type=type(self).__name__, show=self._show) def __repr__(self): return '{type}(show={show})'.format( type=type(self).__name__, show=repr(self._show)) Anki.Vector.VizInterface.ShowObjects = ShowObjects del ShowObjects class TrackerQuad(object): "Generated message-passing message." __slots__ = ( '_topLeft_x', # int_16 '_topLeft_y', # int_16 '_topRight_x', # int_16 '_topRight_y', # int_16 '_bottomRight_x', # int_16 '_bottomRight_y', # int_16 '_bottomLeft_x', # int_16 '_bottomLeft_y', # int_16 ) @property def topLeft_x(self): "int_16 topLeft_x struct property." return self._topLeft_x @topLeft_x.setter def topLeft_x(self, value): self._topLeft_x = msgbuffers.validate_integer( 'TrackerQuad.topLeft_x', value, -32768, 32767) @property def topLeft_y(self): "int_16 topLeft_y struct property." return self._topLeft_y @topLeft_y.setter def topLeft_y(self, value): self._topLeft_y = msgbuffers.validate_integer( 'TrackerQuad.topLeft_y', value, -32768, 32767) @property def topRight_x(self): "int_16 topRight_x struct property." return self._topRight_x @topRight_x.setter def topRight_x(self, value): self._topRight_x = msgbuffers.validate_integer( 'TrackerQuad.topRight_x', value, -32768, 32767) @property def topRight_y(self): "int_16 topRight_y struct property." return self._topRight_y @topRight_y.setter def topRight_y(self, value): self._topRight_y = msgbuffers.validate_integer( 'TrackerQuad.topRight_y', value, -32768, 32767) @property def bottomRight_x(self): "int_16 bottomRight_x struct property." return self._bottomRight_x @bottomRight_x.setter def bottomRight_x(self, value): self._bottomRight_x = msgbuffers.validate_integer( 'TrackerQuad.bottomRight_x', value, -32768, 32767) @property def bottomRight_y(self): "int_16 bottomRight_y struct property." return self._bottomRight_y @bottomRight_y.setter def bottomRight_y(self, value): self._bottomRight_y = msgbuffers.validate_integer( 'TrackerQuad.bottomRight_y', value, -32768, 32767) @property def bottomLeft_x(self): "int_16 bottomLeft_x struct property." return self._bottomLeft_x @bottomLeft_x.setter def bottomLeft_x(self, value): self._bottomLeft_x = msgbuffers.validate_integer( 'TrackerQuad.bottomLeft_x', value, -32768, 32767) @property def bottomLeft_y(self): "int_16 bottomLeft_y struct property." return self._bottomLeft_y @bottomLeft_y.setter def bottomLeft_y(self, value): self._bottomLeft_y = msgbuffers.validate_integer( 'TrackerQuad.bottomLeft_y', value, -32768, 32767) def __init__(self, topLeft_x=0, topLeft_y=0, topRight_x=0, topRight_y=0, bottomRight_x=0, bottomRight_y=0, bottomLeft_x=0, bottomLeft_y=0): self.topLeft_x = topLeft_x self.topLeft_y = topLeft_y self.topRight_x = topRight_x self.topRight_y = topRight_y self.bottomRight_x = bottomRight_x self.bottomRight_y = bottomRight_y self.bottomLeft_x = bottomLeft_x self.bottomLeft_y = bottomLeft_y @classmethod def unpack(cls, buffer): "Reads a new TrackerQuad from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('TrackerQuad.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new TrackerQuad from the given BinaryReader." _topLeft_x = reader.read('h') _topLeft_y = reader.read('h') _topRight_x = reader.read('h') _topRight_y = reader.read('h') _bottomRight_x = reader.read('h') _bottomRight_y = reader.read('h') _bottomLeft_x = reader.read('h') _bottomLeft_y = reader.read('h') return cls(_topLeft_x, _topLeft_y, _topRight_x, _topRight_y, _bottomRight_x, _bottomRight_y, _bottomLeft_x, _bottomLeft_y) def pack(self): "Writes the current TrackerQuad, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current TrackerQuad to the given BinaryWriter." writer.write(self._topLeft_x, 'h') writer.write(self._topLeft_y, 'h') writer.write(self._topRight_x, 'h') writer.write(self._topRight_y, 'h') writer.write(self._bottomRight_x, 'h') writer.write(self._bottomRight_y, 'h') writer.write(self._bottomLeft_x, 'h') writer.write(self._bottomLeft_y, 'h') def __eq__(self, other): if type(self) is type(other): return (self._topLeft_x == other._topLeft_x and self._topLeft_y == other._topLeft_y and self._topRight_x == other._topRight_x and self._topRight_y == other._topRight_y and self._bottomRight_x == other._bottomRight_x and self._bottomRight_y == other._bottomRight_y and self._bottomLeft_x == other._bottomLeft_x and self._bottomLeft_y == other._bottomLeft_y) else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._topLeft_x, 'h') + msgbuffers.size(self._topLeft_y, 'h') + msgbuffers.size(self._topRight_x, 'h') + msgbuffers.size(self._topRight_y, 'h') + msgbuffers.size(self._bottomRight_x, 'h') + msgbuffers.size(self._bottomRight_y, 'h') + msgbuffers.size(self._bottomLeft_x, 'h') + msgbuffers.size(self._bottomLeft_y, 'h')) def __str__(self): return '{type}(topLeft_x={topLeft_x}, topLeft_y={topLeft_y}, topRight_x={topRight_x}, topRight_y={topRight_y}, bottomRight_x={bottomRight_x}, bottomRight_y={bottomRight_y}, bottomLeft_x={bottomLeft_x}, bottomLeft_y={bottomLeft_y})'.format( type=type(self).__name__, topLeft_x=self._topLeft_x, topLeft_y=self._topLeft_y, topRight_x=self._topRight_x, topRight_y=self._topRight_y, bottomRight_x=self._bottomRight_x, bottomRight_y=self._bottomRight_y, bottomLeft_x=self._bottomLeft_x, bottomLeft_y=self._bottomLeft_y) def __repr__(self): return '{type}(topLeft_x={topLeft_x}, topLeft_y={topLeft_y}, topRight_x={topRight_x}, topRight_y={topRight_y}, bottomRight_x={bottomRight_x}, bottomRight_y={bottomRight_y}, bottomLeft_x={bottomLeft_x}, bottomLeft_y={bottomLeft_y})'.format( type=type(self).__name__, topLeft_x=repr(self._topLeft_x), topLeft_y=repr(self._topLeft_y), topRight_x=repr(self._topRight_x), topRight_y=repr(self._topRight_y), bottomRight_x=repr(self._bottomRight_x), bottomRight_y=repr(self._bottomRight_y), bottomLeft_x=repr(self._bottomLeft_x), bottomLeft_y=repr(self._bottomLeft_y)) Anki.Vector.VizInterface.TrackerQuad = TrackerQuad del TrackerQuad class FaceDetection(object): "Generated message-passing message." __slots__ = ( '_x_upperLeft', # uint_16 '_y_upperLeft', # uint_16 '_width', # uint_16 '_height', # uint_16 '_visualize', # bool ) @property def x_upperLeft(self): "uint_16 x_upperLeft struct property." return self._x_upperLeft @x_upperLeft.setter def x_upperLeft(self, value): self._x_upperLeft = msgbuffers.validate_integer( 'FaceDetection.x_upperLeft', value, 0, 65535) @property def y_upperLeft(self): "uint_16 y_upperLeft struct property." return self._y_upperLeft @y_upperLeft.setter def y_upperLeft(self, value): self._y_upperLeft = msgbuffers.validate_integer( 'FaceDetection.y_upperLeft', value, 0, 65535) @property def width(self): "uint_16 width struct property." return self._width @width.setter def width(self, value): self._width = msgbuffers.validate_integer( 'FaceDetection.width', value, 0, 65535) @property def height(self): "uint_16 height struct property." return self._height @height.setter def height(self, value): self._height = msgbuffers.validate_integer( 'FaceDetection.height', value, 0, 65535) @property def visualize(self): "bool visualize struct property." return self._visualize @visualize.setter def visualize(self, value): self._visualize = msgbuffers.validate_bool( 'FaceDetection.visualize', value) def __init__(self, x_upperLeft=0, y_upperLeft=0, width=0, height=0, visualize=False): self.x_upperLeft = x_upperLeft self.y_upperLeft = y_upperLeft self.width = width self.height = height self.visualize = visualize @classmethod def unpack(cls, buffer): "Reads a new FaceDetection from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('FaceDetection.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new FaceDetection from the given BinaryReader." _x_upperLeft = reader.read('H') _y_upperLeft = reader.read('H') _width = reader.read('H') _height = reader.read('H') _visualize = bool(reader.read('b')) return cls(_x_upperLeft, _y_upperLeft, _width, _height, _visualize) def pack(self): "Writes the current FaceDetection, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current FaceDetection to the given BinaryWriter." writer.write(self._x_upperLeft, 'H') writer.write(self._y_upperLeft, 'H') writer.write(self._width, 'H') writer.write(self._height, 'H') writer.write(int(self._visualize), 'b') def __eq__(self, other): if type(self) is type(other): return (self._x_upperLeft == other._x_upperLeft and self._y_upperLeft == other._y_upperLeft and self._width == other._width and self._height == other._height and self._visualize == other._visualize) else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._x_upperLeft, 'H') + msgbuffers.size(self._y_upperLeft, 'H') + msgbuffers.size(self._width, 'H') + msgbuffers.size(self._height, 'H') + msgbuffers.size(self._visualize, 'b')) def __str__(self): return '{type}(x_upperLeft={x_upperLeft}, y_upperLeft={y_upperLeft}, width={width}, height={height}, visualize={visualize})'.format( type=type(self).__name__, x_upperLeft=self._x_upperLeft, y_upperLeft=self._y_upperLeft, width=self._width, height=self._height, visualize=self._visualize) def __repr__(self): return '{type}(x_upperLeft={x_upperLeft}, y_upperLeft={y_upperLeft}, width={width}, height={height}, visualize={visualize})'.format( type=type(self).__name__, x_upperLeft=repr(self._x_upperLeft), y_upperLeft=repr(self._y_upperLeft), width=repr(self._width), height=repr(self._height), visualize=repr(self._visualize)) Anki.Vector.VizInterface.FaceDetection = FaceDetection del FaceDetection class BehaviorStackDebug(object): "Generated message-passing message." __slots__ = ( '_debugStrings', # string[uint_8][uint_8] ) @property def debugStrings(self): "string[uint_8][uint_8] debugStrings struct property." return self._debugStrings @debugStrings.setter def debugStrings(self, value): self._debugStrings = msgbuffers.validate_varray( 'BehaviorStackDebug.debugStrings', value, 255, lambda name, value_inner: msgbuffers.validate_string( name, value_inner, 255)) def __init__(self, debugStrings=()): self.debugStrings = debugStrings @classmethod def unpack(cls, buffer): "Reads a new BehaviorStackDebug from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('BehaviorStackDebug.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new BehaviorStackDebug from the given BinaryReader." _debugStrings = reader.read_string_varray('B', 'B') return cls(_debugStrings) def pack(self): "Writes the current BehaviorStackDebug, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current BehaviorStackDebug to the given BinaryWriter." writer.write_string_varray(self._debugStrings, 'B', 'B') def __eq__(self, other): if type(self) is type(other): return self._debugStrings == other._debugStrings else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size_string_varray(self._debugStrings, 'B', 'B')) def __str__(self): return '{type}(debugStrings={debugStrings})'.format( type=type(self).__name__, debugStrings=msgbuffers.shorten_sequence(self._debugStrings, msgbuffers.shorten_string)) def __repr__(self): return '{type}(debugStrings={debugStrings})'.format( type=type(self).__name__, debugStrings=repr(self._debugStrings)) Anki.Vector.VizInterface.BehaviorStackDebug = BehaviorStackDebug del BehaviorStackDebug class VisionModeDebug(object): "Generated message-passing message." __slots__ = ( '_debugStrings', # string[uint_8][uint_8] ) @property def debugStrings(self): "string[uint_8][uint_8] debugStrings struct property." return self._debugStrings @debugStrings.setter def debugStrings(self, value): self._debugStrings = msgbuffers.validate_varray( 'VisionModeDebug.debugStrings', value, 255, lambda name, value_inner: msgbuffers.validate_string( name, value_inner, 255)) def __init__(self, debugStrings=()): self.debugStrings = debugStrings @classmethod def unpack(cls, buffer): "Reads a new VisionModeDebug from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('VisionModeDebug.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new VisionModeDebug from the given BinaryReader." _debugStrings = reader.read_string_varray('B', 'B') return cls(_debugStrings) def pack(self): "Writes the current VisionModeDebug, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current VisionModeDebug to the given BinaryWriter." writer.write_string_varray(self._debugStrings, 'B', 'B') def __eq__(self, other): if type(self) is type(other): return self._debugStrings == other._debugStrings else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size_string_varray(self._debugStrings, 'B', 'B')) def __str__(self): return '{type}(debugStrings={debugStrings})'.format( type=type(self).__name__, debugStrings=msgbuffers.shorten_sequence(self._debugStrings, msgbuffers.shorten_string)) def __repr__(self): return '{type}(debugStrings={debugStrings})'.format( type=type(self).__name__, debugStrings=repr(self._debugStrings)) Anki.Vector.VizInterface.VisionModeDebug = VisionModeDebug del VisionModeDebug class SaveImages(object): "Generated message-passing message." __slots__ = ( '_mode', # Anki.Vector.ImageSendMode '_path', # string[uint_8] ) @property def mode(self): "Anki.Vector.ImageSendMode mode struct property." return self._mode @mode.setter def mode(self, value): self._mode = msgbuffers.validate_integer( 'SaveImages.mode', value, 0, 255) @property def path(self): "string[uint_8] path struct property." return self._path @path.setter def path(self, value): self._path = msgbuffers.validate_string( 'SaveImages.path', value, 255) def __init__(self, mode=Anki.Vector.ImageSendMode.Off, path=''): self.mode = mode self.path = path @classmethod def unpack(cls, buffer): "Reads a new SaveImages from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('SaveImages.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new SaveImages from the given BinaryReader." _mode = reader.read('B') _path = reader.read_string('B') return cls(_mode, _path) def pack(self): "Writes the current SaveImages, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current SaveImages to the given BinaryWriter." writer.write(self._mode, 'B') writer.write_string(self._path, 'B') def __eq__(self, other): if type(self) is type(other): return (self._mode == other._mode and self._path == other._path) else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._mode, 'B') + msgbuffers.size_string(self._path, 'B')) def __str__(self): return '{type}(mode={mode}, path={path})'.format( type=type(self).__name__, mode=self._mode, path=msgbuffers.shorten_string(self._path)) def __repr__(self): return '{type}(mode={mode}, path={path})'.format( type=type(self).__name__, mode=repr(self._mode), path=repr(self._path)) Anki.Vector.VizInterface.SaveImages = SaveImages del SaveImages class SaveState(object): "Generated message-passing message." __slots__ = ( '_enabled', # bool '_path', # string[uint_8] ) @property def enabled(self): "bool enabled struct property." return self._enabled @enabled.setter def enabled(self, value): self._enabled = msgbuffers.validate_bool( 'SaveState.enabled', value) @property def path(self): "string[uint_8] path struct property." return self._path @path.setter def path(self, value): self._path = msgbuffers.validate_string( 'SaveState.path', value, 255) def __init__(self, enabled=False, path=''): self.enabled = enabled self.path = path @classmethod def unpack(cls, buffer): "Reads a new SaveState from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('SaveState.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new SaveState from the given BinaryReader." _enabled = bool(reader.read('b')) _path = reader.read_string('B') return cls(_enabled, _path) def pack(self): "Writes the current SaveState, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current SaveState to the given BinaryWriter." writer.write(int(self._enabled), 'b') writer.write_string(self._path, 'B') def __eq__(self, other): if type(self) is type(other): return (self._enabled == other._enabled and self._path == other._path) else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._enabled, 'b') + msgbuffers.size_string(self._path, 'B')) def __str__(self): return '{type}(enabled={enabled}, path={path})'.format( type=type(self).__name__, enabled=self._enabled, path=msgbuffers.shorten_string(self._path)) def __repr__(self): return '{type}(enabled={enabled}, path={path})'.format( type=type(self).__name__, enabled=repr(self._enabled), path=repr(self._path)) Anki.Vector.VizInterface.SaveState = SaveState del SaveState class MessageViz(object): "Generated message-passing union." __slots__ = ('_tag', '_data') class Tag(object): "The type indicator for this union." ReportCloudConnectivity = 0 # Anki.Vector.ReportCloudConnectivity StartShutdownAnim = 1 # Anki.Vector.StartShutdownAnim AnimationState = 2 # Anki.Vector.AnimationState AnimationAdded = 3 # Anki.Vector.AnimationAdded AnimationStarted = 4 # Anki.Vector.AnimationStarted AnimationEnded = 5 # Anki.Vector.AnimationEnded AnimationEvent = 6 # Anki.Vector.AnimationEvent TextToSpeechEvent = 7 # Anki.Vector.TextToSpeechEvent StreamCameraImages = 8 # Anki.Vector.StreamCameraImages DebugScreenMode = 9 # Anki.Vector.DebugScreenMode RobotAvailable = 10 # Anki.Vector.RobotAvailable AudioStreamStatusEvent = 11 # Anki.Vector.AudioStreamStatusEvent IMURequest = 12 # Anki.Vector.IMURequest IMUTemperature = 13 # Anki.Vector.RobotInterface.IMUTemperature CliffEvent = 14 # Anki.Vector.CliffEvent PotentialCliff = 15 # Anki.Vector.PotentialCliff SetCliffDetectThresholds = 16 # Anki.Vector.SetCliffDetectThresholds SetWhiteDetectThresholds = 17 # Anki.Vector.SetWhiteDetectThresholds CarryStateUpdate = 18 # Anki.Vector.CarryStateUpdate ImageChunk = 19 # Anki.Vector.ImageChunk CameraCalibration = 20 # Anki.Vector.CameraCalibration SetVizOrigin = 21 # Anki.Vector.SetVizOrigin RobotStateMessage = 22 # Anki.Vector.VizInterface.RobotStateMessage CurrentAnimation = 23 # Anki.Vector.VizInterface.CurrentAnimation Object = 24 # Anki.Vector.VizInterface.Object LineSegment = 25 # Anki.Vector.VizInterface.LineSegment Quad = 26 # Anki.Vector.VizInterface.Quad MemoryMapMessageVizBegin = 27 # Anki.Vector.VizInterface.MemoryMapMessageVizBegin MemoryMapMessageViz = 28 # Anki.Vector.VizInterface.MemoryMapMessageViz MemoryMapMessageVizEnd = 29 # Anki.Vector.VizInterface.MemoryMapMessageVizEnd EnabledVisionModes = 30 # Anki.Vector.VizInterface.EnabledVisionModes CameraQuad = 31 # Anki.Vector.VizInterface.CameraQuad CameraRect = 32 # Anki.Vector.VizInterface.CameraRect CameraLine = 33 # Anki.Vector.VizInterface.CameraLine CameraOval = 34 # Anki.Vector.VizInterface.CameraOval CameraText = 35 # Anki.Vector.VizInterface.CameraText EraseObject = 36 # Anki.Vector.VizInterface.EraseObject EraseLineSegments = 37 # Anki.Vector.VizInterface.EraseLineSegments EraseQuad = 38 # Anki.Vector.VizInterface.EraseQuad SetRobot = 39 # Anki.Vector.VizInterface.SetRobot AppendPathSegmentLine = 40 # Anki.Vector.VizInterface.AppendPathSegmentLine AppendPathSegmentArc = 41 # Anki.Vector.VizInterface.AppendPathSegmentArc SetPathColor = 42 # Anki.Vector.VizInterface.SetPathColor ErasePath = 43 # Anki.Vector.VizInterface.ErasePath SetLabel = 44 # Anki.Vector.VizInterface.SetLabel DockingErrorSignal = 45 # Anki.Vector.VizInterface.DockingErrorSignal CameraParams = 46 # Anki.Vector.VizInterface.CameraParams VisionMarker = 47 # Anki.Vector.VizInterface.VisionMarker ShowObjects = 48 # Anki.Vector.VizInterface.ShowObjects TrackerQuad = 49 # Anki.Vector.VizInterface.TrackerQuad FaceDetection = 50 # Anki.Vector.VizInterface.FaceDetection BehaviorStackDebug = 51 # Anki.Vector.VizInterface.BehaviorStackDebug VisionModeDebug = 52 # Anki.Vector.VizInterface.VisionModeDebug SaveImages = 53 # Anki.Vector.VizInterface.SaveImages SaveState = 54 # Anki.Vector.VizInterface.SaveState @property def tag(self): "The current tag for this union." return self._tag @property def tag_name(self): "The name of the current tag for this union." if self._tag in self._tags_by_value: return self._tags_by_value[self._tag] else: return None @property def data(self): "The data held by this union. None if no data is set." return self._data @property def ReportCloudConnectivity(self): "Anki.Vector.ReportCloudConnectivity ReportCloudConnectivity union property." msgbuffers.safety_check_tag('ReportCloudConnectivity', self._tag, self.Tag.ReportCloudConnectivity, self._tags_by_value) return self._data @ReportCloudConnectivity.setter def ReportCloudConnectivity(self, value): self._data = msgbuffers.validate_object( 'MessageViz.ReportCloudConnectivity', value, Anki.Vector.ReportCloudConnectivity) self._tag = self.Tag.ReportCloudConnectivity @property def StartShutdownAnim(self): "Anki.Vector.StartShutdownAnim StartShutdownAnim union property." msgbuffers.safety_check_tag('StartShutdownAnim', self._tag, self.Tag.StartShutdownAnim, self._tags_by_value) return self._data @StartShutdownAnim.setter def StartShutdownAnim(self, value): self._data = msgbuffers.validate_object( 'MessageViz.StartShutdownAnim', value, Anki.Vector.StartShutdownAnim) self._tag = self.Tag.StartShutdownAnim @property def AnimationState(self): "Anki.Vector.AnimationState AnimationState union property." msgbuffers.safety_check_tag('AnimationState', self._tag, self.Tag.AnimationState, self._tags_by_value) return self._data @AnimationState.setter def AnimationState(self, value): self._data = msgbuffers.validate_object( 'MessageViz.AnimationState', value, Anki.Vector.AnimationState) self._tag = self.Tag.AnimationState @property def AnimationAdded(self): "Anki.Vector.AnimationAdded AnimationAdded union property." msgbuffers.safety_check_tag('AnimationAdded', self._tag, self.Tag.AnimationAdded, self._tags_by_value) return self._data @AnimationAdded.setter def AnimationAdded(self, value): self._data = msgbuffers.validate_object( 'MessageViz.AnimationAdded', value, Anki.Vector.AnimationAdded) self._tag = self.Tag.AnimationAdded @property def AnimationStarted(self): "Anki.Vector.AnimationStarted AnimationStarted union property." msgbuffers.safety_check_tag('AnimationStarted', self._tag, self.Tag.AnimationStarted, self._tags_by_value) return self._data @AnimationStarted.setter def AnimationStarted(self, value): self._data = msgbuffers.validate_object( 'MessageViz.AnimationStarted', value, Anki.Vector.AnimationStarted) self._tag = self.Tag.AnimationStarted @property def AnimationEnded(self): "Anki.Vector.AnimationEnded AnimationEnded union property." msgbuffers.safety_check_tag('AnimationEnded', self._tag, self.Tag.AnimationEnded, self._tags_by_value) return self._data @AnimationEnded.setter def AnimationEnded(self, value): self._data = msgbuffers.validate_object( 'MessageViz.AnimationEnded', value, Anki.Vector.AnimationEnded) self._tag = self.Tag.AnimationEnded @property def AnimationEvent(self): "Anki.Vector.AnimationEvent AnimationEvent union property." msgbuffers.safety_check_tag('AnimationEvent', self._tag, self.Tag.AnimationEvent, self._tags_by_value) return self._data @AnimationEvent.setter def AnimationEvent(self, value): self._data = msgbuffers.validate_object( 'MessageViz.AnimationEvent', value, Anki.Vector.AnimationEvent) self._tag = self.Tag.AnimationEvent @property def TextToSpeechEvent(self): "Anki.Vector.TextToSpeechEvent TextToSpeechEvent union property." msgbuffers.safety_check_tag('TextToSpeechEvent', self._tag, self.Tag.TextToSpeechEvent, self._tags_by_value) return self._data @TextToSpeechEvent.setter def TextToSpeechEvent(self, value): self._data = msgbuffers.validate_object( 'MessageViz.TextToSpeechEvent', value, Anki.Vector.TextToSpeechEvent) self._tag = self.Tag.TextToSpeechEvent @property def StreamCameraImages(self): "Anki.Vector.StreamCameraImages StreamCameraImages union property." msgbuffers.safety_check_tag('StreamCameraImages', self._tag, self.Tag.StreamCameraImages, self._tags_by_value) return self._data @StreamCameraImages.setter def StreamCameraImages(self, value): self._data = msgbuffers.validate_object( 'MessageViz.StreamCameraImages', value, Anki.Vector.StreamCameraImages) self._tag = self.Tag.StreamCameraImages @property def DebugScreenMode(self): "Anki.Vector.DebugScreenMode DebugScreenMode union property." msgbuffers.safety_check_tag('DebugScreenMode', self._tag, self.Tag.DebugScreenMode, self._tags_by_value) return self._data @DebugScreenMode.setter def DebugScreenMode(self, value): self._data = msgbuffers.validate_object( 'MessageViz.DebugScreenMode', value, Anki.Vector.DebugScreenMode) self._tag = self.Tag.DebugScreenMode @property def RobotAvailable(self): "Anki.Vector.RobotAvailable RobotAvailable union property." msgbuffers.safety_check_tag('RobotAvailable', self._tag, self.Tag.RobotAvailable, self._tags_by_value) return self._data @RobotAvailable.setter def RobotAvailable(self, value): self._data = msgbuffers.validate_object( 'MessageViz.RobotAvailable', value, Anki.Vector.RobotAvailable) self._tag = self.Tag.RobotAvailable @property def AudioStreamStatusEvent(self): "Anki.Vector.AudioStreamStatusEvent AudioStreamStatusEvent union property." msgbuffers.safety_check_tag('AudioStreamStatusEvent', self._tag, self.Tag.AudioStreamStatusEvent, self._tags_by_value) return self._data @AudioStreamStatusEvent.setter def AudioStreamStatusEvent(self, value): self._data = msgbuffers.validate_object( 'MessageViz.AudioStreamStatusEvent', value, Anki.Vector.AudioStreamStatusEvent) self._tag = self.Tag.AudioStreamStatusEvent @property def IMURequest(self): "Anki.Vector.IMURequest IMURequest union property." msgbuffers.safety_check_tag('IMURequest', self._tag, self.Tag.IMURequest, self._tags_by_value) return self._data @IMURequest.setter def IMURequest(self, value): self._data = msgbuffers.validate_object( 'MessageViz.IMURequest', value, Anki.Vector.IMURequest) self._tag = self.Tag.IMURequest @property def IMUTemperature(self): "Anki.Vector.RobotInterface.IMUTemperature IMUTemperature union property." msgbuffers.safety_check_tag('IMUTemperature', self._tag, self.Tag.IMUTemperature, self._tags_by_value) return self._data @IMUTemperature.setter def IMUTemperature(self, value): self._data = msgbuffers.validate_object( 'MessageViz.IMUTemperature', value, Anki.Vector.RobotInterface.IMUTemperature) self._tag = self.Tag.IMUTemperature @property def CliffEvent(self): "Anki.Vector.CliffEvent CliffEvent union property." msgbuffers.safety_check_tag('CliffEvent', self._tag, self.Tag.CliffEvent, self._tags_by_value) return self._data @CliffEvent.setter def CliffEvent(self, value): self._data = msgbuffers.validate_object( 'MessageViz.CliffEvent', value, Anki.Vector.CliffEvent) self._tag = self.Tag.CliffEvent @property def PotentialCliff(self): "Anki.Vector.PotentialCliff PotentialCliff union property." msgbuffers.safety_check_tag('PotentialCliff', self._tag, self.Tag.PotentialCliff, self._tags_by_value) return self._data @PotentialCliff.setter def PotentialCliff(self, value): self._data = msgbuffers.validate_object( 'MessageViz.PotentialCliff', value, Anki.Vector.PotentialCliff) self._tag = self.Tag.PotentialCliff @property def SetCliffDetectThresholds(self): "Anki.Vector.SetCliffDetectThresholds SetCliffDetectThresholds union property." msgbuffers.safety_check_tag('SetCliffDetectThresholds', self._tag, self.Tag.SetCliffDetectThresholds, self._tags_by_value) return self._data @SetCliffDetectThresholds.setter def SetCliffDetectThresholds(self, value): self._data = msgbuffers.validate_object( 'MessageViz.SetCliffDetectThresholds', value, Anki.Vector.SetCliffDetectThresholds) self._tag = self.Tag.SetCliffDetectThresholds @property def SetWhiteDetectThresholds(self): "Anki.Vector.SetWhiteDetectThresholds SetWhiteDetectThresholds union property." msgbuffers.safety_check_tag('SetWhiteDetectThresholds', self._tag, self.Tag.SetWhiteDetectThresholds, self._tags_by_value) return self._data @SetWhiteDetectThresholds.setter def SetWhiteDetectThresholds(self, value): self._data = msgbuffers.validate_object( 'MessageViz.SetWhiteDetectThresholds', value, Anki.Vector.SetWhiteDetectThresholds) self._tag = self.Tag.SetWhiteDetectThresholds @property def CarryStateUpdate(self): "Anki.Vector.CarryStateUpdate CarryStateUpdate union property." msgbuffers.safety_check_tag('CarryStateUpdate', self._tag, self.Tag.CarryStateUpdate, self._tags_by_value) return self._data @CarryStateUpdate.setter def CarryStateUpdate(self, value): self._data = msgbuffers.validate_object( 'MessageViz.CarryStateUpdate', value, Anki.Vector.CarryStateUpdate) self._tag = self.Tag.CarryStateUpdate @property def ImageChunk(self): "Anki.Vector.ImageChunk ImageChunk union property." msgbuffers.safety_check_tag('ImageChunk', self._tag, self.Tag.ImageChunk, self._tags_by_value) return self._data @ImageChunk.setter def ImageChunk(self, value): self._data = msgbuffers.validate_object( 'MessageViz.ImageChunk', value, Anki.Vector.ImageChunk) self._tag = self.Tag.ImageChunk @property def CameraCalibration(self): "Anki.Vector.CameraCalibration CameraCalibration union property." msgbuffers.safety_check_tag('CameraCalibration', self._tag, self.Tag.CameraCalibration, self._tags_by_value) return self._data @CameraCalibration.setter def CameraCalibration(self, value): self._data = msgbuffers.validate_object( 'MessageViz.CameraCalibration', value, Anki.Vector.CameraCalibration) self._tag = self.Tag.CameraCalibration @property def SetVizOrigin(self): "Anki.Vector.SetVizOrigin SetVizOrigin union property." msgbuffers.safety_check_tag('SetVizOrigin', self._tag, self.Tag.SetVizOrigin, self._tags_by_value) return self._data @SetVizOrigin.setter def SetVizOrigin(self, value): self._data = msgbuffers.validate_object( 'MessageViz.SetVizOrigin', value, Anki.Vector.SetVizOrigin) self._tag = self.Tag.SetVizOrigin @property def RobotStateMessage(self): "Anki.Vector.VizInterface.RobotStateMessage RobotStateMessage union property." msgbuffers.safety_check_tag('RobotStateMessage', self._tag, self.Tag.RobotStateMessage, self._tags_by_value) return self._data @RobotStateMessage.setter def RobotStateMessage(self, value): self._data = msgbuffers.validate_object( 'MessageViz.RobotStateMessage', value, Anki.Vector.VizInterface.RobotStateMessage) self._tag = self.Tag.RobotStateMessage @property def CurrentAnimation(self): "Anki.Vector.VizInterface.CurrentAnimation CurrentAnimation union property." msgbuffers.safety_check_tag('CurrentAnimation', self._tag, self.Tag.CurrentAnimation, self._tags_by_value) return self._data @CurrentAnimation.setter def CurrentAnimation(self, value): self._data = msgbuffers.validate_object( 'MessageViz.CurrentAnimation', value, Anki.Vector.VizInterface.CurrentAnimation) self._tag = self.Tag.CurrentAnimation @property def Object(self): "Anki.Vector.VizInterface.Object Object union property." msgbuffers.safety_check_tag('Object', self._tag, self.Tag.Object, self._tags_by_value) return self._data @Object.setter def Object(self, value): self._data = msgbuffers.validate_object( 'MessageViz.Object', value, Anki.Vector.VizInterface.Object) self._tag = self.Tag.Object @property def LineSegment(self): "Anki.Vector.VizInterface.LineSegment LineSegment union property." msgbuffers.safety_check_tag('LineSegment', self._tag, self.Tag.LineSegment, self._tags_by_value) return self._data @LineSegment.setter def LineSegment(self, value): self._data = msgbuffers.validate_object( 'MessageViz.LineSegment', value, Anki.Vector.VizInterface.LineSegment) self._tag = self.Tag.LineSegment @property def Quad(self): "Anki.Vector.VizInterface.Quad Quad union property." msgbuffers.safety_check_tag('Quad', self._tag, self.Tag.Quad, self._tags_by_value) return self._data @Quad.setter def Quad(self, value): self._data = msgbuffers.validate_object( 'MessageViz.Quad', value, Anki.Vector.VizInterface.Quad) self._tag = self.Tag.Quad @property def MemoryMapMessageVizBegin(self): "Anki.Vector.VizInterface.MemoryMapMessageVizBegin MemoryMapMessageVizBegin union property." msgbuffers.safety_check_tag('MemoryMapMessageVizBegin', self._tag, self.Tag.MemoryMapMessageVizBegin, self._tags_by_value) return self._data @MemoryMapMessageVizBegin.setter def MemoryMapMessageVizBegin(self, value): self._data = msgbuffers.validate_object( 'MessageViz.MemoryMapMessageVizBegin', value, Anki.Vector.VizInterface.MemoryMapMessageVizBegin) self._tag = self.Tag.MemoryMapMessageVizBegin @property def MemoryMapMessageViz(self): "Anki.Vector.VizInterface.MemoryMapMessageViz MemoryMapMessageViz union property." msgbuffers.safety_check_tag('MemoryMapMessageViz', self._tag, self.Tag.MemoryMapMessageViz, self._tags_by_value) return self._data @MemoryMapMessageViz.setter def MemoryMapMessageViz(self, value): self._data = msgbuffers.validate_object( 'MessageViz.MemoryMapMessageViz', value, Anki.Vector.VizInterface.MemoryMapMessageViz) self._tag = self.Tag.MemoryMapMessageViz @property def MemoryMapMessageVizEnd(self): "Anki.Vector.VizInterface.MemoryMapMessageVizEnd MemoryMapMessageVizEnd union property." msgbuffers.safety_check_tag('MemoryMapMessageVizEnd', self._tag, self.Tag.MemoryMapMessageVizEnd, self._tags_by_value) return self._data @MemoryMapMessageVizEnd.setter def MemoryMapMessageVizEnd(self, value): self._data = msgbuffers.validate_object( 'MessageViz.MemoryMapMessageVizEnd', value, Anki.Vector.VizInterface.MemoryMapMessageVizEnd) self._tag = self.Tag.MemoryMapMessageVizEnd @property def EnabledVisionModes(self): "Anki.Vector.VizInterface.EnabledVisionModes EnabledVisionModes union property." msgbuffers.safety_check_tag('EnabledVisionModes', self._tag, self.Tag.EnabledVisionModes, self._tags_by_value) return self._data @EnabledVisionModes.setter def EnabledVisionModes(self, value): self._data = msgbuffers.validate_object( 'MessageViz.EnabledVisionModes', value, Anki.Vector.VizInterface.EnabledVisionModes) self._tag = self.Tag.EnabledVisionModes @property def CameraQuad(self): "Anki.Vector.VizInterface.CameraQuad CameraQuad union property." msgbuffers.safety_check_tag('CameraQuad', self._tag, self.Tag.CameraQuad, self._tags_by_value) return self._data @CameraQuad.setter def CameraQuad(self, value): self._data = msgbuffers.validate_object( 'MessageViz.CameraQuad', value, Anki.Vector.VizInterface.CameraQuad) self._tag = self.Tag.CameraQuad @property def CameraRect(self): "Anki.Vector.VizInterface.CameraRect CameraRect union property." msgbuffers.safety_check_tag('CameraRect', self._tag, self.Tag.CameraRect, self._tags_by_value) return self._data @CameraRect.setter def CameraRect(self, value): self._data = msgbuffers.validate_object( 'MessageViz.CameraRect', value, Anki.Vector.VizInterface.CameraRect) self._tag = self.Tag.CameraRect @property def CameraLine(self): "Anki.Vector.VizInterface.CameraLine CameraLine union property." msgbuffers.safety_check_tag('CameraLine', self._tag, self.Tag.CameraLine, self._tags_by_value) return self._data @CameraLine.setter def CameraLine(self, value): self._data = msgbuffers.validate_object( 'MessageViz.CameraLine', value, Anki.Vector.VizInterface.CameraLine) self._tag = self.Tag.CameraLine @property def CameraOval(self): "Anki.Vector.VizInterface.CameraOval CameraOval union property." msgbuffers.safety_check_tag('CameraOval', self._tag, self.Tag.CameraOval, self._tags_by_value) return self._data @CameraOval.setter def CameraOval(self, value): self._data = msgbuffers.validate_object( 'MessageViz.CameraOval', value, Anki.Vector.VizInterface.CameraOval) self._tag = self.Tag.CameraOval @property def CameraText(self): "Anki.Vector.VizInterface.CameraText CameraText union property." msgbuffers.safety_check_tag('CameraText', self._tag, self.Tag.CameraText, self._tags_by_value) return self._data @CameraText.setter def CameraText(self, value): self._data = msgbuffers.validate_object( 'MessageViz.CameraText', value, Anki.Vector.VizInterface.CameraText) self._tag = self.Tag.CameraText @property def EraseObject(self): "Anki.Vector.VizInterface.EraseObject EraseObject union property." msgbuffers.safety_check_tag('EraseObject', self._tag, self.Tag.EraseObject, self._tags_by_value) return self._data @EraseObject.setter def EraseObject(self, value): self._data = msgbuffers.validate_object( 'MessageViz.EraseObject', value, Anki.Vector.VizInterface.EraseObject) self._tag = self.Tag.EraseObject @property def EraseLineSegments(self): "Anki.Vector.VizInterface.EraseLineSegments EraseLineSegments union property." msgbuffers.safety_check_tag('EraseLineSegments', self._tag, self.Tag.EraseLineSegments, self._tags_by_value) return self._data @EraseLineSegments.setter def EraseLineSegments(self, value): self._data = msgbuffers.validate_object( 'MessageViz.EraseLineSegments', value, Anki.Vector.VizInterface.EraseLineSegments) self._tag = self.Tag.EraseLineSegments @property def EraseQuad(self): "Anki.Vector.VizInterface.EraseQuad EraseQuad union property." msgbuffers.safety_check_tag('EraseQuad', self._tag, self.Tag.EraseQuad, self._tags_by_value) return self._data @EraseQuad.setter def EraseQuad(self, value): self._data = msgbuffers.validate_object( 'MessageViz.EraseQuad', value, Anki.Vector.VizInterface.EraseQuad) self._tag = self.Tag.EraseQuad @property def SetRobot(self): "Anki.Vector.VizInterface.SetRobot SetRobot union property." msgbuffers.safety_check_tag('SetRobot', self._tag, self.Tag.SetRobot, self._tags_by_value) return self._data @SetRobot.setter def SetRobot(self, value): self._data = msgbuffers.validate_object( 'MessageViz.SetRobot', value, Anki.Vector.VizInterface.SetRobot) self._tag = self.Tag.SetRobot @property def AppendPathSegmentLine(self): "Anki.Vector.VizInterface.AppendPathSegmentLine AppendPathSegmentLine union property." msgbuffers.safety_check_tag('AppendPathSegmentLine', self._tag, self.Tag.AppendPathSegmentLine, self._tags_by_value) return self._data @AppendPathSegmentLine.setter def AppendPathSegmentLine(self, value): self._data = msgbuffers.validate_object( 'MessageViz.AppendPathSegmentLine', value, Anki.Vector.VizInterface.AppendPathSegmentLine) self._tag = self.Tag.AppendPathSegmentLine @property def AppendPathSegmentArc(self): "Anki.Vector.VizInterface.AppendPathSegmentArc AppendPathSegmentArc union property." msgbuffers.safety_check_tag('AppendPathSegmentArc', self._tag, self.Tag.AppendPathSegmentArc, self._tags_by_value) return self._data @AppendPathSegmentArc.setter def AppendPathSegmentArc(self, value): self._data = msgbuffers.validate_object( 'MessageViz.AppendPathSegmentArc', value, Anki.Vector.VizInterface.AppendPathSegmentArc) self._tag = self.Tag.AppendPathSegmentArc @property def SetPathColor(self): "Anki.Vector.VizInterface.SetPathColor SetPathColor union property." msgbuffers.safety_check_tag('SetPathColor', self._tag, self.Tag.SetPathColor, self._tags_by_value) return self._data @SetPathColor.setter def SetPathColor(self, value): self._data = msgbuffers.validate_object( 'MessageViz.SetPathColor', value, Anki.Vector.VizInterface.SetPathColor) self._tag = self.Tag.SetPathColor @property def ErasePath(self): "Anki.Vector.VizInterface.ErasePath ErasePath union property." msgbuffers.safety_check_tag('ErasePath', self._tag, self.Tag.ErasePath, self._tags_by_value) return self._data @ErasePath.setter def ErasePath(self, value): self._data = msgbuffers.validate_object( 'MessageViz.ErasePath', value, Anki.Vector.VizInterface.ErasePath) self._tag = self.Tag.ErasePath @property def SetLabel(self): "Anki.Vector.VizInterface.SetLabel SetLabel union property." msgbuffers.safety_check_tag('SetLabel', self._tag, self.Tag.SetLabel, self._tags_by_value) return self._data @SetLabel.setter def SetLabel(self, value): self._data = msgbuffers.validate_object( 'MessageViz.SetLabel', value, Anki.Vector.VizInterface.SetLabel) self._tag = self.Tag.SetLabel @property def DockingErrorSignal(self): "Anki.Vector.VizInterface.DockingErrorSignal DockingErrorSignal union property." msgbuffers.safety_check_tag('DockingErrorSignal', self._tag, self.Tag.DockingErrorSignal, self._tags_by_value) return self._data @DockingErrorSignal.setter def DockingErrorSignal(self, value): self._data = msgbuffers.validate_object( 'MessageViz.DockingErrorSignal', value, Anki.Vector.VizInterface.DockingErrorSignal) self._tag = self.Tag.DockingErrorSignal @property def CameraParams(self): "Anki.Vector.VizInterface.CameraParams CameraParams union property." msgbuffers.safety_check_tag('CameraParams', self._tag, self.Tag.CameraParams, self._tags_by_value) return self._data @CameraParams.setter def CameraParams(self, value): self._data = msgbuffers.validate_object( 'MessageViz.CameraParams', value, Anki.Vector.VizInterface.CameraParams) self._tag = self.Tag.CameraParams @property def VisionMarker(self): "Anki.Vector.VizInterface.VisionMarker VisionMarker union property." msgbuffers.safety_check_tag('VisionMarker', self._tag, self.Tag.VisionMarker, self._tags_by_value) return self._data @VisionMarker.setter def VisionMarker(self, value): self._data = msgbuffers.validate_object( 'MessageViz.VisionMarker', value, Anki.Vector.VizInterface.VisionMarker) self._tag = self.Tag.VisionMarker @property def ShowObjects(self): "Anki.Vector.VizInterface.ShowObjects ShowObjects union property." msgbuffers.safety_check_tag('ShowObjects', self._tag, self.Tag.ShowObjects, self._tags_by_value) return self._data @ShowObjects.setter def ShowObjects(self, value): self._data = msgbuffers.validate_object( 'MessageViz.ShowObjects', value, Anki.Vector.VizInterface.ShowObjects) self._tag = self.Tag.ShowObjects @property def TrackerQuad(self): "Anki.Vector.VizInterface.TrackerQuad TrackerQuad union property." msgbuffers.safety_check_tag('TrackerQuad', self._tag, self.Tag.TrackerQuad, self._tags_by_value) return self._data @TrackerQuad.setter def TrackerQuad(self, value): self._data = msgbuffers.validate_object( 'MessageViz.TrackerQuad', value, Anki.Vector.VizInterface.TrackerQuad) self._tag = self.Tag.TrackerQuad @property def FaceDetection(self): "Anki.Vector.VizInterface.FaceDetection FaceDetection union property." msgbuffers.safety_check_tag('FaceDetection', self._tag, self.Tag.FaceDetection, self._tags_by_value) return self._data @FaceDetection.setter def FaceDetection(self, value): self._data = msgbuffers.validate_object( 'MessageViz.FaceDetection', value, Anki.Vector.VizInterface.FaceDetection) self._tag = self.Tag.FaceDetection @property def BehaviorStackDebug(self): "Anki.Vector.VizInterface.BehaviorStackDebug BehaviorStackDebug union property." msgbuffers.safety_check_tag('BehaviorStackDebug', self._tag, self.Tag.BehaviorStackDebug, self._tags_by_value) return self._data @BehaviorStackDebug.setter def BehaviorStackDebug(self, value): self._data = msgbuffers.validate_object( 'MessageViz.BehaviorStackDebug', value, Anki.Vector.VizInterface.BehaviorStackDebug) self._tag = self.Tag.BehaviorStackDebug @property def VisionModeDebug(self): "Anki.Vector.VizInterface.VisionModeDebug VisionModeDebug union property." msgbuffers.safety_check_tag('VisionModeDebug', self._tag, self.Tag.VisionModeDebug, self._tags_by_value) return self._data @VisionModeDebug.setter def VisionModeDebug(self, value): self._data = msgbuffers.validate_object( 'MessageViz.VisionModeDebug', value, Anki.Vector.VizInterface.VisionModeDebug) self._tag = self.Tag.VisionModeDebug @property def SaveImages(self): "Anki.Vector.VizInterface.SaveImages SaveImages union property." msgbuffers.safety_check_tag('SaveImages', self._tag, self.Tag.SaveImages, self._tags_by_value) return self._data @SaveImages.setter def SaveImages(self, value): self._data = msgbuffers.validate_object( 'MessageViz.SaveImages', value, Anki.Vector.VizInterface.SaveImages) self._tag = self.Tag.SaveImages @property def SaveState(self): "Anki.Vector.VizInterface.SaveState SaveState union property." msgbuffers.safety_check_tag('SaveState', self._tag, self.Tag.SaveState, self._tags_by_value) return self._data @SaveState.setter def SaveState(self, value): self._data = msgbuffers.validate_object( 'MessageViz.SaveState', value, Anki.Vector.VizInterface.SaveState) self._tag = self.Tag.SaveState def __init__(self, **kwargs): if not kwargs: self._tag = None self._data = None elif len(kwargs) == 1: key, value = next(iter(kwargs.items())) if key not in self._tags_by_name: raise TypeError("'{argument}' is an invalid keyword argument for this method.".format(argument=key)) # calls the correct property setattr(self, key, value) else: raise TypeError('This method only accepts up to one keyword argument.') @classmethod def unpack(cls, buffer): "Reads a new MessageViz from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('MessageViz.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new MessageViz from the given BinaryReader." tag = reader.read('B') if tag in cls._tags_by_value: value = cls() setattr(value, cls._tags_by_value[tag], cls._tag_unpack_methods[tag](reader)) return value else: raise ValueError('MessageViz attempted to unpack unknown tag {tag}.'.format(tag=tag)) def pack(self): "Writes the current MessageViz, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current SampleUnion to the given BinaryWriter." if self._tag in self._tags_by_value: writer.write(self._tag, 'B') self._tag_pack_methods[self._tag](writer, self._data) else: raise ValueError('Cannot pack an empty MessageViz.') def clear(self): self._tag = None self._data = None @classmethod def typeByTag(cls, tag): return cls._type_by_tag_value[tag]() def __eq__(self, other): if type(self) is type(other): return self._tag == other._tag and self._data == other._data else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): if 0 <= self._tag < 55: return self._tag_size_methods[self._tag](self._data) else: return 1 def __str__(self): if 0 <= self._tag < 55: return '{type}({name}={value})'.format( type=type(self).__name__, name=self.tag_name, value=self._data) else: return '{type}()'.format( type=type(self).__name__) def __repr__(self): if 0 <= self._tag < 55: return '{type}({name}={value})'.format( type=type(self).__name__, name=self.tag_name, value=repr(self._data)) else: return '{type}()'.format( type=type(self).__name__) _tags_by_name = dict( ReportCloudConnectivity=0, StartShutdownAnim=1, AnimationState=2, AnimationAdded=3, AnimationStarted=4, AnimationEnded=5, AnimationEvent=6, TextToSpeechEvent=7, StreamCameraImages=8, DebugScreenMode=9, RobotAvailable=10, AudioStreamStatusEvent=11, IMURequest=12, IMUTemperature=13, CliffEvent=14, PotentialCliff=15, SetCliffDetectThresholds=16, SetWhiteDetectThresholds=17, CarryStateUpdate=18, ImageChunk=19, CameraCalibration=20, SetVizOrigin=21, RobotStateMessage=22, CurrentAnimation=23, Object=24, LineSegment=25, Quad=26, MemoryMapMessageVizBegin=27, MemoryMapMessageViz=28, MemoryMapMessageVizEnd=29, EnabledVisionModes=30, CameraQuad=31, CameraRect=32, CameraLine=33, CameraOval=34, CameraText=35, EraseObject=36, EraseLineSegments=37, EraseQuad=38, SetRobot=39, AppendPathSegmentLine=40, AppendPathSegmentArc=41, SetPathColor=42, ErasePath=43, SetLabel=44, DockingErrorSignal=45, CameraParams=46, VisionMarker=47, ShowObjects=48, TrackerQuad=49, FaceDetection=50, BehaviorStackDebug=51, VisionModeDebug=52, SaveImages=53, SaveState=54, ) _tags_by_value = dict() _tags_by_value[0] = 'ReportCloudConnectivity' _tags_by_value[1] = 'StartShutdownAnim' _tags_by_value[2] = 'AnimationState' _tags_by_value[3] = 'AnimationAdded' _tags_by_value[4] = 'AnimationStarted' _tags_by_value[5] = 'AnimationEnded' _tags_by_value[6] = 'AnimationEvent' _tags_by_value[7] = 'TextToSpeechEvent' _tags_by_value[8] = 'StreamCameraImages' _tags_by_value[9] = 'DebugScreenMode' _tags_by_value[10] = 'RobotAvailable' _tags_by_value[11] = 'AudioStreamStatusEvent' _tags_by_value[12] = 'IMURequest' _tags_by_value[13] = 'IMUTemperature' _tags_by_value[14] = 'CliffEvent' _tags_by_value[15] = 'PotentialCliff' _tags_by_value[16] = 'SetCliffDetectThresholds' _tags_by_value[17] = 'SetWhiteDetectThresholds' _tags_by_value[18] = 'CarryStateUpdate' _tags_by_value[19] = 'ImageChunk' _tags_by_value[20] = 'CameraCalibration' _tags_by_value[21] = 'SetVizOrigin' _tags_by_value[22] = 'RobotStateMessage' _tags_by_value[23] = 'CurrentAnimation' _tags_by_value[24] = 'Object' _tags_by_value[25] = 'LineSegment' _tags_by_value[26] = 'Quad' _tags_by_value[27] = 'MemoryMapMessageVizBegin' _tags_by_value[28] = 'MemoryMapMessageViz' _tags_by_value[29] = 'MemoryMapMessageVizEnd' _tags_by_value[30] = 'EnabledVisionModes' _tags_by_value[31] = 'CameraQuad' _tags_by_value[32] = 'CameraRect' _tags_by_value[33] = 'CameraLine' _tags_by_value[34] = 'CameraOval' _tags_by_value[35] = 'CameraText' _tags_by_value[36] = 'EraseObject' _tags_by_value[37] = 'EraseLineSegments' _tags_by_value[38] = 'EraseQuad' _tags_by_value[39] = 'SetRobot' _tags_by_value[40] = 'AppendPathSegmentLine' _tags_by_value[41] = 'AppendPathSegmentArc' _tags_by_value[42] = 'SetPathColor' _tags_by_value[43] = 'ErasePath' _tags_by_value[44] = 'SetLabel' _tags_by_value[45] = 'DockingErrorSignal' _tags_by_value[46] = 'CameraParams' _tags_by_value[47] = 'VisionMarker' _tags_by_value[48] = 'ShowObjects' _tags_by_value[49] = 'TrackerQuad' _tags_by_value[50] = 'FaceDetection' _tags_by_value[51] = 'BehaviorStackDebug' _tags_by_value[52] = 'VisionModeDebug' _tags_by_value[53] = 'SaveImages' _tags_by_value[54] = 'SaveState' _tag_unpack_methods = dict() _tag_unpack_methods[0] = lambda reader: reader.read_object(Anki.Vector.ReportCloudConnectivity.unpack_from) _tag_unpack_methods[1] = lambda reader: reader.read_object(Anki.Vector.StartShutdownAnim.unpack_from) _tag_unpack_methods[2] = lambda reader: reader.read_object(Anki.Vector.AnimationState.unpack_from) _tag_unpack_methods[3] = lambda reader: reader.read_object(Anki.Vector.AnimationAdded.unpack_from) _tag_unpack_methods[4] = lambda reader: reader.read_object(Anki.Vector.AnimationStarted.unpack_from) _tag_unpack_methods[5] = lambda reader: reader.read_object(Anki.Vector.AnimationEnded.unpack_from) _tag_unpack_methods[6] = lambda reader: reader.read_object(Anki.Vector.AnimationEvent.unpack_from) _tag_unpack_methods[7] = lambda reader: reader.read_object(Anki.Vector.TextToSpeechEvent.unpack_from) _tag_unpack_methods[8] = lambda reader: reader.read_object(Anki.Vector.StreamCameraImages.unpack_from) _tag_unpack_methods[9] = lambda reader: reader.read_object(Anki.Vector.DebugScreenMode.unpack_from) _tag_unpack_methods[10] = lambda reader: reader.read_object(Anki.Vector.RobotAvailable.unpack_from) _tag_unpack_methods[11] = lambda reader: reader.read_object(Anki.Vector.AudioStreamStatusEvent.unpack_from) _tag_unpack_methods[12] = lambda reader: reader.read_object(Anki.Vector.IMURequest.unpack_from) _tag_unpack_methods[13] = lambda reader: reader.read_object(Anki.Vector.RobotInterface.IMUTemperature.unpack_from) _tag_unpack_methods[14] = lambda reader: reader.read_object(Anki.Vector.CliffEvent.unpack_from) _tag_unpack_methods[15] = lambda reader: reader.read_object(Anki.Vector.PotentialCliff.unpack_from) _tag_unpack_methods[16] = lambda reader: reader.read_object(Anki.Vector.SetCliffDetectThresholds.unpack_from) _tag_unpack_methods[17] = lambda reader: reader.read_object(Anki.Vector.SetWhiteDetectThresholds.unpack_from) _tag_unpack_methods[18] = lambda reader: reader.read_object(Anki.Vector.CarryStateUpdate.unpack_from) _tag_unpack_methods[19] = lambda reader: reader.read_object(Anki.Vector.ImageChunk.unpack_from) _tag_unpack_methods[20] = lambda reader: reader.read_object(Anki.Vector.CameraCalibration.unpack_from) _tag_unpack_methods[21] = lambda reader: reader.read_object(Anki.Vector.SetVizOrigin.unpack_from) _tag_unpack_methods[22] = lambda reader: reader.read_object(Anki.Vector.VizInterface.RobotStateMessage.unpack_from) _tag_unpack_methods[23] = lambda reader: reader.read_object(Anki.Vector.VizInterface.CurrentAnimation.unpack_from) _tag_unpack_methods[24] = lambda reader: reader.read_object(Anki.Vector.VizInterface.Object.unpack_from) _tag_unpack_methods[25] = lambda reader: reader.read_object(Anki.Vector.VizInterface.LineSegment.unpack_from) _tag_unpack_methods[26] = lambda reader: reader.read_object(Anki.Vector.VizInterface.Quad.unpack_from) _tag_unpack_methods[27] = lambda reader: reader.read_object(Anki.Vector.VizInterface.MemoryMapMessageVizBegin.unpack_from) _tag_unpack_methods[28] = lambda reader: reader.read_object(Anki.Vector.VizInterface.MemoryMapMessageViz.unpack_from) _tag_unpack_methods[29] = lambda reader: reader.read_object(Anki.Vector.VizInterface.MemoryMapMessageVizEnd.unpack_from) _tag_unpack_methods[30] = lambda reader: reader.read_object(Anki.Vector.VizInterface.EnabledVisionModes.unpack_from) _tag_unpack_methods[31] = lambda reader: reader.read_object(Anki.Vector.VizInterface.CameraQuad.unpack_from) _tag_unpack_methods[32] = lambda reader: reader.read_object(Anki.Vector.VizInterface.CameraRect.unpack_from) _tag_unpack_methods[33] = lambda reader: reader.read_object(Anki.Vector.VizInterface.CameraLine.unpack_from) _tag_unpack_methods[34] = lambda reader: reader.read_object(Anki.Vector.VizInterface.CameraOval.unpack_from) _tag_unpack_methods[35] = lambda reader: reader.read_object(Anki.Vector.VizInterface.CameraText.unpack_from) _tag_unpack_methods[36] = lambda reader: reader.read_object(Anki.Vector.VizInterface.EraseObject.unpack_from) _tag_unpack_methods[37] = lambda reader: reader.read_object(Anki.Vector.VizInterface.EraseLineSegments.unpack_from) _tag_unpack_methods[38] = lambda reader: reader.read_object(Anki.Vector.VizInterface.EraseQuad.unpack_from) _tag_unpack_methods[39] = lambda reader: reader.read_object(Anki.Vector.VizInterface.SetRobot.unpack_from) _tag_unpack_methods[40] = lambda reader: reader.read_object(Anki.Vector.VizInterface.AppendPathSegmentLine.unpack_from) _tag_unpack_methods[41] = lambda reader: reader.read_object(Anki.Vector.VizInterface.AppendPathSegmentArc.unpack_from) _tag_unpack_methods[42] = lambda reader: reader.read_object(Anki.Vector.VizInterface.SetPathColor.unpack_from) _tag_unpack_methods[43] = lambda reader: reader.read_object(Anki.Vector.VizInterface.ErasePath.unpack_from) _tag_unpack_methods[44] = lambda reader: reader.read_object(Anki.Vector.VizInterface.SetLabel.unpack_from) _tag_unpack_methods[45] = lambda reader: reader.read_object(Anki.Vector.VizInterface.DockingErrorSignal.unpack_from) _tag_unpack_methods[46] = lambda reader: reader.read_object(Anki.Vector.VizInterface.CameraParams.unpack_from) _tag_unpack_methods[47] = lambda reader: reader.read_object(Anki.Vector.VizInterface.VisionMarker.unpack_from) _tag_unpack_methods[48] = lambda reader: reader.read_object(Anki.Vector.VizInterface.ShowObjects.unpack_from) _tag_unpack_methods[49] = lambda reader: reader.read_object(Anki.Vector.VizInterface.TrackerQuad.unpack_from) _tag_unpack_methods[50] = lambda reader: reader.read_object(Anki.Vector.VizInterface.FaceDetection.unpack_from) _tag_unpack_methods[51] = lambda reader: reader.read_object(Anki.Vector.VizInterface.BehaviorStackDebug.unpack_from) _tag_unpack_methods[52] = lambda reader: reader.read_object(Anki.Vector.VizInterface.VisionModeDebug.unpack_from) _tag_unpack_methods[53] = lambda reader: reader.read_object(Anki.Vector.VizInterface.SaveImages.unpack_from) _tag_unpack_methods[54] = lambda reader: reader.read_object(Anki.Vector.VizInterface.SaveState.unpack_from) _tag_pack_methods = dict() _tag_pack_methods[0] = lambda writer, value: writer.write_object(value) _tag_pack_methods[1] = lambda writer, value: writer.write_object(value) _tag_pack_methods[2] = lambda writer, value: writer.write_object(value) _tag_pack_methods[3] = lambda writer, value: writer.write_object(value) _tag_pack_methods[4] = lambda writer, value: writer.write_object(value) _tag_pack_methods[5] = lambda writer, value: writer.write_object(value) _tag_pack_methods[6] = lambda writer, value: writer.write_object(value) _tag_pack_methods[7] = lambda writer, value: writer.write_object(value) _tag_pack_methods[8] = lambda writer, value: writer.write_object(value) _tag_pack_methods[9] = lambda writer, value: writer.write_object(value) _tag_pack_methods[10] = lambda writer, value: writer.write_object(value) _tag_pack_methods[11] = lambda writer, value: writer.write_object(value) _tag_pack_methods[12] = lambda writer, value: writer.write_object(value) _tag_pack_methods[13] = lambda writer, value: writer.write_object(value) _tag_pack_methods[14] = lambda writer, value: writer.write_object(value) _tag_pack_methods[15] = lambda writer, value: writer.write_object(value) _tag_pack_methods[16] = lambda writer, value: writer.write_object(value) _tag_pack_methods[17] = lambda writer, value: writer.write_object(value) _tag_pack_methods[18] = lambda writer, value: writer.write_object(value) _tag_pack_methods[19] = lambda writer, value: writer.write_object(value) _tag_pack_methods[20] = lambda writer, value: writer.write_object(value) _tag_pack_methods[21] = lambda writer, value: writer.write_object(value) _tag_pack_methods[22] = lambda writer, value: writer.write_object(value) _tag_pack_methods[23] = lambda writer, value: writer.write_object(value) _tag_pack_methods[24] = lambda writer, value: writer.write_object(value) _tag_pack_methods[25] = lambda writer, value: writer.write_object(value) _tag_pack_methods[26] = lambda writer, value: writer.write_object(value) _tag_pack_methods[27] = lambda writer, value: writer.write_object(value) _tag_pack_methods[28] = lambda writer, value: writer.write_object(value) _tag_pack_methods[29] = lambda writer, value: writer.write_object(value) _tag_pack_methods[30] = lambda writer, value: writer.write_object(value) _tag_pack_methods[31] = lambda writer, value: writer.write_object(value) _tag_pack_methods[32] = lambda writer, value: writer.write_object(value) _tag_pack_methods[33] = lambda writer, value: writer.write_object(value) _tag_pack_methods[34] = lambda writer, value: writer.write_object(value) _tag_pack_methods[35] = lambda writer, value: writer.write_object(value) _tag_pack_methods[36] = lambda writer, value: writer.write_object(value) _tag_pack_methods[37] = lambda writer, value: writer.write_object(value) _tag_pack_methods[38] = lambda writer, value: writer.write_object(value) _tag_pack_methods[39] = lambda writer, value: writer.write_object(value) _tag_pack_methods[40] = lambda writer, value: writer.write_object(value) _tag_pack_methods[41] = lambda writer, value: writer.write_object(value) _tag_pack_methods[42] = lambda writer, value: writer.write_object(value) _tag_pack_methods[43] = lambda writer, value: writer.write_object(value) _tag_pack_methods[44] = lambda writer, value: writer.write_object(value) _tag_pack_methods[45] = lambda writer, value: writer.write_object(value) _tag_pack_methods[46] = lambda writer, value: writer.write_object(value) _tag_pack_methods[47] = lambda writer, value: writer.write_object(value) _tag_pack_methods[48] = lambda writer, value: writer.write_object(value) _tag_pack_methods[49] = lambda writer, value: writer.write_object(value) _tag_pack_methods[50] = lambda writer, value: writer.write_object(value) _tag_pack_methods[51] = lambda writer, value: writer.write_object(value) _tag_pack_methods[52] = lambda writer, value: writer.write_object(value) _tag_pack_methods[53] = lambda writer, value: writer.write_object(value) _tag_pack_methods[54] = lambda writer, value: writer.write_object(value) _tag_size_methods = dict() _tag_size_methods[0] = lambda value: msgbuffers.size_object(value) _tag_size_methods[1] = lambda value: msgbuffers.size_object(value) _tag_size_methods[2] = lambda value: msgbuffers.size_object(value) _tag_size_methods[3] = lambda value: msgbuffers.size_object(value) _tag_size_methods[4] = lambda value: msgbuffers.size_object(value) _tag_size_methods[5] = lambda value: msgbuffers.size_object(value) _tag_size_methods[6] = lambda value: msgbuffers.size_object(value) _tag_size_methods[7] = lambda value: msgbuffers.size_object(value) _tag_size_methods[8] = lambda value: msgbuffers.size_object(value) _tag_size_methods[9] = lambda value: msgbuffers.size_object(value) _tag_size_methods[10] = lambda value: msgbuffers.size_object(value) _tag_size_methods[11] = lambda value: msgbuffers.size_object(value) _tag_size_methods[12] = lambda value: msgbuffers.size_object(value) _tag_size_methods[13] = lambda value: msgbuffers.size_object(value) _tag_size_methods[14] = lambda value: msgbuffers.size_object(value) _tag_size_methods[15] = lambda value: msgbuffers.size_object(value) _tag_size_methods[16] = lambda value: msgbuffers.size_object(value) _tag_size_methods[17] = lambda value: msgbuffers.size_object(value) _tag_size_methods[18] = lambda value: msgbuffers.size_object(value) _tag_size_methods[19] = lambda value: msgbuffers.size_object(value) _tag_size_methods[20] = lambda value: msgbuffers.size_object(value) _tag_size_methods[21] = lambda value: msgbuffers.size_object(value) _tag_size_methods[22] = lambda value: msgbuffers.size_object(value) _tag_size_methods[23] = lambda value: msgbuffers.size_object(value) _tag_size_methods[24] = lambda value: msgbuffers.size_object(value) _tag_size_methods[25] = lambda value: msgbuffers.size_object(value) _tag_size_methods[26] = lambda value: msgbuffers.size_object(value) _tag_size_methods[27] = lambda value: msgbuffers.size_object(value) _tag_size_methods[28] = lambda value: msgbuffers.size_object(value) _tag_size_methods[29] = lambda value: msgbuffers.size_object(value) _tag_size_methods[30] = lambda value: msgbuffers.size_object(value) _tag_size_methods[31] = lambda value: msgbuffers.size_object(value) _tag_size_methods[32] = lambda value: msgbuffers.size_object(value) _tag_size_methods[33] = lambda value: msgbuffers.size_object(value) _tag_size_methods[34] = lambda value: msgbuffers.size_object(value) _tag_size_methods[35] = lambda value: msgbuffers.size_object(value) _tag_size_methods[36] = lambda value: msgbuffers.size_object(value) _tag_size_methods[37] = lambda value: msgbuffers.size_object(value) _tag_size_methods[38] = lambda value: msgbuffers.size_object(value) _tag_size_methods[39] = lambda value: msgbuffers.size_object(value) _tag_size_methods[40] = lambda value: msgbuffers.size_object(value) _tag_size_methods[41] = lambda value: msgbuffers.size_object(value) _tag_size_methods[42] = lambda value: msgbuffers.size_object(value) _tag_size_methods[43] = lambda value: msgbuffers.size_object(value) _tag_size_methods[44] = lambda value: msgbuffers.size_object(value) _tag_size_methods[45] = lambda value: msgbuffers.size_object(value) _tag_size_methods[46] = lambda value: msgbuffers.size_object(value) _tag_size_methods[47] = lambda value: msgbuffers.size_object(value) _tag_size_methods[48] = lambda value: msgbuffers.size_object(value) _tag_size_methods[49] = lambda value: msgbuffers.size_object(value) _tag_size_methods[50] = lambda value: msgbuffers.size_object(value) _tag_size_methods[51] = lambda value: msgbuffers.size_object(value) _tag_size_methods[52] = lambda value: msgbuffers.size_object(value) _tag_size_methods[53] = lambda value: msgbuffers.size_object(value) _tag_size_methods[54] = lambda value: msgbuffers.size_object(value) _type_by_tag_value = dict() _type_by_tag_value[0] = lambda : Anki.Vector.ReportCloudConnectivity _type_by_tag_value[1] = lambda : Anki.Vector.StartShutdownAnim _type_by_tag_value[2] = lambda : Anki.Vector.AnimationState _type_by_tag_value[3] = lambda : Anki.Vector.AnimationAdded _type_by_tag_value[4] = lambda : Anki.Vector.AnimationStarted _type_by_tag_value[5] = lambda : Anki.Vector.AnimationEnded _type_by_tag_value[6] = lambda : Anki.Vector.AnimationEvent _type_by_tag_value[7] = lambda : Anki.Vector.TextToSpeechEvent _type_by_tag_value[8] = lambda : Anki.Vector.StreamCameraImages _type_by_tag_value[9] = lambda : Anki.Vector.DebugScreenMode _type_by_tag_value[10] = lambda : Anki.Vector.RobotAvailable _type_by_tag_value[11] = lambda : Anki.Vector.AudioStreamStatusEvent _type_by_tag_value[12] = lambda : Anki.Vector.IMURequest _type_by_tag_value[13] = lambda : Anki.Vector.RobotInterface.IMUTemperature _type_by_tag_value[14] = lambda : Anki.Vector.CliffEvent _type_by_tag_value[15] = lambda : Anki.Vector.PotentialCliff _type_by_tag_value[16] = lambda : Anki.Vector.SetCliffDetectThresholds _type_by_tag_value[17] = lambda : Anki.Vector.SetWhiteDetectThresholds _type_by_tag_value[18] = lambda : Anki.Vector.CarryStateUpdate _type_by_tag_value[19] = lambda : Anki.Vector.ImageChunk _type_by_tag_value[20] = lambda : Anki.Vector.CameraCalibration _type_by_tag_value[21] = lambda : Anki.Vector.SetVizOrigin _type_by_tag_value[22] = lambda : Anki.Vector.VizInterface.RobotStateMessage _type_by_tag_value[23] = lambda : Anki.Vector.VizInterface.CurrentAnimation _type_by_tag_value[24] = lambda : Anki.Vector.VizInterface.Object _type_by_tag_value[25] = lambda : Anki.Vector.VizInterface.LineSegment _type_by_tag_value[26] = lambda : Anki.Vector.VizInterface.Quad _type_by_tag_value[27] = lambda : Anki.Vector.VizInterface.MemoryMapMessageVizBegin _type_by_tag_value[28] = lambda : Anki.Vector.VizInterface.MemoryMapMessageViz _type_by_tag_value[29] = lambda : Anki.Vector.VizInterface.MemoryMapMessageVizEnd _type_by_tag_value[30] = lambda : Anki.Vector.VizInterface.EnabledVisionModes _type_by_tag_value[31] = lambda : Anki.Vector.VizInterface.CameraQuad _type_by_tag_value[32] = lambda : Anki.Vector.VizInterface.CameraRect _type_by_tag_value[33] = lambda : Anki.Vector.VizInterface.CameraLine _type_by_tag_value[34] = lambda : Anki.Vector.VizInterface.CameraOval _type_by_tag_value[35] = lambda : Anki.Vector.VizInterface.CameraText _type_by_tag_value[36] = lambda : Anki.Vector.VizInterface.EraseObject _type_by_tag_value[37] = lambda : Anki.Vector.VizInterface.EraseLineSegments _type_by_tag_value[38] = lambda : Anki.Vector.VizInterface.EraseQuad _type_by_tag_value[39] = lambda : Anki.Vector.VizInterface.SetRobot _type_by_tag_value[40] = lambda : Anki.Vector.VizInterface.AppendPathSegmentLine _type_by_tag_value[41] = lambda : Anki.Vector.VizInterface.AppendPathSegmentArc _type_by_tag_value[42] = lambda : Anki.Vector.VizInterface.SetPathColor _type_by_tag_value[43] = lambda : Anki.Vector.VizInterface.ErasePath _type_by_tag_value[44] = lambda : Anki.Vector.VizInterface.SetLabel _type_by_tag_value[45] = lambda : Anki.Vector.VizInterface.DockingErrorSignal _type_by_tag_value[46] = lambda : Anki.Vector.VizInterface.CameraParams _type_by_tag_value[47] = lambda : Anki.Vector.VizInterface.VisionMarker _type_by_tag_value[48] = lambda : Anki.Vector.VizInterface.ShowObjects _type_by_tag_value[49] = lambda : Anki.Vector.VizInterface.TrackerQuad _type_by_tag_value[50] = lambda : Anki.Vector.VizInterface.FaceDetection _type_by_tag_value[51] = lambda : Anki.Vector.VizInterface.BehaviorStackDebug _type_by_tag_value[52] = lambda : Anki.Vector.VizInterface.VisionModeDebug _type_by_tag_value[53] = lambda : Anki.Vector.VizInterface.SaveImages _type_by_tag_value[54] = lambda : Anki.Vector.VizInterface.SaveState Anki.Vector.VizInterface.MessageViz = MessageViz del MessageViz