pycapnp 2.2.2__cp39-cp39-win_amd64.whl

capnp/__init__.py

@@ -0,0 +1,62 @@
+"""A python library wrapping the Cap'n Proto C++ library
+
+Example Usage::
+
+    import capnp
+
+    addressbook = capnp.load('addressbook.capnp')
+
+    # Building
+    addresses = addressbook.AddressBook.newMessage()
+    people = addresses.init('people', 1)
+
+    alice = people[0]
+    alice.id = 123
+    alice.name = 'Alice'
+    alice.email = 'alice@example.com'
+    alicePhone = alice.init('phones', 1)[0]
+    alicePhone.type = 'mobile'
+
+    f = open('example.bin', 'w')
+    addresses.write(f)
+    f.close()
+
+    # Reading
+    f = open('example.bin')
+
+    addresses = addressbook.AddressBook.read(f)
+
+    for person in addresses.people:
+        print(person.name, ':', person.email)
+        for phone in person.phones:
+            print(phone.type, ':', phone.number)
+"""
+
+# flake8: noqa F401 F403 F405
+from .version import version as __version__
+from .lib.capnp import *
+from .lib.capnp import (
+    _CapabilityClient,
+    _DynamicCapabilityClient,
+    _DynamicListBuilder,
+    _DynamicListReader,
+    _DynamicOrphan,
+    _DynamicResizableListBuilder,
+    _DynamicStructBuilder,
+    _DynamicStructReader,
+    _EventLoop,
+    _InterfaceModule,
+    _ListSchema,
+    _MallocMessageBuilder,
+    _PyCustomMessageBuilder,
+    _PackedFdMessageReader,
+    _StreamFdMessageReader,
+    _StructModule,
+    _write_message_to_fd,
+    _write_packed_message_to_fd,
+    _AsyncIoStream as AsyncIoStream,
+    _init_capnp_api,
+)
+
+_init_capnp_api()
+add_import_hook()  # enable import hook by default

capnp/_gen.py

@@ -0,0 +1,80 @@
+import os
+import sys
+
+from jinja2 import Environment, PackageLoader
+
+import capnp
+import schema_capnp
+
+
+def find_type(code, id):
+    for node in code["nodes"]:
+        if node["id"] == id:
+            return node
+
+    return None
+
+
+def main():
+    env = Environment(loader=PackageLoader("capnp", "templates"))
+    env.filters["format_name"] = lambda name: name[name.find(":") + 1 :]
+
+    code = schema_capnp.CodeGeneratorRequest.read(sys.stdin)
+    code = code.to_dict()
+    code["nodes"] = [
+        node for node in code["nodes"] if "struct" in node and node["scopeId"] != 0
+    ]
+    for node in code["nodes"]:
+        displayName = node["displayName"]
+        parent, path = displayName.split(":")
+        node["module_path"] = (
+            parent.replace(".", "_")
+            + "."
+            + ".".join([x[0].upper() + x[1:] for x in path.split(".")])
+        )
+        node["module_name"] = path.replace(".", "_")
+        node["c_module_path"] = "::".join(
+            [x[0].upper() + x[1:] for x in path.split(".")]
+        )
+        node["schema"] = "_{}_Schema".format(node["module_name"])
+        is_union = False
+        for field in node["struct"]["fields"]:
+            if field["discriminantValue"] != 65535:
+                is_union = True
+            field["c_name"] = field["name"][0].upper() + field["name"][1:]
+            if "slot" in field:
+                field["type"] = list(field["slot"]["type"].keys())[0]
+                if not isinstance(field["slot"]["type"][field["type"]], dict):
+                    continue
+                sub_type = field["slot"]["type"][field["type"]].get("typeId", None)
+                if sub_type:
+                    field["sub_type"] = find_type(code, sub_type)
+                sub_type = field["slot"]["type"][field["type"]].get("elementType", None)
+                if sub_type:
+                    field["sub_type"] = sub_type
+            else:
+                field["type"] = find_type(code, field["group"]["typeId"])
+        node["is_union"] = is_union
+
+    include_dir = os.path.abspath(os.path.join(os.path.dirname(capnp.__file__), ".."))
+    module = env.get_template("module.pyx")
+
+    for f in code["requestedFiles"]:
+        filename = f["filename"].replace(".", "_") + "_cython.pyx"
+
+        file_code = dict(code)
+        file_code["nodes"] = [
+            node
+            for node in file_code["nodes"]
+            if node["displayName"].startswith(f["filename"])
+        ]
+        with open(filename, "w") as out:
+            out.write(module.render(code=file_code, file=f, include_dir=include_dir))
+
+    setup = env.get_template("setup.py.tmpl")
+    with open("setup_capnp.py", "w") as out:
+        out.write(setup.render(code=code))
+    print(
+        "You now need to build the cython module by running `python setup_capnp.py build_ext --inplace`."
+    )
+    print()

capnp/c++.capnp

@@ -0,0 +1,48 @@
+# Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors
+# Licensed under the MIT License:
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+@0xbdf87d7bb8304e81;
+$namespace("capnp::annotations");
+
+annotation namespace(file): Text;
+annotation name(field, enumerant, struct, enum, interface, method, param, group, union): Text;
+
+annotation allowCancellation(interface, method, file) :Void;
+# Indicates that the server-side implementation of a method is allowed to be canceled when the
+# client requests cancellation. Without this annotation, once a method call has been delivered to
+# the server-side application code, any requests by the client to cancel it will be ignored, and
+# the method will run to completion anyway. This applies even for local in-process calls.
+#
+# This behavior applies specifically to implementations that inherit from the C++ `Foo::Server`
+# interface. The annotation won't affect DynamicCapability::Server implementations; they must set
+# the cancellation mode at runtime.
+#
+# When applied to an interface rather than an individual method, the annotation applies to all
+# methods in the interface. When applied to a file, it applies to all methods defined in the file.
+#
+# It's generally recommended that this annotation be applied to all methods. However, when doing
+# so, it is important that the server implementation use cancellation-safe code. See:
+#
+#     https://github.com/capnproto/capnproto/blob/master/kjdoc/tour.md#cancellation
+#
+# If your code is not cancellation-safe, then allowing cancellation might give a malicious client
+# an easy way to induce use-after-free or other bugs in your server, by requesting cancellation
+# when not expected.

capnp/helpers/capabilityHelper.h

@@ -0,0 +1,139 @@
+#pragma once
+
+#include "capnp/dynamic.h"
+#include <kj/async-io.h>
+#include <capnp/serialize-async.h>
+#include <stdexcept>
+#include "Python.h"
+
+class GILAcquire {
+public:
+  GILAcquire() : gstate(PyGILState_Ensure()) {}
+  ~GILAcquire() {
+    PyGILState_Release(gstate);
+  }
+
+  PyGILState_STATE gstate;
+};
+
+class GILRelease {
+public:
+  GILRelease() {
+    Py_UNBLOCK_THREADS
+  }
+  ~GILRelease() {
+    Py_BLOCK_THREADS
+  }
+
+  PyThreadState *_save; // The macros above read/write from this variable
+};
+
+class PyRefCounter {
+public:
+  PyObject * obj;
+
+  PyRefCounter(PyObject * o) : obj(o) {
+    GILAcquire gil;
+    Py_INCREF(obj);
+  }
+
+  PyRefCounter(const PyRefCounter & ref) : obj(ref.obj) {
+    GILAcquire gil;
+    Py_INCREF(obj);
+  }
+
+  ~PyRefCounter() {
+    GILAcquire gil;
+    Py_DECREF(obj);
+  }
+};
+
+inline kj::Own<PyRefCounter> stealPyRef(PyObject* o) {
+  auto ret = kj::heap<PyRefCounter>(o);
+  Py_DECREF(o);
+  return ret;
+}
+
+::kj::Promise<kj::Own<PyRefCounter>> convert_to_pypromise(capnp::RemotePromise<capnp::DynamicStruct> promise);
+
+inline ::kj::Promise<kj::Own<PyRefCounter>> convert_to_pypromise(kj::Promise<void> promise) {
+    return promise.then([]() {
+      GILAcquire gil;
+      return kj::heap<PyRefCounter>(Py_None);
+    });
+}
+
+void c_reraise_kj_exception();
+
+void check_py_error();
+
+::kj::Promise<kj::Own<PyRefCounter>> then(kj::Promise<kj::Own<PyRefCounter>> promise,
+                                          kj::Own<PyRefCounter> func, kj::Own<PyRefCounter> error_func);
+
+class PythonInterfaceDynamicImpl final: public capnp::DynamicCapability::Server {
+public:
+  kj::Own<PyRefCounter> py_server;
+  kj::Own<PyRefCounter> kj_loop;
+
+#if (CAPNP_VERSION_MAJOR < 1)
+  PythonInterfaceDynamicImpl(capnp::InterfaceSchema & schema,
+                             kj::Own<PyRefCounter> _py_server,
+                             kj::Own<PyRefCounter> kj_loop)
+    : capnp::DynamicCapability::Server(schema),
+      py_server(kj::mv(_py_server)), kj_loop(kj::mv(kj_loop)) { }
+#else
+  PythonInterfaceDynamicImpl(capnp::InterfaceSchema & schema,
+                             kj::Own<PyRefCounter> _py_server,
+                             kj::Own<PyRefCounter> kj_loop)
+    : capnp::DynamicCapability::Server(schema, { true }),
+      py_server(kj::mv(_py_server)), kj_loop(kj::mv(kj_loop)) { }
+#endif
+
+  ~PythonInterfaceDynamicImpl() {
+  }
+
+  kj::Promise<void> call(capnp::InterfaceSchema::Method method,
+                         capnp::CallContext< capnp::DynamicStruct, capnp::DynamicStruct> context);
+};
+
+inline void allowCancellation(capnp::CallContext<capnp::DynamicStruct, capnp::DynamicStruct> context) {
+#if (CAPNP_VERSION_MAJOR < 1)
+  context.allowCancellation();
+#endif
+}
+
+class PyAsyncIoStream: public kj::AsyncIoStream {
+public:
+  kj::Own<PyRefCounter> protocol;
+
+  PyAsyncIoStream(kj::Own<PyRefCounter> protocol) : protocol(kj::mv(protocol)) {}
+  ~PyAsyncIoStream();
+
+  kj::Promise<size_t> tryRead(void* buffer, size_t minBytes, size_t maxBytes);
+
+  kj::Promise<void> write(const void* buffer, size_t size);
+
+  kj::Promise<void> write(kj::ArrayPtr<const kj::ArrayPtr<const kj::byte>> pieces);
+
+  kj::Promise<void> whenWriteDisconnected();
+
+  void shutdownWrite();
+};
+
+template <typename T>
+inline void rejectDisconnected(kj::PromiseFulfiller<T>& fulfiller, kj::StringPtr message) {
+  fulfiller.reject(KJ_EXCEPTION(DISCONNECTED, message));
+}
+inline void rejectVoidDisconnected(kj::PromiseFulfiller<void>& fulfiller, kj::StringPtr message) {
+  fulfiller.reject(KJ_EXCEPTION(DISCONNECTED, message));
+}
+
+inline kj::Exception makeException(kj::StringPtr message) {
+  return KJ_EXCEPTION(FAILED, message);
+}
+
+kj::Promise<void> taskToPromise(kj::Own<PyRefCounter> coroutine, PyObject* callback);
+
+::kj::Promise<kj::Own<PyRefCounter>> tryReadMessage(kj::AsyncIoStream& stream, capnp::ReaderOptions opts);
+
+void init_capnp_api();

capnp/helpers/checkCompiler.h

@@ -0,0 +1,8 @@
+#ifdef _MSC_VER
+#pragma comment(lib, "Ws2_32.lib")
+#pragma comment(lib, "advapi32.lib")
+#endif
+
+#include "capnp/dynamic.h"
+
+static_assert(CAPNP_VERSION >= 8000, "Version of Cap'n Proto C++ Library is too old. Please upgrade to a version >= 0.8 and then re-install this python library");

capnp/helpers/deserialize.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "capnp/dynamic.h"
+#include "capnp/schema.capnp.h"
+
+/// @brief Convert the dynamic struct to a Node::Reader
+::capnp::schema::Node::Reader toReader(capnp::DynamicStruct::Reader reader)
+{
+    // requires an intermediate step to AnyStruct before going directly to Node::Reader,
+    // since there exists no direct conversion from DynamicStruct::Reader to Node::Reader.
+    return reader.as<capnp::AnyStruct>().as<capnp::schema::Node>();
+}

capnp/helpers/fixMaybe.h

@@ -0,0 +1,11 @@
+#include "kj/common.h"
+#include <stdexcept>
+
+template<typename T>
+T fixMaybe(::kj::Maybe<T> val) {
+  KJ_IF_MAYBE(new_val, val) {
+    return *new_val;
+  } else {
+    throw std::invalid_argument("Member was null.");
+  }
+}

capnp/helpers/helpers.pxd

@@ -0,0 +1,34 @@
+from capnp.includes.capnp_cpp cimport (
+    Maybe, PyPromise, VoidPromise, RemotePromise,
+    DynamicCapability, InterfaceSchema, EnumSchema, StructSchema, DynamicValue, Capability,
+    RpcSystem, MessageBuilder, Own, PyRefCounter, Node, DynamicStruct, CallContext
+)
+
+from capnp.includes.schema_cpp cimport ByteArray
+
+from non_circular cimport c_reraise_kj_exception as reraise_kj_exception
+
+from cpython.ref cimport PyObject
+
+cdef extern from "capnp/helpers/fixMaybe.h":
+    EnumSchema.Enumerant fixMaybe(Maybe[EnumSchema.Enumerant]) except +reraise_kj_exception
+    StructSchema.Field fixMaybe(Maybe[StructSchema.Field]) except +reraise_kj_exception
+
+cdef extern from "capnp/helpers/capabilityHelper.h":
+    PyPromise then(PyPromise promise, Own[PyRefCounter] func, Own[PyRefCounter] error_func)
+    PyPromise convert_to_pypromise(RemotePromise)
+    PyPromise convert_to_pypromise(VoidPromise)
+    VoidPromise taskToPromise(Own[PyRefCounter] coroutine, PyObject* callback)
+    void allowCancellation(CallContext context) except +reraise_kj_exception nogil
+    void init_capnp_api()
+
+cdef extern from "capnp/helpers/rpcHelper.h":
+    Own[Capability.Client] bootstrapHelper(RpcSystem&) except +reraise_kj_exception
+    Own[Capability.Client] bootstrapHelperServer(RpcSystem&) except +reraise_kj_exception
+
+cdef extern from "capnp/helpers/serialize.h":
+    ByteArray messageToPackedBytes(MessageBuilder &, size_t wordCount) except +reraise_kj_exception
+
+cdef extern from "capnp/helpers/deserialize.h":
+    Node.Reader toReader(DynamicStruct.Reader reader) except +reraise_kj_exception
+

capnp/helpers/non_circular.pxd

@@ -0,0 +1,8 @@
+from cpython.ref cimport PyObject
+from libcpp cimport bool
+
+cdef extern from "capnp/helpers/capabilityHelper.h":
+    void c_reraise_kj_exception()
+    cdef cppclass PyRefCounter:
+        PyRefCounter(PyObject *)
+        PyObject * obj

capnp/helpers/rpcHelper.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "capnp/dynamic.h"
+#include <capnp/rpc.capnp.h>
+#include "capnp/rpc-twoparty.h"
+#include "Python.h"
+#include "capabilityHelper.h"
+
+kj::Own<capnp::Capability::Client> bootstrapHelper(capnp::RpcSystem<capnp::rpc::twoparty::SturdyRefHostId>& client) {
+    capnp::MallocMessageBuilder hostIdMessage(8);
+    auto hostId = hostIdMessage.initRoot<capnp::rpc::twoparty::SturdyRefHostId>();
+    hostId.setSide(capnp::rpc::twoparty::Side::SERVER);
+    return kj::heap<capnp::Capability::Client>(client.bootstrap(hostId));
+}
+
+kj::Own<capnp::Capability::Client> bootstrapHelperServer(capnp::RpcSystem<capnp::rpc::twoparty::SturdyRefHostId>& client) {
+    capnp::MallocMessageBuilder hostIdMessage(8);
+    auto hostId = hostIdMessage.initRoot<capnp::rpc::twoparty::SturdyRefHostId>();
+    hostId.setSide(capnp::rpc::twoparty::Side::CLIENT);
+    return kj::heap<capnp::Capability::Client>(client.bootstrap(hostId));
+}

capnp/helpers/serialize.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "kj/io.h"
+#include "capnp/dynamic.h"
+#include "capnp/serialize-packed.h"
+
+kj::Array< ::capnp::byte> messageToPackedBytes(capnp::MessageBuilder & message, size_t wordCount)
+{
+
+    kj::Array<capnp::byte> result = kj::heapArray<capnp::byte>(wordCount * 8);
+    kj::ArrayOutputStream out(result.asPtr());
+    capnp::writePackedMessage(out, message);
+    return heapArray(out.getArray()); // TODO: make this non-copying somehow
+}

capnp/includes/PyCustomMessageBuilder.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "Python.h"
+#include <capnp/message.h>
+#include <capnp/serialize.h>
+#include <vector>
+
+namespace capnp {
+
+class PyCustomMessageBuilder : public capnp::MessageBuilder {
+public:
+  explicit PyCustomMessageBuilder(PyObject* allocateSegmentCallable,
+  uint firstSegmentWords = capnp::SUGGESTED_FIRST_SEGMENT_WORDS);
+
+  ~PyCustomMessageBuilder() noexcept(false) override;
+
+  kj::ArrayPtr<capnp::word> allocateSegment(capnp::uint minimumSize) override;
+
+private:
+  PyObject* allocateSegmentCallable;
+
+  uint firstSize;
+  uint curSize = 0;
+
+  std::vector<PyObject*> allocatedBuffers;
+};
+
+}