1# Copyright 2020 The TensorFlow Authors. All Rights Reserved. 2# 3# Licensed under the Apache License, Version 2.0 (the "License"); 4# you may not use this file except in compliance with the License. 5# You may obtain a copy of the License at 6# 7# http://www.apache.org/licenses/LICENSE-2.0 8# 9# Unless required by applicable law or agreed to in writing, software 10# distributed under the License is distributed on an "AS IS" BASIS, 11# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12# See the License for the specific language governing permissions and 13# limitations under the License. 14# ============================================================================== 15from tflite_support import flatbuffers 16# automatically generated by the FlatBuffers compiler, do not modify 17 18# namespace: tflite 19 20from tflite_support.flatbuffers.compat import import_numpy 21np = import_numpy() 22 23class ValueRange(object): 24 __slots__ = ['_tab'] 25 26 @classmethod 27 def GetRootAsValueRange(cls, buf, offset): 28 n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) 29 x = ValueRange() 30 x.Init(buf, n + offset) 31 return x 32 33 @classmethod 34 def ValueRangeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): 35 return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x30\x30\x31", size_prefixed=size_prefixed) 36 37 # ValueRange 38 def Init(self, buf, pos): 39 self._tab = flatbuffers.table.Table(buf, pos) 40 41 # ValueRange 42 def Min(self): 43 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) 44 if o != 0: 45 return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) 46 return 0 47 48 # ValueRange 49 def Max(self): 50 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) 51 if o != 0: 52 return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) 53 return 0 54 55def ValueRangeStart(builder): builder.StartObject(2) 56def ValueRangeAddMin(builder, min): builder.PrependInt32Slot(0, min, 0) 57def ValueRangeAddMax(builder, max): builder.PrependInt32Slot(1, max, 0) 58def ValueRangeEnd(builder): return builder.EndObject() 59 60 61class ValueRangeT(object): 62 63 # ValueRangeT 64 def __init__(self): 65 self.min = 0 # type: int 66 self.max = 0 # type: int 67 68 @classmethod 69 def InitFromBuf(cls, buf, pos): 70 valueRange = ValueRange() 71 valueRange.Init(buf, pos) 72 return cls.InitFromObj(valueRange) 73 74 @classmethod 75 def InitFromObj(cls, valueRange): 76 x = ValueRangeT() 77 x._UnPack(valueRange) 78 return x 79 80 # ValueRangeT 81 def _UnPack(self, valueRange): 82 if valueRange is None: 83 return 84 self.min = valueRange.Min() 85 self.max = valueRange.Max() 86 87 # ValueRangeT 88 def Pack(self, builder): 89 ValueRangeStart(builder) 90 ValueRangeAddMin(builder, self.min) 91 ValueRangeAddMax(builder, self.max) 92 valueRange = ValueRangeEnd(builder) 93 return valueRange 94# automatically generated by the FlatBuffers compiler, do not modify 95 96# namespace: tflite 97 98from tflite_support.flatbuffers.compat import import_numpy 99np = import_numpy() 100 101class TensorMetadata(object): 102 __slots__ = ['_tab'] 103 104 @classmethod 105 def GetRootAsTensorMetadata(cls, buf, offset): 106 n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) 107 x = TensorMetadata() 108 x.Init(buf, n + offset) 109 return x 110 111 @classmethod 112 def TensorMetadataBufferHasIdentifier(cls, buf, offset, size_prefixed=False): 113 return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x30\x30\x31", size_prefixed=size_prefixed) 114 115 # TensorMetadata 116 def Init(self, buf, pos): 117 self._tab = flatbuffers.table.Table(buf, pos) 118 119 # TensorMetadata 120 def Name(self): 121 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) 122 if o != 0: 123 return self._tab.String(o + self._tab.Pos) 124 return None 125 126 # TensorMetadata 127 def Description(self): 128 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) 129 if o != 0: 130 return self._tab.String(o + self._tab.Pos) 131 return None 132 133 # TensorMetadata 134 def DimensionNames(self, j): 135 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) 136 if o != 0: 137 a = self._tab.Vector(o) 138 return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) 139 return "" 140 141 # TensorMetadata 142 def DimensionNamesLength(self): 143 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) 144 if o != 0: 145 return self._tab.VectorLen(o) 146 return 0 147 148 # TensorMetadata 149 def DimensionNamesIsNone(self): 150 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) 151 return o == 0 152 153 # TensorMetadata 154 def Content(self): 155 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) 156 if o != 0: 157 x = self._tab.Indirect(o + self._tab.Pos) 158 obj = Content() 159 obj.Init(self._tab.Bytes, x) 160 return obj 161 return None 162 163 # TensorMetadata 164 def ProcessUnits(self, j): 165 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) 166 if o != 0: 167 x = self._tab.Vector(o) 168 x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 169 x = self._tab.Indirect(x) 170 obj = ProcessUnit() 171 obj.Init(self._tab.Bytes, x) 172 return obj 173 return None 174 175 # TensorMetadata 176 def ProcessUnitsLength(self): 177 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) 178 if o != 0: 179 return self._tab.VectorLen(o) 180 return 0 181 182 # TensorMetadata 183 def ProcessUnitsIsNone(self): 184 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) 185 return o == 0 186 187 # TensorMetadata 188 def Stats(self): 189 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) 190 if o != 0: 191 x = self._tab.Indirect(o + self._tab.Pos) 192 obj = Stats() 193 obj.Init(self._tab.Bytes, x) 194 return obj 195 return None 196 197 # TensorMetadata 198 def AssociatedFiles(self, j): 199 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) 200 if o != 0: 201 x = self._tab.Vector(o) 202 x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 203 x = self._tab.Indirect(x) 204 obj = AssociatedFile() 205 obj.Init(self._tab.Bytes, x) 206 return obj 207 return None 208 209 # TensorMetadata 210 def AssociatedFilesLength(self): 211 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) 212 if o != 0: 213 return self._tab.VectorLen(o) 214 return 0 215 216 # TensorMetadata 217 def AssociatedFilesIsNone(self): 218 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) 219 return o == 0 220 221def TensorMetadataStart(builder): builder.StartObject(7) 222def TensorMetadataAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) 223def TensorMetadataAddDescription(builder, description): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(description), 0) 224def TensorMetadataAddDimensionNames(builder, dimensionNames): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(dimensionNames), 0) 225def TensorMetadataStartDimensionNamesVector(builder, numElems): return builder.StartVector(4, numElems, 4) 226def TensorMetadataAddContent(builder, content): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(content), 0) 227def TensorMetadataAddProcessUnits(builder, processUnits): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(processUnits), 0) 228def TensorMetadataStartProcessUnitsVector(builder, numElems): return builder.StartVector(4, numElems, 4) 229def TensorMetadataAddStats(builder, stats): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(stats), 0) 230def TensorMetadataAddAssociatedFiles(builder, associatedFiles): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(associatedFiles), 0) 231def TensorMetadataStartAssociatedFilesVector(builder, numElems): return builder.StartVector(4, numElems, 4) 232def TensorMetadataEnd(builder): return builder.EndObject() 233 234try: 235 from typing import List, Optional 236except: 237 pass 238 239class TensorMetadataT(object): 240 241 # TensorMetadataT 242 def __init__(self): 243 self.name = None # type: str 244 self.description = None # type: str 245 self.dimensionNames = None # type: List[str] 246 self.content = None # type: Optional[ContentT] 247 self.processUnits = None # type: List[ProcessUnitT] 248 self.stats = None # type: Optional[StatsT] 249 self.associatedFiles = None # type: List[AssociatedFileT] 250 251 @classmethod 252 def InitFromBuf(cls, buf, pos): 253 tensorMetadata = TensorMetadata() 254 tensorMetadata.Init(buf, pos) 255 return cls.InitFromObj(tensorMetadata) 256 257 @classmethod 258 def InitFromObj(cls, tensorMetadata): 259 x = TensorMetadataT() 260 x._UnPack(tensorMetadata) 261 return x 262 263 # TensorMetadataT 264 def _UnPack(self, tensorMetadata): 265 if tensorMetadata is None: 266 return 267 self.name = tensorMetadata.Name() 268 self.description = tensorMetadata.Description() 269 if not tensorMetadata.DimensionNamesIsNone(): 270 self.dimensionNames = [] 271 for i in range(tensorMetadata.DimensionNamesLength()): 272 self.dimensionNames.append(tensorMetadata.DimensionNames(i)) 273 if tensorMetadata.Content() is not None: 274 self.content = ContentT.InitFromObj(tensorMetadata.Content()) 275 if not tensorMetadata.ProcessUnitsIsNone(): 276 self.processUnits = [] 277 for i in range(tensorMetadata.ProcessUnitsLength()): 278 if tensorMetadata.ProcessUnits(i) is None: 279 self.processUnits.append(None) 280 else: 281 processUnit_ = ProcessUnitT.InitFromObj(tensorMetadata.ProcessUnits(i)) 282 self.processUnits.append(processUnit_) 283 if tensorMetadata.Stats() is not None: 284 self.stats = StatsT.InitFromObj(tensorMetadata.Stats()) 285 if not tensorMetadata.AssociatedFilesIsNone(): 286 self.associatedFiles = [] 287 for i in range(tensorMetadata.AssociatedFilesLength()): 288 if tensorMetadata.AssociatedFiles(i) is None: 289 self.associatedFiles.append(None) 290 else: 291 associatedFile_ = AssociatedFileT.InitFromObj(tensorMetadata.AssociatedFiles(i)) 292 self.associatedFiles.append(associatedFile_) 293 294 # TensorMetadataT 295 def Pack(self, builder): 296 if self.name is not None: 297 name = builder.CreateString(self.name) 298 if self.description is not None: 299 description = builder.CreateString(self.description) 300 if self.dimensionNames is not None: 301 dimensionNameslist = [] 302 for i in range(len(self.dimensionNames)): 303 dimensionNameslist.append(builder.CreateString(self.dimensionNames[i])) 304 TensorMetadataStartDimensionNamesVector(builder, len(self.dimensionNames)) 305 for i in reversed(range(len(self.dimensionNames))): 306 builder.PrependUOffsetTRelative(dimensionNameslist[i]) 307 dimensionNames = builder.EndVector(len(self.dimensionNames)) 308 if self.content is not None: 309 content = self.content.Pack(builder) 310 if self.processUnits is not None: 311 processUnitslist = [] 312 for i in range(len(self.processUnits)): 313 processUnitslist.append(self.processUnits[i].Pack(builder)) 314 TensorMetadataStartProcessUnitsVector(builder, len(self.processUnits)) 315 for i in reversed(range(len(self.processUnits))): 316 builder.PrependUOffsetTRelative(processUnitslist[i]) 317 processUnits = builder.EndVector(len(self.processUnits)) 318 if self.stats is not None: 319 stats = self.stats.Pack(builder) 320 if self.associatedFiles is not None: 321 associatedFileslist = [] 322 for i in range(len(self.associatedFiles)): 323 associatedFileslist.append(self.associatedFiles[i].Pack(builder)) 324 TensorMetadataStartAssociatedFilesVector(builder, len(self.associatedFiles)) 325 for i in reversed(range(len(self.associatedFiles))): 326 builder.PrependUOffsetTRelative(associatedFileslist[i]) 327 associatedFiles = builder.EndVector(len(self.associatedFiles)) 328 TensorMetadataStart(builder) 329 if self.name is not None: 330 TensorMetadataAddName(builder, name) 331 if self.description is not None: 332 TensorMetadataAddDescription(builder, description) 333 if self.dimensionNames is not None: 334 TensorMetadataAddDimensionNames(builder, dimensionNames) 335 if self.content is not None: 336 TensorMetadataAddContent(builder, content) 337 if self.processUnits is not None: 338 TensorMetadataAddProcessUnits(builder, processUnits) 339 if self.stats is not None: 340 TensorMetadataAddStats(builder, stats) 341 if self.associatedFiles is not None: 342 TensorMetadataAddAssociatedFiles(builder, associatedFiles) 343 tensorMetadata = TensorMetadataEnd(builder) 344 return tensorMetadata 345# automatically generated by the FlatBuffers compiler, do not modify 346 347# namespace: tflite 348 349from tflite_support.flatbuffers.compat import import_numpy 350np = import_numpy() 351 352class SubGraphMetadata(object): 353 __slots__ = ['_tab'] 354 355 @classmethod 356 def GetRootAsSubGraphMetadata(cls, buf, offset): 357 n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) 358 x = SubGraphMetadata() 359 x.Init(buf, n + offset) 360 return x 361 362 @classmethod 363 def SubGraphMetadataBufferHasIdentifier(cls, buf, offset, size_prefixed=False): 364 return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x30\x30\x31", size_prefixed=size_prefixed) 365 366 # SubGraphMetadata 367 def Init(self, buf, pos): 368 self._tab = flatbuffers.table.Table(buf, pos) 369 370 # SubGraphMetadata 371 def Name(self): 372 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) 373 if o != 0: 374 return self._tab.String(o + self._tab.Pos) 375 return None 376 377 # SubGraphMetadata 378 def Description(self): 379 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) 380 if o != 0: 381 return self._tab.String(o + self._tab.Pos) 382 return None 383 384 # SubGraphMetadata 385 def InputTensorMetadata(self, j): 386 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) 387 if o != 0: 388 x = self._tab.Vector(o) 389 x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 390 x = self._tab.Indirect(x) 391 obj = TensorMetadata() 392 obj.Init(self._tab.Bytes, x) 393 return obj 394 return None 395 396 # SubGraphMetadata 397 def InputTensorMetadataLength(self): 398 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) 399 if o != 0: 400 return self._tab.VectorLen(o) 401 return 0 402 403 # SubGraphMetadata 404 def InputTensorMetadataIsNone(self): 405 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) 406 return o == 0 407 408 # SubGraphMetadata 409 def OutputTensorMetadata(self, j): 410 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) 411 if o != 0: 412 x = self._tab.Vector(o) 413 x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 414 x = self._tab.Indirect(x) 415 obj = TensorMetadata() 416 obj.Init(self._tab.Bytes, x) 417 return obj 418 return None 419 420 # SubGraphMetadata 421 def OutputTensorMetadataLength(self): 422 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) 423 if o != 0: 424 return self._tab.VectorLen(o) 425 return 0 426 427 # SubGraphMetadata 428 def OutputTensorMetadataIsNone(self): 429 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) 430 return o == 0 431 432 # SubGraphMetadata 433 def AssociatedFiles(self, j): 434 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) 435 if o != 0: 436 x = self._tab.Vector(o) 437 x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 438 x = self._tab.Indirect(x) 439 obj = AssociatedFile() 440 obj.Init(self._tab.Bytes, x) 441 return obj 442 return None 443 444 # SubGraphMetadata 445 def AssociatedFilesLength(self): 446 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) 447 if o != 0: 448 return self._tab.VectorLen(o) 449 return 0 450 451 # SubGraphMetadata 452 def AssociatedFilesIsNone(self): 453 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) 454 return o == 0 455 456def SubGraphMetadataStart(builder): builder.StartObject(5) 457def SubGraphMetadataAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) 458def SubGraphMetadataAddDescription(builder, description): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(description), 0) 459def SubGraphMetadataAddInputTensorMetadata(builder, inputTensorMetadata): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(inputTensorMetadata), 0) 460def SubGraphMetadataStartInputTensorMetadataVector(builder, numElems): return builder.StartVector(4, numElems, 4) 461def SubGraphMetadataAddOutputTensorMetadata(builder, outputTensorMetadata): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(outputTensorMetadata), 0) 462def SubGraphMetadataStartOutputTensorMetadataVector(builder, numElems): return builder.StartVector(4, numElems, 4) 463def SubGraphMetadataAddAssociatedFiles(builder, associatedFiles): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(associatedFiles), 0) 464def SubGraphMetadataStartAssociatedFilesVector(builder, numElems): return builder.StartVector(4, numElems, 4) 465def SubGraphMetadataEnd(builder): return builder.EndObject() 466 467try: 468 from typing import List 469except: 470 pass 471 472class SubGraphMetadataT(object): 473 474 # SubGraphMetadataT 475 def __init__(self): 476 self.name = None # type: str 477 self.description = None # type: str 478 self.inputTensorMetadata = None # type: List[TensorMetadataT] 479 self.outputTensorMetadata = None # type: List[TensorMetadataT] 480 self.associatedFiles = None # type: List[AssociatedFileT] 481 482 @classmethod 483 def InitFromBuf(cls, buf, pos): 484 subGraphMetadata = SubGraphMetadata() 485 subGraphMetadata.Init(buf, pos) 486 return cls.InitFromObj(subGraphMetadata) 487 488 @classmethod 489 def InitFromObj(cls, subGraphMetadata): 490 x = SubGraphMetadataT() 491 x._UnPack(subGraphMetadata) 492 return x 493 494 # SubGraphMetadataT 495 def _UnPack(self, subGraphMetadata): 496 if subGraphMetadata is None: 497 return 498 self.name = subGraphMetadata.Name() 499 self.description = subGraphMetadata.Description() 500 if not subGraphMetadata.InputTensorMetadataIsNone(): 501 self.inputTensorMetadata = [] 502 for i in range(subGraphMetadata.InputTensorMetadataLength()): 503 if subGraphMetadata.InputTensorMetadata(i) is None: 504 self.inputTensorMetadata.append(None) 505 else: 506 tensorMetadata_ = TensorMetadataT.InitFromObj(subGraphMetadata.InputTensorMetadata(i)) 507 self.inputTensorMetadata.append(tensorMetadata_) 508 if not subGraphMetadata.OutputTensorMetadataIsNone(): 509 self.outputTensorMetadata = [] 510 for i in range(subGraphMetadata.OutputTensorMetadataLength()): 511 if subGraphMetadata.OutputTensorMetadata(i) is None: 512 self.outputTensorMetadata.append(None) 513 else: 514 tensorMetadata_ = TensorMetadataT.InitFromObj(subGraphMetadata.OutputTensorMetadata(i)) 515 self.outputTensorMetadata.append(tensorMetadata_) 516 if not subGraphMetadata.AssociatedFilesIsNone(): 517 self.associatedFiles = [] 518 for i in range(subGraphMetadata.AssociatedFilesLength()): 519 if subGraphMetadata.AssociatedFiles(i) is None: 520 self.associatedFiles.append(None) 521 else: 522 associatedFile_ = AssociatedFileT.InitFromObj(subGraphMetadata.AssociatedFiles(i)) 523 self.associatedFiles.append(associatedFile_) 524 525 # SubGraphMetadataT 526 def Pack(self, builder): 527 if self.name is not None: 528 name = builder.CreateString(self.name) 529 if self.description is not None: 530 description = builder.CreateString(self.description) 531 if self.inputTensorMetadata is not None: 532 inputTensorMetadatalist = [] 533 for i in range(len(self.inputTensorMetadata)): 534 inputTensorMetadatalist.append(self.inputTensorMetadata[i].Pack(builder)) 535 SubGraphMetadataStartInputTensorMetadataVector(builder, len(self.inputTensorMetadata)) 536 for i in reversed(range(len(self.inputTensorMetadata))): 537 builder.PrependUOffsetTRelative(inputTensorMetadatalist[i]) 538 inputTensorMetadata = builder.EndVector(len(self.inputTensorMetadata)) 539 if self.outputTensorMetadata is not None: 540 outputTensorMetadatalist = [] 541 for i in range(len(self.outputTensorMetadata)): 542 outputTensorMetadatalist.append(self.outputTensorMetadata[i].Pack(builder)) 543 SubGraphMetadataStartOutputTensorMetadataVector(builder, len(self.outputTensorMetadata)) 544 for i in reversed(range(len(self.outputTensorMetadata))): 545 builder.PrependUOffsetTRelative(outputTensorMetadatalist[i]) 546 outputTensorMetadata = builder.EndVector(len(self.outputTensorMetadata)) 547 if self.associatedFiles is not None: 548 associatedFileslist = [] 549 for i in range(len(self.associatedFiles)): 550 associatedFileslist.append(self.associatedFiles[i].Pack(builder)) 551 SubGraphMetadataStartAssociatedFilesVector(builder, len(self.associatedFiles)) 552 for i in reversed(range(len(self.associatedFiles))): 553 builder.PrependUOffsetTRelative(associatedFileslist[i]) 554 associatedFiles = builder.EndVector(len(self.associatedFiles)) 555 SubGraphMetadataStart(builder) 556 if self.name is not None: 557 SubGraphMetadataAddName(builder, name) 558 if self.description is not None: 559 SubGraphMetadataAddDescription(builder, description) 560 if self.inputTensorMetadata is not None: 561 SubGraphMetadataAddInputTensorMetadata(builder, inputTensorMetadata) 562 if self.outputTensorMetadata is not None: 563 SubGraphMetadataAddOutputTensorMetadata(builder, outputTensorMetadata) 564 if self.associatedFiles is not None: 565 SubGraphMetadataAddAssociatedFiles(builder, associatedFiles) 566 subGraphMetadata = SubGraphMetadataEnd(builder) 567 return subGraphMetadata 568# automatically generated by the FlatBuffers compiler, do not modify 569 570# namespace: tflite 571 572from tflite_support.flatbuffers.compat import import_numpy 573np = import_numpy() 574 575class Stats(object): 576 __slots__ = ['_tab'] 577 578 @classmethod 579 def GetRootAsStats(cls, buf, offset): 580 n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) 581 x = Stats() 582 x.Init(buf, n + offset) 583 return x 584 585 @classmethod 586 def StatsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): 587 return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x30\x30\x31", size_prefixed=size_prefixed) 588 589 # Stats 590 def Init(self, buf, pos): 591 self._tab = flatbuffers.table.Table(buf, pos) 592 593 # Stats 594 def Max(self, j): 595 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) 596 if o != 0: 597 a = self._tab.Vector(o) 598 return self._tab.Get(flatbuffers.number_types.Float32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) 599 return 0 600 601 # Stats 602 def MaxAsNumpy(self): 603 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) 604 if o != 0: 605 return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float32Flags, o) 606 return 0 607 608 # Stats 609 def MaxLength(self): 610 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) 611 if o != 0: 612 return self._tab.VectorLen(o) 613 return 0 614 615 # Stats 616 def MaxIsNone(self): 617 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) 618 return o == 0 619 620 # Stats 621 def Min(self, j): 622 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) 623 if o != 0: 624 a = self._tab.Vector(o) 625 return self._tab.Get(flatbuffers.number_types.Float32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) 626 return 0 627 628 # Stats 629 def MinAsNumpy(self): 630 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) 631 if o != 0: 632 return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float32Flags, o) 633 return 0 634 635 # Stats 636 def MinLength(self): 637 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) 638 if o != 0: 639 return self._tab.VectorLen(o) 640 return 0 641 642 # Stats 643 def MinIsNone(self): 644 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) 645 return o == 0 646 647def StatsStart(builder): builder.StartObject(2) 648def StatsAddMax(builder, max): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(max), 0) 649def StatsStartMaxVector(builder, numElems): return builder.StartVector(4, numElems, 4) 650def StatsAddMin(builder, min): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(min), 0) 651def StatsStartMinVector(builder, numElems): return builder.StartVector(4, numElems, 4) 652def StatsEnd(builder): return builder.EndObject() 653 654try: 655 from typing import List 656except: 657 pass 658 659class StatsT(object): 660 661 # StatsT 662 def __init__(self): 663 self.max = None # type: List[float] 664 self.min = None # type: List[float] 665 666 @classmethod 667 def InitFromBuf(cls, buf, pos): 668 stats = Stats() 669 stats.Init(buf, pos) 670 return cls.InitFromObj(stats) 671 672 @classmethod 673 def InitFromObj(cls, stats): 674 x = StatsT() 675 x._UnPack(stats) 676 return x 677 678 # StatsT 679 def _UnPack(self, stats): 680 if stats is None: 681 return 682 if not stats.MaxIsNone(): 683 if np is None: 684 self.max = [] 685 for i in range(stats.MaxLength()): 686 self.max.append(stats.Max(i)) 687 else: 688 self.max = stats.MaxAsNumpy() 689 if not stats.MinIsNone(): 690 if np is None: 691 self.min = [] 692 for i in range(stats.MinLength()): 693 self.min.append(stats.Min(i)) 694 else: 695 self.min = stats.MinAsNumpy() 696 697 # StatsT 698 def Pack(self, builder): 699 if self.max is not None: 700 if np is not None and type(self.max) is np.ndarray: 701 max = builder.CreateNumpyVector(self.max) 702 else: 703 StatsStartMaxVector(builder, len(self.max)) 704 for i in reversed(range(len(self.max))): 705 builder.PrependFloat32(self.max[i]) 706 max = builder.EndVector(len(self.max)) 707 if self.min is not None: 708 if np is not None and type(self.min) is np.ndarray: 709 min = builder.CreateNumpyVector(self.min) 710 else: 711 StatsStartMinVector(builder, len(self.min)) 712 for i in reversed(range(len(self.min))): 713 builder.PrependFloat32(self.min[i]) 714 min = builder.EndVector(len(self.min)) 715 StatsStart(builder) 716 if self.max is not None: 717 StatsAddMax(builder, max) 718 if self.min is not None: 719 StatsAddMin(builder, min) 720 stats = StatsEnd(builder) 721 return stats 722# automatically generated by the FlatBuffers compiler, do not modify 723 724# namespace: tflite 725 726class ScoreTransformationType(object): 727 IDENTITY = 0 728 LOG = 1 729 INVERSE_LOGISTIC = 2 730 731# automatically generated by the FlatBuffers compiler, do not modify 732 733# namespace: tflite 734 735from tflite_support.flatbuffers.compat import import_numpy 736np = import_numpy() 737 738class ScoreThresholdingOptions(object): 739 __slots__ = ['_tab'] 740 741 @classmethod 742 def GetRootAsScoreThresholdingOptions(cls, buf, offset): 743 n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) 744 x = ScoreThresholdingOptions() 745 x.Init(buf, n + offset) 746 return x 747 748 @classmethod 749 def ScoreThresholdingOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): 750 return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x30\x30\x31", size_prefixed=size_prefixed) 751 752 # ScoreThresholdingOptions 753 def Init(self, buf, pos): 754 self._tab = flatbuffers.table.Table(buf, pos) 755 756 # ScoreThresholdingOptions 757 def GlobalScoreThreshold(self): 758 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) 759 if o != 0: 760 return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) 761 return 0.0 762 763def ScoreThresholdingOptionsStart(builder): builder.StartObject(1) 764def ScoreThresholdingOptionsAddGlobalScoreThreshold(builder, globalScoreThreshold): builder.PrependFloat32Slot(0, globalScoreThreshold, 0.0) 765def ScoreThresholdingOptionsEnd(builder): return builder.EndObject() 766 767 768class ScoreThresholdingOptionsT(object): 769 770 # ScoreThresholdingOptionsT 771 def __init__(self): 772 self.globalScoreThreshold = 0.0 # type: float 773 774 @classmethod 775 def InitFromBuf(cls, buf, pos): 776 scoreThresholdingOptions = ScoreThresholdingOptions() 777 scoreThresholdingOptions.Init(buf, pos) 778 return cls.InitFromObj(scoreThresholdingOptions) 779 780 @classmethod 781 def InitFromObj(cls, scoreThresholdingOptions): 782 x = ScoreThresholdingOptionsT() 783 x._UnPack(scoreThresholdingOptions) 784 return x 785 786 # ScoreThresholdingOptionsT 787 def _UnPack(self, scoreThresholdingOptions): 788 if scoreThresholdingOptions is None: 789 return 790 self.globalScoreThreshold = scoreThresholdingOptions.GlobalScoreThreshold() 791 792 # ScoreThresholdingOptionsT 793 def Pack(self, builder): 794 ScoreThresholdingOptionsStart(builder) 795 ScoreThresholdingOptionsAddGlobalScoreThreshold(builder, self.globalScoreThreshold) 796 scoreThresholdingOptions = ScoreThresholdingOptionsEnd(builder) 797 return scoreThresholdingOptions 798# automatically generated by the FlatBuffers compiler, do not modify 799 800# namespace: tflite 801 802from tflite_support.flatbuffers.compat import import_numpy 803np = import_numpy() 804 805class ScoreCalibrationOptions(object): 806 __slots__ = ['_tab'] 807 808 @classmethod 809 def GetRootAsScoreCalibrationOptions(cls, buf, offset): 810 n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) 811 x = ScoreCalibrationOptions() 812 x.Init(buf, n + offset) 813 return x 814 815 @classmethod 816 def ScoreCalibrationOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): 817 return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x30\x30\x31", size_prefixed=size_prefixed) 818 819 # ScoreCalibrationOptions 820 def Init(self, buf, pos): 821 self._tab = flatbuffers.table.Table(buf, pos) 822 823 # ScoreCalibrationOptions 824 def ScoreTransformation(self): 825 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) 826 if o != 0: 827 return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) 828 return 0 829 830 # ScoreCalibrationOptions 831 def DefaultScore(self): 832 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) 833 if o != 0: 834 return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) 835 return 0.0 836 837def ScoreCalibrationOptionsStart(builder): builder.StartObject(2) 838def ScoreCalibrationOptionsAddScoreTransformation(builder, scoreTransformation): builder.PrependInt8Slot(0, scoreTransformation, 0) 839def ScoreCalibrationOptionsAddDefaultScore(builder, defaultScore): builder.PrependFloat32Slot(1, defaultScore, 0.0) 840def ScoreCalibrationOptionsEnd(builder): return builder.EndObject() 841 842 843class ScoreCalibrationOptionsT(object): 844 845 # ScoreCalibrationOptionsT 846 def __init__(self): 847 self.scoreTransformation = 0 # type: int 848 self.defaultScore = 0.0 # type: float 849 850 @classmethod 851 def InitFromBuf(cls, buf, pos): 852 scoreCalibrationOptions = ScoreCalibrationOptions() 853 scoreCalibrationOptions.Init(buf, pos) 854 return cls.InitFromObj(scoreCalibrationOptions) 855 856 @classmethod 857 def InitFromObj(cls, scoreCalibrationOptions): 858 x = ScoreCalibrationOptionsT() 859 x._UnPack(scoreCalibrationOptions) 860 return x 861 862 # ScoreCalibrationOptionsT 863 def _UnPack(self, scoreCalibrationOptions): 864 if scoreCalibrationOptions is None: 865 return 866 self.scoreTransformation = scoreCalibrationOptions.ScoreTransformation() 867 self.defaultScore = scoreCalibrationOptions.DefaultScore() 868 869 # ScoreCalibrationOptionsT 870 def Pack(self, builder): 871 ScoreCalibrationOptionsStart(builder) 872 ScoreCalibrationOptionsAddScoreTransformation(builder, self.scoreTransformation) 873 ScoreCalibrationOptionsAddDefaultScore(builder, self.defaultScore) 874 scoreCalibrationOptions = ScoreCalibrationOptionsEnd(builder) 875 return scoreCalibrationOptions 876# automatically generated by the FlatBuffers compiler, do not modify 877 878# namespace: tflite 879 880class ProcessUnitOptions(object): 881 NONE = 0 882 NormalizationOptions = 1 883 ScoreCalibrationOptions = 2 884 ScoreThresholdingOptions = 3 885 886 887def ProcessUnitOptionsCreator(unionType, table): 888 from tflite_support.flatbuffers.table import Table 889 if not isinstance(table, Table): 890 return None 891 if unionType == ProcessUnitOptions().NormalizationOptions: 892 return NormalizationOptionsT.InitFromBuf(table.Bytes, table.Pos) 893 if unionType == ProcessUnitOptions().ScoreCalibrationOptions: 894 return ScoreCalibrationOptionsT.InitFromBuf(table.Bytes, table.Pos) 895 if unionType == ProcessUnitOptions().ScoreThresholdingOptions: 896 return ScoreThresholdingOptionsT.InitFromBuf(table.Bytes, table.Pos) 897 return None 898# automatically generated by the FlatBuffers compiler, do not modify 899 900# namespace: tflite 901 902from tflite_support.flatbuffers.compat import import_numpy 903np = import_numpy() 904 905class ProcessUnit(object): 906 __slots__ = ['_tab'] 907 908 @classmethod 909 def GetRootAsProcessUnit(cls, buf, offset): 910 n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) 911 x = ProcessUnit() 912 x.Init(buf, n + offset) 913 return x 914 915 @classmethod 916 def ProcessUnitBufferHasIdentifier(cls, buf, offset, size_prefixed=False): 917 return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x30\x30\x31", size_prefixed=size_prefixed) 918 919 # ProcessUnit 920 def Init(self, buf, pos): 921 self._tab = flatbuffers.table.Table(buf, pos) 922 923 # ProcessUnit 924 def OptionsType(self): 925 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) 926 if o != 0: 927 return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) 928 return 0 929 930 # ProcessUnit 931 def Options(self): 932 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) 933 if o != 0: 934 from tflite_support.flatbuffers.table import Table 935 obj = Table(bytearray(), 0) 936 self._tab.Union(obj, o) 937 return obj 938 return None 939 940def ProcessUnitStart(builder): builder.StartObject(2) 941def ProcessUnitAddOptionsType(builder, optionsType): builder.PrependUint8Slot(0, optionsType, 0) 942def ProcessUnitAddOptions(builder, options): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(options), 0) 943def ProcessUnitEnd(builder): return builder.EndObject() 944 945try: 946 from typing import Union 947except: 948 pass 949 950class ProcessUnitT(object): 951 952 # ProcessUnitT 953 def __init__(self): 954 self.optionsType = 0 # type: int 955 self.options = None # type: Union[None, NormalizationOptionsT, ScoreCalibrationOptionsT, ScoreThresholdingOptionsT] 956 957 @classmethod 958 def InitFromBuf(cls, buf, pos): 959 processUnit = ProcessUnit() 960 processUnit.Init(buf, pos) 961 return cls.InitFromObj(processUnit) 962 963 @classmethod 964 def InitFromObj(cls, processUnit): 965 x = ProcessUnitT() 966 x._UnPack(processUnit) 967 return x 968 969 # ProcessUnitT 970 def _UnPack(self, processUnit): 971 if processUnit is None: 972 return 973 self.optionsType = processUnit.OptionsType() 974 self.options = ProcessUnitOptionsCreator(self.optionsType, processUnit.Options()) 975 976 # ProcessUnitT 977 def Pack(self, builder): 978 if self.options is not None: 979 options = self.options.Pack(builder) 980 ProcessUnitStart(builder) 981 ProcessUnitAddOptionsType(builder, self.optionsType) 982 if self.options is not None: 983 ProcessUnitAddOptions(builder, options) 984 processUnit = ProcessUnitEnd(builder) 985 return processUnit 986# automatically generated by the FlatBuffers compiler, do not modify 987 988# namespace: tflite 989 990from tflite_support.flatbuffers.compat import import_numpy 991np = import_numpy() 992 993class NormalizationOptions(object): 994 __slots__ = ['_tab'] 995 996 @classmethod 997 def GetRootAsNormalizationOptions(cls, buf, offset): 998 n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) 999 x = NormalizationOptions() 1000 x.Init(buf, n + offset) 1001 return x 1002 1003 @classmethod 1004 def NormalizationOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): 1005 return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x30\x30\x31", size_prefixed=size_prefixed) 1006 1007 # NormalizationOptions 1008 def Init(self, buf, pos): 1009 self._tab = flatbuffers.table.Table(buf, pos) 1010 1011 # NormalizationOptions 1012 def Mean(self, j): 1013 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) 1014 if o != 0: 1015 a = self._tab.Vector(o) 1016 return self._tab.Get(flatbuffers.number_types.Float32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) 1017 return 0 1018 1019 # NormalizationOptions 1020 def MeanAsNumpy(self): 1021 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) 1022 if o != 0: 1023 return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float32Flags, o) 1024 return 0 1025 1026 # NormalizationOptions 1027 def MeanLength(self): 1028 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) 1029 if o != 0: 1030 return self._tab.VectorLen(o) 1031 return 0 1032 1033 # NormalizationOptions 1034 def MeanIsNone(self): 1035 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) 1036 return o == 0 1037 1038 # NormalizationOptions 1039 def Std(self, j): 1040 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) 1041 if o != 0: 1042 a = self._tab.Vector(o) 1043 return self._tab.Get(flatbuffers.number_types.Float32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) 1044 return 0 1045 1046 # NormalizationOptions 1047 def StdAsNumpy(self): 1048 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) 1049 if o != 0: 1050 return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float32Flags, o) 1051 return 0 1052 1053 # NormalizationOptions 1054 def StdLength(self): 1055 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) 1056 if o != 0: 1057 return self._tab.VectorLen(o) 1058 return 0 1059 1060 # NormalizationOptions 1061 def StdIsNone(self): 1062 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) 1063 return o == 0 1064 1065def NormalizationOptionsStart(builder): builder.StartObject(2) 1066def NormalizationOptionsAddMean(builder, mean): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(mean), 0) 1067def NormalizationOptionsStartMeanVector(builder, numElems): return builder.StartVector(4, numElems, 4) 1068def NormalizationOptionsAddStd(builder, std): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(std), 0) 1069def NormalizationOptionsStartStdVector(builder, numElems): return builder.StartVector(4, numElems, 4) 1070def NormalizationOptionsEnd(builder): return builder.EndObject() 1071 1072try: 1073 from typing import List 1074except: 1075 pass 1076 1077class NormalizationOptionsT(object): 1078 1079 # NormalizationOptionsT 1080 def __init__(self): 1081 self.mean = None # type: List[float] 1082 self.std = None # type: List[float] 1083 1084 @classmethod 1085 def InitFromBuf(cls, buf, pos): 1086 normalizationOptions = NormalizationOptions() 1087 normalizationOptions.Init(buf, pos) 1088 return cls.InitFromObj(normalizationOptions) 1089 1090 @classmethod 1091 def InitFromObj(cls, normalizationOptions): 1092 x = NormalizationOptionsT() 1093 x._UnPack(normalizationOptions) 1094 return x 1095 1096 # NormalizationOptionsT 1097 def _UnPack(self, normalizationOptions): 1098 if normalizationOptions is None: 1099 return 1100 if not normalizationOptions.MeanIsNone(): 1101 if np is None: 1102 self.mean = [] 1103 for i in range(normalizationOptions.MeanLength()): 1104 self.mean.append(normalizationOptions.Mean(i)) 1105 else: 1106 self.mean = normalizationOptions.MeanAsNumpy() 1107 if not normalizationOptions.StdIsNone(): 1108 if np is None: 1109 self.std = [] 1110 for i in range(normalizationOptions.StdLength()): 1111 self.std.append(normalizationOptions.Std(i)) 1112 else: 1113 self.std = normalizationOptions.StdAsNumpy() 1114 1115 # NormalizationOptionsT 1116 def Pack(self, builder): 1117 if self.mean is not None: 1118 if np is not None and type(self.mean) is np.ndarray: 1119 mean = builder.CreateNumpyVector(self.mean) 1120 else: 1121 NormalizationOptionsStartMeanVector(builder, len(self.mean)) 1122 for i in reversed(range(len(self.mean))): 1123 builder.PrependFloat32(self.mean[i]) 1124 mean = builder.EndVector(len(self.mean)) 1125 if self.std is not None: 1126 if np is not None and type(self.std) is np.ndarray: 1127 std = builder.CreateNumpyVector(self.std) 1128 else: 1129 NormalizationOptionsStartStdVector(builder, len(self.std)) 1130 for i in reversed(range(len(self.std))): 1131 builder.PrependFloat32(self.std[i]) 1132 std = builder.EndVector(len(self.std)) 1133 NormalizationOptionsStart(builder) 1134 if self.mean is not None: 1135 NormalizationOptionsAddMean(builder, mean) 1136 if self.std is not None: 1137 NormalizationOptionsAddStd(builder, std) 1138 normalizationOptions = NormalizationOptionsEnd(builder) 1139 return normalizationOptions 1140# automatically generated by the FlatBuffers compiler, do not modify 1141 1142# namespace: tflite 1143 1144from tflite_support.flatbuffers.compat import import_numpy 1145np = import_numpy() 1146 1147class ModelMetadata(object): 1148 __slots__ = ['_tab'] 1149 1150 @classmethod 1151 def GetRootAsModelMetadata(cls, buf, offset): 1152 n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) 1153 x = ModelMetadata() 1154 x.Init(buf, n + offset) 1155 return x 1156 1157 @classmethod 1158 def ModelMetadataBufferHasIdentifier(cls, buf, offset, size_prefixed=False): 1159 return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x30\x30\x31", size_prefixed=size_prefixed) 1160 1161 # ModelMetadata 1162 def Init(self, buf, pos): 1163 self._tab = flatbuffers.table.Table(buf, pos) 1164 1165 # ModelMetadata 1166 def Name(self): 1167 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) 1168 if o != 0: 1169 return self._tab.String(o + self._tab.Pos) 1170 return None 1171 1172 # ModelMetadata 1173 def Description(self): 1174 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) 1175 if o != 0: 1176 return self._tab.String(o + self._tab.Pos) 1177 return None 1178 1179 # ModelMetadata 1180 def Version(self): 1181 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) 1182 if o != 0: 1183 return self._tab.String(o + self._tab.Pos) 1184 return None 1185 1186 # ModelMetadata 1187 def SubgraphMetadata(self, j): 1188 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) 1189 if o != 0: 1190 x = self._tab.Vector(o) 1191 x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 1192 x = self._tab.Indirect(x) 1193 obj = SubGraphMetadata() 1194 obj.Init(self._tab.Bytes, x) 1195 return obj 1196 return None 1197 1198 # ModelMetadata 1199 def SubgraphMetadataLength(self): 1200 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) 1201 if o != 0: 1202 return self._tab.VectorLen(o) 1203 return 0 1204 1205 # ModelMetadata 1206 def SubgraphMetadataIsNone(self): 1207 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) 1208 return o == 0 1209 1210 # ModelMetadata 1211 def Author(self): 1212 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) 1213 if o != 0: 1214 return self._tab.String(o + self._tab.Pos) 1215 return None 1216 1217 # ModelMetadata 1218 def License(self): 1219 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) 1220 if o != 0: 1221 return self._tab.String(o + self._tab.Pos) 1222 return None 1223 1224 # ModelMetadata 1225 def AssociatedFiles(self, j): 1226 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) 1227 if o != 0: 1228 x = self._tab.Vector(o) 1229 x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 1230 x = self._tab.Indirect(x) 1231 obj = AssociatedFile() 1232 obj.Init(self._tab.Bytes, x) 1233 return obj 1234 return None 1235 1236 # ModelMetadata 1237 def AssociatedFilesLength(self): 1238 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) 1239 if o != 0: 1240 return self._tab.VectorLen(o) 1241 return 0 1242 1243 # ModelMetadata 1244 def AssociatedFilesIsNone(self): 1245 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) 1246 return o == 0 1247 1248def ModelMetadataStart(builder): builder.StartObject(7) 1249def ModelMetadataAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) 1250def ModelMetadataAddDescription(builder, description): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(description), 0) 1251def ModelMetadataAddVersion(builder, version): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(version), 0) 1252def ModelMetadataAddSubgraphMetadata(builder, subgraphMetadata): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(subgraphMetadata), 0) 1253def ModelMetadataStartSubgraphMetadataVector(builder, numElems): return builder.StartVector(4, numElems, 4) 1254def ModelMetadataAddAuthor(builder, author): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(author), 0) 1255def ModelMetadataAddLicense(builder, license): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(license), 0) 1256def ModelMetadataAddAssociatedFiles(builder, associatedFiles): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(associatedFiles), 0) 1257def ModelMetadataStartAssociatedFilesVector(builder, numElems): return builder.StartVector(4, numElems, 4) 1258def ModelMetadataEnd(builder): return builder.EndObject() 1259 1260try: 1261 from typing import List 1262except: 1263 pass 1264 1265class ModelMetadataT(object): 1266 1267 # ModelMetadataT 1268 def __init__(self): 1269 self.name = None # type: str 1270 self.description = None # type: str 1271 self.version = None # type: str 1272 self.subgraphMetadata = None # type: List[SubGraphMetadataT] 1273 self.author = None # type: str 1274 self.license = None # type: str 1275 self.associatedFiles = None # type: List[AssociatedFileT] 1276 1277 @classmethod 1278 def InitFromBuf(cls, buf, pos): 1279 modelMetadata = ModelMetadata() 1280 modelMetadata.Init(buf, pos) 1281 return cls.InitFromObj(modelMetadata) 1282 1283 @classmethod 1284 def InitFromObj(cls, modelMetadata): 1285 x = ModelMetadataT() 1286 x._UnPack(modelMetadata) 1287 return x 1288 1289 # ModelMetadataT 1290 def _UnPack(self, modelMetadata): 1291 if modelMetadata is None: 1292 return 1293 self.name = modelMetadata.Name() 1294 self.description = modelMetadata.Description() 1295 self.version = modelMetadata.Version() 1296 if not modelMetadata.SubgraphMetadataIsNone(): 1297 self.subgraphMetadata = [] 1298 for i in range(modelMetadata.SubgraphMetadataLength()): 1299 if modelMetadata.SubgraphMetadata(i) is None: 1300 self.subgraphMetadata.append(None) 1301 else: 1302 subGraphMetadata_ = SubGraphMetadataT.InitFromObj(modelMetadata.SubgraphMetadata(i)) 1303 self.subgraphMetadata.append(subGraphMetadata_) 1304 self.author = modelMetadata.Author() 1305 self.license = modelMetadata.License() 1306 if not modelMetadata.AssociatedFilesIsNone(): 1307 self.associatedFiles = [] 1308 for i in range(modelMetadata.AssociatedFilesLength()): 1309 if modelMetadata.AssociatedFiles(i) is None: 1310 self.associatedFiles.append(None) 1311 else: 1312 associatedFile_ = AssociatedFileT.InitFromObj(modelMetadata.AssociatedFiles(i)) 1313 self.associatedFiles.append(associatedFile_) 1314 1315 # ModelMetadataT 1316 def Pack(self, builder): 1317 if self.name is not None: 1318 name = builder.CreateString(self.name) 1319 if self.description is not None: 1320 description = builder.CreateString(self.description) 1321 if self.version is not None: 1322 version = builder.CreateString(self.version) 1323 if self.subgraphMetadata is not None: 1324 subgraphMetadatalist = [] 1325 for i in range(len(self.subgraphMetadata)): 1326 subgraphMetadatalist.append(self.subgraphMetadata[i].Pack(builder)) 1327 ModelMetadataStartSubgraphMetadataVector(builder, len(self.subgraphMetadata)) 1328 for i in reversed(range(len(self.subgraphMetadata))): 1329 builder.PrependUOffsetTRelative(subgraphMetadatalist[i]) 1330 subgraphMetadata = builder.EndVector(len(self.subgraphMetadata)) 1331 if self.author is not None: 1332 author = builder.CreateString(self.author) 1333 if self.license is not None: 1334 license = builder.CreateString(self.license) 1335 if self.associatedFiles is not None: 1336 associatedFileslist = [] 1337 for i in range(len(self.associatedFiles)): 1338 associatedFileslist.append(self.associatedFiles[i].Pack(builder)) 1339 ModelMetadataStartAssociatedFilesVector(builder, len(self.associatedFiles)) 1340 for i in reversed(range(len(self.associatedFiles))): 1341 builder.PrependUOffsetTRelative(associatedFileslist[i]) 1342 associatedFiles = builder.EndVector(len(self.associatedFiles)) 1343 ModelMetadataStart(builder) 1344 if self.name is not None: 1345 ModelMetadataAddName(builder, name) 1346 if self.description is not None: 1347 ModelMetadataAddDescription(builder, description) 1348 if self.version is not None: 1349 ModelMetadataAddVersion(builder, version) 1350 if self.subgraphMetadata is not None: 1351 ModelMetadataAddSubgraphMetadata(builder, subgraphMetadata) 1352 if self.author is not None: 1353 ModelMetadataAddAuthor(builder, author) 1354 if self.license is not None: 1355 ModelMetadataAddLicense(builder, license) 1356 if self.associatedFiles is not None: 1357 ModelMetadataAddAssociatedFiles(builder, associatedFiles) 1358 modelMetadata = ModelMetadataEnd(builder) 1359 return modelMetadata 1360# automatically generated by the FlatBuffers compiler, do not modify 1361 1362# namespace: tflite 1363 1364from tflite_support.flatbuffers.compat import import_numpy 1365np = import_numpy() 1366 1367class ImageSize(object): 1368 __slots__ = ['_tab'] 1369 1370 @classmethod 1371 def GetRootAsImageSize(cls, buf, offset): 1372 n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) 1373 x = ImageSize() 1374 x.Init(buf, n + offset) 1375 return x 1376 1377 @classmethod 1378 def ImageSizeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): 1379 return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x30\x30\x31", size_prefixed=size_prefixed) 1380 1381 # ImageSize 1382 def Init(self, buf, pos): 1383 self._tab = flatbuffers.table.Table(buf, pos) 1384 1385 # ImageSize 1386 def Width(self): 1387 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) 1388 if o != 0: 1389 return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) 1390 return 0 1391 1392 # ImageSize 1393 def Height(self): 1394 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) 1395 if o != 0: 1396 return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) 1397 return 0 1398 1399def ImageSizeStart(builder): builder.StartObject(2) 1400def ImageSizeAddWidth(builder, width): builder.PrependUint32Slot(0, width, 0) 1401def ImageSizeAddHeight(builder, height): builder.PrependUint32Slot(1, height, 0) 1402def ImageSizeEnd(builder): return builder.EndObject() 1403 1404 1405class ImageSizeT(object): 1406 1407 # ImageSizeT 1408 def __init__(self): 1409 self.width = 0 # type: int 1410 self.height = 0 # type: int 1411 1412 @classmethod 1413 def InitFromBuf(cls, buf, pos): 1414 imageSize = ImageSize() 1415 imageSize.Init(buf, pos) 1416 return cls.InitFromObj(imageSize) 1417 1418 @classmethod 1419 def InitFromObj(cls, imageSize): 1420 x = ImageSizeT() 1421 x._UnPack(imageSize) 1422 return x 1423 1424 # ImageSizeT 1425 def _UnPack(self, imageSize): 1426 if imageSize is None: 1427 return 1428 self.width = imageSize.Width() 1429 self.height = imageSize.Height() 1430 1431 # ImageSizeT 1432 def Pack(self, builder): 1433 ImageSizeStart(builder) 1434 ImageSizeAddWidth(builder, self.width) 1435 ImageSizeAddHeight(builder, self.height) 1436 imageSize = ImageSizeEnd(builder) 1437 return imageSize 1438# automatically generated by the FlatBuffers compiler, do not modify 1439 1440# namespace: tflite 1441 1442from tflite_support.flatbuffers.compat import import_numpy 1443np = import_numpy() 1444 1445class ImageProperties(object): 1446 __slots__ = ['_tab'] 1447 1448 @classmethod 1449 def GetRootAsImageProperties(cls, buf, offset): 1450 n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) 1451 x = ImageProperties() 1452 x.Init(buf, n + offset) 1453 return x 1454 1455 @classmethod 1456 def ImagePropertiesBufferHasIdentifier(cls, buf, offset, size_prefixed=False): 1457 return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x30\x30\x31", size_prefixed=size_prefixed) 1458 1459 # ImageProperties 1460 def Init(self, buf, pos): 1461 self._tab = flatbuffers.table.Table(buf, pos) 1462 1463 # ImageProperties 1464 def ColorSpace(self): 1465 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) 1466 if o != 0: 1467 return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) 1468 return 0 1469 1470 # ImageProperties 1471 def DefaultSize(self): 1472 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) 1473 if o != 0: 1474 x = self._tab.Indirect(o + self._tab.Pos) 1475 obj = ImageSize() 1476 obj.Init(self._tab.Bytes, x) 1477 return obj 1478 return None 1479 1480def ImagePropertiesStart(builder): builder.StartObject(2) 1481def ImagePropertiesAddColorSpace(builder, colorSpace): builder.PrependInt8Slot(0, colorSpace, 0) 1482def ImagePropertiesAddDefaultSize(builder, defaultSize): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(defaultSize), 0) 1483def ImagePropertiesEnd(builder): return builder.EndObject() 1484 1485try: 1486 from typing import Optional 1487except: 1488 pass 1489 1490class ImagePropertiesT(object): 1491 1492 # ImagePropertiesT 1493 def __init__(self): 1494 self.colorSpace = 0 # type: int 1495 self.defaultSize = None # type: Optional[ImageSizeT] 1496 1497 @classmethod 1498 def InitFromBuf(cls, buf, pos): 1499 imageProperties = ImageProperties() 1500 imageProperties.Init(buf, pos) 1501 return cls.InitFromObj(imageProperties) 1502 1503 @classmethod 1504 def InitFromObj(cls, imageProperties): 1505 x = ImagePropertiesT() 1506 x._UnPack(imageProperties) 1507 return x 1508 1509 # ImagePropertiesT 1510 def _UnPack(self, imageProperties): 1511 if imageProperties is None: 1512 return 1513 self.colorSpace = imageProperties.ColorSpace() 1514 if imageProperties.DefaultSize() is not None: 1515 self.defaultSize = ImageSizeT.InitFromObj(imageProperties.DefaultSize()) 1516 1517 # ImagePropertiesT 1518 def Pack(self, builder): 1519 if self.defaultSize is not None: 1520 defaultSize = self.defaultSize.Pack(builder) 1521 ImagePropertiesStart(builder) 1522 ImagePropertiesAddColorSpace(builder, self.colorSpace) 1523 if self.defaultSize is not None: 1524 ImagePropertiesAddDefaultSize(builder, defaultSize) 1525 imageProperties = ImagePropertiesEnd(builder) 1526 return imageProperties 1527# automatically generated by the FlatBuffers compiler, do not modify 1528 1529# namespace: tflite 1530 1531from tflite_support.flatbuffers.compat import import_numpy 1532np = import_numpy() 1533 1534class FeatureProperties(object): 1535 __slots__ = ['_tab'] 1536 1537 @classmethod 1538 def GetRootAsFeatureProperties(cls, buf, offset): 1539 n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) 1540 x = FeatureProperties() 1541 x.Init(buf, n + offset) 1542 return x 1543 1544 @classmethod 1545 def FeaturePropertiesBufferHasIdentifier(cls, buf, offset, size_prefixed=False): 1546 return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x30\x30\x31", size_prefixed=size_prefixed) 1547 1548 # FeatureProperties 1549 def Init(self, buf, pos): 1550 self._tab = flatbuffers.table.Table(buf, pos) 1551 1552def FeaturePropertiesStart(builder): builder.StartObject(0) 1553def FeaturePropertiesEnd(builder): return builder.EndObject() 1554 1555 1556class FeaturePropertiesT(object): 1557 1558 # FeaturePropertiesT 1559 def __init__(self): 1560 pass 1561 1562 @classmethod 1563 def InitFromBuf(cls, buf, pos): 1564 featureProperties = FeatureProperties() 1565 featureProperties.Init(buf, pos) 1566 return cls.InitFromObj(featureProperties) 1567 1568 @classmethod 1569 def InitFromObj(cls, featureProperties): 1570 x = FeaturePropertiesT() 1571 x._UnPack(featureProperties) 1572 return x 1573 1574 # FeaturePropertiesT 1575 def _UnPack(self, featureProperties): 1576 if featureProperties is None: 1577 return 1578 1579 # FeaturePropertiesT 1580 def Pack(self, builder): 1581 FeaturePropertiesStart(builder) 1582 featureProperties = FeaturePropertiesEnd(builder) 1583 return featureProperties 1584# automatically generated by the FlatBuffers compiler, do not modify 1585 1586# namespace: tflite 1587 1588class CoordinateType(object): 1589 RATIO = 0 1590 PIXEL = 1 1591 1592# automatically generated by the FlatBuffers compiler, do not modify 1593 1594# namespace: tflite 1595 1596class ContentProperties(object): 1597 NONE = 0 1598 FeatureProperties = 1 1599 ImageProperties = 2 1600 BoundingBoxProperties = 3 1601 1602 1603def ContentPropertiesCreator(unionType, table): 1604 from tflite_support.flatbuffers.table import Table 1605 if not isinstance(table, Table): 1606 return None 1607 if unionType == ContentProperties().FeatureProperties: 1608 return FeaturePropertiesT.InitFromBuf(table.Bytes, table.Pos) 1609 if unionType == ContentProperties().ImageProperties: 1610 return ImagePropertiesT.InitFromBuf(table.Bytes, table.Pos) 1611 if unionType == ContentProperties().BoundingBoxProperties: 1612 return BoundingBoxPropertiesT.InitFromBuf(table.Bytes, table.Pos) 1613 return None 1614# automatically generated by the FlatBuffers compiler, do not modify 1615 1616# namespace: tflite 1617 1618from tflite_support.flatbuffers.compat import import_numpy 1619np = import_numpy() 1620 1621class Content(object): 1622 __slots__ = ['_tab'] 1623 1624 @classmethod 1625 def GetRootAsContent(cls, buf, offset): 1626 n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) 1627 x = Content() 1628 x.Init(buf, n + offset) 1629 return x 1630 1631 @classmethod 1632 def ContentBufferHasIdentifier(cls, buf, offset, size_prefixed=False): 1633 return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x30\x30\x31", size_prefixed=size_prefixed) 1634 1635 # Content 1636 def Init(self, buf, pos): 1637 self._tab = flatbuffers.table.Table(buf, pos) 1638 1639 # Content 1640 def ContentPropertiesType(self): 1641 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) 1642 if o != 0: 1643 return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) 1644 return 0 1645 1646 # Content 1647 def ContentProperties(self): 1648 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) 1649 if o != 0: 1650 from tflite_support.flatbuffers.table import Table 1651 obj = Table(bytearray(), 0) 1652 self._tab.Union(obj, o) 1653 return obj 1654 return None 1655 1656 # Content 1657 def Range(self): 1658 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) 1659 if o != 0: 1660 x = self._tab.Indirect(o + self._tab.Pos) 1661 obj = ValueRange() 1662 obj.Init(self._tab.Bytes, x) 1663 return obj 1664 return None 1665 1666def ContentStart(builder): builder.StartObject(3) 1667def ContentAddContentPropertiesType(builder, contentPropertiesType): builder.PrependUint8Slot(0, contentPropertiesType, 0) 1668def ContentAddContentProperties(builder, contentProperties): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(contentProperties), 0) 1669def ContentAddRange(builder, range): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(range), 0) 1670def ContentEnd(builder): return builder.EndObject() 1671 1672try: 1673 from typing import Optional, Union 1674except: 1675 pass 1676 1677class ContentT(object): 1678 1679 # ContentT 1680 def __init__(self): 1681 self.contentPropertiesType = 0 # type: int 1682 self.contentProperties = None # type: Union[None, FeaturePropertiesT, ImagePropertiesT, BoundingBoxPropertiesT] 1683 self.range = None # type: Optional[ValueRangeT] 1684 1685 @classmethod 1686 def InitFromBuf(cls, buf, pos): 1687 content = Content() 1688 content.Init(buf, pos) 1689 return cls.InitFromObj(content) 1690 1691 @classmethod 1692 def InitFromObj(cls, content): 1693 x = ContentT() 1694 x._UnPack(content) 1695 return x 1696 1697 # ContentT 1698 def _UnPack(self, content): 1699 if content is None: 1700 return 1701 self.contentPropertiesType = content.ContentPropertiesType() 1702 self.contentProperties = ContentPropertiesCreator(self.contentPropertiesType, content.ContentProperties()) 1703 if content.Range() is not None: 1704 self.range = ValueRangeT.InitFromObj(content.Range()) 1705 1706 # ContentT 1707 def Pack(self, builder): 1708 if self.contentProperties is not None: 1709 contentProperties = self.contentProperties.Pack(builder) 1710 if self.range is not None: 1711 range = self.range.Pack(builder) 1712 ContentStart(builder) 1713 ContentAddContentPropertiesType(builder, self.contentPropertiesType) 1714 if self.contentProperties is not None: 1715 ContentAddContentProperties(builder, contentProperties) 1716 if self.range is not None: 1717 ContentAddRange(builder, range) 1718 content = ContentEnd(builder) 1719 return content 1720# automatically generated by the FlatBuffers compiler, do not modify 1721 1722# namespace: tflite 1723 1724class ColorSpaceType(object): 1725 UNKNOWN = 0 1726 RGB = 1 1727 GRAYSCALE = 2 1728 1729# automatically generated by the FlatBuffers compiler, do not modify 1730 1731# namespace: tflite 1732 1733class BoundingBoxType(object): 1734 UNKNOWN = 0 1735 BOUNDARIES = 1 1736 UPPER_LEFT = 2 1737 CENTER = 3 1738 1739# automatically generated by the FlatBuffers compiler, do not modify 1740 1741# namespace: tflite 1742 1743from tflite_support.flatbuffers.compat import import_numpy 1744np = import_numpy() 1745 1746class BoundingBoxProperties(object): 1747 __slots__ = ['_tab'] 1748 1749 @classmethod 1750 def GetRootAsBoundingBoxProperties(cls, buf, offset): 1751 n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) 1752 x = BoundingBoxProperties() 1753 x.Init(buf, n + offset) 1754 return x 1755 1756 @classmethod 1757 def BoundingBoxPropertiesBufferHasIdentifier(cls, buf, offset, size_prefixed=False): 1758 return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x30\x30\x31", size_prefixed=size_prefixed) 1759 1760 # BoundingBoxProperties 1761 def Init(self, buf, pos): 1762 self._tab = flatbuffers.table.Table(buf, pos) 1763 1764 # BoundingBoxProperties 1765 def Index(self, j): 1766 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) 1767 if o != 0: 1768 a = self._tab.Vector(o) 1769 return self._tab.Get(flatbuffers.number_types.Uint32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) 1770 return 0 1771 1772 # BoundingBoxProperties 1773 def IndexAsNumpy(self): 1774 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) 1775 if o != 0: 1776 return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint32Flags, o) 1777 return 0 1778 1779 # BoundingBoxProperties 1780 def IndexLength(self): 1781 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) 1782 if o != 0: 1783 return self._tab.VectorLen(o) 1784 return 0 1785 1786 # BoundingBoxProperties 1787 def IndexIsNone(self): 1788 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) 1789 return o == 0 1790 1791 # BoundingBoxProperties 1792 def Type(self): 1793 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) 1794 if o != 0: 1795 return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) 1796 return 0 1797 1798 # BoundingBoxProperties 1799 def CoordinateType(self): 1800 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) 1801 if o != 0: 1802 return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) 1803 return 0 1804 1805def BoundingBoxPropertiesStart(builder): builder.StartObject(3) 1806def BoundingBoxPropertiesAddIndex(builder, index): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(index), 0) 1807def BoundingBoxPropertiesStartIndexVector(builder, numElems): return builder.StartVector(4, numElems, 4) 1808def BoundingBoxPropertiesAddType(builder, type): builder.PrependInt8Slot(1, type, 0) 1809def BoundingBoxPropertiesAddCoordinateType(builder, coordinateType): builder.PrependInt8Slot(2, coordinateType, 0) 1810def BoundingBoxPropertiesEnd(builder): return builder.EndObject() 1811 1812try: 1813 from typing import List 1814except: 1815 pass 1816 1817class BoundingBoxPropertiesT(object): 1818 1819 # BoundingBoxPropertiesT 1820 def __init__(self): 1821 self.index = None # type: List[int] 1822 self.type = 0 # type: int 1823 self.coordinateType = 0 # type: int 1824 1825 @classmethod 1826 def InitFromBuf(cls, buf, pos): 1827 boundingBoxProperties = BoundingBoxProperties() 1828 boundingBoxProperties.Init(buf, pos) 1829 return cls.InitFromObj(boundingBoxProperties) 1830 1831 @classmethod 1832 def InitFromObj(cls, boundingBoxProperties): 1833 x = BoundingBoxPropertiesT() 1834 x._UnPack(boundingBoxProperties) 1835 return x 1836 1837 # BoundingBoxPropertiesT 1838 def _UnPack(self, boundingBoxProperties): 1839 if boundingBoxProperties is None: 1840 return 1841 if not boundingBoxProperties.IndexIsNone(): 1842 if np is None: 1843 self.index = [] 1844 for i in range(boundingBoxProperties.IndexLength()): 1845 self.index.append(boundingBoxProperties.Index(i)) 1846 else: 1847 self.index = boundingBoxProperties.IndexAsNumpy() 1848 self.type = boundingBoxProperties.Type() 1849 self.coordinateType = boundingBoxProperties.CoordinateType() 1850 1851 # BoundingBoxPropertiesT 1852 def Pack(self, builder): 1853 if self.index is not None: 1854 if np is not None and type(self.index) is np.ndarray: 1855 index = builder.CreateNumpyVector(self.index) 1856 else: 1857 BoundingBoxPropertiesStartIndexVector(builder, len(self.index)) 1858 for i in reversed(range(len(self.index))): 1859 builder.PrependUint32(self.index[i]) 1860 index = builder.EndVector(len(self.index)) 1861 BoundingBoxPropertiesStart(builder) 1862 if self.index is not None: 1863 BoundingBoxPropertiesAddIndex(builder, index) 1864 BoundingBoxPropertiesAddType(builder, self.type) 1865 BoundingBoxPropertiesAddCoordinateType(builder, self.coordinateType) 1866 boundingBoxProperties = BoundingBoxPropertiesEnd(builder) 1867 return boundingBoxProperties 1868# automatically generated by the FlatBuffers compiler, do not modify 1869 1870# namespace: tflite 1871 1872class AssociatedFileType(object): 1873 UNKNOWN = 0 1874 DESCRIPTIONS = 1 1875 TENSOR_AXIS_LABELS = 2 1876 TENSOR_VALUE_LABELS = 3 1877 TENSOR_AXIS_SCORE_CALIBRATION = 4 1878 1879# automatically generated by the FlatBuffers compiler, do not modify 1880 1881# namespace: tflite 1882 1883from tflite_support.flatbuffers.compat import import_numpy 1884np = import_numpy() 1885 1886class AssociatedFile(object): 1887 __slots__ = ['_tab'] 1888 1889 @classmethod 1890 def GetRootAsAssociatedFile(cls, buf, offset): 1891 n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) 1892 x = AssociatedFile() 1893 x.Init(buf, n + offset) 1894 return x 1895 1896 @classmethod 1897 def AssociatedFileBufferHasIdentifier(cls, buf, offset, size_prefixed=False): 1898 return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x30\x30\x31", size_prefixed=size_prefixed) 1899 1900 # AssociatedFile 1901 def Init(self, buf, pos): 1902 self._tab = flatbuffers.table.Table(buf, pos) 1903 1904 # AssociatedFile 1905 def Name(self): 1906 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) 1907 if o != 0: 1908 return self._tab.String(o + self._tab.Pos) 1909 return None 1910 1911 # AssociatedFile 1912 def Description(self): 1913 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) 1914 if o != 0: 1915 return self._tab.String(o + self._tab.Pos) 1916 return None 1917 1918 # AssociatedFile 1919 def Type(self): 1920 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) 1921 if o != 0: 1922 return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) 1923 return 0 1924 1925 # AssociatedFile 1926 def Locale(self): 1927 o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) 1928 if o != 0: 1929 return self._tab.String(o + self._tab.Pos) 1930 return None 1931 1932def AssociatedFileStart(builder): builder.StartObject(4) 1933def AssociatedFileAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) 1934def AssociatedFileAddDescription(builder, description): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(description), 0) 1935def AssociatedFileAddType(builder, type): builder.PrependInt8Slot(2, type, 0) 1936def AssociatedFileAddLocale(builder, locale): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(locale), 0) 1937def AssociatedFileEnd(builder): return builder.EndObject() 1938 1939 1940class AssociatedFileT(object): 1941 1942 # AssociatedFileT 1943 def __init__(self): 1944 self.name = None # type: str 1945 self.description = None # type: str 1946 self.type = 0 # type: int 1947 self.locale = None # type: str 1948 1949 @classmethod 1950 def InitFromBuf(cls, buf, pos): 1951 associatedFile = AssociatedFile() 1952 associatedFile.Init(buf, pos) 1953 return cls.InitFromObj(associatedFile) 1954 1955 @classmethod 1956 def InitFromObj(cls, associatedFile): 1957 x = AssociatedFileT() 1958 x._UnPack(associatedFile) 1959 return x 1960 1961 # AssociatedFileT 1962 def _UnPack(self, associatedFile): 1963 if associatedFile is None: 1964 return 1965 self.name = associatedFile.Name() 1966 self.description = associatedFile.Description() 1967 self.type = associatedFile.Type() 1968 self.locale = associatedFile.Locale() 1969 1970 # AssociatedFileT 1971 def Pack(self, builder): 1972 if self.name is not None: 1973 name = builder.CreateString(self.name) 1974 if self.description is not None: 1975 description = builder.CreateString(self.description) 1976 if self.locale is not None: 1977 locale = builder.CreateString(self.locale) 1978 AssociatedFileStart(builder) 1979 if self.name is not None: 1980 AssociatedFileAddName(builder, name) 1981 if self.description is not None: 1982 AssociatedFileAddDescription(builder, description) 1983 AssociatedFileAddType(builder, self.type) 1984 if self.locale is not None: 1985 AssociatedFileAddLocale(builder, locale) 1986 associatedFile = AssociatedFileEnd(builder) 1987 return associatedFile 1988