Raise :exc:`NotImplementedError` in relation to a dialect for which a
    function hasn't been implemented (with a helpful error message).
977428
def fail_unknown_dialect(compiler: "SQLCompiler", task: str) -> None:
    
    raise NotImplementedError(
        "Don't know how to {task} on dialect {dialect!r}. "
        "(Check also: if you printed the SQL before it was bound to an "
        "engine, you will be trying to use a dialect like StrSQLCompiler, "
        "which could be a reason for failure.)".format(
            task=task,
            dialect=compiler.dialect
        )
    )
314430
def rule_function_not_found(self, fun=None):
        
        sfun = str(fun)
        self.cry('rule_function_not_found:' + sfun)

        def not_found(*a, **k):
            return(sfun + ':rule_function_not_found', k.keys())
        return not_found
1252668
def raise_error(self, e, exc_info=None):
        """"""
        if not exc_info:
            exc_info = sys.exc_info()

        if not isinstance(e, InterfaceError):
            # allow python's built in errors to filter up through
            # https://docs.python.org/2/library/exceptions.html
            #if not hasattr(exceptions, e.__class__.__name__):
            if not hasattr(builtins, e.__class__.__name__):
                e = self._create_error(e, exc_info)

        reraise(e.__class__, e, exc_info[2])
100851
function WrapperError(message, innerError) {
  // supports instantiating the object without the new keyword
  if (!(this instanceof WrapperError)) {
    return new WrapperError(message, innerError);
  }

  Error.call(this);
  Error.captureStackTrace(this, WrapperError);

  this.message = message;
  this.innerError = innerError;
}
842088
function PreconditionError(message, caller) {
  this.name = 'PreconditionError';
  this.message = message || 'Precondition failed';
  if (typeof Error.captureStackTrace === 'function') {
    Error.captureStackTrace(this, caller || PreconditionError);
  }
}
300591
def _subclass_must_implement(self, fn):
        
        m = "Missing function implementation in {}: {}".format(type(self), fn)
        return NotImplementedError(m)
410892
def is_free(self):
        
        raise NotImplementedError("%s not implemented for %s" % (self.is_free.__func__.__name__,
                                                                 self.__class__.__name__))
1333889
def pyError(self, type, value, traceback):
        '''
        '''
        sys.stderr.write("Exception thrown during EWrapper method dispatch:\n")
        print_exception(type, value, traceback)
954471
def missing(self):
        
        if self.type == BOOLEAN:
            Log.error("programmer error")
        return self.lang[MissingOp(self)]
298025
def p_error(p):
    

    if p is None:
        raise MOFParseError(msg='Unexpected end of file')

    msg = p.lexer.last_msg
    p.lexer.last_msg = None
    raise MOFParseError(parser_token=p, msg=msg)
97827
def convert_error(exc_src, exc_dest):
    

    def wrap(func):

        @wraps(func)
        def wrapper(*args, **kwargs):
            try:
                return func(*args, **kwargs)
            except exc_dest:
                raise
            except exc_src as err:
                reraise(exc_dest, err, sys.exc_info()[2])

        return wrapper

    return wrap
376724
def error(self, message, *args, **kwargs):
        
        kwargs.setdefault('extra', {}).setdefault('stack', True)
        return self.logger.error(message, *args, **kwargs)
520394
def _fail_with_undefined_error(self, *args, **kwargs):
        
        if self._undefined_hint is None:
            if self._undefined_obj is missing:
                hint = '%r is undefined' % self._undefined_name
            elif not isinstance(self._undefined_name, basestring):
                hint = '%s has no element %r' % (
                    object_type_repr(self._undefined_obj),
                    self._undefined_name
                )
            else:
                hint = '%r has no attribute %r' % (
                    object_type_repr(self._undefined_obj),
                    self._undefined_name
                )
        else:
            hint = self._undefined_hint
        raise self._undefined_exception(hint)
385740
def raises_not_implemented(self):
        
        if not self.exc:
            return False
        for name in self.exc._get_name_nodes():
            if name.name == "NotImplementedError":
                return True
        return False
1201309
def _raise_error_if_container_is_missing_an_utterance(self):
        
        expected_keys = frozenset(self.utt_ids)

        for cnt in self.containers:
            keys = set(cnt.keys())

            if not keys.issuperset(expected_keys):
                raise ValueError('Container is missing data for some utterances!')
168701
def on_view_not_found(
            self,
            environ: Dict[str, Any],
            start_response: Callable) -> Iterable[bytes]:  # pragma: nocover
        
        raise NotImplementedError()
533650
def RaiseIfNotErrorSuccess(result, func = None, arguments = ()):
    
    if result != ERROR_SUCCESS:
        raise ctypes.WinError(result)
    return result