text: #    _____           ______  _____ 
  #  / ____/    /\    |  ____ |  __ \
  # | |        /  \   | |__   | |__) | Caer - Modern Computer Vision
  # | |       / /\ \  |  __|  |  _  /  Languages: Python, C, C++
  # | |___   / ____ \ | |____ | | \ \  http://github.com/jasmcaus/caer
  #  \_____\/_/    \_ \______ |_|  \_
  
  # Licensed under the MIT License <http://opensource.org/licenses/MIT>
  # SPDX-License-Identifier: MIT
  # Copyright (c) 2020-21 The Caer Authors <http://github.com/jasmcaus>
  
  
  """
  Global Caer exception and warning classes.
  """
  
  import operator
  
  NON_FIELD_ERRORS = '__all__'
  
  class ValidationError(Exception):
      """An error while validating data."""
      def __init__(self, message, code=None, params=None):
          """
          The `message` argument can be a single error, a list of errors, or a
          dictionary that maps field names to lists of errors. What we define as
          an "error" can be either a simple string or an instance of
          ValidationError with its message attribute set, and what we define as
          list or dictionary can be an actual `list` or `dict` or an instance
          of ValidationError with its `error_list` or `error_dict` attribute set.
          """
          super().__init__(message, code, params)
  
          if isinstance(message, ValidationError):
              if hasattr(message, 'error_dict'):
                  message = message.error_dict
              elif not hasattr(message, 'message'):
                  message = message.error_list
              else:
                  message, code, params = message.message, message.code, message.params
  
          if isinstance(message, dict):
              self.error_dict = {}
              for field, messages in message.items():
                  if not isinstance(messages, ValidationError):
                      messages = ValidationError(messages)
                  self.error_dict[field] = messages.error_list
  
          elif isinstance(message, list):
              self.error_list = []
              for message in message:
                  # Normalize plain strings to instances of ValidationError.
                  if not isinstance(message, ValidationError):
                      message = ValidationError(message)
                  if hasattr(message, 'error_dict'):
                      self.error_list.extend(sum(message.error_dict.values(), []))
                  else:
                      self.error_list.extend(message.error_list)
  
          else:
              self.message = message
              self.code = code
              self.params = params
              self.error_list = [self]
  
      @property
      def message_dict(self):
          # Trigger an AttributeError if this ValidationError
          # doesn't have an error_dict.
          getattr(self, 'error_dict')
  
          return dict(self)
  
      @property
      def messages(self):
          if hasattr(self, 'error_dict'):
              return sum(dict(self).values(), [])
          return list(self)
  
      def update_error_dict(self, error_dict):
          if hasattr(self, 'error_dict'):
              for field, error_list in self.error_dict.items():
                  error_dict.setdefault(field, []).extend(error_list)
          else:
              error_dict.setdefault(NON_FIELD_ERRORS, []).extend(self.error_list)
          return error_dict
  
      def __iter__(self):
          if hasattr(self, 'error_dict'):
              for field, errors in self.error_dict.items():
                  yield field, list(ValidationError(errors))
          else:
              for error in self.error_list:
                  message = error.message
                  if error.params:
                      message %= error.params
                  yield str(message)
  
      def __str__(self):
          if hasattr(self, 'error_dict'):
              return repr(dict(self))
          return repr(list(self))
  
      def __repr__(self):
          return 'ValidationError(%s)' % self
  
      def __eq__(self, other):
          if not isinstance(other, ValidationError):
              return NotImplemented
          return hash(self) == hash(other)
  
      def __hash__(self):
          if hasattr(self, 'message'):
              return hash((
                  self.message,
                  self.code,
                  make_hashable(self.params),
              ))
          if hasattr(self, 'error_dict'):
              return hash(make_hashable(self.error_dict))
          return hash(tuple(sorted(self.error_list, key=operator.attrgetter('message'))))
  
  
  def make_hashable(value):
      """
      Attempt to make value hashable or raise a TypeError if it fails.
      The returned value should generate the same hash for equal values.
      """
      if isinstance(value, dict):
          return tuple([
              (key, make_hashable(nested_value))
              for key, nested_value in sorted(value.items())
          ])
      # Try hash to avoid converting a hashable iterable (e.g. string, frozenset)
      # to a tuple.
      try:
          hash(value)
      except TypeError:
          if is_iterable(value):
              return tuple(map(make_hashable, value))
          # Non-hashable, non-iterable.
          raise
      return value
  
  
  def is_iterable(x):
      "An implementation independent way of checking for iterables"
      try:
          iter(x)
      except TypeError:
          return False
      else:
          return True