@scrypted/server 0.0.139 → 0.0.143

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

@@ -1,43 +0,0 @@
-# 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

@@ -1,41 +0,0 @@
-# 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

@@ -1,12 +0,0 @@
-# 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

@@ -1,58 +0,0 @@
-# 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

@@ -1,168 +0,0 @@
-# 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

@@ -1,189 +0,0 @@
-# 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

@@ -1,141 +0,0 @@
-# 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)