10991778694

Committed 23 Sep 2024 09:46AM UTC coverage: 84.483%. Remained the same

Build # 10991778694

Build Type

push

github

Committed by

web-flow

Commit Message

Add .style.yapf (#21)

Run Details

18 of 44 new or added lines in 9 files covered. (40.91%)

24 existing lines in 1 file now uncovered.

2058 of 2436 relevant lines covered (84.48%)

0.84 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

51.09

/src/sedpack/io/flatbuffer/unit_tests/shard_writer_flatbuffer_test_schema/NumPyVectorTest.py

# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# automatically generated by the FlatBuffers compiler, do not modify

# namespace: shard_writer_flatbuffer_test_schema

# pylint: skip-file

import flatbuffers  # type: ignore
from flatbuffers.compat import import_numpy  # type: ignore

np = import_numpy()


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

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

    @classmethod
    def GetRootAsNumPyVectorTest(cls, buf, offset=0):
        """This method is deprecated. Please switch to GetRootAs."""
        return cls.GetRootAs(buf, offset)

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

    # NumPyVectorTest
    def AttributeBool(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
        if o != 0:
            a = self._tab.Vector(o)
            return self._tab.Get(
                flatbuffers.number_types.Int8Flags,
                a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
        return 0

    # NumPyVectorTest
    def AttributeBoolAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
        if o != 0:
            return self._tab.GetVectorAsNumpy(
                flatbuffers.number_types.Int8Flags, o)
        return 0

    # NumPyVectorTest
    def AttributeBoolLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0

    # NumPyVectorTest
    def AttributeBoolIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
        return o == 0

    # NumPyVectorTest
    def AttributeByte(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
        if o != 0:
            a = self._tab.Vector(o)
            return self._tab.Get(
                flatbuffers.number_types.Int8Flags,
                a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
        return 0

    # NumPyVectorTest
    def AttributeByteAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
        if o != 0:
            return self._tab.GetVectorAsNumpy(
                flatbuffers.number_types.Int8Flags, o)
        return 0

    # NumPyVectorTest
    def AttributeByteLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0

    # NumPyVectorTest
    def AttributeByteIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
        return o == 0

    # NumPyVectorTest
    def AttributeUbyte(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
        if o != 0:
            a = self._tab.Vector(o)
            return self._tab.Get(
                flatbuffers.number_types.Int8Flags,
                a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
        return 0

    # NumPyVectorTest
    def AttributeUbyteAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
        if o != 0:
            return self._tab.GetVectorAsNumpy(
                flatbuffers.number_types.Int8Flags, o)
        return 0

    # NumPyVectorTest
    def AttributeUbyteLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0

    # NumPyVectorTest
    def AttributeUbyteIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
        return o == 0

    # NumPyVectorTest
    def AttributeShort(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
        if o != 0:
            a = self._tab.Vector(o)
            return self._tab.Get(
                flatbuffers.number_types.Int8Flags,
                a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
        return 0

    # NumPyVectorTest
    def AttributeShortAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
        if o != 0:
            return self._tab.GetVectorAsNumpy(
                flatbuffers.number_types.Int8Flags, o)
        return 0

    # NumPyVectorTest
    def AttributeShortLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0

    # NumPyVectorTest
    def AttributeShortIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
        return o == 0

    # NumPyVectorTest
    def AttributeUshort(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
        if o != 0:
            a = self._tab.Vector(o)
            return self._tab.Get(
                flatbuffers.number_types.Int8Flags,
                a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
        return 0

    # NumPyVectorTest
    def AttributeUshortAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
        if o != 0:
            return self._tab.GetVectorAsNumpy(
                flatbuffers.number_types.Int8Flags, o)
        return 0

    # NumPyVectorTest
    def AttributeUshortLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0

    # NumPyVectorTest
    def AttributeUshortIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
        return o == 0

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

    # NumPyVectorTest
    def AttributeIntAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
        if o != 0:
            return self._tab.GetVectorAsNumpy(
                flatbuffers.number_types.Int8Flags, o)
        return 0

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

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

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

    # NumPyVectorTest
    def AttributeUintAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
        if o != 0:
            return self._tab.GetVectorAsNumpy(
                flatbuffers.number_types.Int8Flags, o)
        return 0

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

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

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

    # NumPyVectorTest
    def AttributeFloatAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
        if o != 0:
            return self._tab.GetVectorAsNumpy(
                flatbuffers.number_types.Int8Flags, o)
        return 0

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

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

    # NumPyVectorTest
    def AttributeLong(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
        if o != 0:
            a = self._tab.Vector(o)
            return self._tab.Get(
                flatbuffers.number_types.Int8Flags,
                a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
        return 0

    # NumPyVectorTest
    def AttributeLongAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
        if o != 0:
            return self._tab.GetVectorAsNumpy(
                flatbuffers.number_types.Int8Flags, o)
        return 0

    # NumPyVectorTest
    def AttributeLongLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0

    # NumPyVectorTest
    def AttributeLongIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
        return o == 0

    # NumPyVectorTest
    def AttributeUlong(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
        if o != 0:
            a = self._tab.Vector(o)
            return self._tab.Get(
                flatbuffers.number_types.Int8Flags,
                a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
        return 0

    # NumPyVectorTest
    def AttributeUlongAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
        if o != 0:
            return self._tab.GetVectorAsNumpy(
                flatbuffers.number_types.Int8Flags, o)
        return 0

    # NumPyVectorTest
    def AttributeUlongLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0

    # NumPyVectorTest
    def AttributeUlongIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
        return o == 0

    # NumPyVectorTest
    def AttributeDouble(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
        if o != 0:
            a = self._tab.Vector(o)
            return self._tab.Get(
                flatbuffers.number_types.Int8Flags,
                a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
        return 0

    # NumPyVectorTest
    def AttributeDoubleAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
        if o != 0:
            return self._tab.GetVectorAsNumpy(
                flatbuffers.number_types.Int8Flags, o)
        return 0

    # NumPyVectorTest
    def AttributeDoubleLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0

    # NumPyVectorTest
    def AttributeDoubleIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
        return o == 0


def NumPyVectorTestStart(builder):
    builder.StartObject(11)


def Start(builder):
    NumPyVectorTestStart(builder)


def NumPyVectorTestAddAttributeBool(builder, attributeBool):
    builder.PrependUOffsetTRelativeSlot(
        0, flatbuffers.number_types.UOffsetTFlags.py_type(attributeBool), 0)


def AddAttributeBool(builder, attributeBool):
    NumPyVectorTestAddAttributeBool(builder, attributeBool)


def NumPyVectorTestStartAttributeBoolVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)


def StartAttributeBoolVector(builder, numElems):
    return NumPyVectorTestStartAttributeBoolVector(builder, numElems)


def NumPyVectorTestAddAttributeByte(builder, attributeByte):
    builder.PrependUOffsetTRelativeSlot(
        1, flatbuffers.number_types.UOffsetTFlags.py_type(attributeByte), 0)


def AddAttributeByte(builder, attributeByte):
    NumPyVectorTestAddAttributeByte(builder, attributeByte)


def NumPyVectorTestStartAttributeByteVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)


def StartAttributeByteVector(builder, numElems):
    return NumPyVectorTestStartAttributeByteVector(builder, numElems)


def NumPyVectorTestAddAttributeUbyte(builder, attributeUbyte):
    builder.PrependUOffsetTRelativeSlot(
        2, flatbuffers.number_types.UOffsetTFlags.py_type(attributeUbyte), 0)


def AddAttributeUbyte(builder, attributeUbyte):
    NumPyVectorTestAddAttributeUbyte(builder, attributeUbyte)


def NumPyVectorTestStartAttributeUbyteVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)


def StartAttributeUbyteVector(builder, numElems):
    return NumPyVectorTestStartAttributeUbyteVector(builder, numElems)


def NumPyVectorTestAddAttributeShort(builder, attributeShort):
    builder.PrependUOffsetTRelativeSlot(
        3, flatbuffers.number_types.UOffsetTFlags.py_type(attributeShort), 0)


def AddAttributeShort(builder, attributeShort):
    NumPyVectorTestAddAttributeShort(builder, attributeShort)


def NumPyVectorTestStartAttributeShortVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)


def StartAttributeShortVector(builder, numElems):
    return NumPyVectorTestStartAttributeShortVector(builder, numElems)


def NumPyVectorTestAddAttributeUshort(builder, attributeUshort):
    builder.PrependUOffsetTRelativeSlot(
        4, flatbuffers.number_types.UOffsetTFlags.py_type(attributeUshort), 0)


def AddAttributeUshort(builder, attributeUshort):
    NumPyVectorTestAddAttributeUshort(builder, attributeUshort)


def NumPyVectorTestStartAttributeUshortVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)


def StartAttributeUshortVector(builder, numElems):
    return NumPyVectorTestStartAttributeUshortVector(builder, numElems)


def NumPyVectorTestAddAttributeInt(builder, attributeInt):
    builder.PrependUOffsetTRelativeSlot(
        5, flatbuffers.number_types.UOffsetTFlags.py_type(attributeInt), 0)


def AddAttributeInt(builder, attributeInt):
    NumPyVectorTestAddAttributeInt(builder, attributeInt)


def NumPyVectorTestStartAttributeIntVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)


def StartAttributeIntVector(builder, numElems):
    return NumPyVectorTestStartAttributeIntVector(builder, numElems)


def NumPyVectorTestAddAttributeUint(builder, attributeUint):
    builder.PrependUOffsetTRelativeSlot(
        6, flatbuffers.number_types.UOffsetTFlags.py_type(attributeUint), 0)


def AddAttributeUint(builder, attributeUint):
    NumPyVectorTestAddAttributeUint(builder, attributeUint)


def NumPyVectorTestStartAttributeUintVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)


def StartAttributeUintVector(builder, numElems):
    return NumPyVectorTestStartAttributeUintVector(builder, numElems)


def NumPyVectorTestAddAttributeFloat(builder, attributeFloat):
    builder.PrependUOffsetTRelativeSlot(
        7, flatbuffers.number_types.UOffsetTFlags.py_type(attributeFloat), 0)


def AddAttributeFloat(builder, attributeFloat):
    NumPyVectorTestAddAttributeFloat(builder, attributeFloat)


def NumPyVectorTestStartAttributeFloatVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)


def StartAttributeFloatVector(builder, numElems):
    return NumPyVectorTestStartAttributeFloatVector(builder, numElems)


def NumPyVectorTestAddAttributeLong(builder, attributeLong):
    builder.PrependUOffsetTRelativeSlot(
        8, flatbuffers.number_types.UOffsetTFlags.py_type(attributeLong), 0)


def AddAttributeLong(builder, attributeLong):
    NumPyVectorTestAddAttributeLong(builder, attributeLong)


def NumPyVectorTestStartAttributeLongVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)


def StartAttributeLongVector(builder, numElems):
    return NumPyVectorTestStartAttributeLongVector(builder, numElems)


def NumPyVectorTestAddAttributeUlong(builder, attributeUlong):
    builder.PrependUOffsetTRelativeSlot(
        9, flatbuffers.number_types.UOffsetTFlags.py_type(attributeUlong), 0)


def AddAttributeUlong(builder, attributeUlong):
    NumPyVectorTestAddAttributeUlong(builder, attributeUlong)


def NumPyVectorTestStartAttributeUlongVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)


def StartAttributeUlongVector(builder, numElems):
    return NumPyVectorTestStartAttributeUlongVector(builder, numElems)


def NumPyVectorTestAddAttributeDouble(builder, attributeDouble):
    builder.PrependUOffsetTRelativeSlot(
        10, flatbuffers.number_types.UOffsetTFlags.py_type(attributeDouble), 0)


def AddAttributeDouble(builder, attributeDouble):
    NumPyVectorTestAddAttributeDouble(builder, attributeDouble)


def NumPyVectorTestStartAttributeDoubleVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)


def StartAttributeDoubleVector(builder, numElems):
    return NumPyVectorTestStartAttributeDoubleVector(builder, numElems)


def NumPyVectorTestEnd(builder):
    return builder.EndObject()


def End(builder):
    return NumPyVectorTestEnd(builder)

1	# Copyright 2024 Google LLC
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	# https://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
15	# automatically generated by the FlatBuffers compiler, do not modify
16
17	# namespace: shard_writer_flatbuffer_test_schema
18
19	# pylint: skip-file
20
21	import flatbuffers # type: ignore	1✔
22	from flatbuffers.compat import import_numpy # type: ignore	1✔
23
24	np = import_numpy()	1✔
25
26
27	class NumPyVectorTest(object):	1✔
28	__slots__ = ['_tab']	1✔
29
30	@classmethod	1✔
31	def GetRootAs(cls, buf, offset=0):	1✔
32	n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)	1✔
33	x = NumPyVectorTest()	1✔
34	x.Init(buf, n + offset)	1✔
35	return x	1✔
36
37	@classmethod	1✔
38	def GetRootAsNumPyVectorTest(cls, buf, offset=0):	1✔
39	"""This method is deprecated. Please switch to GetRootAs."""
40	return cls.GetRootAs(buf, offset)	×
41
42	# NumPyVectorTest
43	def Init(self, buf, pos):	1✔
44	self._tab = flatbuffers.table.Table(buf, pos)	1✔
45
46	# NumPyVectorTest
47	def AttributeBool(self, j):	1✔
48	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))	×
49	if o != 0:	×
50	a = self._tab.Vector(o)	×
51	return self._tab.Get(	×
52	flatbuffers.number_types.Int8Flags,
53	a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
54	return 0	×
55
56	# NumPyVectorTest
57	def AttributeBoolAsNumpy(self):	1✔
58	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))	1✔
59	if o != 0:	1✔
60	return self._tab.GetVectorAsNumpy(	1✔
61	flatbuffers.number_types.Int8Flags, o)
62	return 0	×
63
64	# NumPyVectorTest
65	def AttributeBoolLength(self):	1✔
66	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))	×
67	if o != 0:	×
68	return self._tab.VectorLen(o)	×
69	return 0	×
70
71	# NumPyVectorTest
72	def AttributeBoolIsNone(self):	1✔
73	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))	×
74	return o == 0	×
75
76	# NumPyVectorTest
77	def AttributeByte(self, j):	1✔
78	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))	×
79	if o != 0:	×
80	a = self._tab.Vector(o)	×
81	return self._tab.Get(	×
82	flatbuffers.number_types.Int8Flags,
83	a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
84	return 0	×
85
86	# NumPyVectorTest
87	def AttributeByteAsNumpy(self):	1✔
88	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))	1✔
89	if o != 0:	1✔
90	return self._tab.GetVectorAsNumpy(	1✔
91	flatbuffers.number_types.Int8Flags, o)
92	return 0	×
93
94	# NumPyVectorTest
95	def AttributeByteLength(self):	1✔
96	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))	×
97	if o != 0:	×
98	return self._tab.VectorLen(o)	×
99	return 0	×
100
101	# NumPyVectorTest
102	def AttributeByteIsNone(self):	1✔
103	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))	×
104	return o == 0	×
105
106	# NumPyVectorTest
107	def AttributeUbyte(self, j):	1✔
108	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))	×
109	if o != 0:	×
110	a = self._tab.Vector(o)	×
111	return self._tab.Get(	×
112	flatbuffers.number_types.Int8Flags,
113	a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
114	return 0	×
115
116	# NumPyVectorTest
117	def AttributeUbyteAsNumpy(self):	1✔
118	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))	1✔
119	if o != 0:	1✔
120	return self._tab.GetVectorAsNumpy(	1✔
121	flatbuffers.number_types.Int8Flags, o)
122	return 0	×
123
124	# NumPyVectorTest
125	def AttributeUbyteLength(self):	1✔
126	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))	×
127	if o != 0:	×
128	return self._tab.VectorLen(o)	×
129	return 0	×
130
131	# NumPyVectorTest
132	def AttributeUbyteIsNone(self):	1✔
133	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))	×
134	return o == 0	×
135
136	# NumPyVectorTest
137	def AttributeShort(self, j):	1✔
NEW 138	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))	×
UNCOV 139	if o != 0:	×
140	a = self._tab.Vector(o)	×
141	return self._tab.Get(	×
142	flatbuffers.number_types.Int8Flags,
143	a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
144	return 0	×
145
146	# NumPyVectorTest
147	def AttributeShortAsNumpy(self):	1✔
148	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))	1✔
149	if o != 0:	1✔
150	return self._tab.GetVectorAsNumpy(	1✔
151	flatbuffers.number_types.Int8Flags, o)
152	return 0	×
153
154	# NumPyVectorTest
155	def AttributeShortLength(self):	1✔
NEW 156	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))	×
UNCOV 157	if o != 0:	×
158	return self._tab.VectorLen(o)	×
159	return 0	×
160
161	# NumPyVectorTest
162	def AttributeShortIsNone(self):	1✔
NEW 163	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))	×
UNCOV 164	return o == 0	×
165
166	# NumPyVectorTest
167	def AttributeUshort(self, j):	1✔
NEW 168	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))	×
UNCOV 169	if o != 0:	×
170	a = self._tab.Vector(o)	×
171	return self._tab.Get(	×
172	flatbuffers.number_types.Int8Flags,
173	a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
174	return 0	×
175
176	# NumPyVectorTest
177	def AttributeUshortAsNumpy(self):	1✔
178	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))	1✔
179	if o != 0:	1✔
180	return self._tab.GetVectorAsNumpy(	1✔
181	flatbuffers.number_types.Int8Flags, o)
182	return 0	×
183
184	# NumPyVectorTest
185	def AttributeUshortLength(self):	1✔
NEW 186	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))	×
UNCOV 187	if o != 0:	×
188	return self._tab.VectorLen(o)	×
189	return 0	×
190
191	# NumPyVectorTest
192	def AttributeUshortIsNone(self):	1✔
NEW 193	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))	×
UNCOV 194	return o == 0	×
195
196	# NumPyVectorTest
197	def AttributeInt(self, j):	1✔
NEW 198	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))	×
UNCOV 199	if o != 0:	×
200	a = self._tab.Vector(o)	×
201	return self._tab.Get(	×
202	flatbuffers.number_types.Int8Flags,
203	a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
204	return 0	×
205
206	# NumPyVectorTest
207	def AttributeIntAsNumpy(self):	1✔
208	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))	1✔
209	if o != 0:	1✔
210	return self._tab.GetVectorAsNumpy(	1✔
211	flatbuffers.number_types.Int8Flags, o)
212	return 0	×
213
214	# NumPyVectorTest
215	def AttributeIntLength(self):	1✔
NEW 216	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))	×
UNCOV 217	if o != 0:	×
218	return self._tab.VectorLen(o)	×
219	return 0	×
220
221	# NumPyVectorTest
222	def AttributeIntIsNone(self):	1✔
NEW 223	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))	×
UNCOV 224	return o == 0	×
225
226	# NumPyVectorTest
227	def AttributeUint(self, j):	1✔
NEW 228	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))	×
UNCOV 229	if o != 0:	×
230	a = self._tab.Vector(o)	×
231	return self._tab.Get(	×
232	flatbuffers.number_types.Int8Flags,
233	a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
234	return 0	×
235
236	# NumPyVectorTest
237	def AttributeUintAsNumpy(self):	1✔
238	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))	1✔
239	if o != 0:	1✔
240	return self._tab.GetVectorAsNumpy(	1✔
241	flatbuffers.number_types.Int8Flags, o)
242	return 0	×
243
244	# NumPyVectorTest
245	def AttributeUintLength(self):	1✔
NEW 246	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))	×
UNCOV 247	if o != 0:	×
248	return self._tab.VectorLen(o)	×
249	return 0	×
250
251	# NumPyVectorTest
252	def AttributeUintIsNone(self):	1✔
NEW 253	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))	×
UNCOV 254	return o == 0	×
255
256	# NumPyVectorTest
257	def AttributeFloat(self, j):	1✔
NEW 258	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))	×
UNCOV 259	if o != 0:	×
260	a = self._tab.Vector(o)	×
261	return self._tab.Get(	×
262	flatbuffers.number_types.Int8Flags,
263	a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
264	return 0	×
265
266	# NumPyVectorTest
267	def AttributeFloatAsNumpy(self):	1✔
268	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))	1✔
269	if o != 0:	1✔
270	return self._tab.GetVectorAsNumpy(	1✔
271	flatbuffers.number_types.Int8Flags, o)
272	return 0	×
273
274	# NumPyVectorTest
275	def AttributeFloatLength(self):	1✔
NEW 276	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))	×
UNCOV 277	if o != 0:	×
278	return self._tab.VectorLen(o)	×
279	return 0	×
280
281	# NumPyVectorTest
282	def AttributeFloatIsNone(self):	1✔
NEW 283	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))	×
UNCOV 284	return o == 0	×
285
286	# NumPyVectorTest
287	def AttributeLong(self, j):	1✔
NEW 288	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))	×
UNCOV 289	if o != 0:	×
290	a = self._tab.Vector(o)	×
291	return self._tab.Get(	×
292	flatbuffers.number_types.Int8Flags,
293	a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
294	return 0	×
295
296	# NumPyVectorTest
297	def AttributeLongAsNumpy(self):	1✔
298	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))	1✔
299	if o != 0:	1✔
300	return self._tab.GetVectorAsNumpy(	1✔
301	flatbuffers.number_types.Int8Flags, o)
302	return 0	×
303
304	# NumPyVectorTest
305	def AttributeLongLength(self):	1✔
NEW 306	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))	×
UNCOV 307	if o != 0:	×
308	return self._tab.VectorLen(o)	×
309	return 0	×
310
311	# NumPyVectorTest
312	def AttributeLongIsNone(self):	1✔
NEW 313	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))	×
UNCOV 314	return o == 0	×
315
316	# NumPyVectorTest
317	def AttributeUlong(self, j):	1✔
NEW 318	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))	×
UNCOV 319	if o != 0:	×
320	a = self._tab.Vector(o)	×
321	return self._tab.Get(	×
322	flatbuffers.number_types.Int8Flags,
323	a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
324	return 0	×
325
326	# NumPyVectorTest
327	def AttributeUlongAsNumpy(self):	1✔
328	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))	1✔
329	if o != 0:	1✔
330	return self._tab.GetVectorAsNumpy(	1✔
331	flatbuffers.number_types.Int8Flags, o)
332	return 0	×
333
334	# NumPyVectorTest
335	def AttributeUlongLength(self):	1✔
NEW 336	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))	×
UNCOV 337	if o != 0:	×
338	return self._tab.VectorLen(o)	×
339	return 0	×
340
341	# NumPyVectorTest
342	def AttributeUlongIsNone(self):	1✔
NEW 343	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))	×
UNCOV 344	return o == 0	×
345
346	# NumPyVectorTest
347	def AttributeDouble(self, j):	1✔
NEW 348	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))	×
UNCOV 349	if o != 0:	×
350	a = self._tab.Vector(o)	×
351	return self._tab.Get(	×
352	flatbuffers.number_types.Int8Flags,
353	a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
354	return 0	×
355
356	# NumPyVectorTest
357	def AttributeDoubleAsNumpy(self):	1✔
358	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))	1✔
359	if o != 0:	1✔
360	return self._tab.GetVectorAsNumpy(	1✔
361	flatbuffers.number_types.Int8Flags, o)
362	return 0	×
363
364	# NumPyVectorTest
365	def AttributeDoubleLength(self):	1✔
NEW 366	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))	×
UNCOV 367	if o != 0:	×
368	return self._tab.VectorLen(o)	×
369	return 0	×
370
371	# NumPyVectorTest
372	def AttributeDoubleIsNone(self):	1✔
NEW 373	o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))	×
UNCOV 374	return o == 0	×
375
376
377	def NumPyVectorTestStart(builder):	1✔
378	builder.StartObject(11)	1✔
379
380
381	def Start(builder):	1✔
382	NumPyVectorTestStart(builder)	×
383
384
385	def NumPyVectorTestAddAttributeBool(builder, attributeBool):	1✔
386	builder.PrependUOffsetTRelativeSlot(	1✔
387	0, flatbuffers.number_types.UOffsetTFlags.py_type(attributeBool), 0)
388
389
390	def AddAttributeBool(builder, attributeBool):	1✔
391	NumPyVectorTestAddAttributeBool(builder, attributeBool)	1✔
392
393
394	def NumPyVectorTestStartAttributeBoolVector(builder, numElems):	1✔
395	return builder.StartVector(1, numElems, 1)	×
396
397
398	def StartAttributeBoolVector(builder, numElems):	1✔
399	return NumPyVectorTestStartAttributeBoolVector(builder, numElems)	×
400
401
402	def NumPyVectorTestAddAttributeByte(builder, attributeByte):	1✔
403	builder.PrependUOffsetTRelativeSlot(	1✔
404	1, flatbuffers.number_types.UOffsetTFlags.py_type(attributeByte), 0)
405
406
407	def AddAttributeByte(builder, attributeByte):	1✔
408	NumPyVectorTestAddAttributeByte(builder, attributeByte)	1✔
409
410
411	def NumPyVectorTestStartAttributeByteVector(builder, numElems):	1✔
412	return builder.StartVector(1, numElems, 1)	×
413
414
415	def StartAttributeByteVector(builder, numElems):	1✔
416	return NumPyVectorTestStartAttributeByteVector(builder, numElems)	×
417
418
419	def NumPyVectorTestAddAttributeUbyte(builder, attributeUbyte):	1✔
420	builder.PrependUOffsetTRelativeSlot(	1✔
421	2, flatbuffers.number_types.UOffsetTFlags.py_type(attributeUbyte), 0)
422
423
424	def AddAttributeUbyte(builder, attributeUbyte):	1✔
425	NumPyVectorTestAddAttributeUbyte(builder, attributeUbyte)	1✔
426
427
428	def NumPyVectorTestStartAttributeUbyteVector(builder, numElems):	1✔
429	return builder.StartVector(1, numElems, 1)	×
430
431
432	def StartAttributeUbyteVector(builder, numElems):	1✔
433	return NumPyVectorTestStartAttributeUbyteVector(builder, numElems)	×
434
435
436	def NumPyVectorTestAddAttributeShort(builder, attributeShort):	1✔
437	builder.PrependUOffsetTRelativeSlot(	1✔
438	3, flatbuffers.number_types.UOffsetTFlags.py_type(attributeShort), 0)
439
440
441	def AddAttributeShort(builder, attributeShort):	1✔
442	NumPyVectorTestAddAttributeShort(builder, attributeShort)	1✔
443
444
445	def NumPyVectorTestStartAttributeShortVector(builder, numElems):	1✔
446	return builder.StartVector(1, numElems, 1)	×
447
448
449	def StartAttributeShortVector(builder, numElems):	1✔
450	return NumPyVectorTestStartAttributeShortVector(builder, numElems)	×
451
452
453	def NumPyVectorTestAddAttributeUshort(builder, attributeUshort):	1✔
454	builder.PrependUOffsetTRelativeSlot(	1✔
455	4, flatbuffers.number_types.UOffsetTFlags.py_type(attributeUshort), 0)
456
457
458	def AddAttributeUshort(builder, attributeUshort):	1✔
459	NumPyVectorTestAddAttributeUshort(builder, attributeUshort)	1✔
460
461
462	def NumPyVectorTestStartAttributeUshortVector(builder, numElems):	1✔
463	return builder.StartVector(1, numElems, 1)	×
464
465
466	def StartAttributeUshortVector(builder, numElems):	1✔
467	return NumPyVectorTestStartAttributeUshortVector(builder, numElems)	×
468
469
470	def NumPyVectorTestAddAttributeInt(builder, attributeInt):	1✔
471	builder.PrependUOffsetTRelativeSlot(	1✔
472	5, flatbuffers.number_types.UOffsetTFlags.py_type(attributeInt), 0)
473
474
475	def AddAttributeInt(builder, attributeInt):	1✔
476	NumPyVectorTestAddAttributeInt(builder, attributeInt)	1✔
477
478
479	def NumPyVectorTestStartAttributeIntVector(builder, numElems):	1✔
480	return builder.StartVector(1, numElems, 1)	×
481
482
483	def StartAttributeIntVector(builder, numElems):	1✔
484	return NumPyVectorTestStartAttributeIntVector(builder, numElems)	×
485
486
487	def NumPyVectorTestAddAttributeUint(builder, attributeUint):	1✔
488	builder.PrependUOffsetTRelativeSlot(	1✔
489	6, flatbuffers.number_types.UOffsetTFlags.py_type(attributeUint), 0)
490
491
492	def AddAttributeUint(builder, attributeUint):	1✔
493	NumPyVectorTestAddAttributeUint(builder, attributeUint)	1✔
494
495
496	def NumPyVectorTestStartAttributeUintVector(builder, numElems):	1✔
497	return builder.StartVector(1, numElems, 1)	×
498
499
500	def StartAttributeUintVector(builder, numElems):	1✔
501	return NumPyVectorTestStartAttributeUintVector(builder, numElems)	×
502
503
504	def NumPyVectorTestAddAttributeFloat(builder, attributeFloat):	1✔
505	builder.PrependUOffsetTRelativeSlot(	1✔
506	7, flatbuffers.number_types.UOffsetTFlags.py_type(attributeFloat), 0)
507
508
509	def AddAttributeFloat(builder, attributeFloat):	1✔
510	NumPyVectorTestAddAttributeFloat(builder, attributeFloat)	1✔
511
512
513	def NumPyVectorTestStartAttributeFloatVector(builder, numElems):	1✔
514	return builder.StartVector(1, numElems, 1)	×
515
516
517	def StartAttributeFloatVector(builder, numElems):	1✔
518	return NumPyVectorTestStartAttributeFloatVector(builder, numElems)	×
519
520
521	def NumPyVectorTestAddAttributeLong(builder, attributeLong):	1✔
522	builder.PrependUOffsetTRelativeSlot(	1✔
523	8, flatbuffers.number_types.UOffsetTFlags.py_type(attributeLong), 0)
524
525
526	def AddAttributeLong(builder, attributeLong):	1✔
527	NumPyVectorTestAddAttributeLong(builder, attributeLong)	1✔
528
529
530	def NumPyVectorTestStartAttributeLongVector(builder, numElems):	1✔
531	return builder.StartVector(1, numElems, 1)	×
532
533
534	def StartAttributeLongVector(builder, numElems):	1✔
535	return NumPyVectorTestStartAttributeLongVector(builder, numElems)	×
536
537
538	def NumPyVectorTestAddAttributeUlong(builder, attributeUlong):	1✔
539	builder.PrependUOffsetTRelativeSlot(	1✔
540	9, flatbuffers.number_types.UOffsetTFlags.py_type(attributeUlong), 0)
541
542
543	def AddAttributeUlong(builder, attributeUlong):	1✔
544	NumPyVectorTestAddAttributeUlong(builder, attributeUlong)	1✔
545
546
547	def NumPyVectorTestStartAttributeUlongVector(builder, numElems):	1✔
548	return builder.StartVector(1, numElems, 1)	×
549
550
551	def StartAttributeUlongVector(builder, numElems):	1✔
552	return NumPyVectorTestStartAttributeUlongVector(builder, numElems)	×
553
554
555	def NumPyVectorTestAddAttributeDouble(builder, attributeDouble):	1✔
556	builder.PrependUOffsetTRelativeSlot(	1✔
557	10, flatbuffers.number_types.UOffsetTFlags.py_type(attributeDouble), 0)
558
559
560	def AddAttributeDouble(builder, attributeDouble):	1✔
561	NumPyVectorTestAddAttributeDouble(builder, attributeDouble)	1✔
562
563
564	def NumPyVectorTestStartAttributeDoubleVector(builder, numElems):	1✔
565	return builder.StartVector(1, numElems, 1)	×
566
567
568	def StartAttributeDoubleVector(builder, numElems):	1✔
569	return NumPyVectorTestStartAttributeDoubleVector(builder, numElems)	×
570
571
572	def NumPyVectorTestEnd(builder):	1✔
573	return builder.EndObject()	1✔
574
575
576	def End(builder):	1✔
577	return NumPyVectorTestEnd(builder)	×

google / sedpack / 10991778694

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous