12669669056

Committed 08 Jan 2025 11:28AM UTC coverage: 86.728% (-0.1%) from 86.849%

Build # 12669669056

Build Type

Pull #86

github

Committed by

web-flow

Commit Message

Merge 0ff72b333 into 0261b6670

Pull Request Pull Request #86: Add mypy.ini

Run Details

111 of 133 new or added lines in 14 files covered. (83.46%)

13 existing lines in 5 files now uncovered.

2359 of 2720 relevant lines covered (86.73%)

0.87 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.

# Autogenerated code used only for unit-testing. Ignoring typehints.
# type: ignore

# automatically generated by the FlatBuffers compiler, do not modify

# namespace: shard_writer_flatbuffer_test_schema

# pylint: skip-file

import flatbuffers
from flatbuffers.compat import import_numpy

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: flatbuffers.builder.Builder, numElems: int) -> int:
    return builder.StartVector(1, numElems, 1)


def StartAttributeDoubleVector(builder: flatbuffers.builder.Builder,
                               numElems: int) -> int:
    return NumPyVectorTestStartAttributeDoubleVector(builder, numElems)


def NumPyVectorTestEnd(builder: flatbuffers.builder.Builder) -> int:
    return builder.EndObject()


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

google / sedpack / 12669669056

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