zlmdb 25.12.2__cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl

zlmdb/flatbuffers/reflection/Service.py

@@ -0,0 +1,213 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: reflection
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+
+np = import_numpy()
+
+
+class Service(object):
+    __slots__ = ["_tab"]
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Service()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsService(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+
+    @classmethod
+    def ServiceBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(
+            buf, offset, b"\x42\x46\x42\x53", size_prefixed=size_prefixed
+        )
+
+    # Service
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Service
+    def Name(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Service
+    def Calls(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from reflection.RPCCall import RPCCall
+
+            obj = RPCCall()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Service
+    def CallsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Service
+    def CallsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        return o == 0
+
+    # Service
+    def Attributes(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from reflection.KeyValue import KeyValue
+
+            obj = KeyValue()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Service
+    def AttributesLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Service
+    def AttributesIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        return o == 0
+
+    # Service
+    def Documentation(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(
+                a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)
+            )
+        return ""
+
+    # Service
+    def DocumentationLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Service
+    def DocumentationIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        return o == 0
+
+    # File that this Service is declared in.
+    # Service
+    def DeclarationFile(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+
+def ServiceStart(builder):
+    builder.StartObject(5)
+
+
+def Start(builder):
+    return ServiceStart(builder)
+
+
+def ServiceAddName(builder, name):
+    builder.PrependUOffsetTRelativeSlot(
+        0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0
+    )
+
+
+def AddName(builder, name):
+    return ServiceAddName(builder, name)
+
+
+def ServiceAddCalls(builder, calls):
+    builder.PrependUOffsetTRelativeSlot(
+        1, flatbuffers.number_types.UOffsetTFlags.py_type(calls), 0
+    )
+
+
+def AddCalls(builder, calls):
+    return ServiceAddCalls(builder, calls)
+
+
+def ServiceStartCallsVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+
+def StartCallsVector(builder, numElems):
+    return ServiceStartCallsVector(builder, numElems)
+
+
+def ServiceAddAttributes(builder, attributes):
+    builder.PrependUOffsetTRelativeSlot(
+        2, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0
+    )
+
+
+def AddAttributes(builder, attributes):
+    return ServiceAddAttributes(builder, attributes)
+
+
+def ServiceStartAttributesVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+
+def StartAttributesVector(builder, numElems):
+    return ServiceStartAttributesVector(builder, numElems)
+
+
+def ServiceAddDocumentation(builder, documentation):
+    builder.PrependUOffsetTRelativeSlot(
+        3, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0
+    )
+
+
+def AddDocumentation(builder, documentation):
+    return ServiceAddDocumentation(builder, documentation)
+
+
+def ServiceStartDocumentationVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+
+def StartDocumentationVector(builder, numElems):
+    return ServiceStartDocumentationVector(builder, numElems)
+
+
+def ServiceAddDeclarationFile(builder, declarationFile):
+    builder.PrependUOffsetTRelativeSlot(
+        4, flatbuffers.number_types.UOffsetTFlags.py_type(declarationFile), 0
+    )
+
+
+def AddDeclarationFile(builder, declarationFile):
+    return ServiceAddDeclarationFile(builder, declarationFile)
+
+
+def ServiceEnd(builder):
+    return builder.EndObject()
+
+
+def End(builder):
+    return ServiceEnd(builder)

zlmdb/flatbuffers/reflection/Type.py

@@ -0,0 +1,148 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: reflection
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+
+np = import_numpy()
+
+
+class Type(object):
+    __slots__ = ["_tab"]
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Type()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsType(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+
+    @classmethod
+    def TypeBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(
+            buf, offset, b"\x42\x46\x42\x53", size_prefixed=size_prefixed
+        )
+
+    # Type
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Type
+    def BaseType(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+        return 0
+
+    # Type
+    def Element(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+        return 0
+
+    # Type
+    def Index(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return -1
+
+    # Type
+    def FixedLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(
+                flatbuffers.number_types.Uint16Flags, o + self._tab.Pos
+            )
+        return 0
+
+    # The size (octets) of the `base_type` field.
+    # Type
+    def BaseSize(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(
+                flatbuffers.number_types.Uint32Flags, o + self._tab.Pos
+            )
+        return 4
+
+    # The size (octets) of the `element` field, if present.
+    # Type
+    def ElementSize(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.Get(
+                flatbuffers.number_types.Uint32Flags, o + self._tab.Pos
+            )
+        return 0
+
+
+def TypeStart(builder):
+    builder.StartObject(6)
+
+
+def Start(builder):
+    return TypeStart(builder)
+
+
+def TypeAddBaseType(builder, baseType):
+    builder.PrependInt8Slot(0, baseType, 0)
+
+
+def AddBaseType(builder, baseType):
+    return TypeAddBaseType(builder, baseType)
+
+
+def TypeAddElement(builder, element):
+    builder.PrependInt8Slot(1, element, 0)
+
+
+def AddElement(builder, element):
+    return TypeAddElement(builder, element)
+
+
+def TypeAddIndex(builder, index):
+    builder.PrependInt32Slot(2, index, -1)
+
+
+def AddIndex(builder, index):
+    return TypeAddIndex(builder, index)
+
+
+def TypeAddFixedLength(builder, fixedLength):
+    builder.PrependUint16Slot(3, fixedLength, 0)
+
+
+def AddFixedLength(builder, fixedLength):
+    return TypeAddFixedLength(builder, fixedLength)
+
+
+def TypeAddBaseSize(builder, baseSize):
+    builder.PrependUint32Slot(4, baseSize, 4)
+
+
+def AddBaseSize(builder, baseSize):
+    return TypeAddBaseSize(builder, baseSize)
+
+
+def TypeAddElementSize(builder, elementSize):
+    builder.PrependUint32Slot(5, elementSize, 0)
+
+
+def AddElementSize(builder, elementSize):
+    return TypeAddElementSize(builder, elementSize)
+
+
+def TypeEnd(builder):
+    return builder.EndObject()
+
+
+def End(builder):
+    return TypeEnd(builder)

zlmdb/flatbuffers/reflection.fbs

@@ -0,0 +1,156 @@
+// This schema defines objects that represent a parsed schema, like
+// the binary version of a .fbs file.
+// This could be used to operate on unknown FlatBuffers at runtime.
+// It can even ... represent itself (!)
+
+namespace reflection;
+
+// These must correspond to the enum in idl.h.
+enum BaseType : byte {
+    None,
+    UType,
+    Bool,
+    Byte,
+    UByte,
+    Short,
+    UShort,
+    Int,
+    UInt,
+    Long,
+    ULong,
+    Float,
+    Double,
+    String,
+    Vector,
+    Obj,     // Used for tables & structs.
+    Union,
+    Array,
+    Vector64,
+
+    // Add any new type above this value.
+    MaxBaseType
+}
+
+table Type {
+    base_type:BaseType;
+    element:BaseType = None;  // Only if base_type == Vector
+                              // or base_type == Array.
+    index:int = -1;  // If base_type == Object, index into "objects" below.
+                     // If base_type == Union, UnionType, or integral derived
+                     // from an enum, index into "enums" below.
+                     // If base_type == Vector && element == Union or UnionType.
+    fixed_length:uint16 = 0;  // Only if base_type == Array.
+    /// The size (octets) of the `base_type` field.
+    base_size:uint = 4; // 4 Is a common size due to offsets being that size.
+    /// The size (octets) of the `element` field, if present.
+    element_size:uint = 0;
+}
+
+table KeyValue {
+    key:string (required, key);
+    value:string;
+}
+
+table EnumVal {
+    name:string (required);
+    value:long (key);
+    object:Object (deprecated);
+    union_type:Type;
+    documentation:[string];
+    attributes:[KeyValue];
+}
+
+table Enum {
+    name:string (required, key);
+    values:[EnumVal] (required);  // In order of their values.
+    is_union:bool = false;
+    underlying_type:Type (required);
+    attributes:[KeyValue];
+    documentation:[string];
+    /// File that this Enum is declared in.
+    declaration_file: string;
+}
+
+table Field {
+    name:string (required, key);
+    type:Type (required);
+    id:ushort;
+    offset:ushort;  // Offset into the vtable for tables, or into the struct.
+    default_integer:long = 0;
+    default_real:double = 0.0;
+    deprecated:bool = false;
+    required:bool = false;
+    key:bool = false;
+    attributes:[KeyValue];
+    documentation:[string];
+    optional:bool = false;
+    /// Number of padding octets to always add after this field. Structs only.
+    padding:uint16 = 0; 
+    /// If the field uses 64-bit offsets.
+    offset64:bool = false;
+}
+
+table Object {  // Used for both tables and structs.
+    name:string (required, key);
+    fields:[Field] (required);  // Sorted.
+    is_struct:bool = false;
+    minalign:int;
+    bytesize:int;  // For structs.
+    attributes:[KeyValue];
+    documentation:[string];
+    /// File that this Object is declared in.
+    declaration_file: string;
+}
+
+table RPCCall {
+    name:string (required, key);
+    request:Object (required);      // must be a table (not a struct)
+    response:Object (required);     // must be a table (not a struct)
+    attributes:[KeyValue];
+    documentation:[string];
+}
+
+table Service {
+    name:string (required, key);
+    calls:[RPCCall];
+    attributes:[KeyValue];
+    documentation:[string];
+    /// File that this Service is declared in.
+    declaration_file: string;
+}
+
+/// New schema language features that are not supported by old code generators.
+enum AdvancedFeatures : ulong (bit_flags) {
+    AdvancedArrayFeatures,
+    AdvancedUnionFeatures,
+    OptionalScalars,
+    DefaultVectorsAndStrings,
+}
+
+/// File specific information.
+/// Symbols declared within a file may be recovered by iterating over all
+/// symbols and examining the `declaration_file` field.
+table SchemaFile {
+  /// Filename, relative to project root.
+  filename:string (required, key);
+  /// Names of included files, relative to project root.
+  included_filenames:[string];
+}
+
+table Schema {
+    objects:[Object] (required);    // Sorted.
+    enums:[Enum] (required);        // Sorted.
+    file_ident:string;
+    file_ext:string;
+    root_table:Object;
+    services:[Service];             // Sorted.
+    advanced_features:AdvancedFeatures;
+    /// All the files used in this compilation. Files are relative to where
+    /// flatc was invoked.
+    fbs_files:[SchemaFile];         // Sorted.
+}
+
+root_type Schema;
+
+file_identifier "BFBS";
+file_extension "bfbs";

zlmdb/flatbuffers/table.py

@@ -0,0 +1,129 @@
+# Copyright 2014 Google Inc. All rights reserved.
+#
+# 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
+#
+#     http://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.
+
+from . import encode
+from . import number_types as N
+
+
+class Table(object):
+    """Table wraps a byte slice and provides read access to its data.
+
+    The variable `Pos` indicates the root of the FlatBuffers object therein."""
+
+    __slots__ = ("Bytes", "Pos")
+
+    def __init__(self, buf, pos):
+        N.enforce_number(pos, N.UOffsetTFlags)
+
+        self.Bytes = buf
+        self.Pos = pos
+
+    def Offset(self, vtableOffset):
+        """Offset provides access into the Table's vtable.
+
+        Deprecated fields are ignored by checking the vtable's length."""
+
+        vtable = self.Pos - self.Get(N.SOffsetTFlags, self.Pos)
+        vtableEnd = self.Get(N.VOffsetTFlags, vtable)
+        if vtableOffset < vtableEnd:
+            return self.Get(N.VOffsetTFlags, vtable + vtableOffset)
+        return 0
+
+    def Indirect(self, off):
+        """Indirect retrieves the relative offset stored at `offset`."""
+        N.enforce_number(off, N.UOffsetTFlags)
+        return off + encode.Get(N.UOffsetTFlags.packer_type, self.Bytes, off)
+
+    def String(self, off):
+        """String gets a string from data stored inside the flatbuffer."""
+        N.enforce_number(off, N.UOffsetTFlags)
+        off += encode.Get(N.UOffsetTFlags.packer_type, self.Bytes, off)
+        start = off + N.UOffsetTFlags.bytewidth
+        length = encode.Get(N.UOffsetTFlags.packer_type, self.Bytes, off)
+        return bytes(self.Bytes[start : start + length])
+
+    def VectorLen(self, off):
+        """VectorLen retrieves the length of the vector whose offset is stored
+        at "off" in this object."""
+        N.enforce_number(off, N.UOffsetTFlags)
+
+        off += self.Pos
+        off += encode.Get(N.UOffsetTFlags.packer_type, self.Bytes, off)
+        ret = encode.Get(N.UOffsetTFlags.packer_type, self.Bytes, off)
+        return ret
+
+    def Vector(self, off):
+        """Vector retrieves the start of data of the vector whose offset is
+        stored at "off" in this object."""
+        N.enforce_number(off, N.UOffsetTFlags)
+
+        off += self.Pos
+        x = off + self.Get(N.UOffsetTFlags, off)
+        # data starts after metadata containing the vector length
+        x += N.UOffsetTFlags.bytewidth
+        return x
+
+    def Union(self, t2, off):
+        """Union initializes any Table-derived type to point to the union at
+        the given offset."""
+        assert type(t2) is Table
+        N.enforce_number(off, N.UOffsetTFlags)
+
+        off += self.Pos
+        t2.Pos = off + self.Get(N.UOffsetTFlags, off)
+        t2.Bytes = self.Bytes
+
+    def Get(self, flags, off):
+        """
+        Get retrieves a value of the type specified by `flags`  at the
+        given offset.
+        """
+        N.enforce_number(off, N.UOffsetTFlags)
+        return flags.py_type(encode.Get(flags.packer_type, self.Bytes, off))
+
+    def GetSlot(self, slot, d, validator_flags):
+        N.enforce_number(slot, N.VOffsetTFlags)
+        if validator_flags is not None:
+            N.enforce_number(d, validator_flags)
+        off = self.Offset(slot)
+        if off == 0:
+            return d
+        return self.Get(validator_flags, self.Pos + off)
+
+    def GetVectorAsNumpy(self, flags, off):
+        """
+        GetVectorAsNumpy returns the vector that starts at `Vector(off)`
+        as a numpy array with the type specified by `flags`. The array is
+        a `view` into Bytes, so modifying the returned array will
+        modify Bytes in place.
+        """
+        offset = self.Vector(off)
+        length = self.VectorLen(off)  # TODO: length accounts for bytewidth, right?
+        numpy_dtype = N.to_numpy_type(flags)
+        return encode.GetVectorAsNumpy(numpy_dtype, self.Bytes, length, offset)
+
+    def GetVOffsetTSlot(self, slot, d):
+        """
+        GetVOffsetTSlot retrieves the VOffsetT that the given vtable location
+        points to. If the vtable value is zero, the default value `d`
+        will be returned.
+        """
+
+        N.enforce_number(slot, N.VOffsetTFlags)
+        N.enforce_number(d, N.VOffsetTFlags)
+
+        off = self.Offset(slot)
+        if off == 0:
+            return d
+        return off

zlmdb/flatbuffers/util.py

@@ -0,0 +1,47 @@
+# Copyright 2017 Google Inc. All rights reserved.
+#
+# 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
+#
+#     http://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.
+
+from . import encode
+from . import number_types
+from . import packer
+
+
+def GetSizePrefix(buf, offset):
+    """Extract the size prefix from a buffer."""
+    return encode.Get(packer.int32, buf, offset)
+
+
+def GetBufferIdentifier(buf, offset, size_prefixed=False):
+    """Extract the file_identifier from a buffer"""
+    if size_prefixed:
+        # increase offset by size of UOffsetTFlags
+        offset += number_types.UOffsetTFlags.bytewidth
+    # increase offset by size of root table pointer
+    offset += number_types.UOffsetTFlags.bytewidth
+    # end of FILE_IDENTIFIER
+    end = offset + encode.FILE_IDENTIFIER_LENGTH
+    return buf[offset:end]
+
+
+def BufferHasIdentifier(buf, offset, file_identifier, size_prefixed=False):
+    got = GetBufferIdentifier(buf, offset, size_prefixed=size_prefixed)
+    return got == file_identifier
+
+
+def RemoveSizePrefix(buf, offset):
+    """
+    Create a slice of a size-prefixed buffer that has
+    its position advanced just past the size prefix.
+    """
+    return buf, offset + number_types.Int32Flags.bytewidth

zlmdb/tests/conftest.py

@@ -0,0 +1,9 @@
+# conftest.py - pytest configuration for zlmdb tests
+#
+# This file is loaded by pytest before any test collection happens.
+# It ensures txaio framework is selected before any zlmdb imports,
+# which is required because zlmdb uses txaio for logging internally.
+
+import txaio
+
+txaio.use_twisted()