Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package python-Pebble for openSUSE:Factory checked in at 2023-12-28 23:02:01 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/python-Pebble (Old) and /work/SRC/openSUSE:Factory/.python-Pebble.new.28375 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-Pebble" Thu Dec 28 23:02:01 2023 rev:15 rq:1135314 version:5.0.6 Changes: -------- --- /work/SRC/openSUSE:Factory/python-Pebble/python-Pebble.changes 2023-12-11 21:50:49.884150320 +0100 +++ /work/SRC/openSUSE:Factory/.python-Pebble.new.28375/python-Pebble.changes 2023-12-28 23:03:41.071313043 +0100 @@ -1,0 +2,6 @@ +Wed Dec 27 13:52:06 UTC 2023 - Dirk Müller <[email protected]> + +- update to 5.0.6: + * issue #124: handle `BaseException` in pools' workers + +------------------------------------------------------------------- Old: ---- Pebble-5.0.5.tar.gz New: ---- Pebble-5.0.6.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ python-Pebble.spec ++++++ --- /var/tmp/diff_new_pack.7rQ8bB/_old 2023-12-28 23:03:42.383360995 +0100 +++ /var/tmp/diff_new_pack.7rQ8bB/_new 2023-12-28 23:03:42.399361581 +0100 @@ -17,7 +17,7 @@ Name: python-Pebble -Version: 5.0.5 +Version: 5.0.6 Release: 0 Summary: Threading and multiprocessing eye-candy for Python License: LGPL-3.0-only ++++++ Pebble-5.0.5.tar.gz -> Pebble-5.0.6.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Pebble-5.0.5/PKG-INFO new/Pebble-5.0.6/PKG-INFO --- old/Pebble-5.0.5/PKG-INFO 2023-12-06 17:51:09.814489800 +0100 +++ new/Pebble-5.0.6/PKG-INFO 2023-12-25 17:22:05.110159200 +0100 @@ -1,6 +1,6 @@ Metadata-Version: 2.1 Name: Pebble -Version: 5.0.5 +Version: 5.0.6 Summary: Threading and multiprocessing eye-candy. Home-page: https://github.com/noxdafox/pebble Author: Matteo Cafasso diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Pebble-5.0.5/Pebble.egg-info/PKG-INFO new/Pebble-5.0.6/Pebble.egg-info/PKG-INFO --- old/Pebble-5.0.5/Pebble.egg-info/PKG-INFO 2023-12-06 17:51:09.000000000 +0100 +++ new/Pebble-5.0.6/Pebble.egg-info/PKG-INFO 2023-12-25 17:22:05.000000000 +0100 @@ -1,6 +1,6 @@ Metadata-Version: 2.1 Name: Pebble -Version: 5.0.5 +Version: 5.0.6 Summary: Threading and multiprocessing eye-candy. Home-page: https://github.com/noxdafox/pebble Author: Matteo Cafasso diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Pebble-5.0.5/pebble/__init__.py new/Pebble-5.0.6/pebble/__init__.py --- old/Pebble-5.0.5/pebble/__init__.py 2023-12-06 17:40:34.000000000 +0100 +++ new/Pebble-5.0.6/pebble/__init__.py 2023-12-25 17:18:15.000000000 +0100 @@ -1,5 +1,5 @@ __author__ = 'Matteo Cafasso' -__version__ = '5.0.5' +__version__ = '5.0.6' __license__ = 'LGPL' diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Pebble-5.0.5/pebble/common.py new/Pebble-5.0.6/pebble/common.py --- old/Pebble-5.0.5/pebble/common.py 2023-11-26 17:11:27.000000000 +0100 +++ new/Pebble-5.0.6/pebble/common.py 2023-12-25 11:45:33.000000000 +0100 @@ -164,7 +164,7 @@ """Runs the given function returning its results or exception.""" try: return Result(SUCCESS, function(*args, **kwargs)) - except Exception as error: + except BaseException as error: error.traceback = format_exc() return Result(FAILURE, error) @@ -173,7 +173,7 @@ """Runs the given function returning its results or exception.""" try: return Result(SUCCESS, function(*args, **kwargs)) - except Exception as error: + except BaseException as error: error.traceback = format_exc() return Result(FAILURE, RemoteException(error, error.traceback)) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Pebble-5.0.5/pebble/pool/base_pool.py new/Pebble-5.0.6/pebble/pool/base_pool.py --- old/Pebble-5.0.5/pebble/pool/base_pool.py 2023-11-26 17:55:17.000000000 +0100 +++ new/Pebble-5.0.6/pebble/pool/base_pool.py 2023-12-25 11:57:19.000000000 +0100 @@ -266,7 +266,7 @@ """Returns the results of a processed chunk.""" try: return future.result(timeout=timeout) - except Exception as error: + except BaseException as error: return (error, ) @@ -275,7 +275,7 @@ try: initializer(*initargs) return True - except Exception as error: + except BaseException as error: logging.exception(error) return False diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Pebble-5.0.5/test/test_process_pool_fork.py new/Pebble-5.0.6/test/test_process_pool_fork.py --- old/Pebble-5.0.5/test/test_process_pool_fork.py 2023-11-26 17:57:51.000000000 +0100 +++ new/Pebble-5.0.6/test/test_process_pool_fork.py 2023-12-25 12:05:45.000000000 +0100 @@ -44,7 +44,7 @@ def broken_initializer(): - raise Exception("BOOM!") + raise BaseException("BOOM!") def function(argument, keyword_argument=0): @@ -57,11 +57,11 @@ def error_function(): - raise Exception("BOOM!") + raise BaseException("BOOM!") def return_error_function(): - return Exception("BOOM!") + return BaseException("BOOM!") def pickle_error_function(): @@ -124,7 +124,7 @@ def callback(self, future): try: self.result = future.result() - except Exception as error: + except BaseException as error: self.exception = error finally: self.event.set() @@ -157,13 +157,13 @@ """Process Pool Fork errors are raised by future get.""" with ProcessPool(max_workers=1, context=mp_context) as pool: future = pool.schedule(error_function) - self.assertRaises(Exception, future.result) + self.assertRaises(BaseException, future.result) def test_process_pool_error_returned(self): """Process Pool Fork returned errors are returned by future get.""" with ProcessPool(max_workers=1, context=mp_context) as pool: future = pool.schedule(return_error_function) - self.assertIsInstance(future.result(), Exception) + self.assertIsInstance(future.result(), BaseException) def test_process_pool_error_callback(self): """Process Pool Fork errors are forwarded to callback.""" @@ -171,7 +171,7 @@ future = pool.schedule(error_function) future.add_done_callback(self.callback) self.event.wait() - self.assertTrue(isinstance(self.exception, Exception)) + self.assertTrue(isinstance(self.exception, BaseException)) def test_process_pool_pickling_error_task(self): """Process Pool Fork task pickling errors @@ -388,12 +388,12 @@ kwargs={'keyword_argument': 1}) def test_process_pool_exception_isolated(self): - """Process Pool Fork an Exception does not affect other futures.""" + """Process Pool Fork an BaseException does not affect other futures.""" with ProcessPool(max_workers=1, context=mp_context) as pool: future = pool.schedule(error_function) try: future.result() - except Exception: + except BaseException: pass future = pool.schedule(function, args=[1], kwargs={'keyword_argument': 1}) @@ -573,7 +573,7 @@ def callback(self, future): try: self.result = future.result() - # asyncio.exception.CancelledError does not inherit from Exception + # asyncio.exception.CancelledError does not inherit from BaseException except BaseException as error: self.exception = error finally: @@ -629,7 +629,7 @@ return await loop.run_in_executor(pool, error_function, None) with ProcessPool(max_workers=1, context=mp_context) as pool: - with self.assertRaises(Exception): + with self.assertRaises(BaseException): asyncio.run(test(pool)) def test_process_pool_error_returned(self): @@ -640,7 +640,7 @@ return await loop.run_in_executor(pool, return_error_function, None) with ProcessPool(max_workers=1, context=mp_context) as pool: - self.assertIsInstance(asyncio.run(test(pool)), Exception) + self.assertIsInstance(asyncio.run(test(pool)), BaseException) def test_process_pool_error_callback(self): """Process Pool Fork errors are forwarded to callback.""" @@ -657,7 +657,7 @@ with ProcessPool(max_workers=1, context=mp_context) as pool: asyncio.run(test(pool)) - self.assertTrue(isinstance(self.exception, Exception)) + self.assertTrue(isinstance(self.exception, BaseException)) def test_process_pool_timeout(self): """Process Pool Fork future raises TimeoutError if so.""" diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Pebble-5.0.5/test/test_process_pool_forkserver.py new/Pebble-5.0.6/test/test_process_pool_forkserver.py --- old/Pebble-5.0.5/test/test_process_pool_forkserver.py 2023-11-26 17:57:21.000000000 +0100 +++ new/Pebble-5.0.6/test/test_process_pool_forkserver.py 2023-12-25 12:37:54.000000000 +0100 @@ -28,7 +28,7 @@ if mp_context.get_start_method() == 'forkserver': supported = True else: - raise Exception(mp_context.get_start_method()) + raise BaseException(mp_context.get_start_method()) except RuntimeError: # child process pass @@ -46,7 +46,7 @@ def broken_initializer(): - raise Exception("BOOM!") + raise BaseException("BOOM!") def function(argument, keyword_argument=0): @@ -59,11 +59,11 @@ def error_function(): - raise Exception("BOOM!") + raise BaseException("BOOM!") def return_error_function(): - return Exception("BOOM!") + return BaseException("BOOM!") def pickle_error_function(): @@ -126,7 +126,7 @@ def callback(self, future): try: self.result = future.result() - except Exception as error: + except BaseException as error: self.exception = error finally: self.event.set() @@ -159,13 +159,13 @@ """Process Pool Forkserver errors are raised by future get.""" with ProcessPool(max_workers=1, context=mp_context) as pool: future = pool.schedule(error_function) - self.assertRaises(Exception, future.result) + self.assertRaises(BaseException, future.result) def test_process_pool_error_returned(self): """Process Pool Forkserver returned errors are returned by future get.""" with ProcessPool(max_workers=1, context=mp_context) as pool: future = pool.schedule(return_error_function) - self.assertIsInstance(future.result(), Exception) + self.assertIsInstance(future.result(), BaseException) def test_process_pool_error_callback(self): """Process Pool Forkserver errors are forwarded to callback.""" @@ -173,7 +173,7 @@ future = pool.schedule(error_function) future.add_done_callback(self.callback) self.event.wait() - self.assertTrue(isinstance(self.exception, Exception)) + self.assertTrue(isinstance(self.exception, BaseException)) def test_process_pool_pickling_error_task(self): """Process Pool Forkserver task pickling errors @@ -390,12 +390,12 @@ kwargs={'keyword_argument': 1}) def test_process_pool_exception_isolated(self): - """Process Pool Forkserver an Exception does not affect other futures.""" + """Process Pool Forkserver an BaseException does not affect other futures.""" with ProcessPool(max_workers=1, context=mp_context) as pool: future = pool.schedule(error_function) try: future.result() - except Exception: + except BaseException: pass future = pool.schedule(function, args=[1], kwargs={'keyword_argument': 1}) @@ -574,7 +574,7 @@ def callback(self, future): try: self.result = future.result() - # asyncio.exception.CancelledError does not inherit from Exception + # asyncio.exception.CancelledError does not inherit from BaseException except BaseException as error: self.exception = error finally: @@ -630,7 +630,7 @@ return await loop.run_in_executor(pool, error_function, None) with ProcessPool(max_workers=1, context=mp_context) as pool: - with self.assertRaises(Exception): + with self.assertRaises(BaseException): asyncio.run(test(pool)) def test_process_pool_error_returned(self): @@ -641,7 +641,7 @@ return await loop.run_in_executor(pool, return_error_function, None) with ProcessPool(max_workers=1, context=mp_context) as pool: - self.assertIsInstance(asyncio.run(test(pool)), Exception) + self.assertIsInstance(asyncio.run(test(pool)), BaseException) def test_process_pool_error_callback(self): """Process Pool Forkserver errors are forwarded to callback.""" @@ -658,7 +658,7 @@ with ProcessPool(max_workers=1, context=mp_context) as pool: asyncio.run(test(pool)) - self.assertTrue(isinstance(self.exception, Exception)) + self.assertTrue(isinstance(self.exception, BaseException)) def test_process_pool_timeout(self): """Process Pool Forkserver future raises TimeoutError if so.""" diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Pebble-5.0.5/test/test_process_pool_spawn.py new/Pebble-5.0.6/test/test_process_pool_spawn.py --- old/Pebble-5.0.5/test/test_process_pool_spawn.py 2023-11-26 17:56:27.000000000 +0100 +++ new/Pebble-5.0.6/test/test_process_pool_spawn.py 2023-12-25 12:39:14.000000000 +0100 @@ -44,7 +44,7 @@ def broken_initializer(): - raise Exception("BOOM!") + raise BaseException("BOOM!") def function(argument, keyword_argument=0): @@ -57,11 +57,11 @@ def error_function(): - raise Exception("BOOM!") + raise BaseException("BOOM!") def return_error_function(): - return Exception("BOOM!") + return BaseException("BOOM!") def pickle_error_function(): @@ -124,7 +124,7 @@ def callback(self, future): try: self.result = future.result() - except Exception as error: + except BaseException as error: self.exception = error finally: self.event.set() @@ -157,13 +157,13 @@ """Process Pool Spawn errors are raised by future get.""" with ProcessPool(max_workers=1, context=mp_context) as pool: future = pool.schedule(error_function) - self.assertRaises(Exception, future.result) + self.assertRaises(BaseException, future.result) def test_process_pool_error_returned(self): """Process Pool Spawn returned errors are returned by future get.""" with ProcessPool(max_workers=1, context=mp_context) as pool: future = pool.schedule(return_error_function) - self.assertIsInstance(future.result(), Exception) + self.assertIsInstance(future.result(), BaseException) def test_process_pool_error_callback(self): """Process Pool Spawn errors are forwarded to callback.""" @@ -171,7 +171,7 @@ future = pool.schedule(error_function) future.add_done_callback(self.callback) self.event.wait() - self.assertTrue(isinstance(self.exception, Exception)) + self.assertTrue(isinstance(self.exception, BaseException)) def test_process_pool_pickling_error_task(self): """Process Pool Spawn task pickling errors @@ -388,12 +388,12 @@ kwargs={'keyword_argument': 1}) def test_process_pool_exception_isolated(self): - """Process Pool Spawn an Exception does not affect other futures.""" + """Process Pool Spawn an BaseException does not affect other futures.""" with ProcessPool(max_workers=1, context=mp_context) as pool: future = pool.schedule(error_function) try: future.result() - except Exception: + except BaseException: pass future = pool.schedule(function, args=[1], kwargs={'keyword_argument': 1}) @@ -572,7 +572,7 @@ def callback(self, future): try: self.result = future.result() - # asyncio.exception.CancelledError does not inherit from Exception + # asyncio.exception.CancelledError does not inherit from BaseException except BaseException as error: self.exception = error finally: @@ -628,7 +628,7 @@ return await loop.run_in_executor(pool, error_function, None) with ProcessPool(max_workers=1, context=mp_context) as pool: - with self.assertRaises(Exception): + with self.assertRaises(BaseException): asyncio.run(test(pool)) def test_process_pool_error_returned(self): @@ -639,7 +639,7 @@ return await loop.run_in_executor(pool, return_error_function, None) with ProcessPool(max_workers=1, context=mp_context) as pool: - self.assertIsInstance(asyncio.run(test(pool)), Exception) + self.assertIsInstance(asyncio.run(test(pool)), BaseException) def test_process_pool_error_callback(self): """Process Pool Spawn errors are forwarded to callback.""" @@ -656,7 +656,7 @@ with ProcessPool(max_workers=1, context=mp_context) as pool: asyncio.run(test(pool)) - self.assertTrue(isinstance(self.exception, Exception)) + self.assertTrue(isinstance(self.exception, BaseException)) def test_process_pool_timeout(self): """Process Pool Spawn future raises TimeoutError if so.""" diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Pebble-5.0.5/test/test_thread_pool.py new/Pebble-5.0.6/test/test_thread_pool.py --- old/Pebble-5.0.5/test/test_thread_pool.py 2023-11-20 21:18:53.000000000 +0100 +++ new/Pebble-5.0.6/test/test_thread_pool.py 2023-12-25 11:55:53.000000000 +0100 @@ -13,7 +13,7 @@ def error_callback(future): - raise Exception("BOOM!") + raise BaseException("BOOM!") def initializer(value): @@ -22,7 +22,7 @@ def broken_initializer(): - raise Exception("BOOM!") + raise BaseException("BOOM!") def function(argument, keyword_argument=0): @@ -35,7 +35,7 @@ def error_function(): - raise Exception("BOOM!") + raise BaseException("BOOM!") def long_function(value=0): @@ -60,7 +60,7 @@ def callback(self, future): try: self.results = future.result() - except Exception as error: + except BaseException as error: self.exception = error finally: self.event.set() @@ -94,7 +94,7 @@ """Thread Pool errors are raised by future get.""" with ThreadPool(max_workers=1) as pool: future = pool.schedule(error_function) - with self.assertRaises(Exception): + with self.assertRaises(BaseException): future.result() def test_thread_pool_error_callback(self): @@ -103,7 +103,7 @@ future = pool.schedule(error_function) future.add_done_callback(self.callback) self.event.wait() - self.assertTrue(isinstance(self.exception, Exception)) + self.assertTrue(isinstance(self.exception, BaseException)) def test_thread_pool_cancel_callback(self): """Thread Pool FutureCancelled is forwarded to callback.""" @@ -244,7 +244,7 @@ pool.join() def test_thread_pool_exception_isolated(self): - """Thread Pool an Exception does not affect other futures.""" + """Thread Pool an BaseException does not affect other futures.""" with ThreadPool(max_workers=1) as pool: future = pool.schedule(error_function) try: @@ -374,7 +374,7 @@ def callback(self, future): try: self.result = future.result() - # asyncio.exception.CancelledError does not inherit from Exception + # asyncio.exception.CancelledError does not inherit from BaseException except BaseException as error: self.exception = error finally: @@ -430,7 +430,7 @@ return await loop.run_in_executor(pool, error_function) with ThreadPool(max_workers=1) as pool: - with self.assertRaises(Exception): + with self.assertRaises(BaseException): asyncio.run(test(pool)) def test_thread_pool_error_callback(self): @@ -448,7 +448,7 @@ with ThreadPool(max_workers=1) as pool: asyncio.run(test(pool)) - self.assertTrue(isinstance(self.exception, Exception)) + self.assertTrue(isinstance(self.exception, BaseException)) def test_thread_pool_cancel_callback(self): """Thread Pool FutureCancelled is forwarded to callback."""
