original_docstring: 
          For internal use.  Compile a specialized version of the function
          for the given *args* and *kws*, and return the resulting callable.
          
docstring: For internal use.  Compile a specialized version of the function
  for the given *args* and *kws*, and return the resulting callable.
docstring_tokens: For internal use . Compile a specialized version of the function for the given * args * and * kws * and return the resulting callable .
code: def _compile_for_args(self, *args, **kws):
          """
          For internal use.  Compile a specialized version of the function
          for the given *args* and *kws*, and return the resulting callable.
          """
          assert not kws
  
          def error_rewrite(e, issue_type):
              """
              Rewrite and raise Exception `e` with help supplied based on the
              specified issue_type.
              """
              if config.SHOW_HELP:
                  help_msg = errors.error_extras[issue_type]
                  e.patch_message('\n'.join((str(e).rstrip(), help_msg)))
              if config.FULL_TRACEBACKS:
                  raise e
              else:
                  reraise(type(e), e, None)
  
          argtypes = []
          for a in args:
              if isinstance(a, OmittedArg):
                  argtypes.append(types.Omitted(a.value))
              else:
                  argtypes.append(self.typeof_pyval(a))
          try:
              return self.compile(tuple(argtypes))
          except errors.ForceLiteralArg as e:
              # Received request for compiler re-entry with the list of arguments
              # indicated by e.requested_args.
              # First, check if any of these args are already Literal-ized
              already_lit_pos = [i for i in e.requested_args
                                 if isinstance(args[i], types.Literal)]
              if already_lit_pos:
                  # Abort compilation if any argument is already a Literal.
                  # Letting this continue will cause infinite compilation loop.
                  m = ("Repeated literal typing request.\n"
                       "{}.\n"
                       "This is likely caused by an error in typing. "
                       "Please see nested and suppressed exceptions.")
                  info = ', '.join('Arg #{} is {}'.format(i, args[i])
                                   for i in  sorted(already_lit_pos))
                  raise errors.CompilerError(m.format(info))
              # Convert requested arguments into a Literal.
              args = [(types.literal
                       if i in e.requested_args
                       else lambda x: x)(args[i])
                      for i, v in enumerate(args)]
              # Re-enter compilation with the Literal-ized arguments
              return self._compile_for_args(*args)
  
          except errors.TypingError as e:
              # Intercept typing error that may be due to an argument
              # that failed inferencing as a Numba type
              failed_args = []
              for i, arg in enumerate(args):
                  val = arg.value if isinstance(arg, OmittedArg) else arg
                  try:
                      tp = typeof(val, Purpose.argument)
                  except ValueError as typeof_exc:
                      failed_args.append((i, str(typeof_exc)))
                  else:
                      if tp is None:
                          failed_args.append(
                              (i,
                               "cannot determine Numba type of value %r" % (val,)))
              if failed_args:
                  # Patch error message to ease debugging
                  msg = str(e).rstrip() + (
                      "\n\nThis error may have been caused by the following argument(s):\n%s\n"
                      % "\n".join("- argument %d: %s" % (i, err)
                                  for i, err in failed_args))
                  e.patch_message(msg)
  
              error_rewrite(e, 'typing')
          except errors.UnsupportedError as e:
              # Something unsupported is present in the user code, add help info
              error_rewrite(e, 'unsupported_error')
          except (errors.NotDefinedError, errors.RedefinedError,
                  errors.VerificationError) as e:
              # These errors are probably from an issue with either the code supplied
              # being syntactically or otherwise invalid
              error_rewrite(e, 'interpreter')
          except errors.ConstantInferenceError as e:
              # this is from trying to infer something as constant when it isn't
              # or isn't supported as a constant
              error_rewrite(e, 'constant_inference')
          except Exception as e:
              if config.SHOW_HELP:
                  if hasattr(e, 'patch_message'):
                      help_msg = errors.error_extras['reportable']
                      e.patch_message('\n'.join((str(e).rstrip(), help_msg)))
              # ignore the FULL_TRACEBACKS config, this needs reporting!
              raise e
code_tokens: def _compile_for_args ( self , * args , ** kws ) : assert not kws def error_rewrite ( e , issue_type ) : """
              Rewrite and raise Exception `e` with help supplied based on the
              specified issue_type.
              """ if config . SHOW_HELP : help_msg = errors . error_extras [ issue_type ] e . patch_message ( '\n' . join ( ( str ( e ) . rstrip ( ) , help_msg ) ) ) if config . FULL_TRACEBACKS : raise e else : reraise ( type ( e ) , e , None ) argtypes = [ ] for a in args : if isinstance ( a , OmittedArg ) : argtypes . append ( types . Omitted ( a . value ) ) else : argtypes . append ( self . typeof_pyval ( a ) ) try : return self . compile ( tuple ( argtypes ) ) except errors . ForceLiteralArg as e : already_lit_pos = [ i for i in e . requested_args if isinstance ( args [ i ] , types . Literal ) ] if already_lit_pos : m = ( "Repeated literal typing request.\n" "{}.\n" "This is likely caused by an error in typing. " "Please see nested and suppressed exceptions." ) info = ', ' . join ( 'Arg #{} is {}' . format ( i , args [ i ] ) for i in sorted ( already_lit_pos ) ) raise errors . CompilerError ( m . format ( info ) ) args = [ ( types . literal if i in e . requested_args else lambda x : x ) ( args [ i ] ) for i , v in enumerate ( args ) ] return self . _compile_for_args ( * args ) except errors . TypingError as e : failed_args = [ ] for i , arg in enumerate ( args ) : val = arg . value if isinstance ( arg , OmittedArg ) else arg try : tp = typeof ( val , Purpose . argument ) except ValueError as typeof_exc : failed_args . append ( ( i , str ( typeof_exc ) ) ) else : if tp is None : failed_args . append ( ( i , "cannot determine Numba type of value %r" % ( val , ) ) ) if failed_args : msg = str ( e ) . rstrip ( ) + ( "\n\nThis error may have been caused by the following argument(s):\n%s\n" % "\n" . join ( "- argument %d: %s" % ( i , err ) for i , err in failed_args ) ) e . patch_message ( msg ) error_rewrite ( e , 'typing' ) except errors . UnsupportedError as e : error_rewrite ( e , 'unsupported_error' ) except ( errors . NotDefinedError , errors . RedefinedError , errors . VerificationError ) as e : error_rewrite ( e , 'interpreter' ) except errors . ConstantInferenceError as e : error_rewrite ( e , 'constant_inference' ) except Exception as e : if config . SHOW_HELP : if hasattr ( e , 'patch_message' ) : help_msg = errors . error_extras [ 'reportable' ] e . patch_message ( '\n' . join ( ( str ( e ) . rstrip ( ) , help_msg ) ) ) raise e
short_docstring: For internal use.
short_docstring_tokens: For internal use .
comment: """
          For internal use.  Compile a specialized version of the function
          for the given *args* and *kws*, and return the resulting callable.
          """$SEP$"""
              Rewrite and raise Exception `e` with help supplied based on the
              specified issue_type.
              """$SEP$# Received request for compiler re-entry with the list of arguments$SEP$# indicated by e.requested_args.$SEP$# First, check if any of these args are already Literal-ized$SEP$# Abort compilation if any argument is already a Literal.$SEP$# Letting this continue will cause infinite compilation loop.$SEP$# Convert requested arguments into a Literal.$SEP$# Re-enter compilation with the Literal-ized arguments$SEP$# Intercept typing error that may be due to an argument$SEP$# that failed inferencing as a Numba type$SEP$# Patch error message to ease debugging$SEP$# Something unsupported is present in the user code, add help info$SEP$# These errors are probably from an issue with either the code supplied$SEP$# being syntactically or otherwise invalid$SEP$# this is from trying to infer something as constant when it isn't$SEP$# or isn't supported as a constant$SEP$# ignore the FULL_TRACEBACKS config, this needs reporting!