"""
Autogenerated python message buffer code.
Source: clad/cloud/logcollector.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/cloud/logcollector.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.LogCollector = msgbuffers.Namespace()

class LogCollectorError(object):
  "Automatically-generated uint_8 enumeration."
  ErrorConnecting = 0

Anki.Vector.LogCollector.LogCollectorError = LogCollectorError
del LogCollectorError


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

  __slots__ = (
    '_logUrl', # string[uint_16]
  )

  @property
  def logUrl(self):
    "string[uint_16] logUrl struct property."
    return self._logUrl

  @logUrl.setter
  def logUrl(self, value):
    self._logUrl = msgbuffers.validate_string(
      'UploadResponse.logUrl', value, 65535)

  def __init__(self, logUrl=''):
    self.logUrl = logUrl

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

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

  def pack_to(self, writer):
    "Writes the current UploadResponse to the given BinaryWriter."
    writer.write_string(self._logUrl, 'H')

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

  def __str__(self):
    return '{type}(logUrl={logUrl})'.format(
      type=type(self).__name__,
      logUrl=msgbuffers.shorten_string(self._logUrl))

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

Anki.Vector.LogCollector.UploadResponse = UploadResponse
del UploadResponse


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

  __slots__ = (
    '_logFileName', # string[uint_16]
  )

  @property
  def logFileName(self):
    "string[uint_16] logFileName struct property."
    return self._logFileName

  @logFileName.setter
  def logFileName(self, value):
    self._logFileName = msgbuffers.validate_string(
      'UploadRequest.logFileName', value, 65535)

  def __init__(self, logFileName=''):
    self.logFileName = logFileName

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

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

  def pack_to(self, writer):
    "Writes the current UploadRequest to the given BinaryWriter."
    writer.write_string(self._logFileName, 'H')

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

  def __str__(self):
    return '{type}(logFileName={logFileName})'.format(
      type=type(self).__name__,
      logFileName=msgbuffers.shorten_string(self._logFileName))

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

Anki.Vector.LogCollector.UploadRequest = UploadRequest
del UploadRequest


class LogCollectorRequest(object):
  "Generated message-passing union."

  __slots__ = ('_tag', '_data')

  class Tag(object):
    "The type indicator for this union."
    upload = 0 # Anki.Vector.LogCollector.UploadRequest

  @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 upload(self):
    "Anki.Vector.LogCollector.UploadRequest upload union property."
    msgbuffers.safety_check_tag('upload', self._tag, self.Tag.upload, self._tags_by_value)
    return self._data

  @upload.setter
  def upload(self, value):
    self._data = msgbuffers.validate_object(
      'LogCollectorRequest.upload', value, Anki.Vector.LogCollector.UploadRequest)
    self._tag = self.Tag.upload

  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 LogCollectorRequest from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('LogCollectorRequest.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 LogCollectorRequest 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('LogCollectorRequest attempted to unpack unknown tag {tag}.'.format(tag=tag))

  def pack(self):
    "Writes the current LogCollectorRequest, 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 LogCollectorRequest.')

  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 < 1:
      return self._tag_size_methods[self._tag](self._data)
    else:
      return 1

  def __str__(self):
    if 0 <= self._tag < 1:
      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 < 1:
      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(
    upload=0,
  )

  _tags_by_value = dict()
  _tags_by_value[0] = 'upload'
  

  _tag_unpack_methods = dict()
  _tag_unpack_methods[0] = lambda reader: reader.read_object(Anki.Vector.LogCollector.UploadRequest.unpack_from)
  

  _tag_pack_methods = dict()
  _tag_pack_methods[0] = lambda writer, value: writer.write_object(value)
  

  _tag_size_methods = dict()
  _tag_size_methods[0] = lambda value: msgbuffers.size_object(value)
  

  _type_by_tag_value = dict()
  _type_by_tag_value[0] = lambda : Anki.Vector.LogCollector.UploadRequest
  

Anki.Vector.LogCollector.LogCollectorRequest = LogCollectorRequest
del LogCollectorRequest


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

  __slots__ = (
    '_err', # Anki.Vector.LogCollector.LogCollectorError
  )

  @property
  def err(self):
    "Anki.Vector.LogCollector.LogCollectorError err struct property."
    return self._err

  @err.setter
  def err(self, value):
    self._err = msgbuffers.validate_integer(
      'LogCollectorErrorResponse.err', value, 0, 255)

  def __init__(self, err=Anki.Vector.LogCollector.LogCollectorError.ErrorConnecting):
    self.err = err

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

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

  def pack_to(self, writer):
    "Writes the current LogCollectorErrorResponse to the given BinaryWriter."
    writer.write(self._err, 'B')

  def __eq__(self, other):
    if type(self) is type(other):
      return self._err == other._err
    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._err, 'B'))

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

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

Anki.Vector.LogCollector.LogCollectorErrorResponse = LogCollectorErrorResponse
del LogCollectorErrorResponse


class LogCollectorResponse(object):
  "Generated message-passing union."

  __slots__ = ('_tag', '_data')

  class Tag(object):
    "The type indicator for this union."
    upload = 0 # Anki.Vector.LogCollector.UploadResponse
    err    = 1 # Anki.Vector.LogCollector.LogCollectorErrorResponse

  @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 upload(self):
    "Anki.Vector.LogCollector.UploadResponse upload union property."
    msgbuffers.safety_check_tag('upload', self._tag, self.Tag.upload, self._tags_by_value)
    return self._data

  @upload.setter
  def upload(self, value):
    self._data = msgbuffers.validate_object(
      'LogCollectorResponse.upload', value, Anki.Vector.LogCollector.UploadResponse)
    self._tag = self.Tag.upload

  @property
  def err(self):
    "Anki.Vector.LogCollector.LogCollectorErrorResponse err union property."
    msgbuffers.safety_check_tag('err', self._tag, self.Tag.err, self._tags_by_value)
    return self._data

  @err.setter
  def err(self, value):
    self._data = msgbuffers.validate_object(
      'LogCollectorResponse.err', value, Anki.Vector.LogCollector.LogCollectorErrorResponse)
    self._tag = self.Tag.err

  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 LogCollectorResponse from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('LogCollectorResponse.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 LogCollectorResponse 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('LogCollectorResponse attempted to unpack unknown tag {tag}.'.format(tag=tag))

  def pack(self):
    "Writes the current LogCollectorResponse, 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 LogCollectorResponse.')

  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 < 2:
      return self._tag_size_methods[self._tag](self._data)
    else:
      return 1

  def __str__(self):
    if 0 <= self._tag < 2:
      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 < 2:
      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(
    upload=0,
    err=1,
  )

  _tags_by_value = dict()
  _tags_by_value[0] = 'upload'
  _tags_by_value[1] = 'err'
  

  _tag_unpack_methods = dict()
  _tag_unpack_methods[0] = lambda reader: reader.read_object(Anki.Vector.LogCollector.UploadResponse.unpack_from)
  _tag_unpack_methods[1] = lambda reader: reader.read_object(Anki.Vector.LogCollector.LogCollectorErrorResponse.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_size_methods = dict()
  _tag_size_methods[0] = lambda value: msgbuffers.size_object(value)
  _tag_size_methods[1] = lambda value: msgbuffers.size_object(value)
  

  _type_by_tag_value = dict()
  _type_by_tag_value[0] = lambda : Anki.Vector.LogCollector.UploadResponse
  _type_by_tag_value[1] = lambda : Anki.Vector.LogCollector.LogCollectorErrorResponse
  

Anki.Vector.LogCollector.LogCollectorResponse = LogCollectorResponse
del LogCollectorResponse