@scrypted/server 0.0.135 → 0.0.140

package/.venv/lib/python3.9/site-packages/pgi/clib/gir/giarginfo.py

@@ -0,0 +1,65 @@
+# Copyright 2012 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 ..glib import Enum, gboolean, gint
+from .gitypeinfo import GITypeInfo
+from .gibaseinfo import GIBaseInfo, GIInfoType
+from .._utils import find_library, wrap_class
+
+_gir = find_library("girepository-1.0")
+
+
+class GITransfer(Enum):
+    NOTHING, CONTAINER, EVERYTHING = range(3)
+
+
+class GIDirection(Enum):
+    IN, OUT, INOUT = range(3)
+
+
+class GIScopeType(Enum):
+    INVALID, CALL, ASYNC, NOTIFIED = range(4)
+
+
+@GIBaseInfo._register(GIInfoType.ARG)
+class GIArgInfo(GIBaseInfo):
+
+    def _get_repr(self):
+        values = super(GIArgInfo, self)._get_repr()
+        values["direction"] = repr(self.direction)
+        values["is_caller_allocates"] = repr(self.is_caller_allocates)
+        values["is_return_value"] = repr(self.is_return_value)
+        values["is_optional"] = repr(self.is_optional)
+        values["may_be_null"] = repr(self.may_be_null)
+        values["ownership_transfer"] = repr(self.ownership_transfer)
+        values["scope"] = repr(self.scope)
+        if self.closure != -1:
+            values["closure"] = repr(self.closure)
+        if self.destroy != -1:
+            values["destroy"] = repr(self.destroy)
+        values["arg_type"] = repr(self.get_type())
+
+        return values
+
+_methods = [
+    ("get_direction", GIDirection, [GIArgInfo]),
+    ("is_caller_allocates", gboolean, [GIArgInfo]),
+    ("is_return_value", gboolean, [GIArgInfo]),
+    ("is_optional", gboolean, [GIArgInfo]),
+    ("may_be_null", gboolean, [GIArgInfo]),
+    ("get_ownership_transfer", GITransfer, [GIArgInfo]),
+    ("get_scope", GIScopeType, [GIArgInfo]),
+    ("get_closure", gint, [GIArgInfo]),
+    ("get_destroy", gint, [GIArgInfo]),
+    ("get_type", GITypeInfo, [GIArgInfo], True),
+    ("load_type", None, [GIArgInfo, GITypeInfo]),
+    ("is_skip", gboolean, [GIArgInfo]),
+]
+
+wrap_class(_gir, GIArgInfo, GIArgInfo, "g_arg_info_", _methods)
+
+__all__ = ["GITransfer", "GIDirection", "GIScopeType", "GIArgInfo"]

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

@@ -0,0 +1,58 @@
+# Copyright 2012 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 ctypes import Union
+from ..glib import gboolean, gint8, guint8, gint16, guint16, gint32, guint32
+from ..glib import gint64, guint64, gfloat, gdouble, gshort, gushort, gint
+from ..glib import guint, glong, gulong, gsize, gchar_p, gpointer
+from .._compat import PY3
+
+
+class GIArgument(Union):
+    _fields_ = [
+        ("v_boolean", gboolean),
+        ("v_int8", gint8),
+        ("v_uint8", guint8),
+        ("v_int16", gint16),
+        ("v_uint16", guint16),
+        ("v_int32", gint32),
+        ("v_uint32", guint32),
+        ("v_int64", gint64),
+        ("v_uint64", guint64),
+        ("v_float", gfloat),
+        ("v_double", gdouble),
+        ("v_short", gshort),
+        ("v_ushort", gushort),
+        ("v_int", gint),
+        ("v_uint", guint),
+        ("v_long", glong),
+        ("v_ulong", gulong),
+        ("v_ssize", gsize),
+        ("v_string", gchar_p),
+        ("v_pointer", gpointer),
+    ]
+
+    if PY3:
+        assert _fields_[-2][0] == "v_string"
+        _fields_[-2] = ("_v_string", gchar_p)
+
+        @property
+        def v_string(self):
+            res = self._v_string
+            if res is not None:
+                res = res.decode("utf-8")
+            return res
+
+        @v_string.setter
+        def v_string(self, value):
+            if value is None:
+                self._v_string = None
+            else:
+                self._v_string = value.encode("utf-8")
+
+
+__all__ = ["GIArgument"]

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

@@ -0,0 +1,152 @@
+# Copyright 2012 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 ctypes import POINTER, c_char_p, cast, c_void_p, byref, Structure
+
+from ..glib import gchar_p, Enum, gboolean, gpointer
+from .._utils import wrap_class, find_library, _BaseFinalizer
+from .gitypelib import GITypelib
+
+_gir = find_library("girepository-1.0")
+
+
+class GIInfoType(Enum):
+    (INVALID, FUNCTION, CALLBACK, STRUCT, BOXED, ENUM, FLAGS, OBJECT,
+     INTERFACE, CONSTANT, INVALID_0, UNION, VALUE, SIGNAL, VFUNC, PROPERTY,
+     FIELD, ARG, TYPE, UNRESOLVED) = range(20)
+
+_methods = [
+    ("to_string", gchar_p, [GIInfoType]),
+]
+
+wrap_class(_gir, GIInfoType, GIInfoType, "g_info_type_", _methods)
+
+
+class GOptionGroup(Structure):
+    pass
+
+
+class GIAttributeIter(Structure):
+    _fields_ = [
+        ("data", gpointer),
+        ("data2", gpointer),
+        ("data3", gpointer),
+        ("data4", gpointer),
+    ]
+
+
+class _UnrefFinalizer(_BaseFinalizer):
+
+    def destructor(self, deadweakproxy, ptr):
+        ptr.unref()
+
+
+class GIBaseInfo(c_void_p):
+    __types = {}
+    __owns = False
+
+    @classmethod
+    def _register(cls, info_type):
+        """A class decorator to register sub types of GIBaseInfo"""
+
+        def wrap(reg_cls):
+            cls.__types[info_type] = reg_cls
+            return reg_cls
+        return wrap
+
+    def _take_ownership(self):
+        """Make the Python instance take ownership of the GIBaseInfo. i.e.
+        unref if the python instance gets gc'ed.
+        """
+
+        if self:
+            ptr = cast(self.value, GIBaseInfo)
+            _UnrefFinalizer.track(self, ptr)
+            self.__owns = True
+
+    @classmethod
+    def _cast(cls, base_info, take_ownership=True):
+        """Casts a GIBaseInfo instance to the right sub type.
+
+        The original GIBaseInfo can't have ownership.
+        Will take ownership.
+        """
+
+        type_value = base_info.type.value
+        try:
+            new_obj = cast(base_info, cls.__types[type_value])
+        except KeyError:
+            new_obj = base_info
+
+        if take_ownership:
+            assert not base_info.__owns
+            new_obj._take_ownership()
+
+        return new_obj
+
+    def _get_repr(self):
+        values = {}
+        values["info_type"] = repr(self.type)
+        real_type = cast(self, GIBaseInfo).type.value
+        if real_type != GIInfoType.TYPE and self.name:
+            values["name"] = repr(self.name)
+        values["namespace"] = repr(self.namespace)
+        values["deprecated"] = repr(self.is_deprecated)
+        container = self.get_container()
+        if container and container.type.value != GIInfoType.TYPE:
+            values["container"] = repr(container.name)
+
+        return values
+
+    def get_container(self):
+        res = self._get_container()
+        if res:
+            return self._cast(res, take_ownership=False)
+
+    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):
+        l = ", ".join(("%s=%s" % v for v in sorted(self._get_repr().items())))
+        return "<%s %s>" % (type(self).__name__, l)
+
+    def iterate_attributes(self):
+        name = c_char_p()
+        value = c_char_p()
+        it = GIAttributeIter()
+
+        while self._iterate_attributes(byref(it), byref(name), byref(value)):
+            yield (name.value, value.value)
+
+
+_methods = [
+    ("ref", GIBaseInfo, [GIBaseInfo], False),
+    ("unref", None, [GIBaseInfo]),
+    ("get_type", GIInfoType, [GIBaseInfo]),
+    ("get_name", gchar_p, [GIBaseInfo]),
+    ("get_namespace", gchar_p, [GIBaseInfo]),
+    ("is_deprecated", gboolean, [GIBaseInfo]),
+    ("get_attribute", gchar_p, [GIBaseInfo, gchar_p]),
+    ("_iterate_attributes", gboolean, [GIBaseInfo, POINTER(GIAttributeIter),
+                                       POINTER(c_char_p), POINTER(c_char_p)]),
+    ("_get_container", GIBaseInfo, [GIBaseInfo]),
+    ("get_typelib", GITypelib, [GIBaseInfo]),
+    ("equal", gboolean, [GIBaseInfo, GIBaseInfo]),
+]
+
+wrap_class(_gir, None, GIBaseInfo, "g_base_info_", _methods)
+
+__all__ = ["GIInfoType", "GIBaseInfo", "GIAttributeIter"]

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

@@ -0,0 +1,203 @@
+# Copyright 2012 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 ctypes import c_char_p, POINTER, c_int, byref
+
+from ..glib import gint, Enum, gboolean, gchar_p, GError, Flags, gerror
+from ..gobject import GSignalFlags
+from .gibaseinfo import GIBaseInfo, GIAttributeIter, GIInfoType
+from .gitypeinfo import GITypeInfo
+from .giarginfo import GITransfer, GIArgInfo
+from .gipropertyinfo import GIPropertyInfo
+from .giargument import GIArgument
+from .error import GIError
+from .._utils import find_library, wrap_class
+from .._compat import xrange
+
+_gir = find_library("girepository-1.0")
+
+
+class GICallableInfo(GIBaseInfo):
+
+    def get_args(self):
+        for i in xrange(self.n_args):
+            yield self.get_arg(i)
+
+    def iterate_return_attributes(self):
+        name = c_char_p()
+        value = c_char_p()
+        it = GIAttributeIter()
+
+        while self._iterate_return_attributes(byref(it), byref(name),
+                                              byref(value)):
+            yield (name.value, value.value)
+
+    def _get_repr(self):
+        values = super(GICallableInfo, self)._get_repr()
+
+        # FIXME
+        #values["return_type"] = repr(self.get_return_type())
+        values["caller_owns"] = repr(self.caller_owns)
+        values["may_return_null"] = repr(self.may_return_null)
+        values["n_args"] = repr(self.n_args)
+        return values
+
+
+@GIBaseInfo._register(GIInfoType.CALLBACK)
+class GICallbackInfo(GICallableInfo):
+    pass
+
+
+class GIFunctionInfoFlags(Flags):
+    IS_METHOD = 1 << 0
+    IS_CONSTRUCTOR = 1 << 1
+    IS_GETTER = 1 << 2
+    IS_SETTER = 1 << 3
+    WRAPS_VFUNC = 1 << 4
+    THROWS = 1 << 5
+
+
+class GInvokeError(Enum):
+    FAILED, SYMBOL_NOT_FOUND, ARGUMENT_MISMATCH = range(3)
+
+
+@GIBaseInfo._register(GIInfoType.FUNCTION)
+class GIFunctionInfo(GICallableInfo):
+
+    def invoke(self, in_args, out_args, return_value):
+        if in_args:
+            n_in_args = len(in_args)
+            in_type = n_in_args * GIArgument
+            in_args = in_type(*in_args)
+        else:
+            n_in_args = 0
+            in_args = None
+
+        if out_args:
+            n_out_args = len(out_args)
+            out_type = n_out_args * GIArgument
+            out_args = out_type(*out_args)
+        else:
+            n_out_args = 0
+            out_args = None
+
+        if return_value is not None:
+            retval = byref(return_value)
+        else:
+            retval = None
+
+        with gerror(GIError) as error:
+            res = self._invoke(
+                in_args, n_in_args, out_args, n_out_args,
+                retval, error)
+
+        return bool(res)
+
+    def _get_repr(self):
+        values = super(GIFunctionInfo, self)._get_repr()
+
+        values["symbol"] = repr(self.symbol)
+        values["flags"] = repr(self.flags)
+        if self.flags.value & (GIFunctionInfoFlags.IS_GETTER |
+                               GIFunctionInfoFlags.IS_SETTER):
+            values["property"] = repr(self.get_property())
+        elif self.flags.value & GIFunctionInfoFlags.WRAPS_VFUNC:
+            values["vfunc"] = repr(self.get_vfunc())
+
+        return values
+
+
+class GIVFuncInfoFlags(Enum):
+    MUST_CHAIN_UP = 1 << 0
+    MUST_OVERRIDE = 1 << 1
+    MUST_NOT_OVERRIDE = 1 << 2
+    THROWS = 1 << 3
+
+
+@GIBaseInfo._register(GIInfoType.VFUNC)
+class GIVFuncInfo(GICallableInfo):
+
+    def _get_repr(self):
+        values = super(GIVFuncInfo, self)._get_repr()
+        values["flags"] = repr(self.flags)
+        values["offset"] = repr(self.offset)
+        signal = self.get_signal()
+        if signal:
+            values["signal"] = repr(signal)
+        invoker = self.get_invoker()
+        if invoker:
+            values["invoker"] = repr(invoker)
+        return values
+
+
+@GIBaseInfo._register(GIInfoType.SIGNAL)
+class GISignalInfo(GICallableInfo):
+
+    def _get_repr(self):
+        values = super(GISignalInfo, self)._get_repr()
+        values["flags"] = repr(self.flags)
+        closure = self.get_class_closure()
+        if closure:
+            values["class_closure"] = repr(closure)
+        values["true_stops_emit"] = repr(self.true_stops_emit)
+        return values
+
+
+_methods = [
+    ("get_return_type", GITypeInfo, [GICallableInfo], True),
+    ("get_caller_owns", GITransfer, [GICallableInfo]),
+    ("may_return_null", gboolean, [GICallableInfo]),
+    ("get_return_attribute", gchar_p, [GICallableInfo, gchar_p]),
+    ("_iterate_return_attributes", gint,
+     [GICallableInfo,
+      POINTER(GIAttributeIter), POINTER(c_char_p), POINTER(c_char_p)]),
+    ("get_n_args", gint, [GICallableInfo]),
+    ("get_arg", GIArgInfo, [GICallableInfo, gint], True),
+    ("load_arg", None, [GICallableInfo, gint, GIArgInfo]),
+    ("load_return_type", None, [GICallableInfo, GITypeInfo]),
+    ("can_throw_gerror", gboolean, [GICallableInfo]),
+    ("is_method", gboolean, [GICallableInfo]),
+    ("skip_return", gboolean, [GICallableInfo]),
+]
+
+wrap_class(_gir, GICallableInfo, GICallableInfo,
+           "g_callable_info_", _methods)
+
+_methods = [
+    ("get_symbol", gchar_p, [GIFunctionInfo]),
+    ("get_flags", GIFunctionInfoFlags, [GIFunctionInfo]),
+    ("get_property", GIPropertyInfo, [GIFunctionInfo], True),
+    ("get_vfunc", GIVFuncInfo, [GIFunctionInfo], True),
+    ("_invoke", gboolean, [GIFunctionInfo, POINTER(GIArgument), c_int,
+                          POINTER(GIArgument), c_int, POINTER(GIArgument),
+                          POINTER(POINTER(GError))]),
+]
+
+wrap_class(_gir, GIFunctionInfo, GIFunctionInfo,
+           "g_function_info_", _methods)
+
+_methods = [
+    ("get_flags", GIVFuncInfoFlags, [GIVFuncInfo]),
+    ("get_offset", gint, [GIVFuncInfo]),
+    ("get_signal", GISignalInfo, [GIVFuncInfo], True),
+    ("get_invoker", GIFunctionInfo, [GIVFuncInfo], True),
+]
+
+wrap_class(_gir, GIVFuncInfo, GIVFuncInfo, "g_vfunc_info_", _methods)
+
+_methods = [
+    ("get_flags", GSignalFlags, [GISignalInfo]),
+    ("get_class_closure", GIVFuncInfo, [GISignalInfo], True),
+    ("true_stops_emit", gboolean, [GISignalInfo]),
+]
+
+wrap_class(_gir, GISignalInfo, GISignalInfo, "g_signal_info_", _methods)
+
+
+__all__ = ["GICallableInfo", "GIFunctionInfoFlags", "GInvokeError",
+           "GIFunctionInfo", "GIVFuncInfoFlags", "GIVFuncInfo",
+           "GISignalInfo"]

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

@@ -0,0 +1,35 @@
+# Copyright 2012 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 ctypes import POINTER
+
+from ..glib import gint
+from .gibaseinfo import GIBaseInfo, GIInfoType
+from .gitypeinfo import GITypeInfo
+from .giargument import GIArgument
+from .._utils import find_library, wrap_class
+
+_gir = find_library("girepository-1.0")
+
+
+@GIBaseInfo._register(GIInfoType.CONSTANT)
+class GIConstantInfo(GIBaseInfo):
+
+    def _get_repr(self):
+        values = super(GIConstantInfo, self)._get_repr()
+        values["type"] = repr(self.get_type())
+        return values
+
+_methods = [
+    ("get_type", GITypeInfo, [GIConstantInfo], True),
+    ("get_value", gint, [GIConstantInfo, POINTER(GIArgument)]),
+]
+
+wrap_class(_gir, GIConstantInfo, GIConstantInfo,
+           "g_constant_info_", _methods)
+
+__all__ = ["GIConstantInfo"]

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

@@ -0,0 +1,64 @@
+# Copyright 2012 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 ..glib import gint64, gint, gchar_p
+from .gibaseinfo import GIBaseInfo, GIInfoType
+from .gicallableinfo import GIFunctionInfo
+from .gitypeinfo import GITypeTag
+from .giregisteredtypeinfo import GIRegisteredTypeInfo
+from .._utils import find_library, wrap_class
+
+_gir = find_library("girepository-1.0")
+
+
+@GIBaseInfo._register(GIInfoType.VALUE)
+class GIValueInfo(GIBaseInfo):
+
+    def _get_repr(self):
+        values = super(GIValueInfo, self)._get_repr()
+        values["value"] = repr(self.value_)
+        return values
+
+_methods = [
+    ("get_value", gint64, [GIValueInfo]),
+]
+
+wrap_class(_gir, GIValueInfo, GIValueInfo, "g_value_info_", _methods)
+
+
+@GIBaseInfo._register(GIInfoType.FLAGS)
+@GIBaseInfo._register(GIInfoType.ENUM)
+class GIEnumInfo(GIRegisteredTypeInfo):
+
+    def get_values(self):
+        for i in xrange(self.n_values):
+            yield self.get_value(i)
+
+    def get_methods(self):
+        for i in xrange(self.n_methods):
+            yield self.get_method(i)
+
+    def _get_repr(self):
+        values = super(GIEnumInfo, self)._get_repr()
+        values["n_values"] = repr(self.n_values)
+        values["n_methods"] = repr(self.n_methods)
+        values["storage_type"] = repr(self.storage_type)
+        return values
+
+_methods = [
+    ("get_n_values", gint, [GIEnumInfo]),
+    ("get_value", GIValueInfo, [GIEnumInfo, gint], True),
+    ("get_n_methods", gint, [GIEnumInfo]),
+    ("get_method", GIFunctionInfo, [GIEnumInfo], True),
+    ("get_storage_type", GITypeTag, [GIEnumInfo]),
+    ("get_error_domain", gchar_p, [GIEnumInfo]),
+]
+
+wrap_class(_gir, GIEnumInfo, GIEnumInfo, "g_enum_info_", _methods)
+
+__all__ = ["GIEnumInfo", "GIValueInfo"]

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

@@ -0,0 +1,46 @@
+# Copyright 2012 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 ctypes import POINTER
+
+from ..glib import Flags, gint, gboolean, gpointer
+from .gibaseinfo import GIBaseInfo, GIInfoType
+from .gitypeinfo import GITypeInfo
+from .giargument import GIArgument
+from .._utils import find_library, wrap_class
+
+_gir = find_library("girepository-1.0")
+
+
+class GIFieldInfoFlags(Flags):
+    IS_READABLE = 1 << 0
+    IS_WRITABLE = 1 << 1
+
+
+@GIBaseInfo._register(GIInfoType.FIELD)
+class GIFieldInfo(GIBaseInfo):
+
+    def _get_repr(self):
+        values = super(GIFieldInfo, self)._get_repr()
+        values["flags"] = repr(self.flags)
+        values["size"] = repr(self.size)
+        values["offset"] = repr(self.offset)
+        values["type"] = repr(self.get_type())
+        return values
+
+_methods = [
+    ("get_flags", GIFieldInfoFlags, [GIFieldInfo]),
+    ("get_size", gint, [GIFieldInfo]),
+    ("get_offset", gint, [GIFieldInfo]),
+    ("get_type", GITypeInfo, [GIFieldInfo], True),
+    ("get_field", gboolean, [GIFieldInfo, gpointer, POINTER(GIArgument)]),
+    ("set_field", gboolean, [GIFieldInfo, gpointer, POINTER(GIArgument)]),
+]
+
+wrap_class(_gir, GIFieldInfo, GIFieldInfo, "g_field_info_", _methods)
+
+__all__ = ["GIFieldInfo", "GIFieldInfoFlags"]