PyGObject 3.54.2__tar.gz → 3.54.5__tar.gz

{pygobject-3.54.2 → pygobject-3.54.5}/NEWS

@@ -1,3 +1,13 @@
+3.54.5 - 2025-10-18
+-------------------
+
+* Backport: GLib 2.86/GioUnix compatibility :mr:`461`
+
+3.54.3 - 2025-09-21
+-------------------
+
+* Do not skip symbols both in Gio and in platform specific :mr:`452`
+
 3.54.2 - 2025-09-13
 -------------------
 

{pygobject-3.54.2 → pygobject-3.54.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyGObject
-Version: 3.54.2
+Version: 3.54.5
 Summary: Python bindings for GObject Introspection
 Author-Email: James Henstridge <james@daa.com.au>
 Maintainer-Email: Christoph Reiter <creiter@src.gnome.org>, Arjan Molenaar <amolenaar@gnome.org>, Dan Yeaw <danyeaw@gnome.org>, Ignacio Casal Quinteiro <icq@gnome.org>

{pygobject-3.54.2 → pygobject-3.54.5}/gi/overrides/Gio.py

@@ -634,12 +634,7 @@ if GioPlatform:
     platform_name_lower = platform_name.lower()
 
     for attr in dir(GioPlatform):
-        if (
-            attr.startswith("_")
-            or attr in __all__
-            or attr in gio_globals
-            or hasattr(Gio, attr)
-        ):
+        if attr.startswith("_"):
             continue
 
         original_attr = getattr(GioPlatform, attr)
@@ -657,6 +652,27 @@ if GioPlatform:
             except AttributeError:
                 pass
 
+        if wrapper_attr == attr and hasattr(Gio, wrapper_attr):
+            try:
+                name = original_attr.__name__[0]
+            except (AttributeError, IndexError):
+                name = original_attr
+
+            # Fallback if we don't have the original name.
+            if name.islower():
+                wrapper_attr = f"{platform_name_lower}_{attr}"
+            elif "_" in name:
+                wrapper_attr = f"{platform_name.upper()}_{attr}"
+            elif name:
+                wrapper_attr = f"{platform_name}{attr}"
+
+        if (
+            wrapper_attr in __all__
+            or wrapper_attr in gio_globals
+            or hasattr(Gio, wrapper_attr)
+        ):
+            continue
+
         gio_globals[wrapper_attr] = original_attr
         deprecated_attr(
             Gio._namespace, wrapper_attr, f"{GioPlatform._namespace}.{attr}"

pygobject-3.54.5/gi/overrides/GioUnix.py

@@ -0,0 +1,170 @@
+# Copyright 2025 Simon McVittie
+# SPDX-License-Identifier: LGPL-2.1-or-later
+
+from ..module import get_introspection_module
+from ..overrides import override
+
+from gi.repository import GLib
+
+GioUnix = get_introspection_module("GioUnix")
+
+__all__ = []
+
+if (GLib.MAJOR_VERSION, GLib.MINOR_VERSION) < (2, 86):
+    # In older versions of GLib there was some confusion between the
+    # platform-specific classes in GioUnix and their equivalents in Gio,
+    # resulting in functions like g_desktop_app_info_get_action_name()
+    # being assumed to be a global function that happened to take a
+    # Gio.DesktopAppInfo first parameter, instead of being a method on a
+    # GioUnix.DesktopAppInfo instance. There are not very many classes and
+    # methods in GioUnix, so we can wrap them and provide the intended API.
+
+    @override
+    class DesktopAppInfo(GioUnix.DesktopAppInfo):
+        def get_action_name(self, action_name):
+            return GioUnix.DesktopAppInfo.get_action_name(self, action_name)
+
+        def get_boolean(self, key):
+            return GioUnix.DesktopAppInfo.get_boolean(self, key)
+
+        def get_categories(self):
+            return GioUnix.DesktopAppInfo.get_categories(self)
+
+        def get_filename(self):
+            return GioUnix.DesktopAppInfo.get_filename(self)
+
+        def get_generic_name(self):
+            return GioUnix.DesktopAppInfo.get_generic_name(self)
+
+        def get_is_hidden(self):
+            return GioUnix.DesktopAppInfo.get_is_hidden(self)
+
+        def get_keywords(self):
+            return GioUnix.DesktopAppInfo.get_keywords(self)
+
+        def get_locale_string(self, key):
+            return GioUnix.DesktopAppInfo.get_locale_string(self, key)
+
+        def get_nodisplay(self):
+            return GioUnix.DesktopAppInfo.get_nodisplay(self)
+
+        def get_show_in(self, desktop_env=None):
+            return GioUnix.DesktopAppInfo.get_show_in(self, desktop_env)
+
+        def get_startup_wm_class(self):
+            return GioUnix.DesktopAppInfo.get_startup_wm_class(self)
+
+        def get_string(self, key):
+            return GioUnix.DesktopAppInfo.get_string(self, key)
+
+        def get_string_list(self, key):
+            return GioUnix.DesktopAppInfo.get_string_list(self, key)
+
+        def has_key(self, key):
+            return GioUnix.DesktopAppInfo.has_key(self, key)
+
+        def launch_action(self, action_name, launch_context=None):
+            GioUnix.DesktopAppInfo.launch_action(
+                self,
+                action_name,
+                launch_context,
+            )
+
+        def launch_uris_as_manager(
+            self,
+            uris,
+            launch_context,
+            spawn_flags,
+            user_setup=None,
+            user_setup_data=None,
+            pid_callback=None,
+            pid_callback_data=None,
+        ):
+            return GioUnix.DesktopAppInfo.launch_uris_as_manager(
+                self,
+                uris,
+                launch_context,
+                spawn_flags,
+                user_setup,
+                user_setup_data,
+                pid_callback,
+                pid_callback_data,
+            )
+
+        def launch_uris_as_manager_with_fds(
+            self,
+            uris,
+            launch_context,
+            spawn_flags,
+            user_setup,
+            user_setup_data,
+            pid_callback,
+            pid_callback_data,
+            stdin_fd,
+            stdout_fd,
+            stderr_fd,
+        ):
+            return GioUnix.DesktopAppInfo.launch_uris_as_manager_with_fds(
+                self,
+                uris,
+                launch_context,
+                spawn_flags,
+                user_setup,
+                user_setup_data,
+                pid_callback,
+                pid_callback_data,
+                stdin_fd,
+                stdout_fd,
+                stderr_fd,
+            )
+
+        def list_actions(self):
+            return GioUnix.DesktopAppInfo.list_actions(self)
+
+    __all__.append("DesktopAppInfo")
+
+    @override
+    class FDMessage(GioUnix.FDMessage):
+        def append_fd(self, fd):
+            return GioUnix.FDMessage.append_fd(self, fd)
+
+        def get_fd_list(self):
+            return GioUnix.FDMessage.get_fd_list(self)
+
+        def steal_fds(self):
+            return GioUnix.FDMessage.steal_fds(self)
+
+    __all__.append("FDMessage")
+
+    @override
+    class InputStream(GioUnix.InputStream):
+        def get_close_fd(self):
+            return GioUnix.InputStream.get_close_fd(self)
+
+        def get_fd(self):
+            return GioUnix.InputStream.get_fd(self)
+
+        def set_close_fd(self, close_fd):
+            GioUnix.InputStream.set_close_fd(self, close_fd)
+
+    __all__.append("InputStream")
+
+    @override
+    class MountMonitor(GioUnix.MountMonitor):
+        def set_rate_limit(self, limit_msec):
+            GioUnix.MountMonitor.set_rate_limit(limit_msec)
+
+    __all__.append("MountMonitor")
+
+    @override
+    class OutputStream(GioUnix.OutputStream):
+        def get_close_fd(self):
+            return GioUnix.OutputStream.get_close_fd(self)
+
+        def get_fd(self):
+            return GioUnix.OutputStream.get_fd(self)
+
+        def set_close_fd(self, close_fd):
+            GioUnix.OutputStream.set_close_fd(self, close_fd)
+
+    __all__.append("OutputStream")

{pygobject-3.54.2 → pygobject-3.54.5}/gi/overrides/meson.build

@@ -5,6 +5,7 @@ python_sources = [
   'GdkPixbuf.py',
   'GObject.py',
   'Gio.py',
+  'GioUnix.py',
   'GIMarshallingTests.py',
   'Pango.py',
   '__init__.py']

{pygobject-3.54.2 → pygobject-3.54.5}/meson.build

@@ -1,7 +1,7 @@
 project(
   'pygobject',
   'c',
-  version : '3.54.2',
+  version : '3.54.5',
   meson_version : '>= 0.64.0',
   default_options : ['warning_level=1', 'buildtype=debugoptimized']
 )

{pygobject-3.54.2 → pygobject-3.54.5}/tests/test_gio.py

@@ -61,21 +61,26 @@ class TestGioPlatform(unittest.TestCase):
 Version=1.0
 Type=Application
 Name=Some Application
-Exec={GLib.find_program_in_path("sh")}
+Exec={GLib.find_program_in_path("true")} %u
+Actions=act;
+Categories=Development;Profiling;
+GenericName=Test
+Hidden=true
+Keywords=test;example;
+NoDisplay=true
+OnlyShowIn=GNOME;
+StartupWMClass=testTest
+X-Bool=true
+
+[Desktop Action act]
+Name=Take action!
+Exec={GLib.find_program_in_path("true")} action
 """
 
     def setUp(self):
         super().setUp()
 
-        required_glib = GLib.MAJOR_VERSION > 2 or (
-            GLib.MAJOR_VERSION == 2
-            and (
-                GLib.MINOR_VERSION > 85
-                or (GLib.MINOR_VERSION == 85 and GLib.MICRO_VERSION >= 5)
-            )
-        )
-
-        if not required_glib:
+        if (GLib.MAJOR_VERSION, GLib.MINOR_VERSION) < (2, 80):
             self.skipTest("Installed Gio is not new enough for this test")
 
         if GioUnix:
@@ -86,49 +91,146 @@ Exec={GLib.find_program_in_path("sh")}
                 GLib.KeyFileFlags.NONE,
             )
 
-    @unittest.skipIf(GioUnix is None, "Not supported")
+    def assert_expected_desktop_app_info(self, app_info):
+        # All functionality is available as ordinary methods, without
+        # needing extraneous arguments
+        # https://gitlab.gnome.org/GNOME/pygobject/-/issues/719
+        self.assertEqual(app_info.get_action_name("act"), "Take action!")
+        self.assertEqual(app_info.get_boolean("X-Bool"), True)
+        self.assertEqual(app_info.get_categories(), "Development;Profiling;")
+        self.assertIsNone(app_info.get_filename())
+        self.assertEqual(app_info.get_generic_name(), "Test")
+        self.assertEqual(app_info.get_is_hidden(), True)
+        self.assertEqual(app_info.get_keywords(), ["test", "example"])
+        self.assertEqual(app_info.get_locale_string("Keywords"), "test;example;")
+        self.assertEqual(app_info.get_nodisplay(), True)
+        self.assertEqual(app_info.get_show_in("GNOME"), True)
+        self.assertEqual(app_info.get_show_in("KDE"), False)
+        # get_show_in() can be called without an argument, which means NULL
+        self.assertIn(app_info.get_show_in(), [True, False])
+        self.assertIn(app_info.get_show_in(None), [True, False])
+        self.assertEqual(app_info.get_startup_wm_class(), "testTest")
+        self.assertEqual(app_info.get_string("StartupWMClass"), "testTest")
+        self.assertEqual(app_info.get_string_list("Keywords"), ["test", "example"])
+        self.assertEqual(app_info.has_key("Keywords"), True)
+        self.assertEqual(app_info.list_actions(), ["act"])
+
+        # All functionality is also available via unbound methods:
+        # for example Cinnamon relies on this as of October 2025
+        self.assertEqual(
+            GioUnix.DesktopAppInfo.get_action_name(app_info, "act"), "Take action!"
+        )
+        self.assertEqual(
+            Gio.DesktopAppInfo.get_action_name(app_info, "act"), "Take action!"
+        )
+
+        # Exercise methods that actually launch something
+        app_info.launch_action("act")
+        app_info.launch_action("act", None)
+        self.assertTrue(
+            app_info.launch_uris_as_manager(
+                ["about:blank"],
+                None,
+                GLib.SpawnFlags.DEFAULT,
+                None,
+                None,
+                None,
+                None,
+            ),
+        )
+        self.assertTrue(
+            app_info.launch_uris_as_manager(
+                ["about:blank"],
+                None,
+                GLib.SpawnFlags.DEFAULT,
+            ),
+        )
+        self.assertTrue(
+            app_info.launch_uris_as_manager_with_fds(
+                ["about:blank"],
+                None,
+                GLib.SpawnFlags.DEFAULT,
+                None,
+                None,
+                None,
+                None,
+                -1,
+                -1,
+                -1,
+            ),
+        )
+
+    @unittest.skipIf(
+        GioUnix is None or "DesktopAppInfo" not in dir(GioUnix), "Not supported"
+    )
     def test_desktop_app_info_can_be_created_from_gio_unix(self):
         app_info = GioUnix.DesktopAppInfo.new_from_keyfile(self.key_file)
         self.assertIsNotNone(app_info)
         self.assertIsInstance(app_info, GioUnix.DesktopAppInfo)
         self.assertIsInstance(app_info, Gio.AppInfo)
+        self.assert_expected_desktop_app_info(app_info)
 
-    @unittest.skipIf(GioUnix is None, "Not supported")
+    @unittest.skipIf(
+        GioUnix is None or "DesktopAppInfo" not in dir(GioUnix), "Not supported"
+    )
     def test_desktop_app_info_can_be_created_from_gio(self):
         with warnings.catch_warnings(record=True) as warn:
             warnings.simplefilter("always")
             app_info = Gio.DesktopAppInfo.new_from_keyfile(self.key_file)
 
-            self.assertEqual(len(warn), 1)
-            self.assertTrue(issubclass(warn[0].category, PyGIDeprecationWarning))
-            self.assertEqual(
-                str(warn[0].message),
-                "Gio.DesktopAppInfo is deprecated; "
-                + "use GioUnix.DesktopAppInfo instead",
-            )
+            if (GLib.MAJOR_VERSION, GLib.MINOR_VERSION) >= (2, 86):
+                self.assertEqual(len(warn), 1)
+                self.assertTrue(issubclass(warn[0].category, PyGIDeprecationWarning))
+                self.assertEqual(
+                    str(warn[0].message),
+                    "Gio.DesktopAppInfo is deprecated; "
+                    + "use GioUnix.DesktopAppInfo instead",
+                )
 
             self.assertIsNotNone(app_info)
             self.assertIsInstance(app_info, Gio.DesktopAppInfo)
             self.assertIsInstance(app_info, Gio.AppInfo)
 
-    @unittest.skipIf(GioUnix is None, "Not supported")
+    @unittest.skipIf(
+        GioUnix is None or "FDMessage" not in dir(GioUnix), "Not supported"
+    )
+    def test_fd_message(self):
+        message = GioUnix.FDMessage.new()
+        self.assertIsNotNone(message)
+
+        with open("/dev/null", "r+b") as devnull:
+            self.assertTrue(message.append_fd(devnull.fileno()))
+            self.assertIsNotNone(message.get_fd_list())
+            fds = message.steal_fds()
+            self.assertEqual(len(fds), 1)
+            os.close(fds[0])
+
+    @unittest.skipIf(
+        GioUnix is None or "DesktopAppInfo" not in dir(GioUnix), "Not supported"
+    )
     def test_gio_unix_desktop_app_info_provides_platform_independent_functions(self):
         app_info = GioUnix.DesktopAppInfo.new_from_keyfile(self.key_file)
         self.assertEqual(app_info.get_name(), "Some Application")
 
-    @unittest.skipIf(GioUnix is None, "Not supported")
+    @unittest.skipIf(
+        GioUnix is None or "DesktopAppInfo" not in dir(GioUnix), "Not supported"
+    )
     @ignore_gi_deprecation_warnings
     def test_gio_desktop_app_info_provides_platform_independent_functions(self):
         app_info = Gio.DesktopAppInfo.new_from_keyfile(self.key_file)
         self.assertEqual(app_info.get_name(), "Some Application")
 
-    @unittest.skipIf(GioUnix is None, "Not supported")
+    @unittest.skipIf(
+        GioUnix is None or "DesktopAppInfo" not in dir(GioUnix), "Not supported"
+    )
     def test_gio_unix_desktop_app_info_provides_unix_only_functions(self):
         app_info = GioUnix.DesktopAppInfo.new_from_keyfile(self.key_file)
         self.assertTrue(app_info.has_key("Name"))
         self.assertEqual(app_info.get_string("Name"), "Some Application")
 
-    @unittest.skipIf(GioUnix is None, "Not supported")
+    @unittest.skipIf(
+        GioUnix is None or "DesktopAppInfo" not in dir(GioUnix), "Not supported"
+    )
     @ignore_gi_deprecation_warnings
     def test_gio_desktop_app_info_provides_unix_only_functions(self):
         app_info = Gio.DesktopAppInfo.new_from_keyfile(self.key_file)
@@ -141,16 +243,53 @@ Exec={GLib.find_program_in_path("sh")}
             warnings.simplefilter("always")
             mount_points = Gio.unix_mount_points_get()
 
-            self.assertEqual(len(warn), 1)
-            self.assertTrue(issubclass(warn[0].category, PyGIDeprecationWarning))
-            self.assertEqual(
-                str(warn[0].message),
-                "Gio.unix_mount_points_get is deprecated; "
-                + "use GioUnix.mount_points_get instead",
-            )
+            if (GLib.MAJOR_VERSION, GLib.MINOR_VERSION) >= (2, 86):
+                self.assertEqual(len(warn), 1)
+                self.assertTrue(issubclass(warn[0].category, PyGIDeprecationWarning))
+                self.assertEqual(
+                    str(warn[0].message),
+                    "Gio.unix_mount_points_get is deprecated; "
+                    + "use GioUnix.mount_points_get instead",
+                )
 
             self.assertIsNotNone(mount_points)
-            self.assertEqual(GioUnix.mount_points_get, Gio.unix_mount_points_get)
+
+            if (GLib.MAJOR_VERSION, GLib.MINOR_VERSION) >= (2, 86):
+                self.assertEqual(GioUnix.mount_points_get, Gio.unix_mount_points_get)
+
+    def assert_expected_unix_stream_type(self, stream_type):
+        with open("/dev/null", "r+b") as devnull:
+            stream = stream_type.new(devnull.fileno(), False)
+            self.assertIsNotNone(stream)
+            self.assertEqual(stream.get_close_fd(), False)
+            stream.set_close_fd(False)
+            self.assertNotEqual(stream.get_fd(), -1)
+
+    @unittest.skipIf(GioUnix is None, "Not supported")
+    def test_deprecated_unix_type_can_be_used_if_equal_exists_in_gio(self):
+        with warnings.catch_warnings(record=True) as warn:
+            warnings.simplefilter("always")
+
+            input_stream = Gio.UnixInputStream
+
+            if (GLib.MAJOR_VERSION, GLib.MINOR_VERSION) >= (2, 86):
+                self.assertEqual(len(warn), 1)
+                self.assertTrue(issubclass(warn[0].category, PyGIDeprecationWarning))
+                self.assertEqual(
+                    str(warn[0].message),
+                    "Gio.UnixInputStream is deprecated; "
+                    + "use GioUnix.InputStream instead",
+                )
+
+            self.assertIsNotNone(input_stream)
+            self.assertEqual(Gio.UnixInputStream, GioUnix.InputStream)
+            self.assertNotEqual(Gio.InputStream, GioUnix.InputStream)
+
+            self.assert_expected_unix_stream_type(Gio.UnixInputStream)
+            self.assert_expected_unix_stream_type(GioUnix.InputStream)
+
+            self.assert_expected_unix_stream_type(Gio.UnixOutputStream)
+            self.assert_expected_unix_stream_type(GioUnix.OutputStream)
 
     @unittest.skipIf(GioUnix is None, "Not supported")
     def test_deprecated_unix_class_can_be_used_from_gio(self):
@@ -158,17 +297,41 @@ Exec={GLib.find_program_in_path("sh")}
             warnings.simplefilter("always")
             monitor = Gio.UnixMountMonitor.get()
 
-            self.assertEqual(len(warn), 1)
-            self.assertTrue(issubclass(warn[0].category, PyGIDeprecationWarning))
-            self.assertEqual(
-                str(warn[0].message),
-                "Gio.UnixMountMonitor is deprecated; "
-                + "use GioUnix.MountMonitor instead",
-            )
+            if (GLib.MAJOR_VERSION, GLib.MINOR_VERSION) >= (2, 86):
+                self.assertEqual(len(warn), 1)
+                self.assertTrue(issubclass(warn[0].category, PyGIDeprecationWarning))
+                self.assertEqual(
+                    str(warn[0].message),
+                    "Gio.UnixMountMonitor is deprecated; "
+                    + "use GioUnix.MountMonitor instead",
+                )
 
             self.assertIsNotNone(monitor)
             self.assertEqual(Gio.UnixMountMonitor.get, GioUnix.MountMonitor.get)
 
+    @unittest.skipIf(GioUnix is None, "Not supported")
+    def test_deprecated_unix_gobject_class_can_be_used_from_gio(self):
+        with warnings.catch_warnings(record=True) as warn:
+            warnings.simplefilter("always")
+
+            input_stream_class = Gio.UnixInputStreamClass
+
+            if (GLib.MAJOR_VERSION, GLib.MINOR_VERSION) >= (2, 86):
+                self.assertEqual(len(warn), 1)
+                self.assertTrue(issubclass(warn[0].category, PyGIDeprecationWarning))
+                self.assertEqual(
+                    str(warn[0].message),
+                    "Gio.UnixInputStreamClass is deprecated; "
+                    + "use GioUnix.InputStreamClass instead",
+                )
+
+            self.assertIsNotNone(input_stream_class)
+
+            if (GLib.MAJOR_VERSION, GLib.MINOR_VERSION) >= (2, 86):
+                self.assertEqual(Gio.UnixInputStreamClass, GioUnix.InputStreamClass)
+
+            self.assertNotEqual(Gio.InputStreamClass, GioUnix.InputStreamClass)
+
 
 class TestGSettings(unittest.TestCase):
     def setUp(self):