# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.1.1
#
# 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 as _swig_python_version_info
# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _lttoolbox
else:
    import _lttoolbox

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


gm_clean = _lttoolbox.gm_clean
gm_unknown = _lttoolbox.gm_unknown
gm_all = _lttoolbox.gm_all
gm_tagged = _lttoolbox.gm_tagged
gm_tagged_nm = _lttoolbox.gm_tagged_nm
gm_carefulcase = _lttoolbox.gm_carefulcase
class FSTProcessor(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    XML_TEXT_NODE = _lttoolbox.FSTProcessor_XML_TEXT_NODE
    XML_COMMENT_NODE = _lttoolbox.FSTProcessor_XML_COMMENT_NODE
    XML_IGNORED_CHARS_ELEM = _lttoolbox.FSTProcessor_XML_IGNORED_CHARS_ELEM
    XML_RESTORE_CHAR_ELEM = _lttoolbox.FSTProcessor_XML_RESTORE_CHAR_ELEM
    XML_RESTORE_CHARS_ELEM = _lttoolbox.FSTProcessor_XML_RESTORE_CHARS_ELEM
    XML_VALUE_ATTR = _lttoolbox.FSTProcessor_XML_VALUE_ATTR
    XML_CHAR_ELEM = _lttoolbox.FSTProcessor_XML_CHAR_ELEM
    WBLANK_FINAL = _lttoolbox.FSTProcessor_WBLANK_FINAL

    def __init__(self):
        _lttoolbox.FSTProcessor_swiginit(self, _lttoolbox.new_FSTProcessor())

    def initAnalysis(self):
        return _lttoolbox.FSTProcessor_initAnalysis(self)

    def initTMAnalysis(self):
        return _lttoolbox.FSTProcessor_initTMAnalysis(self)

    def initSAO(self):
        return _lttoolbox.FSTProcessor_initSAO(self)

    def initGeneration(self):
        return _lttoolbox.FSTProcessor_initGeneration(self)

    def initPostgeneration(self):
        return _lttoolbox.FSTProcessor_initPostgeneration(self)

    def initTransliteration(self):
        return _lttoolbox.FSTProcessor_initTransliteration(self)

    def initBiltrans(self):
        return _lttoolbox.FSTProcessor_initBiltrans(self)

    def initDecomposition(self):
        return _lttoolbox.FSTProcessor_initDecomposition(self)

    def analysis(self, input, output):
        return _lttoolbox.FSTProcessor_analysis(self, input, output)

    def tm_analysis(self, input, output):
        return _lttoolbox.FSTProcessor_tm_analysis(self, input, output)

    def generation(self, input, output, mode=gm_unknown):
        return _lttoolbox.FSTProcessor_generation(self, input, output, mode)

    def postgeneration(self, input, output):
        return _lttoolbox.FSTProcessor_postgeneration(self, input, output)

    def intergeneration(self, input, output):
        return _lttoolbox.FSTProcessor_intergeneration(self, input, output)

    def transliteration(self, input, output):
        return _lttoolbox.FSTProcessor_transliteration(self, input, output)

    def biltrans(self, input_word, with_delim=True):
        return _lttoolbox.FSTProcessor_biltrans(self, input_word, with_delim)

    def biltransfull(self, input_word, with_delim=True):
        return _lttoolbox.FSTProcessor_biltransfull(self, input_word, with_delim)

    def bilingual(self, input, output, mode=gm_unknown):
        return _lttoolbox.FSTProcessor_bilingual(self, input, output, mode)

    def biltransWithQueue(self, input_word, with_delim=True):
        return _lttoolbox.FSTProcessor_biltransWithQueue(self, input_word, with_delim)

    def biltransWithoutQueue(self, input_word, with_delim=True):
        return _lttoolbox.FSTProcessor_biltransWithoutQueue(self, input_word, with_delim)

    def SAO(self, input, output):
        return _lttoolbox.FSTProcessor_SAO(self, input, output)

    def parseICX(self, file):
        return _lttoolbox.FSTProcessor_parseICX(self, file)

    def parseRCX(self, file):
        return _lttoolbox.FSTProcessor_parseRCX(self, file)

    def load(self, input):
        return _lttoolbox.FSTProcessor_load(self, input)

    def valid(self):
        return _lttoolbox.FSTProcessor_valid(self)

    def setCaseSensitiveMode(self, value):
        return _lttoolbox.FSTProcessor_setCaseSensitiveMode(self, value)

    def setDictionaryCaseMode(self, value):
        return _lttoolbox.FSTProcessor_setDictionaryCaseMode(self, value)

    def setBiltransSurfaceForms(self, value):
        return _lttoolbox.FSTProcessor_setBiltransSurfaceForms(self, value)

    def setBiltransSurfaceFormsKeep(self, value):
        return _lttoolbox.FSTProcessor_setBiltransSurfaceFormsKeep(self, value)

    def setIgnoredChars(self, value):
        return _lttoolbox.FSTProcessor_setIgnoredChars(self, value)

    def setRestoreChars(self, value):
        return _lttoolbox.FSTProcessor_setRestoreChars(self, value)

    def setNullFlush(self, value):
        return _lttoolbox.FSTProcessor_setNullFlush(self, value)

    def setUseDefaultIgnoredChars(self, value):
        return _lttoolbox.FSTProcessor_setUseDefaultIgnoredChars(self, value)

    def setDisplayWeightsMode(self, value):
        return _lttoolbox.FSTProcessor_setDisplayWeightsMode(self, value)

    def setMaxAnalysesValue(self, value):
        return _lttoolbox.FSTProcessor_setMaxAnalysesValue(self, value)

    def setMaxWeightClassesValue(self, value):
        return _lttoolbox.FSTProcessor_setMaxWeightClassesValue(self, value)

    def setCompoundMaxElements(self, value):
        return _lttoolbox.FSTProcessor_setCompoundMaxElements(self, value)

    def getNullFlush(self):
        return _lttoolbox.FSTProcessor_getNullFlush(self)

    def getDecompoundingMode(self):
        return _lttoolbox.FSTProcessor_getDecompoundingMode(self)
    __swig_destroy__ = _lttoolbox.delete_FSTProcessor

# Register FSTProcessor in _lttoolbox:
_lttoolbox.FSTProcessor_swigregister(FSTProcessor)
class LtLocale(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def tryToSetLocale():
        return _lttoolbox.LtLocale_tryToSetLocale()

    def __init__(self):
        _lttoolbox.LtLocale_swiginit(self, _lttoolbox.new_LtLocale())
    __swig_destroy__ = _lttoolbox.delete_LtLocale

# Register LtLocale in _lttoolbox:
_lttoolbox.LtLocale_swigregister(LtLocale)
class FST(FSTProcessor):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, dictionary_path):
        _lttoolbox.FST_swiginit(self, _lttoolbox.new_FST(dictionary_path))

    def lt_proc(self, argc, input_path, output_path):
        return _lttoolbox.FST_lt_proc(self, argc, input_path, output_path)
    __swig_destroy__ = _lttoolbox.delete_FST

# Register FST in _lttoolbox:
_lttoolbox.FST_swigregister(FST)

