Hello community,
here is the log from the commit of package python-Pebble for openSUSE:Factory
checked in at 2020-03-26 23:37:52
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/python-Pebble (Old)
and /work/SRC/openSUSE:Factory/.python-Pebble.new.3160 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-Pebble"
Thu Mar 26 23:37:52 2020 rev:5 rq:788613 version:4.5.1
Changes:
--------
--- /work/SRC/openSUSE:Factory/python-Pebble/python-Pebble.changes
2020-01-15 16:46:16.585215959 +0100
+++ /work/SRC/openSUSE:Factory/.python-Pebble.new.3160/python-Pebble.changes
2020-03-26 23:37:54.354875387 +0100
@@ -1,0 +2,7 @@
+Thu Mar 26 16:16:44 UTC 2020 - Marketa Calabkova <mcalabk...@suse.com>
+
+- update to 4.5.1
+ * add daemon parameter to decorator
+ * travis: add Python 3.8 tests
+
+-------------------------------------------------------------------
Old:
----
Pebble-4.4.1.tar.gz
New:
----
Pebble-4.5.1.tar.gz
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ python-Pebble.spec ++++++
--- /var/tmp/diff_new_pack.mYuexY/_old 2020-03-26 23:37:55.034875633 +0100
+++ /var/tmp/diff_new_pack.mYuexY/_new 2020-03-26 23:37:55.038875634 +0100
@@ -18,7 +18,7 @@
%{?!python_module:%define python_module() python-%{**} python3-%{**}}
Name: python-Pebble
-Version: 4.4.1
+Version: 4.5.1
Release: 0
Summary: Threading and multiprocessing eye-candy for Python
License: LGPL-3.0-only
++++++ Pebble-4.4.1.tar.gz -> Pebble-4.5.1.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Pebble-4.4.1/PKG-INFO new/Pebble-4.5.1/PKG-INFO
--- old/Pebble-4.4.1/PKG-INFO 2019-12-22 22:02:32.000000000 +0100
+++ new/Pebble-4.5.1/PKG-INFO 2020-03-08 14:54:43.000000000 +0100
@@ -1,6 +1,6 @@
Metadata-Version: 1.1
Name: Pebble
-Version: 4.4.1
+Version: 4.5.1
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-4.4.1/Pebble.egg-info/PKG-INFO
new/Pebble-4.5.1/Pebble.egg-info/PKG-INFO
--- old/Pebble-4.4.1/Pebble.egg-info/PKG-INFO 2019-12-22 22:02:31.000000000
+0100
+++ new/Pebble-4.5.1/Pebble.egg-info/PKG-INFO 2020-03-08 14:54:43.000000000
+0100
@@ -1,6 +1,6 @@
Metadata-Version: 1.1
Name: Pebble
-Version: 4.4.1
+Version: 4.5.1
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-4.4.1/pebble/__init__.py
new/Pebble-4.5.1/pebble/__init__.py
--- old/Pebble-4.4.1/pebble/__init__.py 2019-02-09 12:11:00.000000000 +0100
+++ new/Pebble-4.5.1/pebble/__init__.py 2020-03-08 14:54:43.000000000 +0100
@@ -14,3 +14,6 @@
from pebble.common import ProcessExpired, ProcessFuture
from pebble.functions import waitforqueues, waitforthreads
from pebble.pool import ThreadPool, ProcessPool, MapFuture, ProcessMapFuture
+"""Versioning controlled via Git Tag, check setup.py"""
+
+__version__ = "4.5.1"
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Pebble-4.4.1/pebble/common.py
new/Pebble-4.5.1/pebble/common.py
--- old/Pebble-4.4.1/pebble/common.py 2019-12-19 23:04:31.000000000 +0100
+++ new/Pebble-4.5.1/pebble/common.py 2020-01-26 11:20:15.000000000 +0100
@@ -1,5 +1,5 @@
# This file is part of Pebble.
-# Copyright (c) 2013-2019, Matteo Cafasso
+# Copyright (c) 2013-2020, Matteo Cafasso
# Pebble is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License
@@ -127,17 +127,17 @@
return exception
-def launch_thread(name, function, *args, **kwargs):
+def launch_thread(name, function, daemon, *args, **kwargs):
thread = Thread(target=function, name=name, args=args, kwargs=kwargs)
- thread.daemon = True
+ thread.daemon = daemon
thread.start()
return thread
-def launch_process(name, function, *args, **kwargs):
+def launch_process(name, function, daemon, *args, **kwargs):
process = Process(target=function, name=name, args=args, kwargs=kwargs)
- process.daemon = True
+ process.daemon = daemon
process.start()
return process
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Pebble-4.4.1/pebble/concurrent/process.py
new/Pebble-4.5.1/pebble/concurrent/process.py
--- old/Pebble-4.4.1/pebble/concurrent/process.py 2019-09-29
18:45:18.000000000 +0200
+++ new/Pebble-4.5.1/pebble/concurrent/process.py 2020-01-26
11:20:11.000000000 +0100
@@ -1,5 +1,5 @@
# This file is part of Pebble.
-# Copyright (c) 2013-2019, Matteo Cafasso
+# Copyright (c) 2013-2020, Matteo Cafasso
# Pebble is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License
@@ -47,24 +47,27 @@
"""
timeout = kwargs.get('timeout')
name = kwargs.get('name')
+ daemon = kwargs.get('daemon', True)
# decorator without parameters
if len(args) == 1 and len(kwargs) == 0 and callable(args[0]):
- return _process_wrapper(args[0], timeout, name)
+ return _process_wrapper(args[0], timeout, name, daemon)
else:
# decorator with parameters
if timeout is not None and not isinstance(timeout, (int, float)):
raise TypeError('Timeout expected to be None or integer or float')
if name is not None and not isinstance(name, str):
raise TypeError('Name expected to be None or string')
+ if daemon is not None and not isinstance(daemon, bool):
+ raise TypeError('Daemon expected to be None or bool')
def decorating_function(function):
- return _process_wrapper(function, timeout, name)
+ return _process_wrapper(function, timeout, name, daemon)
return decorating_function
-def _process_wrapper(function, timeout, name):
+def _process_wrapper(function, timeout, name, daemon):
_register_function(function)
@wraps(function)
@@ -79,13 +82,13 @@
target = function
worker = launch_process(
- name, _function_handler, target, args, kwargs, writer)
+ name, _function_handler, daemon, target, args, kwargs, writer)
writer.close()
future.set_running_or_notify_cancel()
- launch_thread(name, _worker_handler, future, worker, reader, timeout)
+ launch_thread(name, _worker_handler, True, future, worker, reader,
timeout)
return future
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Pebble-4.4.1/pebble/concurrent/thread.py
new/Pebble-4.5.1/pebble/concurrent/thread.py
--- old/Pebble-4.4.1/pebble/concurrent/thread.py 2019-09-29
18:45:18.000000000 +0200
+++ new/Pebble-4.5.1/pebble/concurrent/thread.py 2020-01-26
11:20:14.000000000 +0100
@@ -1,5 +1,5 @@
# This file is part of Pebble.
-# Copyright (c) 2013-2019, Matteo Cafasso
+# Copyright (c) 2013-2020, Matteo Cafasso
# Pebble is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License
@@ -28,30 +28,33 @@
Decorated functions will return a concurrent.futures.Future object
once called.
- The name parameter will set the process name.
+ The name parameter will set the process name.
"""
name = kwargs.get('name')
+ daemon = kwargs.get('daemon', True)
if len(args) == 1 and len(kwargs) == 0 and callable(args[0]):
- return _thread_wrapper(args[0], name)
+ return _thread_wrapper(args[0], name, daemon)
else:
# decorator with parameters
if name is not None and not isinstance(name, str):
raise TypeError('Name expected to be None or string')
+ if daemon is not None and not isinstance(daemon, bool):
+ raise TypeError('Daemon expected to be None or bool')
def decorating_function(function):
- return _thread_wrapper(function, name)
+ return _thread_wrapper(function, name, daemon)
return decorating_function
-
-def _thread_wrapper(function, name):
+
+def _thread_wrapper(function, name, daemon):
@wraps(function)
def wrapper(*args, **kwargs):
future = Future()
- launch_thread(name, _function_handler, function, args, kwargs, future)
+ launch_thread(name, _function_handler, daemon, function, args, kwargs,
future)
return future
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Pebble-4.4.1/pebble/decorators.py
new/Pebble-4.5.1/pebble/decorators.py
--- old/Pebble-4.4.1/pebble/decorators.py 2019-02-09 12:11:00.000000000
+0100
+++ new/Pebble-4.5.1/pebble/decorators.py 2020-01-26 11:20:22.000000000
+0100
@@ -1,5 +1,5 @@
# This file is part of Pebble.
-# Copyright (c) 2013-2019, Matteo Cafasso
+# Copyright (c) 2013-2020, Matteo Cafasso
# Pebble is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Pebble-4.4.1/pebble/functions.py
new/Pebble-4.5.1/pebble/functions.py
--- old/Pebble-4.4.1/pebble/functions.py 2019-02-09 12:11:00.000000000
+0100
+++ new/Pebble-4.5.1/pebble/functions.py 2020-01-26 11:20:16.000000000
+0100
@@ -1,5 +1,5 @@
# This file is part of Pebble.
-# Copyright (c) 2013-2019, Matteo Cafasso
+# Copyright (c) 2013-2020, Matteo Cafasso
# Pebble is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Pebble-4.4.1/pebble/pool/base_pool.py
new/Pebble-4.5.1/pebble/pool/base_pool.py
--- old/Pebble-4.4.1/pebble/pool/base_pool.py 2019-02-17 10:32:40.000000000
+0100
+++ new/Pebble-4.5.1/pebble/pool/base_pool.py 2020-02-24 20:41:54.000000000
+0100
@@ -1,5 +1,5 @@
# This file is part of Pebble.
-# Copyright (c) 2013-2019, Matteo Cafasso
+# Copyright (c) 2013-2020, Matteo Cafasso
# Pebble is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License
@@ -107,9 +107,7 @@
raise NotImplementedError("Not implemented")
def _stop_pool(self):
- for loop in self._loops:
- loop.join()
- self._pool_manager.stop()
+ raise NotImplementedError("Not implemented")
class PoolContext(object):
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Pebble-4.4.1/pebble/pool/channel.py
new/Pebble-4.5.1/pebble/pool/channel.py
--- old/Pebble-4.4.1/pebble/pool/channel.py 2019-12-20 23:57:33.000000000
+0100
+++ new/Pebble-4.5.1/pebble/pool/channel.py 2020-01-26 11:20:20.000000000
+0100
@@ -1,5 +1,5 @@
# This file is part of Pebble.
-# Copyright (c) 2013-2019, Matteo Cafasso
+# Copyright (c) 2013-2020, Matteo Cafasso
# Pebble is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Pebble-4.4.1/pebble/pool/process.py
new/Pebble-4.5.1/pebble/pool/process.py
--- old/Pebble-4.4.1/pebble/pool/process.py 2019-12-19 23:10:41.000000000
+0100
+++ new/Pebble-4.5.1/pebble/pool/process.py 2020-02-24 20:41:54.000000000
+0100
@@ -1,5 +1,5 @@
# This file is part of Pebble.
-# Copyright (c) 2013-2019, Matteo Cafasso
+# Copyright (c) 2013-2020, Matteo Cafasso
# Pebble is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License
@@ -51,7 +51,6 @@
every time a worker is started, receiving initargs as arguments.
"""
-
def __init__(self, max_workers=cpu_count(), max_tasks=0,
initializer=None, initargs=()):
super(ProcessPool, self).__init__(
@@ -63,13 +62,19 @@
if self._context.state == CREATED:
self._pool_manager.start()
self._loops = (launch_thread(None, task_scheduler_loop,
- self._pool_manager),
+ True, self._pool_manager),
launch_thread(None, pool_manager_loop,
- self._pool_manager),
+ True, self._pool_manager),
launch_thread(None, message_manager_loop,
- self._pool_manager))
+ True, self._pool_manager))
self._context.state = RUNNING
+ def _stop_pool(self):
+ self._pool_manager.close()
+ for loop in self._loops:
+ loop.join()
+ self._pool_manager.stop()
+
def schedule(self, function, args=(), kwargs={}, timeout=None):
"""Schedules *function* to be run the Pool.
@@ -177,7 +182,6 @@
class PoolManager:
"""Combines Task and Worker Managers providing a higher level one."""
-
def __init__(self, context):
self.context = context
self.task_manager = TaskManager(context.task_queue.task_done)
@@ -187,9 +191,11 @@
def start(self):
self.worker_manager.create_workers()
+ def close(self):
+ self.worker_manager.close_channels()
+
def stop(self):
self.worker_manager.stop_workers()
- self.worker_manager.close_channels()
def schedule(self, task):
"""Schedules a new Task in the PoolManager."""
@@ -368,7 +374,7 @@
def new_worker(self):
try:
worker = launch_process(
- None, worker_process, self.worker_parameters,
self.workers_channel)
+ None, worker_process, True, self.worker_parameters,
self.workers_channel)
self.workers[worker.pid] = worker
except (OSError, EnvironmentError) as error:
raise BrokenProcessPool(error)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Pebble-4.4.1/pebble/pool/thread.py
new/Pebble-4.5.1/pebble/pool/thread.py
--- old/Pebble-4.4.1/pebble/pool/thread.py 2019-09-29 18:45:18.000000000
+0200
+++ new/Pebble-4.5.1/pebble/pool/thread.py 2020-02-24 20:41:54.000000000
+0100
@@ -1,5 +1,5 @@
# This file is part of Pebble.
-# Copyright (c) 2013-2019, Matteo Cafasso
+# Copyright (c) 2013-2020, Matteo Cafasso
# Pebble is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License
@@ -39,7 +39,6 @@
every time a worker is started, receiving initargs as arguments.
"""
-
def __init__(self, max_workers=cpu_count(), max_tasks=0,
initializer=None, initargs=()):
super(ThreadPool, self).__init__(
@@ -51,10 +50,15 @@
if self._context.state == CREATED:
self._pool_manager.start()
self._loops = (launch_thread(None, pool_manager_loop,
- self._pool_manager),)
+ True, self._pool_manager),)
self._context.state = RUNNING
+ def _stop_pool(self):
+ for loop in self._loops:
+ loop.join()
+ self._pool_manager.stop()
+
def schedule(self, function, args=(), kwargs={}):
"""Schedules *function* to be run the Pool.
@@ -143,7 +147,7 @@
def create_workers(self):
for _ in range(self.context.workers - len(self.workers)):
- worker = launch_thread(None, worker_thread, self.context)
+ worker = launch_thread(None, worker_thread, True, self.context)
self.workers.append(worker)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Pebble-4.4.1/setup.py new/Pebble-4.5.1/setup.py
--- old/Pebble-4.4.1/setup.py 2019-02-09 12:10:58.000000000 +0100
+++ new/Pebble-4.5.1/setup.py 2020-03-08 14:45:44.000000000 +0100
@@ -3,16 +3,21 @@
from setuptools import setup, find_packages
+CWD = os.path.dirname(__file__)
+
+
def read(fname):
- return open(os.path.join(os.path.dirname(__file__), fname)).read()
+ return open(os.path.join(CWD, fname)).read()
def package_version():
"""Get the package version via Git Tag."""
- version_path = os.path.join(os.path.dirname(__file__), 'version.py')
+ version_path = os.path.join(CWD, 'version.py')
+ init_path = os.path.join(CWD, 'pebble', '__init__.py')
version = read_version(version_path)
write_version(version_path, version)
+ write_version(init_path, version, mode='a')
return version
@@ -20,15 +25,15 @@
def read_version(path):
try:
return subprocess.check_output(('git', 'describe')).rstrip().decode()
- except subprocess.CalledProcessError:
+ except Exception:
with open(path) as version_file:
version_string = version_file.read().split('=')[-1]
return version_string.strip().replace('"', '')
-def write_version(path, version):
+def write_version(path, version, mode='w'):
msg = '"""Versioning controlled via Git Tag, check setup.py"""'
- with open(path, 'w') as version_file:
+ with open(path, mode) as version_file:
version_file.write(msg + os.linesep + os.linesep +
'__version__ = "{}"'.format(version) +
os.linesep)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Pebble-4.4.1/test/test_concurrent_process_fork.py
new/Pebble-4.5.1/test/test_concurrent_process_fork.py
--- old/Pebble-4.4.1/test/test_concurrent_process_fork.py 2019-09-29
18:45:18.000000000 +0200
+++ new/Pebble-4.5.1/test/test_concurrent_process_fork.py 2020-01-25
11:41:23.000000000 +0100
@@ -77,6 +77,13 @@
@concurrent.process(name='decorator_kwarg')
def name_keyword_decorated_and_argument(name='bar'):
return (multiprocessing.current_process().name, name)
+
+
+@concurrent.process(daemon=False)
+def daemon_keyword_decorated():
+ return multiprocessing.current_process().daemon
+
+
class ProcessConcurrentObj:
a = 0
@@ -234,4 +241,9 @@
dec_out, fn_out = f.result()
self.assertEqual(dec_out, "decorator_kwarg")
self.assertEqual(fn_out, "function_kwarg")
-
\ No newline at end of file
+
+ def test_daemon_keyword_decorated(self):
+ """Daemon keyword can be passed to a decorated function and spawns
correctly."""
+ f = daemon_keyword_decorated()
+ dec_out = f.result()
+ self.assertEqual(dec_out, False)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/Pebble-4.4.1/test/test_concurrent_process_forkserver.py
new/Pebble-4.5.1/test/test_concurrent_process_forkserver.py
--- old/Pebble-4.4.1/test/test_concurrent_process_forkserver.py 2019-02-10
00:28:12.000000000 +0100
+++ new/Pebble-4.5.1/test/test_concurrent_process_forkserver.py 2020-01-25
11:41:23.000000000 +0100
@@ -64,6 +64,11 @@
time.sleep(10)
+@concurrent.process(daemon=False)
+def daemon_keyword_decorated():
+ return multiprocessing.current_process().daemon
+
+
class ProcessConcurrentObj:
a = 0
@@ -190,3 +195,9 @@
future = sigterm_decorated()
with self.assertRaises(TimeoutError):
future.result()
+
+ def test_daemon_keyword_decorated(self):
+ """Daemon keyword can be passed to a decorated function and spawns
correctly."""
+ f = daemon_keyword_decorated()
+ dec_out = f.result()
+ self.assertEqual(dec_out, False)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Pebble-4.4.1/test/test_concurrent_process_spawn.py
new/Pebble-4.5.1/test/test_concurrent_process_spawn.py
--- old/Pebble-4.4.1/test/test_concurrent_process_spawn.py 2019-02-10
00:42:17.000000000 +0100
+++ new/Pebble-4.5.1/test/test_concurrent_process_spawn.py 2020-01-25
11:41:23.000000000 +0100
@@ -64,6 +64,11 @@
time.sleep(10)
+@concurrent.process(daemon=False)
+def daemon_keyword_decorated():
+ return multiprocessing.current_process().daemon
+
+
class ProcessConcurrentObj:
a = 0
@@ -190,3 +195,9 @@
future = sigterm_decorated()
with self.assertRaises(TimeoutError):
future.result()
+
+ def test_daemon_keyword_decorated(self):
+ """Daemon keyword can be passed to a decorated function and spawns
correctly."""
+ f = daemon_keyword_decorated()
+ dec_out = f.result()
+ self.assertEqual(dec_out, False)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Pebble-4.4.1/test/test_concurrent_thread.py
new/Pebble-4.5.1/test/test_concurrent_thread.py
--- old/Pebble-4.4.1/test/test_concurrent_thread.py 2019-09-29
18:45:18.000000000 +0200
+++ new/Pebble-4.5.1/test/test_concurrent_thread.py 2020-01-25
11:41:23.000000000 +0100
@@ -30,6 +30,11 @@
return (threading.current_thread().name, name)
+@concurrent.thread(daemon=False)
+def daemon_keyword_decorated():
+ return threading.current_thread().daemon
+
+
class ThreadConcurrentObj:
a = 0
@@ -132,3 +137,9 @@
dec_out, fn_out = f.result()
self.assertEqual(dec_out, "decorator_kwarg")
self.assertEqual(fn_out, "function_kwarg")
+
+ def test_daemon_keyword_decorated(self):
+ """Daemon keyword can be passed to a decorated function and spawns
correctly."""
+ f = daemon_keyword_decorated()
+ dec_out = f.result()
+ self.assertEqual(dec_out, False)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Pebble-4.4.1/test/test_pebble.py
new/Pebble-4.5.1/test/test_pebble.py
--- old/Pebble-4.4.1/test/test_pebble.py 2019-09-29 18:45:18.000000000
+0200
+++ new/Pebble-4.5.1/test/test_pebble.py 2020-01-25 11:41:23.000000000
+0100
@@ -127,20 +127,20 @@
class TestWaitForThreads(unittest.TestCase):
def test_waitforthreads_single(self):
"""Waitforthreads waits for a single thread."""
- thread = launch_thread(None, thread_function, 0.01)
+ thread = launch_thread(None, thread_function, True, 0.01)
self.assertEqual(list(waitforthreads([thread]))[0], thread)
def test_waitforthreads_multiple(self):
"""Waitforthreads waits for multiple threads."""
threads = []
for _ in range(5):
- threads.append(launch_thread(None, thread_function, 0.01))
+ threads.append(launch_thread(None, thread_function, True, 0.01))
time.sleep(0.1)
self.assertEqual(list(waitforthreads(threads)), threads)
def test_waitforthreads_timeout(self):
"""Waitforthreads returns empty list if timeout."""
- thread = launch_thread(None, thread_function, 0.1)
+ thread = launch_thread(None, thread_function, True, 0.1)
self.assertEqual(list(waitforthreads([thread], timeout=0.01)), [])
def test_waitforthreads_restore(self):
@@ -149,7 +149,7 @@
expected = threading.get_ident
else:
expected = threading._get_ident
- thread = launch_thread(None, thread_function, 0)
+ thread = launch_thread(None, thread_function, True, 0)
time.sleep(0.01)
waitforthreads([thread])
if hasattr(threading, 'get_ident'):
@@ -160,7 +160,7 @@
def test_waitforthreads_spurious(self):
"""Waitforthreads tolerates spurious wakeups."""
lock = threading.RLock()
- thread = launch_thread(None, spurious_wakeup_function, 0.1, lock)
+ thread = launch_thread(None, spurious_wakeup_function, True, 0.1, lock)
self.assertEqual(list(waitforthreads([thread])), [thread])
@@ -170,24 +170,24 @@
def test_waitforqueues_single(self):
"""Waitforqueues waits for a single queue."""
- launch_thread(None, queue_function, self.queues, 0, 0.01)
+ launch_thread(None, queue_function, True, self.queues, 0, 0.01)
self.assertEqual(list(waitforqueues(self.queues))[0], self.queues[0])
def test_waitforqueues_multiple(self):
"""Waitforqueues waits for multiple queues."""
for index in range(3):
- launch_thread(None, queue_function, self.queues, index, 0.01)
+ launch_thread(None, queue_function, True, self.queues, index, 0.01)
time.sleep(0.1)
self.assertEqual(list(waitforqueues(self.queues)), self.queues)
def test_waitforqueues_timeout(self):
"""Waitforqueues returns empty list if timeout."""
- launch_thread(None, queue_function, self.queues, 0, 0.1)
+ launch_thread(None, queue_function, True, self.queues, 0, 0.1)
self.assertEqual(list(waitforqueues(self.queues, timeout=0.01)), [])
def test_waitforqueues_restore(self):
"""Waitforqueues Queue object is restored to original one."""
expected = sorted(dir(self.queues[0]))
- launch_thread(None, queue_function, self.queues, 0, 0)
+ launch_thread(None, queue_function, True, self.queues, 0, 0)
waitforqueues(self.queues)
self.assertEqual(sorted(dir(self.queues[0])), expected)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Pebble-4.4.1/version.py new/Pebble-4.5.1/version.py
--- old/Pebble-4.4.1/version.py 2019-12-22 22:02:31.000000000 +0100
+++ new/Pebble-4.5.1/version.py 2020-03-08 14:54:43.000000000 +0100
@@ -1,3 +1,3 @@
"""Versioning controlled via Git Tag, check setup.py"""
-__version__ = "4.4.1"
+__version__ = "4.5.1"
