code: def _validate( # pylint: disable=too-many-arguments
          cls,
          sign,
          integer_part,
          non_repeating_part,
          repeating_part,
          base
      ):
          
          if any(x < 0 or x >= base for x in integer_part):
              return BasesValueError(
                 integer_part,
                 "integer_part",
                 "values must be between 0 and %s" % base
              )
          if any(x < 0 or x >= base for x in non_repeating_part):
              return BasesValueError(
                 non_repeating_part,
                 "non_repeating_part",
                 "values must be between 0 and %s" % base
              )
          if any(x < 0 or x >= base for x in repeating_part):
              return BasesValueError(
                 repeating_part,
                 "repeating_part",
                 "values must be between 0 and %s" % base
              )
          if base < 2:
              return BasesValueError(base, "base", "must be at least 2")
  
          if sign not in (-1, 0, 1) or sign is True or sign is False:
              return BasesValueError(
                 sign,
                 "sign",
                 "must be an int between -1 and 1"
              )
  
          return None
docs: Check if radix is valid.
  
          :param int sign: -1, 0, or 1 as appropriate
          :param integer_part: the part on the left side of the radix
          :type integer_part: list of int
          :param non_repeating_part: non repeating part on left side
          :type non_repeating_part: list of int
          :param repeating_part: repeating part
          :type repeating_part: list of int
          :param int base: base of the radix, must be at least 2
  
          :returns: BasesValueError if invalid values
          :rtype: BasesValueError or NoneType
  
          Complexity: O(len(integer_part + non_repeating_part + repeating_part))