diff --git a/19/libtextclassifier3/AnnotationUsecase.py b/19/libtextclassifier3/AnnotationUsecase.py new file mode 100644 index 0000000000000000000000000000000000000000..061ca3566d75e209815cb82d4a89dbb99318d7b8 --- /dev/null +++ b/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 + diff --git a/19/libtextclassifier3/CapturingGroup.py b/19/libtextclassifier3/CapturingGroup.py new file mode 100644 index 0000000000000000000000000000000000000000..e7391a5571572e7153ada111964dc3ec610975ce --- /dev/null +++ b/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() diff --git a/19/libtextclassifier3/ClassificationModelOptions.py b/19/libtextclassifier3/ClassificationModelOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..8b7137d4a4e2f4e544a791cd14870a29f86043e7 --- /dev/null +++ b/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() diff --git a/19/libtextclassifier3/ContactAnnotatorOptions.py b/19/libtextclassifier3/ContactAnnotatorOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..cc01a3fdffe8766fdc62743a5c7c3180f5116e76 --- /dev/null +++ b/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() diff --git a/19/libtextclassifier3/DatetimeExtractorType.py b/19/libtextclassifier3/DatetimeExtractorType.py new file mode 100644 index 0000000000000000000000000000000000000000..a6613fdcb1e1d332705c7998e557a6956d85a1c5 --- /dev/null +++ b/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 + diff --git a/19/libtextclassifier3/DatetimeGroupType.py b/19/libtextclassifier3/DatetimeGroupType.py new file mode 100644 index 0000000000000000000000000000000000000000..c3e551f77541ec22dac3d4eef550aec781eadbc3 --- /dev/null +++ b/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 + diff --git a/19/libtextclassifier3/DatetimeModel.py b/19/libtextclassifier3/DatetimeModel.py new file mode 100644 index 0000000000000000000000000000000000000000..f10aeabf7218ae05e7b710a888e753c06e62c366 --- /dev/null +++ b/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() diff --git a/19/libtextclassifier3/DatetimeModelExtractor.py b/19/libtextclassifier3/DatetimeModelExtractor.py new file mode 100644 index 0000000000000000000000000000000000000000..9bd9ec8d16d2a8c04a396aa4187c0642f4230bab --- /dev/null +++ b/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() diff --git a/19/libtextclassifier3/DatetimeModelLibrary.py b/19/libtextclassifier3/DatetimeModelLibrary.py new file mode 100644 index 0000000000000000000000000000000000000000..94643462261106c98a63ae25836632d0c178b727 --- /dev/null +++ b/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() diff --git a/19/libtextclassifier3/DatetimeModelLibrary_/Item.py b/19/libtextclassifier3/DatetimeModelLibrary_/Item.py new file mode 100644 index 0000000000000000000000000000000000000000..af9f9138bd6e34549355d997a0e297c820262984 --- /dev/null +++ b/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() diff --git a/19/libtextclassifier3/DatetimeModelPattern.py b/19/libtextclassifier3/DatetimeModelPattern.py new file mode 100644 index 0000000000000000000000000000000000000000..d3c9a6f33ae8818433be009046947c6d2d206935 --- /dev/null +++ b/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() diff --git a/19/libtextclassifier3/DatetimeModelPattern_/Regex.py b/19/libtextclassifier3/DatetimeModelPattern_/Regex.py new file mode 100644 index 0000000000000000000000000000000000000000..744be9e3f676f62050e05ea335078b961bab941d --- /dev/null +++ b/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() diff --git a/19/libtextclassifier3/DurationAnnotatorOptions.py b/19/libtextclassifier3/DurationAnnotatorOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..86ad482a1ba50210fece1f576c9ba0f092221e2d --- /dev/null +++ b/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() diff --git a/19/libtextclassifier3/FeatureProcessorOptions.py b/19/libtextclassifier3/FeatureProcessorOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..e8ce1f31123705854d1b0e894428eec4c87d706d --- /dev/null +++ b/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() diff --git a/19/libtextclassifier3/FeatureProcessorOptions_/BoundsSensitiveFeatures.py b/19/libtextclassifier3/FeatureProcessorOptions_/BoundsSensitiveFeatures.py new file mode 100644 index 0000000000000000000000000000000000000000..cef003a46cec087574ebcff447003cf5ae680031 --- /dev/null +++ b/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() diff --git a/19/libtextclassifier3/FeatureProcessorOptions_/CenterTokenSelectionMethod.py b/19/libtextclassifier3/FeatureProcessorOptions_/CenterTokenSelectionMethod.py new file mode 100644 index 0000000000000000000000000000000000000000..d123be1f7fb9be7af7d066685249af94f7be32ee --- /dev/null +++ b/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 + diff --git a/19/libtextclassifier3/FeatureProcessorOptions_/__init__.py b/19/libtextclassifier3/FeatureProcessorOptions_/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/19/libtextclassifier3/GrammarModel.py b/19/libtextclassifier3/GrammarModel.py new file mode 100644 index 0000000000000000000000000000000000000000..414d6bc17eab28580545b3cec666325718ad3bed --- /dev/null +++ b/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() diff --git a/19/libtextclassifier3/GrammarModel_/RuleClassificationResult.py b/19/libtextclassifier3/GrammarModel_/RuleClassificationResult.py new file mode 100644 index 0000000000000000000000000000000000000000..32caad1b6b9c4b2a775fdd9616d182a5dca03e13 --- /dev/null +++ b/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() diff --git a/19/libtextclassifier3/GrammarTokenizerOptions.py b/19/libtextclassifier3/GrammarTokenizerOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..474e060c40e54837045cbc93dd5ca39c609671cf --- /dev/null +++ b/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() diff --git a/19/libtextclassifier3/ModeFlag.py b/19/libtextclassifier3/ModeFlag.py new file mode 100644 index 0000000000000000000000000000000000000000..f75016cb4550f92cee776134f32fd4b7d8700cab --- /dev/null +++ b/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 + diff --git a/19/libtextclassifier3/Model.py b/19/libtextclassifier3/Model.py new file mode 100644 index 0000000000000000000000000000000000000000..9594a989a7d2c6332dbe50c154a48de3c65efaff --- /dev/null +++ b/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() diff --git a/19/libtextclassifier3/ModelTriggeringOptions.py b/19/libtextclassifier3/ModelTriggeringOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..2d7cb4093bbb417d0001e6fcb875c0ec18a6d6aa --- /dev/null +++ b/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() diff --git a/19/libtextclassifier3/ModelTriggeringOptions_/CollectionToPriorityEntry.py b/19/libtextclassifier3/ModelTriggeringOptions_/CollectionToPriorityEntry.py new file mode 100644 index 0000000000000000000000000000000000000000..7303c6e865e2873173ca236fefcac4d3d4e89aeb --- /dev/null +++ b/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() diff --git a/19/libtextclassifier3/Model_/ConflictResolutionOptions.py b/19/libtextclassifier3/Model_/ConflictResolutionOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..f3e5baf4040d5868b2de0044286baa24ae14f956 --- /dev/null +++ b/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() diff --git a/19/libtextclassifier3/Model_/EmbeddingPruningMask.py b/19/libtextclassifier3/Model_/EmbeddingPruningMask.py new file mode 100644 index 0000000000000000000000000000000000000000..4e866072bebd2b64dc97ecbc5e4e2cef8d8210e4 --- /dev/null +++ b/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() diff --git a/19/libtextclassifier3/Model_/__init__.py b/19/libtextclassifier3/Model_/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/19/libtextclassifier3/MoneyParsingOptions.py b/19/libtextclassifier3/MoneyParsingOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..4b79d18a9b30ea57cf9de07bd078e48f252ce86e --- /dev/null +++ b/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() diff --git a/19/libtextclassifier3/MoneyParsingOptions_/QuantitiesNameToExponentEntry.py b/19/libtextclassifier3/MoneyParsingOptions_/QuantitiesNameToExponentEntry.py new file mode 100644 index 0000000000000000000000000000000000000000..bee64b3c015b2394ce392e3379dce95c8ed8e0bd --- /dev/null +++ b/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() diff --git a/19/libtextclassifier3/NumberAnnotatorOptions.py b/19/libtextclassifier3/NumberAnnotatorOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..6303e2bf7bd3576b4e1c4ad56742c95c3d1be0d7 --- /dev/null +++ b/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() diff --git a/19/libtextclassifier3/OutputOptions.py b/19/libtextclassifier3/OutputOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..d81712510f7108632acc2abcfdb9fc7f8e0ed24d --- /dev/null +++ b/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() diff --git a/19/libtextclassifier3/PodNerModel.py b/19/libtextclassifier3/PodNerModel.py new file mode 100644 index 0000000000000000000000000000000000000000..4bc99e5cba1f3f4c67f128f67cd7c7e64e731231 --- /dev/null +++ b/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() diff --git a/19/libtextclassifier3/PodNerModel_/Collection.py b/19/libtextclassifier3/PodNerModel_/Collection.py new file mode 100644 index 0000000000000000000000000000000000000000..a023efa603df0f80e534b2ed4c3c1728e9b82c77 --- /dev/null +++ b/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() diff --git a/19/libtextclassifier3/PodNerModel_/Label.py b/19/libtextclassifier3/PodNerModel_/Label.py new file mode 100644 index 0000000000000000000000000000000000000000..b24510db823d4d3e35ef8ec2cf832cf782a3b881 --- /dev/null +++ b/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() diff --git a/19/libtextclassifier3/PodNerModel_/Label_/BoiseType.py b/19/libtextclassifier3/PodNerModel_/Label_/BoiseType.py new file mode 100644 index 0000000000000000000000000000000000000000..e003177ee3858265a440eb26881b1dcdbfd35780 --- /dev/null +++ b/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 + diff --git a/19/libtextclassifier3/PodNerModel_/Label_/MentionType.py b/19/libtextclassifier3/PodNerModel_/Label_/MentionType.py new file mode 100644 index 0000000000000000000000000000000000000000..86584faa1348a97b7b679fcf223e06673b56bf6b --- /dev/null +++ b/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 + diff --git a/19/libtextclassifier3/PodNerModel_/Label_/__init__.py b/19/libtextclassifier3/PodNerModel_/Label_/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/19/libtextclassifier3/PodNerModel_/__init__.py b/19/libtextclassifier3/PodNerModel_/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/19/libtextclassifier3/RegexModel.py b/19/libtextclassifier3/RegexModel.py new file mode 100644 index 0000000000000000000000000000000000000000..e5210aad58f966150838ed13e0145baab6b0a72b --- /dev/null +++ b/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() diff --git a/19/libtextclassifier3/RegexModel_/Pattern.py b/19/libtextclassifier3/RegexModel_/Pattern.py new file mode 100644 index 0000000000000000000000000000000000000000..1bfce55cb9ac2685736eaf5ab83f96eb9c6ee055 --- /dev/null +++ b/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() diff --git a/19/libtextclassifier3/SelectionModelOptions.py b/19/libtextclassifier3/SelectionModelOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..7edf0065c7d9f25b6604abb55d3355891a2d7c22 --- /dev/null +++ b/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() diff --git a/19/libtextclassifier3/TranslateAnnotatorOptions.py b/19/libtextclassifier3/TranslateAnnotatorOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..a81a2294769dab891720b28a7e53d1446b3e2ec7 --- /dev/null +++ b/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() diff --git a/19/libtextclassifier3/TranslateAnnotatorOptions_/Algorithm.py b/19/libtextclassifier3/TranslateAnnotatorOptions_/Algorithm.py new file mode 100644 index 0000000000000000000000000000000000000000..f1aa6d0b7f7a4c735cd80d29f8cd1aa9de7eac74 --- /dev/null +++ b/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 + diff --git a/19/libtextclassifier3/TranslateAnnotatorOptions_/BackoffOptions.py b/19/libtextclassifier3/TranslateAnnotatorOptions_/BackoffOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..d9bf47ddc96c50fbab9889b19b6d3254d5b88f91 --- /dev/null +++ b/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() diff --git a/19/libtextclassifier3/TranslateAnnotatorOptions_/__init__.py b/19/libtextclassifier3/TranslateAnnotatorOptions_/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/19/libtextclassifier3/VerificationOptions.py b/19/libtextclassifier3/VerificationOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..790711192afd1a42740159a879371d706f7330b5 --- /dev/null +++ b/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() diff --git a/19/libtextclassifier3/VocabModel.py b/19/libtextclassifier3/VocabModel.py new file mode 100644 index 0000000000000000000000000000000000000000..9f9a5e4c9fb54ca9e0e1d52dd59746e1f8bd66d5 --- /dev/null +++ b/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() diff --git a/19/libtextclassifier3/__init__.py b/19/libtextclassifier3/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/19/libtextclassifier3/__pycache__/FeatureProcessorOptions.cpython-310.pyc b/19/libtextclassifier3/__pycache__/FeatureProcessorOptions.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..077b199a5fd3961a141d0199686b132d5d54f432 Binary files /dev/null and b/19/libtextclassifier3/__pycache__/FeatureProcessorOptions.cpython-310.pyc differ diff --git a/19/libtextclassifier3/__pycache__/Model.cpython-310.pyc b/19/libtextclassifier3/__pycache__/Model.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..df5e42b9bfecced15a6891cc4e1baefba6bd5748 Binary files /dev/null and b/19/libtextclassifier3/__pycache__/Model.cpython-310.pyc differ diff --git a/19/libtextclassifier3/__pycache__/__init__.cpython-310.pyc b/19/libtextclassifier3/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..803e3e2537b47707ece9032ed052e634d57de98a Binary files /dev/null and b/19/libtextclassifier3/__pycache__/__init__.cpython-310.pyc differ