@scrypted/server 0.0.138 → 0.0.139

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

@@ -0,0 +1,313 @@
+# 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 warnings import warn
+import ctypes
+
+from .clib import gobject
+from .clib.gobject import GValue, GValuePtr, G_TYPE_FROM_INSTANCE
+from .clib.gobject import GObjectClassPtr
+from .clib.gir import GIInfoType, GITypeTag
+
+from .util import escape_parameter, unescape_parameter, InfoIterWrapper
+from .util import import_attribute, set_gvalue_from_py
+from .gtype import PGType
+from ._compat import PY3
+
+
+PROPS_NAME = "props"
+
+
+class GParamSpec(object):
+    _spec = None
+    _info = None
+
+    def __init__(self, spec, name, info):
+        assert spec  # null ptr check
+
+        spec.ref()
+        self._spec = spec
+        self._info = info
+        self._name = name
+
+    @property
+    def name(self):
+        if PY3 and self._name is not None:
+            return self._name.decode("utf-8")
+        return self._name
+
+    @property
+    def __gtype__(self):
+        return G_TYPE_FROM_INSTANCE(self._spec.contents.g_type_instance)
+
+    @property
+    def flags(self):
+        return self._spec.contents.flags.value
+
+    @property
+    def nick(self):
+        return self._spec.nick
+
+    @property
+    def blurb(self):
+        return self._spec.blurb
+
+    @property
+    def owner_type(self):
+        return PGType(self._spec.contents.owner_type)
+
+    @property
+    def value_type(self):
+        return PGType(self._spec.contents.value_type)
+
+    @property
+    def default_value(self):
+        from pgi.repository import GObject
+        gvalue = GObject.Value()
+        gvalue.init(self.value_type)
+        self._spec.set_default(ctypes.cast(gvalue._obj, GValuePtr))
+        v = gvalue.get_value()
+        # XXX: add something to register gvalue marshallers for
+        # boxed types like GStrv
+        if v is None and GObject.TYPE_STRV == self.value_type:
+            return []
+        return v
+
+    def __repr__(self):
+        return "<%s %r>" % (self.__gtype__.name, self.name)
+
+
+class Property(object):
+    def __init__(self, spec):
+        self.__spec = spec
+        type_ = spec._info.get_type()
+        self.__tag = type_.tag.value
+
+        self.__interface = False
+        if self.__tag == GITypeTag.INTERFACE:
+            iface_info = type_.get_interface()
+            self.__tag = iface_info.type.value
+            name = iface_info.name
+            namespace = iface_info.namespace
+            self.__iclass = import_attribute(namespace, name)
+            self.__interface = True
+
+        self.__value_type = spec.value_type._type.value
+
+    def __get__(self, instance, owner):
+        ptr = GValuePtr(GValue())
+        ptr.init(self.__value_type)
+
+        tag = self.__tag
+
+        func = None
+        if not self.__interface:
+            if tag == GITypeTag.UTF8:
+                func = lambda: ptr.string
+            elif tag == GITypeTag.INT32:
+                func = lambda: ptr.int
+            elif tag == GITypeTag.BOOLEAN:
+                func = lambda: ptr.boolean
+            elif tag == GITypeTag.FLOAT:
+                func = lambda: ptr.float
+        else:
+            if tag == GIInfoType.ENUM:
+                func = lambda: self.__iclass(ptr.enum)
+            elif tag == GIInfoType.OBJECT:
+                def func():
+                    adr = ptr.get_object()
+                    if adr:
+                        new = object.__new__(self.__iclass)
+                        new._obj = ptr.get_object()
+                        return new
+                    else:
+                        return None
+
+        if func is None:
+            ptr.unset()
+            name = self.__spec.name
+            warn("Property %r unhandled. Type not supported" % name, Warning)
+            return None
+
+        if not instance._object:
+            ptr.unset()
+            raise TypeError("Object not initialized")
+
+        name = self.__spec.name
+        if PY3:
+            name = name.encode("ascii")
+
+        gobject.get_property(instance._object, name, ptr)
+        return func()
+
+    def __set__(self, instance, value):
+        ptr = GValuePtr(GValue())
+        ptr.init(self.__value_type)
+
+        tag = self.__tag
+
+        if not set_gvalue_from_py(ptr, self.__interface, tag, value):
+            ptr.unset()
+            name = self.__spec.name
+            warn("Property %r unhandled. Type not supported" % name, Warning)
+            return
+
+        name = self.__spec.name
+        if PY3:
+            name = name.encode("ascii")
+
+        gobject.set_property(instance._object, name, ptr)
+
+
+class _GProps(object):
+    def __init__(self, name, instance):
+        self.__name = name
+        self.__instance = instance
+
+    @property
+    def _object(self):
+        return self.__instance._obj
+
+    def __repr__(self):
+        text = (self.__instance and "instance ") or ""
+        return "<GProps of %s%r>" % (text, self.__name)
+
+
+class PropertyIterWrapper(InfoIterWrapper):
+    def _get_count(self, source):
+        return source.n_properties
+
+    def _get_info(self, source, index):
+        return source.get_property(index)
+
+    def _get_name(self, info):
+        return info.name
+
+
+class _ObjectClassProp(object):
+    def __init__(self, info, owner):
+        self._info = info
+        self._wrapper = PropertyIterWrapper(info)
+        self._owner = owner
+
+    def __get_base_props(self):
+        for base in self._owner.__mro__:
+            props = getattr(base, PROPS_NAME, None)
+            if not props or props is self:
+                continue
+            yield props
+
+    def __dir__(self):
+        names = [escape_parameter(n) for n in self._wrapper.iternames()]
+        for props in self.__get_base_props():
+            names.extend(
+                [escape_parameter(n) for n in props._wrapper.iternames()])
+
+        base = dir(self.__class__)
+        return list(set(base + names))
+
+    def __getattr__(self, name):
+        for props in self.__get_base_props():
+            try:
+                return getattr(props, name)
+            except AttributeError:
+                pass
+
+        info = self._info
+        gname = unescape_parameter(name)
+        prop_info = self._wrapper.lookup_name(gname)
+        if PY3:
+            gname = gname.encode("utf-8")
+        if prop_info:
+            gtype = info.g_type
+            if info.type.value == GIInfoType.OBJECT:
+                klass = gtype.class_ref()
+                klass = ctypes.cast(klass, GObjectClassPtr)
+                spec = klass.find_property(gname)
+                gtype.class_unref(klass)
+            else:
+                iface = gtype.default_interface_ref()
+                spec = iface.find_property(gname)
+                gtype.default_interface_unref(iface)
+            if not spec:  # FIXME: why can this be the case?
+                raise AttributeError
+            gspec = GParamSpec(spec, gname, prop_info)
+            setattr(self, name, gspec)
+            return gspec
+
+        raise AttributeError
+
+
+class _PropsDescriptor(object):
+    __cache = None
+    __cls_cache = None
+
+    def __init__(self, info):
+        self._info = info
+
+    def __get_gparam_spec(self, owner):
+        if not self.__cache:
+            cls_dict = dict(_ObjectClassProp.__dict__)
+            bases = (object,)
+            self.__cache = type("GProps", bases, cls_dict)(self._info, owner)
+        return self.__cache
+
+    def __get_gprops_class(self, specs):
+        if not self.__cls_cache:
+            cls = _GProps
+            cls_dict = dict(cls.__dict__)
+
+            for key in (p for p in dir(specs) if not p.startswith("_")):
+                spec = getattr(specs, key)
+                cls_dict[key] = Property(spec)
+
+            self.__cls_cache = type("GProps", cls.__bases__, cls_dict)
+        return self.__cls_cache
+
+    def __get__(self, instance, owner):
+        specs = self.__get_gparam_spec(owner)
+        if not instance:
+            return specs
+
+        gprops = self.__get_gprops_class(specs)
+        attr = gprops(self._info.name, instance)
+        setattr(instance, PROPS_NAME, attr)
+        return attr
+
+
+def list_properties(type):
+    """
+    :param type: a Python GObject instance or type that the signal is associated with
+    :type type: :obj:`GObject.Object`
+
+    :returns: a list of :obj:`GObject.ParamSpec`
+    :rtype: [:obj:`GObject.ParamSpec`]
+
+    Takes a GObject/GInterface subclass or a GType and returns a list of
+    GParamSpecs for all properties of `type`.
+    """
+
+    if isinstance(type, PGType):
+        type = type.pytype
+
+    from pgi.obj import Object, InterfaceBase
+
+    if not issubclass(type, (Object, InterfaceBase)):
+        raise TypeError("Must be a subclass of %s or %s" %
+                        (Object.__name__, InterfaceBase.__name__))
+
+    gparams = []
+    for key in dir(type.props):
+        if not key.startswith("_"):
+            gparams.append(getattr(type.props, key))
+    return gparams
+
+
+def PropertyAttribute(obj_info):
+    cls = _PropsDescriptor
+    cls_dict = dict(cls.__dict__)
+    return type(obj_info.name + "Props", cls.__bases__, cls_dict)(obj_info)

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

@@ -0,0 +1,12 @@
+# 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.
+
+
+class Property(object):
+
+    def __init__(self, *args, **kwargs):
+        raise NotImplementedError

package/.venv/lib/python3.9/site-packages/pgi/repository/__init__.py

@@ -0,0 +1,10 @@
+# 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 pgi.importer import install_import_hook
+
+install_import_hook()

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

@@ -0,0 +1,18 @@
+# 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.
+
+
+class Signal(object):
+
+    def __init__(self, *args, **kwargs):
+        raise NotImplementedError
+
+
+class SignalOverride(object):
+
+    def __init__(self, *args, **kwargs):
+        raise NotImplementedError

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

@@ -0,0 +1,122 @@
+# 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 ctypes import byref
+
+from .util import cached_property, escape_parameter, decode_return
+from .clib.glib import guint
+from .clib.gobject import signal_list_ids, signal_query, GSignalQuery
+from .codegen import generate_dummy_callable
+from .gtype import PGType
+
+
+class GSignal(object):
+    def __init__(self, info, signal_id):
+        self._id = signal_id
+        self._info = info
+
+    @property
+    def _func(self):
+        try:
+            sig_info = self._info.find_signal(self._query.signal_name)
+        except AttributeError:
+            # older libgirepository
+            sig_info = None
+
+        if sig_info:
+            func_name = sig_info.name.replace("-", "_")
+            return generate_dummy_callable(
+                sig_info, func_name, signal_owner_type=self.instance_type)
+        else:
+            # FIXME: either too old libgirepository or signal
+            # that is not in the typelib.
+            f = lambda: None
+            f.__doc__ = "%s()" % self.name.replace("-", "_")
+            return f
+
+    @property
+    def __doc__(self):
+        return self._func.__doc__
+
+    def __call__(self, *args, **kwargs):
+        assert self._func
+        return self._func(*args, **kwargs)
+
+    @cached_property
+    def _query(self):
+        query = GSignalQuery()
+        signal_query(self._id, byref(query))
+        return query
+
+    @property
+    def id(self):
+        return self._query.signal_id
+
+    @property
+    @decode_return()
+    def name(self):
+        return self._query.signal_name
+
+    @property
+    def instance_type(self):
+        return PGType(self._query.itype)
+
+    @property
+    def return_type(self):
+        return PGType(self._query.return_type)
+
+    @property
+    def flags(self):
+        return self._query.signal_flags.value
+
+    @property
+    def param_types(self):
+        count = int(self._query.n_params)
+        return [PGType(t) for t in self._query.param_types[:count]]
+
+
+class _GSignalQuery(object):
+    def __init__(self, info, pgtype):
+        # FIXME: DBusGLib.Proxy ?
+        if pgtype == PGType.from_name("void"):
+            return
+
+        gtype = pgtype._type
+        is_interface = pgtype.is_interface()
+
+        def get_sig_ids(gtype):
+            length = guint()
+            array = signal_list_ids(gtype, byref(length))
+            return array[:length.value]
+
+        if is_interface:
+            iface = gtype.default_interface_ref()
+            sig_ids = get_sig_ids(gtype)
+            gtype.default_interface_unref(iface)
+        else:
+            klass = gtype.class_ref()
+            sig_ids = get_sig_ids(gtype)
+            gtype.class_unref(klass)
+
+        for id_ in sig_ids:
+            sig = GSignal(info, id_)
+            setattr(self, escape_parameter(sig.name), sig)
+
+_GSignalQuery.__name__ = "GSignalQuery"
+
+
+class SignalsDescriptor(object):
+
+    def __init__(self, info):
+        self.info = info
+
+    def __get__(self, instance, owner):
+        return _GSignalQuery(self.info, owner.__gtype__)
+
+
+def SignalsAttribute(info):
+    return SignalsDescriptor(info)

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

@@ -0,0 +1,189 @@
+# Copyright 2012,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.
+
+import ctypes
+
+from .gtype import PGType as GType
+from .enum import GEnumBase as GEnum, EnumBase as Enum
+from .enum import GFlagsBase as GFlags, FlagsBase as Flags
+from .gerror import PGError as GError
+from .obj import InterfaceBase as GInterface
+from .properties import list_properties
+from . import version_info as pygobject_version
+
+
+def _init_glib(glib_module):
+    global OptionContext, OptionGroup, spawn_async
+
+    OptionContext = glib_module.OptionContext
+    OptionGroup = glib_module.OptionGroup
+    spawn_async = glib_module.spawn_async
+
+
+GType, GEnum, GFlags, GError, GInterface, list_properties, pygobject_version
+Flags, Enum
+
+GBoxed = None
+GObject = None
+GObjectWeakRef = None
+GParamSpec = None
+GPointer = None
+Warning = None
+TYPE_INVALID = None
+OptionContext = None
+OptionGroup = None
+spawn_async = None
+
+features = {'generic-c-marshaller': True}
+
+
+def _gvalue_set(self, boxed):
+    # XXX
+    return type(self).__mro__[1].set_boxed(self, boxed)
+
+
+def _gvalue_get(self):
+    # XXX
+    return type(self).__mro__[1].get_boxed(self)
+
+
+def type_register(class_):
+    """
+    :param class_: a Python class that is a descendant of :obj:`GObject.Object`
+
+    The GObject.type_register() function registers the specified Python class
+    as a GObject type. `class_` must be a descendant of GObject.Object.
+    The function generates a name for the new type.
+    """
+
+    raise NotImplementedError
+
+
+def new(gtype_or_similar, **kwargs):
+    """
+    :param type: a Python GObject type
+    :type type: :obj:`GObject.Object`
+
+    :param kwargs: set of property-value pairs
+
+    :returns: a new object of the specified `type`
+
+    The Gobject.new() function returns a new object of the specified type.
+    `type` must specify a type that is a descendant of gobject.GObject.
+    GObject properties can set via keyword arguments.
+    """
+
+    return GType(gtype_or_similar).pytype(**kwargs)
+
+
+def _min_value(ctypes_type):
+    signed = ctypes_type(-1).value == -1
+    if signed:
+        return - 2 ** (ctypes.sizeof(ctypes_type) * 8 - 1)
+    return 0
+
+
+def _max_value(ctypes_type):
+    signed = ctypes_type(-1).value == -1
+    return 2 ** (ctypes.sizeof(ctypes_type) * 8 - signed) - 1
+
+
+G_MINDOUBLE = 2.2250738585072014e-308
+G_MAXDOUBLE = 1.7976931348623157e+308
+G_MINFLOAT = 1.1754943508222875e-38
+G_MAXFLOAT = 3.4028234663852886e+38
+G_MINSHORT = _min_value(ctypes.c_short)
+G_MAXSHORT = _max_value(ctypes.c_short)
+G_MAXUSHORT = _max_value(ctypes.c_ushort)
+G_MININT = _min_value(ctypes.c_int)
+G_MAXINT = _max_value(ctypes.c_int)
+G_MAXUINT = _max_value(ctypes.c_uint)
+G_MINLONG = _min_value(ctypes.c_long)
+G_MAXLONG = _max_value(ctypes.c_long)
+G_MAXULONG = _max_value(ctypes.c_ulong)
+G_MAXSIZE = _max_value(ctypes.c_size_t)
+G_MINSSIZE = _min_value(ctypes.c_ssize_t)
+G_MAXSSIZE = _max_value(ctypes.c_ssize_t)
+G_MINOFFSET = _min_value(ctypes.c_int64)
+G_MAXOFFSET = _max_value(ctypes.c_int64)
+
+
+class Pid(object):
+
+    def __init__(*args, **kwargs):
+        raise NotImplementedError
+
+
+def add_emission_hook(type, name, callback, *user_data):
+    """
+    :param type: a Python GObject instance or type
+    :type type: :obj:`GObject.Object`
+
+    :param name: a signal name
+    :type name: :obj:`str`
+
+    :param callback: a function
+
+    :param user_data: zero or more extra arguments that will be passed to callback
+
+    The add_emission_hook() function adds an emission hook for the signal
+    specified by name, which will get called for any emission of that signal,
+    independent of the instance. This is possible only for signals which don't
+    have the :obj:`GObject.SignalFlags.NO_HOOKS` flag set.
+    """
+
+    raise NotImplementedError
+
+
+def signal_new(signal_name, type, flags, return_type, param_types):
+    """
+    :param signal_name: the name of the signal
+    :type signal_name: :obj:`str`
+
+    :param type: a Python GObject instance or type that the signal is associated with
+    :type type: :obj:`GObject.Object`
+
+    :param flags: the signal flags
+    :type flags: :obj:`GObject.SignalFlags`
+
+    :param return_type: the return type of the signal handler
+    :type return_type: :obj:`type`
+
+    :param param_types: the parameter types passed to the signal handler
+    :type param_types: [:obj:`type`]
+
+    :returns: a unique integer signal ID
+    :rtype: :obj:`int`
+
+    The :obj:`GObject.signal_new`\() function registers a signal with the
+    specified `signal_name` for the specified object `type`.
+
+    `return_type` is the type of the return value from a signal handler and may
+    be a gobject type, type ID or instance. The `param_types` parameter is a
+    list of additional types that are passed to the signal handler. Each
+    parameter type may be specified as a gobject type, type ID or instance.
+    For example, to add a signal to the :obj:`Gtk.Window` type called "my-signal"
+    that calls a handler with a :obj:`Gtk.Button` widget and an integer value and a
+    return value that is a boolean, use::
+
+          GObject.signal_new("my_signal", Gtk.Window, GObject.SignalFlags.RUN_LAST, GObject.TYPE_BOOLEAN, (Gtk.Button, GObject.TYPE_INT))
+
+    """
+
+    raise NotImplementedError
+
+
+def source_new(*args, **kwargs):
+    raise NotImplementedError
+
+
+def source_set_callback(*args, **kwargs):
+    raise NotImplementedError
+
+
+def io_channel_read(*args, **kwargs):
+    raise NotImplementedError