Esempio n. 1
0
 def test_require_version(self):
     self.assertTrue(require_version("Gtk", "3.0") is None)
     self.assertRaises(ValueError, require_version, "Gtk", "4.0")
     self.assertRaises(ValueError, require_version, "Gtk", "2.0")
     self.assertEqual(get_required_version("Gtk"), "3.0")
     self.assertTrue(get_required_version("...") is None)
     self.assertRaises(ValueError, require_version, "...", "3.0")
Esempio n. 2
0
 def test_require_version(self):
     self.assertTrue(require_version("Gtk", "3.0") is None)
     self.assertRaises(ValueError, require_version, "Gtk", "4.0")
     self.assertRaises(ValueError, require_version, "Gtk", "2.0")
     self.assertEqual(get_required_version("Gtk"), "3.0")
     self.assertTrue(get_required_version("...") is None)
     self.assertRaises(ValueError, require_version, "...", "3.0")
Esempio n. 3
0
    def _load(self):
        version = gi.get_required_version(self._namespace)
        self._introspection_module = IntrospectionModule(self._namespace,
                                                         version)

        overrides_modules = __import__('gi.overrides', fromlist=[self._namespace])
        self._overrides_module = getattr(overrides_modules, self._namespace, None)
        self.__path__ = repository.get_typelib_path(self._namespace)
    def _load(self):
        version = gi.get_required_version(self._namespace)
        self._introspection_module = IntrospectionModule(
            self._namespace, version)

        overrides_modules = __import__('gi.overrides',
                                       fromlist=[self._namespace])
        self._overrides_module = getattr(overrides_modules, self._namespace,
                                         None)
        self.__path__ = repository.get_typelib_path(self._namespace)
Esempio n. 5
0
    def _load(self):
        version = gi.get_required_version(self._namespace)
        self._introspection_module = IntrospectionModule(self._namespace,
                                                         version)

        overrides_modules = __import__('gi.overrides', fromlist=[self._namespace])
        self._overrides_module = getattr(overrides_modules, self._namespace, None)
        self.__path__ = repository.get_typelib_path(self._namespace)
        if _have_py3:
            # get_typelib_path() delivers bytes, not a string
            self.__path__ = self.__path__.decode('UTF-8')
Esempio n. 6
0
def get_introspection_module(namespace):
    """
    :Returns:
        An object directly wrapping the gi module without overrides.
    """
    if namespace in _introspection_modules:
        return _introspection_modules[namespace]

    version = gi.get_required_version(namespace)
    module = IntrospectionModule(namespace, version)
    _introspection_modules[namespace] = module
    return module
Esempio n. 7
0
def get_introspection_module(namespace):
    """
    :Returns:
        An object directly wrapping the gi module without overrides.
    """
    if namespace in _introspection_modules:
        return _introspection_modules[namespace]

    version = gi.get_required_version(namespace)
    module = IntrospectionModule(namespace, version)
    _introspection_modules[namespace] = module
    return module
Esempio n. 8
0
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()
    """

    global _active_imports, _implicit_required

    # This keeps track of the recursion level so we only check for
    # explicitly imported namespaces and not the ones imported in overrides
    _active_imports.append(namespace)

    try:
        yield
    except:
        raise
    else:
        # Keep track of all dependency versions forced due to this import, so
        # we don't warn for them in the future. This mirrors the import
        # behavior where importing will get an older version if a previous
        # import depended on it.
        for dependency in _get_all_dependencies(namespace):
            ns, version = dependency.split("-", 1)
            _implicit_required[ns] = version
    finally:
        _active_imports.remove(namespace)

    # Warn in case:
    #  * this namespace was explicitly imported
    #  * the version wasn't forced using require_version()
    #  * the version wasn't forced implicitly by a previous import
    #  * this namespace isn't part of glib (we have bigger problems if
    #    versions change there)
    is_explicit_import = not _active_imports
    version_required = gi.get_required_version(namespace) is not None
    version_implicit = namespace in _implicit_required
    is_in_glib = namespace in ("GLib", "GObject", "Gio")

    if is_explicit_import and not version_required and not version_implicit and not is_in_glib:
        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},
            ImportWarning,
            stacklevel=stacklevel,
        )
Esempio n. 9
0
    def _load(self):
        version = gi.get_required_version(self._namespace)
        self._introspection_module = IntrospectionModule(
            self._namespace, version)

        overrides_modules = __import__('gi.overrides',
                                       fromlist=[self._namespace])
        self._overrides_module = getattr(overrides_modules, self._namespace,
                                         None)
        self.__path__ = repository.get_typelib_path(self._namespace)
        if _have_py3:
            # get_typelib_path() delivers bytes, not a string
            self.__path__ = self.__path__.decode('UTF-8')
Esempio n. 10
0
def get_matplotlib_gtk_backend():
    import gi
    required = gi.get_required_version("Gtk")
    if required == "4.0":
        versions = [4]
    elif required == "3.0":
        versions = [3]
    elif os.environ.get("_GTK_API"):  # Private undocumented API.
        versions = [int(os.environ["_GTK_API"])]
    else:
        versions = [4, 3]
    for version in versions:
        # Matplotlib converts require_version ValueErrors into ImportErrors.
        try:
            mod = importlib.import_module(
                f"matplotlib.backends.backend_gtk{version}")
            return mod, getattr(mod, f"_BackendGTK{version}")
        except ImportError:
            pass
    raise ImportError("Failed to import any Matplotlib GTK backend")
Esempio n. 11
0
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()
    """

    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 gi.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)
Esempio n. 12
0
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()
    """

    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 gi.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,
    )