"""
Autogenerated python message buffer code.
Source: clad/types/ledTypes.clad
Full command line: victor-clad/tools/message-buffers/emitters/Python_emitter.py -C src -I clad/src lib/util/source/anki/clad robot/clad/src coretech/vision/clad_src coretech/common/clad_src -o generated/cladPython clad/types/ledTypes.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()

class BackpackLightLayer(object):
  "Automatically-generated uint_8 enumeration."
  BPL_USER       = 0
  BPL_ANIMATION  = 1
  BPL_NUM_LAYERS = 2

Anki.Vector.BackpackLightLayer = BackpackLightLayer
del BackpackLightLayer


class LEDId(object):
  "Automatically-generated uint_8 enumeration."
  LED_BACKPACK_FRONT  = 0
  LED_BACKPACK_MIDDLE = 1
  LED_BACKPACK_BACK   = 2
  NUM_BACKPACK_LEDS   = 3

Anki.Vector.LEDId = LEDId
del LEDId


class LEDColor(object):
  "Automatically-generated uint_32 enumeration."
  LED_CURRENT_COLOR = 0xffffffff
  LED_OFF           = 0x0
  LED_RED           = 0xff000000
  LED_GREEN         = 0xff0000
  LED_YELLOW        = 0xffff0000
  LED_BLUE          = 0xff00
  LED_PURPLE        = 0xff00ff00
  LED_CYAN          = 0xffff00
  LED_WHITE         = 0xffffff00

Anki.Vector.LEDColor = LEDColor
del LEDColor


class LEDColorShift(object):
  "Automatically-generated uint_8 enumeration."
  LED_RED_SHIFT = 24
  LED_GRN_SHIFT = 16
  LED_BLU_SHIFT = 8

Anki.Vector.LEDColorShift = LEDColorShift
del LEDColorShift


class CubeLightState(object):
  "Generated message-passing structure."

  __slots__ = (
    '_onColor',             # uint_32
    '_offColor',            # uint_32
    '_onFrames',            # uint_8
    '_offFrames',           # uint_8
    '_transitionOnFrames',  # uint_8
    '_transitionOffFrames', # uint_8
    '_offset',              # uint_8
    '_padding1',            # int_8
    '_padding2',            # int_16
  )

  @property
  def onColor(self):
    "uint_32 onColor struct property."
    return self._onColor

  @onColor.setter
  def onColor(self, value):
    self._onColor = msgbuffers.validate_integer(
      'CubeLightState.onColor', value, 0, 4294967295)

  @property
  def offColor(self):
    "uint_32 offColor struct property."
    return self._offColor

  @offColor.setter
  def offColor(self, value):
    self._offColor = msgbuffers.validate_integer(
      'CubeLightState.offColor', value, 0, 4294967295)

  @property
  def onFrames(self):
    "uint_8 onFrames struct property."
    return self._onFrames

  @onFrames.setter
  def onFrames(self, value):
    self._onFrames = msgbuffers.validate_integer(
      'CubeLightState.onFrames', value, 0, 255)

  @property
  def offFrames(self):
    "uint_8 offFrames struct property."
    return self._offFrames

  @offFrames.setter
  def offFrames(self, value):
    self._offFrames = msgbuffers.validate_integer(
      'CubeLightState.offFrames', value, 0, 255)

  @property
  def transitionOnFrames(self):
    "uint_8 transitionOnFrames struct property."
    return self._transitionOnFrames

  @transitionOnFrames.setter
  def transitionOnFrames(self, value):
    self._transitionOnFrames = msgbuffers.validate_integer(
      'CubeLightState.transitionOnFrames', value, 0, 255)

  @property
  def transitionOffFrames(self):
    "uint_8 transitionOffFrames struct property."
    return self._transitionOffFrames

  @transitionOffFrames.setter
  def transitionOffFrames(self, value):
    self._transitionOffFrames = msgbuffers.validate_integer(
      'CubeLightState.transitionOffFrames', value, 0, 255)

  @property
  def offset(self):
    "uint_8 offset struct property."
    return self._offset

  @offset.setter
  def offset(self, value):
    self._offset = msgbuffers.validate_integer(
      'CubeLightState.offset', value, 0, 255)

  @property
  def padding1(self):
    "int_8 padding1 struct property."
    return self._padding1

  @padding1.setter
  def padding1(self, value):
    self._padding1 = msgbuffers.validate_integer(
      'CubeLightState.padding1', value, -128, 127)

  @property
  def padding2(self):
    "int_16 padding2 struct property."
    return self._padding2

  @padding2.setter
  def padding2(self, value):
    self._padding2 = msgbuffers.validate_integer(
      'CubeLightState.padding2', value, -32768, 32767)

  def __init__(self, onColor=0, offColor=0, onFrames=0, offFrames=0, transitionOnFrames=0, transitionOffFrames=0, offset=0, padding1=0, padding2=0):
    self.onColor = onColor
    self.offColor = offColor
    self.onFrames = onFrames
    self.offFrames = offFrames
    self.transitionOnFrames = transitionOnFrames
    self.transitionOffFrames = transitionOffFrames
    self.offset = offset
    self.padding1 = padding1
    self.padding2 = padding2

  @classmethod
  def unpack(cls, buffer):
    "Reads a new CubeLightState from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('CubeLightState.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 CubeLightState from the given BinaryReader."
    _onColor = reader.read('I')
    _offColor = reader.read('I')
    _onFrames = reader.read('B')
    _offFrames = reader.read('B')
    _transitionOnFrames = reader.read('B')
    _transitionOffFrames = reader.read('B')
    _offset = reader.read('B')
    _padding1 = reader.read('b')
    _padding2 = reader.read('h')
    return cls(_onColor, _offColor, _onFrames, _offFrames, _transitionOnFrames, _transitionOffFrames, _offset, _padding1, _padding2)

  def pack(self):
    "Writes the current CubeLightState, returning bytes."
    writer = msgbuffers.BinaryWriter()
    self.pack_to(writer)
    return writer.dumps()

  def pack_to(self, writer):
    "Writes the current CubeLightState to the given BinaryWriter."
    writer.write(self._onColor, 'I')
    writer.write(self._offColor, 'I')
    writer.write(self._onFrames, 'B')
    writer.write(self._offFrames, 'B')
    writer.write(self._transitionOnFrames, 'B')
    writer.write(self._transitionOffFrames, 'B')
    writer.write(self._offset, 'B')
    writer.write(self._padding1, 'b')
    writer.write(self._padding2, 'h')

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._onColor == other._onColor and
        self._offColor == other._offColor and
        self._onFrames == other._onFrames and
        self._offFrames == other._offFrames and
        self._transitionOnFrames == other._transitionOnFrames and
        self._transitionOffFrames == other._transitionOffFrames and
        self._offset == other._offset and
        self._padding1 == other._padding1 and
        self._padding2 == other._padding2)
    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._onColor, 'I') +
      msgbuffers.size(self._offColor, 'I') +
      msgbuffers.size(self._onFrames, 'B') +
      msgbuffers.size(self._offFrames, 'B') +
      msgbuffers.size(self._transitionOnFrames, 'B') +
      msgbuffers.size(self._transitionOffFrames, 'B') +
      msgbuffers.size(self._offset, 'B') +
      msgbuffers.size(self._padding1, 'b') +
      msgbuffers.size(self._padding2, 'h'))

  def __str__(self):
    return '{type}(onColor={onColor}, offColor={offColor}, onFrames={onFrames}, offFrames={offFrames}, transitionOnFrames={transitionOnFrames}, transitionOffFrames={transitionOffFrames}, offset={offset}, padding1={padding1}, padding2={padding2})'.format(
      type=type(self).__name__,
      onColor=self._onColor,
      offColor=self._offColor,
      onFrames=self._onFrames,
      offFrames=self._offFrames,
      transitionOnFrames=self._transitionOnFrames,
      transitionOffFrames=self._transitionOffFrames,
      offset=self._offset,
      padding1=self._padding1,
      padding2=self._padding2)

  def __repr__(self):
    return '{type}(onColor={onColor}, offColor={offColor}, onFrames={onFrames}, offFrames={offFrames}, transitionOnFrames={transitionOnFrames}, transitionOffFrames={transitionOffFrames}, offset={offset}, padding1={padding1}, padding2={padding2})'.format(
      type=type(self).__name__,
      onColor=repr(self._onColor),
      offColor=repr(self._offColor),
      onFrames=repr(self._onFrames),
      offFrames=repr(self._offFrames),
      transitionOnFrames=repr(self._transitionOnFrames),
      transitionOffFrames=repr(self._transitionOffFrames),
      offset=repr(self._offset),
      padding1=repr(self._padding1),
      padding2=repr(self._padding2))

Anki.Vector.CubeLightState = CubeLightState
del CubeLightState


class CubeLights(object):
  "Generated message-passing structure."

  __slots__ = (
    '_lights',   # CubeLightState[4]
    '_rotate',   # bool
    '_playOnce', # bool
  )

  @property
  def lights(self):
    "CubeLightState[4] lights struct property."
    return self._lights

  @lights.setter
  def lights(self, value):
    self._lights = msgbuffers.validate_farray(
      'CubeLights.lights', value, 4,
      lambda name, value_inner: msgbuffers.validate_object(
        name, value_inner, Anki.Vector.CubeLightState))

  @property
  def rotate(self):
    "bool rotate struct property."
    return self._rotate

  @rotate.setter
  def rotate(self, value):
    self._rotate = msgbuffers.validate_bool(
      'CubeLights.rotate', value)

  @property
  def playOnce(self):
    "bool playOnce struct property."
    return self._playOnce

  @playOnce.setter
  def playOnce(self, value):
    self._playOnce = msgbuffers.validate_bool(
      'CubeLights.playOnce', value)

  def __init__(self, lights=(Anki.Vector.CubeLightState(),) * 4, rotate=False, playOnce=False):
    self.lights = lights
    self.rotate = rotate
    self.playOnce = playOnce

  @classmethod
  def unpack(cls, buffer):
    "Reads a new CubeLights from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('CubeLights.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 CubeLights from the given BinaryReader."
    _lights = reader.read_object_farray(Anki.Vector.CubeLightState.unpack_from, 4)
    _rotate = bool(reader.read('b'))
    _playOnce = bool(reader.read('b'))
    return cls(_lights, _rotate, _playOnce)

  def pack(self):
    "Writes the current CubeLights, returning bytes."
    writer = msgbuffers.BinaryWriter()
    self.pack_to(writer)
    return writer.dumps()

  def pack_to(self, writer):
    "Writes the current CubeLights to the given BinaryWriter."
    writer.write_object_farray(self._lights, 4)
    writer.write(int(self._rotate), 'b')
    writer.write(int(self._playOnce), 'b')

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._lights == other._lights and
        self._rotate == other._rotate and
        self._playOnce == other._playOnce)
    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_farray(self._lights, 4) +
      msgbuffers.size(self._rotate, 'b') +
      msgbuffers.size(self._playOnce, 'b'))

  def __str__(self):
    return '{type}(lights={lights}, rotate={rotate}, playOnce={playOnce})'.format(
      type=type(self).__name__,
      lights=msgbuffers.shorten_sequence(self._lights),
      rotate=self._rotate,
      playOnce=self._playOnce)

  def __repr__(self):
    return '{type}(lights={lights}, rotate={rotate}, playOnce={playOnce})'.format(
      type=type(self).__name__,
      lights=repr(self._lights),
      rotate=repr(self._rotate),
      playOnce=repr(self._playOnce))

Anki.Vector.CubeLights = CubeLights
del CubeLights


class WhichCubeLEDs(object):
  "Automatically-generated uint_8 enumeration."
  NONE           = 0x0
  ALL            = 0xff
  BACK           = 0x1
  LEFT           = 0x2
  FRONT          = 0x4
  RIGHT          = 0x8
  FRONT_LEFT     = 0x6
  FRONT_RIGHT    = 0xc
  BACK_LEFT      = 0x3
  BACK_RIGHT     = 0x9
  CHARGER_BACK   = 0x1
  CHARGER_MIDDLE = 0x2
  CHARGER_FRONT  = 0x4

Anki.Vector.WhichCubeLEDs = WhichCubeLEDs
del WhichCubeLEDs


class MakeRelativeMode(object):
  "Automatically-generated uint_8 enumeration."
  RELATIVE_LED_MODE_OFF       = 0
  RELATIVE_LED_MODE_BY_CORNER = 1
  RELATIVE_LED_MODE_BY_SIDE   = 2

Anki.Vector.MakeRelativeMode = MakeRelativeMode
del MakeRelativeMode


class CubeConstants(object):
  "Automatically-generated int_32 enumeration."
  NUM_CUBE_LEDS = 4

Anki.Vector.CubeConstants = CubeConstants
del CubeConstants


class LightState(object):
  "Generated message-passing structure."

  __slots__ = (
    '_onColor',                # uint_32
    '_offColor',               # uint_32
    '_onPeriod_ms',            # uint_16
    '_offPeriod_ms',           # uint_16
    '_transitionOnPeriod_ms',  # uint_16
    '_transitionOffPeriod_ms', # uint_16
    '_offset_ms',              # int_16
    '_padding',                # uint_16
  )

  @property
  def onColor(self):
    "uint_32 onColor struct property."
    return self._onColor

  @onColor.setter
  def onColor(self, value):
    self._onColor = msgbuffers.validate_integer(
      'LightState.onColor', value, 0, 4294967295)

  @property
  def offColor(self):
    "uint_32 offColor struct property."
    return self._offColor

  @offColor.setter
  def offColor(self, value):
    self._offColor = msgbuffers.validate_integer(
      'LightState.offColor', value, 0, 4294967295)

  @property
  def onPeriod_ms(self):
    "uint_16 onPeriod_ms struct property."
    return self._onPeriod_ms

  @onPeriod_ms.setter
  def onPeriod_ms(self, value):
    self._onPeriod_ms = msgbuffers.validate_integer(
      'LightState.onPeriod_ms', value, 0, 65535)

  @property
  def offPeriod_ms(self):
    "uint_16 offPeriod_ms struct property."
    return self._offPeriod_ms

  @offPeriod_ms.setter
  def offPeriod_ms(self, value):
    self._offPeriod_ms = msgbuffers.validate_integer(
      'LightState.offPeriod_ms', value, 0, 65535)

  @property
  def transitionOnPeriod_ms(self):
    "uint_16 transitionOnPeriod_ms struct property."
    return self._transitionOnPeriod_ms

  @transitionOnPeriod_ms.setter
  def transitionOnPeriod_ms(self, value):
    self._transitionOnPeriod_ms = msgbuffers.validate_integer(
      'LightState.transitionOnPeriod_ms', value, 0, 65535)

  @property
  def transitionOffPeriod_ms(self):
    "uint_16 transitionOffPeriod_ms struct property."
    return self._transitionOffPeriod_ms

  @transitionOffPeriod_ms.setter
  def transitionOffPeriod_ms(self, value):
    self._transitionOffPeriod_ms = msgbuffers.validate_integer(
      'LightState.transitionOffPeriod_ms', value, 0, 65535)

  @property
  def offset_ms(self):
    "int_16 offset_ms struct property."
    return self._offset_ms

  @offset_ms.setter
  def offset_ms(self, value):
    self._offset_ms = msgbuffers.validate_integer(
      'LightState.offset_ms', value, -32768, 32767)

  @property
  def padding(self):
    "uint_16 padding struct property."
    return self._padding

  @padding.setter
  def padding(self, value):
    self._padding = msgbuffers.validate_integer(
      'LightState.padding', value, 0, 65535)

  def __init__(self, onColor=0, offColor=0, onPeriod_ms=0, offPeriod_ms=0, transitionOnPeriod_ms=0, transitionOffPeriod_ms=0, offset_ms=0, padding=0):
    self.onColor = onColor
    self.offColor = offColor
    self.onPeriod_ms = onPeriod_ms
    self.offPeriod_ms = offPeriod_ms
    self.transitionOnPeriod_ms = transitionOnPeriod_ms
    self.transitionOffPeriod_ms = transitionOffPeriod_ms
    self.offset_ms = offset_ms
    self.padding = padding

  @classmethod
  def unpack(cls, buffer):
    "Reads a new LightState from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('LightState.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 LightState from the given BinaryReader."
    _onColor = reader.read('I')
    _offColor = reader.read('I')
    _onPeriod_ms = reader.read('H')
    _offPeriod_ms = reader.read('H')
    _transitionOnPeriod_ms = reader.read('H')
    _transitionOffPeriod_ms = reader.read('H')
    _offset_ms = reader.read('h')
    _padding = reader.read('H')
    return cls(_onColor, _offColor, _onPeriod_ms, _offPeriod_ms, _transitionOnPeriod_ms, _transitionOffPeriod_ms, _offset_ms, _padding)

  def pack(self):
    "Writes the current LightState, returning bytes."
    writer = msgbuffers.BinaryWriter()
    self.pack_to(writer)
    return writer.dumps()

  def pack_to(self, writer):
    "Writes the current LightState to the given BinaryWriter."
    writer.write(self._onColor, 'I')
    writer.write(self._offColor, 'I')
    writer.write(self._onPeriod_ms, 'H')
    writer.write(self._offPeriod_ms, 'H')
    writer.write(self._transitionOnPeriod_ms, 'H')
    writer.write(self._transitionOffPeriod_ms, 'H')
    writer.write(self._offset_ms, 'h')
    writer.write(self._padding, 'H')

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._onColor == other._onColor and
        self._offColor == other._offColor and
        self._onPeriod_ms == other._onPeriod_ms and
        self._offPeriod_ms == other._offPeriod_ms and
        self._transitionOnPeriod_ms == other._transitionOnPeriod_ms and
        self._transitionOffPeriod_ms == other._transitionOffPeriod_ms and
        self._offset_ms == other._offset_ms and
        self._padding == other._padding)
    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._onColor, 'I') +
      msgbuffers.size(self._offColor, 'I') +
      msgbuffers.size(self._onPeriod_ms, 'H') +
      msgbuffers.size(self._offPeriod_ms, 'H') +
      msgbuffers.size(self._transitionOnPeriod_ms, 'H') +
      msgbuffers.size(self._transitionOffPeriod_ms, 'H') +
      msgbuffers.size(self._offset_ms, 'h') +
      msgbuffers.size(self._padding, 'H'))

  def __str__(self):
    return '{type}(onColor={onColor}, offColor={offColor}, onPeriod_ms={onPeriod_ms}, offPeriod_ms={offPeriod_ms}, transitionOnPeriod_ms={transitionOnPeriod_ms}, transitionOffPeriod_ms={transitionOffPeriod_ms}, offset_ms={offset_ms}, padding={padding})'.format(
      type=type(self).__name__,
      onColor=self._onColor,
      offColor=self._offColor,
      onPeriod_ms=self._onPeriod_ms,
      offPeriod_ms=self._offPeriod_ms,
      transitionOnPeriod_ms=self._transitionOnPeriod_ms,
      transitionOffPeriod_ms=self._transitionOffPeriod_ms,
      offset_ms=self._offset_ms,
      padding=self._padding)

  def __repr__(self):
    return '{type}(onColor={onColor}, offColor={offColor}, onPeriod_ms={onPeriod_ms}, offPeriod_ms={offPeriod_ms}, transitionOnPeriod_ms={transitionOnPeriod_ms}, transitionOffPeriod_ms={transitionOffPeriod_ms}, offset_ms={offset_ms}, padding={padding})'.format(
      type=type(self).__name__,
      onColor=repr(self._onColor),
      offColor=repr(self._offColor),
      onPeriod_ms=repr(self._onPeriod_ms),
      offPeriod_ms=repr(self._offPeriod_ms),
      transitionOnPeriod_ms=repr(self._transitionOnPeriod_ms),
      transitionOffPeriod_ms=repr(self._transitionOffPeriod_ms),
      offset_ms=repr(self._offset_ms),
      padding=repr(self._padding))

Anki.Vector.LightState = LightState
del LightState