@scrypted/server 0.0.134 → 0.0.139

package/.venv/lib/python3.9/site-packages/pgi/cffilib/gir/giargument.py

@@ -0,0 +1,36 @@
+# Copyright 2015 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 ._ffi import ffi
+from ..glib import strdup
+from .._compat import PY3
+
+
+class GIArgument(object):
+
+    def __init__(self, **kwargs):
+        self._ptr = ffi.new("GIArgument*")
+        for key, value in kwargs.items():
+            # FIXME: leaks..
+            if key == "v_string":
+                if PY3:
+                    value = value.encode("utf-8")
+                value = strdup(value)
+            setattr(self._ptr, key, value)
+
+    def __getattr__(self, key):
+        res = getattr(self._ptr, key)
+        if key == "v_string":
+            if res:
+                res = ffi.string(res)
+                if PY3:
+                    res = res.decode("utf-8")
+                return res
+        else:
+            return res
+
+__all__ = ["GIArgument"]

package/.venv/lib/python3.9/site-packages/pgi/cffilib/gir/gibaseinfo.py

@@ -0,0 +1,113 @@
+# 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 .. import _create_enum_class
+
+from ._ffi import ffi, lib
+from .._utils import string_decode
+from .gitypelib import GITypelib
+
+
+GIInfoType = _create_enum_class(ffi, "GIInfoType", "GI_INFO_TYPE_")
+
+
+def _g_info_type_to_string(self):
+    res = lib.g_info_type_to_string(self)
+    return string_decode(ffi, res)
+
+GIInfoType.string = property(_g_info_type_to_string)
+
+
+class GIBaseInfo(object):
+    __types = {}
+
+    def __init__(self, ptr):
+        self._ptr = ptr
+
+        if ptr:
+            self._gc = ffi.gc(ptr, lib.g_base_info_unref)
+
+    @classmethod
+    def _register(cls, info_type):
+        def wrap(reg_cls):
+            cls.__types[info_type] = reg_cls
+            return reg_cls
+        return wrap
+
+    @classmethod
+    def _get_type(cls, ptr):
+        """Get the subtype class for a pointer"""
+
+        # fall back to the base class if unknown
+        return cls.__types.get(lib.g_base_info_get_type(ptr), cls)
+
+    def ref(self):
+        lib.g_base_info_ref(self._ptr)
+
+    def unref(self):
+        lib.g_base_info_unref(self._ptr)
+
+    @property
+    def type(self):
+        assert self._ptr, type(self)
+        return GIInfoType(lib.g_base_info_get_type(self._ptr))
+
+    @property
+    def name(self):
+        res = lib.g_base_info_get_name(self._ptr)
+        return string_decode(ffi, res)
+
+    @property
+    def namespace(self):
+        res = lib.g_base_info_get_namespace(self._ptr)
+        return string_decode(ffi, res)
+
+    @property
+    def is_deprecated(self):
+        return lib.g_base_info_is_deprecated(self._ptr)
+
+    def get_attribute(self, name):
+        res = lib.g_base_info_get_attribute(self._ptr, name)
+        if res:
+            return ffi.string(res)
+
+    def iterate_attributes(self):
+        it = ffi.new("GIAttributeIter*")
+        name = ffi.new("char**")
+        value = ffi.new("char**")
+        while lib.g_base_info_iterate_attributes(self._ptr, it, name, value):
+            yield (ffi.string(name[0]), ffi.string(value[0]))
+
+    def get_container(self):
+        res = lib.g_base_info_get_container(self._ptr)
+        if res:
+            type_ = self._get_type(res)
+            inst = type_(res)
+            inst.ref()
+            return inst
+
+    def get_typelib(self):
+        return GITypelib(lib.g_base_info_get_typelib(self._ptr))
+
+    def equal(self, other):
+        return bool(lib.g_base_info_equal(self._ptr, other._ptr))
+
+    def __eq__(self, other):
+        if not isinstance(other, GIBaseInfo):
+            return False
+        if not self and not other:
+            return True
+        elif not self or not other:
+            return False
+        return self.equal(other)
+
+    def __neq__(self, other):
+        return not self.equal(other)
+
+    def __repr__(self):
+        return "<%s namespace=%r name=%r>" % (
+            type(self).__name__, self.namespace, self.name)

package/.venv/lib/python3.9/site-packages/pgi/cffilib/gir/gicallableinfo.py

@@ -0,0 +1,75 @@
+# 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 .._compat import xrange
+from ._ffi import ffi, lib
+from .gibaseinfo import GIBaseInfo, GIInfoType
+from .gitypeinfo import GITypeInfo
+from .giarginfo import GITransfer, GIArgInfo
+
+
+class GICallableInfo(GIBaseInfo):
+
+    def get_return_type(self):
+        return GITypeInfo(lib.g_callable_info_get_return_type(self._ptr))
+
+    @property
+    def caller_owns(self):
+        return GITransfer(lib.g_callable_info_get_caller_owns(self._ptr))
+
+    @property
+    def can_throw_gerror(self):
+        return lib.g_callable_info_can_throw_gerror(self._ptr)
+
+    @property
+    def may_return_null(self):
+        return lib.g_callable_info_may_return_null(self._ptr)
+
+    def get_return_attribute(self, name):
+        res = lib.g_callable_info_get_return_attribute(self._ptr)
+        if res:
+            return ffi.string(res)
+
+    def iterate_return_attributes(self):
+        it = ffi.new("GIAttributeIter*")
+        name = ffi.new("char**")
+        value = ffi.new("char**")
+        while lib.g_callable_info_iterate_return_attributes(
+                self._ptr, it, name, value):
+            yield (ffi.string(name[0]), ffi.string(value[0]))
+
+    @property
+    def n_args(self):
+        return lib.g_callable_info_get_n_args(self._ptr)
+
+    def get_arg(self, n):
+        return GIArgInfo(lib.g_callable_info_get_arg(self._ptr, n))
+
+    def get_args(self):
+        for i in xrange(self.n_args):
+            yield self.get_arg(i)
+
+    def load_arg(self, n, args):
+        # warning: lifetime bound to this info
+        info = ffi.new("GIArgInfo*")
+        lib.g_callable_info_load_arg(self._ptr, info)
+        return GIArgInfo(info)
+
+    def load_return_type(self):
+        # warning: lifetime bound to this info
+        info = ffi.new("GITypeInfo*")
+        lib.g_callable_info_load_return_type(self._ptr, info)
+        return GITypeInfo(info)
+
+    @property
+    def skip_return(self):
+        return lib.g_callable_info_skip_return(self._ptr)
+
+
+@GIBaseInfo._register(GIInfoType.CALLBACK)
+class GICallbackInfo(GICallableInfo):
+    pass

package/.venv/lib/python3.9/site-packages/pgi/cffilib/gir/giconstantinfo.py

@@ -0,0 +1,22 @@
+# 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 ._ffi import ffi, lib
+from .gibaseinfo import GIBaseInfo, GIInfoType
+from .gitypeinfo import GITypeInfo
+
+
+@GIBaseInfo._register(GIInfoType.CONSTANT)
+class GIConstantInfo(GIBaseInfo):
+
+    def get_type(self):
+        return GITypeInfo(lib.g_constant_info_get_type(self._ptr))
+
+    def get_value(self):
+        arg = ffi.new("GIArgument*")
+        size = lib.g_constant_info_get_value(self._ptr, arg)
+        return (size, arg[0])

package/.venv/lib/python3.9/site-packages/pgi/cffilib/gir/gienuminfo.py

@@ -0,0 +1,59 @@
+# 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 .._compat import xrange
+from .._utils import string_decode
+from ._ffi import lib, ffi
+from .gibaseinfo import GIBaseInfo, GIInfoType
+from .gitypeinfo import GITypeTag
+from .giregisteredtypeinfo import GIRegisteredTypeInfo
+from .gifunctioninfo import GIFunctionInfo
+
+
+class GIValueInfo(GIBaseInfo):
+
+    @property
+    def value_(self):
+        return lib.g_value_info_get_value(self._ptr)
+
+
+@GIBaseInfo._register(GIInfoType.FLAGS)
+@GIBaseInfo._register(GIInfoType.ENUM)
+class GIEnumInfo(GIRegisteredTypeInfo):
+
+    @property
+    def n_values(self):
+        return lib.g_enum_info_get_n_values(self._ptr)
+
+    def get_value(self, n):
+        res = lib.g_enum_info_get_value(self._ptr, n)
+        if res:
+            return GIValueInfo(res)
+
+    def get_values(self):
+        for i in xrange(self.n_values):
+            yield self.get_value(i)
+
+    @property
+    def n_methods(self):
+        return lib.g_enum_info_get_n_methods(self._ptr)
+
+    def get_method(self, n):
+        return GIFunctionInfo(lib.g_enum_info_get_method(self._ptr, n))
+
+    def get_methods(self):
+        for i in xrange(self.n_methods):
+            yield self.get_method(i)
+
+    @property
+    def storage_type(self):
+        return GITypeTag(lib.g_enum_info_get_storage_type(self._ptr))
+
+    @property
+    def error_domain(self):
+        res = lib.g_enum_info_get_error_domain(self._ptr)
+        return string_decode(ffi, res)

package/.venv/lib/python3.9/site-packages/pgi/cffilib/gir/gifieldinfo.py

@@ -0,0 +1,40 @@
+# 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 .. import _create_enum_class
+from ._ffi import ffi, lib
+from .gibaseinfo import GIBaseInfo, GIInfoType
+from .gitypeinfo import GITypeInfo
+
+
+GIFieldInfoFlags = _create_enum_class(
+    ffi, "GIFieldInfoFlags", "GI_FIELD_", flags=True)
+
+
+@GIBaseInfo._register(GIInfoType.FIELD)
+class GIFieldInfo(GIBaseInfo):
+
+    @property
+    def flags(self):
+        return GIFieldInfoFlags(lib.g_field_info_get_flags(self._ptr))
+
+    @property
+    def size(self):
+        return lib.g_field_info_get_size(self._ptr)
+
+    @property
+    def offset(self):
+        return lib.g_field_info_get_offset(self._ptr)
+
+    def get_type(self):
+        return GITypeInfo(lib.g_field_info_get_type(self._ptr))
+
+    def get_field(self, mem, value):
+        return lib.g_field_info_get_field(self._ptr, mem, value)
+
+    def set_field(self, mem, value):
+        return lib.g_field_info_set_field(self._ptr, mem, value)

package/.venv/lib/python3.9/site-packages/pgi/cffilib/gir/gifunctioninfo.py

@@ -0,0 +1,64 @@
+# 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 .. import _create_enum_class, glib
+from .._utils import string_decode
+from ._ffi import ffi, lib
+from .gibaseinfo import GIBaseInfo, GIInfoType
+from .gicallableinfo import GICallableInfo
+from .gipropertyinfo import GIPropertyInfo
+
+
+GIFunctionInfoFlags = _create_enum_class(ffi, "GIFunctionInfoFlags",
+                                         "GI_FUNCTION_", flags=True)
+
+
+GInvokeError = _create_enum_class(ffi, "GInvokeError", "G_INVOKE_ERROR_")
+
+
+@GIBaseInfo._register(GIInfoType.FUNCTION)
+class GIFunctionInfo(GICallableInfo):
+
+    @property
+    def symbol(self):
+        res = lib.g_function_info_get_symbol(self._ptr)
+        return string_decode(ffi, res)
+
+    @property
+    def flags(self):
+        return GIFunctionInfoFlags(lib.g_function_info_get_flags(self._ptr))
+
+    def get_property(self):
+        res = lib.g_function_info_get_property(self._ptr)
+        if res:
+            return GIPropertyInfo(res)
+
+    def invoke(self, in_args, out_args, return_value):
+        if return_value is None:
+            return_value = ffi.NULL
+        else:
+            return_value = return_value._ptr
+
+        if in_args is None:
+            in_args = ffi.NULL
+            n_in_args = 0
+        else:
+            n_in_args = len(in_args)
+            in_args = ffi.new("GIArgument[]", [a._ptr[0] for a in in_args])
+
+        if out_args is None:
+            out_args = ffi.NULL
+            n_out_args = 0
+        else:
+            n_out_args = len(out_args)
+            out_args = ffi.new("GIArgument[]", [a._ptr[0] for a in out_args])
+
+        with glib.gerror() as error:
+            res = lib.g_function_info_invoke(
+                self._ptr, in_args, n_in_args, out_args, n_out_args,
+                return_value, error)
+        return bool(res)

package/.venv/lib/python3.9/site-packages/pgi/cffilib/gir/giinterfaceinfo.py

@@ -0,0 +1,93 @@
+# Copyright 2014 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 .._compat import xrange
+from ._ffi import lib
+from .giregisteredtypeinfo import GIRegisteredTypeInfo
+from .gibaseinfo import GIBaseInfo, GIInfoType
+from .gifunctioninfo import GIFunctionInfo
+from .gipropertyinfo import GIPropertyInfo
+from .gistructinfo import GIStructInfo
+from .gisignalinfo import GISignalInfo, GIVFuncInfo
+from .giconstantinfo import GIConstantInfo
+
+
+@GIBaseInfo._register(GIInfoType.INTERFACE)
+class GIInterfaceInfo(GIRegisteredTypeInfo):
+
+    @property
+    def n_methods(self):
+        return lib.g_interface_info_get_n_methods(self._ptr)
+
+    def get_method(self, n):
+        return GIFunctionInfo(lib.g_interface_info_get_method(self._ptr, n))
+
+    def get_methods(self):
+        for i in xrange(self.n_methods):
+            yield self.get_method(i)
+
+    @property
+    def n_vfuncs(self):
+        return lib.g_interface_info_get_n_vfuncs(self._ptr)
+
+    def get_vfunc(self, n):
+        return GIVFuncInfo(lib.g_interface_info_get_vfunc(self._ptr, n))
+
+    def get_vfuncs(self):
+        for i in xrange(self.n_vfuncs):
+            yield self.get_vfunc(i)
+
+    @property
+    def n_signals(self):
+        return lib.g_interface_info_get_n_signals(self._ptr)
+
+    def get_signal(self, n):
+        return GISignalInfo(lib.g_interface_info_get_signal(self._ptr, n))
+
+    def get_signals(self):
+        for i in xrange(self.n_signals):
+            yield self.get_signal(i)
+
+    @property
+    def n_constants(self):
+        return lib.g_interface_info_get_n_constants(self._ptr)
+
+    def get_constant(self, n):
+        return GIConstantInfo(lib.g_interface_info_get_constant(self._ptr, n))
+
+    def get_constants(self):
+        for i in xrange(self.n_constants):
+            yield self.get_constant(i)
+
+    @property
+    def n_properties(self):
+        return lib.g_interface_info_get_n_properties(self._ptr)
+
+    def get_property(self, n):
+        return GIPropertyInfo(lib.g_interface_info_get_property(self._ptr, n))
+
+    def get_properties(self):
+        for i in xrange(self.n_properties):
+            yield self.get_property(i)
+
+    @property
+    def n_prerequisites(self):
+        return lib.g_interface_info_get_n_prerequisites(self._ptr)
+
+    def get_prerequisite(self, n):
+        res = lib.g_interface_info_get_prerequisite(self._ptr, n)
+        type_ = GIBaseInfo._get_type(res)
+        return type_(res)
+
+    def get_prerequisites(self):
+        for i in xrange(self.n_prerequisites):
+            yield self.get_prerequisite(i)
+
+    def get_iface_struct(self):
+        res = lib.g_interface_info_get_iface_struct(self._ptr)
+        if res:
+            return GIStructInfo(res)

package/.venv/lib/python3.9/site-packages/pgi/cffilib/gir/giobjectinfo.py

@@ -0,0 +1,143 @@
+# 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 .._compat import xrange
+from .._utils import string_decode
+from ._ffi import ffi, lib
+from .giregisteredtypeinfo import GIRegisteredTypeInfo
+from .gibaseinfo import GIBaseInfo, GIInfoType
+from .gifunctioninfo import GIFunctionInfo
+from .gipropertyinfo import GIPropertyInfo
+from .gifieldinfo import GIFieldInfo
+from .giconstantinfo import GIConstantInfo
+from .gisignalinfo import GISignalInfo, GIVFuncInfo
+from .gistructinfo import GIStructInfo
+from .giinterfaceinfo import GIInterfaceInfo
+
+
+@GIBaseInfo._register(GIInfoType.OBJECT)
+class GIObjectInfo(GIRegisteredTypeInfo):
+
+    @property
+    def abstract(self):
+        return lib.g_object_info_get_abstract(self._ptr)
+
+    @property
+    def fundamental(self):
+        return lib.g_object_info_get_fundamental(self._ptr)
+
+    @property
+    def n_methods(self):
+        return lib.g_object_info_get_n_methods(self._ptr)
+
+    def get_method(self, n):
+        return GIFunctionInfo(lib.g_object_info_get_method(self._ptr, n))
+
+    def get_methods(self):
+        for i in xrange(self.n_methods):
+            yield self.get_method(i)
+
+    @property
+    def n_fields(self):
+        return lib.g_object_info_get_n_fields(self._ptr)
+
+    def get_field(self, n):
+        return GIFieldInfo(lib.g_object_info_get_field(self._ptr, n))
+
+    def get_fields(self):
+        for i in xrange(self.n_fields):
+            yield self.get_field(i)
+
+    @property
+    def n_constants(self):
+        return lib.g_object_info_get_n_constants(self._ptr)
+
+    def get_constant(self, n):
+        return GIConstantInfo(lib.g_object_info_get_constant(self._ptr, n))
+
+    def get_constants(self):
+        for i in xrange(self.n_constants):
+            yield self.get_constant(i)
+
+    @property
+    def n_vfuncs(self):
+        return lib.g_object_info_get_n_vfuncs(self._ptr)
+
+    def get_vfunc(self, n):
+        return GIVFuncInfo(lib.g_object_info_get_vfunc(self._ptr, n))
+
+    def get_vfuncs(self):
+        for i in xrange(self.n_vfuncs):
+            yield self.get_vfunc(i)
+
+    @property
+    def n_signals(self):
+        return lib.g_object_info_get_n_signals(self._ptr)
+
+    def get_signal(self, n):
+        return GISignalInfo(lib.g_object_info_get_signal(self._ptr, n))
+
+    def get_signals(self):
+        for i in xrange(self.n_signals):
+            yield self.get_signal(i)
+
+    @property
+    def n_interfaces(self):
+        return lib.g_object_info_get_n_interfaces(self._ptr)
+
+    def get_interface(self, n):
+        return GIInterfaceInfo(lib.g_object_info_get_interface(self._ptr, n))
+
+    def get_interfaces(self):
+        for i in xrange(self.n_interfaces):
+            yield self.get_interface(i)
+
+    @property
+    def n_properties(self):
+        return lib.g_object_info_get_n_properties(self._ptr)
+
+    def get_property(self, n):
+        return GIPropertyInfo(lib.g_object_info_get_property(self._ptr, n))
+
+    def get_properties(self):
+        for i in xrange(self.n_properties):
+            yield self.get_property(i)
+
+    @property
+    def type_name(self):
+        res = lib.g_object_info_get_type_name(self._ptr)
+        return string_decode(ffi, res)
+
+    @property
+    def type_init(self):
+        res = lib.g_object_info_get_type_init(self._ptr)
+        return string_decode(ffi, res)
+
+    @property
+    def ref_function(self):
+        res = lib.g_object_info_get_ref_function(self._ptr)
+        return string_decode(ffi, res)
+
+    @property
+    def unref_function(self):
+        res = lib.g_object_info_get_unref_function(self._ptr)
+        return string_decode(ffi, res)
+
+    @property
+    def set_value_function(self):
+        res = lib.g_object_info_get_set_value_function(self._ptr)
+        return string_decode(ffi, res)
+
+    @property
+    def get_value_function(self):
+        res = lib.g_object_info_get_get_value_function(self._ptr)
+        return string_decode(ffi, res)
+
+    def get_class_struct(self):
+        res = lib.g_object_info_get_class_struct(self._ptr)
+        if res:
+            return GIStructInfo(res)

package/.venv/lib/python3.9/site-packages/pgi/cffilib/gir/gipropertyinfo.py

@@ -0,0 +1,28 @@
+# 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 ._ffi import lib
+from ..gobject import GParamFlags
+from .gibaseinfo import GIBaseInfo, GIInfoType
+from .gitypeinfo import GITypeInfo
+from .giarginfo import GITransfer
+
+
+@GIBaseInfo._register(GIInfoType.PROPERTY)
+class GIPropertyInfo(GIBaseInfo):
+
+    @property
+    def flags(self):
+        return GParamFlags(lib.g_property_info_get_flags(self._ptr))
+
+    def get_type(self):
+        return GITypeInfo(lib.g_property_info_get_type(self._ptr))
+
+    @property
+    def ownership_transfer(self):
+        return GITransfer(
+            lib.g_property_info_get_ownership_transfer(self._ptr))