spacedatastandards.org 1.73.0__py3-none-any.whl

XTC/BooleanArgumentType.py

@@ -0,0 +1,223 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Boolean argument type
+class BooleanArgumentType(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = BooleanArgumentType()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsBooleanArgumentType(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def BooleanArgumentTypeBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # BooleanArgumentType
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Type name
+    # BooleanArgumentType
+    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
+
+    # Short description
+    # BooleanArgumentType
+    def SHORT_DESCRIPTION(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
+
+    # Long description
+    # BooleanArgumentType
+    def LONG_DESCRIPTION(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
+
+    # Data encoding
+    # BooleanArgumentType
+    def DATA_ENCODING(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from IntegerDataEncoding import IntegerDataEncoding
+            obj = IntegerDataEncoding()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # String representation of true value
+    # BooleanArgumentType
+    def ONE_STRING_VALUE(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
+
+    # String representation of false value
+    # BooleanArgumentType
+    def ZERO_STRING_VALUE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Initial/default value
+    # BooleanArgumentType
+    def INITIAL_VALUE(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
+
+def BooleanArgumentTypeStart(builder):
+    builder.StartObject(7)
+
+def Start(builder):
+    BooleanArgumentTypeStart(builder)
+
+def BooleanArgumentTypeAddNAME(builder, NAME):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(NAME), 0)
+
+def AddNAME(builder, NAME):
+    BooleanArgumentTypeAddNAME(builder, NAME)
+
+def BooleanArgumentTypeAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(SHORT_DESCRIPTION), 0)
+
+def AddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION):
+    BooleanArgumentTypeAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION)
+
+def BooleanArgumentTypeAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(LONG_DESCRIPTION), 0)
+
+def AddLONG_DESCRIPTION(builder, LONG_DESCRIPTION):
+    BooleanArgumentTypeAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION)
+
+def BooleanArgumentTypeAddDATA_ENCODING(builder, DATA_ENCODING):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(DATA_ENCODING), 0)
+
+def AddDATA_ENCODING(builder, DATA_ENCODING):
+    BooleanArgumentTypeAddDATA_ENCODING(builder, DATA_ENCODING)
+
+def BooleanArgumentTypeAddONE_STRING_VALUE(builder, ONE_STRING_VALUE):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(ONE_STRING_VALUE), 0)
+
+def AddONE_STRING_VALUE(builder, ONE_STRING_VALUE):
+    BooleanArgumentTypeAddONE_STRING_VALUE(builder, ONE_STRING_VALUE)
+
+def BooleanArgumentTypeAddZERO_STRING_VALUE(builder, ZERO_STRING_VALUE):
+    builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(ZERO_STRING_VALUE), 0)
+
+def AddZERO_STRING_VALUE(builder, ZERO_STRING_VALUE):
+    BooleanArgumentTypeAddZERO_STRING_VALUE(builder, ZERO_STRING_VALUE)
+
+def BooleanArgumentTypeAddINITIAL_VALUE(builder, INITIAL_VALUE):
+    builder.PrependBoolSlot(6, INITIAL_VALUE, 0)
+
+def AddINITIAL_VALUE(builder, INITIAL_VALUE):
+    BooleanArgumentTypeAddINITIAL_VALUE(builder, INITIAL_VALUE)
+
+def BooleanArgumentTypeEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return BooleanArgumentTypeEnd(builder)
+
+import IntegerDataEncoding
+try:
+    from typing import Optional
+except:
+    pass
+
+class BooleanArgumentTypeT(object):
+
+    # BooleanArgumentTypeT
+    def __init__(self):
+        self.NAME = None  # type: str
+        self.SHORT_DESCRIPTION = None  # type: str
+        self.LONG_DESCRIPTION = None  # type: str
+        self.DATA_ENCODING = None  # type: Optional[IntegerDataEncoding.IntegerDataEncodingT]
+        self.ONE_STRING_VALUE = None  # type: str
+        self.ZERO_STRING_VALUE = None  # type: str
+        self.INITIAL_VALUE = False  # type: bool
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        booleanArgumentType = BooleanArgumentType()
+        booleanArgumentType.Init(buf, pos)
+        return cls.InitFromObj(booleanArgumentType)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, booleanArgumentType):
+        x = BooleanArgumentTypeT()
+        x._UnPack(booleanArgumentType)
+        return x
+
+    # BooleanArgumentTypeT
+    def _UnPack(self, booleanArgumentType):
+        if booleanArgumentType is None:
+            return
+        self.NAME = booleanArgumentType.NAME()
+        self.SHORT_DESCRIPTION = booleanArgumentType.SHORT_DESCRIPTION()
+        self.LONG_DESCRIPTION = booleanArgumentType.LONG_DESCRIPTION()
+        if booleanArgumentType.DATA_ENCODING() is not None:
+            self.DATA_ENCODING = IntegerDataEncoding.IntegerDataEncodingT.InitFromObj(booleanArgumentType.DATA_ENCODING())
+        self.ONE_STRING_VALUE = booleanArgumentType.ONE_STRING_VALUE()
+        self.ZERO_STRING_VALUE = booleanArgumentType.ZERO_STRING_VALUE()
+        self.INITIAL_VALUE = booleanArgumentType.INITIAL_VALUE()
+
+    # BooleanArgumentTypeT
+    def Pack(self, builder):
+        if self.NAME is not None:
+            NAME = builder.CreateString(self.NAME)
+        if self.SHORT_DESCRIPTION is not None:
+            SHORT_DESCRIPTION = builder.CreateString(self.SHORT_DESCRIPTION)
+        if self.LONG_DESCRIPTION is not None:
+            LONG_DESCRIPTION = builder.CreateString(self.LONG_DESCRIPTION)
+        if self.DATA_ENCODING is not None:
+            DATA_ENCODING = self.DATA_ENCODING.Pack(builder)
+        if self.ONE_STRING_VALUE is not None:
+            ONE_STRING_VALUE = builder.CreateString(self.ONE_STRING_VALUE)
+        if self.ZERO_STRING_VALUE is not None:
+            ZERO_STRING_VALUE = builder.CreateString(self.ZERO_STRING_VALUE)
+        BooleanArgumentTypeStart(builder)
+        if self.NAME is not None:
+            BooleanArgumentTypeAddNAME(builder, NAME)
+        if self.SHORT_DESCRIPTION is not None:
+            BooleanArgumentTypeAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION)
+        if self.LONG_DESCRIPTION is not None:
+            BooleanArgumentTypeAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION)
+        if self.DATA_ENCODING is not None:
+            BooleanArgumentTypeAddDATA_ENCODING(builder, DATA_ENCODING)
+        if self.ONE_STRING_VALUE is not None:
+            BooleanArgumentTypeAddONE_STRING_VALUE(builder, ONE_STRING_VALUE)
+        if self.ZERO_STRING_VALUE is not None:
+            BooleanArgumentTypeAddZERO_STRING_VALUE(builder, ZERO_STRING_VALUE)
+        BooleanArgumentTypeAddINITIAL_VALUE(builder, self.INITIAL_VALUE)
+        booleanArgumentType = BooleanArgumentTypeEnd(builder)
+        return booleanArgumentType

XTC/BooleanExpression.py

@@ -0,0 +1,212 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Boolean expression combining comparisons
+class BooleanExpression(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = BooleanExpression()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsBooleanExpression(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def BooleanExpressionBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # BooleanExpression
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Boolean operator
+    # BooleanExpression
+    def OPERATOR(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+        return 0
+
+    # Comparison conditions
+    # BooleanExpression
+    def CONDITIONS(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 ParameterComparison import ParameterComparison
+            obj = ParameterComparison()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # BooleanExpression
+    def CONDITIONSLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # BooleanExpression
+    def CONDITIONSIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        return o == 0
+
+    # Nested expressions
+    # BooleanExpression
+    def EXPRESSIONS(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 BooleanExpression import BooleanExpression
+            obj = BooleanExpression()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # BooleanExpression
+    def EXPRESSIONSLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # BooleanExpression
+    def EXPRESSIONSIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        return o == 0
+
+def BooleanExpressionStart(builder):
+    builder.StartObject(3)
+
+def Start(builder):
+    BooleanExpressionStart(builder)
+
+def BooleanExpressionAddOPERATOR(builder, OPERATOR):
+    builder.PrependInt8Slot(0, OPERATOR, 0)
+
+def AddOPERATOR(builder, OPERATOR):
+    BooleanExpressionAddOPERATOR(builder, OPERATOR)
+
+def BooleanExpressionAddCONDITIONS(builder, CONDITIONS):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(CONDITIONS), 0)
+
+def AddCONDITIONS(builder, CONDITIONS):
+    BooleanExpressionAddCONDITIONS(builder, CONDITIONS)
+
+def BooleanExpressionStartCONDITIONSVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartCONDITIONSVector(builder, numElems):
+    return BooleanExpressionStartCONDITIONSVector(builder, numElems)
+
+def BooleanExpressionAddEXPRESSIONS(builder, EXPRESSIONS):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(EXPRESSIONS), 0)
+
+def AddEXPRESSIONS(builder, EXPRESSIONS):
+    BooleanExpressionAddEXPRESSIONS(builder, EXPRESSIONS)
+
+def BooleanExpressionStartEXPRESSIONSVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartEXPRESSIONSVector(builder, numElems):
+    return BooleanExpressionStartEXPRESSIONSVector(builder, numElems)
+
+def BooleanExpressionEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return BooleanExpressionEnd(builder)
+
+import ParameterComparison
+try:
+    from typing import List
+except:
+    pass
+
+class BooleanExpressionT(object):
+
+    # BooleanExpressionT
+    def __init__(self):
+        self.OPERATOR = 0  # type: int
+        self.CONDITIONS = None  # type: List[ParameterComparison.ParameterComparisonT]
+        self.EXPRESSIONS = None  # type: List[BooleanExpression.BooleanExpressionT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        booleanExpression = BooleanExpression()
+        booleanExpression.Init(buf, pos)
+        return cls.InitFromObj(booleanExpression)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, booleanExpression):
+        x = BooleanExpressionT()
+        x._UnPack(booleanExpression)
+        return x
+
+    # BooleanExpressionT
+    def _UnPack(self, booleanExpression):
+        if booleanExpression is None:
+            return
+        self.OPERATOR = booleanExpression.OPERATOR()
+        if not booleanExpression.CONDITIONSIsNone():
+            self.CONDITIONS = []
+            for i in range(booleanExpression.CONDITIONSLength()):
+                if booleanExpression.CONDITIONS(i) is None:
+                    self.CONDITIONS.append(None)
+                else:
+                    parameterComparison_ = ParameterComparison.ParameterComparisonT.InitFromObj(booleanExpression.CONDITIONS(i))
+                    self.CONDITIONS.append(parameterComparison_)
+        if not booleanExpression.EXPRESSIONSIsNone():
+            self.EXPRESSIONS = []
+            for i in range(booleanExpression.EXPRESSIONSLength()):
+                if booleanExpression.EXPRESSIONS(i) is None:
+                    self.EXPRESSIONS.append(None)
+                else:
+                    booleanExpression_ = BooleanExpression.BooleanExpressionT.InitFromObj(booleanExpression.EXPRESSIONS(i))
+                    self.EXPRESSIONS.append(booleanExpression_)
+
+    # BooleanExpressionT
+    def Pack(self, builder):
+        if self.CONDITIONS is not None:
+            CONDITIONSlist = []
+            for i in range(len(self.CONDITIONS)):
+                CONDITIONSlist.append(self.CONDITIONS[i].Pack(builder))
+            BooleanExpressionStartCONDITIONSVector(builder, len(self.CONDITIONS))
+            for i in reversed(range(len(self.CONDITIONS))):
+                builder.PrependUOffsetTRelative(CONDITIONSlist[i])
+            CONDITIONS = builder.EndVector()
+        if self.EXPRESSIONS is not None:
+            EXPRESSIONSlist = []
+            for i in range(len(self.EXPRESSIONS)):
+                EXPRESSIONSlist.append(self.EXPRESSIONS[i].Pack(builder))
+            BooleanExpressionStartEXPRESSIONSVector(builder, len(self.EXPRESSIONS))
+            for i in reversed(range(len(self.EXPRESSIONS))):
+                builder.PrependUOffsetTRelative(EXPRESSIONSlist[i])
+            EXPRESSIONS = builder.EndVector()
+        BooleanExpressionStart(builder)
+        BooleanExpressionAddOPERATOR(builder, self.OPERATOR)
+        if self.CONDITIONS is not None:
+            BooleanExpressionAddCONDITIONS(builder, CONDITIONS)
+        if self.EXPRESSIONS is not None:
+            BooleanExpressionAddEXPRESSIONS(builder, EXPRESSIONS)
+        booleanExpression = BooleanExpressionEnd(builder)
+        return booleanExpression

XTC/BooleanOperatorType.py

@@ -0,0 +1,12 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+# Boolean operators for combining conditions
+class BooleanOperatorType(object):
+    # Logical AND
+    AND = 0
+    # Logical OR
+    OR = 1
+    # Logical XOR
+    XOR = 2

XTC/BooleanParameterType.py

@@ -0,0 +1,223 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Boolean parameter type
+class BooleanParameterType(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = BooleanParameterType()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsBooleanParameterType(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def BooleanParameterTypeBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # BooleanParameterType
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Type name
+    # BooleanParameterType
+    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
+
+    # Short description
+    # BooleanParameterType
+    def SHORT_DESCRIPTION(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
+
+    # Long description
+    # BooleanParameterType
+    def LONG_DESCRIPTION(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
+
+    # Data encoding (typically IntegerDataEncoding with 1 bit)
+    # BooleanParameterType
+    def DATA_ENCODING(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from IntegerDataEncoding import IntegerDataEncoding
+            obj = IntegerDataEncoding()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # String representation of true value
+    # BooleanParameterType
+    def ONE_STRING_VALUE(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
+
+    # String representation of false value
+    # BooleanParameterType
+    def ZERO_STRING_VALUE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Initial/default value
+    # BooleanParameterType
+    def INITIAL_VALUE(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
+
+def BooleanParameterTypeStart(builder):
+    builder.StartObject(7)
+
+def Start(builder):
+    BooleanParameterTypeStart(builder)
+
+def BooleanParameterTypeAddNAME(builder, NAME):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(NAME), 0)
+
+def AddNAME(builder, NAME):
+    BooleanParameterTypeAddNAME(builder, NAME)
+
+def BooleanParameterTypeAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(SHORT_DESCRIPTION), 0)
+
+def AddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION):
+    BooleanParameterTypeAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION)
+
+def BooleanParameterTypeAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(LONG_DESCRIPTION), 0)
+
+def AddLONG_DESCRIPTION(builder, LONG_DESCRIPTION):
+    BooleanParameterTypeAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION)
+
+def BooleanParameterTypeAddDATA_ENCODING(builder, DATA_ENCODING):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(DATA_ENCODING), 0)
+
+def AddDATA_ENCODING(builder, DATA_ENCODING):
+    BooleanParameterTypeAddDATA_ENCODING(builder, DATA_ENCODING)
+
+def BooleanParameterTypeAddONE_STRING_VALUE(builder, ONE_STRING_VALUE):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(ONE_STRING_VALUE), 0)
+
+def AddONE_STRING_VALUE(builder, ONE_STRING_VALUE):
+    BooleanParameterTypeAddONE_STRING_VALUE(builder, ONE_STRING_VALUE)
+
+def BooleanParameterTypeAddZERO_STRING_VALUE(builder, ZERO_STRING_VALUE):
+    builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(ZERO_STRING_VALUE), 0)
+
+def AddZERO_STRING_VALUE(builder, ZERO_STRING_VALUE):
+    BooleanParameterTypeAddZERO_STRING_VALUE(builder, ZERO_STRING_VALUE)
+
+def BooleanParameterTypeAddINITIAL_VALUE(builder, INITIAL_VALUE):
+    builder.PrependBoolSlot(6, INITIAL_VALUE, 0)
+
+def AddINITIAL_VALUE(builder, INITIAL_VALUE):
+    BooleanParameterTypeAddINITIAL_VALUE(builder, INITIAL_VALUE)
+
+def BooleanParameterTypeEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return BooleanParameterTypeEnd(builder)
+
+import IntegerDataEncoding
+try:
+    from typing import Optional
+except:
+    pass
+
+class BooleanParameterTypeT(object):
+
+    # BooleanParameterTypeT
+    def __init__(self):
+        self.NAME = None  # type: str
+        self.SHORT_DESCRIPTION = None  # type: str
+        self.LONG_DESCRIPTION = None  # type: str
+        self.DATA_ENCODING = None  # type: Optional[IntegerDataEncoding.IntegerDataEncodingT]
+        self.ONE_STRING_VALUE = None  # type: str
+        self.ZERO_STRING_VALUE = None  # type: str
+        self.INITIAL_VALUE = False  # type: bool
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        booleanParameterType = BooleanParameterType()
+        booleanParameterType.Init(buf, pos)
+        return cls.InitFromObj(booleanParameterType)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, booleanParameterType):
+        x = BooleanParameterTypeT()
+        x._UnPack(booleanParameterType)
+        return x
+
+    # BooleanParameterTypeT
+    def _UnPack(self, booleanParameterType):
+        if booleanParameterType is None:
+            return
+        self.NAME = booleanParameterType.NAME()
+        self.SHORT_DESCRIPTION = booleanParameterType.SHORT_DESCRIPTION()
+        self.LONG_DESCRIPTION = booleanParameterType.LONG_DESCRIPTION()
+        if booleanParameterType.DATA_ENCODING() is not None:
+            self.DATA_ENCODING = IntegerDataEncoding.IntegerDataEncodingT.InitFromObj(booleanParameterType.DATA_ENCODING())
+        self.ONE_STRING_VALUE = booleanParameterType.ONE_STRING_VALUE()
+        self.ZERO_STRING_VALUE = booleanParameterType.ZERO_STRING_VALUE()
+        self.INITIAL_VALUE = booleanParameterType.INITIAL_VALUE()
+
+    # BooleanParameterTypeT
+    def Pack(self, builder):
+        if self.NAME is not None:
+            NAME = builder.CreateString(self.NAME)
+        if self.SHORT_DESCRIPTION is not None:
+            SHORT_DESCRIPTION = builder.CreateString(self.SHORT_DESCRIPTION)
+        if self.LONG_DESCRIPTION is not None:
+            LONG_DESCRIPTION = builder.CreateString(self.LONG_DESCRIPTION)
+        if self.DATA_ENCODING is not None:
+            DATA_ENCODING = self.DATA_ENCODING.Pack(builder)
+        if self.ONE_STRING_VALUE is not None:
+            ONE_STRING_VALUE = builder.CreateString(self.ONE_STRING_VALUE)
+        if self.ZERO_STRING_VALUE is not None:
+            ZERO_STRING_VALUE = builder.CreateString(self.ZERO_STRING_VALUE)
+        BooleanParameterTypeStart(builder)
+        if self.NAME is not None:
+            BooleanParameterTypeAddNAME(builder, NAME)
+        if self.SHORT_DESCRIPTION is not None:
+            BooleanParameterTypeAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION)
+        if self.LONG_DESCRIPTION is not None:
+            BooleanParameterTypeAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION)
+        if self.DATA_ENCODING is not None:
+            BooleanParameterTypeAddDATA_ENCODING(builder, DATA_ENCODING)
+        if self.ONE_STRING_VALUE is not None:
+            BooleanParameterTypeAddONE_STRING_VALUE(builder, ONE_STRING_VALUE)
+        if self.ZERO_STRING_VALUE is not None:
+            BooleanParameterTypeAddZERO_STRING_VALUE(builder, ZERO_STRING_VALUE)
+        BooleanParameterTypeAddINITIAL_VALUE(builder, self.INITIAL_VALUE)
+        booleanParameterType = BooleanParameterTypeEnd(builder)
+        return booleanParameterType

XTC/ByteOrderType.py

@@ -0,0 +1,10 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+# Byte ordering for data encoding
+class ByteOrderType(object):
+    # Most significant byte first
+    BIG_ENDIAN = 0
+    # Least significant byte first
+    LITTLE_ENDIAN = 1