# automatically generated by the FlatBuffers compiler, do not modify

# namespace: libtextclassifier3

import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()

class Model(object):
    __slots__ = ['_tab']

    @classmethod
    def GetRootAsModel(cls, buf, offset):
        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
        x = Model()
        x.Init(buf, n + offset)
        return x

    @classmethod
    def ModelBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x43\x32\x20", size_prefixed=size_prefixed)

    # Model
    def Init(self, buf, pos):
        self._tab = flatbuffers.table.Table(buf, pos)

    # Model
    def Locales(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
        if o != 0:
            return self._tab.String(o + self._tab.Pos)
        return None

    # Model
    def Version(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
        return 0

    # Model
    def Name(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
        if o != 0:
            return self._tab.String(o + self._tab.Pos)
        return None

    # Model
    def SelectionFeatureOptions(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            from libtextclassifier3.FeatureProcessorOptions import FeatureProcessorOptions
            obj = FeatureProcessorOptions()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # Model
    def ClassificationFeatureOptions(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            from libtextclassifier3.FeatureProcessorOptions import FeatureProcessorOptions
            obj = FeatureProcessorOptions()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # Model
    def SelectionModel(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
        if o != 0:
            a = self._tab.Vector(o)
            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
        return 0

    # Model
    def SelectionModelAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
        if o != 0:
            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
        return 0

    # Model
    def SelectionModelLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0

    # Model
    def SelectionModelIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
        return o == 0

    # Model
    def ClassificationModel(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
        if o != 0:
            a = self._tab.Vector(o)
            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
        return 0

    # Model
    def ClassificationModelAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
        if o != 0:
            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
        return 0

    # Model
    def ClassificationModelLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0

    # Model
    def ClassificationModelIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
        return o == 0

    # Model
    def EmbeddingModel(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
        if o != 0:
            a = self._tab.Vector(o)
            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
        return 0

    # Model
    def EmbeddingModelAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
        if o != 0:
            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
        return 0

    # Model
    def EmbeddingModelLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0

    # Model
    def EmbeddingModelIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
        return o == 0

    # Model
    def SelectionOptions(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            from libtextclassifier3.SelectionModelOptions import SelectionModelOptions
            obj = SelectionModelOptions()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # Model
    def ClassificationOptions(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            from libtextclassifier3.ClassificationModelOptions import ClassificationModelOptions
            obj = ClassificationModelOptions()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # Model
    def RegexModel(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            from libtextclassifier3.RegexModel import RegexModel
            obj = RegexModel()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # Model
    def DatetimeModel(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            from libtextclassifier3.DatetimeModel import DatetimeModel
            obj = DatetimeModel()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # Model
    def TriggeringOptions(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            from libtextclassifier3.ModelTriggeringOptions import ModelTriggeringOptions
            obj = ModelTriggeringOptions()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # Model
    def EnabledModes(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
        return 7

    # Model
    def SnapWhitespaceSelections(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
        if o != 0:
            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
        return True

    # Model
    def OutputOptions(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            from libtextclassifier3.OutputOptions import OutputOptions
            obj = OutputOptions()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # Model
    def AndroidIntentOptions(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            from libtextclassifier3.AndroidIntentFactoryOptions import AndroidIntentFactoryOptions
            obj = AndroidIntentFactoryOptions()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # Model
    def IntentOptions(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            from libtextclassifier3.IntentFactoryModel import IntentFactoryModel
            obj = IntentFactoryModel()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # Model
    def Resources(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            from libtextclassifier3.ResourcePool import ResourcePool
            obj = ResourcePool()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # Model
    def EntityDataSchema(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
        if o != 0:
            a = self._tab.Vector(o)
            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
        return 0

    # Model
    def EntityDataSchemaAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
        if o != 0:
            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
        return 0

    # Model
    def EntityDataSchemaLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0

    # Model
    def EntityDataSchemaIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
        return o == 0

    # Model
    def NumberAnnotatorOptions(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(44))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            from libtextclassifier3.NumberAnnotatorOptions import NumberAnnotatorOptions
            obj = NumberAnnotatorOptions()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # Model
    def DurationAnnotatorOptions(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(46))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            from libtextclassifier3.DurationAnnotatorOptions import DurationAnnotatorOptions
            obj = DurationAnnotatorOptions()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # Model
    def TriggeringLocales(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(48))
        if o != 0:
            return self._tab.String(o + self._tab.Pos)
        return None

    # Model
    def EmbeddingPruningMask(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(50))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            from libtextclassifier3.Model_.EmbeddingPruningMask import EmbeddingPruningMask
            obj = EmbeddingPruningMask()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # Model
    def ContactAnnotatorOptions(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(54))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            from libtextclassifier3.ContactAnnotatorOptions import ContactAnnotatorOptions
            obj = ContactAnnotatorOptions()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # Model
    def MoneyParsingOptions(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(56))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            from libtextclassifier3.MoneyParsingOptions import MoneyParsingOptions
            obj = MoneyParsingOptions()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # Model
    def TranslateAnnotatorOptions(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(58))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            from libtextclassifier3.TranslateAnnotatorOptions import TranslateAnnotatorOptions
            obj = TranslateAnnotatorOptions()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # Model
    def GrammarModel(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            from libtextclassifier3.GrammarModel import GrammarModel
            obj = GrammarModel()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # Model
    def ConflictResolutionOptions(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            from libtextclassifier3.Model_.ConflictResolutionOptions import ConflictResolutionOptions
            obj = ConflictResolutionOptions()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # Model
    def ExperimentalModel(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            from libtextclassifier3.ExperimentalModel import ExperimentalModel
            obj = ExperimentalModel()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # Model
    def PodNerModel(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            from libtextclassifier3.PodNerModel import PodNerModel
            obj = PodNerModel()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # Model
    def VocabModel(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            from libtextclassifier3.VocabModel import VocabModel
            obj = VocabModel()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

def ModelStart(builder): builder.StartObject(33)
def ModelAddLocales(builder, locales): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(locales), 0)
def ModelAddVersion(builder, version): builder.PrependInt32Slot(1, version, 0)
def ModelAddName(builder, name): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
def ModelAddSelectionFeatureOptions(builder, selectionFeatureOptions): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(selectionFeatureOptions), 0)
def ModelAddClassificationFeatureOptions(builder, classificationFeatureOptions): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(classificationFeatureOptions), 0)
def ModelAddSelectionModel(builder, selectionModel): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(selectionModel), 0)
def ModelStartSelectionModelVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def ModelAddClassificationModel(builder, classificationModel): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(classificationModel), 0)
def ModelStartClassificationModelVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def ModelAddEmbeddingModel(builder, embeddingModel): builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(embeddingModel), 0)
def ModelStartEmbeddingModelVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def ModelAddSelectionOptions(builder, selectionOptions): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(selectionOptions), 0)
def ModelAddClassificationOptions(builder, classificationOptions): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(classificationOptions), 0)
def ModelAddRegexModel(builder, regexModel): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(regexModel), 0)
def ModelAddDatetimeModel(builder, datetimeModel): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(datetimeModel), 0)
def ModelAddTriggeringOptions(builder, triggeringOptions): builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(triggeringOptions), 0)
def ModelAddEnabledModes(builder, enabledModes): builder.PrependInt32Slot(13, enabledModes, 7)
def ModelAddSnapWhitespaceSelections(builder, snapWhitespaceSelections): builder.PrependBoolSlot(14, snapWhitespaceSelections, 1)
def ModelAddOutputOptions(builder, outputOptions): builder.PrependUOffsetTRelativeSlot(15, flatbuffers.number_types.UOffsetTFlags.py_type(outputOptions), 0)
def ModelAddAndroidIntentOptions(builder, androidIntentOptions): builder.PrependUOffsetTRelativeSlot(16, flatbuffers.number_types.UOffsetTFlags.py_type(androidIntentOptions), 0)
def ModelAddIntentOptions(builder, intentOptions): builder.PrependUOffsetTRelativeSlot(17, flatbuffers.number_types.UOffsetTFlags.py_type(intentOptions), 0)
def ModelAddResources(builder, resources): builder.PrependUOffsetTRelativeSlot(18, flatbuffers.number_types.UOffsetTFlags.py_type(resources), 0)
def ModelAddEntityDataSchema(builder, entityDataSchema): builder.PrependUOffsetTRelativeSlot(19, flatbuffers.number_types.UOffsetTFlags.py_type(entityDataSchema), 0)
def ModelStartEntityDataSchemaVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def ModelAddNumberAnnotatorOptions(builder, numberAnnotatorOptions): builder.PrependUOffsetTRelativeSlot(20, flatbuffers.number_types.UOffsetTFlags.py_type(numberAnnotatorOptions), 0)
def ModelAddDurationAnnotatorOptions(builder, durationAnnotatorOptions): builder.PrependUOffsetTRelativeSlot(21, flatbuffers.number_types.UOffsetTFlags.py_type(durationAnnotatorOptions), 0)
def ModelAddTriggeringLocales(builder, triggeringLocales): builder.PrependUOffsetTRelativeSlot(22, flatbuffers.number_types.UOffsetTFlags.py_type(triggeringLocales), 0)
def ModelAddEmbeddingPruningMask(builder, embeddingPruningMask): builder.PrependUOffsetTRelativeSlot(23, flatbuffers.number_types.UOffsetTFlags.py_type(embeddingPruningMask), 0)
def ModelAddContactAnnotatorOptions(builder, contactAnnotatorOptions): builder.PrependUOffsetTRelativeSlot(25, flatbuffers.number_types.UOffsetTFlags.py_type(contactAnnotatorOptions), 0)
def ModelAddMoneyParsingOptions(builder, moneyParsingOptions): builder.PrependUOffsetTRelativeSlot(26, flatbuffers.number_types.UOffsetTFlags.py_type(moneyParsingOptions), 0)
def ModelAddTranslateAnnotatorOptions(builder, translateAnnotatorOptions): builder.PrependUOffsetTRelativeSlot(27, flatbuffers.number_types.UOffsetTFlags.py_type(translateAnnotatorOptions), 0)
def ModelAddGrammarModel(builder, grammarModel): builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(grammarModel), 0)
def ModelAddConflictResolutionOptions(builder, conflictResolutionOptions): builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(conflictResolutionOptions), 0)
def ModelAddExperimentalModel(builder, experimentalModel): builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(experimentalModel), 0)
def ModelAddPodNerModel(builder, podNerModel): builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(podNerModel), 0)
def ModelAddVocabModel(builder, vocabModel): builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vocabModel), 0)
def ModelEnd(builder): return builder.EndObject()