python-presage 0.8.7-1 / usr / share / pyshared / presage.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.0.4
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.



from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_presage', [dirname(__file__)])
        except ImportError:
            import _presage
            return _presage
        if fp is not None:
            try:
                _mod = imp.load_module('_presage', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _presage = swig_import_helper()
    del swig_import_helper
else:
    import _presage
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

def _swig_setattr(self,class_type,name,value):
    return _swig_setattr_nondynamic(self,class_type,name,value,0)

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

def _swig_repr(self):
    try: strthis = "proxy of " + self.this.__repr__()
    except: strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


try:
    import weakref
    weakref_proxy = weakref.proxy
except:
    weakref_proxy = lambda x: x


class SwigPyIterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _presage.delete_SwigPyIterator
    __del__ = lambda self : None;
    def value(self): return _presage.SwigPyIterator_value(self)
    def incr(self, n = 1): return _presage.SwigPyIterator_incr(self, n)
    def decr(self, n = 1): return _presage.SwigPyIterator_decr(self, n)
    def distance(self, *args): return _presage.SwigPyIterator_distance(self, *args)
    def equal(self, *args): return _presage.SwigPyIterator_equal(self, *args)
    def copy(self): return _presage.SwigPyIterator_copy(self)
    def next(self): return _presage.SwigPyIterator_next(self)
    def __next__(self): return _presage.SwigPyIterator___next__(self)
    def previous(self): return _presage.SwigPyIterator_previous(self)
    def advance(self, *args): return _presage.SwigPyIterator_advance(self, *args)
    def __eq__(self, *args): return _presage.SwigPyIterator___eq__(self, *args)
    def __ne__(self, *args): return _presage.SwigPyIterator___ne__(self, *args)
    def __iadd__(self, *args): return _presage.SwigPyIterator___iadd__(self, *args)
    def __isub__(self, *args): return _presage.SwigPyIterator___isub__(self, *args)
    def __add__(self, *args): return _presage.SwigPyIterator___add__(self, *args)
    def __sub__(self, *args): return _presage.SwigPyIterator___sub__(self, *args)
    def __iter__(self): return self
SwigPyIterator_swigregister = _presage.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)


def presage_new(*args):
  return _presage.presage_new(*args)
presage_new = _presage.presage_new

def presage_new_with_config(*args):
  return _presage.presage_new_with_config(*args)
presage_new_with_config = _presage.presage_new_with_config

def presage_free(*args):
  return _presage.presage_free(*args)
presage_free = _presage.presage_free

def presage_free_string(*args):
  return _presage.presage_free_string(*args)
presage_free_string = _presage.presage_free_string

def presage_free_string_array(*args):
  return _presage.presage_free_string_array(*args)
presage_free_string_array = _presage.presage_free_string_array

def presage_predict(*args):
  return _presage.presage_predict(*args)
presage_predict = _presage.presage_predict

def presage_completion(*args):
  return _presage.presage_completion(*args)
presage_completion = _presage.presage_completion

def presage_context(*args):
  return _presage.presage_context(*args)
presage_context = _presage.presage_context

def presage_context_change(*args):
  return _presage.presage_context_change(*args)
presage_context_change = _presage.presage_context_change

def presage_prefix(*args):
  return _presage.presage_prefix(*args)
presage_prefix = _presage.presage_prefix

def presage_config(*args):
  return _presage.presage_config(*args)
presage_config = _presage.presage_config

def presage_config_set(*args):
  return _presage.presage_config_set(*args)
presage_config_set = _presage.presage_config_set

def presage_save_config(*args):
  return _presage.presage_save_config(*args)
presage_save_config = _presage.presage_save_config
class Presage(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Presage, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Presage, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _presage.new_Presage(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _presage.delete_Presage
    __del__ = lambda self : None;
    def predict(self, *args): return _presage.Presage_predict(self, *args)
    def callback(self, *args): return _presage.Presage_callback(self, *args)
    def completion(self, *args): return _presage.Presage_completion(self, *args)
    def context(self): return _presage.Presage_context(self)
    def context_change(self): return _presage.Presage_context_change(self)
    def prefix(self): return _presage.Presage_prefix(self)
    def config(self, *args): return _presage.Presage_config(self, *args)
    def save_config(self): return _presage.Presage_save_config(self)
Presage_swigregister = _presage.Presage_swigregister
Presage_swigregister(Presage)

PRESAGE_OK = _presage.PRESAGE_OK
PRESAGE_ERROR = _presage.PRESAGE_ERROR
PRESAGE_TOKEN_PREFIX_MISMATCH_ERROR = _presage.PRESAGE_TOKEN_PREFIX_MISMATCH_ERROR
PRESAGE_SMOOTHED_NGRAM_PREDICTOR_LEARN_ERROR = _presage.PRESAGE_SMOOTHED_NGRAM_PREDICTOR_LEARN_ERROR
PRESAGE_CONFIG_VARIABLE_ERROR = _presage.PRESAGE_CONFIG_VARIABLE_ERROR
PRESAGE_INVALID_CALLBACK_ERROR = _presage.PRESAGE_INVALID_CALLBACK_ERROR
PRESAGE_INVALID_SUGGESTION_ERROR = _presage.PRESAGE_INVALID_SUGGESTION_ERROR
PRESAGE_INIT_PREDICTOR_ERROR = _presage.PRESAGE_INIT_PREDICTOR_ERROR
PRESAGE_SQLITE_OPEN_DATABASE_ERROR = _presage.PRESAGE_SQLITE_OPEN_DATABASE_ERROR
PRESAGE_SQLITE_EXECUTE_SQL_ERROR = _presage.PRESAGE_SQLITE_EXECUTE_SQL_ERROR
class PresageException(Exception):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PresageException, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PresageException, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _presage.new_PresageException(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _presage.delete_PresageException
    __del__ = lambda self : None;
    def what(self): return _presage.PresageException_what(self)
    def code(self): return _presage.PresageException_code(self)
PresageException_swigregister = _presage.PresageException_swigregister
PresageException_swigregister(PresageException)

class PresageCallback(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PresageCallback, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PresageCallback, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _presage.delete_PresageCallback
    __del__ = lambda self : None;
    def get_past_stream(self): return _presage.PresageCallback_get_past_stream(self)
    def get_future_stream(self): return _presage.PresageCallback_get_future_stream(self)
    def __init__(self): 
        if self.__class__ == PresageCallback:
            _self = None
        else:
            _self = self
        this = _presage.new_PresageCallback(_self, )
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _presage.disown_PresageCallback(self)
        return weakref_proxy(self)
PresageCallback_swigregister = _presage.PresageCallback_swigregister
PresageCallback_swigregister(PresageCallback)

class LegacyPresageCallback(PresageCallback):
    __swig_setmethods__ = {}
    for _s in [PresageCallback]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LegacyPresageCallback, name, value)
    __swig_getmethods__ = {}
    for _s in [PresageCallback]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, LegacyPresageCallback, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _presage.new_LegacyPresageCallback()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _presage.delete_LegacyPresageCallback
    __del__ = lambda self : None;
    def get_past_stream(self): return _presage.LegacyPresageCallback_get_past_stream(self)
    def get_future_stream(self): return _presage.LegacyPresageCallback_get_future_stream(self)
    def update(self, *args): return _presage.LegacyPresageCallback_update(self, *args)
LegacyPresageCallback_swigregister = _presage.LegacyPresageCallback_swigregister
LegacyPresageCallback_swigregister(LegacyPresageCallback)

# This file is compatible with both classic and new-style classes.