12657020692

Committed 07 Jan 2025 06:21PM UTC coverage: 86.723% (-0.1%) from 86.849%

Build # 12657020692

Build Type

Pull #86

github

Committed by

web-flow

Commit Message

Merge 03c0767fa into 0261b6670

Pull Request Pull Request #86: Add mypy.ini

Run Details

109 of 132 new or added lines in 16 files covered. (82.58%)

13 existing lines in 5 files now uncovered.

2358 of 2719 relevant lines covered (86.72%)

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.

# type: ignore

# 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(  # type: ignore[no-any-unimported]
        builder: flatbuffers.builder.Builder, numElems: int) -> int:
    return builder.StartVector(1, numElems, 1)  # type: ignore[no-any-return]


def StartAttributeDoubleVector(  # type: ignore[no-any-unimported]
        builder: flatbuffers.builder.Builder, numElems: int) -> int:
    return NumPyVectorTestStartAttributeDoubleVector(builder, numElems)


def NumPyVectorTestEnd(  # type: ignore[no-any-unimported]
    builder: flatbuffers.builder.Builder) -> int:
    return builder.EndObject()  # type: ignore[no-any-return]


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

google / sedpack / 12657020692

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