Upload 51 files

19/libtextclassifier3/AnnotationUsecase.py

@@ -0,0 +1,8 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: libtextclassifier3
+
+class AnnotationUsecase(object):
+    ANNOTATION_USECASE_SMART = 0
+    ANNOTATION_USECASE_RAW = 1
+

19/libtextclassifier3/CapturingGroup.py

@@ -0,0 +1,80 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: libtextclassifier3
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class CapturingGroup(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsCapturingGroup(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = CapturingGroup()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def CapturingGroupBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x43\x32\x20", size_prefixed=size_prefixed)
+
+    # CapturingGroup
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # CapturingGroup
+    def ExtendSelection(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return True
+
+    # CapturingGroup
+    def EntityFieldPath(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from libtextclassifier3.FlatbufferFieldPath import FlatbufferFieldPath
+            obj = FlatbufferFieldPath()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # CapturingGroup
+    def SerializedEntityData(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
+
+    # CapturingGroup
+    def NormalizationOptions(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.NormalizationOptions import NormalizationOptions
+            obj = NormalizationOptions()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # CapturingGroup
+    def EntityData(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.EntityData import EntityData
+            obj = EntityData()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+def CapturingGroupStart(builder): builder.StartObject(5)
+def CapturingGroupAddExtendSelection(builder, extendSelection): builder.PrependBoolSlot(0, extendSelection, 1)
+def CapturingGroupAddEntityFieldPath(builder, entityFieldPath): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(entityFieldPath), 0)
+def CapturingGroupAddSerializedEntityData(builder, serializedEntityData): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(serializedEntityData), 0)
+def CapturingGroupAddNormalizationOptions(builder, normalizationOptions): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(normalizationOptions), 0)
+def CapturingGroupAddEntityData(builder, entityData): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(entityData), 0)
+def CapturingGroupEnd(builder): return builder.EndObject()

19/libtextclassifier3/ClassificationModelOptions.py

@@ -0,0 +1,60 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: libtextclassifier3
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class ClassificationModelOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsClassificationModelOptions(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = ClassificationModelOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def ClassificationModelOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x43\x32\x20", size_prefixed=size_prefixed)
+
+    # ClassificationModelOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # ClassificationModelOptions
+    def PhoneMinNumDigits(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 7
+
+    # ClassificationModelOptions
+    def PhoneMaxNumDigits(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 15
+
+    # ClassificationModelOptions
+    def AddressMinNumTokens(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # ClassificationModelOptions
+    def MaxNumTokens(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return -1
+
+def ClassificationModelOptionsStart(builder): builder.StartObject(4)
+def ClassificationModelOptionsAddPhoneMinNumDigits(builder, phoneMinNumDigits): builder.PrependInt32Slot(0, phoneMinNumDigits, 7)
+def ClassificationModelOptionsAddPhoneMaxNumDigits(builder, phoneMaxNumDigits): builder.PrependInt32Slot(1, phoneMaxNumDigits, 15)
+def ClassificationModelOptionsAddAddressMinNumTokens(builder, addressMinNumTokens): builder.PrependInt32Slot(2, addressMinNumTokens, 0)
+def ClassificationModelOptionsAddMaxNumTokens(builder, maxNumTokens): builder.PrependInt32Slot(3, maxNumTokens, -1)
+def ClassificationModelOptionsEnd(builder): return builder.EndObject()

19/libtextclassifier3/ContactAnnotatorOptions.py

@@ -0,0 +1,44 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: libtextclassifier3
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class ContactAnnotatorOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsContactAnnotatorOptions(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = ContactAnnotatorOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def ContactAnnotatorOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x43\x32\x20", size_prefixed=size_prefixed)
+
+    # ContactAnnotatorOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # ContactAnnotatorOptions
+    def EnableDeclension(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # ContactAnnotatorOptions
+    def Language(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+def ContactAnnotatorOptionsStart(builder): builder.StartObject(2)
+def ContactAnnotatorOptionsAddEnableDeclension(builder, enableDeclension): builder.PrependBoolSlot(0, enableDeclension, 0)
+def ContactAnnotatorOptionsAddLanguage(builder, language): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(language), 0)
+def ContactAnnotatorOptionsEnd(builder): return builder.EndObject()

19/libtextclassifier3/DatetimeExtractorType.py

@@ -0,0 +1,81 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: libtextclassifier3
+
+class DatetimeExtractorType(object):
+    UNKNOWN_DATETIME_EXTRACTOR_TYPE = 0
+    AM = 1
+    PM = 2
+    JANUARY = 3
+    FEBRUARY = 4
+    MARCH = 5
+    APRIL = 6
+    MAY = 7
+    JUNE = 8
+    JULY = 9
+    AUGUST = 10
+    SEPTEMBER = 11
+    OCTOBER = 12
+    NOVEMBER = 13
+    DECEMBER = 14
+    NEXT = 15
+    NEXT_OR_SAME = 16
+    LAST = 17
+    NOW = 18
+    TOMORROW = 19
+    YESTERDAY = 20
+    PAST = 21
+    FUTURE = 22
+    DAY = 23
+    WEEK = 24
+    MONTH = 25
+    YEAR = 26
+    MONDAY = 27
+    TUESDAY = 28
+    WEDNESDAY = 29
+    THURSDAY = 30
+    FRIDAY = 31
+    SATURDAY = 32
+    SUNDAY = 33
+    DAYS = 34
+    WEEKS = 35
+    MONTHS = 36
+    HOURS = 37
+    MINUTES = 38
+    SECONDS = 39
+    YEARS = 40
+    DIGITS = 41
+    SIGNEDDIGITS = 42
+    ZERO = 43
+    ONE = 44
+    TWO = 45
+    THREE = 46
+    FOUR = 47
+    FIVE = 48
+    SIX = 49
+    SEVEN = 50
+    EIGHT = 51
+    NINE = 52
+    TEN = 53
+    ELEVEN = 54
+    TWELVE = 55
+    THIRTEEN = 56
+    FOURTEEN = 57
+    FIFTEEN = 58
+    SIXTEEN = 59
+    SEVENTEEN = 60
+    EIGHTEEN = 61
+    NINETEEN = 62
+    TWENTY = 63
+    THIRTY = 64
+    FORTY = 65
+    FIFTY = 66
+    SIXTY = 67
+    SEVENTY = 68
+    EIGHTY = 69
+    NINETY = 70
+    HUNDRED = 71
+    THOUSAND = 72
+    NOON = 73
+    MIDNIGHT = 74
+

19/libtextclassifier3/DatetimeGroupType.py

@@ -0,0 +1,21 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: libtextclassifier3
+
+class DatetimeGroupType(object):
+    GROUP_UNKNOWN = 0
+    GROUP_UNUSED = 1
+    GROUP_YEAR = 2
+    GROUP_MONTH = 3
+    GROUP_DAY = 4
+    GROUP_HOUR = 5
+    GROUP_MINUTE = 6
+    GROUP_SECOND = 7
+    GROUP_AMPM = 8
+    GROUP_RELATIONDISTANCE = 9
+    GROUP_RELATION = 10
+    GROUP_RELATIONTYPE = 11
+    GROUP_DUMMY1 = 12
+    GROUP_DUMMY2 = 13
+    GROUP_ABSOLUTETIME = 14
+

19/libtextclassifier3/DatetimeModel.py

@@ -0,0 +1,165 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: libtextclassifier3
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class DatetimeModel(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsDatetimeModel(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = DatetimeModel()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def DatetimeModelBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x43\x32\x20", size_prefixed=size_prefixed)
+
+    # DatetimeModel
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # DatetimeModel
+    def Locales(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # DatetimeModel
+    def LocalesLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # DatetimeModel
+    def LocalesIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        return o == 0
+
+    # DatetimeModel
+    def Patterns(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from libtextclassifier3.DatetimeModelPattern import DatetimeModelPattern
+            obj = DatetimeModelPattern()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # DatetimeModel
+    def PatternsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # DatetimeModel
+    def PatternsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        return o == 0
+
+    # DatetimeModel
+    def Extractors(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from libtextclassifier3.DatetimeModelExtractor import DatetimeModelExtractor
+            obj = DatetimeModelExtractor()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # DatetimeModel
+    def ExtractorsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # DatetimeModel
+    def ExtractorsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        return o == 0
+
+    # DatetimeModel
+    def UseExtractorsForLocating(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return True
+
+    # DatetimeModel
+    def DefaultLocales(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return 0
+
+    # DatetimeModel
+    def DefaultLocalesAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o)
+        return 0
+
+    # DatetimeModel
+    def DefaultLocalesLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # DatetimeModel
+    def DefaultLocalesIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        return o == 0
+
+    # DatetimeModel
+    def GenerateAlternativeInterpretationsWhenAmbiguous(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # DatetimeModel
+    def LazyRegexCompilation(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return True
+
+    # DatetimeModel
+    def PreferFutureForUnspecifiedDate(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+def DatetimeModelStart(builder): builder.StartObject(8)
+def DatetimeModelAddLocales(builder, locales): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(locales), 0)
+def DatetimeModelStartLocalesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def DatetimeModelAddPatterns(builder, patterns): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(patterns), 0)
+def DatetimeModelStartPatternsVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def DatetimeModelAddExtractors(builder, extractors): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(extractors), 0)
+def DatetimeModelStartExtractorsVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def DatetimeModelAddUseExtractorsForLocating(builder, useExtractorsForLocating): builder.PrependBoolSlot(3, useExtractorsForLocating, 1)
+def DatetimeModelAddDefaultLocales(builder, defaultLocales): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(defaultLocales), 0)
+def DatetimeModelStartDefaultLocalesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def DatetimeModelAddGenerateAlternativeInterpretationsWhenAmbiguous(builder, generateAlternativeInterpretationsWhenAmbiguous): builder.PrependBoolSlot(5, generateAlternativeInterpretationsWhenAmbiguous, 0)
+def DatetimeModelAddLazyRegexCompilation(builder, lazyRegexCompilation): builder.PrependBoolSlot(6, lazyRegexCompilation, 1)
+def DatetimeModelAddPreferFutureForUnspecifiedDate(builder, preferFutureForUnspecifiedDate): builder.PrependBoolSlot(7, preferFutureForUnspecifiedDate, 0)
+def DatetimeModelEnd(builder): return builder.EndObject()

19/libtextclassifier3/DatetimeModelExtractor.py

@@ -0,0 +1,85 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: libtextclassifier3
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class DatetimeModelExtractor(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsDatetimeModelExtractor(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = DatetimeModelExtractor()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def DatetimeModelExtractorBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x43\x32\x20", size_prefixed=size_prefixed)
+
+    # DatetimeModelExtractor
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # DatetimeModelExtractor
+    def Extractor(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # DatetimeModelExtractor
+    def Pattern(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # DatetimeModelExtractor
+    def Locales(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return 0
+
+    # DatetimeModelExtractor
+    def LocalesAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o)
+        return 0
+
+    # DatetimeModelExtractor
+    def LocalesLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # DatetimeModelExtractor
+    def LocalesIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        return o == 0
+
+    # DatetimeModelExtractor
+    def CompressedPattern(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.CompressedBuffer import CompressedBuffer
+            obj = CompressedBuffer()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+def DatetimeModelExtractorStart(builder): builder.StartObject(4)
+def DatetimeModelExtractorAddExtractor(builder, extractor): builder.PrependInt32Slot(0, extractor, 0)
+def DatetimeModelExtractorAddPattern(builder, pattern): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(pattern), 0)
+def DatetimeModelExtractorAddLocales(builder, locales): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(locales), 0)
+def DatetimeModelExtractorStartLocalesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def DatetimeModelExtractorAddCompressedPattern(builder, compressedPattern): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(compressedPattern), 0)
+def DatetimeModelExtractorEnd(builder): return builder.EndObject()

19/libtextclassifier3/DatetimeModelLibrary.py

@@ -0,0 +1,55 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: libtextclassifier3
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class DatetimeModelLibrary(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsDatetimeModelLibrary(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = DatetimeModelLibrary()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def DatetimeModelLibraryBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x43\x32\x20", size_prefixed=size_prefixed)
+
+    # DatetimeModelLibrary
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # DatetimeModelLibrary
+    def Models(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from libtextclassifier3.DatetimeModelLibrary_.Item import Item
+            obj = Item()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # DatetimeModelLibrary
+    def ModelsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # DatetimeModelLibrary
+    def ModelsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        return o == 0
+
+def DatetimeModelLibraryStart(builder): builder.StartObject(1)
+def DatetimeModelLibraryAddModels(builder, models): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(models), 0)
+def DatetimeModelLibraryStartModelsVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def DatetimeModelLibraryEnd(builder): return builder.EndObject()

19/libtextclassifier3/DatetimeModelLibrary_/Item.py

@@ -0,0 +1,48 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: DatetimeModelLibrary_
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Item(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsItem(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Item()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def ItemBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x43\x32\x20", size_prefixed=size_prefixed)
+
+    # Item
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Item
+    def Key(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
+
+    # Item
+    def Value(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        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
+
+def ItemStart(builder): builder.StartObject(2)
+def ItemAddKey(builder, key): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(key), 0)
+def ItemAddValue(builder, value): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(value), 0)
+def ItemEnd(builder): return builder.EndObject()

19/libtextclassifier3/DatetimeModelPattern.py

@@ -0,0 +1,116 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: libtextclassifier3
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class DatetimeModelPattern(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsDatetimeModelPattern(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = DatetimeModelPattern()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def DatetimeModelPatternBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x43\x32\x20", size_prefixed=size_prefixed)
+
+    # DatetimeModelPattern
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # DatetimeModelPattern
+    def Regexes(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from libtextclassifier3.DatetimeModelPattern_.Regex import Regex
+            obj = Regex()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # DatetimeModelPattern
+    def RegexesLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # DatetimeModelPattern
+    def RegexesIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        return o == 0
+
+    # DatetimeModelPattern
+    def Locales(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return 0
+
+    # DatetimeModelPattern
+    def LocalesAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o)
+        return 0
+
+    # DatetimeModelPattern
+    def LocalesLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # DatetimeModelPattern
+    def LocalesIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        return o == 0
+
+    # DatetimeModelPattern
+    def TargetClassificationScore(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 1.0
+
+    # DatetimeModelPattern
+    def PriorityScore(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # DatetimeModelPattern
+    def EnabledModes(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 7
+
+    # DatetimeModelPattern
+    def EnabledAnnotationUsecases(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
+        return 4294967295
+
+def DatetimeModelPatternStart(builder): builder.StartObject(6)
+def DatetimeModelPatternAddRegexes(builder, regexes): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(regexes), 0)
+def DatetimeModelPatternStartRegexesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def DatetimeModelPatternAddLocales(builder, locales): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(locales), 0)
+def DatetimeModelPatternStartLocalesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def DatetimeModelPatternAddTargetClassificationScore(builder, targetClassificationScore): builder.PrependFloat32Slot(2, targetClassificationScore, 1.0)
+def DatetimeModelPatternAddPriorityScore(builder, priorityScore): builder.PrependFloat32Slot(3, priorityScore, 0.0)
+def DatetimeModelPatternAddEnabledModes(builder, enabledModes): builder.PrependInt32Slot(4, enabledModes, 7)
+def DatetimeModelPatternAddEnabledAnnotationUsecases(builder, enabledAnnotationUsecases): builder.PrependUint32Slot(5, enabledAnnotationUsecases, 4294967295)
+def DatetimeModelPatternEnd(builder): return builder.EndObject()

19/libtextclassifier3/DatetimeModelPattern_/Regex.py

@@ -0,0 +1,77 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: DatetimeModelPattern_
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Regex(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsRegex(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Regex()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def RegexBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x43\x32\x20", size_prefixed=size_prefixed)
+
+    # Regex
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Regex
+    def Pattern(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
+
+    # Regex
+    def Groups(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return 0
+
+    # Regex
+    def GroupsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o)
+        return 0
+
+    # Regex
+    def GroupsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Regex
+    def GroupsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        return o == 0
+
+    # Regex
+    def CompressedPattern(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from libtextclassifier3.CompressedBuffer import CompressedBuffer
+            obj = CompressedBuffer()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+def RegexStart(builder): builder.StartObject(3)
+def RegexAddPattern(builder, pattern): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pattern), 0)
+def RegexAddGroups(builder, groups): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(groups), 0)
+def RegexStartGroupsVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def RegexAddCompressedPattern(builder, compressedPattern): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(compressedPattern), 0)
+def RegexEnd(builder): return builder.EndObject()

19/libtextclassifier3/DurationAnnotatorOptions.py

@@ -0,0 +1,267 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: libtextclassifier3
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class DurationAnnotatorOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsDurationAnnotatorOptions(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = DurationAnnotatorOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def DurationAnnotatorOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x43\x32\x20", size_prefixed=size_prefixed)
+
+    # DurationAnnotatorOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # DurationAnnotatorOptions
+    def Enabled(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # DurationAnnotatorOptions
+    def Score(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 1.0
+
+    # DurationAnnotatorOptions
+    def PriorityScore(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # DurationAnnotatorOptions
+    def EnabledModes(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 7
+
+    # DurationAnnotatorOptions
+    def EnabledAnnotationUsecases(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
+        return 4294967295
+
+    # DurationAnnotatorOptions
+    def WeekExpressions(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # DurationAnnotatorOptions
+    def WeekExpressionsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # DurationAnnotatorOptions
+    def WeekExpressionsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        return o == 0
+
+    # DurationAnnotatorOptions
+    def DayExpressions(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # DurationAnnotatorOptions
+    def DayExpressionsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # DurationAnnotatorOptions
+    def DayExpressionsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        return o == 0
+
+    # DurationAnnotatorOptions
+    def HourExpressions(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # DurationAnnotatorOptions
+    def HourExpressionsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # DurationAnnotatorOptions
+    def HourExpressionsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        return o == 0
+
+    # DurationAnnotatorOptions
+    def MinuteExpressions(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # DurationAnnotatorOptions
+    def MinuteExpressionsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # DurationAnnotatorOptions
+    def MinuteExpressionsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        return o == 0
+
+    # DurationAnnotatorOptions
+    def SecondExpressions(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # DurationAnnotatorOptions
+    def SecondExpressionsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # DurationAnnotatorOptions
+    def SecondExpressionsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        return o == 0
+
+    # DurationAnnotatorOptions
+    def FillerExpressions(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # DurationAnnotatorOptions
+    def FillerExpressionsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # DurationAnnotatorOptions
+    def FillerExpressionsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        return o == 0
+
+    # DurationAnnotatorOptions
+    def HalfExpressions(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # DurationAnnotatorOptions
+    def HalfExpressionsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # DurationAnnotatorOptions
+    def HalfExpressionsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        return o == 0
+
+    # DurationAnnotatorOptions
+    def SubTokenSeparatorCodepoints(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return 0
+
+    # DurationAnnotatorOptions
+    def SubTokenSeparatorCodepointsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o)
+        return 0
+
+    # DurationAnnotatorOptions
+    def SubTokenSeparatorCodepointsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # DurationAnnotatorOptions
+    def SubTokenSeparatorCodepointsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        return o == 0
+
+    # DurationAnnotatorOptions
+    def RequireQuantity(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # DurationAnnotatorOptions
+    def EnableDanglingQuantityInterpretation(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
+
+def DurationAnnotatorOptionsStart(builder): builder.StartObject(15)
+def DurationAnnotatorOptionsAddEnabled(builder, enabled): builder.PrependBoolSlot(0, enabled, 0)
+def DurationAnnotatorOptionsAddScore(builder, score): builder.PrependFloat32Slot(1, score, 1.0)
+def DurationAnnotatorOptionsAddPriorityScore(builder, priorityScore): builder.PrependFloat32Slot(2, priorityScore, 0.0)
+def DurationAnnotatorOptionsAddEnabledModes(builder, enabledModes): builder.PrependInt32Slot(3, enabledModes, 7)
+def DurationAnnotatorOptionsAddEnabledAnnotationUsecases(builder, enabledAnnotationUsecases): builder.PrependUint32Slot(4, enabledAnnotationUsecases, 4294967295)
+def DurationAnnotatorOptionsAddWeekExpressions(builder, weekExpressions): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(weekExpressions), 0)
+def DurationAnnotatorOptionsStartWeekExpressionsVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def DurationAnnotatorOptionsAddDayExpressions(builder, dayExpressions): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(dayExpressions), 0)
+def DurationAnnotatorOptionsStartDayExpressionsVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def DurationAnnotatorOptionsAddHourExpressions(builder, hourExpressions): builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(hourExpressions), 0)
+def DurationAnnotatorOptionsStartHourExpressionsVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def DurationAnnotatorOptionsAddMinuteExpressions(builder, minuteExpressions): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(minuteExpressions), 0)
+def DurationAnnotatorOptionsStartMinuteExpressionsVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def DurationAnnotatorOptionsAddSecondExpressions(builder, secondExpressions): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(secondExpressions), 0)
+def DurationAnnotatorOptionsStartSecondExpressionsVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def DurationAnnotatorOptionsAddFillerExpressions(builder, fillerExpressions): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(fillerExpressions), 0)
+def DurationAnnotatorOptionsStartFillerExpressionsVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def DurationAnnotatorOptionsAddHalfExpressions(builder, halfExpressions): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(halfExpressions), 0)
+def DurationAnnotatorOptionsStartHalfExpressionsVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def DurationAnnotatorOptionsAddSubTokenSeparatorCodepoints(builder, subTokenSeparatorCodepoints): builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(subTokenSeparatorCodepoints), 0)
+def DurationAnnotatorOptionsStartSubTokenSeparatorCodepointsVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def DurationAnnotatorOptionsAddRequireQuantity(builder, requireQuantity): builder.PrependBoolSlot(13, requireQuantity, 0)
+def DurationAnnotatorOptionsAddEnableDanglingQuantityInterpretation(builder, enableDanglingQuantityInterpretation): builder.PrependBoolSlot(14, enableDanglingQuantityInterpretation, 1)
+def DurationAnnotatorOptionsEnd(builder): return builder.EndObject()

19/libtextclassifier3/FeatureProcessorOptions.py

@@ -0,0 +1,429 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: libtextclassifier3
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class FeatureProcessorOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsFeatureProcessorOptions(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = FeatureProcessorOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def FeatureProcessorOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x43\x32\x20", size_prefixed=size_prefixed)
+
+    # FeatureProcessorOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # FeatureProcessorOptions
+    def NumBuckets(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return -1
+
+    # FeatureProcessorOptions
+    def EmbeddingSize(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 -1
+
+    # FeatureProcessorOptions
+    def EmbeddingQuantizationBits(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 8
+
+    # FeatureProcessorOptions
+    def ContextSize(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return -1
+
+    # FeatureProcessorOptions
+    def MaxSelectionSpan(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return -1
+
+    # FeatureProcessorOptions
+    def ChargramOrders(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.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return 0
+
+    # FeatureProcessorOptions
+    def ChargramOrdersAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o)
+        return 0
+
+    # FeatureProcessorOptions
+    def ChargramOrdersLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # FeatureProcessorOptions
+    def ChargramOrdersIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        return o == 0
+
+    # FeatureProcessorOptions
+    def MaxWordLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 20
+
+    # FeatureProcessorOptions
+    def UnicodeAwareFeatures(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # FeatureProcessorOptions
+    def ExtractCaseFeature(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # FeatureProcessorOptions
+    def ExtractSelectionMaskFeature(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # FeatureProcessorOptions
+    def RegexpFeature(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # FeatureProcessorOptions
+    def RegexpFeatureLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # FeatureProcessorOptions
+    def RegexpFeatureIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        return o == 0
+
+    # FeatureProcessorOptions
+    def RemapDigits(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # FeatureProcessorOptions
+    def LowercaseTokens(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # FeatureProcessorOptions
+    def SelectionReducedOutputSpace(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return True
+
+    # FeatureProcessorOptions
+    def Collections(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # FeatureProcessorOptions
+    def CollectionsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # FeatureProcessorOptions
+    def CollectionsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
+        return o == 0
+
+    # FeatureProcessorOptions
+    def DefaultCollection(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return -1
+
+    # FeatureProcessorOptions
+    def OnlyUseLineWithClick(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # FeatureProcessorOptions
+    def SplitTokensOnSelectionBoundaries(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # FeatureProcessorOptions
+    def TokenizationCodepointConfig(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from libtextclassifier3.TokenizationCodepointRange import TokenizationCodepointRange
+            obj = TokenizationCodepointRange()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # FeatureProcessorOptions
+    def TokenizationCodepointConfigLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # FeatureProcessorOptions
+    def TokenizationCodepointConfigIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
+        return o == 0
+
+    # FeatureProcessorOptions
+    def CenterTokenSelectionMethod(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # FeatureProcessorOptions
+    def SnapLabelSpanBoundariesToContainingTokens(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(44))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # FeatureProcessorOptions
+    def SupportedCodepointRanges(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(46))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from libtextclassifier3.CodepointRange import CodepointRange
+            obj = CodepointRange()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # FeatureProcessorOptions
+    def SupportedCodepointRangesLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(46))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # FeatureProcessorOptions
+    def SupportedCodepointRangesIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(46))
+        return o == 0
+
+    # FeatureProcessorOptions
+    def InternalTokenizerCodepointRanges(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(48))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from libtextclassifier3.CodepointRange import CodepointRange
+            obj = CodepointRange()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # FeatureProcessorOptions
+    def InternalTokenizerCodepointRangesLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(48))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # FeatureProcessorOptions
+    def InternalTokenizerCodepointRangesIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(48))
+        return o == 0
+
+    # FeatureProcessorOptions
+    def MinSupportedCodepointRatio(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(50))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # FeatureProcessorOptions
+    def FeatureVersion(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # FeatureProcessorOptions
+    def TokenizationType(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(54))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 1
+
+    # FeatureProcessorOptions
+    def IcuPreserveWhitespaceTokens(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(56))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # FeatureProcessorOptions
+    def IgnoredSpanBoundaryCodepoints(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(58))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return 0
+
+    # FeatureProcessorOptions
+    def IgnoredSpanBoundaryCodepointsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(58))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o)
+        return 0
+
+    # FeatureProcessorOptions
+    def IgnoredSpanBoundaryCodepointsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(58))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # FeatureProcessorOptions
+    def IgnoredSpanBoundaryCodepointsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(58))
+        return o == 0
+
+    # FeatureProcessorOptions
+    def BoundsSensitiveFeatures(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.FeatureProcessorOptions_.BoundsSensitiveFeatures import BoundsSensitiveFeatures
+            obj = BoundsSensitiveFeatures()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # FeatureProcessorOptions
+    def AllowedChargrams(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # FeatureProcessorOptions
+    def AllowedChargramsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # FeatureProcessorOptions
+    def AllowedChargramsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
+        return o == 0
+
+    # FeatureProcessorOptions
+    def TokenizeOnScriptChange(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # FeatureProcessorOptions
+    def UsePipeCharacterForNewline(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return True
+
+def FeatureProcessorOptionsStart(builder): builder.StartObject(32)
+def FeatureProcessorOptionsAddNumBuckets(builder, numBuckets): builder.PrependInt32Slot(0, numBuckets, -1)
+def FeatureProcessorOptionsAddEmbeddingSize(builder, embeddingSize): builder.PrependInt32Slot(1, embeddingSize, -1)
+def FeatureProcessorOptionsAddEmbeddingQuantizationBits(builder, embeddingQuantizationBits): builder.PrependInt32Slot(2, embeddingQuantizationBits, 8)
+def FeatureProcessorOptionsAddContextSize(builder, contextSize): builder.PrependInt32Slot(3, contextSize, -1)
+def FeatureProcessorOptionsAddMaxSelectionSpan(builder, maxSelectionSpan): builder.PrependInt32Slot(4, maxSelectionSpan, -1)
+def FeatureProcessorOptionsAddChargramOrders(builder, chargramOrders): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(chargramOrders), 0)
+def FeatureProcessorOptionsStartChargramOrdersVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def FeatureProcessorOptionsAddMaxWordLength(builder, maxWordLength): builder.PrependInt32Slot(6, maxWordLength, 20)
+def FeatureProcessorOptionsAddUnicodeAwareFeatures(builder, unicodeAwareFeatures): builder.PrependBoolSlot(7, unicodeAwareFeatures, 0)
+def FeatureProcessorOptionsAddExtractCaseFeature(builder, extractCaseFeature): builder.PrependBoolSlot(8, extractCaseFeature, 0)
+def FeatureProcessorOptionsAddExtractSelectionMaskFeature(builder, extractSelectionMaskFeature): builder.PrependBoolSlot(9, extractSelectionMaskFeature, 0)
+def FeatureProcessorOptionsAddRegexpFeature(builder, regexpFeature): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(regexpFeature), 0)
+def FeatureProcessorOptionsStartRegexpFeatureVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def FeatureProcessorOptionsAddRemapDigits(builder, remapDigits): builder.PrependBoolSlot(11, remapDigits, 0)
+def FeatureProcessorOptionsAddLowercaseTokens(builder, lowercaseTokens): builder.PrependBoolSlot(12, lowercaseTokens, 0)
+def FeatureProcessorOptionsAddSelectionReducedOutputSpace(builder, selectionReducedOutputSpace): builder.PrependBoolSlot(13, selectionReducedOutputSpace, 1)
+def FeatureProcessorOptionsAddCollections(builder, collections): builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(collections), 0)
+def FeatureProcessorOptionsStartCollectionsVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def FeatureProcessorOptionsAddDefaultCollection(builder, defaultCollection): builder.PrependInt32Slot(15, defaultCollection, -1)
+def FeatureProcessorOptionsAddOnlyUseLineWithClick(builder, onlyUseLineWithClick): builder.PrependBoolSlot(16, onlyUseLineWithClick, 0)
+def FeatureProcessorOptionsAddSplitTokensOnSelectionBoundaries(builder, splitTokensOnSelectionBoundaries): builder.PrependBoolSlot(17, splitTokensOnSelectionBoundaries, 0)
+def FeatureProcessorOptionsAddTokenizationCodepointConfig(builder, tokenizationCodepointConfig): builder.PrependUOffsetTRelativeSlot(18, flatbuffers.number_types.UOffsetTFlags.py_type(tokenizationCodepointConfig), 0)
+def FeatureProcessorOptionsStartTokenizationCodepointConfigVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def FeatureProcessorOptionsAddCenterTokenSelectionMethod(builder, centerTokenSelectionMethod): builder.PrependInt32Slot(19, centerTokenSelectionMethod, 0)
+def FeatureProcessorOptionsAddSnapLabelSpanBoundariesToContainingTokens(builder, snapLabelSpanBoundariesToContainingTokens): builder.PrependBoolSlot(20, snapLabelSpanBoundariesToContainingTokens, 0)
+def FeatureProcessorOptionsAddSupportedCodepointRanges(builder, supportedCodepointRanges): builder.PrependUOffsetTRelativeSlot(21, flatbuffers.number_types.UOffsetTFlags.py_type(supportedCodepointRanges), 0)
+def FeatureProcessorOptionsStartSupportedCodepointRangesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def FeatureProcessorOptionsAddInternalTokenizerCodepointRanges(builder, internalTokenizerCodepointRanges): builder.PrependUOffsetTRelativeSlot(22, flatbuffers.number_types.UOffsetTFlags.py_type(internalTokenizerCodepointRanges), 0)
+def FeatureProcessorOptionsStartInternalTokenizerCodepointRangesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def FeatureProcessorOptionsAddMinSupportedCodepointRatio(builder, minSupportedCodepointRatio): builder.PrependFloat32Slot(23, minSupportedCodepointRatio, 0.0)
+def FeatureProcessorOptionsAddFeatureVersion(builder, featureVersion): builder.PrependInt32Slot(24, featureVersion, 0)
+def FeatureProcessorOptionsAddTokenizationType(builder, tokenizationType): builder.PrependInt32Slot(25, tokenizationType, 1)
+def FeatureProcessorOptionsAddIcuPreserveWhitespaceTokens(builder, icuPreserveWhitespaceTokens): builder.PrependBoolSlot(26, icuPreserveWhitespaceTokens, 0)
+def FeatureProcessorOptionsAddIgnoredSpanBoundaryCodepoints(builder, ignoredSpanBoundaryCodepoints): builder.PrependUOffsetTRelativeSlot(27, flatbuffers.number_types.UOffsetTFlags.py_type(ignoredSpanBoundaryCodepoints), 0)
+def FeatureProcessorOptionsStartIgnoredSpanBoundaryCodepointsVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def FeatureProcessorOptionsAddBoundsSensitiveFeatures(builder, boundsSensitiveFeatures): builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(boundsSensitiveFeatures), 0)
+def FeatureProcessorOptionsAddAllowedChargrams(builder, allowedChargrams): builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(allowedChargrams), 0)
+def FeatureProcessorOptionsStartAllowedChargramsVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def FeatureProcessorOptionsAddTokenizeOnScriptChange(builder, tokenizeOnScriptChange): builder.PrependBoolSlot(30, tokenizeOnScriptChange, 0)
+def FeatureProcessorOptionsAddUsePipeCharacterForNewline(builder, usePipeCharacterForNewline): builder.PrependBoolSlot(31, usePipeCharacterForNewline, 1)
+def FeatureProcessorOptionsEnd(builder): return builder.EndObject()

19/libtextclassifier3/FeatureProcessorOptions_/BoundsSensitiveFeatures.py

@@ -0,0 +1,92 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: FeatureProcessorOptions_
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class BoundsSensitiveFeatures(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsBoundsSensitiveFeatures(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = BoundsSensitiveFeatures()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def BoundsSensitiveFeaturesBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x43\x32\x20", size_prefixed=size_prefixed)
+
+    # BoundsSensitiveFeatures
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # BoundsSensitiveFeatures
+    def Enabled(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # BoundsSensitiveFeatures
+    def NumTokensBefore(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
+
+    # BoundsSensitiveFeatures
+    def NumTokensInsideLeft(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # BoundsSensitiveFeatures
+    def NumTokensInsideRight(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # BoundsSensitiveFeatures
+    def NumTokensAfter(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # BoundsSensitiveFeatures
+    def IncludeInsideBag(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # BoundsSensitiveFeatures
+    def IncludeInsideLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # BoundsSensitiveFeatures
+    def ScoreSingleTokenSpansAsZero(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+def BoundsSensitiveFeaturesStart(builder): builder.StartObject(8)
+def BoundsSensitiveFeaturesAddEnabled(builder, enabled): builder.PrependBoolSlot(0, enabled, 0)
+def BoundsSensitiveFeaturesAddNumTokensBefore(builder, numTokensBefore): builder.PrependInt32Slot(1, numTokensBefore, 0)
+def BoundsSensitiveFeaturesAddNumTokensInsideLeft(builder, numTokensInsideLeft): builder.PrependInt32Slot(2, numTokensInsideLeft, 0)
+def BoundsSensitiveFeaturesAddNumTokensInsideRight(builder, numTokensInsideRight): builder.PrependInt32Slot(3, numTokensInsideRight, 0)
+def BoundsSensitiveFeaturesAddNumTokensAfter(builder, numTokensAfter): builder.PrependInt32Slot(4, numTokensAfter, 0)
+def BoundsSensitiveFeaturesAddIncludeInsideBag(builder, includeInsideBag): builder.PrependBoolSlot(5, includeInsideBag, 0)
+def BoundsSensitiveFeaturesAddIncludeInsideLength(builder, includeInsideLength): builder.PrependBoolSlot(6, includeInsideLength, 0)
+def BoundsSensitiveFeaturesAddScoreSingleTokenSpansAsZero(builder, scoreSingleTokenSpansAsZero): builder.PrependBoolSlot(7, scoreSingleTokenSpansAsZero, 0)
+def BoundsSensitiveFeaturesEnd(builder): return builder.EndObject()

19/libtextclassifier3/FeatureProcessorOptions_/CenterTokenSelectionMethod.py

@@ -0,0 +1,9 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: FeatureProcessorOptions_
+
+class CenterTokenSelectionMethod(object):
+    DEFAULT_CENTER_TOKEN_METHOD = 0
+    CENTER_TOKEN_FROM_CLICK = 1
+    CENTER_TOKEN_MIDDLE_OF_SELECTION = 2
+

19/libtextclassifier3/GrammarModel.py

@@ -0,0 +1,95 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: libtextclassifier3
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class GrammarModel(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsGrammarModel(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = GrammarModel()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GrammarModelBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x43\x32\x20", size_prefixed=size_prefixed)
+
+    # GrammarModel
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # GrammarModel
+    def Rules(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from libtextclassifier3.grammar.RulesSet import RulesSet
+            obj = RulesSet()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # GrammarModel
+    def RuleClassificationResult(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from libtextclassifier3.GrammarModel_.RuleClassificationResult import RuleClassificationResult
+            obj = RuleClassificationResult()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # GrammarModel
+    def RuleClassificationResultLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # GrammarModel
+    def RuleClassificationResultIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        return o == 0
+
+    # GrammarModel
+    def ContextLeftNumTokens(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # GrammarModel
+    def ContextRightNumTokens(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # GrammarModel
+    def TokenizerOptions(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.GrammarTokenizerOptions import GrammarTokenizerOptions
+            obj = GrammarTokenizerOptions()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+def GrammarModelStart(builder): builder.StartObject(5)
+def GrammarModelAddRules(builder, rules): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(rules), 0)
+def GrammarModelAddRuleClassificationResult(builder, ruleClassificationResult): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(ruleClassificationResult), 0)
+def GrammarModelStartRuleClassificationResultVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def GrammarModelAddContextLeftNumTokens(builder, contextLeftNumTokens): builder.PrependInt32Slot(2, contextLeftNumTokens, 0)
+def GrammarModelAddContextRightNumTokens(builder, contextRightNumTokens): builder.PrependInt32Slot(3, contextRightNumTokens, 0)
+def GrammarModelAddTokenizerOptions(builder, tokenizerOptions): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(tokenizerOptions), 0)
+def GrammarModelEnd(builder): return builder.EndObject()

19/libtextclassifier3/GrammarModel_/RuleClassificationResult.py

@@ -0,0 +1,107 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: GrammarModel_
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class RuleClassificationResult(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsRuleClassificationResult(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = RuleClassificationResult()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def RuleClassificationResultBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x43\x32\x20", size_prefixed=size_prefixed)
+
+    # RuleClassificationResult
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # RuleClassificationResult
+    def CollectionName(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
+
+    # RuleClassificationResult
+    def TargetClassificationScore(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 1.0
+
+    # RuleClassificationResult
+    def PriorityScore(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # RuleClassificationResult
+    def CapturingGroup(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from libtextclassifier3.CapturingGroup import CapturingGroup
+            obj = CapturingGroup()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # RuleClassificationResult
+    def CapturingGroupLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # RuleClassificationResult
+    def CapturingGroupIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        return o == 0
+
+    # RuleClassificationResult
+    def SerializedEntityData(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # RuleClassificationResult
+    def EnabledModes(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 7
+
+    # RuleClassificationResult
+    def EntityData(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from libtextclassifier3.EntityData import EntityData
+            obj = EntityData()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+def RuleClassificationResultStart(builder): builder.StartObject(7)
+def RuleClassificationResultAddCollectionName(builder, collectionName): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(collectionName), 0)
+def RuleClassificationResultAddTargetClassificationScore(builder, targetClassificationScore): builder.PrependFloat32Slot(1, targetClassificationScore, 1.0)
+def RuleClassificationResultAddPriorityScore(builder, priorityScore): builder.PrependFloat32Slot(2, priorityScore, 0.0)
+def RuleClassificationResultAddCapturingGroup(builder, capturingGroup): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(capturingGroup), 0)
+def RuleClassificationResultStartCapturingGroupVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def RuleClassificationResultAddSerializedEntityData(builder, serializedEntityData): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(serializedEntityData), 0)
+def RuleClassificationResultAddEnabledModes(builder, enabledModes): builder.PrependInt32Slot(5, enabledModes, 7)
+def RuleClassificationResultAddEntityData(builder, entityData): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(entityData), 0)
+def RuleClassificationResultEnd(builder): return builder.EndObject()

19/libtextclassifier3/GrammarTokenizerOptions.py

@@ -0,0 +1,106 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: libtextclassifier3
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class GrammarTokenizerOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsGrammarTokenizerOptions(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = GrammarTokenizerOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GrammarTokenizerOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x43\x32\x20", size_prefixed=size_prefixed)
+
+    # GrammarTokenizerOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # GrammarTokenizerOptions
+    def TokenizationType(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 2
+
+    # GrammarTokenizerOptions
+    def IcuPreserveWhitespaceTokens(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # GrammarTokenizerOptions
+    def TokenizationCodepointConfig(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from libtextclassifier3.TokenizationCodepointRange import TokenizationCodepointRange
+            obj = TokenizationCodepointRange()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # GrammarTokenizerOptions
+    def TokenizationCodepointConfigLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # GrammarTokenizerOptions
+    def TokenizationCodepointConfigIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        return o == 0
+
+    # GrammarTokenizerOptions
+    def InternalTokenizerCodepointRanges(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from libtextclassifier3.CodepointRange import CodepointRange
+            obj = CodepointRange()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # GrammarTokenizerOptions
+    def InternalTokenizerCodepointRangesLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # GrammarTokenizerOptions
+    def InternalTokenizerCodepointRangesIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        return o == 0
+
+    # GrammarTokenizerOptions
+    def TokenizeOnScriptChange(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+def GrammarTokenizerOptionsStart(builder): builder.StartObject(5)
+def GrammarTokenizerOptionsAddTokenizationType(builder, tokenizationType): builder.PrependInt32Slot(0, tokenizationType, 2)
+def GrammarTokenizerOptionsAddIcuPreserveWhitespaceTokens(builder, icuPreserveWhitespaceTokens): builder.PrependBoolSlot(1, icuPreserveWhitespaceTokens, 0)
+def GrammarTokenizerOptionsAddTokenizationCodepointConfig(builder, tokenizationCodepointConfig): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(tokenizationCodepointConfig), 0)
+def GrammarTokenizerOptionsStartTokenizationCodepointConfigVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def GrammarTokenizerOptionsAddInternalTokenizerCodepointRanges(builder, internalTokenizerCodepointRanges): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(internalTokenizerCodepointRanges), 0)
+def GrammarTokenizerOptionsStartInternalTokenizerCodepointRangesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def GrammarTokenizerOptionsAddTokenizeOnScriptChange(builder, tokenizeOnScriptChange): builder.PrependBoolSlot(4, tokenizeOnScriptChange, 0)
+def GrammarTokenizerOptionsEnd(builder): return builder.EndObject()

19/libtextclassifier3/ModeFlag.py

@@ -0,0 +1,14 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: libtextclassifier3
+
+class ModeFlag(object):
+    NONE = 0
+    ANNOTATION = 1
+    CLASSIFICATION = 2
+    ANNOTATION_AND_CLASSIFICATION = 3
+    SELECTION = 4
+    ANNOTATION_AND_SELECTION = 5
+    CLASSIFICATION_AND_SELECTION = 6
+    ALL = 7
+

19/libtextclassifier3/Model.py

@@ -0,0 +1,456 @@
+# 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()

19/libtextclassifier3/ModelTriggeringOptions.py

@@ -0,0 +1,103 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: libtextclassifier3
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class ModelTriggeringOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsModelTriggeringOptions(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = ModelTriggeringOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def ModelTriggeringOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x43\x32\x20", size_prefixed=size_prefixed)
+
+    # ModelTriggeringOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # ModelTriggeringOptions
+    def MinAnnotateConfidence(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # ModelTriggeringOptions
+    def EnabledModes(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 7
+
+    # ModelTriggeringOptions
+    def DictionaryLocales(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
+
+    # ModelTriggeringOptions
+    def Locales(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # ModelTriggeringOptions
+    def OtherCollectionPriorityScore(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return -1000.0
+
+    # ModelTriggeringOptions
+    def KnowledgePriorityScore(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # ModelTriggeringOptions
+    def CollectionToPriority(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from libtextclassifier3.ModelTriggeringOptions_.CollectionToPriorityEntry import CollectionToPriorityEntry
+            obj = CollectionToPriorityEntry()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # ModelTriggeringOptions
+    def CollectionToPriorityLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # ModelTriggeringOptions
+    def CollectionToPriorityIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        return o == 0
+
+def ModelTriggeringOptionsStart(builder): builder.StartObject(8)
+def ModelTriggeringOptionsAddMinAnnotateConfidence(builder, minAnnotateConfidence): builder.PrependFloat32Slot(0, minAnnotateConfidence, 0.0)
+def ModelTriggeringOptionsAddEnabledModes(builder, enabledModes): builder.PrependInt32Slot(1, enabledModes, 7)
+def ModelTriggeringOptionsAddDictionaryLocales(builder, dictionaryLocales): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(dictionaryLocales), 0)
+def ModelTriggeringOptionsAddLocales(builder, locales): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(locales), 0)
+def ModelTriggeringOptionsAddOtherCollectionPriorityScore(builder, otherCollectionPriorityScore): builder.PrependFloat32Slot(4, otherCollectionPriorityScore, -1000.0)
+def ModelTriggeringOptionsAddKnowledgePriorityScore(builder, knowledgePriorityScore): builder.PrependFloat32Slot(5, knowledgePriorityScore, 0.0)
+def ModelTriggeringOptionsAddCollectionToPriority(builder, collectionToPriority): builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(collectionToPriority), 0)
+def ModelTriggeringOptionsStartCollectionToPriorityVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def ModelTriggeringOptionsEnd(builder): return builder.EndObject()

19/libtextclassifier3/ModelTriggeringOptions_/CollectionToPriorityEntry.py

@@ -0,0 +1,44 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: ModelTriggeringOptions_
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class CollectionToPriorityEntry(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsCollectionToPriorityEntry(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = CollectionToPriorityEntry()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def CollectionToPriorityEntryBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x43\x32\x20", size_prefixed=size_prefixed)
+
+    # CollectionToPriorityEntry
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # CollectionToPriorityEntry
+    def Key(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
+
+    # CollectionToPriorityEntry
+    def Value(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+def CollectionToPriorityEntryStart(builder): builder.StartObject(2)
+def CollectionToPriorityEntryAddKey(builder, key): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(key), 0)
+def CollectionToPriorityEntryAddValue(builder, value): builder.PrependFloat32Slot(1, value, 0.0)
+def CollectionToPriorityEntryEnd(builder): return builder.EndObject()

19/libtextclassifier3/Model_/ConflictResolutionOptions.py

@@ -0,0 +1,44 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: Model_
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class ConflictResolutionOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsConflictResolutionOptions(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = ConflictResolutionOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def ConflictResolutionOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x43\x32\x20", size_prefixed=size_prefixed)
+
+    # ConflictResolutionOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # ConflictResolutionOptions
+    def PrioritizeLongestAnnotation(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # ConflictResolutionOptions
+    def DoConflictResolutionInRawMode(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return True
+
+def ConflictResolutionOptionsStart(builder): builder.StartObject(2)
+def ConflictResolutionOptionsAddPrioritizeLongestAnnotation(builder, prioritizeLongestAnnotation): builder.PrependBoolSlot(0, prioritizeLongestAnnotation, 0)
+def ConflictResolutionOptionsAddDoConflictResolutionInRawMode(builder, doConflictResolutionInRawMode): builder.PrependBoolSlot(1, doConflictResolutionInRawMode, 1)
+def ConflictResolutionOptionsEnd(builder): return builder.EndObject()

19/libtextclassifier3/Model_/EmbeddingPruningMask.py

@@ -0,0 +1,81 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: Model_
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class EmbeddingPruningMask(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsEmbeddingPruningMask(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = EmbeddingPruningMask()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def EmbeddingPruningMaskBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x43\x32\x20", size_prefixed=size_prefixed)
+
+    # EmbeddingPruningMask
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # EmbeddingPruningMask
+    def Enabled(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # EmbeddingPruningMask
+    def PruningMask(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # EmbeddingPruningMask
+    def PruningMaskAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
+        return 0
+
+    # EmbeddingPruningMask
+    def PruningMaskLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # EmbeddingPruningMask
+    def PruningMaskIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        return o == 0
+
+    # EmbeddingPruningMask
+    def FullNumBuckets(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # EmbeddingPruningMask
+    def PrunedRowBucketId(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+def EmbeddingPruningMaskStart(builder): builder.StartObject(4)
+def EmbeddingPruningMaskAddEnabled(builder, enabled): builder.PrependBoolSlot(0, enabled, 0)
+def EmbeddingPruningMaskAddPruningMask(builder, pruningMask): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(pruningMask), 0)
+def EmbeddingPruningMaskStartPruningMaskVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+def EmbeddingPruningMaskAddFullNumBuckets(builder, fullNumBuckets): builder.PrependInt32Slot(2, fullNumBuckets, 0)
+def EmbeddingPruningMaskAddPrunedRowBucketId(builder, prunedRowBucketId): builder.PrependInt32Slot(3, prunedRowBucketId, 0)
+def EmbeddingPruningMaskEnd(builder): return builder.EndObject()

19/libtextclassifier3/MoneyParsingOptions.py

@@ -0,0 +1,84 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: libtextclassifier3
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class MoneyParsingOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsMoneyParsingOptions(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = MoneyParsingOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def MoneyParsingOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x43\x32\x20", size_prefixed=size_prefixed)
+
+    # MoneyParsingOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # MoneyParsingOptions
+    def Separators(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return 0
+
+    # MoneyParsingOptions
+    def SeparatorsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o)
+        return 0
+
+    # MoneyParsingOptions
+    def SeparatorsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # MoneyParsingOptions
+    def SeparatorsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        return o == 0
+
+    # MoneyParsingOptions
+    def QuantitiesNameToExponent(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from libtextclassifier3.MoneyParsingOptions_.QuantitiesNameToExponentEntry import QuantitiesNameToExponentEntry
+            obj = QuantitiesNameToExponentEntry()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # MoneyParsingOptions
+    def QuantitiesNameToExponentLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # MoneyParsingOptions
+    def QuantitiesNameToExponentIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        return o == 0
+
+def MoneyParsingOptionsStart(builder): builder.StartObject(2)
+def MoneyParsingOptionsAddSeparators(builder, separators): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(separators), 0)
+def MoneyParsingOptionsStartSeparatorsVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def MoneyParsingOptionsAddQuantitiesNameToExponent(builder, quantitiesNameToExponent): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(quantitiesNameToExponent), 0)
+def MoneyParsingOptionsStartQuantitiesNameToExponentVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def MoneyParsingOptionsEnd(builder): return builder.EndObject()

19/libtextclassifier3/MoneyParsingOptions_/QuantitiesNameToExponentEntry.py

@@ -0,0 +1,44 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: MoneyParsingOptions_
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class QuantitiesNameToExponentEntry(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsQuantitiesNameToExponentEntry(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = QuantitiesNameToExponentEntry()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def QuantitiesNameToExponentEntryBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x43\x32\x20", size_prefixed=size_prefixed)
+
+    # QuantitiesNameToExponentEntry
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # QuantitiesNameToExponentEntry
+    def Key(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
+
+    # QuantitiesNameToExponentEntry
+    def Value(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
+
+def QuantitiesNameToExponentEntryStart(builder): builder.StartObject(2)
+def QuantitiesNameToExponentEntryAddKey(builder, key): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(key), 0)
+def QuantitiesNameToExponentEntryAddValue(builder, value): builder.PrependInt32Slot(1, value, 0)
+def QuantitiesNameToExponentEntryEnd(builder): return builder.EndObject()

19/libtextclassifier3/NumberAnnotatorOptions.py

@@ -0,0 +1,261 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: libtextclassifier3
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class NumberAnnotatorOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsNumberAnnotatorOptions(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = NumberAnnotatorOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def NumberAnnotatorOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x43\x32\x20", size_prefixed=size_prefixed)
+
+    # NumberAnnotatorOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # NumberAnnotatorOptions
+    def Enabled(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # NumberAnnotatorOptions
+    def Score(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 1.0
+
+    # NumberAnnotatorOptions
+    def PriorityScore(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # NumberAnnotatorOptions
+    def EnabledModes(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 7
+
+    # NumberAnnotatorOptions
+    def EnabledAnnotationUsecases(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
+        return 4294967295
+
+    # NumberAnnotatorOptions
+    def AllowedPrefixCodepoints(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.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return 0
+
+    # NumberAnnotatorOptions
+    def AllowedPrefixCodepointsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o)
+        return 0
+
+    # NumberAnnotatorOptions
+    def AllowedPrefixCodepointsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # NumberAnnotatorOptions
+    def AllowedPrefixCodepointsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        return o == 0
+
+    # NumberAnnotatorOptions
+    def AllowedSuffixCodepoints(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.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return 0
+
+    # NumberAnnotatorOptions
+    def AllowedSuffixCodepointsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o)
+        return 0
+
+    # NumberAnnotatorOptions
+    def AllowedSuffixCodepointsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # NumberAnnotatorOptions
+    def AllowedSuffixCodepointsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        return o == 0
+
+    # NumberAnnotatorOptions
+    def IgnoredPrefixSpanBoundaryCodepoints(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.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return 0
+
+    # NumberAnnotatorOptions
+    def IgnoredPrefixSpanBoundaryCodepointsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o)
+        return 0
+
+    # NumberAnnotatorOptions
+    def IgnoredPrefixSpanBoundaryCodepointsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # NumberAnnotatorOptions
+    def IgnoredPrefixSpanBoundaryCodepointsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        return o == 0
+
+    # NumberAnnotatorOptions
+    def IgnoredSuffixSpanBoundaryCodepoints(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return 0
+
+    # NumberAnnotatorOptions
+    def IgnoredSuffixSpanBoundaryCodepointsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o)
+        return 0
+
+    # NumberAnnotatorOptions
+    def IgnoredSuffixSpanBoundaryCodepointsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # NumberAnnotatorOptions
+    def IgnoredSuffixSpanBoundaryCodepointsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        return o == 0
+
+    # NumberAnnotatorOptions
+    def EnablePercentage(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # NumberAnnotatorOptions
+    def PercentagePiecesString(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # NumberAnnotatorOptions
+    def PercentagePiecesOffsets(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return 0
+
+    # NumberAnnotatorOptions
+    def PercentagePiecesOffsetsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o)
+        return 0
+
+    # NumberAnnotatorOptions
+    def PercentagePiecesOffsetsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # NumberAnnotatorOptions
+    def PercentagePiecesOffsetsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        return o == 0
+
+    # NumberAnnotatorOptions
+    def PercentagePriorityScore(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 1.0
+
+    # NumberAnnotatorOptions
+    def FloatNumberPriorityScore(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # NumberAnnotatorOptions
+    def MaxNumberOfDigits(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 20
+
+    # NumberAnnotatorOptions
+    def PercentageAnnotationUsecases(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
+        return 2
+
+def NumberAnnotatorOptionsStart(builder): builder.StartObject(16)
+def NumberAnnotatorOptionsAddEnabled(builder, enabled): builder.PrependBoolSlot(0, enabled, 0)
+def NumberAnnotatorOptionsAddScore(builder, score): builder.PrependFloat32Slot(1, score, 1.0)
+def NumberAnnotatorOptionsAddPriorityScore(builder, priorityScore): builder.PrependFloat32Slot(2, priorityScore, 0.0)
+def NumberAnnotatorOptionsAddEnabledModes(builder, enabledModes): builder.PrependInt32Slot(3, enabledModes, 7)
+def NumberAnnotatorOptionsAddEnabledAnnotationUsecases(builder, enabledAnnotationUsecases): builder.PrependUint32Slot(4, enabledAnnotationUsecases, 4294967295)
+def NumberAnnotatorOptionsAddAllowedPrefixCodepoints(builder, allowedPrefixCodepoints): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(allowedPrefixCodepoints), 0)
+def NumberAnnotatorOptionsStartAllowedPrefixCodepointsVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def NumberAnnotatorOptionsAddAllowedSuffixCodepoints(builder, allowedSuffixCodepoints): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(allowedSuffixCodepoints), 0)
+def NumberAnnotatorOptionsStartAllowedSuffixCodepointsVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def NumberAnnotatorOptionsAddIgnoredPrefixSpanBoundaryCodepoints(builder, ignoredPrefixSpanBoundaryCodepoints): builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(ignoredPrefixSpanBoundaryCodepoints), 0)
+def NumberAnnotatorOptionsStartIgnoredPrefixSpanBoundaryCodepointsVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def NumberAnnotatorOptionsAddIgnoredSuffixSpanBoundaryCodepoints(builder, ignoredSuffixSpanBoundaryCodepoints): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(ignoredSuffixSpanBoundaryCodepoints), 0)
+def NumberAnnotatorOptionsStartIgnoredSuffixSpanBoundaryCodepointsVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def NumberAnnotatorOptionsAddEnablePercentage(builder, enablePercentage): builder.PrependBoolSlot(9, enablePercentage, 0)
+def NumberAnnotatorOptionsAddPercentagePiecesString(builder, percentagePiecesString): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(percentagePiecesString), 0)
+def NumberAnnotatorOptionsAddPercentagePiecesOffsets(builder, percentagePiecesOffsets): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(percentagePiecesOffsets), 0)
+def NumberAnnotatorOptionsStartPercentagePiecesOffsetsVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def NumberAnnotatorOptionsAddPercentagePriorityScore(builder, percentagePriorityScore): builder.PrependFloat32Slot(12, percentagePriorityScore, 1.0)
+def NumberAnnotatorOptionsAddFloatNumberPriorityScore(builder, floatNumberPriorityScore): builder.PrependFloat32Slot(13, floatNumberPriorityScore, 0.0)
+def NumberAnnotatorOptionsAddMaxNumberOfDigits(builder, maxNumberOfDigits): builder.PrependInt32Slot(14, maxNumberOfDigits, 20)
+def NumberAnnotatorOptionsAddPercentageAnnotationUsecases(builder, percentageAnnotationUsecases): builder.PrependUint32Slot(15, percentageAnnotationUsecases, 2)
+def NumberAnnotatorOptionsEnd(builder): return builder.EndObject()

19/libtextclassifier3/OutputOptions.py

@@ -0,0 +1,94 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: libtextclassifier3
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class OutputOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsOutputOptions(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = OutputOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def OutputOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x43\x32\x20", size_prefixed=size_prefixed)
+
+    # OutputOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # OutputOptions
+    def FilteredCollectionsAnnotation(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # OutputOptions
+    def FilteredCollectionsAnnotationLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # OutputOptions
+    def FilteredCollectionsAnnotationIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        return o == 0
+
+    # OutputOptions
+    def FilteredCollectionsClassification(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # OutputOptions
+    def FilteredCollectionsClassificationLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # OutputOptions
+    def FilteredCollectionsClassificationIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        return o == 0
+
+    # OutputOptions
+    def FilteredCollectionsSelection(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # OutputOptions
+    def FilteredCollectionsSelectionLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # OutputOptions
+    def FilteredCollectionsSelectionIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        return o == 0
+
+def OutputOptionsStart(builder): builder.StartObject(3)
+def OutputOptionsAddFilteredCollectionsAnnotation(builder, filteredCollectionsAnnotation): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(filteredCollectionsAnnotation), 0)
+def OutputOptionsStartFilteredCollectionsAnnotationVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def OutputOptionsAddFilteredCollectionsClassification(builder, filteredCollectionsClassification): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(filteredCollectionsClassification), 0)
+def OutputOptionsStartFilteredCollectionsClassificationVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def OutputOptionsAddFilteredCollectionsSelection(builder, filteredCollectionsSelection): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(filteredCollectionsSelection), 0)
+def OutputOptionsStartFilteredCollectionsSelectionVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def OutputOptionsEnd(builder): return builder.EndObject()

19/libtextclassifier3/PodNerModel.py

@@ -0,0 +1,212 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: libtextclassifier3
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class PodNerModel(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsPodNerModel(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = PodNerModel()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def PodNerModelBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x43\x32\x20", size_prefixed=size_prefixed)
+
+    # PodNerModel
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # PodNerModel
+    def TfliteModel(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        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
+
+    # PodNerModel
+    def TfliteModelAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # PodNerModel
+    def TfliteModelLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # PodNerModel
+    def TfliteModelIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        return o == 0
+
+    # PodNerModel
+    def WordPieceVocab(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        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
+
+    # PodNerModel
+    def WordPieceVocabAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # PodNerModel
+    def WordPieceVocabLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # PodNerModel
+    def WordPieceVocabIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        return o == 0
+
+    # PodNerModel
+    def LowercaseInput(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return True
+
+    # PodNerModel
+    def LogitsIndexInOutputTensor(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # PodNerModel
+    def AppendFinalPeriod(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # PodNerModel
+    def PriorityScore(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # PodNerModel
+    def MaxNumWordpieces(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 128
+
+    # PodNerModel
+    def SlidingWindowNumWordpiecesOverlap(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 20
+
+    # PodNerModel
+    def Labels(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from libtextclassifier3.PodNerModel_.Label import Label
+            obj = Label()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # PodNerModel
+    def LabelsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # PodNerModel
+    def LabelsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        return o == 0
+
+    # PodNerModel
+    def MaxRatioUnknownWordpieces(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.1
+
+    # PodNerModel
+    def Collections(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from libtextclassifier3.PodNerModel_.Collection import Collection
+            obj = Collection()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # PodNerModel
+    def CollectionsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # PodNerModel
+    def CollectionsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        return o == 0
+
+    # PodNerModel
+    def MinNumberOfTokens(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 1
+
+    # PodNerModel
+    def MinNumberOfWordpieces(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 1
+
+def PodNerModelStart(builder): builder.StartObject(14)
+def PodNerModelAddTfliteModel(builder, tfliteModel): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(tfliteModel), 0)
+def PodNerModelStartTfliteModelVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def PodNerModelAddWordPieceVocab(builder, wordPieceVocab): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(wordPieceVocab), 0)
+def PodNerModelStartWordPieceVocabVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def PodNerModelAddLowercaseInput(builder, lowercaseInput): builder.PrependBoolSlot(2, lowercaseInput, 1)
+def PodNerModelAddLogitsIndexInOutputTensor(builder, logitsIndexInOutputTensor): builder.PrependInt32Slot(3, logitsIndexInOutputTensor, 0)
+def PodNerModelAddAppendFinalPeriod(builder, appendFinalPeriod): builder.PrependBoolSlot(4, appendFinalPeriod, 0)
+def PodNerModelAddPriorityScore(builder, priorityScore): builder.PrependFloat32Slot(5, priorityScore, 0.0)
+def PodNerModelAddMaxNumWordpieces(builder, maxNumWordpieces): builder.PrependInt32Slot(6, maxNumWordpieces, 128)
+def PodNerModelAddSlidingWindowNumWordpiecesOverlap(builder, slidingWindowNumWordpiecesOverlap): builder.PrependInt32Slot(7, slidingWindowNumWordpiecesOverlap, 20)
+def PodNerModelAddLabels(builder, labels): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(labels), 0)
+def PodNerModelStartLabelsVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def PodNerModelAddMaxRatioUnknownWordpieces(builder, maxRatioUnknownWordpieces): builder.PrependFloat32Slot(10, maxRatioUnknownWordpieces, 0.1)
+def PodNerModelAddCollections(builder, collections): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(collections), 0)
+def PodNerModelStartCollectionsVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def PodNerModelAddMinNumberOfTokens(builder, minNumberOfTokens): builder.PrependInt32Slot(12, minNumberOfTokens, 1)
+def PodNerModelAddMinNumberOfWordpieces(builder, minNumberOfWordpieces): builder.PrependInt32Slot(13, minNumberOfWordpieces, 1)
+def PodNerModelEnd(builder): return builder.EndObject()

19/libtextclassifier3/PodNerModel_/Collection.py

@@ -0,0 +1,52 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: PodNerModel_
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Collection(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsCollection(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Collection()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def CollectionBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x43\x32\x20", size_prefixed=size_prefixed)
+
+    # Collection
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Collection
+    def Name(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
+
+    # Collection
+    def SingleTokenPriorityScore(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # Collection
+    def MultiTokenPriorityScore(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+def CollectionStart(builder): builder.StartObject(3)
+def CollectionAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+def CollectionAddSingleTokenPriorityScore(builder, singleTokenPriorityScore): builder.PrependFloat32Slot(1, singleTokenPriorityScore, 0.0)
+def CollectionAddMultiTokenPriorityScore(builder, multiTokenPriorityScore): builder.PrependFloat32Slot(2, multiTokenPriorityScore, 0.0)
+def CollectionEnd(builder): return builder.EndObject()

19/libtextclassifier3/PodNerModel_/Label.py

@@ -0,0 +1,52 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: PodNerModel_
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Label(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsLabel(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Label()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def LabelBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x43\x32\x20", size_prefixed=size_prefixed)
+
+    # Label
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Label
+    def BoiseType(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # Label
+    def MentionType(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
+
+    # Label
+    def CollectionId(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+def LabelStart(builder): builder.StartObject(3)
+def LabelAddBoiseType(builder, boiseType): builder.PrependInt32Slot(0, boiseType, 0)
+def LabelAddMentionType(builder, mentionType): builder.PrependInt32Slot(1, mentionType, 0)
+def LabelAddCollectionId(builder, collectionId): builder.PrependInt32Slot(2, collectionId, 0)
+def LabelEnd(builder): return builder.EndObject()

19/libtextclassifier3/PodNerModel_/Label_/BoiseType.py

@@ -0,0 +1,12 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: Label_
+
+class BoiseType(object):
+    NONE = 0
+    BEGIN = 1
+    O = 2
+    INTERMEDIATE = 3
+    SINGLE = 4
+    END = 5
+

19/libtextclassifier3/PodNerModel_/Label_/MentionType.py

@@ -0,0 +1,9 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: Label_
+
+class MentionType(object):
+    UNDEFINED = 0
+    NAM = 1
+    NOM = 2
+

19/libtextclassifier3/RegexModel.py

@@ -0,0 +1,85 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: libtextclassifier3
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class RegexModel(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsRegexModel(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = RegexModel()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def RegexModelBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x43\x32\x20", size_prefixed=size_prefixed)
+
+    # RegexModel
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # RegexModel
+    def Patterns(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from libtextclassifier3.RegexModel_.Pattern import Pattern
+            obj = Pattern()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # RegexModel
+    def PatternsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # RegexModel
+    def PatternsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        return o == 0
+
+    # RegexModel
+    def LazyRegexCompilation(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return True
+
+    # RegexModel
+    def LuaVerifier(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # RegexModel
+    def LuaVerifierLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # RegexModel
+    def LuaVerifierIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        return o == 0
+
+def RegexModelStart(builder): builder.StartObject(3)
+def RegexModelAddPatterns(builder, patterns): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(patterns), 0)
+def RegexModelStartPatternsVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def RegexModelAddLazyRegexCompilation(builder, lazyRegexCompilation): builder.PrependBoolSlot(1, lazyRegexCompilation, 1)
+def RegexModelAddLuaVerifier(builder, luaVerifier): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(luaVerifier), 0)
+def RegexModelStartLuaVerifierVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def RegexModelEnd(builder): return builder.EndObject()

19/libtextclassifier3/RegexModel_/Pattern.py

@@ -0,0 +1,147 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: RegexModel_
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Pattern(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsPattern(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Pattern()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def PatternBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x43\x32\x20", size_prefixed=size_prefixed)
+
+    # Pattern
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Pattern
+    def CollectionName(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
+
+    # Pattern
+    def Pattern(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Pattern
+    def EnabledModes(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 7
+
+    # Pattern
+    def TargetClassificationScore(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 1.0
+
+    # Pattern
+    def PriorityScore(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # Pattern
+    def UseApproximateMatching(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # Pattern
+    def CompressedPattern(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from libtextclassifier3.CompressedBuffer import CompressedBuffer
+            obj = CompressedBuffer()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Pattern
+    def VerificationOptions(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from libtextclassifier3.VerificationOptions import VerificationOptions
+            obj = VerificationOptions()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Pattern
+    def CapturingGroup(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from libtextclassifier3.CapturingGroup import CapturingGroup
+            obj = CapturingGroup()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Pattern
+    def CapturingGroupLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Pattern
+    def CapturingGroupIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        return o == 0
+
+    # Pattern
+    def SerializedEntityData(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Pattern
+    def EntityData(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.EntityData import EntityData
+            obj = EntityData()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+def PatternStart(builder): builder.StartObject(11)
+def PatternAddCollectionName(builder, collectionName): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(collectionName), 0)
+def PatternAddPattern(builder, pattern): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(pattern), 0)
+def PatternAddEnabledModes(builder, enabledModes): builder.PrependInt32Slot(2, enabledModes, 7)
+def PatternAddTargetClassificationScore(builder, targetClassificationScore): builder.PrependFloat32Slot(3, targetClassificationScore, 1.0)
+def PatternAddPriorityScore(builder, priorityScore): builder.PrependFloat32Slot(4, priorityScore, 0.0)
+def PatternAddUseApproximateMatching(builder, useApproximateMatching): builder.PrependBoolSlot(5, useApproximateMatching, 0)
+def PatternAddCompressedPattern(builder, compressedPattern): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(compressedPattern), 0)
+def PatternAddVerificationOptions(builder, verificationOptions): builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(verificationOptions), 0)
+def PatternAddCapturingGroup(builder, capturingGroup): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(capturingGroup), 0)
+def PatternStartCapturingGroupVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def PatternAddSerializedEntityData(builder, serializedEntityData): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(serializedEntityData), 0)
+def PatternAddEntityData(builder, entityData): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(entityData), 0)
+def PatternEnd(builder): return builder.EndObject()

19/libtextclassifier3/SelectionModelOptions.py

@@ -0,0 +1,60 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: libtextclassifier3
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class SelectionModelOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsSelectionModelOptions(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = SelectionModelOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def SelectionModelOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x43\x32\x20", size_prefixed=size_prefixed)
+
+    # SelectionModelOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # SelectionModelOptions
+    def StripUnpairedBrackets(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return True
+
+    # SelectionModelOptions
+    def SymmetryContextSize(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
+
+    # SelectionModelOptions
+    def BatchSize(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 1024
+
+    # SelectionModelOptions
+    def AlwaysClassifySuggestedSelection(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+def SelectionModelOptionsStart(builder): builder.StartObject(4)
+def SelectionModelOptionsAddStripUnpairedBrackets(builder, stripUnpairedBrackets): builder.PrependBoolSlot(0, stripUnpairedBrackets, 1)
+def SelectionModelOptionsAddSymmetryContextSize(builder, symmetryContextSize): builder.PrependInt32Slot(1, symmetryContextSize, 0)
+def SelectionModelOptionsAddBatchSize(builder, batchSize): builder.PrependInt32Slot(2, batchSize, 1024)
+def SelectionModelOptionsAddAlwaysClassifySuggestedSelection(builder, alwaysClassifySuggestedSelection): builder.PrependBoolSlot(3, alwaysClassifySuggestedSelection, 0)
+def SelectionModelOptionsEnd(builder): return builder.EndObject()

19/libtextclassifier3/TranslateAnnotatorOptions.py

@@ -0,0 +1,72 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: libtextclassifier3
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class TranslateAnnotatorOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsTranslateAnnotatorOptions(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = TranslateAnnotatorOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def TranslateAnnotatorOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x43\x32\x20", size_prefixed=size_prefixed)
+
+    # TranslateAnnotatorOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # TranslateAnnotatorOptions
+    def Enabled(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # TranslateAnnotatorOptions
+    def Score(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 1.0
+
+    # TranslateAnnotatorOptions
+    def PriorityScore(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # TranslateAnnotatorOptions
+    def Algorithm(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # TranslateAnnotatorOptions
+    def BackoffOptions(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.TranslateAnnotatorOptions_.BackoffOptions import BackoffOptions
+            obj = BackoffOptions()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+def TranslateAnnotatorOptionsStart(builder): builder.StartObject(5)
+def TranslateAnnotatorOptionsAddEnabled(builder, enabled): builder.PrependBoolSlot(0, enabled, 0)
+def TranslateAnnotatorOptionsAddScore(builder, score): builder.PrependFloat32Slot(1, score, 1.0)
+def TranslateAnnotatorOptionsAddPriorityScore(builder, priorityScore): builder.PrependFloat32Slot(2, priorityScore, 0.0)
+def TranslateAnnotatorOptionsAddAlgorithm(builder, algorithm): builder.PrependInt32Slot(3, algorithm, 0)
+def TranslateAnnotatorOptionsAddBackoffOptions(builder, backoffOptions): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(backoffOptions), 0)
+def TranslateAnnotatorOptionsEnd(builder): return builder.EndObject()

19/libtextclassifier3/TranslateAnnotatorOptions_/Algorithm.py

@@ -0,0 +1,8 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: TranslateAnnotatorOptions_
+
+class Algorithm(object):
+    DEFAULT_ALGORITHM = 0
+    BACKOFF = 1
+

19/libtextclassifier3/TranslateAnnotatorOptions_/BackoffOptions.py

@@ -0,0 +1,52 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: TranslateAnnotatorOptions_
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class BackoffOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsBackoffOptions(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = BackoffOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def BackoffOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x43\x32\x20", size_prefixed=size_prefixed)
+
+    # BackoffOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # BackoffOptions
+    def MinTextSize(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 20
+
+    # BackoffOptions
+    def PenalizeRatio(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 1.0
+
+    # BackoffOptions
+    def SubjectTextScoreRatio(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.4
+
+def BackoffOptionsStart(builder): builder.StartObject(3)
+def BackoffOptionsAddMinTextSize(builder, minTextSize): builder.PrependInt32Slot(0, minTextSize, 20)
+def BackoffOptionsAddPenalizeRatio(builder, penalizeRatio): builder.PrependFloat32Slot(1, penalizeRatio, 1.0)
+def BackoffOptionsAddSubjectTextScoreRatio(builder, subjectTextScoreRatio): builder.PrependFloat32Slot(2, subjectTextScoreRatio, 0.4)
+def BackoffOptionsEnd(builder): return builder.EndObject()

19/libtextclassifier3/VerificationOptions.py

@@ -0,0 +1,44 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: libtextclassifier3
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class VerificationOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsVerificationOptions(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = VerificationOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def VerificationOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x43\x32\x20", size_prefixed=size_prefixed)
+
+    # VerificationOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # VerificationOptions
+    def VerifyLuhnChecksum(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # VerificationOptions
+    def LuaVerifier(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 -1
+
+def VerificationOptionsStart(builder): builder.StartObject(2)
+def VerificationOptionsAddVerifyLuhnChecksum(builder, verifyLuhnChecksum): builder.PrependBoolSlot(0, verifyLuhnChecksum, 0)
+def VerificationOptionsAddLuaVerifier(builder, luaVerifier): builder.PrependInt32Slot(1, luaVerifier, -1)
+def VerificationOptionsEnd(builder): return builder.EndObject()

19/libtextclassifier3/VocabModel.py

@@ -0,0 +1,105 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: libtextclassifier3
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class VocabModel(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAsVocabModel(cls, buf, offset):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = VocabModel()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def VocabModelBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x43\x32\x20", size_prefixed=size_prefixed)
+
+    # VocabModel
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # VocabModel
+    def VocabTrie(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        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
+
+    # VocabModel
+    def VocabTrieAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # VocabModel
+    def VocabTrieLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # VocabModel
+    def VocabTrieIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        return o == 0
+
+    # VocabModel
+    def BeginnerLevel(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from libtextclassifier3.BitVectorData import BitVectorData
+            obj = BitVectorData()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # VocabModel
+    def DoNotTriggerInUpperCase(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from libtextclassifier3.BitVectorData import BitVectorData
+            obj = BitVectorData()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # VocabModel
+    def TriggeringLocales(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # VocabModel
+    def TargetClassificationScore(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 1.0
+
+    # VocabModel
+    def PriorityScore(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+def VocabModelStart(builder): builder.StartObject(6)
+def VocabModelAddVocabTrie(builder, vocabTrie): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(vocabTrie), 0)
+def VocabModelStartVocabTrieVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def VocabModelAddBeginnerLevel(builder, beginnerLevel): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(beginnerLevel), 0)
+def VocabModelAddDoNotTriggerInUpperCase(builder, doNotTriggerInUpperCase): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(doNotTriggerInUpperCase), 0)
+def VocabModelAddTriggeringLocales(builder, triggeringLocales): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(triggeringLocales), 0)
+def VocabModelAddTargetClassificationScore(builder, targetClassificationScore): builder.PrependFloat32Slot(4, targetClassificationScore, 1.0)
+def VocabModelAddPriorityScore(builder, priorityScore): builder.PrependFloat32Slot(5, priorityScore, 0.0)
+def VocabModelEnd(builder): return builder.EndObject()