@scrypted/server 0.0.137 → 0.0.141

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

@@ -0,0 +1,43 @@
+# Copyright 2016 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 ForeignStruct(object):
+    """The foreign struct interface"""
+
+    _FOREIGN = {}
+
+    def from_pointer(self, pointer):
+        raise NotImplementedError
+
+    def to_pointer(self, instance):
+        raise NotImplementedError
+
+    def destroy(self, pointer):
+        raise NotImplementedError
+
+    def get_type(self):
+        raise NotImplementedError
+
+    @classmethod
+    def register(cls, namespace, name):
+        """Class decorator"""
+
+        def func(kind):
+            cls._FOREIGN[(namespace, name)] = kind()
+            return kind
+        return func
+
+    @classmethod
+    def get(cls, namespace, name):
+        """Raises KeyError"""
+
+        return cls._FOREIGN[(namespace, name)]
+
+
+class ForeignError(Exception):
+    pass

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

@@ -0,0 +1,41 @@
+# Copyright 2016 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 cffi
+import cairocffi
+
+from ._base import ForeignStruct
+
+
+ffi = cffi.FFI()
+
+@ForeignStruct.register("cairo", "Context")
+class Context(ForeignStruct):
+
+    def from_pointer(self, pointer):
+        pointer = ffi.cast("void*", pointer)
+        return cairocffi.Context._from_pointer(pointer, True)
+
+    def to_pointer(self, instance):
+        return int(ffi.cast("intptr_t", instance._pointer))
+
+    def get_type(self):
+        return cairocffi.Context
+
+
+@ForeignStruct.register("cairo", "Surface")
+class Surface(ForeignStruct):
+
+    def from_pointer(self, pointer):
+        pointer = ffi.cast("void*", pointer)
+        return cairocffi.Surface._from_pointer(pointer, True)
+
+    def to_pointer(self, instance):
+        return int(ffi.cast("intptr_t", instance._pointer))
+
+    def get_type(self):
+        return cairocffi.Surface

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

@@ -0,0 +1,12 @@
+# 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 .codegen import generate_function
+
+
+def FunctionAttribute(info):
+    return generate_function(info)

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

@@ -0,0 +1,58 @@
+# Copyright 2013,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 PY3
+from .util import cached_property
+
+
+class PGError(RuntimeError):
+
+    _error = None
+
+    @classmethod
+    def _from_gerror(cls, error, own=True):
+        """Creates a GError exception and takes ownership if own is True"""
+
+        if not own:
+            error = error.copy()
+
+        self = cls()
+        self._error = error
+        return self
+
+    @cached_property
+    def message(self):
+        if self._error:
+            message = self._error.contents.message
+            if PY3 and message is not None:
+                message = message.decode("utf-8")
+            return message
+
+    @cached_property
+    def domain(self):
+        if self._error:
+            return self._error.contents.domain.string
+
+    @cached_property
+    def code(self):
+        if self._error:
+            return self._error.contents.code
+
+    def __str__(self):
+        message = self.message
+        if message is None:
+            # base case without error set
+            return super(PGError, self).__str__()
+        return message
+
+    def __del__(self):
+        if self._error:
+            self._error.free()
+
+
+PGError.__module__ = "GLib"
+PGError.__name__ = "Error"

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

@@ -0,0 +1,168 @@
+# 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 byref
+
+from . import _compat
+from .clib.gir import GIRepository
+from .clib.gobject import GType, GTypeFlags, GTypeFundamentalFlags
+from .clib.glib import guint, free
+from .util import import_attribute, cached_property
+
+
+class PGType(object):
+
+    _PYTYPES = {}
+    _REGISTRY = {}
+
+    def __init__(self, type_):
+        if isinstance(type_, _compat.integer_types):
+            type_ = GType(type_)
+        elif isinstance(type_, type(self)):
+            type_ = type_._type
+        elif hasattr(type_, "__gtype__"):
+            type_ = type_.__gtype__._type
+        self._type = type_
+
+    def __get_gtype_list(self, function):
+        length = guint()
+        array = getattr(self._type, function)(byref(length))
+        # copy the gtypes and free the array so we don't leak
+        items = [PGType(GType(v.value)) for v in array[:length.value]]
+        free(array)
+        return items
+
+    @cached_property
+    def children(self):
+        return self.__get_gtype_list("children")
+
+    @cached_property
+    def interfaces(self):
+        return self.__get_gtype_list("interfaces")
+
+    @classmethod
+    def from_name(self, name):
+        if isinstance(name, _compat.text_type):
+            name = name.encode("ascii")
+        if not isinstance(name, bytes):
+            raise TypeError
+        type_ = GType.from_name(name)
+        if type_.value == 0:
+            # to match gi
+            raise RuntimeError("unknown type name")
+        return PGType(type_)
+
+    @cached_property
+    def fundamental(self):
+        return PGType(self._type.fundamental)
+
+    def has_value_table(self):
+        return bool(self._type.value_table_peek)
+
+    def is_a(self, type_):
+        return self._type.is_a(type_._type)
+
+    def is_abstract(self):
+        return self._type.test_flags(GTypeFlags.ABSTRACT)
+
+    def is_classed(self):
+        return self._type.test_flags(GTypeFundamentalFlags.CLASSED)
+
+    def is_deep_derivable(self):
+        return self._type.test_flags(GTypeFundamentalFlags.DEEP_DERIVABLE)
+
+    def is_derivable(self):
+        return self._type.test_flags(GTypeFundamentalFlags.DERIVABLE)
+
+    def is_instantiatable(self):
+        return self._type.test_flags(GTypeFundamentalFlags.INSTANTIATABLE)
+
+    def is_interface(self):
+        return self.fundamental._type.value == (2 << 2)
+
+    def is_value_abstract(self):
+        return self._type.test_flags(GTypeFlags.VALUE_ABSTRACT)
+
+    def is_value_type(self):
+        return self._type.check_is_value_type
+
+    @cached_property
+    def parent(self):
+        return PGType(self._type.parent)
+
+    @cached_property
+    def name(self):
+        return self._type.name or "invalid"
+
+    @cached_property
+    def depth(self):
+        return self._type.depth
+
+    @cached_property
+    def pytype(self):
+        type_ = self._type
+        if type_.value == 0:
+            return None
+
+        repo = GIRepository.get_default()
+        base_info = repo.find_by_gtype(type_)
+        if not base_info:
+            # look if it's a basic type
+            name = type_.name
+            if name in self._PYTYPES:
+                return self._PYTYPES[name]
+
+            if name in self._REGISTRY:
+                return self._REGISTRY[name]
+
+            from pgi.obj import new_class_from_gtype
+            cls = new_class_from_gtype(self)
+            self._REGISTRY[name] = cls
+            return cls
+        name = base_info.name
+        namespace = base_info.namespace
+
+        return import_attribute(namespace, name)
+
+    def __hash__(self):
+        return hash(self._type.value)
+
+    def __eq__(self, other):
+        try:
+            return self._type.value == other._type.value
+        except AttributeError:
+            return False
+
+    def __neq__(self, other):
+        return not self == other
+
+    def __cmp__(self, other):
+        try:
+            return cmp(self._type.value, other._type.value)
+        except AttributeError:
+            return 1
+
+    def __repr__(self):
+        return "<GType %s (%d)>" % (self.name, self._type.value)
+
+PGType.__name__ = "GType"
+PGType.__module__ = "GObject"
+
+PGType._PYTYPES = {
+    "gchararray": str,
+    "gboolean": bool,
+    "gint": int,
+    "guint": int,
+    "guint64": int,
+    "gfloat": float,
+    "gdouble": float,
+    "GStrv": [str],
+    "gpointer": int,  # ?
+    "gulong": int,
+    "gint64": int,
+    "GType": PGType,
+}

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

@@ -0,0 +1,189 @@
+# 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.
+
+"""Provides a custom PEP-302 import hook to load GI libraries"""
+
+import sys
+import warnings
+import importlib
+from contextlib import contextmanager
+
+from .clib.gir import GIRepository
+from . import const, overrides
+from .util import PyGIWarning
+from .module import get_introspection_module
+
+_versions = {}
+
+
+def require_version(namespace, version):
+    """Set a version for the namespace to be loaded.
+    This needs to be called before importing the namespace or any
+    namespace that depends on it.
+    """
+
+    global _versions
+
+    repo = GIRepository()
+    namespaces = repo.get_loaded_namespaces()
+
+    if namespace in namespaces:
+        loaded_version = repo.get_version(namespace)
+        if loaded_version != version:
+            raise ValueError('Namespace %s is already loaded with version %s' %
+                             (namespace, loaded_version))
+
+    if namespace in _versions and _versions[namespace] != version:
+        raise ValueError('Namespace %s already requires version %s' %
+                         (namespace, _versions[namespace]))
+
+    available_versions = repo.enumerate_versions(namespace)
+    if not available_versions:
+        raise ValueError('Namespace %s not available' % namespace)
+
+    if version not in available_versions:
+        raise ValueError('Namespace %s not available for version %s' %
+                         (namespace, version))
+
+    _versions[namespace] = version
+
+
+def get_required_version(namespace):
+    """Returns the version string for the namespace that was previously
+    required through 'require_version' or None
+    """
+
+    global _versions
+
+    return _versions.get(namespace, None)
+
+
+def extract_namespace(fullname):
+    for prefix in const.PREFIX:
+        if fullname.startswith(prefix):
+            namespace = fullname[len(prefix) + 1:]
+            if "." not in namespace:
+                return namespace
+
+
+def install_import_hook():
+    sys.meta_path.append(Importer())
+
+
+@contextmanager
+def _check_require_version(namespace, stacklevel):
+    """A context manager which tries to give helpful warnings
+    about missing gi.require_version() which could potentially
+    break code if only an older version than expected is installed
+    or a new version gets introduced.
+
+    ::
+
+        with _check_require_version("Gtk", stacklevel):
+            load_namespace_and_overrides()
+    """
+
+    repository = GIRepository()
+    was_loaded = repository.is_registered(namespace)
+
+    yield
+
+    if was_loaded:
+        # it was loaded before by another import which depended on this
+        # namespace or by C code like libpeas
+        return
+
+    if namespace in ("GLib", "GObject", "Gio"):
+        # part of glib (we have bigger problems if versions change there)
+        return
+
+    if get_required_version(namespace) is not None:
+        # the version was forced using require_version()
+        return
+
+    version = repository.get_version(namespace)
+    warnings.warn(
+        "%(namespace)s was imported without specifying a version first. "
+        "Use gi.require_version('%(namespace)s', '%(version)s') before "
+        "import to ensure that the right version gets loaded."
+        % {"namespace": namespace, "version": version},
+        PyGIWarning, stacklevel=stacklevel)
+
+
+def get_import_stacklevel(import_hook):
+    """Returns the stacklevel value for warnings.warn() for when the warning
+    gets emitted by an imported module, but the warning should point at the
+    code doing the import.
+
+    Pass import_hook=True if the warning gets generated by an import hook
+    (warn() gets called in load_module(), see PEP302)
+    """
+
+    py_version = sys.version_info[:2]
+    if py_version <= (3, 2):
+        # 2.7 included
+        return 4 if import_hook else 2
+    elif py_version == (3, 3):
+        return 8 if import_hook else 10
+    elif py_version == (3, 4):
+        return 10 if import_hook else 8
+    else:
+        # fixed again in 3.5+, see https://bugs.python.org/issue24305
+        return 4 if import_hook else 2
+
+
+class Importer(object):
+    """Import hook according to http://www.python.org/dev/peps/pep-0302/"""
+
+    def find_module(self, fullname, path=None):
+        namespace = extract_namespace(fullname)
+
+        if not namespace:
+            return
+
+        repository = GIRepository()
+
+        # is_registered() is faster than enumerate_versions() and
+        # in the common case of a namespace getting loaded before its
+        # dependencies, is_registered() returns True for all dependencies.
+        if repository.is_registered(namespace) or \
+                repository.enumerate_versions(namespace):
+            return self
+        else:
+            raise ImportError('cannot import name %s, '
+                              'introspection typelib not found' % namespace)
+
+    def load_module(self, fullname):
+        global _versions
+
+        # Dependency already loaded, skip
+        if fullname in sys.modules:
+            return sys.modules[fullname]
+
+        namespace = extract_namespace(fullname)
+        repository = GIRepository()
+
+        stacklevel = get_import_stacklevel(import_hook=True)
+        with _check_require_version(namespace, stacklevel=stacklevel):
+            introspection_module = get_introspection_module(namespace)
+
+            # Import all dependencies first so their init functions
+            # (gdk_init, ..) in overrides get called.
+            # https://bugzilla.gnome.org/show_bug.cgi?id=656314
+            for dep in repository.get_immediate_dependencies(namespace):
+                importlib.import_module(
+                    const.PREFIX[0] + '.' + dep.split("-")[0])
+
+            # Import a override module if available.
+            proxy = overrides.load_overrides(introspection_module)
+
+        proxy.__loader__ = self
+        for prefix in const.PREFIX:
+            module_key = prefix + "." + namespace
+            sys.modules[module_key] = proxy
+
+        return proxy

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

@@ -0,0 +1,141 @@
+# 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.
+
+import types
+
+from . import util, const
+from .clib.gir import GIRepository, GIError
+from .enum import EnumAttribute, FlagsAttribute
+from .constant import ConstantAttribute
+from .function import FunctionAttribute
+from .structure import StructureAttribute, UnionAttribute
+from .obj import ObjectAttribute, InterfaceAttribute
+from .callback import CallbackAttribute
+from .util import InfoIterWrapper, escape_identifier, unescape_identifier
+
+
+_introspection_modules = {}
+
+
+_attr_list = [None, FunctionAttribute, CallbackAttribute,
+              StructureAttribute, None,
+              EnumAttribute, FlagsAttribute, ObjectAttribute,
+              InterfaceAttribute, ConstantAttribute, None, UnionAttribute,
+              None, None, None, None, None, None, None, None]
+
+
+class RepositoryWrapper(InfoIterWrapper):
+
+    def __init__(self, namespace, *args, **kwargs):
+        super(RepositoryWrapper, self).__init__(*args, **kwargs)
+        self._namespace = namespace
+
+    def _get_count(self, source):
+        return source.get_n_infos(self._namespace)
+
+    def _get_info(self, source, index):
+        return source.get_info(self._namespace, index)
+
+    def _get_name(self, info):
+        return info.name
+
+    def _get_by_name(self, source, name):
+        return source.find_by_name(self._namespace, name)
+
+
+class _Module(types.ModuleType):
+    """Template class for gi modules (Gtk, ...)"""
+
+    __weakref__ = None
+
+    def __init__(self, namespace, wrapper):
+        types.ModuleType.__init__(self, namespace)
+        self._wrapper = wrapper
+
+    def __dir__(self):
+        # get all infos and
+        names = list(self._wrapper.iternames())
+        names.extend(self.__dict__.keys())
+        names = map(escape_identifier, names)
+
+        # filter out not implemented ones
+        implemented_names = []
+        for name in list(set(names)):
+            try:
+                getattr(self, name)
+            except NotImplementedError:
+                pass
+            else:
+                implemented_names.append(name)
+
+        return implemented_names
+
+    def __getattr__(self, name):
+        info = self._wrapper.lookup_name(name)
+        if not info:
+            info = self._wrapper.lookup_name(unescape_identifier(name))
+
+        if not info:
+            raise AttributeError("%r module has not attribute %r" %
+                                 (self.__class__.__name__, name))
+
+        cls = _attr_list[info.type.value]
+        if cls:
+            attr = cls(info)
+            setattr(self, name, attr)
+        else:
+            raise NotImplementedError(
+                "%r attribute type not supported" % info.type)
+
+        return attr
+
+    def __repr__(self):
+        return "<module '%s' from '%s'>" % (self.__name__, self.__path__)
+
+
+def get_introspection_module(namespace):
+    """Raises ImportError"""
+
+    if namespace in _introspection_modules:
+        return _introspection_modules[namespace]
+
+    from . import get_required_version
+
+    repository = GIRepository()
+    version = get_required_version(namespace)
+
+    try:
+        repository.require(namespace, version, 0)
+    except GIError as e:
+        raise ImportError(e.message)
+
+    # No strictly needed here, but most things will fail during use
+    library = repository.get_shared_library(namespace)
+    if library:
+        library = library.split(",")[0]
+        try:
+            util.load_ctypes_library(library)
+        except OSError:
+            raise ImportError(
+                "Couldn't load shared library %r" % library)
+
+    # Generate bindings, set up lazy attributes
+    instance = Module(repository, namespace)
+    instance.__path__ = repository.get_typelib_path(namespace)
+    instance.__package__ = const.PREFIX[0]
+    instance.__file__ = "<%s.%s>" % (const.PREFIX[0], namespace)
+    instance._version = version or repository.get_version(namespace)
+
+    _introspection_modules[namespace] = instance
+
+    return instance
+
+
+def Module(repo, namespace):
+    cls = type(namespace, _Module.__bases__, dict(_Module.__dict__))
+    wrapper = RepositoryWrapper(namespace, repo)
+    return cls(namespace, wrapper)