"""
Autogenerated python message buffer code.
Source: clad/types/proxMessages.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/proxMessages.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 CliffSensor(object):
  "Automatically-generated uint_8 enumeration."
  CLIFF_FL    = 0
  CLIFF_FR    = 1
  CLIFF_BL    = 2
  CLIFF_BR    = 3
  CLIFF_COUNT = 4

Anki.Vector.CliffSensor = CliffSensor
del CliffSensor


class StopReason(object):
  "Automatically-generated uint_8 enumeration."
  CLIFF = 0
  WHITE = 1

Anki.Vector.StopReason = StopReason
del StopReason


class CliffEvent(object):
  "Generated message-passing message."

  __slots__ = (
    '_timestamp',       # uint_32
    '_detectedFlags',   # uint_8
    '_didStopForCliff', # bool
  )

  @property
  def timestamp(self):
    "uint_32 timestamp struct property."
    return self._timestamp

  @timestamp.setter
  def timestamp(self, value):
    self._timestamp = msgbuffers.validate_integer(
      'CliffEvent.timestamp', value, 0, 4294967295)

  @property
  def detectedFlags(self):
    "uint_8 detectedFlags struct property."
    return self._detectedFlags

  @detectedFlags.setter
  def detectedFlags(self, value):
    self._detectedFlags = msgbuffers.validate_integer(
      'CliffEvent.detectedFlags', value, 0, 255)

  @property
  def didStopForCliff(self):
    "bool didStopForCliff struct property."
    return self._didStopForCliff

  @didStopForCliff.setter
  def didStopForCliff(self, value):
    self._didStopForCliff = msgbuffers.validate_bool(
      'CliffEvent.didStopForCliff', value)

  def __init__(self, timestamp=0, detectedFlags=0, didStopForCliff=False):
    self.timestamp = timestamp
    self.detectedFlags = detectedFlags
    self.didStopForCliff = didStopForCliff

  @classmethod
  def unpack(cls, buffer):
    "Reads a new CliffEvent from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('CliffEvent.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 CliffEvent from the given BinaryReader."
    _timestamp = reader.read('I')
    _detectedFlags = reader.read('B')
    _didStopForCliff = bool(reader.read('b'))
    return cls(_timestamp, _detectedFlags, _didStopForCliff)

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

  def pack_to(self, writer):
    "Writes the current CliffEvent to the given BinaryWriter."
    writer.write(self._timestamp, 'I')
    writer.write(self._detectedFlags, 'B')
    writer.write(int(self._didStopForCliff), 'b')

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._timestamp == other._timestamp and
        self._detectedFlags == other._detectedFlags and
        self._didStopForCliff == other._didStopForCliff)
    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._timestamp, 'I') +
      msgbuffers.size(self._detectedFlags, 'B') +
      msgbuffers.size(self._didStopForCliff, 'b'))

  def __str__(self):
    return '{type}(timestamp={timestamp}, detectedFlags={detectedFlags}, didStopForCliff={didStopForCliff})'.format(
      type=type(self).__name__,
      timestamp=self._timestamp,
      detectedFlags=self._detectedFlags,
      didStopForCliff=self._didStopForCliff)

  def __repr__(self):
    return '{type}(timestamp={timestamp}, detectedFlags={detectedFlags}, didStopForCliff={didStopForCliff})'.format(
      type=type(self).__name__,
      timestamp=repr(self._timestamp),
      detectedFlags=repr(self._detectedFlags),
      didStopForCliff=repr(self._didStopForCliff))

Anki.Vector.CliffEvent = CliffEvent
del CliffEvent


class PotentialCliff(object):
  "Generated message-passing message."

  __slots__ = ()

  def __init__(self):
    pass

  @classmethod
  def unpack(cls, buffer):
    "Reads a new PotentialCliff from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('PotentialCliff.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 PotentialCliff from the given BinaryReader."
    return cls()

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

  def pack_to(self, writer):
    "Writes the current PotentialCliff to the given BinaryWriter."

  def __eq__(self, other):
    if type(self) is type(other):
      return True
    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 0

  def __str__(self):
    return '{type}()'.format(type=type(self).__name__)

  def __repr__(self):
    return '{type}()'.format(type=type(self).__name__)

Anki.Vector.PotentialCliff = PotentialCliff
del PotentialCliff


class SetCliffDetectThresholds(object):
  "Generated message-passing message."

  __slots__ = (
    '_thresholds', # uint_16[4]
  )

  @property
  def thresholds(self):
    "uint_16[4] thresholds struct property."
    return self._thresholds

  @thresholds.setter
  def thresholds(self, value):
    self._thresholds = msgbuffers.validate_farray(
      'SetCliffDetectThresholds.thresholds', value, 4,
      lambda name, value_inner: msgbuffers.validate_integer(
        name, value_inner, 0, 65535))

  def __init__(self, thresholds=(0,) * 4):
    self.thresholds = thresholds

  @classmethod
  def unpack(cls, buffer):
    "Reads a new SetCliffDetectThresholds from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('SetCliffDetectThresholds.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 SetCliffDetectThresholds from the given BinaryReader."
    _thresholds = reader.read_farray('H', 4)
    return cls(_thresholds)

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

  def pack_to(self, writer):
    "Writes the current SetCliffDetectThresholds to the given BinaryWriter."
    writer.write_farray(self._thresholds, 'H', 4)

  def __eq__(self, other):
    if type(self) is type(other):
      return self._thresholds == other._thresholds
    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_farray(self._thresholds, 'H', 4))

  def __str__(self):
    return '{type}(thresholds={thresholds})'.format(
      type=type(self).__name__,
      thresholds=msgbuffers.shorten_sequence(self._thresholds))

  def __repr__(self):
    return '{type}(thresholds={thresholds})'.format(
      type=type(self).__name__,
      thresholds=repr(self._thresholds))

Anki.Vector.SetCliffDetectThresholds = SetCliffDetectThresholds
del SetCliffDetectThresholds


class SetWhiteDetectThresholds(object):
  "Generated message-passing message."

  __slots__ = (
    '_whiteThresholds', # uint_16[4]
  )

  @property
  def whiteThresholds(self):
    "uint_16[4] whiteThresholds struct property."
    return self._whiteThresholds

  @whiteThresholds.setter
  def whiteThresholds(self, value):
    self._whiteThresholds = msgbuffers.validate_farray(
      'SetWhiteDetectThresholds.whiteThresholds', value, 4,
      lambda name, value_inner: msgbuffers.validate_integer(
        name, value_inner, 0, 65535))

  def __init__(self, whiteThresholds=(0,) * 4):
    self.whiteThresholds = whiteThresholds

  @classmethod
  def unpack(cls, buffer):
    "Reads a new SetWhiteDetectThresholds from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('SetWhiteDetectThresholds.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 SetWhiteDetectThresholds from the given BinaryReader."
    _whiteThresholds = reader.read_farray('H', 4)
    return cls(_whiteThresholds)

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

  def pack_to(self, writer):
    "Writes the current SetWhiteDetectThresholds to the given BinaryWriter."
    writer.write_farray(self._whiteThresholds, 'H', 4)

  def __eq__(self, other):
    if type(self) is type(other):
      return self._whiteThresholds == other._whiteThresholds
    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_farray(self._whiteThresholds, 'H', 4))

  def __str__(self):
    return '{type}(whiteThresholds={whiteThresholds})'.format(
      type=type(self).__name__,
      whiteThresholds=msgbuffers.shorten_sequence(self._whiteThresholds))

  def __repr__(self):
    return '{type}(whiteThresholds={whiteThresholds})'.format(
      type=type(self).__name__,
      whiteThresholds=repr(self._whiteThresholds))

Anki.Vector.SetWhiteDetectThresholds = SetWhiteDetectThresholds
del SetWhiteDetectThresholds


class RangeStatus(object):
  "Automatically-generated uint_8 enumeration."
  RANGE_VALID    = 0
  SIGMA_FAIL     = 1
  SIGNAL_FAIL    = 2
  MIN_RANGE_FAIL = 3
  PHASE_FAIL     = 4
  HARDWARE_FAIL  = 5
  NO_UPDATE      = 255

Anki.Vector.RangeStatus = RangeStatus
del RangeStatus


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

  __slots__ = (
    '_signalIntensity',  # float_32
    '_ambientIntensity', # float_32
    '_spadCount',        # float_32
    '_timestamp_ms',     # uint_32
    '_distance_mm',      # uint_16
    '_rangeStatus',      # Anki.Vector.RangeStatus
    '_padding',          # uint_8
  )

  @property
  def signalIntensity(self):
    "float_32 signalIntensity struct property."
    return self._signalIntensity

  @signalIntensity.setter
  def signalIntensity(self, value):
    self._signalIntensity = msgbuffers.validate_float(
      'ProxSensorDataRaw.signalIntensity', value, 'f')

  @property
  def ambientIntensity(self):
    "float_32 ambientIntensity struct property."
    return self._ambientIntensity

  @ambientIntensity.setter
  def ambientIntensity(self, value):
    self._ambientIntensity = msgbuffers.validate_float(
      'ProxSensorDataRaw.ambientIntensity', value, 'f')

  @property
  def spadCount(self):
    "float_32 spadCount struct property."
    return self._spadCount

  @spadCount.setter
  def spadCount(self, value):
    self._spadCount = msgbuffers.validate_float(
      'ProxSensorDataRaw.spadCount', value, 'f')

  @property
  def timestamp_ms(self):
    "uint_32 timestamp_ms struct property."
    return self._timestamp_ms

  @timestamp_ms.setter
  def timestamp_ms(self, value):
    self._timestamp_ms = msgbuffers.validate_integer(
      'ProxSensorDataRaw.timestamp_ms', value, 0, 4294967295)

  @property
  def distance_mm(self):
    "uint_16 distance_mm struct property."
    return self._distance_mm

  @distance_mm.setter
  def distance_mm(self, value):
    self._distance_mm = msgbuffers.validate_integer(
      'ProxSensorDataRaw.distance_mm', value, 0, 65535)

  @property
  def rangeStatus(self):
    "Anki.Vector.RangeStatus rangeStatus struct property."
    return self._rangeStatus

  @rangeStatus.setter
  def rangeStatus(self, value):
    self._rangeStatus = msgbuffers.validate_integer(
      'ProxSensorDataRaw.rangeStatus', value, 0, 255)

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

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

  def __init__(self, signalIntensity=0.0, ambientIntensity=0.0, spadCount=0.0, timestamp_ms=0, distance_mm=0, rangeStatus=Anki.Vector.RangeStatus.RANGE_VALID, padding=0):
    self.signalIntensity = signalIntensity
    self.ambientIntensity = ambientIntensity
    self.spadCount = spadCount
    self.timestamp_ms = timestamp_ms
    self.distance_mm = distance_mm
    self.rangeStatus = rangeStatus
    self.padding = padding

  @classmethod
  def unpack(cls, buffer):
    "Reads a new ProxSensorDataRaw from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('ProxSensorDataRaw.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 ProxSensorDataRaw from the given BinaryReader."
    _signalIntensity = reader.read('f')
    _ambientIntensity = reader.read('f')
    _spadCount = reader.read('f')
    _timestamp_ms = reader.read('I')
    _distance_mm = reader.read('H')
    _rangeStatus = reader.read('B')
    _padding = reader.read('B')
    return cls(_signalIntensity, _ambientIntensity, _spadCount, _timestamp_ms, _distance_mm, _rangeStatus, _padding)

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

  def pack_to(self, writer):
    "Writes the current ProxSensorDataRaw to the given BinaryWriter."
    writer.write(self._signalIntensity, 'f')
    writer.write(self._ambientIntensity, 'f')
    writer.write(self._spadCount, 'f')
    writer.write(self._timestamp_ms, 'I')
    writer.write(self._distance_mm, 'H')
    writer.write(self._rangeStatus, 'B')
    writer.write(self._padding, 'B')

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._signalIntensity == other._signalIntensity and
        self._ambientIntensity == other._ambientIntensity and
        self._spadCount == other._spadCount and
        self._timestamp_ms == other._timestamp_ms and
        self._distance_mm == other._distance_mm and
        self._rangeStatus == other._rangeStatus 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._signalIntensity, 'f') +
      msgbuffers.size(self._ambientIntensity, 'f') +
      msgbuffers.size(self._spadCount, 'f') +
      msgbuffers.size(self._timestamp_ms, 'I') +
      msgbuffers.size(self._distance_mm, 'H') +
      msgbuffers.size(self._rangeStatus, 'B') +
      msgbuffers.size(self._padding, 'B'))

  def __str__(self):
    return '{type}(signalIntensity={signalIntensity}, ambientIntensity={ambientIntensity}, spadCount={spadCount}, timestamp_ms={timestamp_ms}, distance_mm={distance_mm}, rangeStatus={rangeStatus}, padding={padding})'.format(
      type=type(self).__name__,
      signalIntensity=self._signalIntensity,
      ambientIntensity=self._ambientIntensity,
      spadCount=self._spadCount,
      timestamp_ms=self._timestamp_ms,
      distance_mm=self._distance_mm,
      rangeStatus=self._rangeStatus,
      padding=self._padding)

  def __repr__(self):
    return '{type}(signalIntensity={signalIntensity}, ambientIntensity={ambientIntensity}, spadCount={spadCount}, timestamp_ms={timestamp_ms}, distance_mm={distance_mm}, rangeStatus={rangeStatus}, padding={padding})'.format(
      type=type(self).__name__,
      signalIntensity=repr(self._signalIntensity),
      ambientIntensity=repr(self._ambientIntensity),
      spadCount=repr(self._spadCount),
      timestamp_ms=repr(self._timestamp_ms),
      distance_mm=repr(self._distance_mm),
      rangeStatus=repr(self._rangeStatus),
      padding=repr(self._padding))

Anki.Vector.ProxSensorDataRaw = ProxSensorDataRaw
del ProxSensorDataRaw