@scrypted/server 0.0.135 → 0.0.140

package/.venv/lib/python3.9/site-packages/pgi/codegen/returnvalues.py

@@ -0,0 +1,443 @@
+# Copyright 2012,2013 Christoph Reiter
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+
+from pgi.clib.gir import GITypeTag, GIInfoType, GITransfer, GIArrayType
+from pgi.gtype import PGType
+from pgi.gerror import PGError
+from pgi.util import import_attribute
+from pgi import _compat
+
+
+class ReturnValue(object):
+
+    TAG = None
+    py_type = None
+
+    # if the return value can be ignored (None in the single case,
+    # no value in the case out args are present)
+    ignore = False
+
+    def __init__(self, info, type_, args, backend):
+        super(ReturnValue, self).__init__()
+        self.info = info
+        self.type = type_
+        self.backend = backend
+        self.args = args
+
+    @classmethod
+    def get_class(cls, type_):
+        return cls
+
+    @property
+    def may_return_null(self):
+        return self.info.may_return_null
+
+    def get_type(self):
+        return self.backend.get_type(self.type, self.may_return_null)
+
+    def setup(self):
+        pass
+
+    def get_param_type(self, index):
+        """Returns a ReturnValue instance for param type 'index'"""
+
+        assert index in (0, 1)
+
+        type_info = self.type.get_param_type(index)
+        type_cls = get_return_class(type_info)
+        instance = type_cls(None, type_info, [], self.backend)
+        instance.setup()
+        return instance
+
+    def pre_call(self):
+        pass
+
+    def post_call(self, name):
+        return None, None
+
+    def is_zero_terminated(self):
+        return self.type.is_zero_terminated
+
+    def transfer_nothing(self):
+        return self.info.caller_owns.value == GITransfer.NOTHING
+
+    def transfer_container(self):
+        return self.info.caller_owns.value == GITransfer.CONTAINER
+
+    def transfer_everything(self):
+        return self.info.caller_owns.value == GITransfer.EVERYTHING
+
+
+class VoidReturnValue(ReturnValue):
+    TAG = GITypeTag.VOID
+    py_type = object
+
+    def setup(self):
+        if not self.type.is_pointer:
+            self.ignore = True
+
+    def post_call(self, name):
+        # FIXME
+        if self.type.is_pointer:
+            return None, name
+        else:
+            return None, None
+
+
+class BaseArrayReturn(ReturnValue):
+    TAG = GITypeTag.ARRAY
+    py_type = list
+
+    def setup(self):
+        elm_type = self.get_param_type(0)
+        if isinstance(elm_type, UInt8ReturnValue):
+            self.py_type = "bytes"
+        else:
+            self.py_type = [elm_type.py_type]
+
+    @classmethod
+    def get_class(cls, type_):
+        value = type_.array_type.value
+
+        if value == GIArrayType.C:
+            return CArrayReturn
+        elif value == GIArrayType.PTR_ARRAY:
+            return PtrArrayReturn
+        elif value == GIArrayType.BYTE_ARRAY:
+            return ByteArrayReturn
+        elif value == GIArrayType.ARRAY:
+            return ArrayReturn
+
+        raise NotImplementedError(
+            "Unsupported array return type %r" % type_.array_type)
+
+
+class ArrayReturn(BaseArrayReturn):
+
+    def pre_call(self):
+        return None
+
+    def post_call(self, name):
+        return None, name
+
+
+class ByteArrayReturn(BaseArrayReturn):
+
+    def pre_call(self):
+        return None
+
+    def post_call(self, name):
+        return None, name
+
+
+class PtrArrayReturn(BaseArrayReturn):
+
+    def pre_call(self):
+        return None
+
+    def post_call(self, name):
+        return None, name
+
+
+class CArrayReturn(BaseArrayReturn):
+
+    def setup(self):
+        super(CArrayReturn, self).setup()
+
+        if self.type.array_length != -1:
+            aux = self.args[self.type.array_length]
+            aux.is_aux = True
+            self._aux = aux
+
+    def pre_call(self):
+        if self.type.array_length != -1:
+            var = self.backend.get_type(self._aux.type)
+            self._length_var = var.new()
+            self._aux.call_var = var.get_reference(self._length_var)
+            return var.block
+
+    def post_call(self, name):
+        var = self.get_type()
+        if self.type.array_length != -1:
+            out = var.unpack(name, self._length_var)
+        else:
+            out = var.unpack(name, None)
+        return var.block, out
+
+
+class BasicReturnValue(ReturnValue):
+
+    def post_call(self, name):
+        var = self.get_type()
+        out = var.unpack_return(name)
+        return var.block, out
+
+
+class BooleanReturnValue(BasicReturnValue):
+    TAG = GITypeTag.BOOLEAN
+    py_type = bool
+
+
+class UInt8ReturnValue(BasicReturnValue):
+    TAG = GITypeTag.UINT8
+    py_type = int
+
+
+class Int8ReturnValue(BasicReturnValue):
+    TAG = GITypeTag.INT8
+    py_type = int
+
+
+class Int16ReturnValue(BasicReturnValue):
+    TAG = GITypeTag.INT16
+    py_type = int
+
+
+class UInt16ReturnValue(BasicReturnValue):
+    TAG = GITypeTag.UINT16
+    py_type = int
+
+
+class Int32ReturnValue(BasicReturnValue):
+    TAG = GITypeTag.INT32
+    py_type = int
+
+
+class UInt32ReturnValue(BasicReturnValue):
+    TAG = GITypeTag.UINT32
+    py_type = int
+
+
+class Int64ReturnValue(BasicReturnValue):
+    TAG = GITypeTag.INT64
+    py_type = int
+
+
+class UInt64ReturnValue(BasicReturnValue):
+    TAG = GITypeTag.UINT64
+    py_type = int
+
+
+class DoubleReturnValue(BasicReturnValue):
+    TAG = GITypeTag.DOUBLE
+    py_type = float
+
+
+class FloatReturnValue(BasicReturnValue):
+    TAG = GITypeTag.FLOAT
+    py_type = float
+
+
+class Utf8ReturnValue(ReturnValue):
+    TAG = GITypeTag.UTF8
+    py_type = str
+
+    def post_call(self, name):
+        var = self.get_type()
+        out = var.unpack_return(name)
+        if self.transfer_everything():
+            var.free(name)
+        return var.block, out
+
+
+class UniCharReturnValue(BasicReturnValue):
+    TAG = GITypeTag.UNICHAR
+    py_type = _compat.text_type
+
+    def post_call(self, name):
+        var = self.get_type()
+        out = var.unpack_return(name)
+        return var.block, out
+
+
+class ErrorReturn(ReturnValue):
+    TAG = GITypeTag.ERROR
+    py_type = PGError
+
+    def post_call(self, name):
+        var = self.get_type()
+        out = var.unpack(name)
+        return var.block, out
+
+
+class GHashReturn(ReturnValue):
+    TAG = GITypeTag.GHASH
+    py_type = dict
+
+    def setup(self):
+        self.py_type = {
+            self.get_param_type(0).py_type: self.get_param_type(1).py_type}
+
+    def post_call(self, name):
+        var = self.get_type()
+        # FIXME
+        return var.block, name
+
+
+class GListReturn(ReturnValue):
+    TAG = GITypeTag.GLIST
+    py_type = list
+
+    def setup(self):
+        self.py_type = [self.get_param_type(0).py_type]
+
+    def post_call(self, name):
+        var = self.get_type()
+        out = var.unpack(name)
+        if self.transfer_container():
+            var.free(name)
+        elif self.transfer_everything():
+            #FIXME: leaking
+            var.free(name)
+
+        return var.block, out
+
+
+class GSListReturn(ReturnValue):
+    TAG = GITypeTag.GSLIST
+    py_type = list
+
+    def setup(self):
+        self.py_type = [self.get_param_type(0).py_type]
+
+    def post_call(self, name):
+        # FIXME
+        var = self.get_type()
+        return var.block, name
+
+
+class FilenameReturnValue(Utf8ReturnValue):
+    TAG = GITypeTag.FILENAME
+    py_type = str
+
+
+class BaseInterfaceReturn(ReturnValue):
+    TAG = GITypeTag.INTERFACE
+    py_type = object
+
+    def setup(self):
+        iface = self.type.get_interface()
+        try:
+            self.py_type = import_attribute(iface.namespace, iface.name)
+        except ImportError:
+            # fall back to object
+            pass
+
+    @classmethod
+    def get_class(cls, type_):
+        iface = type_.get_interface()
+        iface_type = iface.type.value
+
+        if iface_type == GIInfoType.ENUM:
+            return EnumReturn
+        elif iface_type == GIInfoType.OBJECT:
+            return ObjectReturn
+        elif iface_type == GIInfoType.INTERFACE:
+            return InterfaceReturn
+        elif iface_type == GIInfoType.STRUCT:
+            return StructReturn
+        elif iface_type == GIInfoType.UNION:
+            return UnionReturn
+        elif iface_type == GIInfoType.FLAGS:
+            return FlagsReturn
+
+        raise NotImplementedError(
+            "Unsuported interface return type %r" % iface.type)
+
+
+class EnumReturn(BaseInterfaceReturn):
+
+    def post_call(self, name):
+        var = self.get_type()
+        out = var.unpack_return(name)
+        return var.block, out
+
+
+class InterfaceReturn(BaseInterfaceReturn):
+
+    def post_call(self, name):
+        var = self.get_type()
+        out = var.unpack_return(name)
+        if self.transfer_nothing():
+            var.ref(out)
+        return var.block, out
+
+
+class ObjectReturn(BaseInterfaceReturn):
+
+    def post_call(self, name):
+        var = self.get_type()
+        out = var.unpack_return(name)
+        if self.transfer_nothing():
+            var.ref(out)
+        return var.block, out
+
+
+class StructReturn(BaseInterfaceReturn):
+
+    def post_call(self, name):
+        iface = self.type.get_interface()
+        iface_namespace = iface.namespace
+        iface_name = iface.name
+
+        var = self.get_type()
+        out = var.unpack_return(name)
+        if iface_namespace == "GObject" and iface_name == "Value":
+            out = var.unpack_gvalue(out)
+        if iface_namespace == "GLib" and iface_name == "Variant":
+            if self.transfer_nothing():
+                var.ref_sink_variant(out)
+        return var.block, out
+
+
+class UnionReturn(BaseInterfaceReturn):
+
+    def post_call(self, name):
+        var = self.get_type()
+        out = var.unpack_return(name)
+        return var.block, out
+
+
+class FlagsReturn(BaseInterfaceReturn):
+
+    def post_call(self, name):
+        var = self.get_type()
+        out = var.unpack_return(name)
+        return var.block, out
+
+
+class GTypeReturnValue(ReturnValue):
+    TAG = GITypeTag.GTYPE
+    py_type = PGType
+
+    def post_call(self, name):
+        var = self.get_type()
+        out = var.unpack_return(name)
+        return var.block, out
+
+
+_classes = {}
+
+
+def _find_return_values():
+    global _classes
+    cls = [a for a in globals().values() if isinstance(a, type)]
+    rv = ReturnValue
+    retv = [a for a in cls if issubclass(a, rv) and a is not rv]
+    _classes = dict(((a.TAG, a) for a in retv))
+_find_return_values()
+
+
+def get_return_class(type_):
+    global _classes
+    tag_value = type_.tag.value
+    try:
+        cls = _classes[tag_value]
+    except KeyError:
+        raise NotImplementedError("%r return not implemented" % type_.tag)
+    else:
+        return cls.get_class(type_)

package/.venv/lib/python3.9/site-packages/pgi/codegen/siggen.py

@@ -0,0 +1,157 @@
+# Copyright 2013 Christoph Reiter
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+
+from .backend import get_backend
+from .utils import CodeBlock
+from .cbargs import get_cbarg_class
+from .cbreturn import get_cbreturn_class
+from pgi.util import escape_identifier, escape_parameter
+
+
+def build_docstring(cb_name, args):
+    parts = []
+    for arg in args:
+        if arg.py_type is None:
+            parts.append(arg.name)
+        else:
+            parts.append("%s: %s" % (arg.name, arg.py_type.__name__))
+
+    return "%s(%s) -> None" % (cb_name, ", ".join(parts))
+
+
+def generate_callback_wrapper(info):
+    backend = get_backend("ctypes")()
+
+    args = list(info.get_args())
+    arg_types = [a.get_type() for a in args]
+
+    ret_type = info.get_return_type()
+    cls = get_cbreturn_class(ret_type)
+    return_value = cls(backend, info, ret_type)
+
+    cb_args = []
+    for arg, type_ in zip(args, arg_types):
+        cls = get_cbarg_class(type_)
+        excaped_name = escape_identifier(arg.name)
+        cb_arg = cls(backend, arg, type_, excaped_name)
+        cb_args.append(cb_arg)
+
+    for arg in cb_args:
+        arg.setup()
+
+    body = CodeBlock()
+
+    outs_vars = []
+    for arg in cb_args:
+        if arg.is_aux:
+            continue
+        block, out = arg.process()
+        if block:
+            block.write_into(body)
+        outs_vars.append(out)
+
+    arg_names = [a.name for a in cb_args]
+    backend.var.add_blacklist(arg_names)
+
+    argument_list = ", ".join(arg_names)
+    forward_arguments = ", ".join(outs_vars)
+    func_name = escape_parameter(info.name)
+    cb_name = backend.var()
+
+    return_var = backend.var()
+    return_block, out_var = return_value.process(return_var)
+    return_block = return_block or CodeBlock()
+
+    docstring = build_docstring(func_name, cb_args)
+
+    block, var = backend.parse("""
+def $cb_wrapper($args):
+    $body
+    # $docstring
+    $ret = $callback($out_args)
+    $post
+    return $out
+""", args=argument_list, out_args=forward_arguments, cb_wrapper=func_name,
+     callback=cb_name, body=body, docstring=docstring, ret=return_var,
+     out=out_var, post=return_block)
+
+    def create_cb_for_func(real_func):
+        if real_func is not None:
+            # binds the callback to the block and compiles it
+            func = block.compile(**{cb_name: real_func})[func_name]
+        else:
+            func = None
+        return backend.get_callback(func, cb_args, return_value)
+
+    return create_cb_for_func, docstring
+
+
+def _generate_signal_callback(backend, info, args, arg_types):
+    sig_args = []
+
+    ret_type = info.get_return_type()
+    cls = get_cbreturn_class(ret_type)
+    return_value = cls(backend, info, ret_type)
+
+    for arg, type_ in zip(args, arg_types):
+        cls = get_cbarg_class(type_)
+        excaped_name = escape_identifier(arg.name)
+        sig_arg = cls(backend, arg, type_, excaped_name)
+        sig_args.append(sig_arg)
+
+    for arg in sig_args:
+        arg.setup()
+
+    body = CodeBlock()
+
+    outs_vars = []
+    for arg in sig_args:
+        if arg.is_aux:
+            continue
+        block, out = arg.process()
+        if block:
+            block.write_into(body)
+        outs_vars.append(out)
+
+    argument_list = ", ".join([a.name for a in sig_args])
+    forward_arguments = ", ".join(outs_vars)
+    func_name = escape_parameter(info.name)
+    cb_name = backend.var()
+
+    return_var = backend.var()
+    return_block, out_var = return_value.process(return_var)
+    return_block = return_block or CodeBlock()
+
+    block, var = backend.parse("""
+def $cb_wrapper($dummy, $args):
+    $body
+    $ret = $callback($out_args)
+    $post
+    return $out
+""", args=argument_list, out_args=forward_arguments, cb_wrapper=func_name,
+     callback=cb_name, body=body, post=return_block, out=out_var,
+     ret=return_var)
+
+    def create_sig_for_func(real_func):
+        f = block.compile(**{cb_name: real_func})[func_name]
+        return backend.get_callback(f, sig_args, return_value, is_signal=True)
+
+    return create_sig_for_func
+
+
+def generate_signal_callback(info):
+    args = list(info.get_args())
+    arg_types = [a.get_type() for a in args]
+    backend = get_backend("ctypes")()
+
+    cb_func = None
+    try:
+        cb_func = _generate_signal_callback(backend, info, args, arg_types)
+    except NotImplementedError:
+        raise
+
+    return cb_func