From 0c9287b623ab4e9999488a09e3fa27e0c94fed07 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Fri, 22 Jul 2016 14:29:26 +0200 Subject: [PATCH 001/155] add displaying function to tutorial --- noodles/tutorial.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/noodles/tutorial.py b/noodles/tutorial.py index 59cb0d8..e493b69 100644 --- a/noodles/tutorial.py +++ b/noodles/tutorial.py @@ -1,4 +1,4 @@ -from . import schedule +from . import schedule, schedule_hint @schedule @@ -6,6 +6,11 @@ def add(x, y): return x + y +@schedule_hint(display="{a} + {b}", confirm=True) +def log_add(a, b): + return a + b + + @schedule def sub(x, y): return x - y From 41038a029dbbe81d954d380eb94952e90b39b206 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Fri, 22 Jul 2016 14:38:14 +0200 Subject: [PATCH 002/155] fixed example/run-on-das.py, exit is not clean but it works --- examples/run-on-das.py | 30 +++++++++++++++++++----------- setup.py | 5 +++-- 2 files changed, 22 insertions(+), 13 deletions(-) diff --git a/examples/run-on-das.py b/examples/run-on-das.py index 97421a8..179de83 100644 --- a/examples/run-on-das.py +++ b/examples/run-on-das.py @@ -2,18 +2,21 @@ serial, gather) from noodles.run.xenon import ( - XenonConfig, RemoteJobConfig, XenonKeeper, run_xenon) + XenonConfig, RemoteJobConfig, XenonKeeper, run_xenon_prov) + +from noodles.display import ( + NCDisplay) from noodles.tutorial import ( - add, mul, sub, accumulate) + log_add, mul, sub, accumulate) import os if __name__ == '__main__': - A = add(1, 1) + A = log_add(1, 1) B = sub(3, A) - multiples = [mul(add(i, B), A) for i in range(6)] + multiples = [mul(log_add(i, B), A) for i in range(6)] C = accumulate(gather(*multiples)) with XenonKeeper() as Xe: @@ -22,17 +25,22 @@ xenon_config = XenonConfig( jobs_scheme='slurm', - location=None, - # credential=certificate + location='', + credential=certificate, + jobs_properties={ + 'xenon.adaptors.slurm.ignore.version': 'true' + } ) job_config = RemoteJobConfig( registry=serial.base, - prefix='/home/jhidding/venv', - working_dir='/home/jhidding/noodles', - time_out=1 + prefix='', + working_dir='', + time_out=5000 ) - result = run_xenon(Xe, 2, xenon_config, job_config, C) + with NCDisplay() as display: + result = run_xenon_prov( + C, Xe, "cache.json", 2, + xenon_config, job_config, display=display) print("The answer is", result) - diff --git a/setup.py b/setup.py index 2169a6a..8add559 100755 --- a/setup.py +++ b/setup.py @@ -12,12 +12,13 @@ setup( name='Noodles', - version='0.1.9300', + version='0.1.9301', description='Workflow Engine', author='Johan Hidding', url='https://github.com/NLeSC/noodles', packages=[ - 'noodles', 'noodles.serial', 'noodles.run', 'noodles.display', + 'noodles', 'noodles.serial', 'noodles.run', 'noodles.run.xenon', + 'noodles.display', 'noodles.interface', 'noodles.workflow', 'noodles.files', 'noodles.prov'], From a063d386af3318c67f3062b6162e0e649923ed89 Mon Sep 17 00:00:00 2001 From: Joris Borgdorff Date: Mon, 8 Aug 2016 15:22:42 +0200 Subject: [PATCH 003/155] Added docker-py as testing dependency --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index 8add559..439e3e9 100755 --- a/setup.py +++ b/setup.py @@ -36,6 +36,6 @@ extras_require={ 'prov': ['tinydb'], 'xenon': ['pyxenon'], - 'test': ['nose', 'coverage', 'pyflakes', 'pep8'] + 'test': ['nose', 'coverage', 'pyflakes', 'pep8', 'docker-py'] }, ) From 385fc15696790b4ad89ab85c8ff712cfc691cafa Mon Sep 17 00:00:00 2001 From: Joris Borgdorff Date: Mon, 8 Aug 2016 15:55:51 +0200 Subject: [PATCH 004/155] Fixed tests with optional dependencies --- noodles/run/xenon/__init__.py | 16 +++- noodles/run/xenon/runner.py | 139 +++++++++++++++++----------------- test/test_prov.py | 1 - test/test_xenon_local.py | 14 ++-- 4 files changed, 92 insertions(+), 78 deletions(-) diff --git a/noodles/run/xenon/__init__.py b/noodles/run/xenon/__init__.py index e0730c8..4998e7d 100644 --- a/noodles/run/xenon/__init__.py +++ b/noodles/run/xenon/__init__.py @@ -1,5 +1,13 @@ -from .runner import (run_xenon, run_xenon_prov) -from .xenon import (XenonConfig, RemoteJobConfig, XenonKeeper) +from .runner import (run_xenon) +from .xenon import (XenonJob, XenonScheduler, XenonConfig, RemoteJobConfig, + XenonKeeper) -__all__ = ['XenonConfig', 'RemoteJobConfig', 'XenonKeeper', - 'run_xenon', 'run_xenon_prov'] +# Only export run_xenon_prov if provenance is installed +try: + from .runner import run_xenon_prov + __all__ = ['run_xenon_prov'] +except ImportError: + __all__ = [] + +__all__ += ['XenonConfig', 'XenonJob', 'XenonScheduler', 'RemoteJobConfig', + 'XenonKeeper', 'run_xenon'] diff --git a/noodles/run/xenon/runner.py b/noodles/run/xenon/runner.py index e177a75..15856e5 100644 --- a/noodles/run/xenon/runner.py +++ b/noodles/run/xenon/runner.py @@ -2,7 +2,6 @@ from ..scheduler import Scheduler from ..job_keeper import JobKeeper from ..haploid import (broadcast, sink_map, patch, branch) -from ..run_with_prov import (prov_wrap_connection) from ..queue import Queue from ...workflow import (get_workflow) @@ -10,6 +9,77 @@ import threading from copy import copy +# Only define run_xenon_prov if provenance is installed +try: + from ..run_with_prov import prov_wrap_connection +except ImportError: + pass +else: + def run_xenon_prov(wf, Xe, jobdb_file, n_processes, xenon_config, + job_config, *, deref=False, job_keeper=None, display=None): + """Run the workflow using a number of online Xenon workers. + + :param Xe: + The XenonKeeper instance. + + :param wf: + The workflow. + :type wf: `Workflow` or `PromisedObject` + + :param n_processes: + Number of processes to start. + + :param xenon_config: + The :py:class:`XenonConfig` object that gives tells us how to use + Xenon. + + :param job_config: + The :py:class:`RemoteJobConfig` object that specifies the command to + run remotely for each worker. + + :param deref: + Set this to True to pass the result through one more encoding and + decoding step with object derefencing turned on. + :type deref: bool + + :returns: the result of evaluating the workflow + :rtype: any + """ + DP = DynamicPool(Xe, xenon_config) + + for i in range(n_processes): + cfg = copy(job_config) + cfg.name = 'xenon-{0:02}'.format(i) + DP.add_xenon_worker(cfg) + + if job_keeper is None: + job_keeper = JobKeeper() + S = Scheduler(job_keeper=job_keeper) + + LogQ = Queue() + if display: + tgt = broadcast(job_keeper.message, sink_map(display)) + else: + tgt = job_keeper.message + + threading.Thread( + target=patch, + args=(LogQ.source, tgt), + daemon=True).start() + + result = S.run( + prov_wrap_connection( + DP >> branch(LogQ.sink), + DP.result_queue, job_config.registry, + jobdb_file, job_keeper, + log_q=LogQ), + get_workflow(wf)) + + if deref: + return job_config.registry().dereference(result, host='localhost') + else: + return result + def run_xenon(wf, Xe, jobdb_file, n_processes, xenon_config, job_config, *, deref=False, job_keeper=None, display=None): @@ -81,70 +151,3 @@ def run_xenon(wf, Xe, jobdb_file, n_processes, xenon_config, return job_config.registry().dereference(result, host='localhost') else: return result - - -def run_xenon_prov(wf, Xe, jobdb_file, n_processes, xenon_config, - job_config, *, deref=False, job_keeper=None, display=None): - """Run the workflow using a number of online Xenon workers. - - :param Xe: - The XenonKeeper instance. - - :param wf: - The workflow. - :type wf: `Workflow` or `PromisedObject` - - :param n_processes: - Number of processes to start. - - :param xenon_config: - The :py:class:`XenonConfig` object that gives tells us how to use - Xenon. - - :param job_config: - The :py:class:`RemoteJobConfig` object that specifies the command to - run remotely for each worker. - - :param deref: - Set this to True to pass the result through one more encoding and - decoding step with object derefencing turned on. - :type deref: bool - - :returns: the result of evaluating the workflow - :rtype: any - """ - - DP = DynamicPool(Xe, xenon_config) - - for i in range(n_processes): - cfg = copy(job_config) - cfg.name = 'xenon-{0:02}'.format(i) - DP.add_xenon_worker(cfg) - - if job_keeper is None: - job_keeper = JobKeeper() - S = Scheduler(job_keeper=job_keeper) - - LogQ = Queue() - if display: - tgt = broadcast(job_keeper.message, sink_map(display)) - else: - tgt = job_keeper.message - - threading.Thread( - target=patch, - args=(LogQ.source, tgt), - daemon=True).start() - - result = S.run( - prov_wrap_connection( - DP >> branch(LogQ.sink), - DP.result_queue, job_config.registry, - jobdb_file, job_keeper, - log_q=LogQ), - get_workflow(wf)) - - if deref: - return job_config.registry().dereference(result, host='localhost') - else: - return result diff --git a/test/test_prov.py b/test/test_prov.py index 1050095..1c60747 100644 --- a/test/test_prov.py +++ b/test/test_prov.py @@ -4,7 +4,6 @@ from noodles.prov import prov_key from noodles.run.run_with_prov import ( run_single, run_parallel, run_parallel_opt) - except ImportError as e: raise SkipTest(str(e)) diff --git a/test/test_xenon_local.py b/test/test_xenon_local.py index 3f4f560..cf22b13 100644 --- a/test/test_xenon_local.py +++ b/test/test_xenon_local.py @@ -1,12 +1,16 @@ from nose.plugins.skip import SkipTest try: - from noodles.run.xenon import ( - run_xenon_prov, XenonConfig, - RemoteJobConfig, XenonKeeper) - + # Only test xenon if it is installed + from noodles.run.xenon import (XenonConfig, RemoteJobConfig, XenonKeeper) except ImportError as e: raise SkipTest(str(e)) +else: + # Only test run_xenon_prov if provenance is installed, otherwise run_xenon + try: + from noodles.run.xenon import run_xenon_prov as run_xenon + except ImportError: + from noodles.run.xenon import run_xenon import noodles from noodles.display import (NCDisplay) @@ -36,7 +40,7 @@ def test_xenon_42(): ) with XenonKeeper() as Xe, NCDisplay() as display: - result = run_xenon_prov( + result = run_xenon( C, Xe, "cache.json", 2, xenon_config, job_config, display=display) From 975cbadddcf1d63ab8af8f6d5cd4a9c37b2b1a78 Mon Sep 17 00:00:00 2001 From: Joris Borgdorff Date: Mon, 8 Aug 2016 16:07:07 +0200 Subject: [PATCH 005/155] Defer xenon.init to the XenonKeeper() constructor --- noodles/run/xenon/xenon.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/noodles/run/xenon/xenon.py b/noodles/run/xenon/xenon.py index dfc2b71..88a26e6 100644 --- a/noodles/run/xenon/xenon.py +++ b/noodles/run/xenon/xenon.py @@ -10,12 +10,6 @@ import sys -# from contextlib import redirect_stderr -# xenon_log = open('xenon_log.txt', 'w') -# with redirect_stderr(xenon_log): -xenon.init(log_level='ERROR') # noqa - - class XenonConfig: """Configuration to the Xenon library. @@ -186,7 +180,13 @@ def interactive(self): class XenonKeeper: + is_initialized = False + def __init__(self): + if not XenonKeeper.is_initialized: + xenon.init(log_level='ERROR') # noqa + XenonKeeper.is_initialized = True + self._x = xenon.Xenon() self.jobs = self._x.jobs() self.credentials = self._x.credentials() From 345402f6858e087b9d1dc47c0db2a75e56c419da Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Mon, 22 Aug 2016 11:20:19 +0200 Subject: [PATCH 006/155] mod xenon test --- test/test_xenon_local.py | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/test/test_xenon_local.py b/test/test_xenon_local.py index 3f4f560..288d9bd 100644 --- a/test/test_xenon_local.py +++ b/test/test_xenon_local.py @@ -11,12 +11,7 @@ import noodles from noodles.display import (NCDisplay) from noodles import serial -from noodles.tutorial import (mul, sub, accumulate) - - -@noodles.schedule_hint(display="{a} + {b}", confirm=True) -def log_add(a, b): - return a + b +from noodles.tutorial import (log_add, mul, sub, accumulate) def test_xenon_42(): From bc0ec0089ecdec35247437ef6fbc16e4361e31ae Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Mon, 22 Aug 2016 11:22:52 +0200 Subject: [PATCH 007/155] remove superfluous patches --- patches/jnius-patch.diff | 26 -------------------------- 1 file changed, 26 deletions(-) delete mode 100644 patches/jnius-patch.diff diff --git a/patches/jnius-patch.diff b/patches/jnius-patch.diff deleted file mode 100644 index e6ea0e5..0000000 --- a/patches/jnius-patch.diff +++ /dev/null @@ -1,26 +0,0 @@ -diff --git a/setup.py b/setup.py -index b3c422d..8df0dca 100644 ---- a/setup.py -+++ b/setup.py -@@ -12,13 +12,14 @@ PY3 = sys.version_info >= (3,0,0) - - def getenv(key): - val = environ.get(key) -- if val is not None: -- if PY3: -- return val.decode() -- else: -- return val -- else: -- return val -+ return val -+# if val is not None: -+# if PY3: -+# return val.decode() -+# else: -+# return val -+# else: -+# return val - - files = [ - 'jni.pxi', From 5426e564ccca2a50f328c8914476bd1f6a68406c Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Mon, 22 Aug 2016 11:24:40 +0200 Subject: [PATCH 008/155] remove very old and unused `lib` folder --- lib/__init__.py | 2 -- lib/exceptions.py | 48 ----------------------------------------------- 2 files changed, 50 deletions(-) delete mode 100644 lib/__init__.py delete mode 100644 lib/exceptions.py diff --git a/lib/__init__.py b/lib/__init__.py deleted file mode 100644 index 10247a0..0000000 --- a/lib/__init__.py +++ /dev/null @@ -1,2 +0,0 @@ -from .exceptions import * - diff --git a/lib/exceptions.py b/lib/exceptions.py deleted file mode 100644 index e245935..0000000 --- a/lib/exceptions.py +++ /dev/null @@ -1,48 +0,0 @@ - -def _ordinal(n): - """ - Ugly hack to get ordinal number. Is there an internationalized solution - to this? - """ - return "%d%s" % (n,"tsnrhtdd"[(n/10%10!=1)*(n%10<4)*n%10::4]) - -class MissingArgument(Exception): - def __init__(self, func_name, pos, arg_name, doc): - self.msg = "Missing {rank} argument '{arg}'" \ - " in scheduling function call to '{func}'." \ - .format(rank = _ordinal(pos), arg = arg_name, func = func_name) - self.doc = doc if doc else "This function is not documented" - - def __str__(self): - return self.msg + "\n" + self.doc - -class DuplicateArgument(Exception): - def __init__(self, func_name, pos, arg_name, doc): - self.msg = "Duplicate argument '{arg}'; already given as {rank}" \ - " argument in call to '{func}'." \ - .format(arg = arg_name, rank = _ordinal(pos), func = func_name) - self.doc = doc if doc else "This function is not documented" - - def __str__(self): - return self.msg + "\n" + self.doc - -class SpuriousArgument(Exception): - def __init__(self, func_name, nargs, ngiven, doc): - self.msg = "Too many arguments; '{func}' takes {nargs} regular" \ - " arguments and does not take variadic arguments;" \ - " {ngiven} arguments given." \ - .format(func = func_name, nargs = nargs, ngiven = ngiven) - self.doc = doc if doc else "This function is not documented" - - def __str__(self): - return self.msg + "\n" + self.doc - -class SpuriousKeywordArgument(Exception): - def __init__(self, func_name, doc): - self.msg = "Function '{func}' does not take keyword arguments." \ - .format(func = func_name) - self.doc = doc if doc else "This function is not documented" - - def __str__(self): - return self.msg + "\n" + self.doc - From aeaade328429eb6b13fb54e09df8da195cbbdcaa Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Mon, 22 Aug 2016 13:19:07 +0200 Subject: [PATCH 009/155] fixes issue #31 --- examples/boil/boil | 8 +++---- noodles/display/simple_nc.py | 45 ++++++++++++++++++++++++++++-------- test/test_broker.py | 12 ++++------ test/test_xenon_local.py | 2 +- 4 files changed, 46 insertions(+), 21 deletions(-) diff --git a/examples/boil/boil b/examples/boil/boil index 95cb231..5e3c58a 100755 --- a/examples/boil/boil +++ b/examples/boil/boil @@ -86,7 +86,7 @@ def object_filename(srcdir, filename, config): return os.path.join(target_dir, basename + '.o') -@noodles.schedule_hint(display="│ Compiling {source_file} ... ", +@noodles.schedule_hint(display=" Compiling {source_file} ... ", confirm=True, annotated=True) def compile_source(source_file, object_file, config): @@ -118,7 +118,7 @@ def get_object_file(src_dir, src_file, config): return obj_path -@noodles.schedule_hint(display="│ Linking ... ", +@noodles.schedule_hint(display=" Linking ... ", confirm=True, annotated=True) def link(object_files, config): @@ -147,10 +147,10 @@ def get_target(obj_files, config): if is_out_of_date(config['target'], obj_files): return link(obj_files, config) else: - return message("│ target is up-to-date.") + return message("target is up-to-date.") -@noodles.schedule_hint(display="╭─(Building target {config[target]})") +@noodles.schedule_hint(display="Building target {config[target]}") def make_target(config): """Make a target. First compiles the source files, then links the object files to create an executable. diff --git a/noodles/display/simple_nc.py b/noodles/display/simple_nc.py index 1bde5f5..44f66f1 100644 --- a/noodles/display/simple_nc.py +++ b/noodles/display/simple_nc.py @@ -12,20 +12,45 @@ class Display: 'check' Makes sure that the user gets feedback on the success or failure of the job, meaning a green V or red X will appear behind the .""" - def __init__(self, error_filter=None): + def __init__(self, error_filter=None, title='running jobs'): self.jobs = {} self.out = OutStream(sys.stdout) self.errors = [] self.error_filter = error_filter or (lambda e: None) self.messages = [] + ascii_chars = { + 'check': 'V', + 'fail': 'X', + 'line-hor': '-', + 'line-ver': '|', + 'line-tl': '+', + 'line-bl': '+' + } + + utf8_chars = { + 'check': '✔', + 'fail': '✘', + 'line-hor': '─', + 'line-ver': '│', + 'line-tl': '╭', + 'line-bl': '╰' + } + + self.chars = utf8_chars \ + if sys.stdout.encoding == 'UTF-8' \ + else ascii_chars + + self.out << self.chars['line-tl'] << self.chars['line-hor'] \ + << '(' << title << ')' << "\n" + def start(self, key, job, _): if job.hints and 'display' in job.hints: if key not in self.jobs: msg = job.hints['display'].format( **job.bound_args.arguments)[:70] self.add_job(key, job, msg) - self.out << msg << "\n" + self.out << self.chars['line-ver'] << " " << msg << "\n" else: self.out << ['save'] << ['up', self.jobs[key]['line']] \ << ['forward', max(50, self.jobs[key]['length'] + 2)] @@ -35,8 +60,8 @@ def done(self, key, data, msg): if key in self.jobs and 'confirm' in self.jobs[key]: self.out << ['save'] << ['up', self.jobs[key]['line']] \ << ['forward', max(50, self.jobs[key]['length'] + 2)] - self.out << "(" << ['fg', 60, 180, 100] << "✔" << ['reset'] \ - << ")" << ['restore'] + self.out << "(" << ['fg', 60, 180, 100] << self.chars['check'] \ + << ['reset'] << ")" << ['restore'] if key in self.jobs and msg: self.message_handler(self.jobs[key], msg) @@ -45,7 +70,7 @@ def schedule(self, key, job, _): if job.hints and 'display' in job.hints: msg = job.hints['display'].format(**job.bound_args.arguments)[:70] self.add_job(key, job, msg) - self.out << "│ " << msg << "\n" + self.out << self.chars['line-ver'] << " " << msg << "\n" def retrieved(self, key, data, msg): if key in self.jobs and 'confirm' in self.jobs[key]: @@ -61,8 +86,8 @@ def error(self, key, _, data): if key in self.jobs and 'confirm' in self.jobs[key]: self.out << ['save'] << ['up', self.jobs[key]['line']] \ << ['forward', max(50, self.jobs[key]['length'] + 2)] - self.out << "(" << ['fg', 240, 100, 60] << "✘" << ['reset'] \ - << ")" << ['restore'] + self.out << "(" << ['fg', 240, 100, 60] << self.chars['fail'] \ + << ['reset'] << ")" << ['restore'] def add_job(self, key, job, msg): for k in self.jobs: @@ -83,7 +108,8 @@ def message_handler(self, job, warning): def report(self): if len(self.errors) == 0: - self.out << "╰─(success)\n" + self.out << self.chars['line-bl'] << self.chars['line-hor'] \ + << "(success)\n" if len(self.messages) != 0: self.out << "There were warnings: \n\n" @@ -101,7 +127,8 @@ def report(self): print(w) else: - self.out << "╰─(" << ['fg', 240, 100, 60] << "ERROR!" \ + self.out << self.chars['line-bl'] << self.chars['line-hor'] \ + << "(" << ['fg', 240, 100, 60] << "ERROR!" \ << ['reset'] << ")\n\n" for job, e in self.errors: diff --git a/test/test_broker.py b/test/test_broker.py index c9ba763..0e0342f 100644 --- a/test/test_broker.py +++ b/test/test_broker.py @@ -1,8 +1,8 @@ import noodles from noodles.tutorial import (add, sub, mul, accumulate) from noodles.display import (NCDisplay) -from noodles.run.runners import (run_single, run_parallel, run_parallel_with_display) -import time +from noodles.run.runners import ( + run_single, run_parallel, run_parallel_with_display) def test_broker_01(): @@ -25,7 +25,7 @@ def test_broker_02(): assert run_single(C) == 42 -@noodles.schedule_hint(display="│ {a} + {b}", confirm=True) +@noodles.schedule_hint(display="{a} + {b}", confirm=True) def log_add(a, b): return a + b @@ -41,8 +41,6 @@ def test_broker_logging(): multiples = [mul(log_add(i, B), A) for i in range(6)] C = accumulate(noodles.gather(*multiples)) - wf = message("\n╭─(Running the test)", lambda: C) - - with NCDisplay() as display: - assert run_parallel_with_display(wf, 4, display) == 42 + with NCDisplay(title="Running the test") as display: + assert run_parallel_with_display(C, 4, display) == 42 diff --git a/test/test_xenon_local.py b/test/test_xenon_local.py index 3f4f560..5cad9d7 100644 --- a/test/test_xenon_local.py +++ b/test/test_xenon_local.py @@ -32,7 +32,7 @@ def test_xenon_42(): job_config = RemoteJobConfig( registry=serial.base, - time_out=1 + time_out=1000 ) with XenonKeeper() as Xe, NCDisplay() as display: From bf18672b6234476f7b4e71885f5c5efd5e45067d Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Mon, 22 Aug 2016 13:56:56 +0200 Subject: [PATCH 010/155] version 0.2.0 --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index 439e3e9..0c0bfb2 100755 --- a/setup.py +++ b/setup.py @@ -12,7 +12,7 @@ setup( name='Noodles', - version='0.1.9301', + version='0.2.0', description='Workflow Engine', author='Johan Hidding', url='https://github.com/NLeSC/noodles', From 9dd602071884d3165790e574e63b391e2a5d05e8 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Mon, 22 Aug 2016 14:03:57 +0200 Subject: [PATCH 011/155] version 0.2.1, updated version number --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index 0c0bfb2..b041112 100755 --- a/setup.py +++ b/setup.py @@ -12,7 +12,7 @@ setup( name='Noodles', - version='0.2.0', + version='0.2.1', description='Workflow Engine', author='Johan Hidding', url='https://github.com/NLeSC/noodles', From 0442faec7472568997ed5981b4ed51ff31e7ac96 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Fri, 2 Sep 2016 15:02:00 +0200 Subject: [PATCH 012/155] add namedtuple serialisation --- noodles/serial/namedtuple.py | 12 ++++++++++++ test/test_namedtuple.py | 20 ++++++++++++++++++++ 2 files changed, 32 insertions(+) create mode 100644 noodles/serial/namedtuple.py create mode 100644 test/test_namedtuple.py diff --git a/noodles/serial/namedtuple.py b/noodles/serial/namedtuple.py new file mode 100644 index 0000000..b6e07ba --- /dev/null +++ b/noodles/serial/namedtuple.py @@ -0,0 +1,12 @@ +from .registry import (Serialiser) + + +class SerNamedTuple(Serialiser): + def __init__(self, cls): + super(SerNamedTuple, self).__init__(cls) + + def encode(self, obj, make_rec): + return make_rec(tuple(obj)) + + def decode(self, cls, data): + return cls(*data) diff --git a/test/test_namedtuple.py b/test/test_namedtuple.py new file mode 100644 index 0000000..0e55445 --- /dev/null +++ b/test/test_namedtuple.py @@ -0,0 +1,20 @@ +from collections import namedtuple +from noodles.serial.namedtuple import SerNamedTuple +from noodles.serial import (Registry, base) + +A = namedtuple('A', ['x', 'y']) + + +def registry(): + return Registry( + parent=base(), + types={ + A: SerNamedTuple(A) + }) + + +def test_namedtuple_00(): + a = A(73, 38) + r = registry() + assert r.deep_decode(r.deep_encode(a)) == a + From 7fdf410e6a758e7da52d6aea8d5cd77d9b11f4bb Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Fri, 2 Sep 2016 15:37:02 +0200 Subject: [PATCH 013/155] add optional automatic namedtuple serialisation, not 100% reliable, tests wether object is tuple and has `_fields` attribute. --- noodles/serial/__init__.py | 3 ++- noodles/serial/namedtuple.py | 35 ++++++++++++++++++++++++++++++++++- test/test_namedtuple.py | 20 +++++++++++++++----- 3 files changed, 51 insertions(+), 7 deletions(-) diff --git a/noodles/serial/__init__.py b/noodles/serial/__init__.py index 67fb63a..e9a062a 100644 --- a/noodles/serial/__init__.py +++ b/noodles/serial/__init__.py @@ -2,7 +2,8 @@ from .pickle import registry as pickle from .base import registry as base from .as_dict import AsDict +from .namedtuple import registry as namedtuple from .registry import (Registry, Serialiser, RefObject) __all__ = ['pickle', 'base', 'Registry', 'Serialiser', - 'RefObject', 'AsDict'] + 'RefObject', 'AsDict', 'namedtuple'] diff --git a/noodles/serial/namedtuple.py b/noodles/serial/namedtuple.py index b6e07ba..8300af8 100644 --- a/noodles/serial/namedtuple.py +++ b/noodles/serial/namedtuple.py @@ -1,4 +1,5 @@ -from .registry import (Serialiser) +from .registry import (Registry, Serialiser) +from ..utility import (object_name, look_up) class SerNamedTuple(Serialiser): @@ -10,3 +11,35 @@ def encode(self, obj, make_rec): def decode(self, cls, data): return cls(*data) + + +class SerAutoNamedTuple(Serialiser): + def __init__(self): + super(SerAutoNamedTuple, self).__init__('') + + def encode(self, obj, make_rec): + return make_rec({ + 'name': object_name(type(obj)), + 'data': tuple(obj)}) + + def decode(self, cls, data): + return look_up(data['name'])(*data['data']) + + +def is_namedtuple(obj): + return isinstance(obj, tuple) and hasattr(obj, '_fields') + + +def namedtuple_hook(obj): + if is_namedtuple(obj): + return '' + else: + return None + + +def registry(): + return Registry( + hooks={ + '': SerAutoNamedTuple() + }, + hook_fn=namedtuple_hook) diff --git a/test/test_namedtuple.py b/test/test_namedtuple.py index 0e55445..09921de 100644 --- a/test/test_namedtuple.py +++ b/test/test_namedtuple.py @@ -1,20 +1,30 @@ from collections import namedtuple -from noodles.serial.namedtuple import SerNamedTuple -from noodles.serial import (Registry, base) +from noodles import serial +from noodles.serial.namedtuple import (SerNamedTuple) +from noodles.serial import (Registry) A = namedtuple('A', ['x', 'y']) +B = namedtuple('B', ['u', 'v']) -def registry(): +def registry1(): return Registry( - parent=base(), + parent=serial.base(), types={ A: SerNamedTuple(A) }) +def registry2(): + return serial.base() + serial.namedtuple() + + def test_namedtuple_00(): a = A(73, 38) - r = registry() + r = registry1() assert r.deep_decode(r.deep_encode(a)) == a + b = B(783, 837) + r = registry2() + print(r.deep_encode(b)) + assert r.deep_decode(r.deep_encode(b)) == b From 45908d31e224b8eca30ed6a0762aa87c6ce8231e Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Thu, 22 Sep 2016 11:12:26 +0200 Subject: [PATCH 014/155] changed numpy serialisation to give base64 string, needs to go to hdf5 storage --- doc/source/boil_tutorial.rst | 2 +- doc/source/eating.rst | 55 +++++++++++++++++++++++------------- doc/source/index.rst | 55 +++++++++++++++++++++--------------- noodles/serial/numpy.py | 15 ++++++---- 4 files changed, 78 insertions(+), 49 deletions(-) diff --git a/doc/source/boil_tutorial.rst b/doc/source/boil_tutorial.rst index 2fa16ca..fe143db 100644 --- a/doc/source/boil_tutorial.rst +++ b/doc/source/boil_tutorial.rst @@ -47,7 +47,7 @@ The function for linking object files to an executable looks very similar:: return config['target'] -In this case the function takes a list of object file names and the same configuration object that we saw before. Again, this function returns the name of the target executable file. The caller of this function already knows the name of the target file, but we need it to track dependencies. +In this case the function takes a list of object file names and the same configuration object that we saw before. Again, this function returns the name of the target executable file. The caller of this function already knows the name of the target file, but we need it to track dependencies between function calls. Since both the :py:func:`link` and the :py:func:`compile_source` functions do actual work that we'd like to see being done in a concurrent environment, they need to be decorated with the :py:func:`schedule` decorator. diff --git a/doc/source/eating.rst b/doc/source/eating.rst index 16f01a6..5a17aab 100644 --- a/doc/source/eating.rst +++ b/doc/source/eating.rst @@ -195,9 +195,12 @@ If you need to setup some more aspects of the environment, load modules, set var :: - from noodles import schedule, Scheduler, gather - from noodles.datamodel import get_workflow - from noodles.run_xenon import xenon_interactive_worker, XenonConfig + from noodles import ( + serial, gather) + from noodles.run.xenon import ( + XenonConfig, RemoteJobConfig, XenonKeeper, run_xenon_prov) + from noodles.display import ( + NCDisplay) from noodles.tutorial import add, accumulate @@ -205,24 +208,40 @@ If you need to setup some more aspects of the environment, load modules, set var a = [add(i, j) for i in range(5) for j in range(5)] b = accumulate(gather(*a)) - config = XenonConfig() # use default settings - config.working_dir = sys.getcwd() # this actually is the default - config.prefix = sys.prefix # virtual-env prefix or just '/usr' - - # options given to Xenon.newScheduler() - config.schedule_args = ('ssh', 'localhost', None, None) - - result = Scheduler().run( - xenon_interactive_worker(config), - get_workflow(b)) + # XenonKeeper is the root Xenon object that gives access + # to the Xenon Java library + with XenonKeeper() as Xe: + # We recommend loging in on your compute resource + # through private/public key pairs. This prevents + # passwords ending up as ASCII in your source files. + certificate = Xe.credentials.newCertificateCredential( + 'ssh', os.environ['HOME'] + '/.ssh/id_rsa', '', '', None) + + # Configure Xenon to access your favourite super computer. + xenon_config = XenonConfig( + jobs_scheme='slurm', + location='login.super-duper-computer.darpa.net', + credential=certificate + ) + + # Specify how to submit jobs. + job_config = RemoteJobConfig( + registry=serial.base, + prefix='', + working_dir='', + time_out=5000 + ) + + + # Run jobs with NCurses based console feedback + with NCDisplay() as display: + result = run_xenon_prov( + b, Xe, "cache.json", 2, xenon_config, job_config, + display=display) print("This test is working {0}%!".format(result)) -Fireworks -~~~~~~~~~ -Fireworks_ is a workflow engine that runs workflows as stored in a MongoDB. This is the `Dicke Bertha`_ in our armoury. Fireworks support is still in an early stage of development. The advantage of Fireworks is that it is here, it works and it is robust. However, it may be a hassle with the system admins to setup a MongoDB and be allowed to communicate with it from within the cluster environment. - Hybrid mode ~~~~~~~~~~~ We may have a situation where a workflow consists of some very heavy *compute* jobs and a lot of smaller jobs that do some bookkeeping. If we were to schedule all the menial jobs to a SLURM queue we actually slow down the computation through the overhead of job submission. The Noodles cook may provide the schedule functions with hints on the type of job the function represents. Depending on these hints we may dispatch the job to a remote worker or keep it on the local machine. @@ -231,7 +250,5 @@ We provide an example on how to use the hybrid worker in the source. If you really need to, it is not too complicated to develop your own job runner based on some of these examples. Elsewhere in this documentation we elaborate on the architecture and interaction between runners and the scheduler, see: :ref:`noodles-scheduler`. -.. _Fireworks: https://pythonhosted.org/FireWorks/index.html -.. _Dicke Bertha: https://en.wikipedia.org/wiki/Big_Bertha_%28howitzer%29 .. _Xenon: http://nlesc.github.io/Xenon/ .. _pyxenon: http://github.com/NLeSC/pyxenon diff --git a/doc/source/index.rst b/doc/source/index.rst index 7ca1ce9..5fc83fe 100644 --- a/doc/source/index.rst +++ b/doc/source/index.rst @@ -6,23 +6,10 @@ Welcome to Noodles's documentation! =================================== -Contents: - -.. toctree:: - :maxdepth: 2 - - Introduction - eating - cooking - first_steps - poetry_tutorial - boil_tutorial - development - scheduler - brokers - Introduction -============ +------------ +Noodles offers a model for parallel programming in Python. It can be used for a variety of tasks including data pipelines, and computational workflows. + The primary goal of Noodles is to make it easy to run jobs on cluster supercomputers, in parallel, straight from a Python shell. The user enters a Python script that looks and feels like a serial program. The Noodles engine then converts this script into a call graph. This graph can be executed on a variety of machines using the different back-end runners that Noodles provides. This is not so much a design driven by technology but by social considerations. The end user may expect an elegant, easy to understand, interface to a computational library. This user experience we refer to as *eating of noodles*. The computational library that is exposed to the user by means of Noodles needs to adhere to some design principles that are more strict than plain Python gives us. The library should follow a functional style of programming and is limited by the fact that function arguments need to pass through a layer where data is converted to and from a JSON format. The design of such a library is the *cooking of noodles*. As it is with ramen noodles, ofttimes the cook is also an avid consumer of noodles. @@ -45,21 +32,43 @@ The core of Noodles runs on **Python 3.5**. To run Noodles on your own machine, .. code-block:: bash - # pyxenon needs Java, which may needs JAVA_HOME set, put it in .bashrc + # pyxenon needs Java, which may need JAVA_HOME to be set, put it in .bashrc export JAVA_HOME="/usr/lib/jvm/default-java" # or similar... # create the virtualenv - pyvenv-3.5 + virtualenv -p python3 . /bin/activate # install noodles - cd noodles # git pull git@github.com:NLeSC/noodles.git - pip install -r requirements.txt - pip install . + pip install noodles + +Noodles has several optional dependencies. To be able to use the Xenon job scheduler, install Noodles with:: -.. NOTE:: In the future this will reduce to `pip install noodles`. + pip install noodles[xenon] -To run the nosetests, you will need passwordless access to localhost with ssh. This is achieved by appending ``.ssh/id_rsa.pub`` to ``.ssh/authorized_keys``. If ``id_rsa.pub`` does not yet exist, generate it (GitHub has a good article on `generating SSH keys`_). +The provenance/caching feature needs TinyDB installed:: + + pip install noodles[prov] + +To be able to run the unit tests:: + + pip install noodles[test] + +Documentation Contents +====================== + +.. toctree:: + :maxdepth: 2 + + Introduction + eating + cooking + first_steps + poetry_tutorial + boil_tutorial + development + scheduler + brokers Indices and tables ================== diff --git a/noodles/serial/numpy.py b/noodles/serial/numpy.py index 5581221..b831ca3 100644 --- a/noodles/serial/numpy.py +++ b/noodles/serial/numpy.py @@ -2,20 +2,23 @@ from ..utility import look_up import numpy import uuid +import io +import base64 class SerNumpyArray(Serialiser): def __init__(self, file_prefix=None): super(SerNumpyArray, self).__init__(numpy.ndarray) - self.file_prefix = file_prefix if file_prefix else '' + # self.file_prefix = file_prefix if file_prefix else '' def encode(self, obj, make_rec): - filename = self.file_prefix + str(uuid.uuid4()) + '.npy' - numpy.save(filename, obj) - return make_rec(filename, ref=True, files=[filename]) + fo = io.BytesIO() + numpy.save(fo, obj, allow_pickle=False) + return make_rec(base64.b64encode(fo.getvalue()).decode()) - def decode(self, cls, filename): - return numpy.load(filename) + def decode(self, cls, data): + fi = io.BytesIO(base64.b64decode(data.encode())) + return numpy.load(fi) class SerUFunc(Serialiser): From dd7f33dd85a07c78a683fcf917ff9a7add33a653 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Thu, 22 Sep 2016 11:33:47 +0200 Subject: [PATCH 015/155] fix numpy serialisation tests, restore option for .npy files behaviour --- noodles/serial/numpy.py | 36 ++++++++++++++++++++++++++++++++---- test/test_numpy.py | 8 ++++---- 2 files changed, 36 insertions(+), 8 deletions(-) diff --git a/noodles/serial/numpy.py b/noodles/serial/numpy.py index b831ca3..ad5d902 100644 --- a/noodles/serial/numpy.py +++ b/noodles/serial/numpy.py @@ -7,9 +7,8 @@ class SerNumpyArray(Serialiser): - def __init__(self, file_prefix=None): + def __init__(self): super(SerNumpyArray, self).__init__(numpy.ndarray) - # self.file_prefix = file_prefix if file_prefix else '' def encode(self, obj, make_rec): fo = io.BytesIO() @@ -21,6 +20,20 @@ def decode(self, cls, data): return numpy.load(fi) +class SerNumpyArrayToFile(Serialiser): + def __init__(self, file_prefix=None): + super(SerNumpyArrayToFile, self).__init__(numpy.ndarray) + self.file_prefix = file_prefix if file_prefix else '' + + def encode(self, obj, make_rec): + filename = self.file_prefix + str(uuid.uuid4()) + '.npy' + numpy.save(filename, obj) + return make_rec(filename, ref=True, files=[filename]) + + def decode(self, cls, filename): + return numpy.load(filename) + + class SerUFunc(Serialiser): def __init__(self): super(SerUFunc, self).__init__(None) @@ -39,16 +52,31 @@ def _numpy_hook(obj): return None -def registry(file_prefix=None): +def arrays_to_file(file_prefix=None): """Returns a serialisation registry for serialising NumPy data and as well as any UFuncs that have no normal way of retrieving qualified names.""" return Registry( types={ - numpy.ndarray: SerNumpyArray(file_prefix) + numpy.ndarray: SerNumpyArrayToFile(file_prefix) + }, + hooks={ + '': SerUFunc() + }, + hook_fn=_numpy_hook + ) + + +def arrays_to_string(file_prefix=None): + return Registry( + types={ + numpy.ndarray: SerNumpyArray() }, hooks={ '': SerUFunc() }, hook_fn=_numpy_hook ) + +registry = arrays_to_string + diff --git a/test/test_numpy.py b/test/test_numpy.py index d9113e0..30dbb4a 100644 --- a/test/test_numpy.py +++ b/test/test_numpy.py @@ -1,11 +1,10 @@ from nose.plugins.skip import SkipTest try: - import numpy import numpy as np from numpy import (random, fft, exp) - from noodles.serial.numpy import registry as numpy_registry + from noodles.serial.numpy import arrays_to_file except ImportError: raise SkipTest("No NumPy installed.") @@ -13,11 +12,11 @@ from noodles import schedule, run_process, serial import os -from shutil import (copyfile, rmtree) +from shutil import (rmtree) def registry(): - return serial.base() + numpy_registry(file_prefix='test-numpy/') + return serial.base() + arrays_to_file(file_prefix='test-numpy/') @schedule @@ -44,6 +43,7 @@ def apply_filter(a, b): def make_noise(n): return random.normal(0, 1, n) + def test_pickle(): x = make_noise(256) k = make_kernel(256, 10) From 9f62dfcf045e6524ec57bff8b8951cd4a585c14d Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Tue, 18 Oct 2016 12:12:52 +0200 Subject: [PATCH 016/155] serialisation for objects that define `__setstate__` and `__getstate__` --- noodles/serial/base.py | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/noodles/serial/base.py b/noodles/serial/base.py index 7610ef8..bf5225d 100644 --- a/noodles/serial/base.py +++ b/noodles/serial/base.py @@ -149,6 +149,19 @@ def decode(self, cls, data): return FunctionNode.from_node_data(NodeData(**data)) +class SerMagic(Serialiser): + def __init__(self): + super(SerMagic, self).__init__() + + def encode(self, obj, make_rec): + return make_rec(obj.__getstate__()) + + def decode(self, cls, data): + obj = cls.__new__(cls) + obj.__setstate__(data) + return obj + + def _noodles_hook(obj): if '__member_of__' in dir(obj) and obj.__member_of__: return '' @@ -162,6 +175,9 @@ def _noodles_hook(obj): if isfunction(obj): return '' + if hasattr(obj, '__setstate__') and hasattr(obj, '__getstate__'): + return '' + return None @@ -179,7 +195,8 @@ def registry(): }, hooks={ '': SerMethod(), - '': SerImportable() + '': SerImportable(), + '': SerMagic(), # '': SerAutoStorable() }, hook_fn=_noodles_hook, From 54470a2f28abab4617544e87bd4792ec5db875d7 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Tue, 18 Oct 2016 12:16:19 +0200 Subject: [PATCH 017/155] changed -init and -finish to need string arg --- noodles/run/xenon/dynamic_pool.py | 26 +++++++++++++----------- noodles/run/xenon/runner.py | 3 ++- noodles/run/xenon/xenon.py | 6 ++++-- noodles/worker.py | 33 +++++++++---------------------- 4 files changed, 30 insertions(+), 38 deletions(-) diff --git a/noodles/run/xenon/dynamic_pool.py b/noodles/run/xenon/dynamic_pool.py index 72494f0..3a7711a 100644 --- a/noodles/run/xenon/dynamic_pool.py +++ b/noodles/run/xenon/dynamic_pool.py @@ -93,17 +93,21 @@ def __init__(self, sched, job_config): def init_worker(self): """Sends the `init` and `finish` jobs to the worker if this is needed. This part will be called first, after a remote worker goes online.""" - if self.job_config.init is not None: - self.sink().send( - ("init", self.job_config.init()._workflow.root_node)) - key, status, result, err_msg = next(self.source()) - if key != "init" or not result: - raise RuntimeError( - "The initializer function did not succeed on worker.") - - if self.job_config.finish is not None: - self.sink().send( - ("finish", self.job_config.finish()._workflow.root_node)) + pass + # print("Initializing worker: ", end='', flush=True) + # if self.job_config.init is not None: + # print("[init] ", end='', flush=True) + # self.sink().send( + # ("init", self.job_config.init()._workflow.root_node)) + # key, status, result, err_msg = next(self.source()) + # if key != "init" or not result: + # raise RuntimeError( + # "The initializer function did not succeed on worker.") + # + # if self.job_config.finish is not None: + # self.sink().send( + # ("finish", self.job_config.finish()._workflow.root_node)) + # print("[done]", flush=True) def wait_until_running(self, callback=None): """Waits until the remote worker is running, then calls the callback. diff --git a/noodles/run/xenon/runner.py b/noodles/run/xenon/runner.py index 15856e5..bf163e2 100644 --- a/noodles/run/xenon/runner.py +++ b/noodles/run/xenon/runner.py @@ -16,7 +16,8 @@ pass else: def run_xenon_prov(wf, Xe, jobdb_file, n_processes, xenon_config, - job_config, *, deref=False, job_keeper=None, display=None): + job_config, *, deref=False, job_keeper=None, + display=None): """Run the workflow using a number of online Xenon workers. :param Xe: diff --git a/noodles/run/xenon/xenon.py b/noodles/run/xenon/xenon.py index 88a26e6..85f5e81 100644 --- a/noodles/run/xenon/xenon.py +++ b/noodles/run/xenon/xenon.py @@ -130,10 +130,12 @@ def command_line(self): '-registry', object_name(self.registry)] if self.init: - cmd.append("-init") + cmd.extend(["-init", object_name(self.init)]) + # cmd.append("-init") if self.finish: - cmd.append("-finish") + cmd.extend(["-finish", object_name(self.finish)]) + # cmd.append("-finish") if self.verbose: cmd.append("-verbose") diff --git a/noodles/worker.py b/noodles/worker.py index 3ac0503..cb2993a 100644 --- a/noodles/worker.py +++ b/noodles/worker.py @@ -87,28 +87,11 @@ def msg_stream(): # run the init function if it is given if args.init: - # line = sys.stdin.readline() - key, job = get_job(next(messages)) - if key != 'init': - raise RuntimeError("Expected init function.") - with redirect_stdout(sys.stderr): - result = run_job(key, job) - - if args.msgpack: - sys.stdout.buffer.write(put_result_msgpack( - registry, args.name, *result)) - sys.stdout.flush() - else: - print(put_result_json(registry, args.name, *result), - flush=True) + look_up(args.init)() if args.finish: - # line = sys.stdin.readline() - key, job = get_job(next(messages)) - if key != 'finish': - raise RuntimeError("Expected finish function.") - finish = job + finish = look_up(args.finish) for msg in messages: key, job = get_job(msg) @@ -148,7 +131,7 @@ def msg_stream(): flush=True) if finish: - run_job(0, finish) + finish() if __name__ == "__main__": @@ -201,11 +184,13 @@ def msg_stream(): help="worker identity", default="worker-" + str(uuid.uuid4())) online_parser.add_argument( - "-init", help="an init function will be send before other jobs", - default=False, action='store_true') + "-init", type=str, + help="an init function will be send before other jobs", + default=None) online_parser.add_argument( - "-finish", help="a finish function will be send before other jobs", - default=False, action='store_true') + "-finish", type=str, + help="a finish function will be send before other jobs", + default=None) online_parser.set_defaults(func=run_online_mode) From 9055185bdf3469c3811f323e046ed1aa58fe08d5 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Tue, 18 Oct 2016 13:42:35 +0200 Subject: [PATCH 018/155] fix serialiser --- noodles/serial/base.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/noodles/serial/base.py b/noodles/serial/base.py index bf5225d..74cf6f3 100644 --- a/noodles/serial/base.py +++ b/noodles/serial/base.py @@ -151,7 +151,7 @@ def decode(self, cls, data): class SerMagic(Serialiser): def __init__(self): - super(SerMagic, self).__init__() + super(SerMagic, self).__init__('') def encode(self, obj, make_rec): return make_rec(obj.__getstate__()) From aa6de12c494d67979523ea2ebfead7060dedf2d3 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Tue, 18 Oct 2016 14:38:20 +0200 Subject: [PATCH 019/155] fix serialiser #2 --- noodles/serial/base.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/noodles/serial/base.py b/noodles/serial/base.py index 74cf6f3..434959d 100644 --- a/noodles/serial/base.py +++ b/noodles/serial/base.py @@ -154,11 +154,13 @@ def __init__(self): super(SerMagic, self).__init__('') def encode(self, obj, make_rec): - return make_rec(obj.__getstate__()) + return make_rec({'type': object_name(type(obj)), + 'data': obj.__getstate__()}) - def decode(self, cls, data): + def decode(self, _, data): + cls = look_up(data['type']) obj = cls.__new__(cls) - obj.__setstate__(data) + obj.__setstate__(data['data']) return obj From 6859f5dd9bdaeb3543722a5709c191b83a8b5786 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Tue, 18 Oct 2016 15:51:13 +0200 Subject: [PATCH 020/155] do away with , just derive from Storabel --- noodles/serial/base.py | 39 +++------------------------------------ 1 file changed, 3 insertions(+), 36 deletions(-) diff --git a/noodles/serial/base.py b/noodles/serial/base.py index 434959d..51b2843 100644 --- a/noodles/serial/base.py +++ b/noodles/serial/base.py @@ -125,19 +125,6 @@ def decode(self, _, data): return cls.from_dict(**data['dict']) -class SerAutoStorable(Serialiser): - def __init__(self, cls): - super(SerAutoStorable, self).__init__(cls) - - def encode(self, obj, make_rec): - return make_rec({'type': object_name(type(obj)), - 'dict': obj.as_dict()}) - - def decode(self, _, data): - cls = look_up(data['type']) - return cls.from_dict(**data['dict']) - - class SerNode(Serialiser): def __init__(self): super(SerNode, self).__init__(FunctionNode) @@ -149,36 +136,18 @@ def decode(self, cls, data): return FunctionNode.from_node_data(NodeData(**data)) -class SerMagic(Serialiser): - def __init__(self): - super(SerMagic, self).__init__('') - - def encode(self, obj, make_rec): - return make_rec({'type': object_name(type(obj)), - 'data': obj.__getstate__()}) - - def decode(self, _, data): - cls = look_up(data['type']) - obj = cls.__new__(cls) - obj.__setstate__(data['data']) - return obj - - def _noodles_hook(obj): if '__member_of__' in dir(obj) and obj.__member_of__: return '' - # if hasattr(obj, 'as_dict') and hasattr(type(obj), 'from_dict'): - # return '' - if importable(obj): return '' - if isfunction(obj): + if isinstance(obj, type): return '' - if hasattr(obj, '__setstate__') and hasattr(obj, '__getstate__'): - return '' + if isfunction(obj): + return '' return None @@ -198,8 +167,6 @@ def registry(): hooks={ '': SerMethod(), '': SerImportable(), - '': SerMagic(), - # '': SerAutoStorable() }, hook_fn=_noodles_hook, default=Serialiser(object), From 439e81f2f8beb297f3d9eef85fefc36bc4f6faeb Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Tue, 18 Oct 2016 16:06:11 +0200 Subject: [PATCH 021/155] removed autostorable --- noodles/interface/exceptions.py | 14 ++++++--- noodles/run/process.py | 22 +++++++------- noodles/run/run_with_prov.py | 10 ++++-- noodles/serial/base.py | 6 ++-- noodles/serial/numpy.py | 54 ++++++++++++++++++++++++++++++++- 5 files changed, 84 insertions(+), 22 deletions(-) diff --git a/noodles/interface/exceptions.py b/noodles/interface/exceptions.py index fcd1fa0..eebef7a 100644 --- a/noodles/interface/exceptions.py +++ b/noodles/interface/exceptions.py @@ -1,12 +1,18 @@ -class JobException(Exception): +class JobException: def __init__(self, exc_type, exc_value, exc_tb): self.exc_type = exc_type self.exc_value = exc_value - self.exc_tb = exc_tb + # self.exc_tb = exc_tb def reraise(self): - raise self.exc_value.with_traceback(self.exc_tb) + raise self.exc_value def __iter__(self): - return iter((self.exc_type, self.exc_value, self.exc_tb)) + return iter((self.exc_type, self.exc_value, None)) + + # def __getstate__(self): + # return self.__dict__ + # + # def __setstate__(self, state): + # self.__dict__.update(state) diff --git a/noodles/run/process.py b/noodles/run/process.py index 647bd24..81f5e51 100644 --- a/noodles/run/process.py +++ b/noodles/run/process.py @@ -73,9 +73,9 @@ def process_worker(registry, if not status: cmd.append("-nostatus") if init: - cmd.append("-init") + cmd.extend(["-init", object_name(init)]) if finish: - cmd.append("-finish") + cmd.extend(["-finish", object_name(finish)]) p = Popen( cmd, @@ -113,15 +113,15 @@ def get_result(): result = get_result_tuple(msg) yield result - if init is not None: - send_job().send(("init", init()._workflow.root_node)) - key, status, result, err_msg = next(get_result()) - if key != "init" or not result: - raise RuntimeError( - "The initializer function did not succeed on worker.") - - if finish is not None: - send_job().send(("finish", finish()._workflow.root_node)) + # if init is not None: + # send_job().send(("init", init()._workflow.root_node)) + # key, status, result, err_msg = next(get_result()) + # if key != "init" or not result: + # raise RuntimeError( + # "The initializer function did not succeed on worker.") + # + # if finish is not None: + # send_job().send(("finish", finish()._workflow.root_node)) return Connection(get_result, send_job, aux=read_stderr) diff --git a/noodles/run/run_with_prov.py b/noodles/run/run_with_prov.py index 96035bd..2ada8f5 100644 --- a/noodles/run/run_with_prov.py +++ b/noodles/run/run_with_prov.py @@ -254,7 +254,7 @@ def log_job_sched(key, job): def run_parallel_opt(wf, n_threads, registry, jobdb_file, - job_keeper=None, display=None): + job_keeper=None, display=None, cache_all=False): """Run a workflow in `n_threads` parallel threads. Now we replaced the single worker with a thread-pool of workers. @@ -288,8 +288,12 @@ def run_parallel_opt(wf, n_threads, registry, jobdb_file, results = Queue() - def pred(job): - return job.hints and 'store' in job.hints + if cache_all: + def pred(job): + return True + else: + def pred(job): + return job.hints and 'store' in job.hints LogQ = Queue() if display: diff --git a/noodles/serial/base.py b/noodles/serial/base.py index 51b2843..ff92a74 100644 --- a/noodles/serial/base.py +++ b/noodles/serial/base.py @@ -112,8 +112,8 @@ def decode(self, cls, data): class SerStorable(Serialiser): - def __init__(self): - super(SerStorable, self).__init__(Storable) + def __init__(self, cls): + super(SerStorable, self).__init__(cls) def encode(self, obj, make_reca): return make_reca( @@ -161,7 +161,7 @@ def registry(): FunctionNode: SerNode(), ArgumentAddress: SerNamedTuple(ArgumentAddress), Workflow: SerWorkflow(), - Storable: SerStorable(), + Storable: SerStorable(Storable), PromisedObject: SerPromisedObject() }, hooks={ diff --git a/noodles/serial/numpy.py b/noodles/serial/numpy.py index ad5d902..218d9e6 100644 --- a/noodles/serial/numpy.py +++ b/noodles/serial/numpy.py @@ -4,6 +4,10 @@ import uuid import io import base64 +import filelock +import h5py +import msgpack +import hashlib class SerNumpyArray(Serialiser): @@ -34,6 +38,44 @@ def decode(self, cls, filename): return numpy.load(filename) +def array_sha256(a): + dtype = msgpack.dumps(str(a.dtype)) + shape = msgpack.dumps(a.shape) + bdata = a.view(numpy.uint8) + sha = hashlib.sha256() + sha.update(dtype) + sha.update(shape) + sha.update(bdata) + return sha.hexdigest() + + +class SerNumpyArrayToHDF5(Serialiser): + def __init__(self, filename, lockfile): + super(SerNumpyArrayToHDF5, self).__init__(numpy.ndarray) + self.f = h5py.File(filename) + self.filename = filename + self.lock = filelock.FileLock(lockfile) + + def encode(self, obj, make_rec): + path = array_sha256(obj) + with self.lock: + if path not in self.f: + dataset = self.f.create_dataset( + path, shape=obj.shape, dtype=obj.dtype) + dataset[...] = obj + + return make_rec({ + "filename": self.filename, + "path": path + }, files=[self.filename], ref=True) + + def decode(self, cls, data): + with self.lock: + obj = cls(self.f[data["path"]]) + + return obj + + class SerUFunc(Serialiser): def __init__(self): super(SerUFunc, self).__init__(None) @@ -78,5 +120,15 @@ def arrays_to_string(file_prefix=None): hook_fn=_numpy_hook ) -registry = arrays_to_string +def arrays_to_hdf5(filename="cache.hdf5"): + return Registry( + types={ + numpy.ndarray: SerNumpyArrayToHDF5(filename, "cache.lock") + }, + hooks={ + '': SerUFunc() + }, + hook_fn=_numpy_hook + ) +registry = arrays_to_string From dbe784a6d544ecadc67e690c9d112b9f3274104f Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Tue, 18 Oct 2016 17:22:32 +0200 Subject: [PATCH 022/155] serialisation for bound methods --- noodles/draw_workflow.py | 34 ++++++++++++++++++++++++++++++++++ noodles/serial/base.py | 20 +++++++++++++++++--- test/test_class_decorator.py | 34 +++++++++++++++++++++++++++------- test/test_globals.py | 5 ++--- 4 files changed, 80 insertions(+), 13 deletions(-) create mode 100644 noodles/draw_workflow.py diff --git a/noodles/draw_workflow.py b/noodles/draw_workflow.py new file mode 100644 index 0000000..2a4d444 --- /dev/null +++ b/noodles/draw_workflow.py @@ -0,0 +1,34 @@ +################################################################################ +# Drawing routines | +#------------------------------------------------------------------------------+ +from pygraphviz import AGraph +from inspect import Parameter + +def _format_arg_list(a, v): + if len(a) == 0: + if v: + return "(\u2026)" + else: + return "()" + + s = "({0}{1})" + for i in a[:-1]: + s = s.format(str(i) if i != Parameter.empty else "\u2014", ", {0}{1}") + + if v: + return s.format("\u2026", "") + + return s.format(str(a[-1]) if a[-1] != Parameter.empty else "\u2014", "") + +def draw_workflow(filename, workflow): + dot = AGraph(directed=True) #(comment="Computing scheme") + for i,n in workflow.nodes.items(): + dot.add_node(i, label="{0} \n {1}".format(n.foo.__name__, + _format_arg_list(n.bound_args.args, None))) + + for i in workflow.links: + for j in workflow.links[i]: + dot.add_edge(i, j[0]) + dot.layout(prog='dot') + + dot.draw(filename) diff --git a/noodles/serial/base.py b/noodles/serial/base.py index ff92a74..4a3293b 100644 --- a/noodles/serial/base.py +++ b/noodles/serial/base.py @@ -6,7 +6,7 @@ from ..storable import (Storable) # from .as_dict import (AsDict) # from enum import Enum -from inspect import isfunction +from inspect import isfunction, ismethod # from collections import namedtuple from itertools import count # import json @@ -100,6 +100,19 @@ def decode(self, cls, data): return getattr(cls, data['method']) +class SerBoundMethod(Serialiser): + def __init__(self): + super(SerBoundMethod, self).__init__('') + + def encode(self, obj, make_rec): + return make_rec({ + 'self': obj.__self__, + 'name': obj.__name__}) + + def decode(self, _, data): + return getattr(data['self'], data['name']) + + class SerImportable(Serialiser): def __init__(self): super(SerImportable, self).__init__('') @@ -143,8 +156,8 @@ def _noodles_hook(obj): if importable(obj): return '' - if isinstance(obj, type): - return '' + if ismethod(obj): + return '' if isfunction(obj): return '' @@ -166,6 +179,7 @@ def registry(): }, hooks={ '': SerMethod(), + '': SerBoundMethod(), '': SerImportable(), }, hook_fn=_noodles_hook, diff --git a/test/test_class_decorator.py b/test/test_class_decorator.py index 61ac656..8925788 100644 --- a/test/test_class_decorator.py +++ b/test/test_class_decorator.py @@ -1,4 +1,5 @@ -from noodles import schedule, run_single, unwrap +from noodles import schedule, run_single, unwrap, run_process, Storable +from noodles import serial from nose.tools import raises @@ -18,8 +19,13 @@ def mul(x, y): @schedule -class A: +def make_object(cls, *args, **kwargs): + return cls(*args, **kwargs) + + +class A(Storable): def __init__(self, value): + # super(A, self).__init__() self.value = value self.m_attr = 0 @@ -39,24 +45,38 @@ def multiply(self, factor): return self -@schedule class B: pass def test_class_decorator(): - a = A(5).multiply(10) + a = make_object(A, 5).multiply(10) a.second = 7 result = run_single(a) assert result.value == 50 assert result.second == 7 +def registry(): + return serial.base() + + +def test_class_decorator_process(): + from noodles.draw_workflow import draw_workflow + a = make_object(A, 5).multiply(10) + a.second = 7 + draw_workflow('wf.svg', a._workflow) + result = run_process( + a, n_processes=1, registry=registry) + assert result.value == 50 + assert result.second == 7 + + def test_class_property(): - a = A(10) + a = make_object(A, 10) a.attr = 1.0 - b = B() + b = make_object(B) b.first = a.attr b.second = a.mul_attr(3) @@ -103,7 +123,7 @@ def test_unwrap(): @raises(AttributeError) def test_class_decorator2(): - a = A(6).multiply(7) + a = make_object(A, 6).multiply(7) b = a.divide(0) result = run_single(b) print(dir(result)) diff --git a/test/test_globals.py b/test/test_globals.py index a94d0db..b52a880 100644 --- a/test/test_globals.py +++ b/test/test_globals.py @@ -1,14 +1,14 @@ from noodles import schedule, run_process, serial -@schedule +# @schedule def init(): global s s = "This global variable needs to be here!" return True -@schedule +# @schedule def finish(): return "Finish functino was run!" @@ -23,4 +23,3 @@ def test_globals(): result = run_process(a, n_processes=1, registry=serial.base, init=init, finish=finish) assert result - From 1748ab9337541ec9e7f1ea3e9b130012db7d7a07 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Tue, 18 Oct 2016 18:30:58 +0200 Subject: [PATCH 023/155] serialisation of arrays to hdf5 --- noodles/serial/numpy.py | 21 ++++++++++---- test/test_numpy.py | 64 +++++++++++++++++++++++------------------ 2 files changed, 51 insertions(+), 34 deletions(-) diff --git a/noodles/serial/numpy.py b/noodles/serial/numpy.py index 218d9e6..1b6471c 100644 --- a/noodles/serial/numpy.py +++ b/noodles/serial/numpy.py @@ -41,7 +41,7 @@ def decode(self, cls, filename): def array_sha256(a): dtype = msgpack.dumps(str(a.dtype)) shape = msgpack.dumps(a.shape) - bdata = a.view(numpy.uint8) + bdata = a.flatten().view(numpy.uint8) sha = hashlib.sha256() sha.update(dtype) sha.update(shape) @@ -52,17 +52,23 @@ def array_sha256(a): class SerNumpyArrayToHDF5(Serialiser): def __init__(self, filename, lockfile): super(SerNumpyArrayToHDF5, self).__init__(numpy.ndarray) - self.f = h5py.File(filename) self.filename = filename self.lock = filelock.FileLock(lockfile) def encode(self, obj, make_rec): - path = array_sha256(obj) + key = array_sha256(obj) with self.lock: - if path not in self.f: - dataset = self.f.create_dataset( + f = h5py.File(self.filename) + path = next( + (ds for ds in f if f[ds].attrs.get('hash') == key), + False) + if not path: + path = base64.b64encode(uuid.uuid4().bytes).decode() + dataset = f.create_dataset( path, shape=obj.shape, dtype=obj.dtype) dataset[...] = obj + dataset.attrs['hash'] = key + f.close() return make_rec({ "filename": self.filename, @@ -71,7 +77,9 @@ def encode(self, obj, make_rec): def decode(self, cls, data): with self.lock: - obj = cls(self.f[data["path"]]) + f = h5py.File(self.filename) + obj = f[data["path"]].value + f.close() return obj @@ -120,6 +128,7 @@ def arrays_to_string(file_prefix=None): hook_fn=_numpy_hook ) + def arrays_to_hdf5(filename="cache.hdf5"): return Registry( types={ diff --git a/test/test_numpy.py b/test/test_numpy.py index 30dbb4a..fdd9ad9 100644 --- a/test/test_numpy.py +++ b/test/test_numpy.py @@ -4,22 +4,27 @@ import numpy as np from numpy import (random, fft, exp) - from noodles.serial.numpy import arrays_to_file + from noodles.serial.numpy import arrays_to_hdf5 + from noodles.run.xenon import (XenonConfig, RemoteJobConfig, XenonKeeper) except ImportError: - raise SkipTest("No NumPy installed.") + raise SkipTest("No NumPy or Xenon installed.") +else: + try: + from noodles.run.xenon import run_xenon_prov as run_xenon + except ImportError: + from noodles.run.xenon import run_xenon -from noodles import schedule, run_process, serial -import os -from shutil import (rmtree) +from noodles.display import (NCDisplay) +from noodles import schedule, serial, schedule_hint def registry(): - return serial.base() + arrays_to_file(file_prefix='test-numpy/') + return serial.base() + arrays_to_hdf5() -@schedule +@schedule_hint(display="fft", confirm=True, store=True) def do_fft(a): return fft.fft(a) @@ -29,7 +34,7 @@ def make_kernel(n, sigma): return exp(-fft.fftfreq(n)**2 * sigma**2) -@schedule +@schedule_hint(display="ifft", confirm=True, store=True) def do_ifft(a): return fft.ifft(a).real @@ -39,32 +44,35 @@ def apply_filter(a, b): return a * b -@schedule -def make_noise(n): +@schedule_hint(display="make noise {seed}", confirm=True, store=True) +def make_noise(n, seed=0): + random.seed(seed) return random.normal(0, 1, n) -def test_pickle(): - x = make_noise(256) - k = make_kernel(256, 10) - x_smooth = do_ifft(apply_filter(do_fft(x), k)) - - if os.path.exists("./test-numpy"): - rmtree("./test-numpy") +def run(wf): + xenon_config = XenonConfig( + jobs_scheme='local' + ) - os.mkdir("./test-numpy") + job_config = RemoteJobConfig( + registry=registry, + time_out=1000 + ) - result = run_process(x_smooth, 1, registry, deref=True) + with XenonKeeper() as Xe, NCDisplay() as display: + result = run_xenon( + wf, Xe, "cache.json", 2, xenon_config, job_config, + display=display, deref=True) - assert isinstance(result, np.ndarray) - assert result.size == 256 + return result - # above workflow has five steps - lst = os.listdir("./test-numpy") - assert len(lst) == 5 - # remove the .npy files - for f in lst: - os.remove("./test-numpy/" + f) +def test_hdf5(): + x = make_noise(256) + k = make_kernel(256, 10) + x_smooth = do_ifft(apply_filter(do_fft(x), k)) + result = run(x_smooth) - os.rmdir("./test-numpy") + assert isinstance(result, np.ndarray) + assert result.size == 256 From 43cd780c965d8b6232c1a789ad440c99992bbb09 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Tue, 18 Oct 2016 18:33:19 +0200 Subject: [PATCH 024/155] some new dependencies for numpy serialisation --- setup.py | 1 + 1 file changed, 1 insertion(+) diff --git a/setup.py b/setup.py index b041112..4d8f7b9 100755 --- a/setup.py +++ b/setup.py @@ -36,6 +36,7 @@ extras_require={ 'prov': ['tinydb'], 'xenon': ['pyxenon'], + 'numpy': ['numpy', 'h5py', 'msgpack-python', 'filelock'], 'test': ['nose', 'coverage', 'pyflakes', 'pep8', 'docker-py'] }, ) From d928bd4661cb4cd2130ba47038c2d937864e40e2 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Tue, 18 Oct 2016 18:34:03 +0200 Subject: [PATCH 025/155] remove drawing workflow from test --- test/test_class_decorator.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/test/test_class_decorator.py b/test/test_class_decorator.py index 8925788..b3673a9 100644 --- a/test/test_class_decorator.py +++ b/test/test_class_decorator.py @@ -62,10 +62,8 @@ def registry(): def test_class_decorator_process(): - from noodles.draw_workflow import draw_workflow a = make_object(A, 5).multiply(10) a.second = 7 - draw_workflow('wf.svg', a._workflow) result = run_process( a, n_processes=1, registry=registry) assert result.value == 50 From 95c9a9403ff22fbac389d03d7b5fb4406328d92c Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Wed, 19 Oct 2016 18:21:22 +0200 Subject: [PATCH 026/155] changed license to Apache --- COPYING | 674 --------------------------------- COPYING.LESSER | 165 -------- LICENSE | 201 ++++++++++ doc/source/poetry_tutorial.rst | 126 ++++-- noodles/run/run_with_prov.py | 2 +- noodles/serial/registry.py | 3 +- setup.py | 5 +- 7 files changed, 290 insertions(+), 886 deletions(-) delete mode 100644 COPYING delete mode 100644 COPYING.LESSER create mode 100644 LICENSE diff --git a/COPYING b/COPYING deleted file mode 100644 index 94a9ed0..0000000 --- a/COPYING +++ /dev/null @@ -1,674 +0,0 @@ - GNU GENERAL PUBLIC LICENSE - Version 3, 29 June 2007 - - Copyright (C) 2007 Free Software Foundation, Inc. - Everyone is permitted to copy and distribute verbatim copies - of this license document, but changing it is not allowed. - - Preamble - - The GNU General Public License is a free, copyleft license for -software and other kinds of works. - - The licenses for most software and other practical works are designed -to take away your freedom to share and change the works. By contrast, -the GNU General Public License is intended to guarantee your freedom to -share and change all versions of a program--to make sure it remains free -software for all its users. We, the Free Software Foundation, use the -GNU General Public License for most of our software; it applies also to -any other work released this way by its authors. You can apply it to -your programs, too. - - When we speak of free software, we are referring to freedom, not -price. Our General Public Licenses are designed to make sure that you -have the freedom to distribute copies of free software (and charge for -them if you wish), that you receive source code or can get it if you -want it, that you can change the software or use pieces of it in new -free programs, and that you know you can do these things. - - To protect your rights, we need to prevent others from denying you -these rights or asking you to surrender the rights. Therefore, you have -certain responsibilities if you distribute copies of the software, or if -you modify it: responsibilities to respect the freedom of others. - - For example, if you distribute copies of such a program, whether -gratis or for a fee, you must pass on to the recipients the same -freedoms that you received. You must make sure that they, too, receive -or can get the source code. And you must show them these terms so they -know their rights. - - Developers that use the GNU GPL protect your rights with two steps: -(1) assert copyright on the software, and (2) offer you this License -giving you legal permission to copy, distribute and/or modify it. - - For the developers' and authors' protection, the GPL clearly explains -that there is no warranty for this free software. For both users' and -authors' sake, the GPL requires that modified versions be marked as -changed, so that their problems will not be attributed erroneously to -authors of previous versions. - - Some devices are designed to deny users access to install or run -modified versions of the software inside them, although the manufacturer -can do so. This is fundamentally incompatible with the aim of -protecting users' freedom to change the software. The systematic -pattern of such abuse occurs in the area of products for individuals to -use, which is precisely where it is most unacceptable. Therefore, we -have designed this version of the GPL to prohibit the practice for those -products. If such problems arise substantially in other domains, we -stand ready to extend this provision to those domains in future versions -of the GPL, as needed to protect the freedom of users. - - Finally, every program is threatened constantly by software patents. -States should not allow patents to restrict development and use of -software on general-purpose computers, but in those that do, we wish to -avoid the special danger that patents applied to a free program could -make it effectively proprietary. To prevent this, the GPL assures that -patents cannot be used to render the program non-free. - - The precise terms and conditions for copying, distribution and -modification follow. - - TERMS AND CONDITIONS - - 0. Definitions. - - "This License" refers to version 3 of the GNU General Public License. - - "Copyright" also means copyright-like laws that apply to other kinds of -works, such as semiconductor masks. - - "The Program" refers to any copyrightable work licensed under this -License. Each licensee is addressed as "you". "Licensees" and -"recipients" may be individuals or organizations. - - To "modify" a work means to copy from or adapt all or part of the work -in a fashion requiring copyright permission, other than the making of an -exact copy. The resulting work is called a "modified version" of the -earlier work or a work "based on" the earlier work. - - A "covered work" means either the unmodified Program or a work based -on the Program. - - To "propagate" a work means to do anything with it that, without -permission, would make you directly or secondarily liable for -infringement under applicable copyright law, except executing it on a -computer or modifying a private copy. Propagation includes copying, -distribution (with or without modification), making available to the -public, and in some countries other activities as well. - - To "convey" a work means any kind of propagation that enables other -parties to make or receive copies. Mere interaction with a user through -a computer network, with no transfer of a copy, is not conveying. - - An interactive user interface displays "Appropriate Legal Notices" -to the extent that it includes a convenient and prominently visible -feature that (1) displays an appropriate copyright notice, and (2) -tells the user that there is no warranty for the work (except to the -extent that warranties are provided), that licensees may convey the -work under this License, and how to view a copy of this License. If -the interface presents a list of user commands or options, such as a -menu, a prominent item in the list meets this criterion. - - 1. Source Code. - - The "source code" for a work means the preferred form of the work -for making modifications to it. "Object code" means any non-source -form of a work. - - A "Standard Interface" means an interface that either is an official -standard defined by a recognized standards body, or, in the case of -interfaces specified for a particular programming language, one that -is widely used among developers working in that language. - - The "System Libraries" of an executable work include anything, other -than the work as a whole, that (a) is included in the normal form of -packaging a Major Component, but which is not part of that Major -Component, and (b) serves only to enable use of the work with that -Major Component, or to implement a Standard Interface for which an -implementation is available to the public in source code form. A -"Major Component", in this context, means a major essential component -(kernel, window system, and so on) of the specific operating system -(if any) on which the executable work runs, or a compiler used to -produce the work, or an object code interpreter used to run it. - - The "Corresponding Source" for a work in object code form means all -the source code needed to generate, install, and (for an executable -work) run the object code and to modify the work, including scripts to -control those activities. However, it does not include the work's -System Libraries, or general-purpose tools or generally available free -programs which are used unmodified in performing those activities but -which are not part of the work. For example, Corresponding Source -includes interface definition files associated with source files for -the work, and the source code for shared libraries and dynamically -linked subprograms that the work is specifically designed to require, -such as by intimate data communication or control flow between those -subprograms and other parts of the work. - - The Corresponding Source need not include anything that users -can regenerate automatically from other parts of the Corresponding -Source. - - The Corresponding Source for a work in source code form is that -same work. - - 2. Basic Permissions. - - All rights granted under this License are granted for the term of -copyright on the Program, and are irrevocable provided the stated -conditions are met. This License explicitly affirms your unlimited -permission to run the unmodified Program. The output from running a -covered work is covered by this License only if the output, given its -content, constitutes a covered work. This License acknowledges your -rights of fair use or other equivalent, as provided by copyright law. - - You may make, run and propagate covered works that you do not -convey, without conditions so long as your license otherwise remains -in force. You may convey covered works to others for the sole purpose -of having them make modifications exclusively for you, or provide you -with facilities for running those works, provided that you comply with -the terms of this License in conveying all material for which you do -not control copyright. Those thus making or running the covered works -for you must do so exclusively on your behalf, under your direction -and control, on terms that prohibit them from making any copies of -your copyrighted material outside their relationship with you. - - Conveying under any other circumstances is permitted solely under -the conditions stated below. Sublicensing is not allowed; section 10 -makes it unnecessary. - - 3. Protecting Users' Legal Rights From Anti-Circumvention Law. - - No covered work shall be deemed part of an effective technological -measure under any applicable law fulfilling obligations under article -11 of the WIPO copyright treaty adopted on 20 December 1996, or -similar laws prohibiting or restricting circumvention of such -measures. - - When you convey a covered work, you waive any legal power to forbid -circumvention of technological measures to the extent such circumvention -is effected by exercising rights under this License with respect to -the covered work, and you disclaim any intention to limit operation or -modification of the work as a means of enforcing, against the work's -users, your or third parties' legal rights to forbid circumvention of -technological measures. - - 4. Conveying Verbatim Copies. - - You may convey verbatim copies of the Program's source code as you -receive it, in any medium, provided that you conspicuously and -appropriately publish on each copy an appropriate copyright notice; -keep intact all notices stating that this License and any -non-permissive terms added in accord with section 7 apply to the code; -keep intact all notices of the absence of any warranty; and give all -recipients a copy of this License along with the Program. - - You may charge any price or no price for each copy that you convey, -and you may offer support or warranty protection for a fee. - - 5. Conveying Modified Source Versions. - - You may convey a work based on the Program, or the modifications to -produce it from the Program, in the form of source code under the -terms of section 4, provided that you also meet all of these conditions: - - a) The work must carry prominent notices stating that you modified - it, and giving a relevant date. - - b) The work must carry prominent notices stating that it is - released under this License and any conditions added under section - 7. This requirement modifies the requirement in section 4 to - "keep intact all notices". - - c) You must license the entire work, as a whole, under this - License to anyone who comes into possession of a copy. This - License will therefore apply, along with any applicable section 7 - additional terms, to the whole of the work, and all its parts, - regardless of how they are packaged. This License gives no - permission to license the work in any other way, but it does not - invalidate such permission if you have separately received it. - - d) If the work has interactive user interfaces, each must display - Appropriate Legal Notices; however, if the Program has interactive - interfaces that do not display Appropriate Legal Notices, your - work need not make them do so. - - A compilation of a covered work with other separate and independent -works, which are not by their nature extensions of the covered work, -and which are not combined with it such as to form a larger program, -in or on a volume of a storage or distribution medium, is called an -"aggregate" if the compilation and its resulting copyright are not -used to limit the access or legal rights of the compilation's users -beyond what the individual works permit. Inclusion of a covered work -in an aggregate does not cause this License to apply to the other -parts of the aggregate. - - 6. Conveying Non-Source Forms. - - You may convey a covered work in object code form under the terms -of sections 4 and 5, provided that you also convey the -machine-readable Corresponding Source under the terms of this License, -in one of these ways: - - a) Convey the object code in, or embodied in, a physical product - (including a physical distribution medium), accompanied by the - Corresponding Source fixed on a durable physical medium - customarily used for software interchange. - - b) Convey the object code in, or embodied in, a physical product - (including a physical distribution medium), accompanied by a - written offer, valid for at least three years and valid for as - long as you offer spare parts or customer support for that product - model, to give anyone who possesses the object code either (1) a - copy of the Corresponding Source for all the software in the - product that is covered by this License, on a durable physical - medium customarily used for software interchange, for a price no - more than your reasonable cost of physically performing this - conveying of source, or (2) access to copy the - Corresponding Source from a network server at no charge. - - c) Convey individual copies of the object code with a copy of the - written offer to provide the Corresponding Source. This - alternative is allowed only occasionally and noncommercially, and - only if you received the object code with such an offer, in accord - with subsection 6b. - - d) Convey the object code by offering access from a designated - place (gratis or for a charge), and offer equivalent access to the - Corresponding Source in the same way through the same place at no - further charge. You need not require recipients to copy the - Corresponding Source along with the object code. If the place to - copy the object code is a network server, the Corresponding Source - may be on a different server (operated by you or a third party) - that supports equivalent copying facilities, provided you maintain - clear directions next to the object code saying where to find the - Corresponding Source. Regardless of what server hosts the - Corresponding Source, you remain obligated to ensure that it is - available for as long as needed to satisfy these requirements. - - e) Convey the object code using peer-to-peer transmission, provided - you inform other peers where the object code and Corresponding - Source of the work are being offered to the general public at no - charge under subsection 6d. - - A separable portion of the object code, whose source code is excluded -from the Corresponding Source as a System Library, need not be -included in conveying the object code work. - - A "User Product" is either (1) a "consumer product", which means any -tangible personal property which is normally used for personal, family, -or household purposes, or (2) anything designed or sold for incorporation -into a dwelling. In determining whether a product is a consumer product, -doubtful cases shall be resolved in favor of coverage. For a particular -product received by a particular user, "normally used" refers to a -typical or common use of that class of product, regardless of the status -of the particular user or of the way in which the particular user -actually uses, or expects or is expected to use, the product. A product -is a consumer product regardless of whether the product has substantial -commercial, industrial or non-consumer uses, unless such uses represent -the only significant mode of use of the product. - - "Installation Information" for a User Product means any methods, -procedures, authorization keys, or other information required to install -and execute modified versions of a covered work in that User Product from -a modified version of its Corresponding Source. The information must -suffice to ensure that the continued functioning of the modified object -code is in no case prevented or interfered with solely because -modification has been made. - - If you convey an object code work under this section in, or with, or -specifically for use in, a User Product, and the conveying occurs as -part of a transaction in which the right of possession and use of the -User Product is transferred to the recipient in perpetuity or for a -fixed term (regardless of how the transaction is characterized), the -Corresponding Source conveyed under this section must be accompanied -by the Installation Information. But this requirement does not apply -if neither you nor any third party retains the ability to install -modified object code on the User Product (for example, the work has -been installed in ROM). - - The requirement to provide Installation Information does not include a -requirement to continue to provide support service, warranty, or updates -for a work that has been modified or installed by the recipient, or for -the User Product in which it has been modified or installed. Access to a -network may be denied when the modification itself materially and -adversely affects the operation of the network or violates the rules and -protocols for communication across the network. - - Corresponding Source conveyed, and Installation Information provided, -in accord with this section must be in a format that is publicly -documented (and with an implementation available to the public in -source code form), and must require no special password or key for -unpacking, reading or copying. - - 7. Additional Terms. - - "Additional permissions" are terms that supplement the terms of this -License by making exceptions from one or more of its conditions. -Additional permissions that are applicable to the entire Program shall -be treated as though they were included in this License, to the extent -that they are valid under applicable law. If additional permissions -apply only to part of the Program, that part may be used separately -under those permissions, but the entire Program remains governed by -this License without regard to the additional permissions. - - When you convey a copy of a covered work, you may at your option -remove any additional permissions from that copy, or from any part of -it. (Additional permissions may be written to require their own -removal in certain cases when you modify the work.) You may place -additional permissions on material, added by you to a covered work, -for which you have or can give appropriate copyright permission. - - Notwithstanding any other provision of this License, for material you -add to a covered work, you may (if authorized by the copyright holders of -that material) supplement the terms of this License with terms: - - a) Disclaiming warranty or limiting liability differently from the - terms of sections 15 and 16 of this License; or - - b) Requiring preservation of specified reasonable legal notices or - author attributions in that material or in the Appropriate Legal - Notices displayed by works containing it; or - - c) Prohibiting misrepresentation of the origin of that material, or - requiring that modified versions of such material be marked in - reasonable ways as different from the original version; or - - d) Limiting the use for publicity purposes of names of licensors or - authors of the material; or - - e) Declining to grant rights under trademark law for use of some - trade names, trademarks, or service marks; or - - f) Requiring indemnification of licensors and authors of that - material by anyone who conveys the material (or modified versions of - it) with contractual assumptions of liability to the recipient, for - any liability that these contractual assumptions directly impose on - those licensors and authors. - - All other non-permissive additional terms are considered "further -restrictions" within the meaning of section 10. If the Program as you -received it, or any part of it, contains a notice stating that it is -governed by this License along with a term that is a further -restriction, you may remove that term. If a license document contains -a further restriction but permits relicensing or conveying under this -License, you may add to a covered work material governed by the terms -of that license document, provided that the further restriction does -not survive such relicensing or conveying. - - If you add terms to a covered work in accord with this section, you -must place, in the relevant source files, a statement of the -additional terms that apply to those files, or a notice indicating -where to find the applicable terms. - - Additional terms, permissive or non-permissive, may be stated in the -form of a separately written license, or stated as exceptions; -the above requirements apply either way. - - 8. Termination. - - You may not propagate or modify a covered work except as expressly -provided under this License. Any attempt otherwise to propagate or -modify it is void, and will automatically terminate your rights under -this License (including any patent licenses granted under the third -paragraph of section 11). - - However, if you cease all violation of this License, then your -license from a particular copyright holder is reinstated (a) -provisionally, unless and until the copyright holder explicitly and -finally terminates your license, and (b) permanently, if the copyright -holder fails to notify you of the violation by some reasonable means -prior to 60 days after the cessation. - - Moreover, your license from a particular copyright holder is -reinstated permanently if the copyright holder notifies you of the -violation by some reasonable means, this is the first time you have -received notice of violation of this License (for any work) from that -copyright holder, and you cure the violation prior to 30 days after -your receipt of the notice. - - Termination of your rights under this section does not terminate the -licenses of parties who have received copies or rights from you under -this License. If your rights have been terminated and not permanently -reinstated, you do not qualify to receive new licenses for the same -material under section 10. - - 9. Acceptance Not Required for Having Copies. - - You are not required to accept this License in order to receive or -run a copy of the Program. Ancillary propagation of a covered work -occurring solely as a consequence of using peer-to-peer transmission -to receive a copy likewise does not require acceptance. However, -nothing other than this License grants you permission to propagate or -modify any covered work. These actions infringe copyright if you do -not accept this License. Therefore, by modifying or propagating a -covered work, you indicate your acceptance of this License to do so. - - 10. Automatic Licensing of Downstream Recipients. - - Each time you convey a covered work, the recipient automatically -receives a license from the original licensors, to run, modify and -propagate that work, subject to this License. You are not responsible -for enforcing compliance by third parties with this License. - - An "entity transaction" is a transaction transferring control of an -organization, or substantially all assets of one, or subdividing an -organization, or merging organizations. If propagation of a covered -work results from an entity transaction, each party to that -transaction who receives a copy of the work also receives whatever -licenses to the work the party's predecessor in interest had or could -give under the previous paragraph, plus a right to possession of the -Corresponding Source of the work from the predecessor in interest, if -the predecessor has it or can get it with reasonable efforts. - - You may not impose any further restrictions on the exercise of the -rights granted or affirmed under this License. For example, you may -not impose a license fee, royalty, or other charge for exercise of -rights granted under this License, and you may not initiate litigation -(including a cross-claim or counterclaim in a lawsuit) alleging that -any patent claim is infringed by making, using, selling, offering for -sale, or importing the Program or any portion of it. - - 11. Patents. - - A "contributor" is a copyright holder who authorizes use under this -License of the Program or a work on which the Program is based. The -work thus licensed is called the contributor's "contributor version". - - A contributor's "essential patent claims" are all patent claims -owned or controlled by the contributor, whether already acquired or -hereafter acquired, that would be infringed by some manner, permitted -by this License, of making, using, or selling its contributor version, -but do not include claims that would be infringed only as a -consequence of further modification of the contributor version. For -purposes of this definition, "control" includes the right to grant -patent sublicenses in a manner consistent with the requirements of -this License. - - Each contributor grants you a non-exclusive, worldwide, royalty-free -patent license under the contributor's essential patent claims, to -make, use, sell, offer for sale, import and otherwise run, modify and -propagate the contents of its contributor version. - - In the following three paragraphs, a "patent license" is any express -agreement or commitment, however denominated, not to enforce a patent -(such as an express permission to practice a patent or covenant not to -sue for patent infringement). To "grant" such a patent license to a -party means to make such an agreement or commitment not to enforce a -patent against the party. - - If you convey a covered work, knowingly relying on a patent license, -and the Corresponding Source of the work is not available for anyone -to copy, free of charge and under the terms of this License, through a -publicly available network server or other readily accessible means, -then you must either (1) cause the Corresponding Source to be so -available, or (2) arrange to deprive yourself of the benefit of the -patent license for this particular work, or (3) arrange, in a manner -consistent with the requirements of this License, to extend the patent -license to downstream recipients. "Knowingly relying" means you have -actual knowledge that, but for the patent license, your conveying the -covered work in a country, or your recipient's use of the covered work -in a country, would infringe one or more identifiable patents in that -country that you have reason to believe are valid. - - If, pursuant to or in connection with a single transaction or -arrangement, you convey, or propagate by procuring conveyance of, a -covered work, and grant a patent license to some of the parties -receiving the covered work authorizing them to use, propagate, modify -or convey a specific copy of the covered work, then the patent license -you grant is automatically extended to all recipients of the covered -work and works based on it. - - A patent license is "discriminatory" if it does not include within -the scope of its coverage, prohibits the exercise of, or is -conditioned on the non-exercise of one or more of the rights that are -specifically granted under this License. You may not convey a covered -work if you are a party to an arrangement with a third party that is -in the business of distributing software, under which you make payment -to the third party based on the extent of your activity of conveying -the work, and under which the third party grants, to any of the -parties who would receive the covered work from you, a discriminatory -patent license (a) in connection with copies of the covered work -conveyed by you (or copies made from those copies), or (b) primarily -for and in connection with specific products or compilations that -contain the covered work, unless you entered into that arrangement, -or that patent license was granted, prior to 28 March 2007. - - Nothing in this License shall be construed as excluding or limiting -any implied license or other defenses to infringement that may -otherwise be available to you under applicable patent law. - - 12. No Surrender of Others' Freedom. - - If conditions are imposed on you (whether by court order, agreement or -otherwise) that contradict the conditions of this License, they do not -excuse you from the conditions of this License. If you cannot convey a -covered work so as to satisfy simultaneously your obligations under this -License and any other pertinent obligations, then as a consequence you may -not convey it at all. For example, if you agree to terms that obligate you -to collect a royalty for further conveying from those to whom you convey -the Program, the only way you could satisfy both those terms and this -License would be to refrain entirely from conveying the Program. - - 13. Use with the GNU Affero General Public License. - - Notwithstanding any other provision of this License, you have -permission to link or combine any covered work with a work licensed -under version 3 of the GNU Affero General Public License into a single -combined work, and to convey the resulting work. The terms of this -License will continue to apply to the part which is the covered work, -but the special requirements of the GNU Affero General Public License, -section 13, concerning interaction through a network will apply to the -combination as such. - - 14. Revised Versions of this License. - - The Free Software Foundation may publish revised and/or new versions of -the GNU General Public License from time to time. Such new versions will -be similar in spirit to the present version, but may differ in detail to -address new problems or concerns. - - Each version is given a distinguishing version number. If the -Program specifies that a certain numbered version of the GNU General -Public License "or any later version" applies to it, you have the -option of following the terms and conditions either of that numbered -version or of any later version published by the Free Software -Foundation. If the Program does not specify a version number of the -GNU General Public License, you may choose any version ever published -by the Free Software Foundation. - - If the Program specifies that a proxy can decide which future -versions of the GNU General Public License can be used, that proxy's -public statement of acceptance of a version permanently authorizes you -to choose that version for the Program. - - Later license versions may give you additional or different -permissions. However, no additional obligations are imposed on any -author or copyright holder as a result of your choosing to follow a -later version. - - 15. Disclaimer of Warranty. - - THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY -APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT -HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY -OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, -THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR -PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM -IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF -ALL NECESSARY SERVICING, REPAIR OR CORRECTION. - - 16. Limitation of Liability. - - IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING -WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS -THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY -GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE -USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF -DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD -PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), -EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF -SUCH DAMAGES. - - 17. Interpretation of Sections 15 and 16. - - If the disclaimer of warranty and limitation of liability provided -above cannot be given local legal effect according to their terms, -reviewing courts shall apply local law that most closely approximates -an absolute waiver of all civil liability in connection with the -Program, unless a warranty or assumption of liability accompanies a -copy of the Program in return for a fee. - - END OF TERMS AND CONDITIONS - - How to Apply These Terms to Your New Programs - - If you develop a new program, and you want it to be of the greatest -possible use to the public, the best way to achieve this is to make it -free software which everyone can redistribute and change under these terms. - - To do so, attach the following notices to the program. It is safest -to attach them to the start of each source file to most effectively -state the exclusion of warranty; and each file should have at least -the "copyright" line and a pointer to where the full notice is found. - - - Copyright (C) - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see . - -Also add information on how to contact you by electronic and paper mail. - - If the program does terminal interaction, make it output a short -notice like this when it starts in an interactive mode: - - Copyright (C) - This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. - This is free software, and you are welcome to redistribute it - under certain conditions; type `show c' for details. - -The hypothetical commands `show w' and `show c' should show the appropriate -parts of the General Public License. Of course, your program's commands -might be different; for a GUI interface, you would use an "about box". - - You should also get your employer (if you work as a programmer) or school, -if any, to sign a "copyright disclaimer" for the program, if necessary. -For more information on this, and how to apply and follow the GNU GPL, see -. - - The GNU General Public License does not permit incorporating your program -into proprietary programs. If your program is a subroutine library, you -may consider it more useful to permit linking proprietary applications with -the library. If this is what you want to do, use the GNU Lesser General -Public License instead of this License. But first, please read -. diff --git a/COPYING.LESSER b/COPYING.LESSER deleted file mode 100644 index 65c5ca8..0000000 --- a/COPYING.LESSER +++ /dev/null @@ -1,165 +0,0 @@ - GNU LESSER GENERAL PUBLIC LICENSE - Version 3, 29 June 2007 - - Copyright (C) 2007 Free Software Foundation, Inc. - Everyone is permitted to copy and distribute verbatim copies - of this license document, but changing it is not allowed. - - - This version of the GNU Lesser General Public License incorporates -the terms and conditions of version 3 of the GNU General Public -License, supplemented by the additional permissions listed below. - - 0. Additional Definitions. - - As used herein, "this License" refers to version 3 of the GNU Lesser -General Public License, and the "GNU GPL" refers to version 3 of the GNU -General Public License. - - "The Library" refers to a covered work governed by this License, -other than an Application or a Combined Work as defined below. - - An "Application" is any work that makes use of an interface provided -by the Library, but which is not otherwise based on the Library. -Defining a subclass of a class defined by the Library is deemed a mode -of using an interface provided by the Library. - - A "Combined Work" is a work produced by combining or linking an -Application with the Library. The particular version of the Library -with which the Combined Work was made is also called the "Linked -Version". - - The "Minimal Corresponding Source" for a Combined Work means the -Corresponding Source for the Combined Work, excluding any source code -for portions of the Combined Work that, considered in isolation, are -based on the Application, and not on the Linked Version. - - The "Corresponding Application Code" for a Combined Work means the -object code and/or source code for the Application, including any data -and utility programs needed for reproducing the Combined Work from the -Application, but excluding the System Libraries of the Combined Work. - - 1. Exception to Section 3 of the GNU GPL. - - You may convey a covered work under sections 3 and 4 of this License -without being bound by section 3 of the GNU GPL. - - 2. Conveying Modified Versions. - - If you modify a copy of the Library, and, in your modifications, a -facility refers to a function or data to be supplied by an Application -that uses the facility (other than as an argument passed when the -facility is invoked), then you may convey a copy of the modified -version: - - a) under this License, provided that you make a good faith effort to - ensure that, in the event an Application does not supply the - function or data, the facility still operates, and performs - whatever part of its purpose remains meaningful, or - - b) under the GNU GPL, with none of the additional permissions of - this License applicable to that copy. - - 3. Object Code Incorporating Material from Library Header Files. - - The object code form of an Application may incorporate material from -a header file that is part of the Library. You may convey such object -code under terms of your choice, provided that, if the incorporated -material is not limited to numerical parameters, data structure -layouts and accessors, or small macros, inline functions and templates -(ten or fewer lines in length), you do both of the following: - - a) Give prominent notice with each copy of the object code that the - Library is used in it and that the Library and its use are - covered by this License. - - b) Accompany the object code with a copy of the GNU GPL and this license - document. - - 4. Combined Works. - - You may convey a Combined Work under terms of your choice that, -taken together, effectively do not restrict modification of the -portions of the Library contained in the Combined Work and reverse -engineering for debugging such modifications, if you also do each of -the following: - - a) Give prominent notice with each copy of the Combined Work that - the Library is used in it and that the Library and its use are - covered by this License. - - b) Accompany the Combined Work with a copy of the GNU GPL and this license - document. - - c) For a Combined Work that displays copyright notices during - execution, include the copyright notice for the Library among - these notices, as well as a reference directing the user to the - copies of the GNU GPL and this license document. - - d) Do one of the following: - - 0) Convey the Minimal Corresponding Source under the terms of this - License, and the Corresponding Application Code in a form - suitable for, and under terms that permit, the user to - recombine or relink the Application with a modified version of - the Linked Version to produce a modified Combined Work, in the - manner specified by section 6 of the GNU GPL for conveying - Corresponding Source. - - 1) Use a suitable shared library mechanism for linking with the - Library. A suitable mechanism is one that (a) uses at run time - a copy of the Library already present on the user's computer - system, and (b) will operate properly with a modified version - of the Library that is interface-compatible with the Linked - Version. - - e) Provide Installation Information, but only if you would otherwise - be required to provide such information under section 6 of the - GNU GPL, and only to the extent that such information is - necessary to install and execute a modified version of the - Combined Work produced by recombining or relinking the - Application with a modified version of the Linked Version. (If - you use option 4d0, the Installation Information must accompany - the Minimal Corresponding Source and Corresponding Application - Code. If you use option 4d1, you must provide the Installation - Information in the manner specified by section 6 of the GNU GPL - for conveying Corresponding Source.) - - 5. Combined Libraries. - - You may place library facilities that are a work based on the -Library side by side in a single library together with other library -facilities that are not Applications and are not covered by this -License, and convey such a combined library under terms of your -choice, if you do both of the following: - - a) Accompany the combined library with a copy of the same work based - on the Library, uncombined with any other library facilities, - conveyed under the terms of this License. - - b) Give prominent notice with the combined library that part of it - is a work based on the Library, and explaining where to find the - accompanying uncombined form of the same work. - - 6. Revised Versions of the GNU Lesser General Public License. - - The Free Software Foundation may publish revised and/or new versions -of the GNU Lesser General Public License from time to time. Such new -versions will be similar in spirit to the present version, but may -differ in detail to address new problems or concerns. - - Each version is given a distinguishing version number. If the -Library as you received it specifies that a certain numbered version -of the GNU Lesser General Public License "or any later version" -applies to it, you have the option of following the terms and -conditions either of that published version or of any later version -published by the Free Software Foundation. If the Library as you -received it does not specify a version number of the GNU Lesser -General Public License, you may choose any version of the GNU Lesser -General Public License ever published by the Free Software Foundation. - - If the Library as you received it specifies that a proxy can decide -whether future versions of the GNU Lesser General Public License shall -apply, that proxy's public statement of acceptance of any version is -permanent authorization for you to choose that version for the -Library. diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..8dada3e --- /dev/null +++ b/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "{}" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright {yyyy} {name of copyright owner} + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/doc/source/poetry_tutorial.rst b/doc/source/poetry_tutorial.rst index 5cb4318..534b91d 100644 --- a/doc/source/poetry_tutorial.rst +++ b/doc/source/poetry_tutorial.rst @@ -3,10 +3,42 @@ Real World Tutorial 1: Translating Poetry ========================================= +First example +------------- + +We build workflows by calling functions. The simplest example of this +is the "diamond workflow": + +.. code:: python + + from noodles import run_single + from noodles.tutorial import (add, sub, mul) + + u = add(5, 4) + v = sub(u, 3) + w = sub(u, 2) + x = mul(v, w) + + answer = run_single(x) + + print("The answer is {0}.".format(answer)) + +That looks like any other Python code! But this example is a bit silly. +How do we leverage Noodles to earn an honest living? Here's a slightly less +silly example (but only just!). We will build a small translation engine +that translates sentences by submitting each word to an online dictionary +over a Rest API. To do this we make loops ("For thou shalt make loops of +blue"). First we build the program as you would do in Python, then we +sprinkle some Noodles magic and make it work parallel! Furthermore, we'll +see how to: + + * make more loops + * cache results for reuse + Making loops ------------ -Thats all swell, but how do we make a parallel loop? Let's look at a +How do we make a parallel loop? Let's look at a ``map`` operation; in Python there are several ways to perform a function on all elements in an array. For this example, we will translate some words using the Glosbe service, which has a nice REST @@ -20,10 +52,10 @@ interface. We first build some functionality to use this interface. class Translate: - """Translate words and sentences in the worst possible way. The Glosbe dictionary - has a nice REST interface that we query for a phrase. We then take the first result. - To translate a sentence, we cut it in pieces, translate it and paste it back into - a Frankenstein monster.""" + """Translate words and sentences in the worst possible way. The Glosbe + dictionary has a nice REST interface that we query for a phrase. We + then take the first result. To translate a sentence, we cut it in + pieces, translate it and paste it back into a Frankenstein monster.""" def __init__(self, src_lang='en', tgt_lang='fy'): self.src = src_lang self.tgt = tgt_lang @@ -33,13 +65,14 @@ interface. We first build some functionality to use this interface. src=src_lang, tgt=tgt_lang) def query_phrase(self, phrase): - with urllib.request.urlopen(self.url.format(phrase=phrase.lower())) as response: + url = self.url.format(phrase=phrase.lower()) + with urllib.request.urlopen(url) as response: translation = json.loads(response.read().decode()) return translation def word(self, phrase): - #translation = self.query_phrase(phrase) - translation = {'tuc': [{'phrase': {'text': phrase.lower()[::-1]}}]} + translation = self.query_phrase(phrase) + if len(translation['tuc']) > 0 and 'phrase' in translation['tuc'][0]: result = translation['tuc'][0]['phrase']['text'] if phrase[0].isupper(): @@ -50,11 +83,15 @@ interface. We first build some functionality to use this interface. return "<" + phrase + ">" def sentence(self, phrase): + """Split a sentence into a list of words and a format string, + replacing each occurance of a word with '{}'. Map the words through + the translation engine and join them using the format string.""" words = re.sub("[^\w]", " ", phrase).split() space = re.sub("[\w]+", "{}", phrase) return space.format(*map(self.word, words)) -We start with a list of strings that desparately need translation. +We start with a list of strings that desparately need translation. And add a little +routine to print it in a gracious manner. .. code:: python @@ -81,7 +118,7 @@ We start with a list of strings that desparately need translation. -Beginning Python programmers like to append things; this is not how you +Beginning Python programmers like to append things; this is *not* how you are supposed to program in Python; if you do, please go and read Jeff Knupp's *Writing Idiomatic Python*. @@ -97,12 +134,11 @@ Knupp's *Writing Idiomatic Python*. .. parsed-literal:: Auf Deutsch: - Fi cisum eb eht doof fo evol, yalp no, - Evig em ssecxe fo ti; taht gnitiefrus, - Eht etiteppa yam nekcis, dna os eid. + Wenn Musik sein der Essen von Minne, spielen an, + Geben ich Übermaß von es; das übersättigend, + Der Appetit dürfen ekeln, und so sterben. - Rather use a comprehension like so: .. code:: python @@ -115,9 +151,9 @@ Rather use a comprehension like so: .. parsed-literal:: Yn it Frysk: - Fi cisum eb eht doof fo evol, yalp no, - Evig em ssecxe fo ti; taht gnitiefrus, - Eht etiteppa yam nekcis, dna os eid. + At muzyk wêze de fiedsel fan leafde, boartsje oan, + Jaan by fersin fan it; dat , + De maaie , en dus deagean. @@ -133,12 +169,11 @@ Or use ``map``: .. parsed-literal:: På Dansk: - Fi cisum eb eht doof fo evol, yalp no, - Evig em ssecxe fo ti; taht gnitiefrus, - Eht etiteppa yam nekcis, dna os eid. + Hvis musik være de mad af kærlighed, spil på, + Give mig udskejelser af det; som , + De appetit må , og så dø. - Noodlify! --------- @@ -161,9 +196,9 @@ We could write in the last line of the ``sentence`` method, but the string format method doesn't support wrapping. We rely on getting the signature of a function by calling ``inspect.signature``. In some cases of build-in -function this raises an exception. We may find a work around for these -cases in future versions of Noodles. For the moment we'll have to define -a little wrapper function. +function this raises an exception. Note that this is a design flaw in Python, +not Noodles! We may find a work around for these cases in future versions of +Noodles. For the moment we'll have to define a little wrapper function. .. code:: python @@ -181,10 +216,10 @@ a little wrapper function. class Translate: - """Translate words and sentences in the worst possible way. The Glosbe dictionary - has a nice REST interface that we query for a phrase. We then take the first result. - To translate a sentence, we cut it in pieces, translate it and paste it back into - a Frankenstein monster.""" + """Translate words and sentences in the worst possible way. The Glosbe + dictionary has a nice REST interface that we query for a phrase. We + then take the first result. To translate a sentence, we cut it in + pieces, translate it and paste it back into a Frankenstein monster.""" def __init__(self, src_lang='en', tgt_lang='fy'): self.src = src_lang self.tgt = tgt_lang @@ -194,14 +229,14 @@ a little wrapper function. src=src_lang, tgt=tgt_lang) def query_phrase(self, phrase): - with urllib.request.urlopen(self.url.format(phrase=phrase.lower())) as response: + url = self.url.format(phrase=phrase.lower()) + with urllib.request.urlopen(url) as response: translation = json.loads(response.read().decode()) return translation @schedule def word(self, phrase): - translation = {'tuc': [{'phrase': {'text': phrase.lower()[::-1]}}]} - #translation = self.query_phrase(phrase) + translation = self.query_phrase(phrase) if len(translation['tuc']) > 0 and 'phrase' in translation['tuc'][0]: result = translation['tuc'][0]['phrase']['text'] @@ -215,6 +250,12 @@ a little wrapper function. def sentence(self, phrase): words = re.sub("[^\w]", " ", phrase).split() space = re.sub("[\w]+", "{}", phrase) + + # translated_words now is a sequence of promises! + translated_words = map(self.word, words) + + # we may only pass them to another `schedule` function + # since `string.format` has no knowledge about promises. return format_string(space, *map(self.word, words)) def __str__(self): @@ -249,11 +290,9 @@ to plot the workflow graph. Let's run the new script. .. parsed-literal:: Shakespeare en Esperanto: - Fi cisum eb eht doof fo evol, yalp no, - Evig em ssecxe fo ti; taht gnitiefrus, - Eht etiteppa yam nekcis, dna os eid. - - + Se muziko esti la manĝaĵo de ami, ludi sur, + Doni mi eksceso de ĝi; tio , + La apetito povi naŭzi, kaj tiel morti. The last peculiar thing that you may notice, is the ``gather`` function. It collects the promises that ``map`` generates and creates a single new @@ -276,8 +315,7 @@ Dealing with repetition ----------------------- In the following example we have a line with some repetition. It would -be a shame to look up the repeated words twice, wouldn't it? Let's build -a little counter routine to check if everything is working. +be a shame to look up the repeated words twice, wouldn't it? .. code:: python @@ -285,11 +323,9 @@ a little counter routine to check if everything is working. run_parallel(Translate('de', 'fr').sentence(line), n_threads=4) - - .. parsed-literal:: - 'Niem Ttog, niem Ttog, muraw tsah Ud hcim nessalrev?' + 'Mon Dieu, mon Dieu, pourquoi as Tu me quitter?' @@ -313,9 +349,15 @@ retrieval and result storage in a ``JobKeeper`` instance. .. parsed-literal:: - 'Niem Ttog, niem Ttog, muraw tsah Ud hcim nessalrev?' + 'Mon Dieu, mon Dieu, pourquoi as Tu me quitter?' +Now we can see how the results were obtained by inspecting the +``JobKeeper`` object. Running the first time, you may see that +some jobs *attached* themselves to other jobs as they are identical. +Then try running above cell again. All the results should be cached +in the `matthew.json` file, and no queries are send to Glosbe, saving +us from certain doom of IP black listing. .. code:: python diff --git a/noodles/run/run_with_prov.py b/noodles/run/run_with_prov.py index 2ada8f5..d7a62c1 100644 --- a/noodles/run/run_with_prov.py +++ b/noodles/run/run_with_prov.py @@ -103,7 +103,7 @@ def schedule_f(job_sink_): if status == 'retrieved': result_sink.send( (key, 'retrieved', - registry.deep_decode(result), None)) + registry.deep_decode(result, deref=True), None)) continue elif status == 'attached': continue diff --git a/noodles/serial/registry.py b/noodles/serial/registry.py index b1e57fa..34c007c 100644 --- a/noodles/serial/registry.py +++ b/noodles/serial/registry.py @@ -208,7 +208,8 @@ def decode(self, rec, deref=False): if '_noodles' not in rec: return rec - if rec.get('ref', False) and not deref: + # if rec.get('ref', False) and not deref: + if not deref: return RefObject(rec) typename = rec['type'] diff --git a/setup.py b/setup.py index 4d8f7b9..8146f87 100755 --- a/setup.py +++ b/setup.py @@ -12,7 +12,7 @@ setup( name='Noodles', - version='0.2.1', + version='0.2.2', description='Workflow Engine', author='Johan Hidding', url='https://github.com/NLeSC/noodles', @@ -23,8 +23,7 @@ 'noodles.prov'], classifiers=[ - 'License :: OSI Approved :: ' - 'GNU Lesser General Public License v3 or later (LGPLv3+)', + 'License :: OSI Approved :: Apache Software License', 'Intended Audience :: Developers', 'Intended Audience :: Science/Research', 'Environment :: Console', From 8bff4c64f3d61c3923eb0cb5f5420f5fe6487508 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Wed, 19 Oct 2016 18:29:26 +0200 Subject: [PATCH 027/155] restore optional deref, JPype crashes the JVM intermittently --- noodles/serial/registry.py | 4 +-- test/test_autostorable.py | 54 -------------------------------------- 2 files changed, 2 insertions(+), 56 deletions(-) delete mode 100644 test/test_autostorable.py diff --git a/noodles/serial/registry.py b/noodles/serial/registry.py index 34c007c..b70a8da 100644 --- a/noodles/serial/registry.py +++ b/noodles/serial/registry.py @@ -208,8 +208,8 @@ def decode(self, rec, deref=False): if '_noodles' not in rec: return rec - # if rec.get('ref', False) and not deref: - if not deref: + # if not deref: + if rec.get('ref', False) and not deref: return RefObject(rec) typename = rec['type'] diff --git a/test/test_autostorable.py b/test/test_autostorable.py deleted file mode 100644 index b4b7558..0000000 --- a/test/test_autostorable.py +++ /dev/null @@ -1,54 +0,0 @@ -from noodles import ( - schedule, run_process, gather, serial -) - - -def registry(): - return serial.pickle() + serial.base() - - -class A(object): - def __init__(self, a): - self.a = a - - @classmethod - def from_dict(cls, a): - return cls(a) - - def as_dict(self): - return {'a': self.a} - - -class B(object): - def __init__(self): - super(B, self).__init__() - - -@schedule -def g(a): - return A(a) - - -@schedule -def f(a): - b = B() - b.b = A(a.a * 5) - return b - - -@schedule -def h(b): - return b.b.a + 7 - - -def test_autostorable(): - a = g(7) - b = f(a) - c = h(b) - d = gather(c, a) - - result = run_process(d, 1, registry) - assert result[0] == 42 - assert result[1].a == 7 - - From 3946f0a6f2a9df9d34eae79b1f35e4e817ef2258 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Thu, 20 Oct 2016 14:16:23 +0200 Subject: [PATCH 028/155] remove some superfluous stuff from config.py --- noodles/config.py | 10 ---------- noodles/draw_workflow.py | 15 +++++++-------- noodles/run/xenon/xenon.py | 2 +- 3 files changed, 8 insertions(+), 19 deletions(-) diff --git a/noodles/config.py b/noodles/config.py index f961071..6a35fc8 100644 --- a/noodles/config.py +++ b/noodles/config.py @@ -4,14 +4,4 @@ # The functioning of the DelayedObject and Storable classes depend # on deep-copying arguments to scheduled functions. 'call_by_value': True, - - # use_prov: compute a MD5 hash of job descriptions and keep a database - # with the results. This is made optional, since it creates a computational - # overhead. - 'use_prov': True, - - # prov_serialiser: use this serialiser to compute the MD5 hash that - # generates the key used to identify jobs and workflows in the provenance - # database. Only has an effect if use_prov is True. - 'prov_serialiser': 'noodles.serial.base' } diff --git a/noodles/draw_workflow.py b/noodles/draw_workflow.py index 2a4d444..e68c1c5 100644 --- a/noodles/draw_workflow.py +++ b/noodles/draw_workflow.py @@ -1,9 +1,7 @@ -################################################################################ -# Drawing routines | -#------------------------------------------------------------------------------+ from pygraphviz import AGraph from inspect import Parameter + def _format_arg_list(a, v): if len(a) == 0: if v: @@ -18,13 +16,14 @@ def _format_arg_list(a, v): if v: return s.format("\u2026", "") - return s.format(str(a[-1]) if a[-1] != Parameter.empty else "\u2014", "") + return s.format(str(a[-1]) if a[-1] != Parameter.empty else "\u2014", "") + def draw_workflow(filename, workflow): - dot = AGraph(directed=True) #(comment="Computing scheme") - for i,n in workflow.nodes.items(): - dot.add_node(i, label="{0} \n {1}".format(n.foo.__name__, - _format_arg_list(n.bound_args.args, None))) + dot = AGraph(directed=True) # (comment="Computing scheme") + for i, n in workflow.nodes.items(): + dot.add_node(i, label="{0} \n {1}".format( + n.foo.__name__, _format_arg_list(n.bound_args.args, None))) for i in workflow.links: for j in workflow.links[i]: diff --git a/noodles/run/xenon/xenon.py b/noodles/run/xenon/xenon.py index 85f5e81..c429e45 100644 --- a/noodles/run/xenon/xenon.py +++ b/noodles/run/xenon/xenon.py @@ -17,7 +17,7 @@ class XenonConfig: These jobs may be run locally, over ssh ar against a queue manager like SLURM. - [Documentation to Xenon can be found online](http://nlesc.github.io/xenon) + [Documentation to Xenon can be found online](http://nlesc.github.io/Xenon) :param name: The quasi human readable name to give to this Xenon instance. From 83b43605a292781db3336784272e8473348bd31b Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Thu, 20 Oct 2016 14:17:06 +0200 Subject: [PATCH 029/155] add ujson to deps for better tinydb performance. --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index 8146f87..1d00d13 100755 --- a/setup.py +++ b/setup.py @@ -33,7 +33,7 @@ install_requires=[], extras_require={ - 'prov': ['tinydb'], + 'prov': ['tinydb', 'ujson'], 'xenon': ['pyxenon'], 'numpy': ['numpy', 'h5py', 'msgpack-python', 'filelock'], 'test': ['nose', 'coverage', 'pyflakes', 'pep8', 'docker-py'] From 9e802e8a7c87aece4aa4aedb444693ef6414ed6f Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Wed, 26 Oct 2016 15:35:52 +0200 Subject: [PATCH 030/155] started work on global prov keys --- noodles/prov/prov.py | 11 +++++-- noodles/prov/workflow.py | 67 ++++++++++++++++++++++++++++++++++++++ noodles/serial/registry.py | 13 ++++++-- noodles/workflow/model.py | 22 ++++++++++--- test/test_recursion.py | 8 ++--- 5 files changed, 107 insertions(+), 14 deletions(-) create mode 100644 noodles/prov/workflow.py diff --git a/noodles/prov/prov.py b/noodles/prov/prov.py index 4fdf101..12dac52 100644 --- a/noodles/prov/prov.py +++ b/noodles/prov/prov.py @@ -1,12 +1,16 @@ from tinydb import (TinyDB, Query) import hashlib -import json from threading import Lock # from ..utility import on import time import uuid import sys +try: + import ujson as json +except ImportError: + import json + def update_object_hash(m, obj): r = json.dumps(obj, sort_keys=True) @@ -14,7 +18,7 @@ def update_object_hash(m, obj): return m -def prov_key(job_msg): +def prov_key(job_msg, extra=None): """Retrieves a MD5 sum from a function call. This takes into account the name of the function, the arguments and possibly a version number of the function, if that is given in the hints. @@ -29,6 +33,9 @@ def prov_key(job_msg): if 'version' in job_msg['data']['hints']: update_object_hash(m, job_msg['data']['hints']['version']) + if extra is not None: + update_object_hash(m, extra) + return m.hexdigest() diff --git a/noodles/prov/workflow.py b/noodles/prov/workflow.py new file mode 100644 index 0000000..5425189 --- /dev/null +++ b/noodles/prov/workflow.py @@ -0,0 +1,67 @@ +from ..workflow import (Workflow, is_node_ready, Empty) +from ..workflow.arguments import (serialize_arguments, ref_argument) +from ..serial import (Registry) +from .prov import (prov_key) + + +def links(wf, i, deps): + for d in deps: + for l in wf.links[d]: + if l[0] == i: + yield (l[1], wf.nodes[d].prov) + + +def empty_args(n): + for arg in serialize_arguments(n.bound_args): + if ref_argument(n.bound_args, arg) == Empty: + yield arg + + +def set_global_provenance(wf: Workflow, registry: Registry): + """Compute a global provenance key for the entire workflow + before evaluation. This key can be used to store and retrieve + results in a database. The key computed in this stage is different + from the (local) provenance key that can be computed for a node + if all its arguments are known. + + In cases where a result derives from other results that were + computed in child workflows, we can prevent the workflow system + from reevaluating the results at each step to find that we already + had the end-result somewhere. This is where the global prov-key + comes in. + + Each node is assigned a `prov` attribute. If all arguments for this + node are known, this key will be the same as the local prov-key. + If some of the arguments are still empty, we add the global prov-keys + of the dependent nodes to the hash. + + In this algorithm we traverse from the bottom of the DAG to the top + and back using a stack. This allows us to compute the keys for each + node without modifying the node other than setting the `prov` attribute + with the resulting key.""" + stack = [wf.root] + + while stack: + i = stack.pop() + n = wf.nodes[i] + + if n.prov: + continue + + if is_node_ready(wf): + job_msg = registry.deep_encode(n) + n.prov = prov_key(job_msg) + continue + + deps = wf.inverse_links[i] + todo = [j for j in deps if not wf.node[j].prov] + + if not todo: + link_dict = dict(links(wf, i, deps)) + link_prov = registry.deep_encode( + [link_dict[arg] for arg in empty_args(n)]) + n.prov = prov_key(job_msg, link_prov) + continue + + stack.append(i) + stack.extend(deps) diff --git a/noodles/serial/registry.py b/noodles/serial/registry.py index b70a8da..9de5f3b 100644 --- a/noodles/serial/registry.py +++ b/noodles/serial/registry.py @@ -3,8 +3,11 @@ object_name, look_up, deep_map, inverse_deep_map) import noodles + +# try: +# import ujson as json +# except ImportError: import json -# import sys try: import msgpack @@ -234,8 +237,11 @@ def to_json(self, obj, host=None, indent=None): :param host: hostname where this object is being encoded. :type host: str""" - return json.dumps(deep_map(lambda o: self.encode(o, host), obj), - indent=indent) + if indent: + return json.dumps(deep_map(lambda o: self.encode(o, host), obj), + indent=indent) + else: + return json.dumps(deep_map(lambda o: self.encode(o, host), obj)) def to_msgpack(self, obj, host=None): return msgpack.packb(deep_map(lambda o: self.encode(o, host), obj)) @@ -252,6 +258,7 @@ def from_json(self, data, deref=False): :param deref: Whether to decode records that gave `ref=True` at encoding. :type deref: bool""" + # return self.deep_decode(json.loads(data), deref) return json.loads(data, object_hook=lambda o: self.decode(o, deref)) def from_msgpack(self, data, deref=False): diff --git a/noodles/workflow/model.py b/noodles/workflow/model.py index d480471..3824129 100644 --- a/noodles/workflow/model.py +++ b/noodles/workflow/model.py @@ -33,6 +33,7 @@ def __init__(self, foo, bound_args, hints, result=Empty): self.bound_args = bound_args self.hints = hints self.result = result + self.prov = None def apply(self): return self.foo(*self.bound_args.args, **self.bound_args.kwargs) @@ -41,8 +42,7 @@ def apply(self): def data(self): """Convert to a :py:class:`NodeData` for subsequent serial.""" return NodeData( - self.foo, get_arguments(self.bound_args), - self.hints) + self.foo, get_arguments(self.bound_args), self.hints) def __str__(self): s = self.foo.__name__ + '(' + \ @@ -81,13 +81,25 @@ def __iter__(self): def root_node(self): return self.nodes[self.root] + @property + def prov(self): + return self.root_node.prov + + @property + def inverse_links(self): + try: + return self._inverse_links + except AttributeError: + self.create_inverse_links() + return self._inverse_links + def create_inverse_links(self): - self.inverse_links = {} + self._inverse_links = {} for k, v in self.links.items(): for target, _ in v: if target not in self.inverse_links: - self.inverse_links[target] = set() - self.inverse_links[target].add(k) + self._inverse_links[target] = set() + self._inverse_links[target].add(k) def is_workflow(x): diff --git a/test/test_recursion.py b/test/test_recursion.py index 60316ae..d4d69a2 100644 --- a/test/test_recursion.py +++ b/test/test_recursion.py @@ -16,10 +16,10 @@ def factorial(n): def test_recursion_parallel(): - f100 = factorial(100) + f100 = factorial(50.0) result = run_parallel(f100, n_threads=1) print(result) - assert floor(log(result)) == 363 + assert floor(log(result)) == 148 def registry(): @@ -27,7 +27,7 @@ def registry(): def test_recursion_process(): - f100 = factorial(100) + f100 = factorial(50.0) result = run_process(f100, n_processes=1, registry=registry, verbose=False) print(result) - assert floor(log(result)) == 363 + assert floor(log(result)) == 148 From f90d0007e498c9f5da1b5bafbd5d2208bbfc0193 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Wed, 26 Oct 2016 17:00:55 +0200 Subject: [PATCH 031/155] add test for global prov --- noodles/prov/workflow.py | 5 +++-- test/test_global_prov.py | 26 ++++++++++++++++++++++++++ 2 files changed, 29 insertions(+), 2 deletions(-) create mode 100644 test/test_global_prov.py diff --git a/noodles/prov/workflow.py b/noodles/prov/workflow.py index 5425189..1c6eabf 100644 --- a/noodles/prov/workflow.py +++ b/noodles/prov/workflow.py @@ -48,18 +48,19 @@ def set_global_provenance(wf: Workflow, registry: Registry): if n.prov: continue - if is_node_ready(wf): + if is_node_ready(n): job_msg = registry.deep_encode(n) n.prov = prov_key(job_msg) continue deps = wf.inverse_links[i] - todo = [j for j in deps if not wf.node[j].prov] + todo = [j for j in deps if not wf.nodes[j].prov] if not todo: link_dict = dict(links(wf, i, deps)) link_prov = registry.deep_encode( [link_dict[arg] for arg in empty_args(n)]) + job_msg = registry.deep_encode(n) n.prov = prov_key(job_msg, link_prov) continue diff --git a/test/test_global_prov.py b/test/test_global_prov.py new file mode 100644 index 0000000..5478100 --- /dev/null +++ b/test/test_global_prov.py @@ -0,0 +1,26 @@ +from noodles.prov.workflow import (set_global_provenance) +from noodles.tutorial import (add, sub, mul) +from noodles.serial import base + + +def test_global_prov(): + a = add(4, 5) + b = sub(a, 3) + c = mul(b, 7) + d = mul(b, 7) + e = sub(c, 3) + f = sub(c, 5) + + set_global_provenance(c._workflow, base()) + + assert c._workflow.prov is not None + assert b._workflow.prov is not None + assert c._workflow.prov != b._workflow.prov + + set_global_provenance(d._workflow, base()) + set_global_provenance(e._workflow, base()) + set_global_provenance(f._workflow, base()) + + assert c._workflow.prov == d._workflow.prov + assert b._workflow.prov != e._workflow.prov + assert f._workflow.prov != e._workflow.prov From f1d04a65aa709f0a06f98cee17428ab76ba22d0c Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Thu, 27 Oct 2016 15:32:29 +0200 Subject: [PATCH 032/155] started formalising remote worker IO, msgpack support --- noodles/run/messages.py | 38 ++++++++++++++++++ noodles/run/remote/io.py | 37 ++++++++++++++++++ noodles/run/scheduler.py | 14 ++----- noodles/serial/__init__.py | 3 +- noodles/serial/base.py | 18 ++++++++- noodles/serial/reasonable.py | 24 ++++++++++++ noodles/serial/registry.py | 2 +- test/{ => test_run}/test_haploid.py | 0 test/test_run/test_remote_io.py | 51 +++++++++++++++++++++++++ test/{ => test_run}/test_xenon_local.py | 0 10 files changed, 173 insertions(+), 14 deletions(-) create mode 100644 noodles/run/messages.py create mode 100644 noodles/run/remote/io.py create mode 100644 noodles/serial/reasonable.py rename test/{ => test_run}/test_haploid.py (100%) create mode 100644 test/test_run/test_remote_io.py rename test/{ => test_run}/test_xenon_local.py (100%) diff --git a/noodles/run/messages.py b/noodles/run/messages.py new file mode 100644 index 0000000..84df25e --- /dev/null +++ b/noodles/run/messages.py @@ -0,0 +1,38 @@ +""" +Messages to facilitate communication between scheduler and remote workers. +There are currently three types of messages: + + * ``JobMessage``, sending a job to a worker. + * ``ResultMessage``, a worker returning a result. + * ``PilotMessage``, extra communication back and forth, status updates, + performance information, but also stopping a worker in a nice way. +""" + +from ..serial import Reasonable + + +class JobMessage(Reasonable): + def __init__(self, key, node): + self.key = key + self.node = node + + def __iter__(self): + return iter((self.key, self.node)) + + +class ResultMessage(Reasonable): + def __init__(self, key, status, value, msg): + self.key = key + self.status = status + self.value = value + self.msg = msg + + def __iter__(self): + return iter((self.key, self.status, self.value, self.msg)) + + +class PilotMessage(Reasonable): + def __init__(self, msg, **kwargs): + self.msg = msg + self.__dict__.update(kwargs) + diff --git a/noodles/run/remote/io.py b/noodles/run/remote/io.py new file mode 100644 index 0000000..c09f161 --- /dev/null +++ b/noodles/run/remote/io.py @@ -0,0 +1,37 @@ +""" +Manage IO between remote worker/pilot job, and the scheduler. Here there are +two options: use json, or msgpack. +""" + +from ..coroutine import coroutine + +try: + import msgpack +except ImportError: + pass + + +def MsgPackObjectReader(registry, fi, deref=False): + yield from msgpack.Unpacker( + fi, object_hook=lambda o: registry.decode(o, deref), + encoding='utf-8') + + +@coroutine +def MsgPackObjectWriter(registry, fo, host=None): + while True: + obj = yield + fo.write(registry.to_msgpack(obj, host=host)) + + +def JSONObjectReader(registry, fi, deref=False): + for line in fi: + yield registry.from_json(line, deref=deref) + + +@coroutine +def JSONObjectWriter(registry, fo, host=None): + while True: + obj = yield + print(registry.to_json(obj, host=host), file=fo, flush=True) + diff --git a/noodles/run/scheduler.py b/noodles/run/scheduler.py index 23f5b4b..4c2eb32 100644 --- a/noodles/run/scheduler.py +++ b/noodles/run/scheduler.py @@ -1,5 +1,7 @@ from .connection import (Connection) from .job_keeper import (JobKeeper) +from .messages import (ResultMessage as Result) + from ..workflow import ( is_workflow, get_workflow, insert_result, is_node_ready, Workflow) @@ -8,6 +10,7 @@ class Job: + """A Job message.""" def __init__(self, workflow, node_id): self.workflow = workflow self.node_id = node_id @@ -20,17 +23,6 @@ def node(self): return self.workflow.nodes[self.node_id] -class Result: - def __init__(self, key, status, value, msg): - self.key = key - self.status = status - self.value = value - self.msg = msg - - def __iter__(self): - return iter((self.key, self.status, self.value, self.msg)) - - class DynamicLink: def __init__(self, source, target, node): self.source = source diff --git a/noodles/serial/__init__.py b/noodles/serial/__init__.py index e9a062a..ee42277 100644 --- a/noodles/serial/__init__.py +++ b/noodles/serial/__init__.py @@ -4,6 +4,7 @@ from .as_dict import AsDict from .namedtuple import registry as namedtuple from .registry import (Registry, Serialiser, RefObject) +from .reasonable import (Reasonable) __all__ = ['pickle', 'base', 'Registry', 'Serialiser', - 'RefObject', 'AsDict', 'namedtuple'] + 'RefObject', 'AsDict', 'namedtuple', 'Reasonable'] diff --git a/noodles/serial/base.py b/noodles/serial/base.py index 4a3293b..7bc6f67 100644 --- a/noodles/serial/base.py +++ b/noodles/serial/base.py @@ -1,5 +1,6 @@ from .registry import (Registry, Serialiser) -from ..interface import (PromisedObject) +from .reasonable import (Reasonable, SerReasonableObject) +from ..interface import (PromisedObject) from ..utility import (object_name, look_up, importable) from ..workflow import (Workflow, NodeData, FunctionNode, ArgumentAddress, ArgumentKind, reset_workflow, get_workflow) @@ -24,6 +25,19 @@ def decode(self, cls, data): return cls(data) +class SerTuple(Serialiser): + """Tuples get converted to lists during serialisation. + We want to get tuples back, so make this explicit.""" + def __init__(self): + super(SerTuple, self).__init__(tuple) + + def encode(self, obj, make_rec): + return make_rec(list(obj)) + + def decode(self, cls, data): + return cls(data) + + class SerEnum(Serialiser): def __init__(self, cls): super(SerEnum, self).__init__(cls) @@ -170,6 +184,8 @@ def registry(): return Registry( types={ dict: SerDict(), + tuple: SerTuple(), + Reasonable: SerReasonableObject(Reasonable), ArgumentKind: SerEnum(ArgumentKind), FunctionNode: SerNode(), ArgumentAddress: SerNamedTuple(ArgumentAddress), diff --git a/noodles/serial/reasonable.py b/noodles/serial/reasonable.py new file mode 100644 index 0000000..f7d4253 --- /dev/null +++ b/noodles/serial/reasonable.py @@ -0,0 +1,24 @@ +from .registry import Serialiser + + +class Reasonable(object): + """A Reasonable object is an object which is most reasonably serialised + using its `__dict__` property. To deserialise the object, we first create + an instance using the `__new__` method, then setting the `__dict__` + property manualy. This class is empty, it is used as a tag to designate + other objects as reasonable.""" + pass + + +class SerReasonableObject(Serialiser): + def __init__(self, cls): + super(SerReasonableObject, self).__init__(cls) + + def encode(self, obj, make_rec): + return make_rec(obj.__dict__) + + def decode(self, cls, data): + obj = cls.__new__(cls) + obj.__dict__ = data + return obj + diff --git a/noodles/serial/registry.py b/noodles/serial/registry.py index 9de5f3b..cd3e752 100644 --- a/noodles/serial/registry.py +++ b/noodles/serial/registry.py @@ -160,7 +160,7 @@ def encode(self, obj, host=None): if obj is None: return None - if type(obj) in [dict, list, str, int, float, bool, tuple]: + if type(obj) in [dict, list, str, int, float, bool]: return obj if isinstance(obj, RefObject): diff --git a/test/test_haploid.py b/test/test_run/test_haploid.py similarity index 100% rename from test/test_haploid.py rename to test/test_run/test_haploid.py diff --git a/test/test_run/test_remote_io.py b/test/test_run/test_remote_io.py new file mode 100644 index 0000000..e1e02de --- /dev/null +++ b/test/test_run/test_remote_io.py @@ -0,0 +1,51 @@ +from nose.plugins.skip import SkipTest +import io + +from noodles.run.remote.io import ( + MsgPackObjectReader, MsgPackObjectWriter, + JSONObjectReader, JSONObjectWriter) +from noodles.serial import base as registry +import math + +try: + import msgpack + has_msgpack = True +except ImportError: + has_msgpack = False + + +objects = ["Hello", 42, [3, 4], (5, 6), {"hello": "world"}, + math.tan, object] + + +def test_msgpack(): + if not has_msgpack: + raise SkipTest("No MsgPack installed.") + + f = io.BytesIO() + output_stream = MsgPackObjectWriter(registry(), f) + + for obj in objects: + output_stream.send(obj) + + f.seek(0) + input_stream = MsgPackObjectReader(registry(), f) + + new_objects = list(input_stream) + assert new_objects == objects + + +def test_json(): + f = io.StringIO() + output_stream = JSONObjectWriter(registry(), f) + + for obj in objects: + output_stream.send(obj) + + f.seek(0) + input_stream = JSONObjectReader(registry(), f) + + new_objects = list(input_stream) + + assert new_objects == objects + diff --git a/test/test_xenon_local.py b/test/test_run/test_xenon_local.py similarity index 100% rename from test/test_xenon_local.py rename to test/test_run/test_xenon_local.py From 7a4210ac0b88939d8c768cc89df33fadb94e85ca Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Thu, 27 Oct 2016 16:30:04 +0200 Subject: [PATCH 033/155] harmonize remote worker io, getting rid of assumption in code that keys are uuids --- noodles/prov/prov.py | 25 +++++------ noodles/run/job_keeper.py | 4 +- noodles/run/process.py | 75 +++++-------------------------- noodles/run/remote/io.py | 1 + noodles/run/scheduler.py | 1 - noodles/run/worker.py | 10 ++--- noodles/run/xenon/dynamic_pool.py | 44 ++++++------------ noodles/worker.py | 65 ++++++++++----------------- 8 files changed, 69 insertions(+), 156 deletions(-) diff --git a/noodles/prov/prov.py b/noodles/prov/prov.py index 12dac52..4c392cf 100644 --- a/noodles/prov/prov.py +++ b/noodles/prov/prov.py @@ -3,7 +3,6 @@ from threading import Lock # from ..utility import on import time -import uuid import sys try: @@ -71,14 +70,14 @@ def get_result_or_attach(self, key, prov, running): rec = self.db.get(job.prov == prov) if 'result' in rec: - return 'retrieved', uuid.UUID(rec['key']), rec['result'] + return 'retrieved', rec['key'], rec['result'] - job_running = uuid.UUID(rec['key']) in running + job_running = rec['key'] in running wf_running = rec['link'] in running.workflows if job_running or wf_running: - self.db.update(attach_job(key.hex), job.prov == prov) - return 'attached', uuid.UUID(rec['key']), None + self.db.update(attach_job(key), job.prov == prov) + return 'attached', rec['key'], None print("WARNING: unfinished job in database. Removing it and " " rerunning.", file=sys.stderr) @@ -93,21 +92,21 @@ def job_exists(self, prov): def store_result(self, key, result): job = Query() with self.lock: - if not self.db.contains(job.key == key.hex): + if not self.db.contains(job.key == key): return self.add_time_stamp(key, 'done') with self.lock: self.db.update( {'result': result, 'link': None}, - job.key == key.hex) - rec = self.db.get(job.key == key.hex) - return map(uuid.UUID, rec['attached']) + job.key == key) + rec = self.db.get(job.key == key) + return rec['attached'] def new_job(self, key, prov, job_msg): with self.lock: self.db.insert({ - 'key': key.hex, + 'key': key, 'attached': [], 'prov': prov, 'link': None, @@ -122,13 +121,13 @@ def new_job(self, key, prov, job_msg): def add_link(self, key, ppn): job = Query() with self.lock: - self.db.update({'link': ppn}, job.key == key.hex) + self.db.update({'link': ppn}, job.key == key) def get_linked_jobs(self, ppn): job = Query() with self.lock: rec = self.db.search(job.link == ppn) - return [uuid.UUID(r['key']) for r in rec] + return [r['key'] for r in rec] def add_time_stamp(self, key, name): def update(r): @@ -138,4 +137,4 @@ def update(r): with self.lock: self.db.update( update, - job.key == key.hex) + job.key == key) diff --git a/noodles/run/job_keeper.py b/noodles/run/job_keeper.py index ce61f89..51f6172 100644 --- a/noodles/run/job_keeper.py +++ b/noodles/run/job_keeper.py @@ -16,7 +16,7 @@ def __init__(self, keep=False): def register(self, job): with self.lock: - key = uuid.uuid1() + key = str(uuid.uuid4()) job.log = [] job.log.append((time.time(), 'register', None, None)) self[key] = job @@ -66,7 +66,7 @@ def __init__(self, timing_file, registry=None): self.owner = False def register(self, job): - key = uuid.uuid1() + key = str(uuid.uuid4()) job.sched_time = time.time() self[key] = job return key, job.node diff --git a/noodles/run/process.py b/noodles/run/process.py index 81f5e51..5adb5b4 100644 --- a/noodles/run/process.py +++ b/noodles/run/process.py @@ -13,6 +13,10 @@ from .hybrid import hybrid_threaded_worker from .haploid import (pull, push) +from .remote.io import ( + MsgPackObjectReader, MsgPackObjectWriter, + JSONObjectReader, JSONObjectWriter) + try: import msgpack has_msgpack = True @@ -20,51 +24,14 @@ has_msgpack = False -def get_result_tuple(msg): - key = msg['key'] - status = msg['status'] - - try: - key = uuid.UUID(key) - except ValueError: - pass - - return key, status, msg['result'], msg['err_msg'] - - -def read_result_json(registry, s): - obj = registry.from_json(s) - key = obj['key'] - status = obj['status'] - - try: - key = uuid.UUID(key) - except ValueError: - pass - - return key, status, obj['result'], obj['err_msg'] - - -def job_msg(registry, host, key, job): - obj = {'key': key if isinstance(key, str) else key.hex, - 'node': job} - return registry.to_msgpack(obj, host=host) - - -def put_job(registry, host, key, job): - obj = {'key': key if isinstance(key, str) else key.hex, - 'node': job} - return registry.to_json(obj, host=host) - - -def process_worker(registry, - verbose=False, jobdirs=False, +def process_worker(registry, verbose=False, jobdirs=False, init=None, finish=None, status=True, use_msgpack=False): name = "process-" + str(uuid.uuid4()) cmd = ["/bin/bash", os.getcwd() + "/worker.sh", sys.prefix, "online", "-name", name, "-registry", object_name(registry)] if use_msgpack: + assert has_msgpack cmd.append("-msgpack") if verbose: cmd.append("-verbose") @@ -92,36 +59,18 @@ def read_stderr(): @push def send_job(): reg = registry() - while True: - key, job = yield - if use_msgpack: - p.stdin.buffer.write(job_msg(reg, name, key, job)) - p.stdin.flush() - else: - print(put_job(reg, name, key, job), file=p.stdin, flush=True) + if use_msgpack: + yield from MsgPackObjectWriter(reg, p.stdin.buffer) + else: + yield from JSONObjectWriter(reg, p.stdin) @pull def get_result(): reg = registry() if use_msgpack: - messages = msgpack.Unpacker( - p.stdout.buffer, object_hook=reg.decode) + yield from MsgPackObjectReader(reg, p.stdout.buffer) else: - messages = (reg.from_json(line) for line in p.stdout) - - for msg in messages: - result = get_result_tuple(msg) - yield result - - # if init is not None: - # send_job().send(("init", init()._workflow.root_node)) - # key, status, result, err_msg = next(get_result()) - # if key != "init" or not result: - # raise RuntimeError( - # "The initializer function did not succeed on worker.") - # - # if finish is not None: - # send_job().send(("finish", finish()._workflow.root_node)) + yield from JSONObjectReader(reg, p.stdout) return Connection(get_result, send_job, aux=read_stderr) diff --git a/noodles/run/remote/io.py b/noodles/run/remote/io.py index c09f161..29c043c 100644 --- a/noodles/run/remote/io.py +++ b/noodles/run/remote/io.py @@ -22,6 +22,7 @@ def MsgPackObjectWriter(registry, fo, host=None): while True: obj = yield fo.write(registry.to_msgpack(obj, host=host)) + fo.flush() def JSONObjectReader(registry, fi, deref=False): diff --git a/noodles/run/scheduler.py b/noodles/run/scheduler.py index 4c2eb32..33cf3d6 100644 --- a/noodles/run/scheduler.py +++ b/noodles/run/scheduler.py @@ -10,7 +10,6 @@ class Job: - """A Job message.""" def __init__(self, workflow, node_id): self.workflow = workflow self.node_id = node_id diff --git a/noodles/run/worker.py b/noodles/run/worker.py index 14ef4fe..82f5125 100644 --- a/noodles/run/worker.py +++ b/noodles/run/worker.py @@ -1,5 +1,5 @@ from .haploid import (pull_map) -from .scheduler import (Result) +from .messages import (ResultMessage) from ..interface import (AnnotatedValue, JobException) from ..utility import (object_name) import sys @@ -22,7 +22,7 @@ def run_job(key, job): result = job.apply() if isinstance(result, tuple) and len(result) == 2: value, msg = result - return Result(key, 'done', value, msg) + return ResultMessage(key, 'done', value, msg) else: raise TypeError("You promised annotation in call " "to function {} but return value " @@ -33,10 +33,10 @@ def run_job(key, job): result = job.apply() if isinstance(result, AnnotatedValue): value, message = result - return Result(key, 'done', value, message) + return ResultMesage(key, 'done', value, message) - return Result(key, 'done', result, None) + return ResultMessage(key, 'done', result, None) except Exception as error: exc_info = sys.exc_info() - return Result(key, 'error', None, JobException(*exc_info)) + return ResultMessage(key, 'error', None, JobException(*exc_info)) diff --git a/noodles/run/xenon/dynamic_pool.py b/noodles/run/xenon/dynamic_pool.py index 3a7711a..6320d98 100644 --- a/noodles/run/xenon/dynamic_pool.py +++ b/noodles/run/xenon/dynamic_pool.py @@ -2,7 +2,12 @@ from ..connection import Connection from ..coroutine import coroutine from ..haploid import (push) -from ..scheduler import Result + +from ..messages import ( + ResultMessage, JobMessage) + +from ..remote.io import ( + JSONObjectWriter, JSONObjectReader) import xenon import jpype @@ -15,24 +20,6 @@ from .xenon import (XenonKeeper, XenonConfig, XenonScheduler) -def read_result(registry, s): - obj = registry.from_json(s) - status = obj['status'] - key = obj['key'] - try: - key = uuid.UUID(key) - except ValueError: - pass - - return Result(key, status, obj['result'], obj['err_msg']) - - -def put_job(registry, host, key, job): - obj = {'key': key if isinstance(key, str) else key.hex, - 'node': job} - return registry.to_json(obj, host=host) - - def xenon_interactive_worker(XeS: XenonScheduler, job_config): """Uses Xenon to run a single remote interactive worker. @@ -60,20 +47,17 @@ def read_stderr(): registry = job_config.registry() - @coroutine + @push def send_job(): - out = xenon.conversions.OutputStream(J.streams.getStdin()) - - while True: - key, ujob = yield - print(put_job(registry, 'scheduler', key, ujob), - file=out, flush=True) + output_stream = xenon.conversions.OutputStream(J.streams.getStdin()) + yield from JSONObjectWriter(reg, output_stream, host="scheduler") + @pull def get_result(): - """ Returns a result tuple: key, status, result, err_msg """ - for line in xenon.conversions.read_lines(J.streams.getStdout()): - yield read_result(registry, line) - + reg = registry() + input_stream = xenon.conversions.InputStream(J.streams.getStdout()): + yield from JSONObjectReader(reg, input_stream) + return Connection(get_result, send_job, aux=J) diff --git a/noodles/worker.py b/noodles/worker.py index cb2993a..0d70522 100644 --- a/noodles/worker.py +++ b/noodles/worker.py @@ -30,7 +30,6 @@ from contextlib import redirect_stdout import os -from noodles.run.worker import run_job from .utility import (look_up) try: @@ -39,33 +38,16 @@ except ImportError: has_msgpack = False +from .run.worker import ( + run_job) -def get_job(msg): - return msg['key'], msg['node'] - - -def get_job_json(registry, s): - obj = registry.from_json(s, deref=True) - return obj['key'], obj['node'] - - -def put_result_msgpack(registry, host, key, status, result, err_msg): - return registry.to_msgpack({ - 'key': key, - 'status': status, - 'result': result, - 'err_msg': err_msg - }, host=host) - - -def put_result_json(registry, host, key, status, result, err_msg): - return registry.to_json({ - 'key': key, - 'status': status, - 'result': result, - 'err_msg': err_msg - }, host=host) - +from .run.messages import ( + JobMessage, ResultMessage) + +from .run.remote.io import ( + MsgPackObjectReader, MsgPackObjectWriter, + JSONObjectReader, JSONObjectWriter) + def run_batch_mode(args): print("Batch mode is not yet implemented") @@ -77,13 +59,15 @@ def run_online_mode(args): finish = None if args.msgpack: - messages = msgpack.Unpacker(sys.stdin.buffer) + input_stream = MsgPackObjectReader( + registry, sys.stdin.buffer, deref=True) + output_stream = MsgPackObjectWriter( + registry, sys.stdout.buffer, host=args.name) else: - def msg_stream(): - for line in sys.stdin: - yield registry.from_json(line, deref=True) - - messages = msg_stream() + input_stream = JSONObjectReader( + registry, sys.stdin, deref=True) + output_stream = JSONObjectWriter( + registry, sys.stdout, host=args.name) # run the init function if it is given if args.init: @@ -93,8 +77,11 @@ def msg_stream(): if args.finish: finish = look_up(args.finish) - for msg in messages: - key, job = get_job(msg) + for msg in input_stream: + if isinstance(msg, JobMessage): + key, job = msg + else: + continue if args.jobdirs: # make a directory @@ -122,13 +109,7 @@ def msg_stream(): # parent directory os.chdir("..") - if args.msgpack: - sys.stdout.buffer.write(put_result_msgpack( - registry, args.name, *result)) - sys.stdout.flush() - else: - print(put_result_json(registry, args.name, *result), - flush=True) + output_stream.send(result) if finish: finish() From 21df38c246a9251006bb23145a9438219c943e1d Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Thu, 27 Oct 2016 17:11:10 +0200 Subject: [PATCH 034/155] tests are working again --- noodles/run/hybrid.py | 13 +++++++------ noodles/run/job_keeper.py | 5 +++-- noodles/run/process.py | 9 +++++---- noodles/run/protect.py | 3 ++- noodles/run/remote/io.py | 3 +++ noodles/run/run_with_prov.py | 9 +++++---- noodles/run/scheduler.py | 2 +- noodles/run/xenon/dynamic_pool.py | 11 +++++------ noodles/worker.py | 2 ++ 9 files changed, 33 insertions(+), 24 deletions(-) diff --git a/noodles/run/hybrid.py b/noodles/run/hybrid.py index a19577b..de56e27 100644 --- a/noodles/run/hybrid.py +++ b/noodles/run/hybrid.py @@ -30,13 +30,14 @@ def hybrid_coroutine_worker(selector, workers): def get_result(): source = jobs.source() - for key, job in source: + for msg in source: + key, job = msg worker = selector(job) if worker is None: yield run_job(key, job) else: # send the worker a job and wait for it to return - worker_sink[worker].send((key, job)) + worker_sink[worker].send(msg) result = next(worker_source[worker]) yield result @@ -89,12 +90,12 @@ def dispatch_job(): default_sink = results.sink() while True: - key, job = yield - worker = selector(job) + msg = yield + worker = selector(msg.node) if worker: - job_sink[worker].send((key, job)) + job_sink[worker].send(msg) else: - default_sink.send(run_job(key, job)) + default_sink.send(run_job(*msg)) for key, worker in workers.items(): t = threading.Thread( diff --git a/noodles/run/job_keeper.py b/noodles/run/job_keeper.py index 51f6172..fc82059 100644 --- a/noodles/run/job_keeper.py +++ b/noodles/run/job_keeper.py @@ -5,6 +5,7 @@ from threading import Lock from .haploid import (coroutine) +from .messages import (JobMessage) class JobKeeper(dict): @@ -21,7 +22,7 @@ def register(self, job): job.log.append((time.time(), 'register', None, None)) self[key] = job - return key, job.node + return JobMessage(key, job.node) def __delitem__(self, key): if not self.keep: @@ -69,7 +70,7 @@ def register(self, job): key = str(uuid.uuid4()) job.sched_time = time.time() self[key] = job - return key, job.node + return JobMessage(key, job.node) def __delitem__(self, key): pass diff --git a/noodles/run/process.py b/noodles/run/process.py index 5adb5b4..6c145f4 100644 --- a/noodles/run/process.py +++ b/noodles/run/process.py @@ -1,6 +1,7 @@ import sys import uuid from subprocess import Popen, PIPE +import threading import os import random @@ -50,11 +51,11 @@ def process_worker(registry, verbose=False, jobdirs=False, def read_stderr(): for line in p.stderr: - log.worker_stderr(name, line) + print(name + ": " + line.strip(), file=sys.stderr, flush=True) - # t = threading.Thread(target=read_stderr) - # t.daemon = True - # t.start() + t = threading.Thread(target=read_stderr) + t.daemon = True + t.start() @push def send_job(): diff --git a/noodles/run/protect.py b/noodles/run/protect.py index 27a5fda..648e17a 100644 --- a/noodles/run/protect.py +++ b/noodles/run/protect.py @@ -1,4 +1,5 @@ from functools import wraps +from .messages import (ResultMessage) from .haploid import (push_map, pull_map) import threading @@ -59,7 +60,7 @@ def protected_fn(*args, **kwargs): except Exception as exc: with self.lock: for key in self.jobs: - sink.send((key, 'aborted', None, exc)) + sink.send(ResultMessage(key, 'aborted', None, exc)) raise exc diff --git a/noodles/run/remote/io.py b/noodles/run/remote/io.py index 29c043c..4db51e8 100644 --- a/noodles/run/remote/io.py +++ b/noodles/run/remote/io.py @@ -32,7 +32,10 @@ def JSONObjectReader(registry, fi, deref=False): @coroutine def JSONObjectWriter(registry, fo, host=None): + import sys while True: obj = yield + #obj_msg = registry.to_json(obj, host=host) + #print(obj_msg, file=sys.stderr) print(registry.to_json(obj, host=host), file=fo, flush=True) diff --git a/noodles/run/run_with_prov.py b/noodles/run/run_with_prov.py index d7a62c1..fa5a3d6 100644 --- a/noodles/run/run_with_prov.py +++ b/noodles/run/run_with_prov.py @@ -1,6 +1,7 @@ from .connection import (Connection) from .queue import (Queue) -from .scheduler import (Scheduler, Result) +from .scheduler import (Scheduler) +from .messages import (ResultMessage) from .haploid import ( pull, push, push_map, sink_map, branch, patch, broadcast) @@ -26,7 +27,7 @@ def run_single(wf, registry, jobdb_file, display=None): db = JobDB(jobdb_file) def decode_result(key, obj): - return Result(key, 'retrieved', registry.deep_decode(obj), None) + return ResultMessage(key, 'retrieved', registry.deep_decode(obj), None) @pull def pass_job(source): @@ -132,7 +133,7 @@ def store_result(key, result, msg): attached = db.store_result(key, result_msg) if attached: for akey in attached: - yield (akey, 'attached', result, msg) + yield ResultMessage(akey, 'attached', result, msg) @pull def f(source): @@ -157,7 +158,7 @@ def f(source): for k in linked_jobs: yield from store_result(k, result, msg) - yield (key, status, result, msg) + yield ResultMessage(key, status, result, msg) return f diff --git a/noodles/run/scheduler.py b/noodles/run/scheduler.py index 33cf3d6..8bc169d 100644 --- a/noodles/run/scheduler.py +++ b/noodles/run/scheduler.py @@ -1,6 +1,6 @@ from .connection import (Connection) from .job_keeper import (JobKeeper) -from .messages import (ResultMessage as Result) +from .messages import (JobMessage) from ..workflow import ( is_workflow, get_workflow, insert_result, diff --git a/noodles/run/xenon/dynamic_pool.py b/noodles/run/xenon/dynamic_pool.py index 6320d98..621d9f7 100644 --- a/noodles/run/xenon/dynamic_pool.py +++ b/noodles/run/xenon/dynamic_pool.py @@ -50,13 +50,12 @@ def read_stderr(): @push def send_job(): output_stream = xenon.conversions.OutputStream(J.streams.getStdin()) - yield from JSONObjectWriter(reg, output_stream, host="scheduler") + yield from JSONObjectWriter(registry, output_stream, host="scheduler") - @pull + # @pull def get_result(): - reg = registry() - input_stream = xenon.conversions.InputStream(J.streams.getStdout()): - yield from JSONObjectReader(reg, input_stream) + input_stream = xenon.conversions.InputStream(J.streams.getStdout()) + yield from JSONObjectReader(registry, input_stream) return Connection(get_result, send_job, aux=J) @@ -188,7 +187,7 @@ def activate(_): # lock end ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ for key in w.jobs: - sink.send(Result(key, 'aborted', None, + sink.send(ResultMessage(key, 'aborted', None, 'connection to remote worker lost.')) # Start the `activate` function when the worker goes online. diff --git a/noodles/worker.py b/noodles/worker.py index 0d70522..6927bed 100644 --- a/noodles/worker.py +++ b/noodles/worker.py @@ -80,6 +80,8 @@ def run_online_mode(args): for msg in input_stream: if isinstance(msg, JobMessage): key, job = msg + elif isinstance(msg, tuple): + key, job = msg else: continue From 4b400c0d60f68fef038c1f775999583b91d9ca45 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Thu, 27 Oct 2016 17:45:06 +0200 Subject: [PATCH 035/155] msgpack is working for process runner! --- noodles/run/process.py | 7 ++++--- noodles/worker.py | 3 ++- test/test_capture_output.py | 2 +- test/test_worker.py | 2 +- 4 files changed, 8 insertions(+), 6 deletions(-) diff --git a/noodles/run/process.py b/noodles/run/process.py index 6c145f4..5fdacd2 100644 --- a/noodles/run/process.py +++ b/noodles/run/process.py @@ -69,7 +69,8 @@ def send_job(): def get_result(): reg = registry() if use_msgpack: - yield from MsgPackObjectReader(reg, p.stdout.buffer) + newin = os.fdopen(p.stdout.fileno(), 'rb', buffering=0) + yield from MsgPackObjectReader(reg, newin) else: yield from JSONObjectReader(reg, p.stdout) @@ -78,7 +79,7 @@ def get_result(): def run_process(wf, n_processes, registry, verbose=False, jobdirs=False, - init=None, finish=None, deref=False): + init=None, finish=None, deref=False, use_msgpack=False): """Run the workflow using a number of new python processes. Use this runner to test the workflow in a situation where data serial is needed. @@ -117,7 +118,7 @@ def run_process(wf, n_processes, registry, """ workers = {} for i in range(n_processes): - new_worker = process_worker(registry, verbose, jobdirs, init, finish) + new_worker = process_worker(registry, verbose, jobdirs, init, finish, use_msgpack=use_msgpack) workers['worker {0:2}'.format(i)] = new_worker worker_names = list(workers.keys()) diff --git a/noodles/worker.py b/noodles/worker.py index 6927bed..73df658 100644 --- a/noodles/worker.py +++ b/noodles/worker.py @@ -59,8 +59,9 @@ def run_online_mode(args): finish = None if args.msgpack: + newin = os.fdopen(sys.stdin.fileno(), 'rb', buffering=0) input_stream = MsgPackObjectReader( - registry, sys.stdin.buffer, deref=True) + registry, newin, deref=True) output_stream = MsgPackObjectWriter( registry, sys.stdout.buffer, host=args.name) else: diff --git a/test/test_capture_output.py b/test/test_capture_output.py index 609faf3..ca3167b 100644 --- a/test/test_capture_output.py +++ b/test/test_capture_output.py @@ -9,5 +9,5 @@ def writes_to_stdout(): def test_capture_output(): a = writes_to_stdout() - result = run_process(a, n_processes=1, registry=serial.base) + result = run_process(a, n_processes=1, registry=serial.base, use_msgpack=True) assert result == 42 diff --git a/test/test_worker.py b/test/test_worker.py index f0762f3..5f13ce4 100644 --- a/test/test_worker.py +++ b/test/test_worker.py @@ -25,7 +25,7 @@ def test_worker(): b = ssum(gather(*a)) result = Scheduler().run( - process_worker(registry), + process_worker(registry, use_msgpack=True), get_workflow(b)) assert result == 100 From 7bea220d15d7794aaa0366c99b324b91169273e3 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Mon, 21 Nov 2016 11:27:46 +0100 Subject: [PATCH 036/155] some work on config files --- examples/noodles.ini | 35 +++++++++ noodles/config.py | 7 ++ noodles/run/config.py | 167 ++++++++++++++++++++++++++++++++++++++++++ noodles/run/run.py | 83 +++++++++++++++++++++ 4 files changed, 292 insertions(+) create mode 100644 examples/noodles.ini create mode 100644 noodles/run/config.py create mode 100644 noodles/run/run.py diff --git a/examples/noodles.ini b/examples/noodles.ini new file mode 100644 index 0000000..9513446 --- /dev/null +++ b/examples/noodles.ini @@ -0,0 +1,35 @@ +[default] +machine=local + +[Machines] + [local] + runner=parallel + features=prov, display + n_threads=4 + + [debug] + runner=process + features=msgpack + verbose=True + + [cartesius] + runner=xenon + features=prov, display + host=cartesius.surfsara.nl + scheme=slurm + user=jhidding + n_jobs=1 + n_threads_per_job=16 + + [das5] + runner=xenon + featuers=prov, display + host=fs0.das5.cs.vu.nl + scheme=slurm + user=jhidding + +[Users] + [] + username= + protocol=ssh + certificate=~/.ssh/id_rsa diff --git a/noodles/config.py b/noodles/config.py index 6a35fc8..db7a14c 100644 --- a/noodles/config.py +++ b/noodles/config.py @@ -1,3 +1,4 @@ +import configparser config = { # call_by_value: keep this True unless you know what you're doing. @@ -5,3 +6,9 @@ # on deep-copying arguments to scheduled functions. 'call_by_value': True, } + + +def read_config(filename: str): + config = configparser.ConfigParser() + config.read(filename) + return config diff --git a/noodles/run/config.py b/noodles/run/config.py new file mode 100644 index 0000000..f93f3ac --- /dev/null +++ b/noodles/run/config.py @@ -0,0 +1,167 @@ +import configparser +from typing import (List) +from ..utility import (look_up) + + +runners = [ + # ======================================================================= # + # Single threaded runners + # ======================================================================= # + { + 'name': 'single', + 'features': [], + 'description': """ + Run a workflow in a single thread. This is the absolute minimal + runner, consisting of a single queue for jobs and a worker running + jobs every time a result is pulled.""", + 'command': 'noodles.run.single', + 'arguments': {} + }, + + { + 'name': 'single', + 'features': ['display'], + 'description': """ + Adds a display to the single runner. Everything still runs in a + single thread. Every time a job is pulled by the worker, a message + goes to the display routine; when the job is finished the result is + sent to the display routine.""", + 'command': 'noodles.run.single_with_display', + 'arguments': { + 'display': { + 'default': 'noodles.display.NCDisplay', + 'reader': 'look-up', + 'help': 'the display routine' + } + } + }, + + # ======================================================================= # + # Multi-threaded runners + # ======================================================================= # + { + 'name': 'parallel', + 'features': [], + 'command': 'noodles.run.parallel', + 'arguments': { + 'n_threads': { + 'default': '1', + 'reader': 'integer' + } + } + }, + + { + 'name': 'parallel', + 'features': ['display'], + 'command': 'noodles.run.parallel_with_display', + 'arguments': { + 'n_threads': { + 'default': '1', + 'reader': 'integer' + }, + 'display': { + 'default': 'noodles.display.NCDisplay', + 'reader': 'look-up' + } + } + }, + + { + 'name': 'parallel', + 'features': ['prov', 'display'], + 'description': """ + Run a workflow in `n_threads` parallel threads. Now we replaced the + single worker with a thread-pool of workers. + + This version works with the JobDB to cache results; however we only + store the jobs that are hinted with the 'store' keyword, unless + `cache_all` is set to `True`.""", + 'command': 'noodles.run.run_with_prov.run_parallel_opt', + 'arguments': { + 'n_threads': { + 'default': '1', + 'reader': 'integer', + 'help': 'the number of threads to run' + }, + 'registry': { + 'default': 'noodles.serial.base', + 'reader': 'look-up', + 'help': 'the serialisation registry to use' + }, + 'display': { + 'default': 'noodles.display.NCDisplay', + 'reader': 'look-up', + 'help': 'the display to use' + }, + 'database': { + 'default': 'TinyDB', + 'help': 'the database backend for the job cache' + }, + 'cache_file': { + 'default': 'cache.json', + 'help': 'the file used to store the job cache' + }, + 'cache_all': { + 'default': 'False', + 'reader': 'boolean', + 'help': 'set this if you want to store all jobs in cache' + } + } + }, + + { + 'name': 'xenon', + 'features': ['prov', 'display'], + 'command': 'noodles.run.xenon.run_xenon_prov', + 'arguments': { + } + }, + + { + 'name': 'process', + 'features': ['msgpack'], + 'command': 'noodles.run.process.run_process', + 'arguments': { + } + } +] + + +def find_runner(name: str, features: List[str]) -> str: + name_candidates = filter( + lambda r: r['name'] == name, + runners) + feature_candidates = filter( + lambda r: all(f in r['features'] for f in features), + name_candidates) + return min(feature_candidates, lambda r: len(r['features'])) + + +def run_with_config(config_file, workflow, machine=None): + config = configparser.ConfigParser( + interpolation=configparser.ExtendedInterpolation()) + config.read(config_file) + + machine = config.get('default', 'machine', fallback=machine) + if machine is None: + print("No machine given, running local in single thread.") + runner = find_runner(name='single', features=[]) + settings = {} + + else: + M = config['Machines'] + runner_name = M.get(machine, 'runner') + features = map(str.strip, M.get(machine, 'features').split(',')) + runner = find_runner(name=runner_name, features=features) + settings = dict(M[machine]) + + del settings['runner'] + del settings['features'] + + if 'user' in settings: + settings['user'] = dict(config['Users'][settings['user']]) + + run = look_up(runner['command']) + + return run(workflow, **settings) diff --git a/noodles/run/run.py b/noodles/run/run.py new file mode 100644 index 0000000..b9437a0 --- /dev/null +++ b/noodles/run/run.py @@ -0,0 +1,83 @@ +""" +Next generation class of Workflow Runners. These are accessed by configuring +Noodles in a `noodles.ini` file. For this reason they have to obey similar +interfaces. +""" + +from .queue import (Queue) +from .scheduler import (Scheduler) +from .haploid import (push_map, sink_map, branch, patch) +from .thread_pool import (thread_pool) +from .worker import (worker) +from ..workflow import (get_workflow) + +from itertools import (repeat) +import threading + + +# =========================================================================== # +def run_single(wf): + """Run a workflow in a single thread. This is the absolute minimal + runner, consisting of a single queue for jobs and a worker running + jobs every time a result is pulled.""" + S = Scheduler() + W = Queue() >> worker + + return S.run(W, get_workflow(wf)) + + +def run_single_with_display(wf, display): + """Adds a display to the single runner. Everything still runs in a single + thread. Every time a job is pulled by the worker, a message goes to the + display routine; when the job is finished the result is sent to the display + routine.""" + + @push_map + def log_job_start(key, job): + return (key, 'start', job, None) + + S = Scheduler(error_handler=display.error_handler) + W = Queue() \ + >> branch(log_job_start.to(sink_map(display))) \ + >> worker \ + >> branch(sink_map(display)) + + return S.run(W, get_workflow(wf)) + + +def run_parallel(wf, n_threads): + """Run a workflow in `n_threads` parallel threads. Now we replaced the + single worker with a thread-pool of workers.""" + S = Scheduler() + W = Queue() >> thread_pool(*repeat(worker, n_threads)) + + return S.run(W, get_workflow(wf)) + + +def run_parallel_with_display(wf, n_threads, display): + """Adds a display to the parallel runner. Because messages come in + asynchronously now, we start an extra thread just for the display + routine.""" + + @push_map + def log_job_start(key, job): + return (key, 'start', job, None) + + LogQ = Queue() + + S = Scheduler(error_handler=display.error_handler) + + threading.Thread( + target=patch, + args=(LogQ.source, sink_map(display)), + daemon=True).start() + + W = Queue() \ + >> branch(log_job_start >> LogQ.sink) \ + >> thread_pool(*repeat(worker, n_threads)) \ + >> branch(LogQ.sink) + + result = S.run(W, get_workflow(wf)) + LogQ.wait() + + return result From e689f5dee7da0d7a8f1be122998d9123e3f91582 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Mon, 21 Nov 2016 17:03:19 +0100 Subject: [PATCH 037/155] quote and unquote, testing in test_conditionals --- noodles/__init__.py | 6 +-- noodles/interface/__init__.py | 4 +- noodles/interface/functions.py | 18 +++++++ test/test_conditionals.py | 88 ++++++++++++++++++++++++++++++++++ 4 files changed, 111 insertions(+), 5 deletions(-) create mode 100644 test/test_conditionals.py diff --git a/noodles/__init__.py b/noodles/__init__.py index 1de1a3e..314726c 100644 --- a/noodles/__init__.py +++ b/noodles/__init__.py @@ -1,6 +1,6 @@ from noodles.interface import ( delay, gather, lift, schedule, schedule_hint, unwrap, - has_scheduled_methods, update_hints, unpack) + has_scheduled_methods, update_hints, unpack, quote, unquote) from .eval_data import Lambda from .run.runners import run_parallel_with_display as run_logging from .run.runners import (run_single, run_parallel) @@ -13,5 +13,5 @@ __all__ = ['schedule', 'schedule_hint', 'run_single', 'run_process', 'run_logging', 'run_parallel', 'run_hybrid', 'unwrap', 'Scheduler', 'Storable', 'has_scheduled_methods', 'Lambda', - 'gather', 'lift', 'unpack', 'delay', 'update_hints'] - + 'gather', 'lift', 'unpack', 'delay', 'update_hints', + 'quote', 'unquote'] diff --git a/noodles/interface/__init__.py b/noodles/interface/__init__.py index 6712d3d..79a7e97 100644 --- a/noodles/interface/__init__.py +++ b/noodles/interface/__init__.py @@ -1,9 +1,9 @@ from .decorator import (PromisedObject, schedule, schedule_hint, has_scheduled_methods, unwrap, update_hints) -from .functions import (delay, gather, lift, unpack) +from .functions import (delay, gather, lift, unpack, quote, unquote) from .annotated_value import (AnnotatedValue) from .exceptions import (JobException) __all__ = ['delay', 'gather', 'schedule_hint', 'schedule', 'unpack', 'has_scheduled_methods', 'unwrap', 'update_hints', 'AnnotatedValue', - 'JobException', 'lift', 'PromisedObject'] + 'JobException', 'lift', 'PromisedObject', 'quote', 'unquote'] diff --git a/noodles/interface/functions.py b/noodles/interface/functions.py index 11bbf60..9d4ff29 100644 --- a/noodles/interface/functions.py +++ b/noodles/interface/functions.py @@ -1,5 +1,6 @@ from .decorator import (schedule, PromisedObject) # from copy import deepcopy +from ..serial.reasonable import Reasonable @schedule @@ -61,6 +62,23 @@ def make_set(*args): return set(args) +class Quote(Reasonable): + def __init__(self, promise): + self.workflow = promise._workflow + + @property + def promise(self): + return PromisedObject(self.workflow) + + +def quote(promise): + return Quote(promise) + + +def unquote(quoted): + return quoted.promise + + def lift(obj, memo=None): if memo is None: memo = {} diff --git a/test/test_conditionals.py b/test/test_conditionals.py new file mode 100644 index 0000000..2eeb8b6 --- /dev/null +++ b/test/test_conditionals.py @@ -0,0 +1,88 @@ +from noodles import ( + schedule, run_single, quote, unquote, run_process, + schedule_hint, run_logging) +from noodles.tutorial import (add, sub, mul, accumulate) +from noodles.serial import base +from noodles.display import NCDisplay + + +def cond(t, wt, wf): + return s_cond(t, quote(wt), quote(wf)) + + +@schedule +def s_cond(truth, when_true, when_false): + if truth: + return unquote(when_true) + else: + return unquote(when_false) + + +def find_first(pred, lst): + if lst: + return s_find_first(pred, lst[0], [quote(l) for l in lst[1:]]) + else: + return None + + +@schedule +def s_find_first(pred, first, lst): + if pred(first): + return first + elif lst: + return s_find_first(pred, unquote(lst[0]), lst[1:]) + else: + return None + + +@schedule +def should_not_run(): + raise RuntimeError("This function should never have been called.") + + +def test_truthfulness(): + w = sub(4, add(3, 2)) + a = cond(True, w, should_not_run()) + b = cond(False, should_not_run(), w) + result = run_single(mul(a, b)) + assert result == 1 + + +counter = 0 + + +def is_sixteen(n): + return n == 16 + + +@schedule +def counted_sqr(x): + global counter + counter += 1 + return x*x + + +@schedule_hint(display="squaring {x}", confirm=True) +def display_sqr(x): + return x*x + + +def test_find_first(): + global counter + + wfs = [counted_sqr(x) for x in range(10)] + w = find_first(is_sixteen, wfs) + result = run_single(w) + assert result == 16 + assert counter == 5 + + wfs = [counted_sqr(x) for x in range(10)] + w = find_first(is_sixteen, wfs) + result = run_process(w, n_processes=1, registry=base) + assert result == 16 + + wfs = [display_sqr(x) for x in range(10)] + w = find_first(is_sixteen, wfs) + with NCDisplay() as display: + result = run_logging(w, n_threads=2, display=display) + assert result == 16 From 617e94c86cb0c257b17dbd467622786b793436e9 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Wed, 23 Nov 2016 13:54:03 +0100 Subject: [PATCH 038/155] enable travis --- .travis.yml | 5 +++++ noodles/__init__.py | 2 +- setup.py | 3 ++- 3 files changed, 8 insertions(+), 2 deletions(-) create mode 100644 .travis.yml diff --git a/.travis.yml b/.travis.yml new file mode 100644 index 0000000..75decd9 --- /dev/null +++ b/.travis.yml @@ -0,0 +1,5 @@ +language: python +python: + - "3.5" +install: pip install .[prov,numpy,test] +script: nosetests test diff --git a/noodles/__init__.py b/noodles/__init__.py index 314726c..59fa35a 100644 --- a/noodles/__init__.py +++ b/noodles/__init__.py @@ -8,7 +8,7 @@ from .run.scheduler import Scheduler from .storable import Storable -__version__ = "0.2.0" +__version__ = "0.2.3" __all__ = ['schedule', 'schedule_hint', 'run_single', 'run_process', 'run_logging', 'run_parallel', 'run_hybrid', 'unwrap', diff --git a/setup.py b/setup.py index 1d00d13..95eba68 100755 --- a/setup.py +++ b/setup.py @@ -12,12 +12,13 @@ setup( name='Noodles', - version='0.2.2', + version='0.2.3', description='Workflow Engine', author='Johan Hidding', url='https://github.com/NLeSC/noodles', packages=[ 'noodles', 'noodles.serial', 'noodles.run', 'noodles.run.xenon', + 'noodles.run.remote', 'noodles.display', 'noodles.interface', 'noodles.workflow', 'noodles.files', 'noodles.prov'], From f2c4f2f9661bb171a581b3e5350393719ab1d433 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Wed, 23 Nov 2016 13:57:48 +0100 Subject: [PATCH 039/155] restrict travis to master and devel --- .travis.yml | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/.travis.yml b/.travis.yml index 75decd9..3e80ea3 100644 --- a/.travis.yml +++ b/.travis.yml @@ -3,3 +3,9 @@ python: - "3.5" install: pip install .[prov,numpy,test] script: nosetests test + +branches: + only: + - master + - devel + From 7845a87e3007049debdb43517bdf3878a88715c8 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Wed, 23 Nov 2016 15:36:01 +0100 Subject: [PATCH 040/155] added find_first function, tag docstrings to show scheduled functions. --- README.rst | 3 + noodles/interface/decorator.py | 3 + noodles/interface/functions.py | 129 +++++++++++++++++++++++++++++---- 3 files changed, 119 insertions(+), 16 deletions(-) diff --git a/README.rst b/README.rst index 4daa410..79ec254 100644 --- a/README.rst +++ b/README.rst @@ -1,3 +1,6 @@ +.. image:: https://travis-ci.org/NLeSC/noodles.svg?branch=master + :alt: Travis + Noodles - workflow engine ========================= diff --git a/noodles/interface/decorator.py b/noodles/interface/decorator.py index 36c4143..30e9ed9 100644 --- a/noodles/interface/decorator.py +++ b/noodles/interface/decorator.py @@ -38,6 +38,9 @@ def wrapped(*args, **kwargs): f, args, kwargs, deepcopy(hints), call_by_value=config['call_by_value'])) + if hasattr(wrapped, '__doc__') and wrapped.__doc__ is not None: + wrapped.__doc__ = "*(scheduled)* " + wrapped.__doc__ + return wrapped diff --git a/noodles/interface/functions.py b/noodles/interface/functions.py index 9d4ff29..fb69d75 100644 --- a/noodles/interface/functions.py +++ b/noodles/interface/functions.py @@ -1,3 +1,7 @@ +""" +.. default-domain:: py +""" + from .decorator import (schedule, PromisedObject) # from copy import deepcopy from ..serial.reasonable import Reasonable @@ -5,38 +9,43 @@ @schedule def delay(value): + """Creates a promise of a given value. TODO: this function should have a + different name.""" return value @schedule def gather(*a): - """ - Converts a list of workflows (i.e. :py:class:`PromisedObject`) to - a workflow representing the promised list of values. - - Currently the :py:func:`from_call` function detects workflows - only by their top type (using `isinstance`). If we have some - deeper structure containing :py:class:`PromisedObject`, these are not - recognised as workflow input and taken as literal values. - - This behaviour may change in the future, making this function - `gather` obsolete. - """ + """Converts a list of promises (i.e. :class:`PromisedObject`) to a promised + list of values.""" return list(a) def unpack(t, n): + """Iterates over a promised sequence, the sequence should support random + access by :meth:`object.__getitem__`. Also the length of the sequence + should be known beforehand. + + :param t: a sequence. + :param n: the length of the sequence. + :return: an unpackable generator for the elements in the sequence.""" return (t[i] for i in range(n)) @schedule def set_dict(obj, d): + """Set the :attr:`object.__dict__` of `obj`. + + :param obj: input object. + :param d: dictionary. + :return: the modified object.""" obj.__dict__ = d return obj @schedule def create_object(cls, members): + """Promise an object of class `cls` with content `members`.""" obj = cls.__new__(cls) obj.__dict__ = members return obj @@ -44,25 +53,33 @@ def create_object(cls, members): @schedule def make_tuple(*args): + """Promise a tuple.""" return args @schedule -def make_dict(*args): - return dict(args) +def make_dict(*kwargs): + """Promise a dictionary, from a list of 2-tuples.""" + return dict(kwargs) @schedule def make_list(*args): + """Promise a list explicitely; function is identical to :func:`gather`.""" return list(args) @schedule def make_set(*args): + """Promise a set.""" return set(args) class Quote(Reasonable): + """Quote objects store the contents of a workflow, allowing the workflow to + be passed as an argument to a higher order function without its contents + being evaluated. Don't use this object, rather use the functions + :func:`quote` and :func:`unquote`.""" def __init__(self, promise): self.workflow = promise._workflow @@ -72,14 +89,94 @@ def promise(self): def quote(promise): - return Quote(promise) + """Quote a promise.""" + if isinstance(promise, PromisedObject): + return Quote(promise) + return promise def unquote(quoted): - return quoted.promise + """Unquote a quoted promise.""" + if isinstance(quoted, Quote): + return quoted.promise + return quoted + + +def find_first(pred, lst): + """Find the first result of a list of promises `lst` that satisfies a + predicate `pred`. + + :param pred: a function of one argument returning `True` or `False`. + :param lst: a list of promises or values. :return: a promise of a value or + `None`. + + This is a wrapper around :func:`s_find_first`. The first item on the list + is passed *as is*, forcing evalutation. The tail of the list is quoted, and + only unquoted if the predicate fails on the result of the first promise. + + If the input list is empty, `None` is returned.""" + if lst: + return s_find_first(pred, lst[0], [quote(l) for l in lst[1:]]) + else: + return None + + +@schedule +def s_find_first(pred, first, lst): + """Evaluate `first`; if predicate `pred` succeeds on the result of `first`, + return the result; otherwise recur on the first element of `lst`. + + :param pred: a predicate. + :param first: a promise. + :param lst: a list of quoted promises. + :return: the first element for which predicate is true.""" + if pred(first): + return first + elif lst: + return s_find_first(pred, unquote(lst[0]), lst[1:]) + else: + return None def lift(obj, memo=None): + """Make a promise out of object `obj`, where `obj` may contain promises + internally. + + :param obj: Any object. :param memo: used for internal caching (similar to + :func:`deepcopy`). + + If the object is a :class:`PromisedObject`, or *pass-by-value* + (:class:`str`, :class:`int`, :class:`float`, :class:`complex`) it is + returned as is. + + If the object's `id` has an entry in `memo`, the value from `memo` is + returned. + + If the object has a method `__lift__`, it is used to get the promise. + `__lift__` should take one additional argument for the `memo` dictionary, + entirely analogous to :func:`deepcopy`. + + If the object is an instance of one of the basic container types (list, + dictionary, tuple and set), we use the analogous function + (:func:`make_list`, :func:`make_dict`, :func:`make_tuple`, and + :func:`make_set`) to promise their counterparts should these objects + contain any promises. First, we map all items in the container through + :func:`lift`, then check the result for any promises. Note that in the + case of dictionaries, we lift all the items (i.e. the list of key/value + tuples) and then construct a new dictionary. + + If the object is an instance of a subclass of any of the basic container + types, the `__dict__` of the object is lifted as well as the object cast + to its base type. We then use :func:`set_dict` to set the `__dict__` of + the new promise. Again, if the object did not contain any promises, + we return it without change. + + Otherwise, we lift the `__dict__` and create a promise of a new object of + the same class as the input, using :func:`create_object`. This works fine + for what we call *reasonable* objects. Since calling :func:`lift` is an + explicit action, we do not require reasonable objects to be derived from + :class:`Reasonable` as we do with serialisation, where such a default + behaviour could lead to unexplicable bugs.""" if memo is None: memo = {} From 917b535d26537f506c0c2a727768bb6f0026c564 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Wed, 23 Nov 2016 15:51:04 +0100 Subject: [PATCH 041/155] add find_first to main namespace --- noodles/__init__.py | 5 +++-- noodles/interface/__init__.py | 5 +++-- test/test_conditionals.py | 21 ++------------------- 3 files changed, 8 insertions(+), 23 deletions(-) diff --git a/noodles/__init__.py b/noodles/__init__.py index 59fa35a..3676086 100644 --- a/noodles/__init__.py +++ b/noodles/__init__.py @@ -1,6 +1,7 @@ from noodles.interface import ( delay, gather, lift, schedule, schedule_hint, unwrap, - has_scheduled_methods, update_hints, unpack, quote, unquote) + has_scheduled_methods, update_hints, unpack, quote, unquote, + find_first) from .eval_data import Lambda from .run.runners import run_parallel_with_display as run_logging from .run.runners import (run_single, run_parallel) @@ -14,4 +15,4 @@ 'run_logging', 'run_parallel', 'run_hybrid', 'unwrap', 'Scheduler', 'Storable', 'has_scheduled_methods', 'Lambda', 'gather', 'lift', 'unpack', 'delay', 'update_hints', - 'quote', 'unquote'] + 'quote', 'unquote', 'find_first'] diff --git a/noodles/interface/__init__.py b/noodles/interface/__init__.py index 79a7e97..4eb2d20 100644 --- a/noodles/interface/__init__.py +++ b/noodles/interface/__init__.py @@ -1,9 +1,10 @@ from .decorator import (PromisedObject, schedule, schedule_hint, has_scheduled_methods, unwrap, update_hints) -from .functions import (delay, gather, lift, unpack, quote, unquote) +from .functions import (delay, gather, lift, unpack, quote, unquote, find_first) from .annotated_value import (AnnotatedValue) from .exceptions import (JobException) __all__ = ['delay', 'gather', 'schedule_hint', 'schedule', 'unpack', 'has_scheduled_methods', 'unwrap', 'update_hints', 'AnnotatedValue', - 'JobException', 'lift', 'PromisedObject', 'quote', 'unquote'] + 'JobException', 'lift', 'PromisedObject', 'quote', 'unquote', + 'find_first'] diff --git a/test/test_conditionals.py b/test/test_conditionals.py index 2eeb8b6..423d50d 100644 --- a/test/test_conditionals.py +++ b/test/test_conditionals.py @@ -1,7 +1,7 @@ from noodles import ( schedule, run_single, quote, unquote, run_process, - schedule_hint, run_logging) -from noodles.tutorial import (add, sub, mul, accumulate) + schedule_hint, run_logging, find_first) +from noodles.tutorial import (add, sub, mul) from noodles.serial import base from noodles.display import NCDisplay @@ -18,23 +18,6 @@ def s_cond(truth, when_true, when_false): return unquote(when_false) -def find_first(pred, lst): - if lst: - return s_find_first(pred, lst[0], [quote(l) for l in lst[1:]]) - else: - return None - - -@schedule -def s_find_first(pred, first, lst): - if pred(first): - return first - elif lst: - return s_find_first(pred, unquote(lst[0]), lst[1:]) - else: - return None - - @schedule def should_not_run(): raise RuntimeError("This function should never have been called.") From 40d19eb2615d7dbb892c98a6b9012bcc7786c9ef Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Wed, 23 Nov 2016 16:24:15 +0100 Subject: [PATCH 042/155] add codacy to travis --- .travis.yml | 12 ++++++++++-- noodles/interface/__init__.py | 8 +++++--- test/test_prov.py | 2 +- 3 files changed, 16 insertions(+), 6 deletions(-) diff --git a/.travis.yml b/.travis.yml index 3e80ea3..c6e9c56 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,8 +1,16 @@ language: python +sudo: false python: - "3.5" -install: pip install .[prov,numpy,test] -script: nosetests test +install: + - pip install -U codacy-coverage + - pip install -U .[prov,numpy,test] +script: + - nosetests test --with-coverage --cover-xml --cover-package=noodles +after-script: + - coverage report + - coverage xml + - python-codacy-coverage -r coverage.xml branches: only: diff --git a/noodles/interface/__init__.py b/noodles/interface/__init__.py index 4eb2d20..1a35bdf 100644 --- a/noodles/interface/__init__.py +++ b/noodles/interface/__init__.py @@ -1,6 +1,8 @@ -from .decorator import (PromisedObject, schedule, schedule_hint, - has_scheduled_methods, unwrap, update_hints) -from .functions import (delay, gather, lift, unpack, quote, unquote, find_first) +from .decorator import ( + PromisedObject, schedule, schedule_hint, has_scheduled_methods, + unwrap, update_hints) +from .functions import ( + delay, gather, lift, unpack, quote, unquote, find_first) from .annotated_value import (AnnotatedValue) from .exceptions import (JobException) diff --git a/test/test_prov.py b/test/test_prov.py index 1c60747..bcd2779 100644 --- a/test/test_prov.py +++ b/test/test_prov.py @@ -105,7 +105,7 @@ def test_prov_05(): result = run_parallel(wf, 4, serial.base, db_file) end = time.time() - assert (end - start) < 1.0 + assert (end - start) < 5.0 # weak test assert result == 10946 os.unlink(db_file) From f9e0d50fdbe60d05883db861e60f0a34786c83a2 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Wed, 23 Nov 2016 16:44:21 +0100 Subject: [PATCH 043/155] pep8 on examples/ea/ea.py --- examples/ea/ea.py | 37 ++++++++++++++++++++++--------------- 1 file changed, 22 insertions(+), 15 deletions(-) diff --git a/examples/ea/ea.py b/examples/ea/ea.py index 1ccf1de..32b7bda 100644 --- a/examples/ea/ea.py +++ b/examples/ea/ea.py @@ -1,10 +1,9 @@ """ - This module implements a parallelized Evolutionary Strategy with Single Self-Adaptive Sigma. - - + This module implements a parallelized Evolutionary Strategy with Single + Self-Adaptive Sigma. """ -from noodles import (has_scheduled_methods, schedule, schedule_hint) +from noodles import (has_scheduled_methods, schedule_hint) from .chromosome import (Chromosome) from .generation import (Generation) @@ -25,8 +24,10 @@ def make_child(self, g: Generation) -> Chromosome: option2 = random.sample(g.individuals, 2) # Binary Tournament - parent = [option1[0] if option1[0].fitness < option1[1].fitness else option1[1], - option2[0] if option2[0].fitness < option2[1].fitness else option2[1]] + parent = [option1[0] if option1[0].fitness < option1[1].fitness + else option1[1], + option2[0] if option2[0].fitness < option2[1].fitness + else option2[1]] # Crossover child = self.crossover(parent) @@ -37,7 +38,8 @@ def make_child(self, g: Generation) -> Chromosome: return child def generate_offspring(self, g: Generation) -> Generation: - individuals = [self.make_child(g) for _ in range(self.config['offspring'])] + individuals = [self.make_child(g) + for _ in range(self.config['offspring'])] generation = Generation(individuals) generation.number = g.number + 1 @@ -45,14 +47,16 @@ def generate_offspring(self, g: Generation) -> Generation: def crossover(self, parents) -> Chromosome: values = np.where(np.random.random(parents[0].values.shape) > 0.5, - parents[0].values, parents[1].values) - sigma = parents[0].sigma if np.random.random() > 0.5 else parents[1].sigma + parents[0].values, parents[1].values) + sigma = parents[0].sigma if np.random.random() > 0.5 \ + else parents[1].sigma child = Chromosome(values=values, sigma=sigma) return child def mutate(self, child) -> Chromosome: # mutate the sigma - child.sigma = child.sigma + self.config['learning_rate'] * np.random.normal(0, child.sigma) + child.sigma = child.sigma + self.config['learning_rate'] \ + * np.random.normal(0, child.sigma) # mutate the child using the mutated sigma mut = np.random.normal(0, child.sigma, (len(child.values))) @@ -63,9 +67,12 @@ def mutate(self, child) -> Chromosome: # Generate random individuals on the range [range_lower, range_upper] def initialize(self) -> Generation: - individuals = [Chromosome(values=(np.random.rand(self.fitness_evaluator.dimensions) / 2 - 1) * - self.fitness_evaluator.range_upper, sigma=self.config['initial_sigma']) - for _ in range(self.config['population_size'])] + individuals = [ + Chromosome(values=(np.random.rand( + self.fitness_evaluator.dimensions) / 2 - 1) * + self.fitness_evaluator.range_upper, + sigma=self.config['initial_sigma']) + for _ in range(self.config['population_size'])] generation = Generation(individuals) generation.number = 1 @@ -80,7 +87,7 @@ def next_generation(self, g: Generation) -> Generation: return g else: # Generate Children - new_generation = self.generate_offspring(g).evaluate(fitness_evaluator=self.fitness_evaluator) + new_generation = self.generate_offspring(g).evaluate( + fitness_evaluator=self.fitness_evaluator) return self.next_generation(new_generation) - From 63d1c45f3e1ec26cc738db0bfee78a5c9a81448f Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Wed, 23 Nov 2016 16:49:34 +0100 Subject: [PATCH 044/155] fix class decorator example --- examples/class-decorator.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/examples/class-decorator.py b/examples/class-decorator.py index f5152ba..e3a201f 100644 --- a/examples/class-decorator.py +++ b/examples/class-decorator.py @@ -1,5 +1,5 @@ -from noodles import schedule, run -from prototype import draw_workflow +from noodles import schedule, run_single +from noodles.draw_workflow import draw_workflow @schedule @@ -42,6 +42,7 @@ def attr(self, x): class B: pass + a = A(5).multiply(10) a.second = 7 a.attr = 1.0 @@ -51,7 +52,7 @@ class B: b.second = a.second b.attr = a.attr -draw_workflow("oop-wf.svg", b) -result = run(b) +draw_workflow("oop-wf.svg", b._workflow) +result = run_single(b) print(result.x, result.second, result.attr) From 652388a5f888c4accc32e69cc45f9350911d01da Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Wed, 23 Nov 2016 16:51:34 +0100 Subject: [PATCH 045/155] rename sum to my_sum in example --- examples/example2.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/examples/example2.py b/examples/example2.py index ee3a0ae..7cd26de 100644 --- a/examples/example2.py +++ b/examples/example2.py @@ -18,7 +18,7 @@ def mul(a, b): @schedule -def sum(a, buildin_sum=sum): +def my_sum(a, buildin_sum=sum): return buildin_sum(a) @@ -34,7 +34,7 @@ def foo(a, b, c): multiples = [foo(i, r2, r1) for i in range(6)] -r5 = sum(gather(*multiples)) +r5 = my_sum(gather(*multiples)) draw_workflow("graph-example2.svg", r5) answer = run_parallel(r5, 4) From 53153cde6ffc4fac1c19785c981c52aef27a1c53 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Wed, 23 Nov 2016 17:02:09 +0100 Subject: [PATCH 046/155] remove lambda/eval feature --- noodles/__init__.py | 3 +-- noodles/eval_data.py | 37 ------------------------------------- test/test_lambda.py | 22 ---------------------- 3 files changed, 1 insertion(+), 61 deletions(-) delete mode 100644 noodles/eval_data.py delete mode 100644 test/test_lambda.py diff --git a/noodles/__init__.py b/noodles/__init__.py index 3676086..25ff05a 100644 --- a/noodles/__init__.py +++ b/noodles/__init__.py @@ -2,7 +2,6 @@ delay, gather, lift, schedule, schedule_hint, unwrap, has_scheduled_methods, update_hints, unpack, quote, unquote, find_first) -from .eval_data import Lambda from .run.runners import run_parallel_with_display as run_logging from .run.runners import (run_single, run_parallel) from .run.process import run_process @@ -13,6 +12,6 @@ __all__ = ['schedule', 'schedule_hint', 'run_single', 'run_process', 'run_logging', 'run_parallel', 'run_hybrid', 'unwrap', - 'Scheduler', 'Storable', 'has_scheduled_methods', 'Lambda', + 'Scheduler', 'Storable', 'has_scheduled_methods', 'gather', 'lift', 'unpack', 'delay', 'update_hints', 'quote', 'unquote', 'find_first'] diff --git a/noodles/eval_data.py b/noodles/eval_data.py deleted file mode 100644 index dc4dacc..0000000 --- a/noodles/eval_data.py +++ /dev/null @@ -1,37 +0,0 @@ -from .storable import Storable - - -class Lambda(Storable): - """Serializable storage for a lambda-expression. - - The user may want to sprinkle her/his code with little lambda-functions. - Python lambda functions are not easily storable. One may be tempted to - use pickle to store the function object, but pickle doesn't load the - namespace needed to run the function. For instance if the lambda-function - contains a reference to `math.sin`, `scipy.special.erf` or - what-have-you-not, pickling will fail to reproduce a working function - object. - - This class takes a Python expression as a string and uses `eval()` - to create a working function object. Dependencies can be given in the - `globals` dict. Those will be saved and imported back when the object is - loaded.""" - def __init__(self, expression, globals=None, locals=None): - super(Lambda, self).__init__() - - self.expression = expression - self.globals = globals - self.locals = locals - self.obj = eval(expression, globals, locals) - - def as_dict(self): - return {'expression': self.expression, - 'globals': self.globals, - 'locals': self.locals} - - @classmethod - def from_dict(cls, **kwargs): - return Lambda(**kwargs) - - def __call__(self, *args, **kwargs): - return self.obj(*args, **kwargs) diff --git a/test/test_lambda.py b/test/test_lambda.py deleted file mode 100644 index 3222151..0000000 --- a/test/test_lambda.py +++ /dev/null @@ -1,22 +0,0 @@ -from noodles import schedule, Lambda, run_process, serial -from noodles.tutorial import accumulate - - -@schedule -def nmap(f, lst): - return list(map(f, lst)) - - -@schedule -def value(x): - return x - - -def test_lambda(): - a = Lambda("lambda x: x**2") - b = nmap(a, [0.1, 0.2, 0.3, 0.4, 0.5]) - c = accumulate(b) - - # result = run(c) - result = run_process(c, 1, serial.base) - assert result == 0.55 From 952c5c0ed1e72b6eaf111c8378c7790a1b71bfdb Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Wed, 23 Nov 2016 17:03:52 +0100 Subject: [PATCH 047/155] clean run/xenon/dynamic_pool --- noodles/run/xenon/dynamic_pool.py | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/noodles/run/xenon/dynamic_pool.py b/noodles/run/xenon/dynamic_pool.py index 621d9f7..e887d6c 100644 --- a/noodles/run/xenon/dynamic_pool.py +++ b/noodles/run/xenon/dynamic_pool.py @@ -1,10 +1,9 @@ from ..queue import Queue from ..connection import Connection -from ..coroutine import coroutine from ..haploid import (push) from ..messages import ( - ResultMessage, JobMessage) + ResultMessage) from ..remote.io import ( JSONObjectWriter, JSONObjectReader) @@ -14,7 +13,6 @@ import threading import sys -import uuid from collections import namedtuple from .xenon import (XenonKeeper, XenonConfig, XenonScheduler) @@ -56,7 +54,7 @@ def send_job(): def get_result(): input_stream = xenon.conversions.InputStream(J.streams.getStdout()) yield from JSONObjectReader(registry, input_stream) - + return Connection(get_result, send_job, aux=J) @@ -187,8 +185,8 @@ def activate(_): # lock end ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ for key in w.jobs: - sink.send(ResultMessage(key, 'aborted', None, - 'connection to remote worker lost.')) + sink.send(ResultMessage( + key, 'aborted', None, 'connection to remote worker lost.')) # Start the `activate` function when the worker goes online. threading.Thread( From 9478b6e35ec6f8a729fa8ec483137eea2a7dec94 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Wed, 23 Nov 2016 17:10:39 +0100 Subject: [PATCH 048/155] make decoder staticmethod --- noodles/run/xenon/runner.py | 6 +++--- noodles/serial/registry.py | 3 ++- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/noodles/run/xenon/runner.py b/noodles/run/xenon/runner.py index bf163e2..cd1c750 100644 --- a/noodles/run/xenon/runner.py +++ b/noodles/run/xenon/runner.py @@ -35,8 +35,8 @@ def run_xenon_prov(wf, Xe, jobdb_file, n_processes, xenon_config, Xenon. :param job_config: - The :py:class:`RemoteJobConfig` object that specifies the command to - run remotely for each worker. + The :py:class:`RemoteJobConfig` object that specifies the command + to run remotely for each worker. :param deref: Set this to True to pass the result through one more encoding and @@ -83,7 +83,7 @@ def run_xenon_prov(wf, Xe, jobdb_file, n_processes, xenon_config, def run_xenon(wf, Xe, jobdb_file, n_processes, xenon_config, - job_config, *, deref=False, job_keeper=None, display=None): + job_config, *, deref=False, job_keeper=None): """Run the workflow using a number of online Xenon workers. :param Xe: diff --git a/noodles/serial/registry.py b/noodles/serial/registry.py index cd3e752..dc312e3 100644 --- a/noodles/serial/registry.py +++ b/noodles/serial/registry.py @@ -331,7 +331,8 @@ def make_rec(rec, ref=False, files=None): raise NotImplementedError(msg) - def decode(self, cls, data): + @staticmethod + def decode(cls, data): """Should decode the data to an object of type 'cls'. :param cls: From 28f7f30c9af6afcffd2209a557088ea825471eb1 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Wed, 23 Nov 2016 17:11:59 +0100 Subject: [PATCH 049/155] remove cosmology example for now --- examples/Cosmology.ipynb | 176 ------------------------------ examples/cosmology/__init__.py | 11 -- examples/cosmology/amuse.py | 1 - examples/cosmology/cosmology.py | 42 -------- examples/cosmology/filter.py | 108 ------------------- examples/cosmology/gnuplot.py | 186 -------------------------------- examples/cosmology/loops.pyx | 84 --------------- examples/cosmology/maths.py | 71 ------------ examples/cosmology/pm3.py | 112 ------------------- examples/cosmology/setup.py | 6 -- 10 files changed, 797 deletions(-) delete mode 100644 examples/Cosmology.ipynb delete mode 100644 examples/cosmology/__init__.py delete mode 100644 examples/cosmology/amuse.py delete mode 100644 examples/cosmology/cosmology.py delete mode 100644 examples/cosmology/filter.py delete mode 100644 examples/cosmology/gnuplot.py delete mode 100644 examples/cosmology/loops.pyx delete mode 100644 examples/cosmology/maths.py delete mode 100644 examples/cosmology/pm3.py delete mode 100644 examples/cosmology/setup.py diff --git a/examples/Cosmology.ipynb b/examples/Cosmology.ipynb deleted file mode 100644 index 0753447..0000000 --- a/examples/Cosmology.ipynb +++ /dev/null @@ -1,176 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Noodles example: his noodly cosmic structure formation.\n", - "\n", - "This example shows how to do simple astrophysics with Noodles. At the moment this shows how we can handle NumPy data without too much of a fuzz. This may be extended to attempt some parallelisation, optimising for data transport, and experimenting with hybrid iteration schemes.\n", - "\n", - "### TODO\n", - "- include Amuse example" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "import sys\n", - "import os\n", - "sys.path = ['.'] + sys.path" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import cosmology as csf\n", - "import noodles\n", - "from noodles.run_process import process_worker\n", - "from noodles.datamodel import get_workflow\n", - "# from cosmology.loops import power_2, compose_2, scale_2" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### The workflow" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "box = csf.BoxConfig(2, 256, 100.0)\n", - "force_box = csf.BoxConfig(2, 512, 100.0)\n", - "cosmos = csf.EdS\n", - "\n", - "delta_wf = csf.gaussian_random_field(\n", - " box,\n", - " noodles.Lambda(\"lambda k: 1 if k == 0 else 20000*k**(-0.75)\"))\n", - " \n", - "phi_wf = csf.compute_potential(box, delta_wf)\n", - "ics_wf = csf.zeldovich_approximation(box, phi_wf)\n", - "\n", - "za = csf.drift(cosmos, ics_wf, 0.1, 0.1)\n", - "dens = csf.compute_density(force_box, za)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Running the workflow with the `process_worker` to test the saving and retrieval of NumPy data." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "rho = noodles.Scheduler().run(process_worker(), get_workflow(dens))\n", - "rho = rho.make()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Show the results" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "%matplotlib inline\n", - "\n", - "import matplotlib\n", - "from matplotlib import pyplot as plt\n", - "\n", - "plt.rcParams['figure.figsize'] = (12.0, 9.0)\n", - "plt.rcParams['image.cmap'] = 'PaulT_plusmin'\n", - "\n", - "## Register Paul Tol's colormap; see https://personal.sron.nl/~pault/\n", - "def pault_map(x):\n", - " rcol = 0.237 - 2.13*x + 26.92*x**2 - 65.5*x**3 + 63.5*x**4 - 22.36*x**5\n", - " gcol = ((0.572 + 1.524*x - 1.811*x**2)/(1 - 0.291*x + 0.1574*x**2))**2\n", - " bcol = 1/(1.579 - 4.03*x + 12.92*x**2 - 31.4*x**3 + 48.6*x**4 - 23.36*x**5)\n", - " return rcol, gcol, bcol\n", - "\n", - "cols = [pault_map(x) for x in np.linspace(0, 1, 256)]\n", - "cm_plusmin = matplotlib.colors.LinearSegmentedColormap.from_list(\"PaulT_plusmin\", cols)\n", - "plt.cm.register_cmap(\"PaulT_plusmin\", cm_plusmin)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 13, - "output_type": "execute_result", - "metadata": {} - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhoAAAIXCAYAAADaJ/f4AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nDR1Ho4MOOuiggw46eNvw/wEkVMYIoHCRVgAAAABJRU5ErkJggg==\n" - }, - "output_type": "display_data", - "metadata": {} - } - ], - "source": [ - "plt.imshow(rho.data, interpolation='nearest')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3.0 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.5.0+" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file diff --git a/examples/cosmology/__init__.py b/examples/cosmology/__init__.py deleted file mode 100644 index ec537ad..0000000 --- a/examples/cosmology/__init__.py +++ /dev/null @@ -1,11 +0,0 @@ -from .pm3 import ( - gaussian_random_field, zeldovich_approximation, Particles, BoxConfig, - compute_density, compute_potential, drift, kick) - -from .cosmology import ( - Cosmology, EdS, LCDM) - -__all__ = [ - gaussian_random_field, zeldovich_approximation, Particles, - BoxConfig, compute_density, compute_potential, drift, kick, - Cosmology, EdS, LCDM] diff --git a/examples/cosmology/amuse.py b/examples/cosmology/amuse.py deleted file mode 100644 index 9dab2d4..0000000 --- a/examples/cosmology/amuse.py +++ /dev/null @@ -1 +0,0 @@ -from amuse import diff --git a/examples/cosmology/cosmology.py b/examples/cosmology/cosmology.py deleted file mode 100644 index 7653b0f..0000000 --- a/examples/cosmology/cosmology.py +++ /dev/null @@ -1,42 +0,0 @@ -import numpy as np -from scipy.integrate import quad -from noodles import Storable - - -class Cosmology(Storable): - """This object stores all relevant information wrt the background - cosmology, parametrized by OmegaM, OmegaL and H0.""" - def __init__(self, H0, OmegaM, OmegaL): - super(Cosmology, self).__init__() - - self.H0 = H0 - self.OmegaM = OmegaM - self.OmegaL = OmegaL - self.OmegaK = 1 - OmegaM - OmegaL - self.grav_cst = 3./2 * OmegaM * H0**2 - self.factor = self._growing_mode_norm() - - def adot(self, a): - return self.H0 * a * np.sqrt( - self.OmegaL - + self.OmegaM * a**-3 - + self.OmegaK * a**-2) - - def _growing_mode_norm(self): - """result D(1) = 1. d/d0 + 0.001 = 1""" - d = self.adot(1) * quad(lambda b: self.adot(b)**(-3), 0.00001, 1)[0] - return 0.99999/d - - def growing_mode(self, a): - if isinstance(a, np.ndarray): - return np.array([self.growing_mode(b) for b in a]) - elif a <= 0.001: - return a - else: - return self.factor * self.adot(a)/a * quad( - lambda b: self.adot(b)**(-3), 0.00001, a)[0] \ - + 0.00001 - - -LCDM = Cosmology(68.0, 0.31, 0.69) -EdS = Cosmology(70.0, 1.0, 0.0) diff --git a/examples/cosmology/filter.py b/examples/cosmology/filter.py deleted file mode 100644 index 44b7d7a..0000000 --- a/examples/cosmology/filter.py +++ /dev/null @@ -1,108 +0,0 @@ -import numpy as np -from numbers import Number -from functools import reduce -import operator - - -class Filter: - def __init__(self, f): - self.f = f - - def __call__(self, K): - return self.f(K) - - def __mul__(self, other): - if isinstance(other, Filter): - return Filter(lambda K: self.f(K) * other.f(K)) - - elif isinstance(other, Number): - return Filter(lambda K: other * self.f(K)) - - def __pow__(self, n): - return Filter(lambda K: self.f(K)**n) - - def __truediv__(self, other): - if isinstance(other, Number): - return Filter(lambda K: self.f(K) / other) - - def __add__(self, other): - return Filter(lambda K: self.f(K) + other.f(K)) - - def __invert__(self): - return Filter(lambda K: self.f(K).conj()) - - def abs(self, B, P): - return np.sqrt(self.cc(B, P, self)) - - def cc(self, B, P, other): - return (~self * other * P)(B.K).sum().real / B.size * B.res**2 - - def cf(self, B, other): - return ((~self)(B.K) * other).sum().real / B.size * B.res**2 - - -class Identity(Filter): - def __init__(self): - Filter.__init__(self, lambda K: 1) - - -class Zero(Filter): - def __init__(self): - Filter.__init__(self, lambda K: 0) - - -def _scale_filter(B, t): - """returns discrete scale space filter, take care with units: - [res] = Mpc / pixel, [k] = 1 / Mpc, [t] = Mpc**2""" - def f(K): - return reduce( - lambda x, y: x*y, - (np.exp(t / B.res**2 * (np.cos(k * B.res) - 1)) for k in K)) - return f - - -class Scale(Filter): - def __init__(self, B, sigma): - Filter.__init__(self, _scale_filter(B, sigma**2)) - - -def _K_dot(X, K): - return sum(X[i]*K[i] for i in range(len(X))) - - -class Pos(Filter): - def __init__(self, x): - Filter.__init__(self, lambda K: np.exp(-1j * _K_dot(x, K))) - - -class D(Filter): - def __init__(self, n): - def d(i): - return Filter(lambda K: -1j * K[i]) - - A = [d(int(i)-1) for i in str(n)] - Filter.__init__(self, reduce(operator.mul, A)) - - -def _K_pow(k, n): - """raise |k| to the -th power safely""" - save = np.seterr(divide='ignore') - a = np.where(k == 0, 0, k**n) - np.seterr(**save) - return a - - -class Power_law(Filter): - def __init__(self, n): - Filter.__init__(self, lambda K: _K_pow((K**2).sum(axis=0), n/2)) - - -class Cutoff(Filter): - def __init__(self, B): - Filter.__init__(self, lambda K: np.where( - (K**2).sum(axis=0) <= B.k_max**2, 1, 0)) - - -class Potential(Filter): - def __init__(self): - Filter.__init__(self, lambda K: -_K_pow((K**2).sum(axis=0), -1.)) diff --git a/examples/cosmology/gnuplot.py b/examples/cosmology/gnuplot.py deleted file mode 100644 index 685046c..0000000 --- a/examples/cosmology/gnuplot.py +++ /dev/null @@ -1,186 +0,0 @@ -# -*- coding: utf-8 -*- -# module that plots gnuplot to IPython notebook - -import sys -from subprocess import Popen, PIPE -# from functools import reduce, partial -import numpy as np - - -class Gnuplot: - """Create an instance of the Gnuplot process. If dummy is given, the - process will just print to stdout in stead of running Gnuplot.""" - def __init__(self, persist=False, dummy=False, binary=True): - if dummy: - self.f = sys.stdout - elif persist: - self.p = Popen(["gnuplot", "-persist"], stdin=PIPE) - self.f = self.p.stdin - else: - self.p = Popen("gnuplot", stdin=PIPE) - self.f = self.p.stdin - - if binary: - self.put_array = self.put_array_binary - else: - self.put_array = self.put_array_text - - def __call__(self, *args): - """Send commands to Gnuplot. If an instance of a numpy array is given, - it is converted to inline data. You can use this if you give a - 'plot '-' ... ' command just before the data.""" - for a in args: - if isinstance(a, bytes): - self.f.write(a) - self.f.flush() - - if isinstance(a, str): - self.f.write(a.encode()) - self.f.write('\n'.encode()) - self.f.flush() - - if isinstance(a, np.ndarray): - self.put_array(a) - - if isinstance(a, list): - for i in a: - self(i) - - def flush(self): - self.f.flush() - - def terminate(self): - """Close the Gnuplot input pipe, and wait for the process to exit.""" - self.f.close() - self.p.wait() - - def put_array_binary(self, data): - self.f.write(data.tostring()) - - def put_array_text(self, data): - """Print array data such that Gnuplot understands it as inlined data entries. - Doesn't work with matrix data yet, since Gnuplots protocol for entering - matrix data by text is different from other data.""" - if len(data.shape) > 3: - raise - - if len(data.shape) == 1: - for x in data: - self(str(x)) - - if len(data.shape) == 2: - for x in data: - self(" ".join([str(l) for l in x])) - - if len(data.shape) == 3: - for x in data: - for y in x: - self(" ".join([str(l) for l in y])) - self("") - - self("EOF") - - -class Multiplot: - def __init__(self, w, h, n, m): - self.w = w - self.h = h - self.n = n - self.m = m - self.set_margin(0.1, 0.1, 0.8, 0.3) - - def set_margin(self, t, r, b, l): - "set margins (clockwise: t, r, b, l) and recalculate plot positions" - self.margin_left = l - self.margin_bottom = b - self.margin_top = t - self.margin_right = r - - self.fw = self.w*self.n + self.margin_left + self.margin_right - self.fh = self.h*self.m + self.margin_top + self.margin_bottom - - self.ml = self.margin_left / self.fw - self.mr = self.margin_right / self.fw - self.mt = self.margin_top / self.fh - self.mb = self.margin_bottom / self.fh - - self.ew = (1 - (self.ml + self.mr)) / self.n - self.eh = (1 - (self.mt + self.mb)) / self.m - - def set_term(self, term="pdf"): - return "set term {2} size {0:f},{1:f} " \ - "font 'Bitstream Charter, 10'".format( - self.fw, self.fh, term) - - def subplot(self, i, j): - left = self.ml + self.ew * i - right = self.ml + self.ew * (i+1) - bottom = self.mb + self.eh * (self.m - j - 1) - top = self.mb + self.eh * (self.m - j) - return "set l{0} {1:f}; set r{0} {2:f}; " \ - "set b{0} {3:f} ; set t{0} {4:f}".format( - "margin at screen", left, right, bottom, top) - - def left(self, i): - return self.ml + self.ew * i - - def bottom(self, j): - return self.mb + self.eh * (self.m - j - 1) - - -def matrix(data, using=None): - plot_using = "" - d = np.zeros([s+1 for s in data.shape], dtype='float32') - plot_cmd = "binary matrix" - d[1:, 1:] = data - d[1:, 0] = np.arange(data.shape[0]) - d[0, 1:] = np.arange(data.shape[1]) - d[0, 0] = data.shape[1] - - n = np.ones(1, dtype='int32') * data.shape[1] - if using is not None: - plot_using += " " - plot_using += using - - return (plot_cmd + plot_using, n.tostring() + d.flat[1:].tostring()) - - -def array(data, using=None): - plot_cmd = "binary array={0} format='%{1}'".format(data.shape, data.dtype) - plot_using = "" - if using is not None: - plot_using += " " - plot_using += using - plot_data = data.tostring() - return (plot_cmd + plot_using, plot_data) - - -def record(data, using=None): - plot_cmd = "binary record={0} format='{1}'".format( - data.shape[0], ("%" + str(data.dtype)) * data.shape[1]) - plot_using = "" - if using is not None: - plot_using += " " - plot_using += using - plot_data = data - return (plot_cmd + plot_using, plot_data) - - -def plot_data(*args): - plot_cmd = "plot '-' " + args[0][0] + ", '' ".join(a[0] for a in args[1:]) - plot_data = [a[1] for a in args] - return [plot_cmd] + plot_data - - -def splot_data(*args): - plot_cmd = "splot '-' " + ", '' ".join(a[0] for a in args) - plot_data = [a[1] for a in args] - return [plot_cmd] + plot_data - - -default_palette = """# default blue to red palette -rcol(x) = 0.237 - 2.13*x + 26.92*x**2 - 65.5*x**3 + 63.5*x**4 - 22.36*x**5 -gcol(x) = ((0.572 + 1.524*x - 1.811*x**2)/(1 - 0.291*x + 0.1574*x**2))**2 -bcol(x) = 1/(1.579 - 4.03*x + 12.92*x**2 - 31.4*x**3 + 48.6*x**4 - 23.36*x**5) -set palette model RGB functions rcol(gray), gcol(gray), bcol(gray) -""" diff --git a/examples/cosmology/loops.pyx b/examples/cosmology/loops.pyx deleted file mode 100644 index 39ee033..0000000 --- a/examples/cosmology/loops.pyx +++ /dev/null @@ -1,84 +0,0 @@ -cimport numpy as np -from libc.math cimport (exp, cos) - - -cdef double tau = 6.28318530717958647692 - - -cdef int _wave_number(int N, int i): - if i > N/2: - return i - N - else: - return i - - -cpdef double complex potential_2(double kx, double ky): - cdef double k2 = (kx*kx + ky*ky) - if k2 > 0: - return -1./k2 - else: - return 1.0 - - -cdef class power_2: - cdef double power - - def __init__(self, power): - self.power = power - - def __call__(self, double kx, double ky): - cdef double k2 = (kx*kx + ky*ky) - if k2 > 0: - return k2**(self.power/2) - else: - return 1.0 - - -cdef class compose_2: - cdef object f, g - - def __init__(self, f, g): - self.f = f - self.g = g - - def __call__(self, kx, ky): - return self.f(kx, ky) * self.g(kx, ky) - - -cdef class cutoff_2: - cdef double k_max - - def __init__(self, box): - self.k_max = box.k_max - - def __call__(self, double kx, double ky): - cdef double k2 = (kx*kx + ky*ky) - if k2 <= self.k_max**2: - return 1 - else: - return 0 - - -cdef class scale_2: - cdef double t - cdef double res - - def __init__(self, object box, double sigma): - self.t = (sigma / box.res)**2 - self.res = box.res - - def __call__(self, double kx, double ky): - cdef double Gx = exp(self.t * (cos(kx * self.res) - 1.0)) - cdef double Gy = exp(self.t * (cos(ky * self.res) - 1.0)) - - return Gx * Gy - - -def apply_filter_2(object box, object f, np.ndarray data): - for j in range(box.N): - ky = _wave_number(box.N, j) * tau/box.L - - for i in range(box.N): - kx = _wave_number(box.N, i) * tau/box.L - - data[i, j] *= f(ky, kx) diff --git a/examples/cosmology/maths.py b/examples/cosmology/maths.py deleted file mode 100644 index 9b37a53..0000000 --- a/examples/cosmology/maths.py +++ /dev/null @@ -1,71 +0,0 @@ -import numpy as np -from math import pi - -tau = 2*pi - - -def md_cic(B, X_): - X = X_ / B.res - f = X - np.floor(X) - - rho = np.zeros(B.shape, dtype='float64') - rho_, x_, y_ = np.histogram2d( - X[:, 0] % B.N, X[:, 1] % B.N, - bins=B.shape, - range=[[0, B.N], [0, B.N]], - weights=(1 - f[:, 0]) * (1 - f[:, 1])) - - rho += rho_ - rho_, x_, y_ = np.histogram2d( - (X[:, 0] + 1) % B.N, X[:, 1] % B.N, - bins=B.shape, - range=[[0, B.N], [0, B.N]], - weights=(f[:, 0]) * (1 - f[:, 1])) - - rho += rho_ - rho_, x_, y_ = np.histogram2d( - X[:, 0] % B.N, (X[:, 1] + 1) % B.N, - bins=B.shape, - range=[[0, B.N], [0, B.N]], - weights=(1 - f[:, 0]) * (f[:, 1])) - - rho += rho_ - rho_, x_, y_ = np.histogram2d( - (X[:, 0] + 1) % B.N, (X[:, 1] + 1) % B.N, - bins=B.shape, - range=[[0, B.N], [0, B.N]], - weights=(f[:, 0])*(f[:, 1])) - rho += rho_ - - return rho - - -class Interp2D: - "Reasonably fast bilinear interpolation routine" - def __init__(self, data): - self.data = data - self.shape = data.shape - - def __call__(self, x): - X1 = np.floor(x).astype(int) % self.shape - X2 = np.ceil(x).astype(int) % self.shape - xm = x % 1.0 - xn = 1.0 - xm - - f1 = self.data[X1[:, 0], X1[:, 1]] - f2 = self.data[X2[:, 0], X1[:, 1]] - f3 = self.data[X1[:, 0], X2[:, 1]] - f4 = self.data[X2[:, 0], X2[:, 1]] - - return \ - f1 * xn[:, 0] * xn[:, 1] + \ - f2 * xm[:, 0] * xn[:, 1] + \ - f3 * xn[:, 0] * xm[:, 1] + \ - f4 * xm[:, 0] * xm[:, 1] - - -def gradient_2nd_order(F, i): - return 1/12 * np.roll(F, 2, axis=i) \ - - 2/3 * np.roll(F, 1, axis=i) \ - + 2/3 * np.roll(F, -1, axis=i) \ - - 1/12 * np.roll(F, -2, axis=i) diff --git a/examples/cosmology/pm3.py b/examples/cosmology/pm3.py deleted file mode 100644 index 17f38b4..0000000 --- a/examples/cosmology/pm3.py +++ /dev/null @@ -1,112 +0,0 @@ -from noodles import schedule, Storable -from noodles.numpy_data import NumpyData - -import numpy as np -from math import sqrt -from numpy import random -from numpy import fft - -# from scipy.spatial import KDTree - -from .maths import tau, Interp2D, md_cic, gradient_2nd_order -from .loops import apply_filter_2, potential_2 - - -class BoxConfig(Storable): - def __init__(self, dim, N, L): - super(BoxConfig, self).__init__() - - self.dim = dim - self.N = N - self.L = L - - self.shape = (N,) * dim - self.res = L / N - self.k_max = (N * tau) / (2 * L) - self.k_min = tau / L - - def as_dict(self): - return {'dim': self.dim, - 'N': self.N, - 'L': self.L} - - @classmethod - def from_dict(cls, dim, N, L): - return cls(dim, N, L) - - -class Particles(Storable): - def __init__(self, p): - super(Particles, self).__init__() - - self._particles = NumpyData(p) - - @property - def q(self): - return self._particles.data[:, 0, :] - - @property - def p(self): - return self._particles.data[:, 1, :] - - @q.setter - def q(self, n): - self._particles.data[:, 0, :] = n - - @p.setter - def p(self, n): - self._particles.data[:, 1, :] = n - - -@schedule -def gaussian_random_field(box, P, seed=None): - if seed is not None: - random.seed(seed) - - white_noise = random.normal(0.0, 1.0, box.shape) - F = fft.fftn(white_noise) - apply_filter_2(box, lambda kx, ky: sqrt(P(sqrt(kx**2 + ky**2))), F) - return NumpyData(fft.ifftn(F).real) - - -@schedule -def zeldovich_approximation(box, potential_): - potential = potential_.data - vx = gradient_2nd_order(potential, 0) - vy = gradient_2nd_order(potential, 1) - p = Particles(np.zeros(shape=[box.N**2, 2, 2], dtype=np.float64)) - p.q = np.indices(box.shape).transpose([1, 2, 0]).reshape([-1, 2]) * box.res - p.p = np.array([vx, vy]).transpose([1, 2, 0]).reshape([-1, 2]) - return p - - -@schedule -def compute_density(box, particles): - return NumpyData(md_cic(box, particles.q)) - - -@schedule -def compute_potential(box, f_): - f = f_.data - F = fft.fftn(f) - apply_filter_2(box, potential_2, F) - return NumpyData(fft.ifftn(F).real) - - -@schedule -def drift(universe, particles, a, da): - adot = universe.adot(a) - particles.q += da * particles.p / (a**2 * adot) - return particles - - -@schedule -def kick(box, universe, potential, particles, a, da): - adot = universe.adot(a) - - for i in range(2): - g = gradient_2nd_order(potential, i) / box.res * universe.grav_cst / a - particles.p[:, i] -= da * Interp2D(g)( - (particles.q / box.res) % box.N) / adot - - return particles diff --git a/examples/cosmology/setup.py b/examples/cosmology/setup.py deleted file mode 100644 index d7f7f11..0000000 --- a/examples/cosmology/setup.py +++ /dev/null @@ -1,6 +0,0 @@ -from distutils.core import setup -from Cython.Build import cythonize - -setup( - ext_modules=cythonize("loops.pyx") -) From dc2d6f4c84cb8a234873bb03f042da0c686012b0 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Wed, 23 Nov 2016 17:15:04 +0100 Subject: [PATCH 050/155] remove unnecessary lambdas --- noodles/display/pretty_term.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/noodles/display/pretty_term.py b/noodles/display/pretty_term.py index 6a8ce32..2b7076d 100644 --- a/noodles/display/pretty_term.py +++ b/noodles/display/pretty_term.py @@ -1,7 +1,7 @@ term_codes = { - 'fg': (38, lambda r, g, b: ';2;{0};{1};{2}'.format(r, g, b), 'm'), - 'bg': (48, lambda r, g, b: ';2;{0};{1};{2}'.format(r, g, b), 'm'), + 'fg': (38, ';2;{0};{1};{2}'.format, 'm'), + 'bg': (48, ';2;{0};{1};{2}'.format, 'm'), 'bold': (1, 'm'), 'underline': (4, 'm'), 'regular': (23, 'm'), From 9f9a400b94fd9b45bdff92d1399155cce3305a3b Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Wed, 23 Nov 2016 17:17:26 +0100 Subject: [PATCH 051/155] change loop in has_scheduled_methods --- noodles/interface/decorator.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/noodles/interface/decorator.py b/noodles/interface/decorator.py index 30e9ed9..d665695 100644 --- a/noodles/interface/decorator.py +++ b/noodles/interface/decorator.py @@ -49,7 +49,7 @@ def schedule(f): def has_scheduled_methods(cls): - for name, member in cls.__dict__.items(): + for member in cls.__dict__.values(): if hasattr(member, '__wrapped__'): member.__wrapped__.__member_of__ = cls From 727f862137219e7a84c7f49ec30ac0c54d607008 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Wed, 23 Nov 2016 17:23:19 +0100 Subject: [PATCH 052/155] remove very old attempt at central logging system --- noodles/logger.py | 11 ----------- noodles/run/process.py | 7 ++++--- 2 files changed, 4 insertions(+), 14 deletions(-) delete mode 100644 noodles/logger.py diff --git a/noodles/logger.py b/noodles/logger.py deleted file mode 100644 index b838fea..0000000 --- a/noodles/logger.py +++ /dev/null @@ -1,11 +0,0 @@ -import sys - - -class Log: - def worker_stderr(self, wid, msg): - print( - "worker {0}: {1}".format(wid, msg.strip()), - file=sys.stderr, flush=True) - - -log = Log() diff --git a/noodles/run/process.py b/noodles/run/process.py index 5fdacd2..58fb15f 100644 --- a/noodles/run/process.py +++ b/noodles/run/process.py @@ -6,7 +6,7 @@ import os import random from ..workflow import get_workflow -from ..logger import log +# from ..logger import log from .connection import Connection from ..utility import object_name from .scheduler import Scheduler @@ -19,7 +19,7 @@ JSONObjectReader, JSONObjectWriter) try: - import msgpack + import msgpack # noqa has_msgpack = True except ImportError: has_msgpack = False @@ -118,7 +118,8 @@ def run_process(wf, n_processes, registry, """ workers = {} for i in range(n_processes): - new_worker = process_worker(registry, verbose, jobdirs, init, finish, use_msgpack=use_msgpack) + new_worker = process_worker(registry, verbose, jobdirs, init, finish, + use_msgpack=use_msgpack) workers['worker {0:2}'.format(i)] = new_worker worker_names = list(workers.keys()) From ae272e110bda95329f38c1b802567fa481596239 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Wed, 23 Nov 2016 17:27:41 +0100 Subject: [PATCH 053/155] fix style errors in examples --- examples/boil/boil | 266 ------------------------------------ examples/ea.py | 8 +- examples/graph-example1.svg | 57 -------- examples/graph-example2.svg | 239 -------------------------------- examples/oop-wf.svg | 150 -------------------- examples/run-on-das.py | 46 ------- examples/static_sum.py | 12 +- examples/worker.sh | 13 -- 8 files changed, 10 insertions(+), 781 deletions(-) delete mode 100755 examples/boil/boil delete mode 100644 examples/graph-example1.svg delete mode 100644 examples/graph-example2.svg delete mode 100644 examples/oop-wf.svg delete mode 100644 examples/run-on-das.py delete mode 100644 examples/worker.sh diff --git a/examples/boil/boil b/examples/boil/boil deleted file mode 100755 index 5e3c58a..0000000 --- a/examples/boil/boil +++ /dev/null @@ -1,266 +0,0 @@ -#!/usr/bin/env python3.5 - -import argparse -import configparser -import subprocess -import sys -from itertools import chain -import os -import re - - -import noodles -from noodles.display import NCDisplay, DumbDisplay - - -def find_files(path, ext): - """Find all files in `path` with extension `ext`. Returns an - iterator giving tuples (folder, (files...)). - - :param path: - search path - :param ext: - extension of files to find""" - for folder, _, files in os.walk(path): - for f in files: - if f[-len(ext):] == ext: - yield (folder, f) - - -def is_out_of_date(f, deps): - """Check if file `f` needs to be updated. Returns True if any - of the dependencies are newer than `f`. - - :param f: - file to check - :param deps: - dependencies""" - if not os.path.exists(f): - return True - - f_stat = os.stat(f) - - for d in deps: - d_stat = os.stat(d) - - if d_stat.st_mtime_ns > f_stat.st_mtime_ns: - return True - - return False - - -def dependencies(source_file, config): - """Find dependencies of source file. - - :param source_file: - source file - :param config: - boil configuration""" - cmm = subprocess.run( - [config['cc'], '-MM', source_file] + config['cflags'].split(), - stdout=subprocess.PIPE, universal_newlines=True) - deps = re.sub('^.*: ', '', cmm.stdout) \ - .replace('\\', '').replace('\n', '').split() - - return deps - - -def object_filename(srcdir, filename, config): - """Create the object filename. - - :param srcdir: - directory of source file - :param filename: - filename of source - :param config: - boil configuration""" - target_dir = os.path.join(config['objdir'], srcdir) - - # if target directory doesn't exists, create it - # flag exists_ok=True for concurrency reasons - if not os.path.exists(target_dir): - os.makedirs(target_dir, exist_ok=True) - - # construct name of object file - basename = os.path.splitext(filename)[0] - return os.path.join(target_dir, basename + '.o') - - -@noodles.schedule_hint(display=" Compiling {source_file} ... ", - confirm=True, - annotated=True) -def compile_source(source_file, object_file, config): - p = subprocess.run( - [config['cc'], '-c'] + config['cflags'].split() + - [source_file, '-o', object_file], - stderr=subprocess.PIPE, universal_newlines=True) - p.check_returncode() - - return object_file, p.stderr - - -def get_object_file(src_dir, src_file, config): - """Ensures existence of up-to-date object file. - - :param src_dir: - source directory - :param src_file: - source file - :param config: - boil configuration""" - obj_path = object_filename(src_dir, src_file, config) - src_path = os.path.join(src_dir, src_file) - - deps = dependencies(src_path, config) - if is_out_of_date(obj_path, deps): - return compile_source(src_path, obj_path, config) - else: - return obj_path - - -@noodles.schedule_hint(display=" Linking ... ", - confirm=True, - annotated=True) -def link(object_files, config): - p = subprocess.run( - [config['cc']] + object_files + ['-o', config['target']] + - config['ldflags'].split(), - stderr=subprocess.PIPE, universal_newlines=True) - p.check_returncode() - - return config['target'], p.stderr - - -@noodles.schedule_hint(display="{msg}") -def message(msg, value=0): - return value - - -@noodles.schedule -def get_target(obj_files, config): - """Ensures that target is up-to-date. - - :param obj_files: - list of object files - :param config: - boil configuration""" - if is_out_of_date(config['target'], obj_files): - return link(obj_files, config) - else: - return message("target is up-to-date.") - - -@noodles.schedule_hint(display="Building target {config[target]}") -def make_target(config): - """Make a target. First compiles the source files, then - links the object files to create an executable. - - :param config: - boil configuration""" - dirs = [config['srcdir']] + [ - os.path.normpath(os.path.join(config['srcdir'], d)) - for d in config['modules'].split() - ] - - files = chain(*( - find_files(d, config['ext']) - for d in dirs) - ) - - obj_files = noodles.gather(*[ - get_object_file(src_dir, src_file, config) - for src_dir, src_file in files - ]) - - return get_target(obj_files, config) - - -def read_config(filename): - """Read configuration from `filename` and convert it to a nested dict. - - :param filename: - name of an .ini file to read - - :returns: - dictionary.""" - reader = configparser.ConfigParser( - interpolation=configparser.ExtendedInterpolation()) - reader.read(filename) - - return {k: dict(reader[k]) for k in reader.sections()} - - -def error_filter(type, value, tb): - if type is subprocess.CalledProcessError: - return value.stderr - else: - return None - - -def try_to_run(cmd, err_prefix): - p = subprocess.run( - cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, - universal_newlines=True) - try: - p.check_returncode() - return p.stdout - except subprocess.CalledProcessError as e: - print(err_prefix, e.stderr) - sys.exit(1) - - -if __name__ == '__main__': - parser = argparse.ArgumentParser( - description="Compile software. Configuration is in 'boil.ini'.") - parser.add_argument( - '-j', dest='n_threads', type=int, default=1, - help='number of threads to run simultaneously.') - parser.add_argument( - '-dumb', default=False, action='store_true', - help='print info without special term codes.') - parser.add_argument( - 'target', type=str, - help='target to build, give \'list\' to list targets.') - args = parser.parse_args(sys.argv[1:]) - - if not os.path.exists('boil.ini'): - print("No boil.ini in current directory.") - sys.exit(1) - - bconfig = read_config('boil.ini') - - if 'generic' not in bconfig: - print("Error: Configuration has no 'generic' section.") - sys.exit(1) - - if args.target == 'list': - targets = list(bconfig.keys()) - targets.remove('generic') - print("Possible targets: ", ', '.join(targets)) - sys.exit(0) - - if 'command' in bconfig[args.target]: - os.system(bconfig[args.target]['command']) - - else: - target_config = bconfig['generic'] - target_config.update(bconfig[args.target]) - - if 'libraries' in target_config: - a = try_to_run( - ['pkg-config', '--libs'] + target_config['libraries'].split(), - err_prefix="Error running pkg-config: ") - - target_config['ldflags'] += ' ' + a - - a = try_to_run( - ['pkg-config', '--cflags'] + - target_config['libraries'].split(), - err_prefix="Error running pkg-config: ") - - target_config['cflags'] += ' ' + a - - work = make_target(target_config) - display_type = DumbDisplay if args.dumb else NCDisplay - with display_type(error_filter) as display: - noodles.run_logging(work, args.n_threads, display) diff --git a/examples/ea.py b/examples/ea.py index f24c02e..02c682d 100644 --- a/examples/ea.py +++ b/examples/ea.py @@ -1,9 +1,9 @@ -from noodles import gather, run_logging, schedule, has_scheduled_methods, run_process, serial, run_parallel, run_single +from noodles import (run_logging) import subprocess import numpy as np -from ea import (EA, Chromosome, Generation, Rastrigin, registry) -from noodles.display import SimpleDisplay, DumbDisplay +from ea import (EA, Rastrigin) +from noodles.display import SimpleDisplay def error_filter(xcptn): @@ -32,7 +32,7 @@ def error_filter(xcptn): print("╭─(Running evolution...)") with SimpleDisplay(error_filter) as display: answer = run_logging(g, 1, display) - #answer = run_single(g) + # answer = run_single(g) for i in answer.individuals: print(i.fitness) diff --git a/examples/graph-example1.svg b/examples/graph-example1.svg deleted file mode 100644 index 6d9bfc9..0000000 --- a/examples/graph-example1.svg +++ /dev/null @@ -1,57 +0,0 @@ - - - - - - -%3 - - -140238561536256 - -add - (—, —) - - -140238561535824 - -add - (41, —) - - -140238561535824->140238561536256 - - - - -140238561536040 - -sub - (—, 44) - - -140238561536040->140238561536256 - - - - -140238561535608 - -add - (42, 43) - - -140238561535608->140238561535824 - - - - -140238561535608->140238561536040 - - - - - diff --git a/examples/graph-example2.svg b/examples/graph-example2.svg deleted file mode 100644 index 63d077e..0000000 --- a/examples/graph-example2.svg +++ /dev/null @@ -1,239 +0,0 @@ - - - - - - -%3 - - -140041583242912 - -add - (3, —) - - -140041583243128 - -mul - (—, —) - - -140041583242912->140041583243128 - - - - -140041583281064 - -binder - (—, —, —, —, —, —) - - -140041583243128->140041583281064 - - - - -140041583281208 - -sum - (—, <built-in function sum>) - - -140041583281064->140041583281208 - - - - -140041583280704 - -add - (5, —) - - -140041583280920 - -mul - (—, —) - - -140041583280704->140041583280920 - - - - -140041583280920->140041583281064 - - - - -140041583241184 - -add - (1, 1) - - -140041583241184->140041583243128 - - - - -140041583241184->140041583280920 - - - - -140041583242696 - -mul - (—, —) - - -140041583241184->140041583242696 - - - - -140041583241832 - -mul - (—, —) - - -140041583241184->140041583241832 - - - - -140041583280488 - -mul - (—, —) - - -140041583241184->140041583280488 - - - - -140041583242264 - -mul - (—, —) - - -140041583241184->140041583242264 - - - - -140041583241400 - -sub - (3, —) - - -140041583241184->140041583241400 - - - - -140041583242696->140041583281064 - - - - -140041583241832->140041583281064 - - - - -140041583280488->140041583281064 - - - - -140041583242264->140041583281064 - - - - -140041583241400->140041583242912 - - - - -140041583241400->140041583280704 - - - - -140041583280272 - -add - (4, —) - - -140041583241400->140041583280272 - - - - -140041583242480 - -add - (2, —) - - -140041583241400->140041583242480 - - - - -140041583241616 - -add - (0, —) - - -140041583241400->140041583241616 - - - - -140041583242048 - -add - (1, —) - - -140041583241400->140041583242048 - - - - -140041583280272->140041583280488 - - - - -140041583242480->140041583242696 - - - - -140041583241616->140041583241832 - - - - -140041583242048->140041583242264 - - - - - diff --git a/examples/oop-wf.svg b/examples/oop-wf.svg deleted file mode 100644 index 5736bd6..0000000 --- a/examples/oop-wf.svg +++ /dev/null @@ -1,150 +0,0 @@ - - - - - - -%3 - - -140295268461312 - -_setattr - (—, attr, —) - - -140295268874784 - -_setattr - (—, x, —) - - -140295268874840 - -_setattr - (—, second, —) - - -140295268874784->140295268874840 - - - - -140295268874840->140295268461312 - - - - -140295268874952 - -_getattr - (—, second) - - -140295268874952->140295268874840 - - - - -140295274632304 - -A - (5) - - -140295274632528 - -_getattr - (—, multiply) - - -140295274632304->140295274632528 - - - - -140295274632696 - -_do_call - (—, 10) - - -140295274632528->140295274632696 - - - - -140295268972080 - -_setattr - (—, second, 7) - - -140295274632696->140295268972080 - - - - -140295268972080->140295268874952 - - - - -140295268972304 - -_setattr - (—, attr, 1.0) - - -140295268972080->140295268972304 - - - - -140295268461256 - -_getattr - (—, attr) - - -140295268461256->140295268461312 - - - - -140295268952888 - -B - () - - -140295268952888->140295268874784 - - - - -140295268972304->140295268461256 - - - - -140295268874392 - -_getattr - (—, x) - - -140295268972304->140295268874392 - - - - -140295268874392->140295268874784 - - - - - diff --git a/examples/run-on-das.py b/examples/run-on-das.py deleted file mode 100644 index 179de83..0000000 --- a/examples/run-on-das.py +++ /dev/null @@ -1,46 +0,0 @@ -from noodles import ( - serial, gather) - -from noodles.run.xenon import ( - XenonConfig, RemoteJobConfig, XenonKeeper, run_xenon_prov) - -from noodles.display import ( - NCDisplay) - -from noodles.tutorial import ( - log_add, mul, sub, accumulate) - -import os - -if __name__ == '__main__': - A = log_add(1, 1) - B = sub(3, A) - - multiples = [mul(log_add(i, B), A) for i in range(6)] - C = accumulate(gather(*multiples)) - - with XenonKeeper() as Xe: - certificate = Xe.credentials.newCertificateCredential( - 'ssh', os.environ["HOME"] + '/.ssh/id_rsa', '', '', None) - - xenon_config = XenonConfig( - jobs_scheme='slurm', - location='', - credential=certificate, - jobs_properties={ - 'xenon.adaptors.slurm.ignore.version': 'true' - } - ) - - job_config = RemoteJobConfig( - registry=serial.base, - prefix='', - working_dir='', - time_out=5000 - ) - - with NCDisplay() as display: - result = run_xenon_prov( - C, Xe, "cache.json", 2, - xenon_config, job_config, display=display) - print("The answer is", result) diff --git a/examples/static_sum.py b/examples/static_sum.py index 74a6ed7..159966c 100644 --- a/examples/static_sum.py +++ b/examples/static_sum.py @@ -1,7 +1,7 @@ from noodles import (run_parallel, schedule) from noodles.tutorial import (add) -import numpy as np +# import numpy as np def static_sum(values, limit_n=1000): @@ -21,16 +21,16 @@ def dynamic_sum(values, limit_n=1000, acc=0, depth=4): """Example of dynamic sum.""" if len(values) < limit_n: return acc + sum(values) - + if depth > 0: - half = len(values) // 2 + half = len(values) // 2 return add( dynamic_sum(values[:half], limit_n, acc, depth=depth-1), dynamic_sum(values[half:], limit_n, 0, depth=depth-1)) - return dynamic_sum(values[limit_n:], limit_n, acc + sum(values[:limit_n]), depth) - + return dynamic_sum(values[limit_n:], limit_n, + acc + sum(values[:limit_n]), depth) + result = run_parallel(dynamic_sum(range(1000000000), 1000000), 4) print(result) - diff --git a/examples/worker.sh b/examples/worker.sh deleted file mode 100644 index abaa7c8..0000000 --- a/examples/worker.sh +++ /dev/null @@ -1,13 +0,0 @@ -#!/bin/bash - -cd "$(dirname "${BASH_SOURCE[0]}")" - -if [ -e $1/bin/activate ]; then - source $1/bin/activate; -fi - -python -m noodles.worker ${@:2} - -if [ -z ${VIRTUAL_ENV+x} ]; then - deactivate; -fi From 5820c1e6b216fd42e1abda0fa89ea11b1eda7aad Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Wed, 23 Nov 2016 17:34:04 +0100 Subject: [PATCH 054/155] restore boil after faulty commit --- examples/boil/boil | 266 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 266 insertions(+) create mode 100755 examples/boil/boil diff --git a/examples/boil/boil b/examples/boil/boil new file mode 100755 index 0000000..5e3c58a --- /dev/null +++ b/examples/boil/boil @@ -0,0 +1,266 @@ +#!/usr/bin/env python3.5 + +import argparse +import configparser +import subprocess +import sys +from itertools import chain +import os +import re + + +import noodles +from noodles.display import NCDisplay, DumbDisplay + + +def find_files(path, ext): + """Find all files in `path` with extension `ext`. Returns an + iterator giving tuples (folder, (files...)). + + :param path: + search path + :param ext: + extension of files to find""" + for folder, _, files in os.walk(path): + for f in files: + if f[-len(ext):] == ext: + yield (folder, f) + + +def is_out_of_date(f, deps): + """Check if file `f` needs to be updated. Returns True if any + of the dependencies are newer than `f`. + + :param f: + file to check + :param deps: + dependencies""" + if not os.path.exists(f): + return True + + f_stat = os.stat(f) + + for d in deps: + d_stat = os.stat(d) + + if d_stat.st_mtime_ns > f_stat.st_mtime_ns: + return True + + return False + + +def dependencies(source_file, config): + """Find dependencies of source file. + + :param source_file: + source file + :param config: + boil configuration""" + cmm = subprocess.run( + [config['cc'], '-MM', source_file] + config['cflags'].split(), + stdout=subprocess.PIPE, universal_newlines=True) + deps = re.sub('^.*: ', '', cmm.stdout) \ + .replace('\\', '').replace('\n', '').split() + + return deps + + +def object_filename(srcdir, filename, config): + """Create the object filename. + + :param srcdir: + directory of source file + :param filename: + filename of source + :param config: + boil configuration""" + target_dir = os.path.join(config['objdir'], srcdir) + + # if target directory doesn't exists, create it + # flag exists_ok=True for concurrency reasons + if not os.path.exists(target_dir): + os.makedirs(target_dir, exist_ok=True) + + # construct name of object file + basename = os.path.splitext(filename)[0] + return os.path.join(target_dir, basename + '.o') + + +@noodles.schedule_hint(display=" Compiling {source_file} ... ", + confirm=True, + annotated=True) +def compile_source(source_file, object_file, config): + p = subprocess.run( + [config['cc'], '-c'] + config['cflags'].split() + + [source_file, '-o', object_file], + stderr=subprocess.PIPE, universal_newlines=True) + p.check_returncode() + + return object_file, p.stderr + + +def get_object_file(src_dir, src_file, config): + """Ensures existence of up-to-date object file. + + :param src_dir: + source directory + :param src_file: + source file + :param config: + boil configuration""" + obj_path = object_filename(src_dir, src_file, config) + src_path = os.path.join(src_dir, src_file) + + deps = dependencies(src_path, config) + if is_out_of_date(obj_path, deps): + return compile_source(src_path, obj_path, config) + else: + return obj_path + + +@noodles.schedule_hint(display=" Linking ... ", + confirm=True, + annotated=True) +def link(object_files, config): + p = subprocess.run( + [config['cc']] + object_files + ['-o', config['target']] + + config['ldflags'].split(), + stderr=subprocess.PIPE, universal_newlines=True) + p.check_returncode() + + return config['target'], p.stderr + + +@noodles.schedule_hint(display="{msg}") +def message(msg, value=0): + return value + + +@noodles.schedule +def get_target(obj_files, config): + """Ensures that target is up-to-date. + + :param obj_files: + list of object files + :param config: + boil configuration""" + if is_out_of_date(config['target'], obj_files): + return link(obj_files, config) + else: + return message("target is up-to-date.") + + +@noodles.schedule_hint(display="Building target {config[target]}") +def make_target(config): + """Make a target. First compiles the source files, then + links the object files to create an executable. + + :param config: + boil configuration""" + dirs = [config['srcdir']] + [ + os.path.normpath(os.path.join(config['srcdir'], d)) + for d in config['modules'].split() + ] + + files = chain(*( + find_files(d, config['ext']) + for d in dirs) + ) + + obj_files = noodles.gather(*[ + get_object_file(src_dir, src_file, config) + for src_dir, src_file in files + ]) + + return get_target(obj_files, config) + + +def read_config(filename): + """Read configuration from `filename` and convert it to a nested dict. + + :param filename: + name of an .ini file to read + + :returns: + dictionary.""" + reader = configparser.ConfigParser( + interpolation=configparser.ExtendedInterpolation()) + reader.read(filename) + + return {k: dict(reader[k]) for k in reader.sections()} + + +def error_filter(type, value, tb): + if type is subprocess.CalledProcessError: + return value.stderr + else: + return None + + +def try_to_run(cmd, err_prefix): + p = subprocess.run( + cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, + universal_newlines=True) + try: + p.check_returncode() + return p.stdout + except subprocess.CalledProcessError as e: + print(err_prefix, e.stderr) + sys.exit(1) + + +if __name__ == '__main__': + parser = argparse.ArgumentParser( + description="Compile software. Configuration is in 'boil.ini'.") + parser.add_argument( + '-j', dest='n_threads', type=int, default=1, + help='number of threads to run simultaneously.') + parser.add_argument( + '-dumb', default=False, action='store_true', + help='print info without special term codes.') + parser.add_argument( + 'target', type=str, + help='target to build, give \'list\' to list targets.') + args = parser.parse_args(sys.argv[1:]) + + if not os.path.exists('boil.ini'): + print("No boil.ini in current directory.") + sys.exit(1) + + bconfig = read_config('boil.ini') + + if 'generic' not in bconfig: + print("Error: Configuration has no 'generic' section.") + sys.exit(1) + + if args.target == 'list': + targets = list(bconfig.keys()) + targets.remove('generic') + print("Possible targets: ", ', '.join(targets)) + sys.exit(0) + + if 'command' in bconfig[args.target]: + os.system(bconfig[args.target]['command']) + + else: + target_config = bconfig['generic'] + target_config.update(bconfig[args.target]) + + if 'libraries' in target_config: + a = try_to_run( + ['pkg-config', '--libs'] + target_config['libraries'].split(), + err_prefix="Error running pkg-config: ") + + target_config['ldflags'] += ' ' + a + + a = try_to_run( + ['pkg-config', '--cflags'] + + target_config['libraries'].split(), + err_prefix="Error running pkg-config: ") + + target_config['cflags'] += ' ' + a + + work = make_target(target_config) + display_type = DumbDisplay if args.dumb else NCDisplay + with display_type(error_filter) as display: + noodles.run_logging(work, args.n_threads, display) From a3e557b2e057da483c958a18137d1189f37e3b8b Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Wed, 23 Nov 2016 17:36:08 +0100 Subject: [PATCH 055/155] intregration test styling --- integration/test_xenon/test_job_submission.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/integration/test_xenon/test_job_submission.py b/integration/test_xenon/test_job_submission.py index 1fd572a..de4e441 100644 --- a/integration/test_xenon/test_job_submission.py +++ b/integration/test_xenon/test_job_submission.py @@ -1,4 +1,5 @@ -from noodles.run.xenon import (XenonJob, XenonScheduler, XenonKeeper, XenonConfig) +from noodles.run.xenon import ( + XenonScheduler, XenonKeeper, XenonConfig) import docker import uuid From d3b89329de7f8fe355e550e5c2052f7f32415bba Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Wed, 23 Nov 2016 17:38:01 +0100 Subject: [PATCH 056/155] ea example styling --- examples/ea/generation.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/examples/ea/generation.py b/examples/ea/generation.py index af98569..e51fcce 100644 --- a/examples/ea/generation.py +++ b/examples/ea/generation.py @@ -4,13 +4,14 @@ class Generation(Storable): def __init__(self, individuals): - super(Storable, self).__init__() + super(Generation, self).__init__() self.individuals = individuals self.number = -1 # Evaluate individuals def evaluate(self, fitness_evaluator): - evaluate = [Chromosome(fitness=fitness_evaluator.evaluate(c.values), values=c.values, sigma=c.sigma) + evaluate = [Chromosome(fitness=fitness_evaluator.evaluate(c.values), + values=c.values, sigma=c.sigma) for c in self.individuals] self.individuals = gather(*evaluate) From ce17235eebc0e77e46b8a355837ab763af278738 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Wed, 23 Nov 2016 18:09:05 +0100 Subject: [PATCH 057/155] styling --- noodles/__init__.py | 2 +- test/test_exceptions.py | 1 + test/test_merge_workflow.py | 2 +- test/test_worker.py | 3 +-- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/noodles/__init__.py b/noodles/__init__.py index 25ff05a..adabb38 100644 --- a/noodles/__init__.py +++ b/noodles/__init__.py @@ -11,7 +11,7 @@ __version__ = "0.2.3" __all__ = ['schedule', 'schedule_hint', 'run_single', 'run_process', - 'run_logging', 'run_parallel', 'run_hybrid', 'unwrap', + 'run_logging', 'run_parallel', 'unwrap', 'Scheduler', 'Storable', 'has_scheduled_methods', 'gather', 'lift', 'unpack', 'delay', 'update_hints', 'quote', 'unquote', 'find_first'] diff --git a/test/test_exceptions.py b/test/test_exceptions.py index 1b8d233..5223500 100644 --- a/test/test_exceptions.py +++ b/test/test_exceptions.py @@ -10,6 +10,7 @@ def __init__(self, msg): @schedule def raises_my_exception(): raise MyException("Error!") + return None @raises(MyException) diff --git a/test/test_merge_workflow.py b/test/test_merge_workflow.py index c52f493..d562b38 100644 --- a/test/test_merge_workflow.py +++ b/test/test_merge_workflow.py @@ -74,7 +74,7 @@ def test_binder(): @schedule def takes_keywords(s, **kwargs): - pass + return s def test_with_keywords(): diff --git a/test/test_worker.py b/test/test_worker.py index 5f13ce4..4c3624c 100644 --- a/test/test_worker.py +++ b/test/test_worker.py @@ -79,8 +79,7 @@ def concatenate(lst): def dmap(f, lst): - return gather(*[gather(*[ - f(x) for x in row]) for row in lst]) + return gather(*[gather(*[f(x) for x in row]) for row in lst]) # def test_worker_with_storable(): From cba1806f624590b776ab2d63c78e6167af38fb65 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Wed, 23 Nov 2016 18:18:29 +0100 Subject: [PATCH 058/155] small fixes --- noodles/delay.py | 23 ----------------------- noodles/run/protect.py | 2 +- noodles/run/remote/io.py | 7 +++---- noodles/run/run_with_prov.py | 4 ---- noodles/run/worker.py | 4 ++-- noodles/worker.py | 9 +++------ noodles/workflow/mutations.py | 6 +++--- test/test_delay.py | 26 -------------------------- 8 files changed, 12 insertions(+), 69 deletions(-) delete mode 100644 noodles/delay.py delete mode 100644 test/test_delay.py diff --git a/noodles/delay.py b/noodles/delay.py deleted file mode 100644 index 307be7e..0000000 --- a/noodles/delay.py +++ /dev/null @@ -1,23 +0,0 @@ -from copy import deepcopy -from .workflow import get_workflow - - -class DelayedWorkflow(object): - def __init__(self, obj): - self.data = get_workflow(obj) - - def __deepcopy__(self, memo): - # return DelayedWorkflow(self.data) - return DelayedWorkflow(deepcopy(self.data, memo)) - - -def delay(obj): - return DelayedWorkflow(obj) - - -def force(dw): - if isinstance(dw, DelayedWorkflow): - return dw.data - else: - return dw - diff --git a/noodles/run/protect.py b/noodles/run/protect.py index 648e17a..987ad8e 100644 --- a/noodles/run/protect.py +++ b/noodles/run/protect.py @@ -64,4 +64,4 @@ def protected_fn(*args, **kwargs): raise exc - return fn + return protected_fn diff --git a/noodles/run/remote/io.py b/noodles/run/remote/io.py index 4db51e8..65568fa 100644 --- a/noodles/run/remote/io.py +++ b/noodles/run/remote/io.py @@ -32,10 +32,9 @@ def JSONObjectReader(registry, fi, deref=False): @coroutine def JSONObjectWriter(registry, fo, host=None): - import sys + # import sys while True: obj = yield - #obj_msg = registry.to_json(obj, host=host) - #print(obj_msg, file=sys.stderr) + # obj_msg = registry.to_json(obj, host=host) + # print(obj_msg, file=sys.stderr) print(registry.to_json(obj, host=host), file=fo, flush=True) - diff --git a/noodles/run/run_with_prov.py b/noodles/run/run_with_prov.py index fa5a3d6..07aa955 100644 --- a/noodles/run/run_with_prov.py +++ b/noodles/run/run_with_prov.py @@ -210,10 +210,6 @@ def create_prov_worker( jobs = Queue() - @push_map - def log_job_start(key, job): - return (key, 'start', job, None) - r_src = jobs.source \ >> start_job(db) \ >> worker \ diff --git a/noodles/run/worker.py b/noodles/run/worker.py index 82f5125..2a849db 100644 --- a/noodles/run/worker.py +++ b/noodles/run/worker.py @@ -33,10 +33,10 @@ def run_job(key, job): result = job.apply() if isinstance(result, AnnotatedValue): value, message = result - return ResultMesage(key, 'done', value, message) + return ResultMessage(key, 'done', value, message) return ResultMessage(key, 'done', result, None) - except Exception as error: + except Exception: exc_info = sys.exc_info() return ResultMessage(key, 'error', None, JobException(*exc_info)) diff --git a/noodles/worker.py b/noodles/worker.py index 73df658..3552b62 100644 --- a/noodles/worker.py +++ b/noodles/worker.py @@ -42,12 +42,12 @@ run_job) from .run.messages import ( - JobMessage, ResultMessage) - + JobMessage) + from .run.remote.io import ( MsgPackObjectReader, MsgPackObjectWriter, JSONObjectReader, JSONObjectWriter) - + def run_batch_mode(args): print("Batch mode is not yet implemented") @@ -104,9 +104,6 @@ def run_online_mode(args): if args.verbose: print("result: ", result, file=sys.stderr, flush=True) - print("json: ", put_result_json( - registry, args.name, key, - 'success', result, None), file=sys.stderr, flush=True) if args.jobdirs: # parent directory diff --git a/noodles/workflow/mutations.py b/noodles/workflow/mutations.py index f6e5146..8e0923a 100644 --- a/noodles/workflow/mutations.py +++ b/noodles/workflow/mutations.py @@ -1,4 +1,4 @@ -from .arguments import set_argument, ref_argument, format_address, Empty +from .arguments import set_argument, Empty def reset_workflow(workflow): @@ -15,8 +15,8 @@ def insert_result(node, address, value): is redundant, but if we don't give an error here the program would continue with unexpected results. """ - #a = ref_argument(node.bound_args, address) - #if a != Empty: + # a = ref_argument(node.bound_args, address) + # if a != Empty: # raise RuntimeError( # "Noodle panic. Argument {arg} in {name} already given." \ # .format(arg=format_address(address), diff --git a/test/test_delay.py b/test/test_delay.py deleted file mode 100644 index e0127fb..0000000 --- a/test/test_delay.py +++ /dev/null @@ -1,26 +0,0 @@ -import noodles -from noodles import (schedule, run_single) -from noodles.delay import (delay, force) -from noodles.tutorial import (add, sub, mul, accumulate) - - -@schedule -def cond(truth, when_true, when_false): - if truth: - return force(when_true) - else: - return force(when_false) - - -@schedule -def should_not_run(): - raise RuntimeError("This function should never have been called.") - - -def test_truthfulness(): - w = sub(4, add(3, 2)) - a = cond(True, delay(w), delay(should_not_run())) - b = cond(False, delay(should_not_run()), delay(w)) - result = run_single(mul(a, b)) - assert result == 1 - From 419f70ee5fbc0375e40e8eb9663f210d1644a96c Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Wed, 23 Nov 2016 18:27:47 +0100 Subject: [PATCH 059/155] ... --- noodles/run/run_with_prov.py | 6 +----- noodles/run/scheduler.py | 1 - noodles/workflow/arguments.py | 4 ++-- noodles/workflow/mutations.py | 2 +- test/test_exceptions.py | 1 - 5 files changed, 4 insertions(+), 10 deletions(-) diff --git a/noodles/run/run_with_prov.py b/noodles/run/run_with_prov.py index 07aa955..89ddc4d 100644 --- a/noodles/run/run_with_prov.py +++ b/noodles/run/run_with_prov.py @@ -36,7 +36,7 @@ def pass_job(source): prov = prov_key(job_msg) if db.job_exists(prov): - status, other_key, result = db.get_result_or_attach( + status, _, result = db.get_result_or_attach( key, prov, {}) if status == 'retrieved': yield decode_result(key, result) @@ -232,10 +232,6 @@ def prov_wrap_connection( registry = registry() db = JobDB(jobdb_file) - @push_map - def log_job_start(key, job): - return (key, 'start', job, None) - r_src = worker.source \ >> store_result_deep(registry, db, job_keeper, pred) diff --git a/noodles/run/scheduler.py b/noodles/run/scheduler.py index 8bc169d..1056346 100644 --- a/noodles/run/scheduler.py +++ b/noodles/run/scheduler.py @@ -1,6 +1,5 @@ from .connection import (Connection) from .job_keeper import (JobKeeper) -from .messages import (JobMessage) from ..workflow import ( is_workflow, get_workflow, insert_result, diff --git a/noodles/workflow/arguments.py b/noodles/workflow/arguments.py index 5f93db2..8fb2a90 100644 --- a/noodles/workflow/arguments.py +++ b/noodles/workflow/arguments.py @@ -44,12 +44,12 @@ def serialize_arguments(bound_args): """ for p in bound_args.signature.parameters.values(): if p.kind == Parameter.VAR_POSITIONAL: - for i, v in enumerate(bound_args.arguments[p.name]): + for i, _ in enumerate(bound_args.arguments[p.name]): yield ArgumentAddress(ArgumentKind.variadic, p.name, i) continue if p.kind == Parameter.VAR_KEYWORD: - for k, v in bound_args.arguments[p.name].items(): + for k in bound_args.arguments[p.name].keys(): yield ArgumentAddress(ArgumentKind.keyword, p.name, k) continue diff --git a/noodles/workflow/mutations.py b/noodles/workflow/mutations.py index 8e0923a..eb1752d 100644 --- a/noodles/workflow/mutations.py +++ b/noodles/workflow/mutations.py @@ -2,7 +2,7 @@ def reset_workflow(workflow): - for src, tgt in workflow.links.items(): + for tgt in workflow.links.values(): for m, a in tgt: set_argument(workflow.nodes[m].bound_args, a, Empty) diff --git a/test/test_exceptions.py b/test/test_exceptions.py index 5223500..1b8d233 100644 --- a/test/test_exceptions.py +++ b/test/test_exceptions.py @@ -10,7 +10,6 @@ def __init__(self, msg): @schedule def raises_my_exception(): raise MyException("Error!") - return None @raises(MyException) From 8e0c9a5088254bb4bab038e087c63b1dd79ac9cc Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Wed, 23 Nov 2016 18:31:50 +0100 Subject: [PATCH 060/155] two new badges --- README.rst | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/README.rst b/README.rst index 79ec254..29e3a4f 100644 --- a/README.rst +++ b/README.rst @@ -1,5 +1,11 @@ .. image:: https://travis-ci.org/NLeSC/noodles.svg?branch=master :alt: Travis +.. image:: https://api.codacy.com/project/badge/Grade/f45b3299dbb74ccb8f766701563a88db + :target:https://www.codacy.com/app/Noodles/noodles?utm_source=github.com&utm_medium=referral&utm_content=NLeSC/noodles&utm_campaign=Badge_Grade + :alt: Codacy Badge +.. image:: https://api.codacy.com/project/badge/Coverage/f45b3299dbb74ccb8f766701563a88db + :target: https://www.codacy.com/app/Noodles/noodles?utm_source=github.com&utm_medium=referral&utm_content=NLeSC/noodles&utm_campaign=Badge_Coverage + :alt: Coverage Badge Noodles - workflow engine ========================= From b02a5258506828bc59ed3e4163f3472671b05a72 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Wed, 23 Nov 2016 18:34:29 +0100 Subject: [PATCH 061/155] remove stale test --- test/test_worker.py | 94 --------------------------------------------- 1 file changed, 94 deletions(-) delete mode 100644 test/test_worker.py diff --git a/test/test_worker.py b/test/test_worker.py deleted file mode 100644 index 4c3624c..0000000 --- a/test/test_worker.py +++ /dev/null @@ -1,94 +0,0 @@ -from noodles import ( - schedule, Scheduler, gather, - serial, Storable) -from noodles.serial import (Registry, AsDict) -from noodles.workflow import get_workflow -from noodles.run.process import process_worker - - -def registry(): - return Registry(parent=serial.base(), default=AsDict) - - -@schedule -def f(x, y): - return x + y - - -@schedule -def ssum(lst, acc=sum): - return acc(lst) - - -def test_worker(): - a = [f(i, j) for i in range(5) for j in range(5)] - b = ssum(gather(*a)) - - result = Scheduler().run( - process_worker(registry, use_msgpack=True), - get_workflow(b)) - assert result == 100 - - -class A(Storable): - def __init__(self, **kwargs): - super(A, self).__init__() - self.__dict__.update(kwargs) - - -@schedule -def g(a): - return a.x + a.y - - -@schedule -def cons(i, lst): - return [i] + lst - - -def stupid_range(n, m): - if n == m: - return [] - else: - return cons(n, stupid_range(n+1, m)) - - -@schedule -def map(f, lst): - return gather(*[f(i) for i in lst]) - - -@schedule -def sqr(x): - return x*x - - -@schedule -def concatenate(lst): - return sum(lst, []) - - -# def test_stupid_range(): -# a = stupid_range(0, 5) -# result1 = Scheduler().run(process_worker(registry), get_workflow(a)) -# assert result1 == list(range(5)) -# -# b = map(sqr, stupid_range(0, 5)) -# result2 = Scheduler().run(process_worker(registry), get_workflow(b)) -# assert result2 == [i*i for i in range(5)] - - -def dmap(f, lst): - return gather(*[gather(*[f(x) for x in row]) for row in lst]) - - -# def test_worker_with_storable(): -# a = [[A(y=j) for j in range(5)] for i in range(5)] -# for i, lst in enumerate(a): -# for q in lst: -# q.x = f(i, q.y) -# -# c = dmap(g, a) -# b = ssum(concatenate(c)) -# result = Scheduler().run(process_worker(registry), get_workflow(b)) -# assert result == 150 From c3b4aabe18d4a3d791b13c22bdd6f26c341e8a52 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Wed, 23 Nov 2016 18:38:38 +0100 Subject: [PATCH 062/155] missing link in readme --- README.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.rst b/README.rst index 29e3a4f..658cecc 100644 --- a/README.rst +++ b/README.rst @@ -1,7 +1,7 @@ .. image:: https://travis-ci.org/NLeSC/noodles.svg?branch=master :alt: Travis .. image:: https://api.codacy.com/project/badge/Grade/f45b3299dbb74ccb8f766701563a88db - :target:https://www.codacy.com/app/Noodles/noodles?utm_source=github.com&utm_medium=referral&utm_content=NLeSC/noodles&utm_campaign=Badge_Grade + :target: https://www.codacy.com/app/Noodles/noodles?utm_source=github.com&utm_medium=referral&utm_content=NLeSC/noodles&utm_campaign=Badge_Grade :alt: Codacy Badge .. image:: https://api.codacy.com/project/badge/Coverage/f45b3299dbb74ccb8f766701563a88db :target: https://www.codacy.com/app/Noodles/noodles?utm_source=github.com&utm_medium=referral&utm_content=NLeSC/noodles&utm_campaign=Badge_Coverage From eeb5f1508624bd8d1d590fdea78ec8b20494f30c Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Thu, 24 Nov 2016 11:30:26 +0100 Subject: [PATCH 063/155] remove dead space --- noodles/serial/base.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/noodles/serial/base.py b/noodles/serial/base.py index 7bc6f67..f25635a 100644 --- a/noodles/serial/base.py +++ b/noodles/serial/base.py @@ -1,6 +1,6 @@ from .registry import (Registry, Serialiser) from .reasonable import (Reasonable, SerReasonableObject) -from ..interface import (PromisedObject) +from ..interface import (PromisedObject) from ..utility import (object_name, look_up, importable) from ..workflow import (Workflow, NodeData, FunctionNode, ArgumentAddress, ArgumentKind, reset_workflow, get_workflow) @@ -30,13 +30,13 @@ class SerTuple(Serialiser): We want to get tuples back, so make this explicit.""" def __init__(self): super(SerTuple, self).__init__(tuple) - + def encode(self, obj, make_rec): return make_rec(list(obj)) - + def decode(self, cls, data): return cls(data) - + class SerEnum(Serialiser): def __init__(self, cls): From 9e9bdeff1b5be39fdfbb1a95f8694c5fb0908007 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Tue, 29 Nov 2016 09:34:23 +0100 Subject: [PATCH 064/155] docs --- noodles/interface/decorator.py | 40 ++++++++++++++++++++++++++++++---- 1 file changed, 36 insertions(+), 4 deletions(-) diff --git a/noodles/interface/decorator.py b/noodles/interface/decorator.py index d665695..73743f9 100644 --- a/noodles/interface/decorator.py +++ b/noodles/interface/decorator.py @@ -1,3 +1,7 @@ +""" +.. default-domain:: py +""" + from functools import wraps from copy import deepcopy import hashlib @@ -11,14 +15,12 @@ def scheduled_function(f, hints=None): - """ - The Noodles schedule function decorator. + """The Noodles schedule function decorator. The decorated function will return a workflow in stead of being applied immediately. This workflow can then be passed to a job scheduler in order to be run on any architecture supporting the current - python environment. - """ + python environment.""" if hints is None: hints = {} @@ -38,6 +40,7 @@ def wrapped(*args, **kwargs): f, args, kwargs, deepcopy(hints), call_by_value=config['call_by_value'])) + # add *(scheduled)* to the beginning of the docstring. if hasattr(wrapped, '__doc__') and wrapped.__doc__ is not None: wrapped.__doc__ = "*(scheduled)* " + wrapped.__doc__ @@ -45,10 +48,18 @@ def wrapped(*args, **kwargs): def schedule(f): + """Decorator; schedule calls to function `f` into a workflow, in stead of + running them at once. The decorated function returns a + :class:`PromisedObject`.""" return scheduled_function(f) def has_scheduled_methods(cls): + """Decorator; use this on a class for which some methods have been + decorated with :func:`schedule` or :func:`schedule_hint`. Those methods + are then tagged with the attribute `__member_of__`, so that we may + serialise and retrieve the correct method. This should be considered + a patch to a flaw in the Python object model.""" for member in cls.__dict__.values(): if hasattr(member, '__wrapped__'): member.__wrapped__.__member_of__ = cls @@ -57,10 +68,17 @@ def has_scheduled_methods(cls): def schedule_hint(**hints): + """Decorator; same as :func:`schedule`, with added hints. These + hints can be anything.""" return lambda f: scheduled_function(f, hints) def unwrap(f): + """Unwrap a wrapped function; the function needs to have been wrapped + using :func:`functools.wraps`, as is done in :func:`schedule`. + + If function `f` doesn't have the `__wrapped` attribute, the same + function `f` is returned.""" try: return f.__wrapped__ except AttributeError: @@ -105,11 +123,25 @@ def _do_call(obj, *args, **kwargs): def update_hints(obj, data): + """Update the hints on the root-node of a workflow. Usually, schedule + hints are fixed per function. Sometimes a user may want to set hints + manually on a specific promised object. :func:`update_hints` uses the + `update` method on the hints dictionary with `data` as its argument. + + :param obj: a :class:`PromisedObject`. + :param data: a :class:`dict` containing additional hints. + + The hints are modified, in place, on the node. All workflows that contain + the node are affected.""" root = obj._workflow.root obj._workflow.nodes[root].hints.update(data) def get_result(obj): + """Results are stored on the nodes in the workflow at run time. This + function can be used to get at a result of a node in a workflow after + run time. This is not a recommended way of getting at results, but can + help with debugging.""" root = obj._workflow.root return obj._workflow.nodes[root].result From d3de84e99c322894362859b68c1794bf43f2ddf2 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Tue, 29 Nov 2016 16:39:05 +0100 Subject: [PATCH 065/155] add `log_level` option to XenonKeeper --- noodles/run/xenon/xenon.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/noodles/run/xenon/xenon.py b/noodles/run/xenon/xenon.py index c429e45..2c5da77 100644 --- a/noodles/run/xenon/xenon.py +++ b/noodles/run/xenon/xenon.py @@ -184,9 +184,9 @@ def interactive(self): class XenonKeeper: is_initialized = False - def __init__(self): + def __init__(self, log_level='ERROR'): if not XenonKeeper.is_initialized: - xenon.init(log_level='ERROR') # noqa + xenon.init(log_level=log_level) # noqa XenonKeeper.is_initialized = True self._x = xenon.Xenon() From 454f3ca8df31236258870bf5a929b6ae5be48365 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Tue, 29 Nov 2016 17:58:19 +0100 Subject: [PATCH 066/155] enable the `queue` option in RemoteJobConfig in Xenon --- noodles/run/xenon/dynamic_pool.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/noodles/run/xenon/dynamic_pool.py b/noodles/run/xenon/dynamic_pool.py index e887d6c..7384c12 100644 --- a/noodles/run/xenon/dynamic_pool.py +++ b/noodles/run/xenon/dynamic_pool.py @@ -32,7 +32,8 @@ def xenon_interactive_worker(XeS: XenonScheduler, job_config): Job configuration. Specifies the command to be run remotely. """ cmd = job_config.command_line() - J = XeS.submit(cmd, interactive=True) + queue = job_config.queue + J = XeS.submit(cmd, interactive=True, queue=queue) def read_stderr(): jpype.attachThreadToJVM() From 6a4aede0a02fe3839e4544fea52ed650e02f94b9 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Thu, 2 Feb 2017 16:59:37 +0100 Subject: [PATCH 067/155] moved to pytest, worked on integration test setup --- .travis.yml | 2 +- integration/remote-docker/Dockerfile | 45 +++++ .../remote-docker}/README.rst | 0 integration/remote-docker/docker-compose.yml | 9 + integration/remote-docker/etc/slurm.cert | 6 + integration/remote-docker/etc/slurm.conf | 165 ++++++++++++++++++ integration/remote-docker/etc/slurm.key | 15 ++ .../remote-docker}/id_rsa | 0 .../remote-docker}/id_rsa.pub | 0 integration/remote-docker/munge.key | Bin 0 -> 1024 bytes integration/remote-docker/service/munged/run | 2 + .../remote-docker/service/slurmctld/run | 2 + .../remote-docker/service/slurmd-node-0/run | 2 + .../remote-docker/service/slurmd-node-1/run | 2 + .../remote-docker/service/slurmd-node-2/run | 2 + .../remote-docker/service/slurmd-node-3/run | 2 + .../remote-docker/service/slurmd-node-4/run | 2 + .../slurm-wlm-configurator.easy.html | 0 .../remote-docker}/slurm.conf | 0 .../remote-docker}/start.sh | 0 .../remote-docker}/welcome.txt | 0 remote-docker/Dockerfile | 34 ---- setup.py | 2 +- test/test_class_decorator.py | 12 +- test/test_exceptions.py | 14 +- test/test_iterator.py | 14 +- test/test_merge_workflow.py | 14 +- test/test_numpy.py | 31 ++-- test/test_prov.py | 143 ++++++++------- test/test_storable.py | 18 +- 30 files changed, 373 insertions(+), 165 deletions(-) create mode 100644 integration/remote-docker/Dockerfile rename {remote-docker => integration/remote-docker}/README.rst (100%) create mode 100644 integration/remote-docker/docker-compose.yml create mode 100644 integration/remote-docker/etc/slurm.cert create mode 100644 integration/remote-docker/etc/slurm.conf create mode 100644 integration/remote-docker/etc/slurm.key rename {remote-docker => integration/remote-docker}/id_rsa (100%) rename {remote-docker => integration/remote-docker}/id_rsa.pub (100%) create mode 100644 integration/remote-docker/munge.key create mode 100755 integration/remote-docker/service/munged/run create mode 100755 integration/remote-docker/service/slurmctld/run create mode 100755 integration/remote-docker/service/slurmd-node-0/run create mode 100755 integration/remote-docker/service/slurmd-node-1/run create mode 100755 integration/remote-docker/service/slurmd-node-2/run create mode 100755 integration/remote-docker/service/slurmd-node-3/run create mode 100755 integration/remote-docker/service/slurmd-node-4/run rename {remote-docker => integration/remote-docker}/slurm-wlm-configurator.easy.html (100%) rename {remote-docker => integration/remote-docker}/slurm.conf (100%) rename {remote-docker => integration/remote-docker}/start.sh (100%) rename {remote-docker => integration/remote-docker}/welcome.txt (100%) delete mode 100644 remote-docker/Dockerfile diff --git a/.travis.yml b/.travis.yml index c6e9c56..0069cf0 100644 --- a/.travis.yml +++ b/.travis.yml @@ -6,7 +6,7 @@ install: - pip install -U codacy-coverage - pip install -U .[prov,numpy,test] script: - - nosetests test --with-coverage --cover-xml --cover-package=noodles + - pytest test after-script: - coverage report - coverage xml diff --git a/integration/remote-docker/Dockerfile b/integration/remote-docker/Dockerfile new file mode 100644 index 0000000..27f6d6d --- /dev/null +++ b/integration/remote-docker/Dockerfile @@ -0,0 +1,45 @@ +FROM phusion/baseimage:0.9.19 +MAINTAINER Johan Hidding + +RUN rm -f /etc/service/sshd/down +RUN /etc/my_init.d/00_regen_ssh_host_keys.sh + +RUN apt-get update \ + && apt-get install -y --no-install-recommends git python3.5 python3-numpy \ + python3-scipy ca-certificates python3-setuptools \ + slurmd slurm-client slurm-wlm +# && apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/* +RUN apt-get install -y python3-pip +RUN pip3 install noodles + +EXPOSE 22 + +RUN useradd -ms /bin/bash -p $(openssl passwd sixpack) joe + +USER joe +RUN mkdir /home/joe/.ssh +ADD id_rsa.pub /home/joe/.ssh/authorized_keys + +USER root + +ADD munge.key /etc/munge/munge.key +ADD service /etc/service +# Key was generated with openssl genrsa -out slurm.key 1024 && openssl rsa -in slurm.key -pubout -out slurm.cert +ADD etc /etc/slurm-llnl + +RUN mkdir /var/run/munge \ + && mkdir -p /var/spool/slurmctld/state \ + && mkdir -p /var/spool/slurmd.node-0 \ + && mkdir -p /var/spool/slurmd.node-1 \ + && mkdir -p /var/spool/slurmd.node-2 \ + && mkdir -p /var/spool/slurmd.node-3 \ + && mkdir -p /var/spool/slurmd.node-4 \ + && chmod 600 /etc/munge/munge.key \ + && chown root.root /var/lib/munge /etc/munge \ + && touch /var/spool/slurmctld/accounting.txt \ + && chown slurm /var/spool/slurmctld/accounting.txt \ + && chown slurm /var/spool/slurmctld/state \ + && chown slurm /etc/slurm-llnl/slurm.key + +ADD welcome.txt /etc/motd +CMD ["/sbin/my_init"] diff --git a/remote-docker/README.rst b/integration/remote-docker/README.rst similarity index 100% rename from remote-docker/README.rst rename to integration/remote-docker/README.rst diff --git a/integration/remote-docker/docker-compose.yml b/integration/remote-docker/docker-compose.yml new file mode 100644 index 0000000..e0c6123 --- /dev/null +++ b/integration/remote-docker/docker-compose.yml @@ -0,0 +1,9 @@ +mysql: + image: mysql:5.5 + environment: + - MYSQL_ROOT_PASSWORD=xenon-slurm-pw +xenon-slurm: + image: nlesc/xenon-slurm + links: + - mysql + diff --git a/integration/remote-docker/etc/slurm.cert b/integration/remote-docker/etc/slurm.cert new file mode 100644 index 0000000..b051645 --- /dev/null +++ b/integration/remote-docker/etc/slurm.cert @@ -0,0 +1,6 @@ +-----BEGIN PUBLIC KEY----- +MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDCVGH1xuDtfulsZzGnpM++31vZ +xgnbkn8QwJfTeBvYWpud9yCz8YoRcXADlzFLo8Dqujq8Rpnwp5Sz2YGweIQakEqb +2M2oaCYbjHm/QdQftHthIjffW2y+FjJd4hHmkKr73t/tiHbrODsWQAOnxwWnqJuA +6z8xbz+zo40MMXhPgQIDAQAB +-----END PUBLIC KEY----- diff --git a/integration/remote-docker/etc/slurm.conf b/integration/remote-docker/etc/slurm.conf new file mode 100644 index 0000000..db5ab40 --- /dev/null +++ b/integration/remote-docker/etc/slurm.conf @@ -0,0 +1,165 @@ +# slurm.conf file generated by configurator.html. +# Put this file on all nodes of your cluster. +# See the slurm.conf man page for more information. +# +ControlMachine=localhost +#ControlAddr= +#BackupController= +#BackupAddr= +# +AuthType=auth/munge +CacheGroups=0 +#CheckpointType=checkpoint/none +CryptoType=crypto/openssl +JobCredentialPrivateKey=/etc/slurm-llnl/slurm.key +JobCredentialPublicCertificate=/etc/slurm-llnl/slurm.cert +#DisableRootJobs=NO +#EnforcePartLimits=NO +#Epilog= +#EpilogSlurmctld= +#FirstJobId=1 +#MaxJobId=999999 +#GresTypes= +#GroupUpdateForce=0 +GroupUpdateTime=2 +#JobCheckpointDir=/var/slurm/checkpoint +#JobCredentialPrivateKey= +#JobCredentialPublicCertificate= +#JobFileAppend=0 +#JobRequeue=1 +#JobSubmitPlugins=1 +#KillOnBadExit=0 +#Licenses=foo*4,bar +#MailProg=/bin/mail +#MaxJobCount=5000 +#MaxStepCount=40000 +#MaxTasksPerNode=128 +MpiDefault=none +#MpiParams=ports=#-# +#PluginDir= +#PlugStackConfig= +#PrivateData=jobs +ProctrackType=proctrack/pgid +#Prolog= +#PrologSlurmctld= +#PropagatePrioProcess=0 +#PropagateResourceLimits= +#PropagateResourceLimitsExcept= +ReturnToService=1 +#SallocDefaultCommand= +#SlurmctldPidFile=/var/run/slurmctld.pid +SlurmctldPort=6817 +SlurmdPidFile=/var/run/slurmd.%n.pid +SlurmdPort=6818 +SlurmdSpoolDir=/var/spool/slurmd.%n +SlurmUser=slurm +#SlurmdUser=root +#SrunEpilog= +#SrunProlog= +StateSaveLocation=/var/spool/slurmctld/state +SwitchType=switch/none +#TaskEpilog= +TaskPlugin=task/none +#TaskPluginParam= +#TaskProlog= +#TopologyPlugin=topology/tree +#TmpFs=/tmp +#TrackWCKey=no +#TreeWidth= +#UnkillableStepProgram= +#UsePAM=0 +# +# +# TIMERS +BatchStartTimeout=2 +#CompleteWait=0 +EpilogMsgTime=1 +#GetEnvTimeout=2 +#HealthCheckInterval=0 +#HealthCheckProgram= +InactiveLimit=0 +KillWait=2 +MessageTimeout=2 +#ResvOverRun=0 +MinJobAge=2 +#OverTimeLimit=0 +SlurmctldTimeout=2 +SlurmdTimeout=2 +#UnkillableStepTimeout=60 +#VSizeFactor=0 +Waittime=0 +# +# +# SCHEDULING +#DefMemPerCPU=0 +FastSchedule=1 +#MaxMemPerCPU=0 +#SchedulerRootFilter=1 +SchedulerTimeSlice=5 +SchedulerType=sched/backfill +SchedulerPort=7321 +SelectType=select/linear +#SelectTypeParameters= +# +# +# JOB PRIORITY +#PriorityType=priority/basic +#PriorityDecayHalfLife= +#PriorityCalcPeriod= +#PriorityFavorSmall= +#PriorityMaxAge= +#PriorityUsageResetPeriod= +#PriorityWeightAge= +#PriorityWeightFairshare= +#PriorityWeightJobSize= +#PriorityWeightPartition= +#PriorityWeightQOS= +# +# +# LOGGING AND ACCOUNTING +#AccountingStorageEnforce=0 +AccountingStorageHost=mysql +AccountingStorageLoc=slurm_acct_db +AccountingStoragePass=xenon-slurm-pw +#AccountingStoragePort= +AccountingStorageType=accounting_storage/mysql +AccountingStorageUser=root +AccountingStoreJobComment=YES +ClusterName=cluster +#DebugFlags= +JobCompHost=mysql +JobCompLoc=slurm_acct_db +JobCompPass=xenon-slurm-pw +#JobCompPort= +JobCompType=jobcomp/mysql +JobCompUser=root +JobAcctGatherFrequency=2 +JobAcctGatherType=jobacct_gather/linux +SlurmctldDebug=3 +#SlurmctldLogFile= +SlurmdDebug=3 +SlurmdLogFile=/var/log/slurm-llnl/slurmd.%n.log +#SlurmSchedLogFile= +#SlurmSchedLogLevel= +# +# +# POWER SAVE SUPPORT FOR IDLE NODES (optional) +#SuspendProgram= +#ResumeProgram= +#SuspendTimeout= +#ResumeTimeout= +#ResumeRate= +#SuspendExcNodes= +#SuspendExcParts= +#SuspendRate= +#SuspendTime= +# +# +# COMPUTE NODES +NodeName=node-0 Procs=2 NodeAddr=127.0.0.1 Port=17001 State=UNKNOWN +NodeName=node-1 Procs=2 NodeAddr=127.0.0.1 Port=17002 State=UNKNOWN +NodeName=node-2 Procs=2 NodeAddr=127.0.0.1 Port=17003 State=UNKNOWN +NodeName=node-3 Procs=2 NodeAddr=127.0.0.1 Port=17004 State=UNKNOWN +NodeName=node-4 Procs=2 NodeAddr=127.0.0.1 Port=17005 State=UNKNOWN +PartitionName=mypartition Nodes=node-[0-4] Default=YES MaxTime=INFINITE State=UP +PartitionName=otherpartition Nodes=node-[0-2] Default=NO MaxTime=INFINITE State=UP diff --git a/integration/remote-docker/etc/slurm.key b/integration/remote-docker/etc/slurm.key new file mode 100644 index 0000000..e7960cb --- /dev/null +++ b/integration/remote-docker/etc/slurm.key @@ -0,0 +1,15 @@ +-----BEGIN RSA PRIVATE KEY----- +MIICWwIBAAKBgQDCVGH1xuDtfulsZzGnpM++31vZxgnbkn8QwJfTeBvYWpud9yCz +8YoRcXADlzFLo8Dqujq8Rpnwp5Sz2YGweIQakEqb2M2oaCYbjHm/QdQftHthIjff +W2y+FjJd4hHmkKr73t/tiHbrODsWQAOnxwWnqJuA6z8xbz+zo40MMXhPgQIDAQAB +AoGAC0wgjctMFEKGi3jMWDSqpywRCO4McKlpna20peSbqc5KsbpGOm/WWQFBQ9Qs +V3tjocHF3GA2Xtk/Od1xPrMi6tY/q2OMkn9Den51kJpnBRRVIfipBj+IMCt9yhYP +KX2U/kqktwIH5TNduFd6bvYidz9nwBNqEEq3UGDfSPZr+4kCQQD/qNzRuhKX0Vf7 +Ww/sPkgBGwwvzF6gCf6y9MVqnRfq9Vd49kDZf6X1elACbzOO/MunmJI/m7qmYQs1 +Tfd3SbRPAkEAwpad4zLktS/1j8Wm3tDfIqGfI/C//TRFY6WAjnx/T6v5nxeoMt6Y +flt4FVjkhmsikFTOeYEU5rq0Pm25GP47LwJAFe5wcvVZXviwaXmYVhXJq36cfwUz +INt6o/NndAvh32AIjvHhAkd2/yXs8yiC7cM13TyzXw2G53rvsTTtA6io9QJAWUv7 +OrcxQ4C1xPukP15E98SJnlmuEUl6imb53ul9FxfJntuhYW7LNjlNmyZHAPSLUQbK +FfJJoDSP4JJDvhd1GwJAFgYozOFcKZGB5KnnL5B0JLVgCFYNzXuIHPNqwN6OsmKM ++7DGM1GAAfYLwTkU0F3fgNZx2ZCTRmmbMBRRMPC9qg== +-----END RSA PRIVATE KEY----- diff --git a/remote-docker/id_rsa b/integration/remote-docker/id_rsa similarity index 100% rename from remote-docker/id_rsa rename to integration/remote-docker/id_rsa diff --git a/remote-docker/id_rsa.pub b/integration/remote-docker/id_rsa.pub similarity index 100% rename from remote-docker/id_rsa.pub rename to integration/remote-docker/id_rsa.pub diff --git a/integration/remote-docker/munge.key b/integration/remote-docker/munge.key new file mode 100644 index 0000000000000000000000000000000000000000..4c22ae5e508c0f00ce2d6ce30abba5a94e032521 GIT binary patch literal 1024 zcmV+b1poUHiFdVd>B=GK**LnA2FAKogNz32;c@K&uBQ&>gw`)=ZRKXLMlMq4#;-RN>nc-0AR~{}geBR=A zRV!;4>8;)<%|B0T^`Y0b6@B)q;X#6>&mXKkm}IT})3UjV1ri;Sdz*uKdEU5LKcve7 zzxT7Sd$IIbkB@wzb`amo?GTIY?-88dk~1$AwC4e;6Mr^SJz_)B>jJbmiyNg%(^l6KEE1yYYS{p8DQ5mlI$SSNLIs^X=T4CyoZdfG1y z4!FTOaaZ?;nYM$7bw!3tQ+EN6#2% zWHJu^qxAn1;EjY*j17AzF9Vo0L|%~UX10Xr09{VXKfqLVDyz|Dx!pT zfn*!`?6pg-+Qn$+8+b(pUtUci`${U8_9ycOTASrw>{9p6g%O;S4%tzO<>sZlZUy_~sDw0JOs46l_a;kI)wEi-H(S1DL*!CI$o?GM5FGSA3lqHJJy1QSDO z@Ta?AGK6H&0g@19WZN9@_(Zh)A9qIMR#@qG_W{gC4(7y+hRxMn9jKo9MP+Ow0zoHc z(CGrD7+d3eKhM5gl1D>;{|+5XF*sk8vZX!|c0_@MblRqGzR}vN@2I?A z>G#ofg6c%;3m}3AyIhJzW`16mVay4CMNWCcJHDN9+wrbs>RY%AYTQz6(}Eg&zhVAv z&PJ^^120%02T?q}VZFh|_pn)0 zPrcC0Tf|`H0b4>*9H1*crv3$R_Ij0j*4YqTP7n?yEf`$A{`!Ay*ACD$5IDdszR6Om z$xcrT%M2h+&b;rHvb6Lxm0a&ZQM%ZNaF!VsX)t8SybMA7DtCHc(W#pL;(Z7> - -RUN apt-get update && \ - apt-get install -y --no-install-recommends git python3.5 python3-numpy \ - python3-scipy ca-certificates python3-setuptools openssh-server \ - openssh-sftp-server slurmd slurm-client slurm-wlm - -RUN cd /tmp && \ - git clone https://github.com/NLeSC/noodles.git && \ - cd noodles && \ - git checkout devel && \ - python3.5 setup.py install - -EXPOSE 22 - -RUN mkdir /var/run/sshd - -RUN useradd -ms /bin/bash -p $(openssl passwd sixpack) joe - -USER joe -RUN mkdir /home/joe/.ssh -ADD id_rsa.pub /home/joe/.ssh/authorized_keys - -USER root - -ADD slurm.conf /etc/slurm-llnl -RUN mkdir /var/run/slurm-llnl - -ADD welcome.txt /etc/motd -ADD start.sh /usr/bin -RUN chmod +x /usr/bin/start.sh - -CMD ["/usr/bin/start.sh"] diff --git a/setup.py b/setup.py index 95eba68..bc71e3e 100755 --- a/setup.py +++ b/setup.py @@ -37,6 +37,6 @@ 'prov': ['tinydb', 'ujson'], 'xenon': ['pyxenon'], 'numpy': ['numpy', 'h5py', 'msgpack-python', 'filelock'], - 'test': ['nose', 'coverage', 'pyflakes', 'pep8', 'docker-py'] + 'test': ['pytest', 'coverage', 'pyflakes', 'pep8', 'docker-py'] }, ) diff --git a/test/test_class_decorator.py b/test/test_class_decorator.py index b3673a9..ddbc6db 100644 --- a/test/test_class_decorator.py +++ b/test/test_class_decorator.py @@ -1,6 +1,6 @@ from noodles import schedule, run_single, unwrap, run_process, Storable from noodles import serial -from nose.tools import raises +from pytest import raises @schedule @@ -119,9 +119,9 @@ def test_unwrap(): assert f == unwrap(f) -@raises(AttributeError) def test_class_decorator2(): - a = make_object(A, 6).multiply(7) - b = a.divide(0) - result = run_single(b) - print(dir(result)) + with raises(AttributeError): + a = make_object(A, 6).multiply(7) + b = a.divide(0) + result = run_single(b) + print(dir(result)) diff --git a/test/test_exceptions.py b/test/test_exceptions.py index 1b8d233..4d588bc 100644 --- a/test/test_exceptions.py +++ b/test/test_exceptions.py @@ -1,4 +1,4 @@ -from nose.tools import raises +from pytest import raises from noodles import (schedule, schedule_hint, run_single) @@ -12,10 +12,10 @@ def raises_my_exception(): raise MyException("Error!") -@raises(MyException) def test_exception_00(): - wf = raises_my_exception() - run_single(wf) + with raises(MyException): + wf = raises_my_exception() + run_single(wf) @schedule_hint(annotated=True) @@ -23,7 +23,7 @@ def not_really_annotated(): return 0 -@raises(TypeError) def test_exception_01(): - wf = not_really_annotated() - run_single(wf) + with raises(TypeError): + wf = not_really_annotated() + run_single(wf) diff --git a/test/test_iterator.py b/test/test_iterator.py index c77141d..d2ec259 100644 --- a/test/test_iterator.py +++ b/test/test_iterator.py @@ -1,12 +1,12 @@ import noodles -import nose +from pytest import raises -@nose.tools.raises(TypeError) def test_iterate(): - a = noodles.delay((1,2,3)) - b, c, d = a - e = noodles.gather(d, c, b) + with raises(TypeError): + a = noodles.delay((1, 2, 3)) + b, c, d = a + e = noodles.gather(d, c, b) - result = noodles.run_single(e) - assert result == (3, 2, 1) + result = noodles.run_single(e) + assert result == (3, 2, 1) diff --git a/test/test_merge_workflow.py b/test/test_merge_workflow.py index d562b38..352fc25 100644 --- a/test/test_merge_workflow.py +++ b/test/test_merge_workflow.py @@ -1,4 +1,4 @@ -from nose.tools import raises +from pytest import raises from noodles.workflow import ( Empty, ArgumentAddress, ArgumentKind, is_workflow, get_workflow, Workflow) @@ -113,14 +113,14 @@ def test_arg_by_ref(): assert result.y.x == 5 -@raises(TypeError) def test_hidden_promise(): - a = Normal() - b = Scheduled() - c = Scheduled() + with raises(TypeError): + a = Normal() + b = Scheduled() + c = Scheduled() - a.x = b - c.x = a + a.x = b + c.x = a def test_tuple_unpack(): diff --git a/test/test_numpy.py b/test/test_numpy.py index fdd9ad9..a2d766f 100644 --- a/test/test_numpy.py +++ b/test/test_numpy.py @@ -1,20 +1,18 @@ -from nose.plugins.skip import SkipTest +import pytest try: import numpy as np from numpy import (random, fft, exp) - from noodles.serial.numpy import arrays_to_hdf5 - from noodles.run.xenon import (XenonConfig, RemoteJobConfig, XenonKeeper) + + from noodles.run.run_with_prov import ( + run_parallel_opt) except ImportError: - raise SkipTest("No NumPy or Xenon installed.") + has_numpy = False else: - try: - from noodles.run.xenon import run_xenon_prov as run_xenon - except ImportError: - from noodles.run.xenon import run_xenon + has_numpy = True from noodles.display import (NCDisplay) from noodles import schedule, serial, schedule_hint @@ -51,23 +49,14 @@ def make_noise(n, seed=0): def run(wf): - xenon_config = XenonConfig( - jobs_scheme='local' - ) - - job_config = RemoteJobConfig( - registry=registry, - time_out=1000 - ) - - with XenonKeeper() as Xe, NCDisplay() as display: - result = run_xenon( - wf, Xe, "cache.json", 2, xenon_config, job_config, - display=display, deref=True) + with NCDisplay() as display: + result = run_parallel_opt( + wf, 2, registry, "cache.json", display=display) return result +@pytest.mark.skipif(not has_numpy, reason="NumPy needed.") def test_hdf5(): x = make_noise(256) k = make_kernel(256, 10) diff --git a/test/test_prov.py b/test/test_prov.py index bcd2779..cef1111 100644 --- a/test/test_prov.py +++ b/test/test_prov.py @@ -1,11 +1,13 @@ -from nose.plugins.skip import SkipTest +import pytest try: from noodles.prov import prov_key from noodles.run.run_with_prov import ( run_single, run_parallel, run_parallel_opt) -except ImportError as e: - raise SkipTest(str(e)) +except ImportError: + has_prov = False +else: + has_prov = True from noodles import serial, gather, schedule_hint from noodles.tutorial import (add, mul, sub, accumulate) @@ -16,96 +18,93 @@ import os -def test_prov_00(): - reg = serial.base() - a = add(3, 4) - b = sub(3, 4) - c = add(3, 4) - d = add(4, 3) - - enc = [reg.deep_encode(x._workflow.root_node) for x in [a, b, c, d]] - key = [prov_key(o) for o in enc] - assert key[0] == key[2] - assert key[1] != key[0] - assert key[3] != key[0] - - -def test_prov_01(): - reg = serial.base() - a = add(3, 4) - - enc = reg.deep_encode(a._workflow.root_node) - dec = reg.deep_decode(enc) - - result = run_job(0, dec) - assert result.value == 7 +@schedule_hint(store=True) +def add2(x, y): + return x + y -def test_prov_02(): - db_file = "prov1.json" +@schedule_hint(store=True) +def fib(n): + if n < 2: + return 1 + else: + return add(fib(n - 1), fib(n - 2)) - A = add(1, 1) - B = sub(3, A) - multiples = [mul(add(i, B), A) for i in range(6)] - C = accumulate(gather(*multiples)) +@pytest.mark.skipif(not has_prov, reason="TinyDB needed") +class TestProv: + def test_prov_00(self): + reg = serial.base() + a = add(3, 4) + b = sub(3, 4) + c = add(3, 4) + d = add(4, 3) - result = run_single(C, serial.base, db_file) - assert result == 42 - os.unlink(db_file) + enc = [reg.deep_encode(x._workflow.root_node) for x in [a, b, c, d]] + key = [prov_key(o) for o in enc] + assert key[0] == key[2] + assert key[1] != key[0] + assert key[3] != key[0] + def test_prov_01(self): + reg = serial.base() + a = add(3, 4) -def test_prov_03(): - db_file = "prov2.json" + enc = reg.deep_encode(a._workflow.root_node) + dec = reg.deep_decode(enc) - A = add(1, 1) - B = sub(3, A) + result = run_job(0, dec) + assert result.value == 7 - multiples = [mul(add(i, B), A) for i in range(6)] - C = accumulate(gather(*multiples)) + def test_prov_02(self): + db_file = "prov1.json" - result = run_parallel(C, 4, serial.base, db_file, JobKeeper(keep=True)) - assert result == 42 - os.unlink(db_file) + A = add(1, 1) + B = sub(3, A) + multiples = [mul(add(i, B), A) for i in range(6)] + C = accumulate(gather(*multiples)) -@schedule_hint(store=True) -def add2(x, y): - return x + y + result = run_single(C, serial.base, db_file) + assert result == 42 + os.unlink(db_file) + def test_prov_03(self): + db_file = "prov2.json" -def test_prov_04(): - db_file = "prov3.json" + A = add(1, 1) + B = sub(3, A) - A = add2(1, 1) - B = sub(3, A) + multiples = [mul(add(i, B), A) for i in range(6)] + C = accumulate(gather(*multiples)) - multiples = [mul(add2(i, B), A) for i in range(6)] - C = accumulate(gather(*multiples)) + result = run_parallel(C, 4, serial.base, db_file, JobKeeper(keep=True)) + assert result == 42 + os.unlink(db_file) - result = run_parallel_opt(C, 4, serial.base, db_file) - assert result == 42 - os.unlink(db_file) + def test_prov_04(self): + db_file = "prov3.json" + A = add2(1, 1) + B = sub(3, A) -@schedule_hint(store=True) -def fib(n): - if n < 2: - return 1 - else: - return add(fib(n - 1), fib(n - 2)) + multiples = [mul(add2(i, B), A) for i in range(6)] + C = accumulate(gather(*multiples)) + result = run_parallel_opt(C, 4, serial.base, db_file) + assert result == 42 + os.unlink(db_file) -def test_prov_05(): - import time - db_file = "testjobs.json" + def test_prov_05(self): + import time + db_file = "testjobs.json" - wf = fib(20) - start = time.time() - result = run_parallel(wf, 4, serial.base, db_file) - end = time.time() + wf = fib(20) + start = time.time() + result = run_parallel(wf, 4, serial.base, db_file) + end = time.time() - assert (end - start) < 5.0 # weak test - assert result == 10946 + assert (end - start) < 5.0 # weak test + assert result == 10946 - os.unlink(db_file) + os.unlink(db_file) diff --git a/test/test_storable.py b/test/test_storable.py index ccf0b06..c47930e 100644 --- a/test/test_storable.py +++ b/test/test_storable.py @@ -1,6 +1,6 @@ from noodles import schedule, run_single, run_process, serial, lift from noodles.storable import Storable -from nose.tools import raises +from pytest import raises class A(Storable): @@ -44,14 +44,14 @@ def test_storable(): assert result.x == 7 -@raises(TypeError) def test_nonstorable(): - a = A() - b = M() + with raises(TypeError): + a = A() + b = M() - a.x = 1 - b.x = f(3, 4) + a.x = 1 + b.x = f(3, 4) - zzc = g(a, b) - result = run_single(c) - assert result == 8 + c = g(a, b) + result = run_single(c) + assert result == 8 From e9d0ebf686e56cff3a5506d0bbef625942da45f9 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Wed, 22 Feb 2017 10:28:34 +0100 Subject: [PATCH 068/155] another nose job --- test/test_run/test_remote_io.py | 27 ++++++++++++--------------- test/test_run/test_xenon_local.py | 6 ++++-- 2 files changed, 16 insertions(+), 17 deletions(-) diff --git a/test/test_run/test_remote_io.py b/test/test_run/test_remote_io.py index e1e02de..f437562 100644 --- a/test/test_run/test_remote_io.py +++ b/test/test_run/test_remote_io.py @@ -1,4 +1,4 @@ -from nose.plugins.skip import SkipTest +import pytest import io from noodles.run.remote.io import ( @@ -8,44 +8,41 @@ import math try: - import msgpack + import msgpack # noqa has_msgpack = True except ImportError: has_msgpack = False -objects = ["Hello", 42, [3, 4], (5, 6), {"hello": "world"}, +objects = ["Hello", 42, [3, 4], (5, 6), {"hello": "world"}, math.tan, object] - + +@pytest.mark.skipif(not has_msgpack, reason="No MsgPack installed.") def test_msgpack(): - if not has_msgpack: - raise SkipTest("No MsgPack installed.") - f = io.BytesIO() output_stream = MsgPackObjectWriter(registry(), f) - + for obj in objects: output_stream.send(obj) f.seek(0) input_stream = MsgPackObjectReader(registry(), f) - + new_objects = list(input_stream) assert new_objects == objects - -def test_json(): + +def test_json(): f = io.StringIO() output_stream = JSONObjectWriter(registry(), f) - + for obj in objects: output_stream.send(obj) f.seek(0) input_stream = JSONObjectReader(registry(), f) - + new_objects = list(input_stream) - - assert new_objects == objects + assert new_objects == objects diff --git a/test/test_run/test_xenon_local.py b/test/test_run/test_xenon_local.py index 4e47a45..f47836a 100644 --- a/test/test_run/test_xenon_local.py +++ b/test/test_run/test_xenon_local.py @@ -1,11 +1,12 @@ -from nose.plugins.skip import SkipTest +import pytest try: # Only test xenon if it is installed from noodles.run.xenon import (XenonConfig, RemoteJobConfig, XenonKeeper) except ImportError as e: - raise SkipTest(str(e)) + has_xenon = False else: + has_xenon = True # Only test run_xenon_prov if provenance is installed, otherwise run_xenon try: from noodles.run.xenon import run_xenon_prov as run_xenon @@ -18,6 +19,7 @@ from noodles.tutorial import (log_add, mul, sub, accumulate) +@pytest.mark.skipif(not has_xenon, reason="No (py)xenon installed.") def test_xenon_42(): A = log_add(1, 1) B = sub(3, A) From e769c6e1b04c50f18cf4172f4c507a2606471910 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Wed, 22 Feb 2017 10:32:44 +0100 Subject: [PATCH 069/155] experiment with docker-compose, integration test with slurm-docker still not functioning --- integration/remote-docker/docker-compose.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/integration/remote-docker/docker-compose.yml b/integration/remote-docker/docker-compose.yml index e0c6123..52d5a1a 100644 --- a/integration/remote-docker/docker-compose.yml +++ b/integration/remote-docker/docker-compose.yml @@ -2,7 +2,7 @@ mysql: image: mysql:5.5 environment: - MYSQL_ROOT_PASSWORD=xenon-slurm-pw -xenon-slurm: +noodles-remote: image: nlesc/xenon-slurm links: - mysql From 508f3dea28e870c09202fffec81af4cf4b0ec749 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Wed, 22 Feb 2017 10:55:31 +0100 Subject: [PATCH 070/155] update setup.py and .travis.yml to work with pytest and pytest-cov --- .travis.yml | 2 +- setup.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.travis.yml b/.travis.yml index 0069cf0..eb190d9 100644 --- a/.travis.yml +++ b/.travis.yml @@ -6,7 +6,7 @@ install: - pip install -U codacy-coverage - pip install -U .[prov,numpy,test] script: - - pytest test + - pytest test --cov after-script: - coverage report - coverage xml diff --git a/setup.py b/setup.py index bc71e3e..52c4caf 100755 --- a/setup.py +++ b/setup.py @@ -37,6 +37,6 @@ 'prov': ['tinydb', 'ujson'], 'xenon': ['pyxenon'], 'numpy': ['numpy', 'h5py', 'msgpack-python', 'filelock'], - 'test': ['pytest', 'coverage', 'pyflakes', 'pep8', 'docker-py'] + 'test': ['pytest', 'pytest-cov', 'codacy-coverage', 'pyflakes', 'pep8', 'docker-py'] }, ) From ed74f33f23eabef328e8afca9cdb5528c0b586bc Mon Sep 17 00:00:00 2001 From: Arnold Kuzniar Date: Fri, 21 Apr 2017 22:04:14 +0200 Subject: [PATCH 071/155] Fix 2nd example & update text in the intro --- doc/source/eating.rst | 17 +++++++---------- 1 file changed, 7 insertions(+), 10 deletions(-) diff --git a/doc/source/eating.rst b/doc/source/eating.rst index 5a17aab..c73f6e4 100644 --- a/doc/source/eating.rst +++ b/doc/source/eating.rst @@ -1,19 +1,16 @@ .. highlight:: python :linenothreshold: 5 -Eating of Noodles (user docs) -============================= +Eating noodles (user docs) +========================== -The purpose of Noodles is to make it easy to design *computational workflows* straight from Python. -Noodles is meant to be used by scientists that want to do heavy number crunching, and need a way to organise these computations in a readable and sustainable manner. -These workflows are usually associated with a *directed acyclic graph* (DAG, or just: graph). -Each computation in the workflow is a represented as a node in the graph and may have several dependencies. -These dependencies are the arrows; or if you think in reverse, the arrows show transport of data. +The primary goal of the *noodles* library is to ease the construction and execution of *computational workflows* using the Python language. This library is meant for scientists who want to perform complex compute-intensive tasks on parallel/distributed infrastructures in a readable, scalable and sustainable/reproducible? manner. +A workflow is commonly modelled as a *directed acyclic graph* (DAG or simply graph) in which the computations are represented as nodes whereas the dependencies between them are represented as directed edges (indicating data transport). A first example --------------- -Let's look at a small example creating a diamond workflow. All the examples in this documentation do some silly arithmetic. In practice these functions would do quite a bit heavier lifting. +Let's look at a small example of creating a diamond workflow, which consists of simple (arithmetic) functions: :: @@ -108,9 +105,9 @@ Using the Noodles approach it becomes very easy to paralellise computations. Let w = [my_func(i, v, u) for i in range(6)] x = accumulate(gather(*w)) - answer = run_parallel(r5, n_threads=4) + answer = run_parallel(x, n_threads=4) - print("The answer is ${0}, again.".format(answer)) + print("The answer is {0}, again.".format(answer)) This time the workflow graph will look a bit more complicated. From 24fbfc0a1e8e383d4e0c6ccae81255c198e07940 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Tue, 16 May 2017 15:18:43 +0200 Subject: [PATCH 072/155] dumb-term display made very explicit --- examples/example2.py | 14 +++++---- noodles/display/dumb_term.py | 56 ++++++++++++++++++++++++------------ 2 files changed, 47 insertions(+), 23 deletions(-) diff --git a/examples/example2.py b/examples/example2.py index 7cd26de..b57c79f 100644 --- a/examples/example2.py +++ b/examples/example2.py @@ -1,6 +1,6 @@ -from noodles import schedule, gather, run_parallel -from prototype import draw_workflow - +from noodles import schedule, gather, serial +from noodles.run.run_with_prov import run_parallel_opt +from noodles.display import (DumbDisplay) @schedule def add(a, b): @@ -36,7 +36,11 @@ def foo(a, b, c): r5 = my_sum(gather(*multiples)) -draw_workflow("graph-example2.svg", r5) -answer = run_parallel(r5, 4) +# draw_workflow("graph-example2.svg", r5) + +with DumbDisplay() as display: + answer = run_parallel_opt( + r5, 4, serial.base, "cache.json", + display=display, cache_all=True) print("The answer is: {0}".format(answer)) diff --git a/noodles/display/dumb_term.py b/noodles/display/dumb_term.py index 6d8f100..8e6cda5 100644 --- a/noodles/display/dumb_term.py +++ b/noodles/display/dumb_term.py @@ -1,7 +1,25 @@ from .pretty_term import OutStream +from inspect import Parameter import sys +def _format_arg_list(a, v): + if len(a) == 0: + if v: + return "(\u2026)" + else: + return "()" + + s = "({0}{1})" + for i in a[:-1]: + s = s.format(str(i) if i != Parameter.empty else "\u2014", ", {0}{1}") + + if v: + return s.format("\u2026", "") + + return s.format(str(a[-1]) if a[-1] != Parameter.empty else "\u2014", "") + + class DumbDisplay: """Monochrome, dumb term display""" def __init__(self, error_filter=None): @@ -9,34 +27,35 @@ def __init__(self, error_filter=None): self.out = OutStream(sys.stdout) self.errors = [] self.error_filter = error_filter + self.messages = [] - def start(self, key, job, _): + def schedule(self, key, job, _): if job.hints and 'display' in job.hints: - self.add_job(key, job.hints) - self.out << job.hints['display'].format( - **job.bound_args.arguments) << "\n" + msg = job.hints['display'].format(**job.bound_args.arguments) + else: + msg = "{0} {1}".format( + job.foo.__name__, _format_arg_list(job.bound_args.args, None)) - def done(self, key, data, msg): - pass + self.add_job(key, msg) + self.print_message(key, 'schedule') - def error(self, key, _, msg): - pass + def print_message(self, key, msg): + if key in self.jobs: + print("{0} | {1:12} | {2}".format(key, '['+msg.upper()+']', self.jobs[key]['name']), + file=sys.stderr) - def add_job(self, key, hints): - for k in self.jobs: - self.jobs[k]['line'] += 1 - self.jobs[key] = {'line': 1} - self.jobs[key].update(hints) + def add_job(self, key, name): + self.jobs[key] = {'name': name} def error_handler(self, job, xcptn): self.errors.append((job, xcptn)) def report(self): if len(self.errors) == 0: - self.out << "+---(success)\n" + self.out << "[success]\n" else: - self.out << "+---(ERROR!)\n\n" + self.out << "[ERROR!]\n\n" for job, e in self.errors: msg = 'ERROR ' @@ -56,9 +75,10 @@ def report(self): print(e) def __call__(self, key, status, data, err): - # self.q = q - # for status, key, data in q.source(): - getattr(self, status)(key, data, err) + if hasattr(self, status): + getattr(self, status)(key, data, err) + else: + self.print_message(key, status) def __enter__(self): return self From 5e2f9cb639fc083ffff2690103fa6b9341d7a4c6 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Tue, 16 May 2017 15:24:23 +0200 Subject: [PATCH 073/155] very verbose dumb terminal --- examples/example2.py | 9 +++++---- noodles/display/dumb_term.py | 26 ++++++++++++++------------ 2 files changed, 19 insertions(+), 16 deletions(-) diff --git a/examples/example2.py b/examples/example2.py index b57c79f..0074fdb 100644 --- a/examples/example2.py +++ b/examples/example2.py @@ -1,4 +1,4 @@ -from noodles import schedule, gather, serial +from noodles import schedule, gather, serial, run_logging from noodles.run.run_with_prov import run_parallel_opt from noodles.display import (DumbDisplay) @@ -39,8 +39,9 @@ def foo(a, b, c): # draw_workflow("graph-example2.svg", r5) with DumbDisplay() as display: - answer = run_parallel_opt( - r5, 4, serial.base, "cache.json", - display=display, cache_all=True) + answer = run_logging(r5, 4, display) + #answer = run_parallel_opt( + # r5, 4, serial.base, "cache.json", + # display=display, cache_all=True) print("The answer is: {0}".format(answer)) diff --git a/noodles/display/dumb_term.py b/noodles/display/dumb_term.py index 8e6cda5..3c40f49 100644 --- a/noodles/display/dumb_term.py +++ b/noodles/display/dumb_term.py @@ -29,20 +29,11 @@ def __init__(self, error_filter=None): self.error_filter = error_filter self.messages = [] - def schedule(self, key, job, _): - if job.hints and 'display' in job.hints: - msg = job.hints['display'].format(**job.bound_args.arguments) - else: - msg = "{0} {1}".format( - job.foo.__name__, _format_arg_list(job.bound_args.args, None)) - - self.add_job(key, msg) - self.print_message(key, 'schedule') - def print_message(self, key, msg): if key in self.jobs: - print("{0} | {1:12} | {2}".format(key, '['+msg.upper()+']', self.jobs[key]['name']), - file=sys.stderr) + print("{0} | {1:12} | {2}".format( + key, '['+msg.upper()+']', self.jobs[key]['name']), + file=sys.stderr) def add_job(self, key, name): self.jobs[key] = {'name': name} @@ -75,6 +66,17 @@ def report(self): print(e) def __call__(self, key, status, data, err): + if hasattr(data, 'hints'): + job = data + if job.hints and 'display' in job.hints: + msg = job.hints['display'].format(**job.bound_args.arguments) + else: + msg = "{0} {1}".format( + job.foo.__name__, + _format_arg_list(job.bound_args.args, None)) + + self.add_job(key, msg) + if hasattr(self, status): getattr(self, status)(key, data, err) else: From 37ec5e0dac85f4bb27e7aa261c11fe744fbd3a11 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Wed, 17 May 2017 09:18:56 +0200 Subject: [PATCH 074/155] fix .travis.yml --- .travis.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.travis.yml b/.travis.yml index eb190d9..27a9d1f 100644 --- a/.travis.yml +++ b/.travis.yml @@ -4,9 +4,9 @@ python: - "3.5" install: - pip install -U codacy-coverage - - pip install -U .[prov,numpy,test] + - pip install -U .[prov,numpy,test,xenon] script: - - pytest test --cov + - pytest test --cov=./noodles after-script: - coverage report - coverage xml From 3b185ac548b6b30a00f27171871075f6a2e79066 Mon Sep 17 00:00:00 2001 From: Johannes Hidding Date: Wed, 17 May 2017 09:45:36 +0200 Subject: [PATCH 075/155] removed xenon from travis testing --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 27a9d1f..e17e3ba 100644 --- a/.travis.yml +++ b/.travis.yml @@ -4,7 +4,7 @@ python: - "3.5" install: - pip install -U codacy-coverage - - pip install -U .[prov,numpy,test,xenon] + - pip install -U .[prov,numpy,test] script: - pytest test --cov=./noodles after-script: From 9149cdb48acf8555f702f578c687969ba754ee3c Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Mon, 29 May 2017 12:49:18 +0200 Subject: [PATCH 076/155] new function `gather_dict`, which takes kwargs and creates a promise of a dict --- noodles/__init__.py | 4 ++-- noodles/interface/__init__.py | 4 ++-- noodles/interface/functions.py | 6 ++++++ 3 files changed, 10 insertions(+), 4 deletions(-) diff --git a/noodles/__init__.py b/noodles/__init__.py index adabb38..7133a31 100644 --- a/noodles/__init__.py +++ b/noodles/__init__.py @@ -1,7 +1,7 @@ from noodles.interface import ( delay, gather, lift, schedule, schedule_hint, unwrap, has_scheduled_methods, update_hints, unpack, quote, unquote, - find_first) + find_first, gather_dict) from .run.runners import run_parallel_with_display as run_logging from .run.runners import (run_single, run_parallel) from .run.process import run_process @@ -13,5 +13,5 @@ __all__ = ['schedule', 'schedule_hint', 'run_single', 'run_process', 'run_logging', 'run_parallel', 'unwrap', 'Scheduler', 'Storable', 'has_scheduled_methods', - 'gather', 'lift', 'unpack', 'delay', 'update_hints', + 'gather', 'gather_dict', 'lift', 'unpack', 'delay', 'update_hints', 'quote', 'unquote', 'find_first'] diff --git a/noodles/interface/__init__.py b/noodles/interface/__init__.py index 1a35bdf..f4cf280 100644 --- a/noodles/interface/__init__.py +++ b/noodles/interface/__init__.py @@ -2,11 +2,11 @@ PromisedObject, schedule, schedule_hint, has_scheduled_methods, unwrap, update_hints) from .functions import ( - delay, gather, lift, unpack, quote, unquote, find_first) + delay, gather, gather_dict, lift, unpack, quote, unquote, find_first) from .annotated_value import (AnnotatedValue) from .exceptions import (JobException) -__all__ = ['delay', 'gather', 'schedule_hint', 'schedule', 'unpack', +__all__ = ['delay', 'gather', 'gather_dict', 'schedule_hint', 'schedule', 'unpack', 'has_scheduled_methods', 'unwrap', 'update_hints', 'AnnotatedValue', 'JobException', 'lift', 'PromisedObject', 'quote', 'unquote', 'find_first'] diff --git a/noodles/interface/functions.py b/noodles/interface/functions.py index fb69d75..3b84049 100644 --- a/noodles/interface/functions.py +++ b/noodles/interface/functions.py @@ -21,6 +21,12 @@ def gather(*a): return list(a) +@schedule +def gather_dict(**kwargs): + """Creates a promise of a dictionary.""" + return dict(**kwargs) + + def unpack(t, n): """Iterates over a promised sequence, the sequence should support random access by :meth:`object.__getitem__`. Also the length of the sequence From 7f4aab0efc7b803303e3aa40642578e39428f7b9 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Fri, 2 Jun 2017 16:03:01 +0200 Subject: [PATCH 077/155] show complicated example --- examples/example2.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/examples/example2.py b/examples/example2.py index 0074fdb..8bb1a09 100644 --- a/examples/example2.py +++ b/examples/example2.py @@ -39,9 +39,9 @@ def foo(a, b, c): # draw_workflow("graph-example2.svg", r5) with DumbDisplay() as display: - answer = run_logging(r5, 4, display) - #answer = run_parallel_opt( - # r5, 4, serial.base, "cache.json", - # display=display, cache_all=True) + # answer = run_logging(r5, 4, display) + answer = run_parallel_opt( + r5, 4, serial.base, "cache.json", + display=display, cache_all=True) print("The answer is: {0}".format(answer)) From 6b82fcdb2e8e618d26c7f025e9e6ac0f4844c63e Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Fri, 2 Jun 2017 16:04:52 +0200 Subject: [PATCH 078/155] remove key from dumb term output --- noodles/display/dumb_term.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/noodles/display/dumb_term.py b/noodles/display/dumb_term.py index 3c40f49..c82fd40 100644 --- a/noodles/display/dumb_term.py +++ b/noodles/display/dumb_term.py @@ -31,7 +31,7 @@ def __init__(self, error_filter=None): def print_message(self, key, msg): if key in self.jobs: - print("{0} | {1:12} | {2}".format( + print("{1:12} | {2}".format( key, '['+msg.upper()+']', self.jobs[key]['name']), file=sys.stderr) From 500d37262ae5393b29e5173a7c3970a4fc72f852 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Fri, 16 Jun 2017 11:15:16 +0200 Subject: [PATCH 079/155] expose intermediate results to user --- .gitignore | 1 + noodles/__init__.py | 4 ++-- noodles/interface/__init__.py | 10 +++++----- noodles/interface/decorator.py | 8 +++++--- noodles/run/scheduler.py | 1 + test/test_runner.py | 6 +++++- 6 files changed, 19 insertions(+), 11 deletions(-) diff --git a/.gitignore b/.gitignore index a6d1392..428967f 100644 --- a/.gitignore +++ b/.gitignore @@ -11,3 +11,4 @@ cover .*.swp doc/build venv +cache* diff --git a/noodles/__init__.py b/noodles/__init__.py index 7133a31..d76a7cd 100644 --- a/noodles/__init__.py +++ b/noodles/__init__.py @@ -1,7 +1,7 @@ from noodles.interface import ( delay, gather, lift, schedule, schedule_hint, unwrap, has_scheduled_methods, update_hints, unpack, quote, unquote, - find_first, gather_dict) + find_first, gather_dict, result) from .run.runners import run_parallel_with_display as run_logging from .run.runners import (run_single, run_parallel) from .run.process import run_process @@ -14,4 +14,4 @@ 'run_logging', 'run_parallel', 'unwrap', 'Scheduler', 'Storable', 'has_scheduled_methods', 'gather', 'gather_dict', 'lift', 'unpack', 'delay', 'update_hints', - 'quote', 'unquote', 'find_first'] + 'quote', 'unquote', 'find_first', 'result'] diff --git a/noodles/interface/__init__.py b/noodles/interface/__init__.py index f4cf280..529d34d 100644 --- a/noodles/interface/__init__.py +++ b/noodles/interface/__init__.py @@ -1,12 +1,12 @@ from .decorator import ( PromisedObject, schedule, schedule_hint, has_scheduled_methods, - unwrap, update_hints) + unwrap, update_hints, result) from .functions import ( delay, gather, gather_dict, lift, unpack, quote, unquote, find_first) from .annotated_value import (AnnotatedValue) from .exceptions import (JobException) -__all__ = ['delay', 'gather', 'gather_dict', 'schedule_hint', 'schedule', 'unpack', - 'has_scheduled_methods', 'unwrap', 'update_hints', 'AnnotatedValue', - 'JobException', 'lift', 'PromisedObject', 'quote', 'unquote', - 'find_first'] +__all__ = ['delay', 'gather', 'gather_dict', 'schedule_hint', 'schedule', + 'unpack', 'has_scheduled_methods', 'unwrap', 'update_hints', + 'AnnotatedValue', 'JobException', 'lift', 'PromisedObject', 'quote', + 'unquote', 'find_first', 'result'] diff --git a/noodles/interface/decorator.py b/noodles/interface/decorator.py index 73743f9..eb1b8ef 100644 --- a/noodles/interface/decorator.py +++ b/noodles/interface/decorator.py @@ -137,13 +137,12 @@ def update_hints(obj, data): obj._workflow.nodes[root].hints.update(data) -def get_result(obj): +def result(obj): """Results are stored on the nodes in the workflow at run time. This function can be used to get at a result of a node in a workflow after run time. This is not a recommended way of getting at results, but can help with debugging.""" - root = obj._workflow.root - return obj._workflow.nodes[root].result + return obj.__result__() class PromisedObject: @@ -170,6 +169,9 @@ def __setattr__(self, attr, value): self._workflow = get_workflow( _setattr(self, attr, value)) + def __result__(self): + return self._workflow.root_node.result + # predicates # def __lt__(self, other): # return schedule(operator.lt)(self, other) diff --git a/noodles/run/scheduler.py b/noodles/run/scheduler.py index 1056346..0e52325 100644 --- a/noodles/run/scheduler.py +++ b/noodles/run/scheduler.py @@ -126,6 +126,7 @@ def run(self, connection: Connection, master: Workflow): continue # insert the result in the nodes that need it + wf.nodes[n].result = result for (tgt, address) in wf.links[n]: insert_result(wf.nodes[tgt], address, result) if is_node_ready(wf.nodes[tgt]) and not graceful_exit: diff --git a/test/test_runner.py b/test/test_runner.py index 9c7babd..da28075 100644 --- a/test/test_runner.py +++ b/test/test_runner.py @@ -1,4 +1,4 @@ -from noodles import schedule, run_single, run_parallel, gather +from noodles import schedule, run_single, run_parallel, gather, result import time @@ -33,6 +33,8 @@ def test_runner_01(): C = add(A, B) assert run_single(C) == 2 + assert result(A) == 1 + assert result(B) == 1 def test_runner_02(): @@ -43,6 +45,8 @@ def test_runner_02(): C = sum(gather(*multiples)) assert run_single(C) == 42 + assert result(C) == 42 + assert result(A) == 2 def test_parallel_runner_01(): From 812a54fed1c0dbb9ea8811853dff6992de774382 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Fri, 16 Jun 2017 11:42:51 +0200 Subject: [PATCH 080/155] gather_all for iterators, add tests for different flavours of gather --- .editorconfig | 40 ++++++++++++++++++++++++++++++++++ noodles/__init__.py | 6 ++--- noodles/interface/__init__.py | 11 +++++----- noodles/interface/functions.py | 5 +++++ test/test_gather.py | 19 ++++++++++++++++ 5 files changed, 73 insertions(+), 8 deletions(-) create mode 100644 .editorconfig diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 0000000..11a8d1c --- /dev/null +++ b/.editorconfig @@ -0,0 +1,40 @@ +# EditorConfig is awesome: http://EditorConfig.org + +# top-most EditorConfig file +root = true + +# Unix-style newlines with a newline ending every file +[*] +end_of_line = lf +insert_final_newline = true +trim_trailing_whitespace = true +charset = utf-8 + +# Matches multiple files with brace expansion notation +# Set default charset +[*.{js,py,java,r,R}] +indent_style = space + +# 4 space indentation +[*.py] +indent_size = 4 + +# Tab indentation (no size specified) +[*.js] +indent_size = 2 + +# Matches the exact files either package.json or .travis.yml +[*.{json,yml}] +indent_size = 2 + +[*.{md,Rmd}] +trim_trailing_whitespace = true + +[*.{cpp,hpp,cc,hh,c,h,cuh,cu}] +indent_size = 4 +indent_style = space + +[*.{sls,scm,ss}] +indent_size = 2 +indent_style = space + diff --git a/noodles/__init__.py b/noodles/__init__.py index d76a7cd..6f293b7 100644 --- a/noodles/__init__.py +++ b/noodles/__init__.py @@ -1,7 +1,7 @@ from noodles.interface import ( delay, gather, lift, schedule, schedule_hint, unwrap, has_scheduled_methods, update_hints, unpack, quote, unquote, - find_first, gather_dict, result) + find_first, gather_dict, result, gather_all) from .run.runners import run_parallel_with_display as run_logging from .run.runners import (run_single, run_parallel) from .run.process import run_process @@ -13,5 +13,5 @@ __all__ = ['schedule', 'schedule_hint', 'run_single', 'run_process', 'run_logging', 'run_parallel', 'unwrap', 'Scheduler', 'Storable', 'has_scheduled_methods', - 'gather', 'gather_dict', 'lift', 'unpack', 'delay', 'update_hints', - 'quote', 'unquote', 'find_first', 'result'] + 'gather', 'gather_all', 'gather_dict', 'lift', 'unpack', + 'delay', 'update_hints', 'quote', 'unquote', 'find_first', 'result'] diff --git a/noodles/interface/__init__.py b/noodles/interface/__init__.py index 529d34d..3687a16 100644 --- a/noodles/interface/__init__.py +++ b/noodles/interface/__init__.py @@ -2,11 +2,12 @@ PromisedObject, schedule, schedule_hint, has_scheduled_methods, unwrap, update_hints, result) from .functions import ( - delay, gather, gather_dict, lift, unpack, quote, unquote, find_first) + delay, gather, gather_all, gather_dict, lift, unpack, quote, + unquote, find_first) from .annotated_value import (AnnotatedValue) from .exceptions import (JobException) -__all__ = ['delay', 'gather', 'gather_dict', 'schedule_hint', 'schedule', - 'unpack', 'has_scheduled_methods', 'unwrap', 'update_hints', - 'AnnotatedValue', 'JobException', 'lift', 'PromisedObject', 'quote', - 'unquote', 'find_first', 'result'] +__all__ = ['delay', 'gather', 'gather_all', 'gather_dict', 'schedule_hint', + 'schedule', 'unpack', 'has_scheduled_methods', 'unwrap', + 'update_hints', 'AnnotatedValue', 'JobException', 'lift', + 'PromisedObject', 'quote', 'unquote', 'find_first', 'result'] diff --git a/noodles/interface/functions.py b/noodles/interface/functions.py index 3b84049..78e33bb 100644 --- a/noodles/interface/functions.py +++ b/noodles/interface/functions.py @@ -21,6 +21,11 @@ def gather(*a): return list(a) +def gather_all(a): + """Converts an iterator of promises into a promise of a list.""" + return gather(*a) + + @schedule def gather_dict(**kwargs): """Creates a promise of a dictionary.""" diff --git a/test/test_gather.py b/test/test_gather.py index 78b5af2..977e1e7 100644 --- a/test/test_gather.py +++ b/test/test_gather.py @@ -1,8 +1,27 @@ import noodles from noodles.run.runners import run_single +from noodles.tutorial import add def test_empty_gather(): d = noodles.gather() result = run_single(d) assert result == [] + + +def test_gather(): + d = noodles.gather(*[add(x, x) for x in range(10)]) + result = run_single(d) + assert result == list(range(0, 20, 2)) + + +def test_gather_dict(): + d = noodles.gather_dict(a=1, b=add(1, 1), c=add(2, 3)) + result = run_single(d) + assert result == {'a': 1, 'b': 2, 'c': 5} + + +def test_gather_all(): + d = noodles.gather_all(add(x, 2*x) for x in range(10)) + result = run_single(d) + assert result == list(range(0, 30, 3)) From 6c60a38963ba200421558f9c8e5e90505954628e Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Fri, 16 Jun 2017 15:07:58 +0200 Subject: [PATCH 081/155] add `maybe` method for exception handling --- examples/maybe.py | 19 +++++++++ noodles/__init__.py | 4 +- noodles/interface/__init__.py | 4 +- noodles/interface/maybe.py | 74 +++++++++++++++++++++++++++++++++++ 4 files changed, 98 insertions(+), 3 deletions(-) create mode 100644 examples/maybe.py create mode 100644 noodles/interface/maybe.py diff --git a/examples/maybe.py b/examples/maybe.py new file mode 100644 index 0000000..dd7561f --- /dev/null +++ b/examples/maybe.py @@ -0,0 +1,19 @@ +from noodles import (schedule, maybe, run_single) + + +@schedule +@maybe +def inv(x): + return 1/x + + +@schedule +@maybe +def add(**args): + return sum(args.values()) + + +if __name__ == "__main__": + wf = add(a=inv(0), b=inv(0)) + result = run_single(wf) + print(result) diff --git a/noodles/__init__.py b/noodles/__init__.py index 6f293b7..b25f095 100644 --- a/noodles/__init__.py +++ b/noodles/__init__.py @@ -1,7 +1,7 @@ from noodles.interface import ( delay, gather, lift, schedule, schedule_hint, unwrap, has_scheduled_methods, update_hints, unpack, quote, unquote, - find_first, gather_dict, result, gather_all) + find_first, gather_dict, result, gather_all, maybe) from .run.runners import run_parallel_with_display as run_logging from .run.runners import (run_single, run_parallel) from .run.process import run_process @@ -13,5 +13,5 @@ __all__ = ['schedule', 'schedule_hint', 'run_single', 'run_process', 'run_logging', 'run_parallel', 'unwrap', 'Scheduler', 'Storable', 'has_scheduled_methods', - 'gather', 'gather_all', 'gather_dict', 'lift', 'unpack', + 'gather', 'gather_all', 'gather_dict', 'lift', 'unpack', 'maybe' 'delay', 'update_hints', 'quote', 'unquote', 'find_first', 'result'] diff --git a/noodles/interface/__init__.py b/noodles/interface/__init__.py index 3687a16..4120578 100644 --- a/noodles/interface/__init__.py +++ b/noodles/interface/__init__.py @@ -6,8 +6,10 @@ unquote, find_first) from .annotated_value import (AnnotatedValue) from .exceptions import (JobException) +from .maybe import (maybe) __all__ = ['delay', 'gather', 'gather_all', 'gather_dict', 'schedule_hint', 'schedule', 'unpack', 'has_scheduled_methods', 'unwrap', 'update_hints', 'AnnotatedValue', 'JobException', 'lift', - 'PromisedObject', 'quote', 'unquote', 'find_first', 'result'] + 'PromisedObject', 'quote', 'unquote', 'find_first', 'result', + 'maybe'] diff --git a/noodles/interface/maybe.py b/noodles/interface/maybe.py new file mode 100644 index 0000000..d8a1e59 --- /dev/null +++ b/noodles/interface/maybe.py @@ -0,0 +1,74 @@ +from functools import (wraps) +from itertools import (chain) +import inspect +from ..utility import (object_name) + + +class Fail: + def __init__(self, func, fails=[], exception=None): + self.name = "{} ({}:{})".format( + object_name(func), + inspect.getsourcefile(func), + inspect.getsourcelines(func)[1]) + self.fails = fails + self.trace = [] + self.exception = exception + + def add_call(self, func): + self.trace.append("{} ({}:{})".format( + object_name(func), + inspect.getsourcefile(func), + inspect.getsourcelines(func)[1])) + + return self + + @property + def is_root_cause(self): + return self.exception is not None + + def __bool__(self): + return False + + def __str__(self): + msg = "Fail: " + " -> ".join(self.trace + [self.name]) + if self.exception is not None: + msg += "\n* exception: " + msg += "\n ".join(l for l in str(self.exception).split('\n')) + elif self.fails: + msg += "\n* failed arguments:\n " + msg += "\n ".join( + "{} `{}` ".format(foo, bar) + "\n ".join( + l for l in str(fail).split('\n')) + for foo, bar, fail in self.fails) + return msg + + +def maybe(f): + """Calls `f` in a try/except block, returning a `Fail` object if + the call fails in any way. If any of the arguments to the call are Fail + objects, the call is not attempted.""" + + name = object_name(f) + + @wraps(f) + def maybe_wrapped(*args, **kwargs): + fails = [(name, k, v) + for k, v in chain(enumerate(args), kwargs.items()) + if isinstance(v, Fail)] + + if fails: + return Fail(f, fails=fails) + + try: + result = f(*args, **kwargs) + + except Exception as e: + return Fail(f, exception=e) + + else: + if isinstance(result, Fail): + result.add_call(f) + + return result + + return maybe_wrapped From d0c9a701acd5fcdecc8cce2db11e84746e83eae8 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Fri, 16 Jun 2017 15:33:11 +0200 Subject: [PATCH 082/155] fix codacy issues --- noodles/__init__.py | 2 +- noodles/interface/maybe.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/noodles/__init__.py b/noodles/__init__.py index b25f095..990ccc5 100644 --- a/noodles/__init__.py +++ b/noodles/__init__.py @@ -13,5 +13,5 @@ __all__ = ['schedule', 'schedule_hint', 'run_single', 'run_process', 'run_logging', 'run_parallel', 'unwrap', 'Scheduler', 'Storable', 'has_scheduled_methods', - 'gather', 'gather_all', 'gather_dict', 'lift', 'unpack', 'maybe' + 'gather', 'gather_all', 'gather_dict', 'lift', 'unpack', 'maybe', 'delay', 'update_hints', 'quote', 'unquote', 'find_first', 'result'] diff --git a/noodles/interface/maybe.py b/noodles/interface/maybe.py index d8a1e59..8fba49e 100644 --- a/noodles/interface/maybe.py +++ b/noodles/interface/maybe.py @@ -5,12 +5,12 @@ class Fail: - def __init__(self, func, fails=[], exception=None): + def __init__(self, func, fails=None, exception=None): self.name = "{} ({}:{})".format( object_name(func), inspect.getsourcefile(func), inspect.getsourcelines(func)[1]) - self.fails = fails + self.fails = fails or [] self.trace = [] self.exception = exception From a01533248631ca6a2a60720036da8d7edd1c3259 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Thu, 6 Jul 2017 10:02:52 +0200 Subject: [PATCH 083/155] ConstRef object --- noodles/interface/decorator.py | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/noodles/interface/decorator.py b/noodles/interface/decorator.py index eb1b8ef..175e3b3 100644 --- a/noodles/interface/decorator.py +++ b/noodles/interface/decorator.py @@ -76,7 +76,7 @@ def schedule_hint(**hints): def unwrap(f): """Unwrap a wrapped function; the function needs to have been wrapped using :func:`functools.wraps`, as is done in :func:`schedule`. - + If function `f` doesn't have the `__wrapped` attribute, the same function `f` is returned.""" try: @@ -145,6 +145,17 @@ def result(obj): return obj.__result__() +class ConstRef: + def __init__(self, this): + self.this = this + + def __getattr__(self, attr): + return getattr(self.this, attr) + + def __deepcopy__(self, _): + return self + + class PromisedObject: """ Wraps a :py:class:`Workflow`. The workflow represents the future promise From 2c474086090c569738ba98e8b32e533565639c55 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Mon, 18 Sep 2017 11:29:50 +0200 Subject: [PATCH 084/155] include draw_workflow in package distribution --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index 52c4caf..0e9e055 100755 --- a/setup.py +++ b/setup.py @@ -21,7 +21,7 @@ 'noodles.run.remote', 'noodles.display', 'noodles.interface', 'noodles.workflow', 'noodles.files', - 'noodles.prov'], + 'noodles.prov', 'noodles.draw_workflow'], classifiers=[ 'License :: OSI Approved :: Apache Software License', From 90bb24b53e5afecfdc35f61945e99ac5807ff02a Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Mon, 18 Sep 2017 13:06:02 +0200 Subject: [PATCH 085/155] Introduction expended with assumed knowledge statement, and typo fixed in ofttimes --- doc/source/index.rst | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/doc/source/index.rst b/doc/source/index.rst index 5fc83fe..d085f44 100644 --- a/doc/source/index.rst +++ b/doc/source/index.rst @@ -8,14 +8,16 @@ Welcome to Noodles's documentation! Introduction ------------ -Noodles offers a model for parallel programming in Python. It can be used for a variety of tasks including data pipelines, and computational workflows. +Noodles offers a model for parallel programming in Python. It can be used for a variety of tasks including data pipelines, and computational workflows. The primary goal of Noodles is to make it easy to run jobs on cluster supercomputers, in parallel, straight from a Python shell. The user enters a Python script that looks and feels like a serial program. The Noodles engine then converts this script into a call graph. This graph can be executed on a variety of machines using the different back-end runners that Noodles provides. This is not so much a design driven by technology but by social considerations. The end user may expect an elegant, easy to understand, interface to a computational library. This user experience we refer to as *eating of noodles*. -The computational library that is exposed to the user by means of Noodles needs to adhere to some design principles that are more strict than plain Python gives us. The library should follow a functional style of programming and is limited by the fact that function arguments need to pass through a layer where data is converted to and from a JSON format. The design of such a library is the *cooking of noodles*. As it is with ramen noodles, ofttimes the cook is also an avid consumer of noodles. +The computational library that is exposed to the user by means of Noodles needs to adhere to some design principles that are more strict than plain Python gives us. The library should follow a functional style of programming and is limited by the fact that function arguments need to pass through a layer where data is converted to and from a JSON format. The design of such a library is the *cooking of noodles*. As it is with ramen noodles, often the cook is also an avid consumer of noodles. The complexity of running a workflow in parallel on a wide variety of architectures is taken care of by the Noodles engine. This is the *production of noodles* which is left as an exercise for the Noodles dev-team at the Netherlands eScience Center. +Assumed knowledge for this tutorial: Familiarity with basics of the Python language, [decorators](https://www.thecodeship.com/patterns/guide-to-python-function-decorators/) and the distinction between [functional and object oriented programming](https://en.wikipedia.org/wiki/Comparison_of_programming_paradigms). + Copyright & Licence ------------------- From 14478cb9a72d9dfcd44ee97ab745ec6c622bdd32 Mon Sep 17 00:00:00 2001 From: Hanno Spreeuw Date: Mon, 18 Sep 2017 13:11:41 +0200 Subject: [PATCH 086/155] move draw_workflow to submodule --- noodles/draw_workflow/__init__.py | 4 ++++ noodles/{ => draw_workflow}/draw_workflow.py | 0 2 files changed, 4 insertions(+) create mode 100644 noodles/draw_workflow/__init__.py rename noodles/{ => draw_workflow}/draw_workflow.py (100%) diff --git a/noodles/draw_workflow/__init__.py b/noodles/draw_workflow/__init__.py new file mode 100644 index 0000000..513b847 --- /dev/null +++ b/noodles/draw_workflow/__init__.py @@ -0,0 +1,4 @@ +from .draw_workflow import draw_workflow + +__all__ = ['draw_workflow'] + diff --git a/noodles/draw_workflow.py b/noodles/draw_workflow/draw_workflow.py similarity index 100% rename from noodles/draw_workflow.py rename to noodles/draw_workflow/draw_workflow.py From 1fa837e0eb6d5b8603b0bc91e4212f5af5dbe430 Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Mon, 18 Sep 2017 13:06:02 +0200 Subject: [PATCH 087/155] Introduction expended with assumed knowledge statement, and typo fixed in ofttimes --- doc/source/index.rst | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/doc/source/index.rst b/doc/source/index.rst index 5fc83fe..d085f44 100644 --- a/doc/source/index.rst +++ b/doc/source/index.rst @@ -8,14 +8,16 @@ Welcome to Noodles's documentation! Introduction ------------ -Noodles offers a model for parallel programming in Python. It can be used for a variety of tasks including data pipelines, and computational workflows. +Noodles offers a model for parallel programming in Python. It can be used for a variety of tasks including data pipelines, and computational workflows. The primary goal of Noodles is to make it easy to run jobs on cluster supercomputers, in parallel, straight from a Python shell. The user enters a Python script that looks and feels like a serial program. The Noodles engine then converts this script into a call graph. This graph can be executed on a variety of machines using the different back-end runners that Noodles provides. This is not so much a design driven by technology but by social considerations. The end user may expect an elegant, easy to understand, interface to a computational library. This user experience we refer to as *eating of noodles*. -The computational library that is exposed to the user by means of Noodles needs to adhere to some design principles that are more strict than plain Python gives us. The library should follow a functional style of programming and is limited by the fact that function arguments need to pass through a layer where data is converted to and from a JSON format. The design of such a library is the *cooking of noodles*. As it is with ramen noodles, ofttimes the cook is also an avid consumer of noodles. +The computational library that is exposed to the user by means of Noodles needs to adhere to some design principles that are more strict than plain Python gives us. The library should follow a functional style of programming and is limited by the fact that function arguments need to pass through a layer where data is converted to and from a JSON format. The design of such a library is the *cooking of noodles*. As it is with ramen noodles, often the cook is also an avid consumer of noodles. The complexity of running a workflow in parallel on a wide variety of architectures is taken care of by the Noodles engine. This is the *production of noodles* which is left as an exercise for the Noodles dev-team at the Netherlands eScience Center. +Assumed knowledge for this tutorial: Familiarity with basics of the Python language, [decorators](https://www.thecodeship.com/patterns/guide-to-python-function-decorators/) and the distinction between [functional and object oriented programming](https://en.wikipedia.org/wiki/Comparison_of_programming_paradigms). + Copyright & Licence ------------------- From b2730bb178281a10f99e3d1b30e068527579f339 Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Mon, 18 Sep 2017 13:29:08 +0200 Subject: [PATCH 088/155] expanded with assumed knowledge + typo Sentence added with a statement about assumed knowledge in this tutorial Typo fixed in third alinea: ofttimes --- doc/source/index.rst | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/doc/source/index.rst b/doc/source/index.rst index 5fc83fe..6cae8fc 100644 --- a/doc/source/index.rst +++ b/doc/source/index.rst @@ -12,10 +12,12 @@ Noodles offers a model for parallel programming in Python. It can be used for a The primary goal of Noodles is to make it easy to run jobs on cluster supercomputers, in parallel, straight from a Python shell. The user enters a Python script that looks and feels like a serial program. The Noodles engine then converts this script into a call graph. This graph can be executed on a variety of machines using the different back-end runners that Noodles provides. This is not so much a design driven by technology but by social considerations. The end user may expect an elegant, easy to understand, interface to a computational library. This user experience we refer to as *eating of noodles*. -The computational library that is exposed to the user by means of Noodles needs to adhere to some design principles that are more strict than plain Python gives us. The library should follow a functional style of programming and is limited by the fact that function arguments need to pass through a layer where data is converted to and from a JSON format. The design of such a library is the *cooking of noodles*. As it is with ramen noodles, ofttimes the cook is also an avid consumer of noodles. +The computational library that is exposed to the user by means of Noodles needs to adhere to some design principles that are more strict than plain Python gives us. The library should follow a functional style of programming and is limited by the fact that function arguments need to pass through a layer where data is converted to and from a JSON format. The design of such a library is the *cooking of noodles*. As it is with ramen noodles, often the cook is also an avid consumer of noodles. The complexity of running a workflow in parallel on a wide variety of architectures is taken care of by the Noodles engine. This is the *production of noodles* which is left as an exercise for the Noodles dev-team at the Netherlands eScience Center. +Assumed knowledge for this tutorial: Familiarity with basics of the Python language, [decorators](https://www.thecodeship.com/patterns/guide-to-python-function-decorators/) and the distinction between [functional and object oriented programming](https://en.wikipedia.org/wiki/Comparison_of_programming_paradigms). + Copyright & Licence ------------------- From 4803a3dd9ae5f8ac7271e4a5abab84e2a68271fe Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Mon, 18 Sep 2017 13:06:02 +0200 Subject: [PATCH 089/155] Introduction expended with assumed knowledge statement, and typo fixed in ofttimes --- doc/source/index.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/source/index.rst b/doc/source/index.rst index 6cae8fc..e45da7c 100644 --- a/doc/source/index.rst +++ b/doc/source/index.rst @@ -8,7 +8,7 @@ Welcome to Noodles's documentation! Introduction ------------ -Noodles offers a model for parallel programming in Python. It can be used for a variety of tasks including data pipelines, and computational workflows. +Noodles offers a model for parallel programming in Python. It can be used for a variety of tasks including data pipelines, and computational workflows. The primary goal of Noodles is to make it easy to run jobs on cluster supercomputers, in parallel, straight from a Python shell. The user enters a Python script that looks and feels like a serial program. The Noodles engine then converts this script into a call graph. This graph can be executed on a variety of machines using the different back-end runners that Noodles provides. This is not so much a design driven by technology but by social considerations. The end user may expect an elegant, easy to understand, interface to a computational library. This user experience we refer to as *eating of noodles*. From bfc358b92a8bd89da42fe8b44ac2c3e788ffc9c5 Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Mon, 18 Sep 2017 13:50:32 +0200 Subject: [PATCH 090/155] url link fixed in introduction --- doc/source/index.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/source/index.rst b/doc/source/index.rst index e45da7c..0eb9731 100644 --- a/doc/source/index.rst +++ b/doc/source/index.rst @@ -16,7 +16,7 @@ The computational library that is exposed to the user by means of Noodles needs The complexity of running a workflow in parallel on a wide variety of architectures is taken care of by the Noodles engine. This is the *production of noodles* which is left as an exercise for the Noodles dev-team at the Netherlands eScience Center. -Assumed knowledge for this tutorial: Familiarity with basics of the Python language, [decorators](https://www.thecodeship.com/patterns/guide-to-python-function-decorators/) and the distinction between [functional and object oriented programming](https://en.wikipedia.org/wiki/Comparison_of_programming_paradigms). +Assumed knowledge for this tutorial: Familiarity with basics of the Python language, `decorators` and the distinction between `functional and object oriented programming`_. Copyright & Licence ------------------- From b17e7721cabdf951e20cb33131193b45f03a2796 Mon Sep 17 00:00:00 2001 From: Hanno Spreeuw Date: Mon, 18 Sep 2017 14:42:54 +0200 Subject: [PATCH 091/155] Clarifications wrt the installation and import of pygraphviz --- doc/source/first_steps.rst | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/doc/source/first_steps.rst b/doc/source/first_steps.rst index efae898..0fc80f0 100644 --- a/doc/source/first_steps.rst +++ b/doc/source/first_steps.rst @@ -27,7 +27,7 @@ Now we can create a workflow composing several calls to this function. c = add(a, a) d = mul(b, c) -That looks easy enough; the funny thing is though, that nothing has been computed yet! Noodles just created the workflow graphs corresponding to the values that still need to be computed. Until such time, we work with the *promise* of a future value. Using the module ``pygraphviz`` (`pip install pygraphviz`) we can look at the call graphs. +That looks easy enough; the funny thing is though, that nothing has been computed yet! Noodles just created the workflow graphs corresponding to the values that still need to be computed. Until such time, we work with the *promise* of a future value. Using the module ``pygraphviz`` (`pip install pygraphviz`, check `this post `_ if you have problems installing pygraphviz) we can look at the call graphs. .. code:: python @@ -42,6 +42,8 @@ That looks easy enough; the funny thing is though, that nothing has been compute err = os.system("montage wf1?.png -tile 4x1 -geometry +10+0 wf1-series.png") +``draw_workflow`` imports pygraphviz. + .. figure:: _static/images/wf1-series.png :alt: building the workflow :align: center From b68b8e7c0c61abd6c806a3406e0d9f524633b7af Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Mon, 18 Sep 2017 14:47:42 +0200 Subject: [PATCH 092/155] srt syntax errors in url fixed --- doc/source/index.rst | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/doc/source/index.rst b/doc/source/index.rst index 0eb9731..12fe19d 100644 --- a/doc/source/index.rst +++ b/doc/source/index.rst @@ -16,7 +16,7 @@ The computational library that is exposed to the user by means of Noodles needs The complexity of running a workflow in parallel on a wide variety of architectures is taken care of by the Noodles engine. This is the *production of noodles* which is left as an exercise for the Noodles dev-team at the Netherlands eScience Center. -Assumed knowledge for this tutorial: Familiarity with basics of the Python language, `decorators` and the distinction between `functional and object oriented programming`_. +Assumed knowledge for this tutorial: Familiarity with basics of the Python language, `decorators`_, and the distinction between functional and object oriented programming: https://en.wikipedia.org/wiki/Comparison_of_programming_paradigms. Copyright & Licence ------------------- @@ -83,3 +83,4 @@ Indices and tables .. _pyxenon: http://github.com/NLeSC/pyxenon .. _LGPLv3: http://www.gnu.org/licenses/lgpl-3.0.html .. _`generating SSH keys`: https://help.github.com/articles/generating-ssh-keys/ +.. _`decorators`: https://www.thecodeship.com/patterns/guide-to-python-function-decorators/ From 20fb976389e0cd686f948a11162f098e8d55b9f2 Mon Sep 17 00:00:00 2001 From: Hanno Spreeuw Date: Mon, 18 Sep 2017 14:52:00 +0200 Subject: [PATCH 093/155] pygraphviz highlighted like draw_workflow --- doc/source/first_steps.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/source/first_steps.rst b/doc/source/first_steps.rst index 0fc80f0..217218b 100644 --- a/doc/source/first_steps.rst +++ b/doc/source/first_steps.rst @@ -42,7 +42,7 @@ That looks easy enough; the funny thing is though, that nothing has been compute err = os.system("montage wf1?.png -tile 4x1 -geometry +10+0 wf1-series.png") -``draw_workflow`` imports pygraphviz. +``draw_workflow`` imports ``pygraphviz``. .. figure:: _static/images/wf1-series.png :alt: building the workflow From c3fb4a449b33805779f106df738a108d07ce771b Mon Sep 17 00:00:00 2001 From: Hanno Spreeuw Date: Mon, 18 Sep 2017 15:07:24 +0200 Subject: [PATCH 094/155] Some clarification wrt the disk location of the call graph produced. --- doc/source/first_steps.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/source/first_steps.rst b/doc/source/first_steps.rst index 217218b..43034b6 100644 --- a/doc/source/first_steps.rst +++ b/doc/source/first_steps.rst @@ -42,7 +42,7 @@ That looks easy enough; the funny thing is though, that nothing has been compute err = os.system("montage wf1?.png -tile 4x1 -geometry +10+0 wf1-series.png") -``draw_workflow`` imports ``pygraphviz``. +``draw_workflow`` imports ``pygraphviz``. ``wf1-series.png`` is saved to the directory from which you launched this notebook. .. figure:: _static/images/wf1-series.png :alt: building the workflow From 2ccde27142ee735f381df9a063366ae18ac69a71 Mon Sep 17 00:00:00 2001 From: Lars Ridder Date: Mon, 18 Sep 2017 15:20:37 +0200 Subject: [PATCH 095/155] Remove non-existing member "numpy" from automodule noodles.serial --- doc/source/development.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/source/development.rst b/doc/source/development.rst index 702fd64..b4f78cd 100644 --- a/doc/source/development.rst +++ b/doc/source/development.rst @@ -24,7 +24,7 @@ Runners Serialisation ------------- .. automodule:: noodles.serial - :members: base, pickle, numpy + :members: base, pickle .. automodule:: noodles.serial.registry :members: Registry, Serialiser, RefObject From bd5862319ed824c8e03bb73f8ef4ccc8c099da62 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Mon, 18 Sep 2017 15:33:27 +0200 Subject: [PATCH 096/155] lifting test --- test/test_lift.py | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/test/test_lift.py b/test/test_lift.py index cdb06bc..702e77f 100644 --- a/test/test_lift.py +++ b/test/test_lift.py @@ -1,5 +1,19 @@ from noodles import (schedule, run_single, gather, lift) from noodles.tutorial import (add, sub, mul) +from collections import OrderedDict + + +@schedule +def g(x): + return x['a'] + x['b'] + +def test_lift_ordered_dict(): + x = OrderedDict() + x['a'] = 1 + x['b'] = add(1, 2) + y = g(lift(x)) + result = run_single(y) + assert result == 4 class A: From f4622dc2681e1cc2672d0a4021c5e895dd2244c9 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Mon, 18 Sep 2017 15:33:56 +0200 Subject: [PATCH 097/155] add readthedocs.yml --- readthedocs.yml | 3 +++ 1 file changed, 3 insertions(+) create mode 100644 readthedocs.yml diff --git a/readthedocs.yml b/readthedocs.yml new file mode 100644 index 0000000..f8b3b41 --- /dev/null +++ b/readthedocs.yml @@ -0,0 +1,3 @@ +python: + version: 3.5 + pip_install: true From eea8bed006442c1ced90aa48525fa11e5174e12e Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Mon, 18 Sep 2017 15:59:59 +0200 Subject: [PATCH 098/155] fix lifting of OrderedDict bug --- noodles/interface/functions.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/noodles/interface/functions.py b/noodles/interface/functions.py index 78e33bb..5c1aead 100644 --- a/noodles/interface/functions.py +++ b/noodles/interface/functions.py @@ -149,6 +149,11 @@ def s_find_first(pred, first, lst): return None +@schedule +def construct_object(cls, args): + return cls(args) + + def lift(obj, memo=None): """Make a promise out of object `obj`, where `obj` may contain promises internally. @@ -229,7 +234,7 @@ def lift(obj, memo=None): internal = lift(subclass(obj), memo) if isinstance(internal, PromisedObject): - internal = schedule(obj.__class__)(internal) + internal = construct_object(obj.__class__, internal) rv = set_dict(internal, members) elif isinstance(members, PromisedObject): rv = set_dict(obj.__class__(internal), members) From 8a994a214e14d875ef1f716701108e03c8d876da Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Mon, 18 Sep 2017 16:03:09 +0200 Subject: [PATCH 099/155] local link to notebook added --- doc/source/first_steps.rst | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/doc/source/first_steps.rst b/doc/source/first_steps.rst index 0fc80f0..2fbba17 100644 --- a/doc/source/first_steps.rst +++ b/doc/source/first_steps.rst @@ -1,7 +1,7 @@ -First Steps +First Steps =========== -**This tutorial is also available in the form of a Jupyter Notebook. Try it out, and play!** +**This tutorial is also available in the form of a :download:`Jupyter Notebook`. Try it out, and play!** Noodles is there to make your life easier, *in parallel*! The reason why Noodles can be easy and do parallel Python at the same time is its *functional* approach. In one part you'll define a set of functions that you'd like to run with Noodles, in an other part you'll compose these functions into a *workflow graph*. To make this approach work a function should not have any *side effects*. Let's not linger and just start noodling! First we define some functions to use. @@ -9,11 +9,11 @@ Noodles is there to make your life easier, *in parallel*! The reason why Noodles .. code:: python from noodles import schedule - + @schedule def add(x, y): return x + y - + @schedule def mul(x,y): return x * y @@ -34,12 +34,12 @@ That looks easy enough; the funny thing is though, that nothing has been compute from draw_workflow import draw_workflow import sys import os - + draw_workflow("wf1a.png", a._workflow) draw_workflow("wf1b.png", b._workflow) draw_workflow("wf1c.png", c._workflow) draw_workflow("wf1d.png", d._workflow) - + err = os.system("montage wf1?.png -tile 4x1 -geometry +10+0 wf1-series.png") ``draw_workflow`` imports pygraphviz. @@ -54,7 +54,7 @@ Now, to compute the result we have to tell Noodles to evaluate the program. .. code:: python from noodles import run_parallel, run_single - + run_parallel(d, n_threads=2) @@ -63,4 +63,3 @@ Now, to compute the result we have to tell Noodles to evaluate the program. .. parsed-literal:: 16 - From 62a1062437c150a12f0ba5c00cbbb336e6c16a8a Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Mon, 18 Sep 2017 16:06:04 +0200 Subject: [PATCH 100/155] link to notebook replaced by hyperlink --- doc/source/first_steps.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/source/first_steps.rst b/doc/source/first_steps.rst index 71862e2..2a94a3c 100644 --- a/doc/source/first_steps.rst +++ b/doc/source/first_steps.rst @@ -1,7 +1,7 @@ First Steps =========== -**This tutorial is also available in the form of a :download:`Jupyter Notebook`. Try it out, and play!** +**This tutorial is also available in the form of a :download:`Jupyter Notebook`. Try it out, and play!** Noodles is there to make your life easier, *in parallel*! The reason why Noodles can be easy and do parallel Python at the same time is its *functional* approach. In one part you'll define a set of functions that you'd like to run with Noodles, in an other part you'll compose these functions into a *workflow graph*. To make this approach work a function should not have any *side effects*. Let's not linger and just start noodling! First we define some functions to use. From 5aa0439b226f991b88f5184b3e26430cf9cbf54e Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Mon, 18 Sep 2017 16:08:02 +0200 Subject: [PATCH 101/155] fixed syntax typos in hyperlink --- doc/source/first_steps.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/source/first_steps.rst b/doc/source/first_steps.rst index 2a94a3c..6d30e0b 100644 --- a/doc/source/first_steps.rst +++ b/doc/source/first_steps.rst @@ -1,7 +1,7 @@ First Steps =========== -**This tutorial is also available in the form of a :download:`Jupyter Notebook`. Try it out, and play!** +**This tutorial is also available in the form of a :download:`Jupyter Notebook `_. Try it out, and play!** Noodles is there to make your life easier, *in parallel*! The reason why Noodles can be easy and do parallel Python at the same time is its *functional* approach. In one part you'll define a set of functions that you'd like to run with Noodles, in an other part you'll compose these functions into a *workflow graph*. To make this approach work a function should not have any *side effects*. Let's not linger and just start noodling! First we define some functions to use. From f474b7a122978cfb9f567ebfa3490d42482d603d Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Mon, 18 Sep 2017 16:08:59 +0200 Subject: [PATCH 102/155] fix 2 syntax typos in hyperlink --- doc/source/first_steps.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/source/first_steps.rst b/doc/source/first_steps.rst index 6d30e0b..e13b8bc 100644 --- a/doc/source/first_steps.rst +++ b/doc/source/first_steps.rst @@ -1,7 +1,7 @@ First Steps =========== -**This tutorial is also available in the form of a :download:`Jupyter Notebook `_. Try it out, and play!** +**This tutorial is also available in the form of a `Jupyter Notebook `_. Try it out, and play!** Noodles is there to make your life easier, *in parallel*! The reason why Noodles can be easy and do parallel Python at the same time is its *functional* approach. In one part you'll define a set of functions that you'd like to run with Noodles, in an other part you'll compose these functions into a *workflow graph*. To make this approach work a function should not have any *side effects*. Let's not linger and just start noodling! First we define some functions to use. From 67d899c44ff86f69fbbdd297b6790ee4a8679f9c Mon Sep 17 00:00:00 2001 From: Lars Ridder Date: Mon, 18 Sep 2017 16:10:37 +0200 Subject: [PATCH 103/155] Include all docstrings in development documentation --- doc/source/development.rst | 15 ++++++++------- noodles/interface/functions.py | 8 ++++---- 2 files changed, 12 insertions(+), 11 deletions(-) diff --git a/doc/source/development.rst b/doc/source/development.rst index b4f78cd..cace057 100644 --- a/doc/source/development.rst +++ b/doc/source/development.rst @@ -1,34 +1,35 @@ Development documentation ========================= .. automodule:: noodles - :members: schedule, run_single, run_parallel, run_process, gather + :members: Internal Specs -------------- .. automodule:: noodles.workflow - :members: from_call, NodeData, FunctionNode, Workflow + :members: Promised object --------------- .. automodule:: noodles.interface - :members: PromisedObject + :members: Runners ------- .. automodule:: noodles.run.scheduler - :members: Scheduler + :members: .. automodule:: noodles.run.hybrid - :members: hybrid_threaded_worker, run_hybrid + :members: Serialisation ------------- .. automodule:: noodles.serial - :members: base, pickle + :members: .. automodule:: noodles.serial.registry - :members: Registry, Serialiser, RefObject + :members: Worker executable ----------------- .. automodule:: noodles.worker + :members: diff --git a/noodles/interface/functions.py b/noodles/interface/functions.py index 5c1aead..1c16eeb 100644 --- a/noodles/interface/functions.py +++ b/noodles/interface/functions.py @@ -118,8 +118,8 @@ def find_first(pred, lst): predicate `pred`. :param pred: a function of one argument returning `True` or `False`. - :param lst: a list of promises or values. :return: a promise of a value or - `None`. + :param lst: a list of promises or values. + :return: a promise of a value or `None`. This is a wrapper around :func:`s_find_first`. The first item on the list is passed *as is*, forcing evalutation. The tail of the list is quoted, and @@ -158,8 +158,8 @@ def lift(obj, memo=None): """Make a promise out of object `obj`, where `obj` may contain promises internally. - :param obj: Any object. :param memo: used for internal caching (similar to - :func:`deepcopy`). + :param obj: Any object. + :param memo: used for internal caching (similar to :func:`deepcopy`). If the object is a :class:`PromisedObject`, or *pass-by-value* (:class:`str`, :class:`int`, :class:`float`, :class:`complex`) it is From d2d52ad232eb252ae509dc876242e8064165a86f Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Mon, 18 Sep 2017 16:11:45 +0200 Subject: [PATCH 104/155] fix 3 syntax typos in hyperlink --- doc/source/first_steps.rst | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/doc/source/first_steps.rst b/doc/source/first_steps.rst index e13b8bc..a526747 100644 --- a/doc/source/first_steps.rst +++ b/doc/source/first_steps.rst @@ -1,7 +1,9 @@ First Steps =========== -**This tutorial is also available in the form of a `Jupyter Notebook `_. Try it out, and play!** +**This tutorial is also available in the form of a `Jupyter Notebook `_ . Try it out, and play!** + +`this testurl `_ Noodles is there to make your life easier, *in parallel*! The reason why Noodles can be easy and do parallel Python at the same time is its *functional* approach. In one part you'll define a set of functions that you'd like to run with Noodles, in an other part you'll compose these functions into a *workflow graph*. To make this approach work a function should not have any *side effects*. Let's not linger and just start noodling! First we define some functions to use. From 0ab8346476d0a2bd5e7c79498501834535012934 Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Mon, 18 Sep 2017 16:13:44 +0200 Subject: [PATCH 105/155] fix 3 syntax typos in hyperlink --- doc/source/first_steps.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/doc/source/first_steps.rst b/doc/source/first_steps.rst index a526747..c5b94ea 100644 --- a/doc/source/first_steps.rst +++ b/doc/source/first_steps.rst @@ -1,9 +1,9 @@ First Steps =========== -**This tutorial is also available in the form of a `Jupyter Notebook `_ . Try it out, and play!** +**This tutorial is also available in the form of a `Jupyter Notebook `_. Try it out, and play!** -`this testurl `_ +`Jupyter Notebook `_ Noodles is there to make your life easier, *in parallel*! The reason why Noodles can be easy and do parallel Python at the same time is its *functional* approach. In one part you'll define a set of functions that you'd like to run with Noodles, in an other part you'll compose these functions into a *workflow graph*. To make this approach work a function should not have any *side effects*. Let's not linger and just start noodling! First we define some functions to use. From 916989ff1e9e8870d38840ded10bfbc7e26aef1f Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Mon, 18 Sep 2017 16:14:41 +0200 Subject: [PATCH 106/155] fix 4 syntax typos in hyperlink --- doc/source/first_steps.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/source/first_steps.rst b/doc/source/first_steps.rst index c5b94ea..421242e 100644 --- a/doc/source/first_steps.rst +++ b/doc/source/first_steps.rst @@ -1,7 +1,7 @@ First Steps =========== -**This tutorial is also available in the form of a `Jupyter Notebook `_. Try it out, and play!** +**This tutorial is also available in the form of a `Jupyter Notebook. `_ Try it out, and play!** `Jupyter Notebook `_ From ede5248a1f784fe6d5419b02900ecdb6be76ad48 Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Mon, 18 Sep 2017 16:15:38 +0200 Subject: [PATCH 107/155] fix 5: syntax typos in hyperlink --- doc/source/first_steps.rst | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/doc/source/first_steps.rst b/doc/source/first_steps.rst index 421242e..18577e5 100644 --- a/doc/source/first_steps.rst +++ b/doc/source/first_steps.rst @@ -1,9 +1,8 @@ First Steps =========== -**This tutorial is also available in the form of a `Jupyter Notebook. `_ Try it out, and play!** - -`Jupyter Notebook `_ +**This tutorial is also available in the form of a `Jupyter Notebook `_ +Try it out, and play!** Noodles is there to make your life easier, *in parallel*! The reason why Noodles can be easy and do parallel Python at the same time is its *functional* approach. In one part you'll define a set of functions that you'd like to run with Noodles, in an other part you'll compose these functions into a *workflow graph*. To make this approach work a function should not have any *side effects*. Let's not linger and just start noodling! First we define some functions to use. From 7bd1a236fe73d94be46e0bd6c7a9af3512865ec6 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Mon, 18 Sep 2017 16:16:23 +0200 Subject: [PATCH 108/155] ... --- noodles/interface/functions.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/noodles/interface/functions.py b/noodles/interface/functions.py index 5c1aead..5e59a3a 100644 --- a/noodles/interface/functions.py +++ b/noodles/interface/functions.py @@ -50,7 +50,8 @@ def set_dict(obj, d): :param obj: input object. :param d: dictionary. :return: the modified object.""" - obj.__dict__ = d + if d: + obj.__dict__ = d return obj From 5b9013194d896da285c1e64a76b7961c1b8b91a9 Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Mon, 18 Sep 2017 16:17:53 +0200 Subject: [PATCH 109/155] fix 6: syntax typos in hyperlink --- doc/source/first_steps.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/doc/source/first_steps.rst b/doc/source/first_steps.rst index 18577e5..566dd06 100644 --- a/doc/source/first_steps.rst +++ b/doc/source/first_steps.rst @@ -1,7 +1,7 @@ First Steps =========== -**This tutorial is also available in the form of a `Jupyter Notebook `_ +**This tutorial is also available in the form of a `Jupyter Notebook `_. Try it out, and play!** Noodles is there to make your life easier, *in parallel*! The reason why Noodles can be easy and do parallel Python at the same time is its *functional* approach. In one part you'll define a set of functions that you'd like to run with Noodles, in an other part you'll compose these functions into a *workflow graph*. To make this approach work a function should not have any *side effects*. Let's not linger and just start noodling! First we define some functions to use. @@ -28,7 +28,7 @@ Now we can create a workflow composing several calls to this function. c = add(a, a) d = mul(b, c) -That looks easy enough; the funny thing is though, that nothing has been computed yet! Noodles just created the workflow graphs corresponding to the values that still need to be computed. Until such time, we work with the *promise* of a future value. Using the module ``pygraphviz`` (`pip install pygraphviz`, check `this post `_ if you have problems installing pygraphviz) we can look at the call graphs. +**That looks easy enough; the funny thing is though, that nothing has been computed yet! Noodles just created the workflow graphs corresponding to the values that still need to be computed. Until such time, we work with the *promise* of a future value. Using the module ``pygraphviz`` (`pip install pygraphviz`, check `this post `_ if you have problems installing pygraphviz) we can look at the call graphs.** .. code:: python From 4c35da67e45ee3be604641a73022584db7401fbb Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Mon, 18 Sep 2017 16:18:39 +0200 Subject: [PATCH 110/155] fix 7: syntax typos in hyperlink --- doc/source/first_steps.rst | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/doc/source/first_steps.rst b/doc/source/first_steps.rst index 566dd06..928fbf2 100644 --- a/doc/source/first_steps.rst +++ b/doc/source/first_steps.rst @@ -1,8 +1,7 @@ First Steps =========== -**This tutorial is also available in the form of a `Jupyter Notebook `_. -Try it out, and play!** +This tutorial is also available in the form of a `Jupyter Notebook `_. Try it out, and play! Noodles is there to make your life easier, *in parallel*! The reason why Noodles can be easy and do parallel Python at the same time is its *functional* approach. In one part you'll define a set of functions that you'd like to run with Noodles, in an other part you'll compose these functions into a *workflow graph*. To make this approach work a function should not have any *side effects*. Let's not linger and just start noodling! First we define some functions to use. @@ -28,7 +27,7 @@ Now we can create a workflow composing several calls to this function. c = add(a, a) d = mul(b, c) -**That looks easy enough; the funny thing is though, that nothing has been computed yet! Noodles just created the workflow graphs corresponding to the values that still need to be computed. Until such time, we work with the *promise* of a future value. Using the module ``pygraphviz`` (`pip install pygraphviz`, check `this post `_ if you have problems installing pygraphviz) we can look at the call graphs.** +That looks easy enough; the funny thing is though, that nothing has been computed yet! Noodles just created the workflow graphs corresponding to the values that still need to be computed. Until such time, we work with the *promise* of a future value. Using the module ``pygraphviz`` (`pip install pygraphviz`, check `this post `_ if you have problems installing pygraphviz) we can look at the call graphs. .. code:: python From 7ea31ae616f532dc7c5e52f84a27a68cd8168d54 Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Mon, 18 Sep 2017 16:24:08 +0200 Subject: [PATCH 111/155] fix 8: syntax typos in hyperlink --- doc/source/first_steps.rst | 3 +++ 1 file changed, 3 insertions(+) diff --git a/doc/source/first_steps.rst b/doc/source/first_steps.rst index 928fbf2..0ffb948 100644 --- a/doc/source/first_steps.rst +++ b/doc/source/first_steps.rst @@ -3,6 +3,9 @@ First Steps This tutorial is also available in the form of a `Jupyter Notebook `_. Try it out, and play! +|Jupyter Notebook |_ +|bobob `Jupyter Notebook `_ ooboboub |_ + Noodles is there to make your life easier, *in parallel*! The reason why Noodles can be easy and do parallel Python at the same time is its *functional* approach. In one part you'll define a set of functions that you'd like to run with Noodles, in an other part you'll compose these functions into a *workflow graph*. To make this approach work a function should not have any *side effects*. Let's not linger and just start noodling! First we define some functions to use. From bad81bf760032a34f456f193cbe1773f4fec4169 Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Mon, 18 Sep 2017 16:27:27 +0200 Subject: [PATCH 112/155] fix 9: syntax typos in hyperlink --- doc/source/first_steps.rst | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/doc/source/first_steps.rst b/doc/source/first_steps.rst index 0ffb948..1448d8e 100644 --- a/doc/source/first_steps.rst +++ b/doc/source/first_steps.rst @@ -1,10 +1,7 @@ First Steps =========== -This tutorial is also available in the form of a `Jupyter Notebook `_. Try it out, and play! - -|Jupyter Notebook |_ -|bobob `Jupyter Notebook `_ ooboboub |_ +**This tutorial is also available in the form of a** `Jupyter Notebook `_. **Try it out, and play!** Noodles is there to make your life easier, *in parallel*! The reason why Noodles can be easy and do parallel Python at the same time is its *functional* approach. In one part you'll define a set of functions that you'd like to run with Noodles, in an other part you'll compose these functions into a *workflow graph*. To make this approach work a function should not have any *side effects*. Let's not linger and just start noodling! First we define some functions to use. From d9e0fe016995f4ed4e4c8150d5d20421c39fb890 Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Mon, 18 Sep 2017 16:36:29 +0200 Subject: [PATCH 113/155] nbsphinx added to conf.py extensions and notebook added to toc in index.rst --- doc/source/conf.py | 1 + doc/source/index.rst | 2 ++ 2 files changed, 3 insertions(+) diff --git a/doc/source/conf.py b/doc/source/conf.py index fa5c8b2..2505713 100644 --- a/doc/source/conf.py +++ b/doc/source/conf.py @@ -45,6 +45,7 @@ 'sphinx.ext.todo', 'sphinx.ext.coverage', 'sphinx.ext.mathjax', + 'nbsphinx', ] # Add any paths that contain templates here, relative to this directory. diff --git a/doc/source/index.rst b/doc/source/index.rst index 12fe19d..2320999 100644 --- a/doc/source/index.rst +++ b/doc/source/index.rst @@ -71,6 +71,8 @@ Documentation Contents development scheduler brokers + An interactive introduction.ipynb + Indices and tables ================== From 5c39745e0a1a6a6226d8412d44699cfd1c8f85e0 Mon Sep 17 00:00:00 2001 From: Lars Ridder Date: Mon, 18 Sep 2017 23:08:01 +0200 Subject: [PATCH 114/155] Adding cross-references in eating.rst (#63) --- doc/source/eating.rst | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/doc/source/eating.rst b/doc/source/eating.rst index c73f6e4..ad802fe 100644 --- a/doc/source/eating.rst +++ b/doc/source/eating.rst @@ -26,8 +26,8 @@ Let's look at a small example of creating a diamond workflow, which consists of print("The answer is {0}.".format(answer)) -That allmost looks like normal Python! The only difference is the ``run_single`` statement at the end of this program. -The catch is that none of the computation is actually done until the ``run_single`` statement has been given. +That allmost looks like normal Python! The only difference is the :py:func:`~noodles.run_single` statement at the end of this program. +The catch is that none of the computation is actually done until the :py:func:`~noodles.run_single` statement has been given. The variables ``u``, ``v``, ``w``, and ``x`` only represent the *promise* of a value. The functions that we imported are wrapped, such that they construct the directed acyclic graph of the computation in stead of just computing the result immediately. This DAG then looks like this: @@ -73,10 +73,10 @@ However, you should be aware of what happens behind the curtains, to understand ... -The ``@schedule`` decorators takes care that the functions actually return *promises* instead of values. -Such a ``PromisedObject`` is a placeholder for the expected result. +The :py:func:`@schedule ` decorators takes care that the functions actually return *promises* instead of values. +Such a :py:class:`~noodles.interface.PromisedObject` is a placeholder for the expected result. It stores the workflow graph that is needed to compute the promise. -When another `schedule`-decorated function is called with a promise, the graphs of the dependencies are merged to create a new workflow graph. +When another :py:func:`schedule `-decorated function is called with a promise, the graphs of the dependencies are merged to create a new workflow graph. .. NOTE:: The promised object can be of any type and can be used as a normal object. You access attributes and functions of the object that is promised as you normally would. @@ -119,11 +119,11 @@ This time the workflow graph will look a bit more complicated. The workflow graph of the second example. Here we see how a user can define normal python functions and use them to build a larger workflow. -Furthermore, we introduce a new bit of magic: the ``gather`` function. +Furthermore, we introduce a new bit of magic: the :py:func:`gather ` function. When you build a list of computations using a list-comprehension like above, you essentially store a *list of promises* in variable ``w``. However, schedule-decorated functions cannot easily see which arguments contain promised values, such as ``w``, and which arguments are plain Python. -The ``gather`` function converts the list of promises into a promise of a list, making it clear to the scheduled function this argument is a promise. -The ``gather`` function is defined as follows: +The :py:func:`gather ` function converts the list of promises into a promise of a list, making it clear to the scheduled function this argument is a promise. +The :py:func:`gather ` function is defined as follows: :: @@ -133,7 +133,7 @@ The ``gather`` function is defined as follows: By unpacking the list (by doing ``gather(*w)``) in the call to gather, each item in ``w`` becomes a dependency of the ``gather`` node in this workflow, as we can see in the figure above. -To make use of the parallelism in this workflow, we run it with ``run_parallel``. +To make use of the parallelism in this workflow, we run it with :py:func:`~noodles.run_parallel`. This runner function creates a specified number of threads, each taking jobs from the Noodles scheduler and returning results. Running workflows @@ -141,21 +141,21 @@ Running workflows Noodles ships with a few ready-made functions that run the workflow for you, depending on the amount of work that needs to be done. -``run_single``, local single thread -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +:py:func:`~noodles.run_single`, local single thread +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Runs your workflow in the same thread as the caller. This function is mainly for testing. When running workflows you almost always want to use one of the other functions. -``run_parallel``, local multi-thread -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +:py:func:`~noodles.run_parallel`, local multi-thread +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Runs your workflow in parallel using any number of threads. Usually, specifying the number of cores in your CPU will give optimal performance for this runner. .. NOTE:: If you are very **very** certain that your workflow will never need to scale to cluster-computing, this runner is more lenient on the kinds of Python that is supported, because function arguments are not converted to and from JSON. Think of nested functions, lambda forms, generators, etc. -``run_process``, local multi-process -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +:py:func:`~noodles.run_process`, local multi-process +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Starts a second process to run jobs. This is usefull for testing the JSON compatability of your workflow on your own machine. Xenon From 8a00c5ae940d5f9023ceb1e1353558bf2ed1f97d Mon Sep 17 00:00:00 2001 From: Hanno Spreeuw Date: Tue, 19 Sep 2017 11:55:59 +0200 Subject: [PATCH 115/155] Fixed spelling error --- doc/source/eating.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/source/eating.rst b/doc/source/eating.rst index c73f6e4..7a4e1d7 100644 --- a/doc/source/eating.rst +++ b/doc/source/eating.rst @@ -26,7 +26,7 @@ Let's look at a small example of creating a diamond workflow, which consists of print("The answer is {0}.".format(answer)) -That allmost looks like normal Python! The only difference is the ``run_single`` statement at the end of this program. +That almost looks like normal Python! The only difference is the ``run_single`` statement at the end of this program. The catch is that none of the computation is actually done until the ``run_single`` statement has been given. The variables ``u``, ``v``, ``w``, and ``x`` only represent the *promise* of a value. The functions that we imported are wrapped, such that they construct the directed acyclic graph of the computation in stead of just computing the result immediately. From b465d0781f6c63ec039f9c10cd6097a095dd21d3 Mon Sep 17 00:00:00 2001 From: Ben van Werkhoven Date: Tue, 19 Sep 2017 12:05:03 +0200 Subject: [PATCH 116/155] add skiptest when msgpack not installed and test without it --- test/test_capture_output.py | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/test/test_capture_output.py b/test/test_capture_output.py index ca3167b..b5b380b 100644 --- a/test/test_capture_output.py +++ b/test/test_capture_output.py @@ -1,13 +1,25 @@ +import pytest + from noodles import run_process, schedule, serial +try: + import msgpack # noqa + has_msgpack = True +except ImportError: + has_msgpack = False @schedule def writes_to_stdout(): print("Hello Noodles!") return 42 - +@pytest.mark.skipif(not has_msgpack, reason="msgpack needed.") def test_capture_output(): a = writes_to_stdout() result = run_process(a, n_processes=1, registry=serial.base, use_msgpack=True) assert result == 42 + +def test_capture_output_nomsgpack(): + a = writes_to_stdout() + result = run_process(a, n_processes=1, registry=serial.base, use_msgpack=False) + assert result == 42 From 71f26ba3a18f82547474cf0852584633d519f2fd Mon Sep 17 00:00:00 2001 From: Hanno Spreeuw Date: Tue, 19 Sep 2017 14:40:25 +0200 Subject: [PATCH 117/155] Some background on the exceptions occurring when inspecting built-in functions. --- doc/source/poetry_tutorial.rst | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/doc/source/poetry_tutorial.rst b/doc/source/poetry_tutorial.rst index 534b91d..057c6fd 100644 --- a/doc/source/poetry_tutorial.rst +++ b/doc/source/poetry_tutorial.rst @@ -195,9 +195,9 @@ We could write in the last line of the ``sentence`` method, but the string format method doesn't support wrapping. We rely on getting the signature of a -function by calling ``inspect.signature``. In some cases of build-in -function this raises an exception. Note that this is a design flaw in Python, -not Noodles! We may find a work around for these cases in future versions of +function by calling ``inspect.signature``. When the built-in +function is implemented in C, this raises `exception `_. +We may find a work around for these cases in future versions of Noodles. For the moment we'll have to define a little wrapper function. .. code:: python From 31d786635e4efb501acd7514fda4fffaa8258ca4 Mon Sep 17 00:00:00 2001 From: Hanno Spreeuw Date: Tue, 19 Sep 2017 14:41:36 +0200 Subject: [PATCH 118/155] Adden 'an' --- doc/source/poetry_tutorial.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/source/poetry_tutorial.rst b/doc/source/poetry_tutorial.rst index 057c6fd..81b203c 100644 --- a/doc/source/poetry_tutorial.rst +++ b/doc/source/poetry_tutorial.rst @@ -196,7 +196,7 @@ We could write in the last line of the ``sentence`` method, but the string format method doesn't support wrapping. We rely on getting the signature of a function by calling ``inspect.signature``. When the built-in -function is implemented in C, this raises `exception `_. +function is implemented in C, this raises an `exception `_. We may find a work around for these cases in future versions of Noodles. For the moment we'll have to define a little wrapper function. From aa1b3ba043a1e263666996bf392b6fdc1b7f32de Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Tue, 19 Sep 2017 14:51:58 +0200 Subject: [PATCH 119/155] sphinx notebook link added --- doc/source/conf.py | 1 + doc/source/index.rst | 24 ++++++++++++------------ 2 files changed, 13 insertions(+), 12 deletions(-) diff --git a/doc/source/conf.py b/doc/source/conf.py index 2505713..a7348d1 100644 --- a/doc/source/conf.py +++ b/doc/source/conf.py @@ -46,6 +46,7 @@ 'sphinx.ext.coverage', 'sphinx.ext.mathjax', 'nbsphinx', + 'IPython.sphinxext.ipython_console_highlighting' ] # Add any paths that contain templates here, relative to this directory. diff --git a/doc/source/index.rst b/doc/source/index.rst index 2320999..16043c9 100644 --- a/doc/source/index.rst +++ b/doc/source/index.rst @@ -60,18 +60,18 @@ Documentation Contents ====================== .. toctree:: - :maxdepth: 2 - - Introduction - eating - cooking - first_steps - poetry_tutorial - boil_tutorial - development - scheduler - brokers - An interactive introduction.ipynb + :maxdepth: 2 + + Introduction + eating + cooking + first_steps + poetry_tutorial + boil_tutorial + development + scheduler + brokers + An_interactive_introduction Indices and tables From 9d3eb202b06bf19b1b9527ece92e51bce68436d8 Mon Sep 17 00:00:00 2001 From: Ben van Werkhoven Date: Tue, 19 Sep 2017 17:15:40 +0200 Subject: [PATCH 120/155] converted first steps and poetry tutorial to notebook --- doc/source/conf.py | 1 + doc/source/first_steps.ipynb | 1 + doc/source/index.rst | 4 +- doc/source/poetry_tutorial.ipynb | 1 + doc/source/wf1-series.png | 1 + noodles/tutorial.py | 39 +- notebooks/first_steps.ipynb | 133 +++++ notebooks/poetry_tutorial.ipynb | 902 +++++++++++++++++++++++++++++++ notebooks/wf1-series.png | Bin 13092 -> 12811 bytes 9 files changed, 1077 insertions(+), 5 deletions(-) create mode 120000 doc/source/first_steps.ipynb create mode 120000 doc/source/poetry_tutorial.ipynb create mode 120000 doc/source/wf1-series.png create mode 100644 notebooks/first_steps.ipynb create mode 100644 notebooks/poetry_tutorial.ipynb diff --git a/doc/source/conf.py b/doc/source/conf.py index fa5c8b2..f7bb7c7 100644 --- a/doc/source/conf.py +++ b/doc/source/conf.py @@ -41,6 +41,7 @@ # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # ones. extensions = [ + 'nbsphinx', 'sphinx.ext.autodoc', 'sphinx.ext.todo', 'sphinx.ext.coverage', diff --git a/doc/source/first_steps.ipynb b/doc/source/first_steps.ipynb new file mode 120000 index 0000000..df50a8e --- /dev/null +++ b/doc/source/first_steps.ipynb @@ -0,0 +1 @@ +../../notebooks/first_steps.ipynb \ No newline at end of file diff --git a/doc/source/index.rst b/doc/source/index.rst index 6cae8fc..dd1c24d 100644 --- a/doc/source/index.rst +++ b/doc/source/index.rst @@ -65,8 +65,8 @@ Documentation Contents Introduction eating cooking - first_steps - poetry_tutorial + first_steps.ipynb + poetry_tutorial.ipynb boil_tutorial development scheduler diff --git a/doc/source/poetry_tutorial.ipynb b/doc/source/poetry_tutorial.ipynb new file mode 120000 index 0000000..05023fd --- /dev/null +++ b/doc/source/poetry_tutorial.ipynb @@ -0,0 +1 @@ +../../notebooks/poetry_tutorial.ipynb \ No newline at end of file diff --git a/doc/source/wf1-series.png b/doc/source/wf1-series.png new file mode 120000 index 0000000..e8cf9f4 --- /dev/null +++ b/doc/source/wf1-series.png @@ -0,0 +1 @@ +../../notebooks/wf1-series.png \ No newline at end of file diff --git a/noodles/tutorial.py b/noodles/tutorial.py index e493b69..e16b7b1 100644 --- a/noodles/tutorial.py +++ b/noodles/tutorial.py @@ -1,21 +1,22 @@ +from inspect import Parameter +from graphviz import Digraph + from . import schedule, schedule_hint +#scheduled functions @schedule def add(x, y): return x + y - @schedule_hint(display="{a} + {b}", confirm=True) def log_add(a, b): return a + b - @schedule def sub(x, y): return x - y - @schedule def mul(x, y): return x*y @@ -24,3 +25,35 @@ def mul(x, y): @schedule def accumulate(lst, start=0): return sum(lst, start) + +#functions for printing workflow graphs in notebooks + +def _format_arg_list(a, v): + if len(a) == 0: + if v: + return "(\u2026)" + else: + return "()" + + s = "(" + for i in a[:-1]: + s += str(i) if i != Parameter.empty else "\u2014" + s += ", " + + if v: + s += "\u2014" + else: + s += str(a[-1]) if a[-1] != Parameter.empty else "\u2014" + + s += ")" + return s + +def get_workflow_graph(workflow): + dot = Digraph() + for i,n in workflow.nodes.items(): + dot.node(str(i), label="{0} \n {1}".format(n.foo.__name__, + _format_arg_list(n.bound_args.args, None))) + for i in workflow.links: + for j in workflow.links[i]: + dot.edge(str(i), str(j[0]), label=str(j[1].name)) + return dot diff --git a/notebooks/first_steps.ipynb b/notebooks/first_steps.ipynb new file mode 100644 index 0000000..ea9d4ef --- /dev/null +++ b/notebooks/first_steps.ipynb @@ -0,0 +1,133 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# First Steps\n", + "\n", + "**This tutorial is also available in the form of a Jupyter Notebook. Try it out, and play!**\n", + "\n", + "Noodles is there to make your life easier, *in parallel*! The reason why Noodles can be easy and do parallel Python at the same time is its *functional* approach. In one part you'll define a set of functions that you'd like to run with Noodles, in an other part you'll compose these functions into a *workflow graph*. To make this approach work a function should not have any *side effects*. Let's not linger and just start noodling! First we define some functions to use." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "from noodles import schedule\n", + "\n", + "@schedule\n", + "def add(x, y):\n", + " return x + y\n", + "\n", + "@schedule\n", + "def mul(x,y):\n", + " return x * y" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can create a workflow composing several calls to this function." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "a = add(1, 1)\n", + "b = mul(a, 2)\n", + "c = add(a, a)\n", + "d = mul(b, c)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That looks easy enough; the funny thing is though, that nothing has been computed yet! Noodles just created the workflow graphs corresponding to the values that still need to be computed. Until such time, we work with the *promise* of a future value. Using some function in `pygraphviz` we can look at the call graphs." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "from draw_workflow import draw_workflow\n", + "import sys\n", + "import os\n", + "\n", + "draw_workflow(\"wf1a.png\", a._workflow)\n", + "draw_workflow(\"wf1b.png\", b._workflow)\n", + "draw_workflow(\"wf1c.png\", c._workflow)\n", + "draw_workflow(\"wf1d.png\", d._workflow)\n", + "\n", + "err = os.system(\"montage wf1?.png -tile 4x1 -geometry +10+0 wf1-series.png\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![callgraph](wf1-series.png)\n", + "Now, to compute the result we have to tell Noodles to evaluate the program." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "16" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from noodles import run_parallel, run_single\n", + "\n", + "run_parallel(d, n_threads=2)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.5.2" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/notebooks/poetry_tutorial.ipynb b/notebooks/poetry_tutorial.ipynb new file mode 100644 index 0000000..7fb797a --- /dev/null +++ b/notebooks/poetry_tutorial.ipynb @@ -0,0 +1,902 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Real World Tutorial 1: Translating Poetry\n", + "=========================================\n", + "\n", + "First example\n", + "-------------\n", + "\n", + "We build workflows by calling functions. The simplest example of this\n", + "is the \"diamond workflow\":" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The answer is 42.\n" + ] + } + ], + "source": [ + "from noodles import run_single\n", + "from noodles.tutorial import (add, sub, mul)\n", + "\n", + "u = add(5, 4)\n", + "v = sub(u, 3)\n", + "w = sub(u, 2)\n", + "x = mul(v, w)\n", + "\n", + "answer = run_single(x)\n", + "\n", + "print(\"The answer is {0}.\".format(answer))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That looks like any other Python code! But this example is a bit silly.\n", + "How do we leverage Noodles to earn an honest living? Here's a slightly less\n", + "silly example (but only just!). We will build a small translation engine\n", + "that translates sentences by submitting each word to an online dictionary\n", + "over a Rest API. To do this we make loops (\"For thou shalt make loops of \n", + "blue\"). First we build the program as you would do in Python, then we\n", + "sprinkle some Noodles magic and make it work parallel! Furthermore, we'll\n", + "see how to:\n", + "\n", + " * make more loops\n", + " * cache results for reuse" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Making loops\n", + "\n", + "Thats all swell, but how do we make a parallel loop? Let's look at a `map` operation; in Python there are several ways to perform a function on all elements in an array. For this example, we will translate some words using the Glosbe service, which has a nice REST interface. We first build some functionality to use this interface." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import urllib.request\n", + "import json\n", + "import re\n", + "\n", + "\n", + "class Translate:\n", + " \"\"\"Translate words and sentences in the worst possible way. The Glosbe dictionary\n", + " has a nice REST interface that we query for a phrase. We then take the first result.\n", + " To translate a sentence, we cut it in pieces, translate it and paste it back into\n", + " a Frankenstein monster.\"\"\"\n", + " def __init__(self, src_lang='en', tgt_lang='fy'):\n", + " self.src = src_lang\n", + " self.tgt = tgt_lang\n", + " self.url = 'https://glosbe.com/gapi/translate?' \\\n", + " 'from={src}&dest={tgt}&' \\\n", + " 'phrase={{phrase}}&format=json'.format(\n", + " src=src_lang, tgt=tgt_lang)\n", + " \n", + " def query_phrase(self, phrase):\n", + " with urllib.request.urlopen(self.url.format(phrase=phrase.lower())) as response:\n", + " translation = json.loads(response.read().decode())\n", + " return translation\n", + "\n", + " def word(self, phrase):\n", + " translation = self.query_phrase(phrase)\n", + " #translation = {'tuc': [{'phrase': {'text': phrase.lower()[::-1]}}]}\n", + " if len(translation['tuc']) > 0 and 'phrase' in translation['tuc'][0]:\n", + " result = translation['tuc'][0]['phrase']['text']\n", + " if phrase[0].isupper():\n", + " return result.title()\n", + " else:\n", + " return result \n", + " else:\n", + " return \"<\" + phrase + \">\"\n", + " \n", + " def sentence(self, phrase):\n", + " words = re.sub(\"[^\\w]\", \" \", phrase).split()\n", + " space = re.sub(\"[\\w]+\", \"{}\", phrase)\n", + " return space.format(*map(self.word, words))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We start with a list of strings that desparately need translation. And add a little\n", + "routine to print it in a gracious manner." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Original:\n", + " If music be the food of love, play on,\n", + " Give me excess of it; that surfeiting,\n", + " The appetite may sicken, and so die.\n", + "\n" + ] + } + ], + "source": [ + "shakespeare = [\n", + " \"If music be the food of love, play on,\",\n", + " \"Give me excess of it; that surfeiting,\",\n", + " \"The appetite may sicken, and so die.\"]\n", + "\n", + "def print_poem(intro, poem):\n", + " print(intro)\n", + " for line in poem:\n", + " print(\" \", line)\n", + " print()\n", + "\n", + "print_poem(\"Original:\", shakespeare)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Beginning Python programmers like to append things; this is not how you are\n", + "supposed to program in Python; if you do, please go and read Jeff Knupp's *Writing Idiomatic Python*." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Auf Deutsch:\n", + " Wenn Musik sein der Essen von Minne, spielen an,\n", + " Geben ich Übermaß von es; das übersättigend,\n", + " Der Appetit dürfen erkranken, und so sterben.\n", + "\n" + ] + } + ], + "source": [ + "shakespeare_auf_deutsch = []\n", + "for line in shakespeare:\n", + " shakespeare_auf_deutsch.append(\n", + " Translate('en', 'de').sentence(line))\n", + "print_poem(\"Auf Deutsch:\", shakespeare_auf_deutsch)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Rather use a comprehension like so:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Yn it Frysk:\n", + " At muzyk wêze de fiedsel fan leafde, boartsje oan,\n", + " Jaan by fersin fan it; dat ,\n", + " De maaie , en dus deagean.\n", + "\n" + ] + } + ], + "source": [ + "shakespeare_ynt_frysk = \\\n", + " (Translate('en', 'fy').sentence(line) for line in shakespeare)\n", + "print_poem(\"Yn it Frysk:\", shakespeare_ynt_frysk)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Or use `map`:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "På Dansk:\n", + " Hvis musik være de mad af kærlighed, spil på,\n", + " Give mig udskejelser af det; som ,\n", + " De appetit må , og så dø.\n", + "\n" + ] + } + ], + "source": [ + "shakespeare_pa_dansk = \\\n", + " map(Translate('en', 'da').sentence, shakespeare)\n", + "print_poem(\"På Dansk:\", shakespeare_pa_dansk)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Noodlify!\n", + "If your connection is a bit slow, you may find that the translations take a while to process. Wouldn't it be nice to do it in parallel? How much code would we have to change to get there in Noodles? Let's take the slow part of the program and add a `@schedule` decorator, and run! Sadly, it is not that simple. We can add `@schedule` to the `word` method. This means that it will return a promise. \n", + "\n", + "* Rule: *Functions that take promises need to be scheduled functions, or refer to a scheduled function at some level.* \n", + "\n", + "We could write\n", + "\n", + " return schedule(space.format)(*(self.word(w) for w in words))\n", + " \n", + "in the last line of the `sentence` method, but the string format method doesn't support wrapping. We rely on getting the signature of a function by calling `inspect.signature`. In some cases of build-in function this raises an exception. We may find a work around for these cases in future versions of Noodles. For the moment we'll have to define a little wrapper function." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "from noodles import schedule\n", + "\n", + "\n", + "@schedule\n", + "def format_string(s, *args, **kwargs):\n", + " return s.format(*args, **kwargs)\n", + "\n", + "\n", + "import urllib.request\n", + "import json\n", + "import re\n", + "\n", + "\n", + "class Translate:\n", + " \"\"\"Translate words and sentences in the worst possible way. The Glosbe dictionary\n", + " has a nice REST interface that we query for a phrase. We then take the first result.\n", + " To translate a sentence, we cut it in pieces, translate it and paste it back into\n", + " a Frankenstein monster.\"\"\"\n", + " def __init__(self, src_lang='en', tgt_lang='fy'):\n", + " self.src = src_lang\n", + " self.tgt = tgt_lang\n", + " self.url = 'https://glosbe.com/gapi/translate?' \\\n", + " 'from={src}&dest={tgt}&' \\\n", + " 'phrase={{phrase}}&format=json'.format(\n", + " src=src_lang, tgt=tgt_lang)\n", + " \n", + " def query_phrase(self, phrase):\n", + " with urllib.request.urlopen(self.url.format(phrase=phrase.lower())) as response:\n", + " translation = json.loads(response.read().decode())\n", + " return translation\n", + " \n", + " @schedule\n", + " def word(self, phrase):\n", + " #translation = {'tuc': [{'phrase': {'text': phrase.lower()[::-1]}}]}\n", + " translation = self.query_phrase(phrase)\n", + " \n", + " if len(translation['tuc']) > 0 and 'phrase' in translation['tuc'][0]:\n", + " result = translation['tuc'][0]['phrase']['text']\n", + " if phrase[0].isupper():\n", + " return result.title()\n", + " else:\n", + " return result \n", + " else:\n", + " return \"<\" + phrase + \">\"\n", + " \n", + " def sentence(self, phrase):\n", + " words = re.sub(\"[^\\w]\", \" \", phrase).split()\n", + " space = re.sub(\"[\\w]+\", \"{}\", phrase)\n", + " return format_string(space, *map(self.word, words))\n", + " \n", + " def __str__(self):\n", + " return \"[{} -> {}]\".format(self.src, self.tgt)\n", + " \n", + " def __serialize__(self, pack):\n", + " return pack({'src_lang': self.src,\n", + " 'tgt_lang': self.tgt})\n", + "\n", + " @classmethod\n", + " def __construct__(cls, msg):\n", + " return cls(**msg)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's take stock of the mutations to the original. We've added a `@schedule` decorator to `word`, and changed a function call in `sentence`. Also we added the `__str__` method; this is only needed to plot the workflow graph. Let's run the new script." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Shakespeare en Esperanto:\n", + " Se muziko esti la manĝaĵo de ami, ludi sur,\n", + " Doni mi eksceso de ĝi; ke ,\n", + " La apetito povi naŭzi, kaj tiel morti.\n", + "\n" + ] + } + ], + "source": [ + "from noodles import gather, run_parallel\n", + "from noodles.tutorial import get_workflow_graph\n", + "\n", + "shakespeare_en_esperanto = \\\n", + " map(Translate('en', 'eo').sentence, shakespeare)\n", + "\n", + "wf = gather(*shakespeare_en_esperanto)\n", + "workflow_graph = get_workflow_graph(wf._workflow)\n", + "result = run_parallel(wf, n_threads=8)\n", + "print_poem(\"Shakespeare en Esperanto:\", result)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The last peculiar thing that you may notice, is the `gather` function. It collects the promises that `map` generates and creates a single new promise. The definition of `gather` is very simple:\n", + " \n", + " @schedule\n", + " def gather(*lst):\n", + " return lst\n", + "\n", + "The workflow graph of the Esperanto translator script looks like this:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "%3\n", + "\n", + "\n", + "140504116175424\n", + "\n", + "word \n", + " ([en -> eo], excess)\n", + "\n", + "\n", + "140504104094632\n", + "\n", + "format_string \n", + " ({} {} {} {} {}; {} {},, —, —, —, —, —, —, —)\n", + "\n", + "\n", + "140504116175424->140504104094632\n", + "\n", + "\n", + "args\n", + "\n", + "\n", + "140504104093344\n", + "\n", + "word \n", + " ([en -> eo], music)\n", + "\n", + "\n", + "140504104092784\n", + "\n", + "format_string \n", + " ({} {} {} {} {} {} {}, {} {},, —, —, —, —, —, —, —, —, —)\n", + "\n", + "\n", + "140504104093344->140504104092784\n", + "\n", + "\n", + "args\n", + "\n", + "\n", + "140504116176264\n", + "\n", + "gather \n", + " (—, —, —)\n", + "\n", + "\n", + "140504116174976\n", + "\n", + "word \n", + " ([en -> eo], that)\n", + "\n", + "\n", + "140504116174976->140504104094632\n", + "\n", + "\n", + "args\n", + "\n", + "\n", + "140504116175592\n", + "\n", + "word \n", + " ([en -> eo], may)\n", + "\n", + "\n", + "140504116177440\n", + "\n", + "format_string \n", + " ({} {} {} {}, {} {} {}., —, —, —, —, —, —, —)\n", + "\n", + "\n", + "140504116175592->140504116177440\n", + "\n", + "\n", + "args\n", + "\n", + "\n", + "140504125357136\n", + "\n", + "word \n", + " ([en -> eo], love)\n", + "\n", + "\n", + "140504125357136->140504104092784\n", + "\n", + "\n", + "args\n", + "\n", + "\n", + "140504125357752\n", + "\n", + "word \n", + " ([en -> eo], me)\n", + "\n", + "\n", + "140504125357752->140504104094632\n", + "\n", + "\n", + "args\n", + "\n", + "\n", + "140504104094632->140504116176264\n", + "\n", + "\n", + "a\n", + "\n", + "\n", + "140504116175816\n", + "\n", + "word \n", + " ([en -> eo], surfeiting)\n", + "\n", + "\n", + "140504116175816->140504104094632\n", + "\n", + "\n", + "args\n", + "\n", + "\n", + "140504125357584\n", + "\n", + "word \n", + " ([en -> eo], Give)\n", + "\n", + "\n", + "140504125357584->140504104094632\n", + "\n", + "\n", + "args\n", + "\n", + "\n", + "140504116177440->140504116176264\n", + "\n", + "\n", + "a\n", + "\n", + "\n", + "140504125356184\n", + "\n", + "word \n", + " ([en -> eo], food)\n", + "\n", + "\n", + "140504125356184->140504104092784\n", + "\n", + "\n", + "args\n", + "\n", + "\n", + "140504125355680\n", + "\n", + "word \n", + " ([en -> eo], play)\n", + "\n", + "\n", + "140504125355680->140504104092784\n", + "\n", + "\n", + "args\n", + "\n", + "\n", + "140504104092784->140504116176264\n", + "\n", + "\n", + "a\n", + "\n", + "\n", + "140504116078856\n", + "\n", + "word \n", + " ([en -> eo], so)\n", + "\n", + "\n", + "140504116078856->140504116177440\n", + "\n", + "\n", + "args\n", + "\n", + "\n", + "140504104093736\n", + "\n", + "word \n", + " ([en -> eo], be)\n", + "\n", + "\n", + "140504104093736->140504104092784\n", + "\n", + "\n", + "args\n", + "\n", + "\n", + "140504116176096\n", + "\n", + "word \n", + " ([en -> eo], The)\n", + "\n", + "\n", + "140504116176096->140504116177440\n", + "\n", + "\n", + "args\n", + "\n", + "\n", + "140504116175088\n", + "\n", + "word \n", + " ([en -> eo], of)\n", + "\n", + "\n", + "140504116175088->140504104094632\n", + "\n", + "\n", + "args\n", + "\n", + "\n", + "140504104093288\n", + "\n", + "word \n", + " ([en -> eo], the)\n", + "\n", + "\n", + "140504104093288->140504104092784\n", + "\n", + "\n", + "args\n", + "\n", + "\n", + "140504116080200\n", + "\n", + "word \n", + " ([en -> eo], sicken)\n", + "\n", + "\n", + "140504116080200->140504116177440\n", + "\n", + "\n", + "args\n", + "\n", + "\n", + "140504116079640\n", + "\n", + "word \n", + " ([en -> eo], die)\n", + "\n", + "\n", + "140504116079640->140504116177440\n", + "\n", + "\n", + "args\n", + "\n", + "\n", + "140504116176376\n", + "\n", + "word \n", + " ([en -> eo], it)\n", + "\n", + "\n", + "140504116176376->140504104094632\n", + "\n", + "\n", + "args\n", + "\n", + "\n", + "140504116175704\n", + "\n", + "word \n", + " ([en -> eo], appetite)\n", + "\n", + "\n", + "140504116175704->140504116177440\n", + "\n", + "\n", + "args\n", + "\n", + "\n", + "140504116080256\n", + "\n", + "word \n", + " ([en -> eo], and)\n", + "\n", + "\n", + "140504116080256->140504116177440\n", + "\n", + "\n", + "args\n", + "\n", + "\n", + "140504125355568\n", + "\n", + "word \n", + " ([en -> eo], of)\n", + "\n", + "\n", + "140504125355568->140504104092784\n", + "\n", + "\n", + "args\n", + "\n", + "\n", + "140504125357304\n", + "\n", + "word \n", + " ([en -> eo], on)\n", + "\n", + "\n", + "140504125357304->140504104092784\n", + "\n", + "\n", + "args\n", + "\n", + "\n", + "140504104092952\n", + "\n", + "word \n", + " ([en -> eo], If)\n", + "\n", + "\n", + "140504104092952->140504104092784\n", + "\n", + "\n", + "args\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "workflow_graph.attr(size='10')\n", + "workflow_graph" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Dealing with repetition\n", + "In the following example we have a line with some repetition. It would be a shame to look up the repeated words twice, wouldn't it? Let's build a little counter routine to check if everything is working." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Mon , mon , pourquoi as Tu me quitter?'" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "line = \"Mein Gott, mein Gott, warum hast Du mich verlassen?\"\n", + "run_parallel(Translate('de', 'fr').sentence(line), n_threads=4)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "To see how this program is being run, we monitor the job submission, retrieval and result storage in a `JobKeeper` instance." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Mon , mon , pourquoi as Tu me quitter?'" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from noodles.run.job_keeper import JobKeeper\n", + "from noodles.run.run_with_prov import run_parallel\n", + "from noodles import serial\n", + "\n", + "J = JobKeeper(keep=True)\n", + "wf = Translate('de', 'fr').sentence(line)\n", + "run_parallel(wf,\n", + " n_threads=4, registry=serial.base,\n", + " jobdb_file='matthew.json', job_keeper=J)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can see how the results were obtained by inspecting the\n", + "``JobKeeper`` object. Running the first time, you may see that\n", + "some jobs *attached* themselves to other jobs as they are identical.\n", + "\n", + "Then try running above cell again. All the results should be cached\n", + "in the `matthew.json` file, and no queries are send to Glosbe, saving\n", + "us from certain doom of IP black listing." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2017-09-19T15:01:10Z: [register] - None\n", + "2017-09-19T15:01:10Z: [retrieved] - mon\n", + "-------------------------------------\n", + "2017-09-19T15:01:10Z: [register] - None\n", + "2017-09-19T15:01:10Z: [retrieved] - pourquoi\n", + "-------------------------------------\n", + "2017-09-19T15:01:10Z: [register] - None\n", + "2017-09-19T15:01:10Z: [retrieved] - me\n", + "-------------------------------------\n", + "2017-09-19T15:01:10Z: [register] - None\n", + "2017-09-19T15:01:10Z: [retrieved] - Mon , mon , pourquoi as Tu me quitter?\n", + "-------------------------------------\n", + "2017-09-19T15:01:10Z: [register] - None\n", + "2017-09-19T15:01:10Z: [retrieved] - Tu\n", + "-------------------------------------\n", + "2017-09-19T15:01:10Z: [register] - None\n", + "2017-09-19T15:01:10Z: [retrieved] - Mon\n", + "-------------------------------------\n", + "2017-09-19T15:01:10Z: [register] - None\n", + "2017-09-19T15:01:10Z: [retrieved] - \n", + "-------------------------------------\n", + "2017-09-19T15:01:10Z: [register] - None\n", + "2017-09-19T15:01:10Z: [retrieved] - quitter\n", + "-------------------------------------\n", + "2017-09-19T15:01:10Z: [register] - None\n", + "2017-09-19T15:01:10Z: [retrieved] - \n", + "-------------------------------------\n", + "2017-09-19T15:01:10Z: [register] - None\n", + "2017-09-19T15:01:10Z: [retrieved] - as\n", + "-------------------------------------\n" + ] + } + ], + "source": [ + "from itertools import starmap\n", + "import time\n", + "\n", + "def format_log_entry(tm, what, data, msg):\n", + " return \"{}: {:16} - {}\".format(\n", + " time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime(tm)),\n", + " '[' + what + ']',\n", + " data)\n", + "\n", + "for k,j in J.items():\n", + " print('\\n'.join(starmap(format_log_entry, j.log)))\n", + " print(\"-------------------------------------\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.5.2" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/notebooks/wf1-series.png b/notebooks/wf1-series.png index 0a0146365d9852c9a5e38e189612b77ac6ca4a04..f84466def157d1bace792ba79501610140fe88fb 100644 GIT binary patch literal 12811 zcmYj&WmH^EuSG-@5Dm zn$=xh)w`s3^*VD-)Mq7WbQBU4004k4D1@8j@9v}eV&=>#^NCyB2owHh0grEXgQ+a6# zz*|K8XeV@p=q{@$iMWZ3iwOfG2m>`#6IJRNnrP_ ze?I2c{#=1g!)VLgi{pp(U@BH1b*!C_lf2j(#ZqI!R#HP4xoFlGP4)ifwzYu%cPnr{sDq1J}z#8>J^F131S zDIA9j+7#EmN`t~llY%M8c2<;`3r2GW|}|t zWJ-In9UGFYx8~qi+YklviThf$ElyS?q2ayRPtMLoIISxBCnsOgUYy>DmltC^jsge$ zpPaZ}C)hC@A!*MDs6n3&uitS?x~MboA?XkeWtcWh=u6hcLEk)aXF!BHq70 zXVVz;l$I{4US}|0(^o$+l#9?9%8`QHQ9F8-E9ungvucwIAg|c|FxEgLa=q`ipc8!_ zze>N6)@ALR#Z-n^-W;|vM4^Zi|B0NVwYVP^qAz`Hg*7nZjT`cYp(lUstE+ya)1Idh zDM9#G4ntAY&O~B6%(EU^f2|>~G3hOJu%_#uu{r&_A%DYuCTfZGh z320=m6#fy%8I{;AdsRzZSggrMSWf4tIsweionlsaAhx+d;LmOu>O#-Q`RO!B_uPS= zq^F(QwR)o6TfLz=pWjX{bv3FR0c{P;Mn!5*ScP+p(xEwGLNg&PX2PoJq06#NHWUg8 zZtVU_7Y?R83nv_yXSq)jLh@($tH@BwhO{+fT!HdBR5oOw!h2;>QDGI$7o>mT`68~5 zz9OgIL|gfvX{}+>Mu;|E7B~1iASMjS3U0o866_<1b{en=L%~T<)b5naEmux4A@z!w@a1e z=SyhKW}Lzn@9cwzL%RQP8D-7b-OX};`O6>sd-MkBXae}pqhGY&!jpt&`Sk(1@#9 zAPs06lPYwA=hozD-?!Dp+@2~wq%F(5#7rXi64z_k<7+nojd(sYsc0fD89(9+8TgML?YP7n@IOKIU5DJ!j3DrB_i9YfEjo;0kZU{U}W(jGNNg59c{7d%bg6qxW zK{Meisjg#7T#zZy;vF2BPXiFqvVDV1J`qX{`Us|kO=r-5)qHCM=v&`2y#X3 zcvs-rWg)R}kW|vLryoSzQ zlkwlXcMU1eD;ty5u10&X$2pUd>mZZW_Ws*zH2Q`Xs+BFr3Z||A?m88^wc%gmVEufM zmOMWQPR1-U5%DMw_#$TxC)`Uo{a+c{QrxPDF_0?!Omb@DmuoY63`NWnggK%5_~#Si zs>1n~EP_A`=g}N&$DTj>8l(V3=+V@1mSsG1<{_%X@n}92mcR~gR_*tnKL($8f2~2O}%Nh<~5_lG~0;G$^J~Zd`T;!R)pM{w9XL7ooG=9 zrvCheh*TAS#rQw!u9Y3SSQ8sYFk@Uqg)r-eKEttgnP+~M|3tcf_y?Ij>|b4GF00Ou zPZ^^D=|b9ZmXplhm=qcsjN}dy0#6>&AkbqqZJC!+@5V(W4nf{1OX_d<*M=!W z(%*UVK3yN9Q^ux8PWsiN+8MP&=82&9AA&cS53$p$^}GtKG}l~GloeW+Y@y+L=aMxl z!^`|6F+VnXHd0gie-mLOm)~B2a|70aI^5g z?HOg3ad)giU%+Q@RSenB2nd!j$VKM`GAP&;P# zvh1i#pm?(?|N0j3KZbh_Uv!G@VN#16Xz=!kIjHV@{?h|)m9vIhYbK0ACu#v2`MPfn zzPAWv?;M)j)V`wF%ea#&u~QJ6PPIiS=*)q=GkM4H)eHwrPilR~5Bjfk9%`7Md}K*u zN;e=Z+I4%g8LHdEzA--pNwab~27$JQi(*|Q&KgriU*(M;L^8YtQ2^Jo2spCqC-JGBAgPD{*dfv&K%)7w-_Zk7`)`V!ta z@_vDf)zdiBkYV_X`cv-4|5Vms7B|9zt?3_`P6_ZSaQ0fb7D!SfI zx9Rp4v>W+QnSHJP;1GI1f8UJ0!a3GpoF3el&XpI$F$K3nq8$&nB^zB1qqvh|PD`5>KMG=dVZXhY_boc(Wr6>vle)}sr&oe0%Cs#> z&_{C%Q&IeXzh&y}%*X@<;wT!;y{YC{_n5VaUwI}iiXtKfnwo7A_}lbzpc^bB%+%>~ zjn15_cboZ4eTqkeiC#*x@g>?ZbS{1$Rh%|-9cWCv51~FZM3Yxn#pXH2=OT)Uhn|+a zArggnuu*dyN0x}Qdtwmn{gEXyNyQxxeZzVN283Bf7PyjdNY*{@9|H*wXOuv$S(c1g zINO$mr+%K_)uv##xcoI^I#@|ck#--~&*3M{VWFBu@QwMJKKA%8Z$fSuyxvOF2s1y8 zJ%Xz?V`Hkm;63WK7W=IYklnBj5+4qdj3}pBhi{5nz&h~J6V`tNph8&!rB5Yv56Ug= zCTcl8?!)Zbe^2cj9yzQIUd(iR{HQ5C*a&+PS>cz?^TGy;u>NDC_UOz)$Ti|CzZrhW z_360oMQ%^FW}_#g9O?A4ZPYJJDEY|Cp(k^thfHcPC7kXMXqAa$ys3KWgR$aLiV+D2 zaU4;gonpjcPl?tVBo0|9R%J?9avf=}$t&t0%!W%0HyhqRcE=Fo{tqLNet z&9Nec1^;N0Y>L9em+)tu3}ZKx;9ZwD-3oZqHv#FmrAQxetKyrueCd84%MMs32pZR1 zJl6z^MQ?#ydY2)&@ax0{-<>L~esr136o4Qc;<|eWuI?=mvAc%6k&WL7R zkz7}NTu`4_FlF?{SBU*2_=Nf|4v$D>X(b4LOQBk!HHhGe?`23$G>a)IXWJ*(%p!c+ z{Q(i@(<^I2m{E=YUGYd(rUk>&c2|t`^@yJh47fkaCeZNP31xkw_EGOZF48r^*1UF= zw+#keU3j5ZX1V`b3bkbc>7Nu4%mz2M$vHdrC)SVF_x|NdFN?-eGx~^U>*Y&iN;(*^ zx@UB}{$59%E7aP%1t`y>>*Xyy@Hi5IwCHfRE~-P_(Q}KnGV~#~(eowbPp0C0aZBDB zx1r>sO4XI>_3ne9KZAsdW2k$lCp0A@v)INdx8eo920D@yIq04$GsdJoyhO8KWG3hY zR?s8f*!|w=7_Q^qklSP&*{V7;icTOXuiyb}t0q3#!v{J-V(tunp=iEXRQ`grLU@p@ zLG(a7W<717dX5hTmDS}k4@X*}*L&AX$#&k)hW3N9k)`lU1BikQ0^}Rx^aRj*4sQJ6 zH@?>cqh@phgazYJcwVAHF!w4F8?ddXp*9e?9h=yg22-1QN&BUIpEl3ind|5qAWE-i zRdjC9s@fy^UwiD%P~|=)R1C4J{!ECCj!Z6iprM#$&pf{J0^fINHkL#Q$ja_wK}?PC0` z0kS+6PZ+525oP|;{bb(~1CVlgBw%a1U7M=6ATjZBk@-=vJw;Td;4Pm?ikMbzg<@(5 z4$xY5f*3?WjNk5J=B~bd7rLTR50|H~SBeN9gB6K@*qBb_0na_$g(|+>0Y)IrUooDM z;2|;s+6_He?d3c9a+e+&bYp7^`e{`BIXD_b--}_+>J9CbK)bJK@UpSW7;XOTbrKAN z-PtQdXjJ9w`Wi*gURk0?(!krGrywQAJI6SW7KJDuzRjJkpR;0Y6sUqD8H%g|vV=#> zTn59=mlGkkH=FvrS$Q98JrhZPQ>ZSm?#2lIYbT-t`t*&^>VyAHMyVnPj@4S38*7O- zI+4*=Oc<3bx=TtFsmSs5fUOtcoSCP6jm^Ld!##|#zoQ@`ynn+?2t5&HvKzYJ`7fr+h;J$mt$*-LN(`&*l{pmDM{%vFb`#j6)0Ha zEm%kKepP!J!cfM=S+s2mFZEAI?k2upw_&8V@_|zM z#o!(uFL&%6%TM7ws%kLQTkiCbXI8jP)K4{gayk@-Du{uTOOicS2(X-yU~E+z0cuKe zecpP-q?)x#^v<;BDDDh~x#IWLp-@%BQTk@DE+Et}zDjMiLLf~?>4ZWl>39`FJ9OV( zmgvNDq%59##p#4~<&H?Fj6}tBhS>i1pm3-z>j*J28(?*h(QV6ub3nw0@Ue`WvuFnd z-|$a$lTfN#ulmm{k1T|{3I+BX5Pf#ZwQ}t}eE&b`Ew5C!VD$u4+GP}{7!L11oL6UO z^%R0s@h`dPS4;e;F@JIjzLZirr68VRd+70`L`7ued*WuWC)fikXei?9O|debfwf2B|(H z@!UxDy!_kkU&AQhgJ%R>;9f{P_~v^1mGcaOoI0$Jqa~ipI+`+GNSB5RJ>gf9Tb&%_ zZGTE@7I$c0JUXo1-y3ncLZl%AS5!&C*xk;gq1JtblT(Z6>?LHJMJLAa#n{l0W;8q8 z%Xe83V>Fn@=27)7hve!EnFxO!(|kk=7{A^3nIUb# zKyzGS44N9Q(R2t!{ALddFueARY>!(6IRWX0QSq30U91zsMNKSuI9Pfwb$1bTJNOx}K#)bw~iQY1OJwW^0R zC~!}=WtRtLzaUc!W}!$Ebv)$?K{TIIRH>Dx^Bbo@UcjL0nHC5^XaM5XlWRC^Q7Z3N zpuTIu4MHLQ?(L2`bVib1<$7z>2;v?zmRXI{_l|CA`*sIqVDLrCBJiat*=O^^nYzat zsY9PnK=V~D4(t1affqzPf6*f(Ji+Klsg*RfSmqRG{U^;3Q~t_}`wiq>>sPPo`djfS z4}6;T^nOwrl=id|`TYHVYFQ_+!JO_N{27K$M(|(thCMl216R5D^E_vmG=wM5-q{`XGnTcGK5W0V&!X=va~H(glx4GIQ15s!fXbiC_MsYD{K z78XAPA5pg~;-v`YobsLvy39wRECkz86if<&d0sv~E_-cnZ*xV^&5!+5irtcp*{gC| zcwd`=O8v4&ZjAlOCYOld{y+_b-v%qLWE}

x+I(?R*y_jRxh~cBGvW8X|AO!KV<& z3GDa#x!Xw+2BxQ_>XHDj7-sY0WN>J6cFJbYup<<$bTdYGRD2;I57X`OyVY1lZtNanQsO& zZ_!+4rm_9PPMZbz`QDwV(f=+3QNZDH_cg;{q#r>u0Z#IyD)1}rt+b;ON(YXLG;KM% z>D7sSgZ@$@4|z~pVw_Ke_#$(Frv@fYO#bY=Gj56gezfT_Z#2@NYSXoInST|| zJ6?n?gTG4imL6dkbHzPZI-?Phiewmn%#vz9Sbnpx(npO@Jx{#}K#5Q3b{2`!Rr91w z=;N-y!Nz>D3t$Xv&$Y7Z7s7k?v{Br6TH`k~6FRKhOcniQadw{)^1;E4u1N8z1Rh4x z$ccOd!FIwgCO6sCb??h?YVJVfJ2|z1IOn3n=d<)+M~~g9^JVp+#I|pi8KGb&e;YgA z&y(P~MVJQ9PJYfH)3-~kiV0N@V77wImibg=N4L~$e}Yr}sI1lQgw zO&RgcbuOrfe+>|@9n@D@HaQkH=S{mzjz6@6M^$%mnLa319}pjGEBHu+q}%0h-=_;{ z9TAYW_*x}(gXo&@9=6rPev%SbAnPl^ixawM zyifnR$DVRSc5#kJ-pg#)p!n+wEMIrw3z!qXZxm3-a_=3m3IC8g=Jt(W^DhWV3s_FQ zy+(<+YvMB}`B8C0oTH=iMnS9<(Cu8^R@Vg-PUmCbjya_219-8*>S#e4&QcU} zC>Ql0oia3hE|k`>A5)6RPCOPLZtAgGK`zs4x_va>A@{wsdo6c5N?WBH+n%>c_A>s1 zrQB~~Gsn)1Xcv2kw5?f(7xC?3QOUOg3sPM4){#L+&DHkRaYbOGx$^{T-EoUMU4M$! zvz5h)O`R|imkvjNuTrSXSLQD?M)Wz$S{;)cvhVPp*E@v{J-$%*Y|JH;yXmEPDauhr z<&1b_0IULM5};_fY(r8U8H_QwXC@iY@Uy1IHM$$eR~&OMbV3qlyG{h+kEu>u%3rWQ zE?qcJPa21T?;N7O&h1i$h>Vzq;m1&5_?ujwq`e>{D}HU!8+vLxxd#>esMv>j zr$Z($9xuDOS$Ko@mhj_KyLi>?k`o8!G2T0?r}oKwiVc#8*Le)j?j7@@gfpPcc(4mV z+V!R-LH_yNd0KJ>S?U@?xL?YNh;kJ#OQ$aJ95|2=o4k}qu(}tOJv#wDJ_nA%@j143 zwQp=}77~(&fOpN1Zj>}LIUaWl{uXaY&Ql=}Qj$h=IMl<_>Lsm+ns_2PP(La+35#Ah ztCm6>TuyR=OE+p%Zk3j|!Z`iS~bSI3G6sli%~ z23j-R<4+*x2CXz6Xna>96Ey$pWg+?l&hYvYOw`}qBRf!%-G4jIBR7GNoX+6g#?<)R z)e&w$WGi?ft1(R!b*!^p3=)(_N>>Wsh_J6s9DjiFaoxRGjay(OsQP;cHDWHt{l#x> zJ}+A4tm_}9S_OU)7-bbtE_iIf&iYvJV9`7exV7Ka1DQ_X&18F|+-3jac6G*8uW{Gp z;W^elt`Teq`x}*v5v+_Tq+{R5uZ4q2$I|Fy?tdm!ty`M>B@LXm^Z{Z%!_)nf7JHgc zwjnFv_Yq!IdgWQ#>juoe(tDPP^ms%eSvKxD=B&a>981`L^k~D-L-%` za=g^3X}noT#$kALFzK_$UmuYOP6dxVTesOMvW*0;`+bkfaz@v;6pjy1?k*>th|E{d z8IoYqP(@X-n%~I48}>1>*lO z3+JSUp#z>FNUeV7M6d3keTGqJppzz?7Y3X=Cz%$o3#+EzFiOEHp{&EjG{H%s+$W!0 zQ;62yW9hqFYJkXPPngM-F1hElsfC*v{~_pvd1~gQakj53Fw_~T+^w<|u!DVC zEp0zGsK1lE%f+*eW!3kbS~}ijICoZkKWmDE+$Mg9VftaC(75H;eVkdka|0?@fGBVdfNPCs5iKjlw0)Rs zUB{;9T{J`vauG~zKZb#YsusUo6M7pYGKB6mj{y^xz$@GEE_osE*Hp+D>tmv8GCyCb zynM2Egkv$M8zvKQ2K})%7c+#kNZ2Bq^zax5B!o;`$gV|Wg5PY({zdNc4X{HEhYzN8RO?lA6fw+GLTnr4_UH3)q|Q0KTsSIT?O^>4RWVW@HBV zz=E;ir2!EZ4jXM(lOdfMf5vtwiRSBowbi8&_bgo#a^stXEAj0|+%RrmcI&j_Hw^qF zCW@d@x;1$pcvN)K|Y7%JE@|V+B${ewA0HD6XLV|a2VTbZG$bHH2qilBQoDQ_-#UA*z@BXkVl-w}-TT z_Kh%<8k-J+6$e^*GLu`~AFnMX)Q?V|m5}xcUg(HicWB5qq^4HSJFlcJ7ZZ&tou>0M zBk=S*T(2W2n!s?`eLo_cfbHI6eEX}EkG#u+}^txWU5hu&4(N-|)*9(O{& zTgrDXZm6gXA{v&QhAal8g(xVt$ z1U^WK^Gt$&w`8&MP0$g9>rq%y)mzTAu)?#~*(pq`ByhS*IzZhDz$t64MMK^!H5RZ- zFon7Nnd}=Uq%cYHDBO3bkE@E2)EHWd{OP#6R~GYy?7?ZcuP4uljHD)fuuC1nC9F3U z!ug$F1ZRc8r)p(*Pswb@{G(vVrD>z|kO(|MUytm8nfb|S!JRz$9qjg&&R(Wzx$&dI z!*m@oPgc@1{X7gga6FWTvzWY+h9mvRZY!eqhcZ=$}?Xk{d7rZ(nNq(qjMqV4(Knp7B% zUDdZ4z`yNO`VL0BGS^Aj)3DcDK<*OPjVym>2JpRATBty8c%h(-Hxo$FjcXY(zW-NF z!g-Y98CpH9B_#aXtk~n5j(KdP{8)>s+gjpi*20~YW($W7AC?Ys{Vew%=+^DhzsZ2x z$F|7J2H?TSMzGDJr&IHpu8P=w?Yz2b7!}F0ve930Ai3z}?>6D-brY_5^k3RX&}c@i zsNknj5tAtyR=9Aj=FB%Sr5EEqGBA$r==+*Q61uge!Z{Yy(OPLSeYTkIq_UIM`D3UV z2-AIE*~G`dI$FGVu159NJ4g3LVCj>{@wpaA@elE-Ilikzu-;1%Id3-jH?Ecb3#>%u!cg&B$l1i(b~TH80L zy)3jln7}ElC%h|KLE2fvQ$iQ9U_(QDbPt$7mB|_Uu_;+zs$saZ>R+&ibknBYFTn#P z$^OIX5nyipOl|xojP*-A*1P1fP`Tj4^7&#!LrWVmewyu#ClB^B zSKKyvB)0T;II-fd5VcHMK_{2n{2cO(KQpMGQ#)Vf5AWv|`3|OrCk#TSo$e36W{LC< z5o)5B7XT`S1F@@n!2Ar_Jx`&@dW!(b9dc|t%szJCPqHo%^GXk^S}^vyN>Pb_cf>F= zg4ob+ih`#bN5b%1P0u)YGH$MiJGf{37Tn*d*BNd5bVX1|eYAHOCF(=Y7e zz`d)>$JeTc;THwU;p973k!hc632OghTVo*p;9z)WElfB(gVjaQR`ZaPWUmzQnD zn%vb7?yBDx08wmjtNd*nAi4|P(MMoicTdEZfGI(HYw!Dt@FPqEWxO|FuRp#5))>KI z*l)u9Glqv_uYBXL#RdklmMQqo(aWqa!dO5(4i`BF!p{~9wq{{|?@=18`&(ody|hcf zvCPy6(B-tv*Um$Sfe5$}YC;l_Z)3Jge^fQrS}Rl#cA~&6q#kwsIDLM6Fpbo?){$VA zEcwg&q}fc3P`3pT7u2|bxIAUn&*!Kmo}_R*MiiCmqN|o(?~By^^TAg{>Lq17`wM0* z8LaUlX<+0DUVd1AkOUn4z6^-9=YD5EHCBl;kVO2msf`7Z37JPOniX&aK%{T6rZitTg zlzPZLc`tT0d3;`&HvoTke1nHnQ#1wvOg;7)7-N1G#?n@ zJqj%zRr56nVzDqXp5AQ^6`O=f|B&;18~#85wS-dOI4**cD&U3Y{X4}3r1Nk6W|BX; zqS5u)V8LLoYNpL&%O&9qkpi9q{qUsfT{nFOOFTL&37|~U|Lfx*4{#3=ik6;Dh%5yF zxG&1pnFrACc((EUl|X{dBLyv_s*u2p@Q9{06|T9V(aTq|$3mdae`-T2!fOVr$A+?A z)d@Ai1DA;ybS+dO!N}q1uqf7O2A0*ec?#7G3bg+mD4l4M`MzG?+Pr0P3DfVB>fI?zdkNqd`K-owYK!OY+dg&PBg(`!u-; zIG*$!9K(N2{RMJTqR@hTbfuq|RbsrRH&(pFI)j)dJ`g~3;p26|gYm|Ieo!b1*rk!KvBoxdi6`TclLO3NDY`snJ zna~4uTNL^^#>(Tk#4XeS3ie$9xABU}g<@b4N8DQ#h6Vol6{%YKzZ7l^wF%^nF2Z$x zG7-^R>*+5$@-#aMy+?-HWIcod4=3$HCv6mRbt_;rsI)N)z9I^^KgQ74KHalrIy;x}Zux z2u6=EF4-f!>e(dp&363PFM{sH@$8%RZ*OB#YhSaLqI1q@I#HqgW6|z#Wrbt(w<*&p zYqn7g&%RUw3_9Tb>haU^25?+nvOFa>Q#VrXSh? zD%Fx41~sw@7riW;c~_RVwbIuRT@fhGL8T=Q_P(tMIHUVjonP&RXuD7ZA-#eD43%I^ ze>{cGTbm@-wJ|7*ky9{o6AGe0sz{mbBXdyKU&U}EMP1+edR6|Bi2gkRyPYE*0U5$d}%sx|k{DneXPKTH+B z6I%$u_aMJe@Y}gMD8OLW@<#>K7)i|rp1WbaX6Y$OY>7Od&FcXw%4?4nmNs2y^H$RL#uDI+jEY z4U?>eU|?iA0bfG~#`W2*oXzaPP-#(f^4=5!DR%iDhuVM$<3W?$52MYmFnU(3GY@ zM@T2;WlTR|Z5pzuQ5u+~WNvI?lC4C)msCKlNSgCQO`>_fmu>%N^USq`UI4jGB+o)| zBb}#nSU^5WkP50q4mQJTjthhYNJ9WaeDDX=Rji5h^+RQa_}Z{N*!6@a{V{x{2(LY zaAJ>~pe367;uS;0YjSB`c^3&IT~TAL$=ioaZ+2PR7)j~f!sedfiN4=^YBosLwo;-r2$A#0mu=(A`zK`W>8p zpBD^;J}OCt zNC3D##cvh|s7J-0z4~gxpS@oYlw6R4y`U}Er#UTR+z_Knw*&pFT<^nBtb9$>g>B?| zEKXHT?7_#=`_E3kc-(5!dQeyjs<2rTHCY{knNHyub=M<)Ji&il#j&6fmeXA^^(*R> zo9DAF?M;K8RP||b3lW+2lZ&fw4M#;Cn9!o2(VYu%+NTfHKWFqayljOoG9LG9K1-;) z9hE74`{WAUz})Z}A;3^h{qBJA_AAYI9DR7G-mbFpf`;lb=J}-8RBVOEWUkXhd z;9K^-?~{PQqyG%WCl|@zpD{Rg+7UP?Wmlv_q20dZ>Xsz0Mqtc~7bBN^2$54M?dQ&- zPft)DUcPmW2n<5T-`K(*vtSihmU+ogMuc{EIvm0WwfPf*^=&=YtHDO@5XA|DXETi` z=#}Gh7+oiVAY9eDO3gt6(D0eRIUBBo%hu?-4H~pHf`&eFb58>4kAk@0s#feTXw_I9 zzAulE21f@3wV)dCyFwePZ*zU1xjZjGT|?md%@fj+j;eLG?sr9dGxoLBi#2QQY9(gM z==V9is7lS%YK@EyK5l0yF0<%-CY(7?(QCfEd+OWcZcBauHWXp-?``9ogaH< zx~pos>M7~&>2O7P2}F22cmM!^C?zSX3;;lO0{{@haNq}kZ&>;w;J;7iLUKX?Kus*d zt06S_p4eDYSq=d3q67c}f&qYM@S}i30Kk7A0PA1Ei6Rgec%6 zEOx9Dd%SM%i?aHx;MN?)h8O_~lqJ0aeU;#3?MF0_%K%^0>M`tS?L|t$i z4HxTM;}=1MJZzKvFJmA3X6EMRaA?eFZc%-6NCwPpUGM{S_8=h389weJ@OOceT1f4} z$iTwPu(loPh0N%&b#n5SiKX?p_VfP87>rB_f|bkUjl+Q%77Egk!EizUAe%S(_cV9 zKqLLnSVv91ypobfYaa21QDWQTlu{6b7_#_LU{alR22wlElk4?O+^QD0aB@LaM-y@9 z*23~j!WKlK1YSFrI0^mXjIyEcE6?*uIViBuLk$N3x*Yj6UU`aylC`a|u*1YuUVXn? zXZ7z@VzyY+z~1J)sdQn%OR)P~W>&82{SuAqW|O6^=q*GyC~tI6|G{(^Ml9?hzY0Xv z`#m?%WN3M@?dMSJtlC_&olhchV@92J_Z%%xgvK3IC${^%;=%6~u0`zUYDUyS*iXGc z#&OJs%!VGl%aHeSnda=Ebl^PCv&cbg70ZbB-J4?gK?3~WUPr@{khh9nEAe+ipMi<% z^vIr<00Ygbz1J@YVdm-TOS5h%lP1nw2VGmZq*YC-|*do5eKIS!_Ng4 zSSIyfd^Lo?sg1_;gl31Q$j&@H&w!itwOlKrlWX#e)a z^WYZTgHRBp5{k?ezVtafYq3Fwfbt@*Xrt7-)2I8!Adyn1ZbJ$m6r%iu4r%larcY2( zfv{ehZC?5~{}~?VPmcvgg(h|M_u(g2lc2OaRLiAVP%YRBln1o*) z|NW^R$aGu#k+P>CWX;;j{ocp(b^ec`I>o~_CYzx=;=}e37!<#A!^}NzlW5HZNi*RK zRWBFSl@>j9WqYj?XzE|L9T}(26#THA2p+POMD&tYxq_l*!uWCL!fotRuGxCt%KA;aMd09B{Mgnn+ovP+gO`Y^=PFq zwpavbZH}BE7@@QO4WDi-4|oywVg~Odr{?JPRs1PKDxnIa57sHs6@SR9a!?Dg^Pj<6uZ%sWYY_<^DmZWrn)(Ig+mEDjE#rHyHwJc(ui(@d~?9?B;e z|H{&<=ZZbmiAcr|V+{71$B4zBOfnc+mp=jS`#?`!&n=xMTQ{FZ7oBy)9ixf96*CrcfLDSBln!|B!0%T`c81750k;{7I0JB#Imoo+6lKlDpR!IcAAMck;$8 zuICKMBB1CDw)Zpu!wn*RZ`=aNgijQ~djPum&l}kIqbMKY^$edeUJK}YhX?K^^6t8s z6JLMug>VZq`+#}}!fZd49#O)9H6DY)lWvO9(sPR=m1tvl>_%W`N4X9-W7l>Fm?G_%e27i+GhEL&|&mAKN3apG` z%YGd&t$aBzZ)oi_5i1WcRdV}u1X|@8f=k; zA4+<`X_zI(A%@|sDX1SdY59zub^h%JY5 z_bcxo$?mvd2HH1kfh!1B!egm~FSd7qIgOCG@(2pB8Ov;IzC(Fzwg8MCAfsg*g}RFc zo$QNz%&RY+Yc*M+#1^a@z&*e1>EeTbitSFE@=w$%Pgvxh$VZ;7>>pBWESKetW@OVA zu$aoNTWytJ2)vb1P>6AcpvM15W*cwZ#Gi&XOC$E7WLLUP$L;^gsoS(yqLVF`)7zGq z{mmmdV#X=CO6Iz(;XXuYm*smI*v-^a?u+|IsT-uS{p0{tVzm7S4V@6xs{#=X!xh`h z^mlgsa0;XgcfU!?;k;hM#8&fLzrW(Kutal$GM$lfvK_AGChh$<`LR)>_8jnF&t$`D z?~g>%4Y90#U8K44-_|`!W;B0h9lF1Nciw&i@D2D4bfEm}*oc&aIn6B>Vp-pv{4}TQ zs%x%FxJ0LDTM}Nsy_ld& zB|PP^9aZirK6&&;uFOffGkZ#MaS4eM4N;Y_Uj652MOW;&eHF}So~XVS8&93P8Vfq| z?ki@a`OfQKs@}aI?N~n#nX@ONcsvPu`A_uymuO_Tl}jVF3|DSQpL6nUYQC}MoC)3p zO_$$jhbFM=o*QAfNN1w=NZfsd?e%rW+ zSX6XJh662{K$(MFO0GkQQV3SukxY>?MWnXj3VclUszS0a{%xVFS>8&Q&*DJ)RTShl z>m~BEPrxRuvu8l?Ker2_p_A3_-Uy;D?JMQhn&RGp7`&r8t<3JCCslD*K{UF#&VR2i zs|&dc5Y?PAJ!YI$OPlaQRe4b4Qt8WsaE63ZVQD}%{SIZKyv|?av$V<_pZ;InKsisL zQWT*LHf>J9a}H^1Qg@PxNOsF>_8%OWKI>cQc%J|@N5U`Jf=u*>+k93OV!xX(O9~Ah z4g@rCCeGEQE@YuSj``l37ulbC#(f-KoBoRO^MB=fLQ?rJrL}pFnP8T*9?z}zXCj&t zX{kT~0C#yX0L_iN#g7CnB#5ML17ER7f1j``CoZT$?8t2>dP2hfx&KTsEt2vRjeruf zghw>%P{Y>Y@lo=|DnINXz-IYJf=~RVU)=Q;id0qNp>Ej+7ZFzZIYFLga#9%b2jHQf z?w?6cIe&y4DLJICLiRrG=vm$zB*U%K8=IfBf7wRnKuwpep`|e=I)*H*`TsDHr~J+A zJ6iHe&hpyet>kcm2ycCGRE3_4S70xrj8*QOKrWT=khO`m279fB&7XPq&jXqdvP_ue z=HO>b4di5h{f&-dlC{3mZO!xEXf?J!q2pK#bYc+DOE9 z53)2;PunOiKY!{gM@(tzh#JY+W^30k$^BtZUX*@pJ_KTW&U{Ox~4y0Znz3RD{eMo>wEw6QY&w8pD*-8O?p%9YmA<}Rc89f8KX;- ze|;>XPP$B+X>P#*Oe1?oPSG$FtLycrCQ}-d=SI-)=A==V7<8M~`Vy+Iv(U^zV9fQC zW12a9UPS)1igpiwkil&#Ae6`Cy7PUIUFgfdk#kuJOdn#Jd7y4T{0sqBjQK2?8elHg z4ibbiuR%m+Bv22kyjBvUgFEh{*q*`{YKp&TM@m87j&=UoHQqB4G~n1EAIN?a=<%Yu&nfY=U2CWv;dY2{2>z1Saw<5oTtv%Gp_0cXA^c>aExr z_e_2=SS5aji*p&f^{UMzfH}y*A{1JxK}$eSEGHsvqPf50H2Q!XY8h#jZE2=_8_~K^ zVd>5$sWY_q5TPPMv2b~p$veW7C+nNsf@P#fB>_0TBaaJf=21#1|0yf9;U0w_&7wT1 zOLh%mSx$JN}`5y=X<_n8W(U>E)_MyyyrcDH~wXiK>jC@mzdd+XD@N;w3tPGCM{PC zznp0m1)6};zDX{*)WW-f%0<^JwoEPu%tcl5?$Ghi8LAm3$83m12r9i>lPaN%RI|l0 z8!vBL=0w5zapsR7KhhugB%%rB8pW{$7%ybF7H}{K2{%^ds48!D)Xf%LpW>!#bj9xe zMft7<^RT!5JZE;Q=Hi~`rsJaIobi#77RFdY%*BwKAIsD@fUS-0u?pvJTYpa$r~6mB zdusA)v^+ob{DktA7btjrEEJ3@01FQE-{?*lm!92kUEM(`t0HnD#;#IALVg5~p<&2h zNslug4@3L=;)wiNKj^|Yib4x588G(`N>mJeVK2*>8{lC8Q@eZn*cfYN78UBM+M@*Y z*}UMn8qfB4s4*k~7d#FuHvK;ssBo)r5TJCG{Vmq;MtgH_iES!H>zN&R4gzA4p|)(kY0h*J))Avl~%XRo1%s(za?n&X%t1gHp$jQ{1pAYXzt%fCh$sgCy7fOY3 z_bNziRtZ79Zw7O}=8wdFtvWEiTxx!LrmlZLZt!83 zm}MLoomuL{Dw?wmaumQ}nOm7A&wJ|>%o`O5dQ;|VTP&HL&LFPVFn~sYDPTHWolYuj@yP-9f%KE8Io>4M5)9|~dL4PViqyK4Jg}}?vm3Ht`b-RNdL&Qu zsjouUxEXW)DFpJfI^pNFa&Hc zu=Y4(d|%^W74S8?4{v_aYTjM1Jv3f z5rx2!^%jK7Yrpga8l&$Oj8#kENuX zjKxIm?hz188#+0v*KV#l<(&eeC2T5RZoj!^d4R6=J_}syh3ftJ(^m3#H~PT(cM=hM zb&cDtF@nTPCP>n5(~x&keQxe$^RnQulc}a|s4m9`nw5@DCLN=z#T22w>=O!Bin=RoE~?;y&{Y% zk^FZFWr#H5j1mLq*$y0WazqJbu}h1k?v9YyDYCy0dDluv2NaxGqHq}`=%*z=>kPbL zu_`+aaV?p^>X~*o^G$c+NIIokALn^DkJD#{4}tf*eF`?&Q+)F(#1#xh- zw`=_Qo-!c-fO7Lp{{q!mf$!I%&gC{wZHWKTGwUJ(@;Kg*>&a`LTG{`0lI^Gh0HRaG zDy;*b?|7W`KjfO)FZC=4rBC)hwgTMU0RY9Zzt+v|bRJQNfB@c@YJzv(Y6yTLe^$T} z7g+p=n&$57%$uKc#h^|_-R6`&%K$5ies(x()(}r&tt;+}=65pI-bJWw- z-@~MUqOSF&2|W@5u=N~JVXW}k$|DB`fN_P4+(!rTxH(ww58bN*4=4t8?+@uv1nd>5 z!){{&ux3~0eRXzJF8m2PvXspAes z0ld{D+bb25IMoSt)h|t+cmU;k-*%MAzjdGS0a#>OL^y`fuNONjS7U@~j(^*G5}r$* zDY+^>rUym_)(2+?*OO9JbUC+@)~W6?Xn)NFw9DGr8j{5aW4ES*;yrMRyg)Sth%@h< z5CGNWO+MrP*RNkJ>7(Tkb#*__A3sxqQe+6axNe1Y0`V`xZ_Y07R-Us?!51WAKxFCK z$UrSx7RH?%qSyljIYF!2#Y$!Qr9fa(lHTy>=xF;g9H8plsSN77WWLt=)Gx;NQi!-m zn6Thb7+4&Qp%tOp5bhOXnwH&i2!J4m>z{y}-MziNece`Mz(PmN7ICt+h;dL09_B#Gw>#C#xkxmHIcwxS6G%86MepP|T$No&=?*+|S zIXQk(6ek#HSf@MtdwIH4m}+7a?$vt3t;H#>u~AW9c5W%`72x?hohLmHvG|JY0rO)P zchO@zgN&%{1JM^WRXo4zc9WcGV~2)*Dz4x^jI@p2M$ws+rY+&b=lVM%&z!}<%KX;; zg|>L(wySmBfj)oT5s%6T#b8-WTcs~KIb`MVGbZ|M?3wpWyxWq;ZR3`J(+Y%8xVA@i zf6;;e-A_7L^E~N7mP->C1)nbu{f1TTs8m@V9m;s{v%?3eaNNL!8YDoIme*|Dkg14+ z8u?tV;~a&}NKj#)lX3*XG7M?qQ!F75aBn=S>_CyNz{yqt&X+2CUdLKaOBwD~OM?Q) zbJy9gJ!Gu0??kQjzDlof*#3&-CBzM0X;0RYLmOx4G?kb6GxNkc0E{3Fap8H)v@= z@h`9OFRtHInm}wWKU@-915a{;g{B6_^qYnByRj){TB<5{wOWkiu!rkx{Kkt|qToFZzpnn)?ML+acNn+9nob$I?^ItIeeu_~IkOK@ zVTA=<(>_DwMyp4s<*%p0Qd6`|eTf8e%oFg`td(S`f8LM4cKqr*03ieQqv$*K*3n|7gPEE}#)&8ZU=yUUsvP(~@LC@|^m)0dq& zM9#4?3mgT1^dJzBt`wCGT1EB=Qc4(?2x`&z=kVgE&ViETi5#9s96@r)I|POnTkP)~ zc=5ypNKQJF6Mx+|Ydqxs7zYe_?`3Z+{z`RH$X6JP3~9XV~lUSHDD3 zTsdfs*al;cq@IMJnAjR3b~Osra7Y2aDYHgnfqQFkKrHgl@IYv*{CL;{1fIH`-)tj-htXAYBYVV zhNzbw`-B?R5`kGFK{T~p>{S4UjuR1hf8iVu4y>sl5uVED5R&~yds;1a~KteTyec)hp^ba6;2rO?P+{D zOJX*=yAt5FUV{NOY%_wd>_F9R^g&C0n8ibCiRa_Y*oYM`)XiO6thZ>-$Z-u0=3x!4 zhaVesbhV_1sd698!(rla8*w(@j`=xjZFjYwW1Qa^BZbAn+%0bA>@qkmRWD)&tD{a( zyfVl+0dZ=h5RwDq2vQwKBPL^hRfE0*F$eNK-UC}V|)QnX&MM zxP?zy-CW#I!d#F^OSU-I4vULB;F0|GAwMSR{uoe8B?Mk>5e+1({FSbTxK0Z0cL~W8 zRQ|gZttvjY5Vu%#c?rb>pPg{XMuJ)ty7j40BJ3-E$%_L91GL6Ug-M(YR6h9;B6*pk zGr4w)N`3`xn2w=@0K-Ggpr%KM5nUNlQoJ>B82PY)$73Kxd8NgHbOCCS{Vw!C>;yx( zy=zSVJo1J#e=jjM1i%0p5G;c^h|X8~6wN4e-+2LIe)M`>jLcL85phEVd?NHSkSdtv zJR_CdJx=c!h>iJ3q;pjd6O`%RRB&XS2+tbuS4iC}uVSJ9Vs;Dn+J&^mn8f+K&lgau#1(%E{j>r_tcwD4K^tTcos_u%4VSiIFwKryMBzgkOPzE);;9wC{Fn*p{Vaj&o^1NDKFpbG?Xb8 z*S>HnVYG})Dp3@o7Tt)u2#*#!Yr!fiJJ8@bdfOvY7fW{t!K72e&&VgWi?9P-vJbXX z);_o8y8IU)mB0rnpsLa03DL6raA~VA3`zl}S9;UIRVj)m>%caE zn{5gHHUDP&;c{A67?c3~oYI@zHU$`Ws2)y%DdlG&6%wZ6rlwg+K1sx5Oj7#5TNNfy zkr5VI@5o0bU-dE;FZ#wkEhN=V5cey~jQ4L&S&u_%ZEU!B94|sNZv4WbC@ckZt1ydi zN!#As(XM;@nb(^jkoE}4v;)lw8WwFatx5JEn$g8CkXr!djTkzEmfJy>in|0aeL-SS z!Sc`R3;Fmpm(=VcBPev9{0D!I6HR(7#x6v>PbddA z^RR(t!xue;DY3pmM3h;}Q z|LM9UPqPdBe zDZr!`!ddzBrVDj4GdiUAGrI=+(To^=@va0|vzQWOl6<+}gj|M>_*{_ki?^&=nW$$g zx#Np+N`{ zjgnN@Wr$_n)tmAsP1DMa>+ju(`&&xog?MtQ9CE2^MqWGONl16fRR*R*K|YhdK73!C z`^YSmJ_8XUFxaE=HiD&s4_|4y^1V^Yrr7~6$cy_*2#4$&X|*o#06&oRB{cn&Q3O8#g#?=ndojHu18*H6CKRuH89x z!zgn4Kvm`X6dPltN#)xJ`bCr0X7vFhX0=8KgH|PaNQiGOh+MtGqWkVs6XletroJ)t z;ws=l+`G3o4L8HJ`t&cy6=ZMtio~ffKcQbW{_QI;cx#1Sn3&C$jl(PGBx(#>8k@r& zuS4?07`AE4e<-&sBHGbS0aGIZtvHzt3q`8pPv^Y9@Z zxFU49N64yfVICai5{qBl1tj9f=J35bkHxuJmWK&yh#4q4SfyQt>Vv_F1Vxqk2lgJ- z3ZeI+PrGO1v_p2t9P`Plkf)8xs>^o%$nfiz`S_|?wQ`zU6yUxBK+13Y}sWf z*l^CLdXmRErcWOlCCDWu_(Yg$h9&~n?CdZ^ge_>(RQZ`+lrQzE#t&vh<#~R+?#&%Q zraFBo%aUvB?`IMPy72S_zLn_Ee|_HYBc5k8{Yjffo;plesym)VAXdoGv88#tLL7;_ zboyx|f{*{)--$j#JPuDkIjV!kM<=5hmCQHDse`5#o>B#>?H<9>K39S`l8>!kvAW^J zOF3zjJ_m-axh;D33#kzI{Jb4zX?F9WqOa*{_5g_srmVVLSPjtDPxpIbTAz3a zEK83&g;grI7uzP9B=XNsQZ;k5Hm#RIXs}*dicm$qC5A?83w`n^Msr~_7P6kQ*nEXxMMeBdvBLUp78zG~@Z+nayDMK_J$jD)@tFuLp<2>mU3IboH6W6cGBgz74_^Z>Rr5^Lc7khylbFP+XG)FJDo0E zv?FW$;e0M)q~k_X+=2ogJa~78{1%D4d?t9?&V;(jmqC0muV@b-FJEn6UK+S(I|Gmc zi?u4O*^1N)BX6$|6UC}|i{NH*RH;(KAh9Xamw>Lmv#%}acd!Z1z)9ea%?JvmHe3n? zcH`NYBR;1S+@Jnlgjk{_-32~FEBBhUvW-@z;yyYz3sLHuhq{Pah2pHnh!{CIkGY^C zt`5$p0v}CTlcp@k^w6=}APIc0ftYBchkflJIJn^v-obNU=Y0y3R_=vT1Mtg6ZxwJO@U8=mBfJ3o8R7 zFvpq4_$LwgfC_Hci-mS=P>3VJZ}6hX_;{<*XMmfXQ}Y;M)(J*5;_r+MWdI1gdWrb? z^SA2-8d>1&dj_46_ubve0nl!Le}8We(;7g(z8kYeT|;)luBJGz_!|)C6%77`&bP-4#f>k!lBmf=GMV^r+rQ2MU6R>bG4L! zfb{sY8No#U3DgY?-BMOK!+6|vqfuOI2i({#x>@&efy=FsX50;NnuuK;`hrOR4V`ZmgNonp7%RnBl zI>=K5NiCQ7F>|{2D!+9n+7Vi_+iYU_U0?#Ew~BVnJXeVkusNL0<-6aeMiIKsR2{z1 zZHJ%^YW}17RtBej;qz=q>`y1#)eiT^{Oz@Z5Qv}c!;#r-bt@czX>)G@^ZhHv%6@me ze=JMFi)MG)+^@65;QC*O^LNO`p0Suwf#&b+^ru5-+Z3tXxTBsvRAGUW<*C=4GZCw~ zzEi^%6FVF@P?vijjKOdgj3fsI$(h?|^9?vB7^~^p7SllnOzrp~vMhlprYh8Sog^l5H8oSfXu$YFgu=^BW z$Nz}?YJ8=`0dI;&5VkjdHZ)&+?Cp&{{;tkklAg3A5_{D+GsR$)==e4O{)Q06f9LB* z?#IJ|-aSXv>Z3f;Y|jY(tNE>-?p0YlbkwTBm_Hl{etyTjwyBz^AF;w<3<|FWX{Q-} zKBi2fAo}c^I`h7Oo9tdAyqfPK>L&iWCAf=-k&OJ!kC5ZDi>fC4b#t&HJcm-3H?OF( z|2TzT{o^WYz41ts`U2lT_IsvZM`8-lgg8*QO;(P~mAdX^Qu+DQzdra))xv7%Se+Xf zgvQXuS|Ug)HF_Zts-u9dc{yHgVqUPFWUYTDA7uh+Ne64GZvrnk0#03XGtH3U)?kcR zuD2)ViZ{^~zKyLmKpctQaxyKHrk8x{1CP46&fc^TjX3qHJeT%G95kg#h0GD%3Ero% z>^)j)t(OK2;|@?TazIkggC`?t1BMj_vUJk9F>QGy5P~VgO=Gw;fPmWDbR|yNzpP-j zVp?;?(}LHdi&z*Frz=R%klKvlQ^A`zv+(^{aty$@MONFj79GoX{RQ{f&xEvK7|i00 z=5~^1P)x@Sf+XMO_dmi*W7CDZz@TbqyKXK10ubz}Bl8hQ1PDs-r&3dhlIoy#S|DS2-=mkF=bGnbNE-$nv!xY$;On(Q_G&UL%Q+TH0bs8F_wlE|U>* zbM&St%qUO6zt!3k&+;+R`*j#@N+X-z-yGQna4d=X!VI8|!C&+8f@qfwx1%fwd&}qj z?Vc9>7JSIg#9sgv244W|HhQj>k21!doOvOcogF;qn1xlm;H{^?(D_m89H07B;s#a! zD%rD#GSmmwp2^)Y!uiJTNWGyCB^-z#n~^g1>ZZY&=zacw(WCUGE!aAe_fs8C^FgrF zmZ)(%C=k2`+gSmC;om+NG6F}4^?8@F9X{nJr;^Ywiy*y8&uf%wcV zJU18vG9ke`c;J~h3xJvG8hX0qY0D3^%u>Oh{1=iU1HT(d8>;1LQl<@+{}xX00N-R( z;8Ug_Gr%OQ+Eb`#v>Tp-QyDhNir1^`YW0vyV=-4`@&9)7y;fz!pndUkc@cAb#1MuZ72-O|`&O)vR`>1PW_ zIZTIRj|qVR7bTAruwrpr(KMrqz5zbx1>*&XD?$Z#7nGN05R2&|N83#Dtf>{*eFEnr zCC`-p$jknV?#dvVr%S!33?EG;m{HP>EY6bEsF5~zVt-TUR&*I-q)2Bm5Bi?A@65j? z4;Q&{Yo8O9k;sN`!D+9p>C}!CLS*t9P3hDKIupAQQr2}J&_olV3s!4EK~UMmDP(fN zQa?Ng6JAsY_c4@Bo;*gYX7_$b@rvRBF(=$sL9gawK5p*|KZ}-DCfGby~Xq& z7t*G@6sd-`JsZUGgmXpnCZjX55llm{thagDdl~-gX~>39Qz?XBi`sI?*yb0)V8K1r zvqI0ZTng2OoeJ%vJyg`046uY-E1ewpim)=FL%f567=qVpbFL9*&G~U|pu= z_yQS62|51wYq319o`j-ze#Wp&7Wzly)J5AuznVuxH48Priddrdej6dF+zU3R-m(;@ z0Lgs(>gXe(!)3B%7s@67J2h6_8!-UA2Os|^Ecxm74XnwqivcwOrD6fZvS)NV9nZwyYf|BU z*}rptzst9kgApiF(w^xNMe1p>Ch&~Dpj)EjaF%<(eZu#Co-fd!js^jElvB77O>}tP zWbPgA7l}DKn_i%3pXzlet238BA+Ucm+hAf7ZNmaPC0PPPU@s${{Qcw3xAqH_HBDiX zt)70^J9v-zHZh}rdEZQ0SJ=!c`0p-$XXp4#o>RY!7xb&=4Cyq?3;;m4WMe5gw1h|X z{6kerzcQWboW_BvM>hTv96XVpz_IXMqBY9TH2`qr zk=Y)WS$7XN*K4*>Y;-O_zyTL;NA6xrkGQ6!xB~Om)7PD%w%eKDA)Bu?y!uw0C>Yty zD0BG#^uPBp{)Ird)P|eLXDVO4F05VoR(BIa^bmgI*3JQTvY6hLQ^uXb7&yyXN4cqp z#wr2ZA_QgTL;{?ahuL=;1{GpWJLi!9ovg5>mX+t%{7Zz1 zifY$iA!sS?HBgojx73vHl=vN-e5S>--I)2_I>at6<3Mrp7)*Z_!5ffz{Ju~?GS~r_ zj4|yBgDAZ!vm*UA Date: Wed, 20 Sep 2017 09:34:10 +0200 Subject: [PATCH 121/155] add graphviz --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index 0e9e055..eac68ce 100755 --- a/setup.py +++ b/setup.py @@ -32,7 +32,7 @@ 'Programming Language :: Python :: 3.5', 'Topic :: System :: Distributed Computing'], - install_requires=[], + install_requires=['graphviz'], extras_require={ 'prov': ['tinydb', 'ujson'], 'xenon': ['pyxenon'], From b2aa0ef332f49472d6bda5f94cb76ca7e7ce938a Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Mon, 18 Sep 2017 13:06:02 +0200 Subject: [PATCH 122/155] Introduction expended with assumed knowledge statement, and typo fixed in ofttimes --- doc/source/index.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/source/index.rst b/doc/source/index.rst index dd1c24d..611a491 100644 --- a/doc/source/index.rst +++ b/doc/source/index.rst @@ -8,7 +8,7 @@ Welcome to Noodles's documentation! Introduction ------------ -Noodles offers a model for parallel programming in Python. It can be used for a variety of tasks including data pipelines, and computational workflows. +Noodles offers a model for parallel programming in Python. It can be used for a variety of tasks including data pipelines, and computational workflows. The primary goal of Noodles is to make it easy to run jobs on cluster supercomputers, in parallel, straight from a Python shell. The user enters a Python script that looks and feels like a serial program. The Noodles engine then converts this script into a call graph. This graph can be executed on a variety of machines using the different back-end runners that Noodles provides. This is not so much a design driven by technology but by social considerations. The end user may expect an elegant, easy to understand, interface to a computational library. This user experience we refer to as *eating of noodles*. From f3e07a5d34dd2018272505b1c5a9886d8d5cb4a0 Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Mon, 18 Sep 2017 13:50:32 +0200 Subject: [PATCH 123/155] url link fixed in introduction --- doc/source/index.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/source/index.rst b/doc/source/index.rst index 611a491..a9eeac5 100644 --- a/doc/source/index.rst +++ b/doc/source/index.rst @@ -16,7 +16,7 @@ The computational library that is exposed to the user by means of Noodles needs The complexity of running a workflow in parallel on a wide variety of architectures is taken care of by the Noodles engine. This is the *production of noodles* which is left as an exercise for the Noodles dev-team at the Netherlands eScience Center. -Assumed knowledge for this tutorial: Familiarity with basics of the Python language, [decorators](https://www.thecodeship.com/patterns/guide-to-python-function-decorators/) and the distinction between [functional and object oriented programming](https://en.wikipedia.org/wiki/Comparison_of_programming_paradigms). +Assumed knowledge for this tutorial: Familiarity with basics of the Python language, `decorators` and the distinction between `functional and object oriented programming`_. Copyright & Licence ------------------- From 5fa3aefa2c274aa67e71e2324cc19e7cac3941f5 Mon Sep 17 00:00:00 2001 From: Hanno Spreeuw Date: Mon, 18 Sep 2017 14:42:54 +0200 Subject: [PATCH 124/155] Clarifications wrt the installation and import of pygraphviz --- doc/source/first_steps.rst | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/doc/source/first_steps.rst b/doc/source/first_steps.rst index efae898..0fc80f0 100644 --- a/doc/source/first_steps.rst +++ b/doc/source/first_steps.rst @@ -27,7 +27,7 @@ Now we can create a workflow composing several calls to this function. c = add(a, a) d = mul(b, c) -That looks easy enough; the funny thing is though, that nothing has been computed yet! Noodles just created the workflow graphs corresponding to the values that still need to be computed. Until such time, we work with the *promise* of a future value. Using the module ``pygraphviz`` (`pip install pygraphviz`) we can look at the call graphs. +That looks easy enough; the funny thing is though, that nothing has been computed yet! Noodles just created the workflow graphs corresponding to the values that still need to be computed. Until such time, we work with the *promise* of a future value. Using the module ``pygraphviz`` (`pip install pygraphviz`, check `this post `_ if you have problems installing pygraphviz) we can look at the call graphs. .. code:: python @@ -42,6 +42,8 @@ That looks easy enough; the funny thing is though, that nothing has been compute err = os.system("montage wf1?.png -tile 4x1 -geometry +10+0 wf1-series.png") +``draw_workflow`` imports pygraphviz. + .. figure:: _static/images/wf1-series.png :alt: building the workflow :align: center From 6978f247fb49968a01fd093434b29a35497c52a1 Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Mon, 18 Sep 2017 14:47:42 +0200 Subject: [PATCH 125/155] srt syntax errors in url fixed --- doc/source/index.rst | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/doc/source/index.rst b/doc/source/index.rst index a9eeac5..7fe920a 100644 --- a/doc/source/index.rst +++ b/doc/source/index.rst @@ -16,7 +16,7 @@ The computational library that is exposed to the user by means of Noodles needs The complexity of running a workflow in parallel on a wide variety of architectures is taken care of by the Noodles engine. This is the *production of noodles* which is left as an exercise for the Noodles dev-team at the Netherlands eScience Center. -Assumed knowledge for this tutorial: Familiarity with basics of the Python language, `decorators` and the distinction between `functional and object oriented programming`_. +Assumed knowledge for this tutorial: Familiarity with basics of the Python language, `decorators`_, and the distinction between functional and object oriented programming: https://en.wikipedia.org/wiki/Comparison_of_programming_paradigms. Copyright & Licence ------------------- @@ -83,3 +83,4 @@ Indices and tables .. _pyxenon: http://github.com/NLeSC/pyxenon .. _LGPLv3: http://www.gnu.org/licenses/lgpl-3.0.html .. _`generating SSH keys`: https://help.github.com/articles/generating-ssh-keys/ +.. _`decorators`: https://www.thecodeship.com/patterns/guide-to-python-function-decorators/ From 03163fc6c3f2aea6c0fca63e30d7ec8e1552ed06 Mon Sep 17 00:00:00 2001 From: Hanno Spreeuw Date: Mon, 18 Sep 2017 14:52:00 +0200 Subject: [PATCH 126/155] pygraphviz highlighted like draw_workflow --- doc/source/first_steps.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/source/first_steps.rst b/doc/source/first_steps.rst index 0fc80f0..217218b 100644 --- a/doc/source/first_steps.rst +++ b/doc/source/first_steps.rst @@ -42,7 +42,7 @@ That looks easy enough; the funny thing is though, that nothing has been compute err = os.system("montage wf1?.png -tile 4x1 -geometry +10+0 wf1-series.png") -``draw_workflow`` imports pygraphviz. +``draw_workflow`` imports ``pygraphviz``. .. figure:: _static/images/wf1-series.png :alt: building the workflow From 37b36863497b0a41f312f2241ec2092213e381d5 Mon Sep 17 00:00:00 2001 From: Hanno Spreeuw Date: Mon, 18 Sep 2017 15:07:24 +0200 Subject: [PATCH 127/155] Some clarification wrt the disk location of the call graph produced. --- doc/source/first_steps.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/source/first_steps.rst b/doc/source/first_steps.rst index 217218b..43034b6 100644 --- a/doc/source/first_steps.rst +++ b/doc/source/first_steps.rst @@ -42,7 +42,7 @@ That looks easy enough; the funny thing is though, that nothing has been compute err = os.system("montage wf1?.png -tile 4x1 -geometry +10+0 wf1-series.png") -``draw_workflow`` imports ``pygraphviz``. +``draw_workflow`` imports ``pygraphviz``. ``wf1-series.png`` is saved to the directory from which you launched this notebook. .. figure:: _static/images/wf1-series.png :alt: building the workflow From ab7307f3fbeba2386e9d71c86f1509a674781f42 Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Mon, 18 Sep 2017 16:03:09 +0200 Subject: [PATCH 128/155] local link to notebook added --- doc/source/first_steps.rst | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/doc/source/first_steps.rst b/doc/source/first_steps.rst index 43034b6..71862e2 100644 --- a/doc/source/first_steps.rst +++ b/doc/source/first_steps.rst @@ -1,7 +1,7 @@ -First Steps +First Steps =========== -**This tutorial is also available in the form of a Jupyter Notebook. Try it out, and play!** +**This tutorial is also available in the form of a :download:`Jupyter Notebook`. Try it out, and play!** Noodles is there to make your life easier, *in parallel*! The reason why Noodles can be easy and do parallel Python at the same time is its *functional* approach. In one part you'll define a set of functions that you'd like to run with Noodles, in an other part you'll compose these functions into a *workflow graph*. To make this approach work a function should not have any *side effects*. Let's not linger and just start noodling! First we define some functions to use. @@ -9,11 +9,11 @@ Noodles is there to make your life easier, *in parallel*! The reason why Noodles .. code:: python from noodles import schedule - + @schedule def add(x, y): return x + y - + @schedule def mul(x,y): return x * y @@ -34,12 +34,12 @@ That looks easy enough; the funny thing is though, that nothing has been compute from draw_workflow import draw_workflow import sys import os - + draw_workflow("wf1a.png", a._workflow) draw_workflow("wf1b.png", b._workflow) draw_workflow("wf1c.png", c._workflow) draw_workflow("wf1d.png", d._workflow) - + err = os.system("montage wf1?.png -tile 4x1 -geometry +10+0 wf1-series.png") ``draw_workflow`` imports ``pygraphviz``. ``wf1-series.png`` is saved to the directory from which you launched this notebook. @@ -54,7 +54,7 @@ Now, to compute the result we have to tell Noodles to evaluate the program. .. code:: python from noodles import run_parallel, run_single - + run_parallel(d, n_threads=2) @@ -63,4 +63,3 @@ Now, to compute the result we have to tell Noodles to evaluate the program. .. parsed-literal:: 16 - From 8d555b89eff6e589278d844a65459fb3bbb8149d Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Mon, 18 Sep 2017 16:06:04 +0200 Subject: [PATCH 129/155] link to notebook replaced by hyperlink --- doc/source/first_steps.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/source/first_steps.rst b/doc/source/first_steps.rst index 71862e2..2a94a3c 100644 --- a/doc/source/first_steps.rst +++ b/doc/source/first_steps.rst @@ -1,7 +1,7 @@ First Steps =========== -**This tutorial is also available in the form of a :download:`Jupyter Notebook`. Try it out, and play!** +**This tutorial is also available in the form of a :download:`Jupyter Notebook`. Try it out, and play!** Noodles is there to make your life easier, *in parallel*! The reason why Noodles can be easy and do parallel Python at the same time is its *functional* approach. In one part you'll define a set of functions that you'd like to run with Noodles, in an other part you'll compose these functions into a *workflow graph*. To make this approach work a function should not have any *side effects*. Let's not linger and just start noodling! First we define some functions to use. From 0e86166d6ad7a2960d8731aa4c0fc0b0a17adf7d Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Mon, 18 Sep 2017 16:08:02 +0200 Subject: [PATCH 130/155] fixed syntax typos in hyperlink --- doc/source/first_steps.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/source/first_steps.rst b/doc/source/first_steps.rst index 2a94a3c..6d30e0b 100644 --- a/doc/source/first_steps.rst +++ b/doc/source/first_steps.rst @@ -1,7 +1,7 @@ First Steps =========== -**This tutorial is also available in the form of a :download:`Jupyter Notebook`. Try it out, and play!** +**This tutorial is also available in the form of a :download:`Jupyter Notebook `_. Try it out, and play!** Noodles is there to make your life easier, *in parallel*! The reason why Noodles can be easy and do parallel Python at the same time is its *functional* approach. In one part you'll define a set of functions that you'd like to run with Noodles, in an other part you'll compose these functions into a *workflow graph*. To make this approach work a function should not have any *side effects*. Let's not linger and just start noodling! First we define some functions to use. From fe1dc2cfa71c8cf8581340d40fda71427472c323 Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Mon, 18 Sep 2017 16:08:59 +0200 Subject: [PATCH 131/155] fix 2 syntax typos in hyperlink --- doc/source/first_steps.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/source/first_steps.rst b/doc/source/first_steps.rst index 6d30e0b..e13b8bc 100644 --- a/doc/source/first_steps.rst +++ b/doc/source/first_steps.rst @@ -1,7 +1,7 @@ First Steps =========== -**This tutorial is also available in the form of a :download:`Jupyter Notebook `_. Try it out, and play!** +**This tutorial is also available in the form of a `Jupyter Notebook `_. Try it out, and play!** Noodles is there to make your life easier, *in parallel*! The reason why Noodles can be easy and do parallel Python at the same time is its *functional* approach. In one part you'll define a set of functions that you'd like to run with Noodles, in an other part you'll compose these functions into a *workflow graph*. To make this approach work a function should not have any *side effects*. Let's not linger and just start noodling! First we define some functions to use. From 508b1b392022ef477e85427bcb1eaf668ef4a34c Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Mon, 18 Sep 2017 16:11:45 +0200 Subject: [PATCH 132/155] fix 3 syntax typos in hyperlink --- doc/source/first_steps.rst | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/doc/source/first_steps.rst b/doc/source/first_steps.rst index e13b8bc..a526747 100644 --- a/doc/source/first_steps.rst +++ b/doc/source/first_steps.rst @@ -1,7 +1,9 @@ First Steps =========== -**This tutorial is also available in the form of a `Jupyter Notebook `_. Try it out, and play!** +**This tutorial is also available in the form of a `Jupyter Notebook `_ . Try it out, and play!** + +`this testurl `_ Noodles is there to make your life easier, *in parallel*! The reason why Noodles can be easy and do parallel Python at the same time is its *functional* approach. In one part you'll define a set of functions that you'd like to run with Noodles, in an other part you'll compose these functions into a *workflow graph*. To make this approach work a function should not have any *side effects*. Let's not linger and just start noodling! First we define some functions to use. From 00a656acd6d552373f3f37d36b70141e8ec42315 Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Mon, 18 Sep 2017 16:13:44 +0200 Subject: [PATCH 133/155] fix 3 syntax typos in hyperlink --- doc/source/first_steps.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/doc/source/first_steps.rst b/doc/source/first_steps.rst index a526747..c5b94ea 100644 --- a/doc/source/first_steps.rst +++ b/doc/source/first_steps.rst @@ -1,9 +1,9 @@ First Steps =========== -**This tutorial is also available in the form of a `Jupyter Notebook `_ . Try it out, and play!** +**This tutorial is also available in the form of a `Jupyter Notebook `_. Try it out, and play!** -`this testurl `_ +`Jupyter Notebook `_ Noodles is there to make your life easier, *in parallel*! The reason why Noodles can be easy and do parallel Python at the same time is its *functional* approach. In one part you'll define a set of functions that you'd like to run with Noodles, in an other part you'll compose these functions into a *workflow graph*. To make this approach work a function should not have any *side effects*. Let's not linger and just start noodling! First we define some functions to use. From f5a6b3b52958772f6abd61cf4e322362ead4d2ab Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Mon, 18 Sep 2017 16:14:41 +0200 Subject: [PATCH 134/155] fix 4 syntax typos in hyperlink --- doc/source/first_steps.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/source/first_steps.rst b/doc/source/first_steps.rst index c5b94ea..421242e 100644 --- a/doc/source/first_steps.rst +++ b/doc/source/first_steps.rst @@ -1,7 +1,7 @@ First Steps =========== -**This tutorial is also available in the form of a `Jupyter Notebook `_. Try it out, and play!** +**This tutorial is also available in the form of a `Jupyter Notebook. `_ Try it out, and play!** `Jupyter Notebook `_ From edab7db762a1f0cb2fe5dd9591e510183bab7dbf Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Mon, 18 Sep 2017 16:15:38 +0200 Subject: [PATCH 135/155] fix 5: syntax typos in hyperlink --- doc/source/first_steps.rst | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/doc/source/first_steps.rst b/doc/source/first_steps.rst index 421242e..18577e5 100644 --- a/doc/source/first_steps.rst +++ b/doc/source/first_steps.rst @@ -1,9 +1,8 @@ First Steps =========== -**This tutorial is also available in the form of a `Jupyter Notebook. `_ Try it out, and play!** - -`Jupyter Notebook `_ +**This tutorial is also available in the form of a `Jupyter Notebook `_ +Try it out, and play!** Noodles is there to make your life easier, *in parallel*! The reason why Noodles can be easy and do parallel Python at the same time is its *functional* approach. In one part you'll define a set of functions that you'd like to run with Noodles, in an other part you'll compose these functions into a *workflow graph*. To make this approach work a function should not have any *side effects*. Let's not linger and just start noodling! First we define some functions to use. From 2f0d8a8cfd424053637789ac46a6ca7d0a0097c7 Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Mon, 18 Sep 2017 16:17:53 +0200 Subject: [PATCH 136/155] fix 6: syntax typos in hyperlink --- doc/source/first_steps.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/doc/source/first_steps.rst b/doc/source/first_steps.rst index 18577e5..566dd06 100644 --- a/doc/source/first_steps.rst +++ b/doc/source/first_steps.rst @@ -1,7 +1,7 @@ First Steps =========== -**This tutorial is also available in the form of a `Jupyter Notebook `_ +**This tutorial is also available in the form of a `Jupyter Notebook `_. Try it out, and play!** Noodles is there to make your life easier, *in parallel*! The reason why Noodles can be easy and do parallel Python at the same time is its *functional* approach. In one part you'll define a set of functions that you'd like to run with Noodles, in an other part you'll compose these functions into a *workflow graph*. To make this approach work a function should not have any *side effects*. Let's not linger and just start noodling! First we define some functions to use. @@ -28,7 +28,7 @@ Now we can create a workflow composing several calls to this function. c = add(a, a) d = mul(b, c) -That looks easy enough; the funny thing is though, that nothing has been computed yet! Noodles just created the workflow graphs corresponding to the values that still need to be computed. Until such time, we work with the *promise* of a future value. Using the module ``pygraphviz`` (`pip install pygraphviz`, check `this post `_ if you have problems installing pygraphviz) we can look at the call graphs. +**That looks easy enough; the funny thing is though, that nothing has been computed yet! Noodles just created the workflow graphs corresponding to the values that still need to be computed. Until such time, we work with the *promise* of a future value. Using the module ``pygraphviz`` (`pip install pygraphviz`, check `this post `_ if you have problems installing pygraphviz) we can look at the call graphs.** .. code:: python From 70a9b7cfddac37b89ceb7bebdc451121f3f495f8 Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Mon, 18 Sep 2017 16:18:39 +0200 Subject: [PATCH 137/155] fix 7: syntax typos in hyperlink --- doc/source/first_steps.rst | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/doc/source/first_steps.rst b/doc/source/first_steps.rst index 566dd06..928fbf2 100644 --- a/doc/source/first_steps.rst +++ b/doc/source/first_steps.rst @@ -1,8 +1,7 @@ First Steps =========== -**This tutorial is also available in the form of a `Jupyter Notebook `_. -Try it out, and play!** +This tutorial is also available in the form of a `Jupyter Notebook `_. Try it out, and play! Noodles is there to make your life easier, *in parallel*! The reason why Noodles can be easy and do parallel Python at the same time is its *functional* approach. In one part you'll define a set of functions that you'd like to run with Noodles, in an other part you'll compose these functions into a *workflow graph*. To make this approach work a function should not have any *side effects*. Let's not linger and just start noodling! First we define some functions to use. @@ -28,7 +27,7 @@ Now we can create a workflow composing several calls to this function. c = add(a, a) d = mul(b, c) -**That looks easy enough; the funny thing is though, that nothing has been computed yet! Noodles just created the workflow graphs corresponding to the values that still need to be computed. Until such time, we work with the *promise* of a future value. Using the module ``pygraphviz`` (`pip install pygraphviz`, check `this post `_ if you have problems installing pygraphviz) we can look at the call graphs.** +That looks easy enough; the funny thing is though, that nothing has been computed yet! Noodles just created the workflow graphs corresponding to the values that still need to be computed. Until such time, we work with the *promise* of a future value. Using the module ``pygraphviz`` (`pip install pygraphviz`, check `this post `_ if you have problems installing pygraphviz) we can look at the call graphs. .. code:: python From 460f8be2bb9a7a7430992b97fc921e8fae33c074 Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Mon, 18 Sep 2017 16:24:08 +0200 Subject: [PATCH 138/155] fix 8: syntax typos in hyperlink --- doc/source/first_steps.rst | 3 +++ 1 file changed, 3 insertions(+) diff --git a/doc/source/first_steps.rst b/doc/source/first_steps.rst index 928fbf2..0ffb948 100644 --- a/doc/source/first_steps.rst +++ b/doc/source/first_steps.rst @@ -3,6 +3,9 @@ First Steps This tutorial is also available in the form of a `Jupyter Notebook `_. Try it out, and play! +|Jupyter Notebook |_ +|bobob `Jupyter Notebook `_ ooboboub |_ + Noodles is there to make your life easier, *in parallel*! The reason why Noodles can be easy and do parallel Python at the same time is its *functional* approach. In one part you'll define a set of functions that you'd like to run with Noodles, in an other part you'll compose these functions into a *workflow graph*. To make this approach work a function should not have any *side effects*. Let's not linger and just start noodling! First we define some functions to use. From dd0c3745b45eacbe70da88af96ebec6be5ba8b1c Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Mon, 18 Sep 2017 16:27:27 +0200 Subject: [PATCH 139/155] fix 9: syntax typos in hyperlink --- doc/source/first_steps.rst | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/doc/source/first_steps.rst b/doc/source/first_steps.rst index 0ffb948..1448d8e 100644 --- a/doc/source/first_steps.rst +++ b/doc/source/first_steps.rst @@ -1,10 +1,7 @@ First Steps =========== -This tutorial is also available in the form of a `Jupyter Notebook `_. Try it out, and play! - -|Jupyter Notebook |_ -|bobob `Jupyter Notebook `_ ooboboub |_ +**This tutorial is also available in the form of a** `Jupyter Notebook `_. **Try it out, and play!** Noodles is there to make your life easier, *in parallel*! The reason why Noodles can be easy and do parallel Python at the same time is its *functional* approach. In one part you'll define a set of functions that you'd like to run with Noodles, in an other part you'll compose these functions into a *workflow graph*. To make this approach work a function should not have any *side effects*. Let's not linger and just start noodling! First we define some functions to use. From 66fce7b4fea5a06418aa304a88cc9732b1aad586 Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Mon, 18 Sep 2017 16:36:29 +0200 Subject: [PATCH 140/155] nbsphinx added to conf.py extensions and notebook added to toc in index.rst --- doc/source/conf.py | 1 + doc/source/index.rst | 2 ++ 2 files changed, 3 insertions(+) diff --git a/doc/source/conf.py b/doc/source/conf.py index f7bb7c7..d6831f9 100644 --- a/doc/source/conf.py +++ b/doc/source/conf.py @@ -46,6 +46,7 @@ 'sphinx.ext.todo', 'sphinx.ext.coverage', 'sphinx.ext.mathjax', + 'nbsphinx', ] # Add any paths that contain templates here, relative to this directory. diff --git a/doc/source/index.rst b/doc/source/index.rst index 7fe920a..bc763a8 100644 --- a/doc/source/index.rst +++ b/doc/source/index.rst @@ -71,6 +71,8 @@ Documentation Contents development scheduler brokers + An interactive introduction.ipynb + Indices and tables ================== From 52872a760397621aa6f761f26bf8f8db6ad29a6d Mon Sep 17 00:00:00 2001 From: Hanno Spreeuw Date: Tue, 19 Sep 2017 11:55:59 +0200 Subject: [PATCH 141/155] Fixed spelling error --- doc/source/eating.rst | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/doc/source/eating.rst b/doc/source/eating.rst index ad802fe..6a34db0 100644 --- a/doc/source/eating.rst +++ b/doc/source/eating.rst @@ -205,11 +205,11 @@ If you need to setup some more aspects of the environment, load modules, set var a = [add(i, j) for i in range(5) for j in range(5)] b = accumulate(gather(*a)) - # XenonKeeper is the root Xenon object that gives access + # XenonKeeper is the root Xenon object that gives access # to the Xenon Java library with XenonKeeper() as Xe: - # We recommend loging in on your compute resource - # through private/public key pairs. This prevents + # We recommend loging in on your compute resource + # through private/public key pairs. This prevents # passwords ending up as ASCII in your source files. certificate = Xe.credentials.newCertificateCredential( 'ssh', os.environ['HOME'] + '/.ssh/id_rsa', '', '', None) From f8cb7477cc964eba402563db2ee5ba53ff0ce304 Mon Sep 17 00:00:00 2001 From: Hanno Spreeuw Date: Tue, 19 Sep 2017 14:40:25 +0200 Subject: [PATCH 142/155] Some background on the exceptions occurring when inspecting built-in functions. --- doc/source/poetry_tutorial.rst | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/doc/source/poetry_tutorial.rst b/doc/source/poetry_tutorial.rst index 534b91d..057c6fd 100644 --- a/doc/source/poetry_tutorial.rst +++ b/doc/source/poetry_tutorial.rst @@ -195,9 +195,9 @@ We could write in the last line of the ``sentence`` method, but the string format method doesn't support wrapping. We rely on getting the signature of a -function by calling ``inspect.signature``. In some cases of build-in -function this raises an exception. Note that this is a design flaw in Python, -not Noodles! We may find a work around for these cases in future versions of +function by calling ``inspect.signature``. When the built-in +function is implemented in C, this raises `exception `_. +We may find a work around for these cases in future versions of Noodles. For the moment we'll have to define a little wrapper function. .. code:: python From e5c42c6a4a872ad851bed27339a948f0b9f04847 Mon Sep 17 00:00:00 2001 From: Hanno Spreeuw Date: Tue, 19 Sep 2017 14:41:36 +0200 Subject: [PATCH 143/155] Adden 'an' --- doc/source/poetry_tutorial.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/source/poetry_tutorial.rst b/doc/source/poetry_tutorial.rst index 057c6fd..81b203c 100644 --- a/doc/source/poetry_tutorial.rst +++ b/doc/source/poetry_tutorial.rst @@ -196,7 +196,7 @@ We could write in the last line of the ``sentence`` method, but the string format method doesn't support wrapping. We rely on getting the signature of a function by calling ``inspect.signature``. When the built-in -function is implemented in C, this raises `exception `_. +function is implemented in C, this raises an `exception `_. We may find a work around for these cases in future versions of Noodles. For the moment we'll have to define a little wrapper function. From 469ae6ca2b3e38f945af1530f54adca6f7fb43db Mon Sep 17 00:00:00 2001 From: Vincent van Hees Date: Tue, 19 Sep 2017 14:51:58 +0200 Subject: [PATCH 144/155] sphinx notebook link added --- doc/source/conf.py | 1 + doc/source/index.rst | 24 ++++++++++++------------ 2 files changed, 13 insertions(+), 12 deletions(-) diff --git a/doc/source/conf.py b/doc/source/conf.py index d6831f9..edcae8e 100644 --- a/doc/source/conf.py +++ b/doc/source/conf.py @@ -47,6 +47,7 @@ 'sphinx.ext.coverage', 'sphinx.ext.mathjax', 'nbsphinx', + 'IPython.sphinxext.ipython_console_highlighting' ] # Add any paths that contain templates here, relative to this directory. diff --git a/doc/source/index.rst b/doc/source/index.rst index bc763a8..16043c9 100644 --- a/doc/source/index.rst +++ b/doc/source/index.rst @@ -60,18 +60,18 @@ Documentation Contents ====================== .. toctree:: - :maxdepth: 2 - - Introduction - eating - cooking - first_steps.ipynb - poetry_tutorial.ipynb - boil_tutorial - development - scheduler - brokers - An interactive introduction.ipynb + :maxdepth: 2 + + Introduction + eating + cooking + first_steps + poetry_tutorial + boil_tutorial + development + scheduler + brokers + An_interactive_introduction Indices and tables From 24b739306e76971113ca05d5851072b23cad3db5 Mon Sep 17 00:00:00 2001 From: Lars Ridder Date: Wed, 20 Sep 2017 18:19:55 +0200 Subject: [PATCH 145/155] Fix integration of ipython notebook "An interactive introduction" into sphyinx documentation #49 --- doc/source/an_interactive_introduction.ipynb | 1 + doc/source/index.rst | 2 +- doc/source/poetry.png | 1 + doc/source/pythagoras.png | 1 + 4 files changed, 4 insertions(+), 1 deletion(-) create mode 120000 doc/source/an_interactive_introduction.ipynb create mode 120000 doc/source/poetry.png create mode 120000 doc/source/pythagoras.png diff --git a/doc/source/an_interactive_introduction.ipynb b/doc/source/an_interactive_introduction.ipynb new file mode 120000 index 0000000..6a9792b --- /dev/null +++ b/doc/source/an_interactive_introduction.ipynb @@ -0,0 +1 @@ +../../notebooks/An interactive introduction.ipynb \ No newline at end of file diff --git a/doc/source/index.rst b/doc/source/index.rst index 16043c9..506a383 100644 --- a/doc/source/index.rst +++ b/doc/source/index.rst @@ -71,7 +71,7 @@ Documentation Contents development scheduler brokers - An_interactive_introduction + an_interactive_introduction Indices and tables diff --git a/doc/source/poetry.png b/doc/source/poetry.png new file mode 120000 index 0000000..c545758 --- /dev/null +++ b/doc/source/poetry.png @@ -0,0 +1 @@ +../../notebooks/poetry.png \ No newline at end of file diff --git a/doc/source/pythagoras.png b/doc/source/pythagoras.png new file mode 120000 index 0000000..fda8ed6 --- /dev/null +++ b/doc/source/pythagoras.png @@ -0,0 +1 @@ +../../notebooks/pythagoras.png \ No newline at end of file From 55f8d0c680ff835985495dada11da43d32144542 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Mon, 25 Sep 2017 22:56:11 +0200 Subject: [PATCH 146/155] export get_workflow function and use it in workflow plotting routine --- noodles/__init__.py | 3 ++- noodles/tutorial.py | 23 +++++++++++++++++------ 2 files changed, 19 insertions(+), 7 deletions(-) diff --git a/noodles/__init__.py b/noodles/__init__.py index 990ccc5..adefc45 100644 --- a/noodles/__init__.py +++ b/noodles/__init__.py @@ -2,6 +2,7 @@ delay, gather, lift, schedule, schedule_hint, unwrap, has_scheduled_methods, update_hints, unpack, quote, unquote, find_first, gather_dict, result, gather_all, maybe) +from noodles.workflow import (get_workflow) from .run.runners import run_parallel_with_display as run_logging from .run.runners import (run_single, run_parallel) from .run.process import run_process @@ -11,7 +12,7 @@ __version__ = "0.2.3" __all__ = ['schedule', 'schedule_hint', 'run_single', 'run_process', - 'run_logging', 'run_parallel', 'unwrap', + 'run_logging', 'run_parallel', 'unwrap', 'get_workflow', 'Scheduler', 'Storable', 'has_scheduled_methods', 'gather', 'gather_all', 'gather_dict', 'lift', 'unpack', 'maybe', 'delay', 'update_hints', 'quote', 'unquote', 'find_first', 'result'] diff --git a/noodles/tutorial.py b/noodles/tutorial.py index e16b7b1..e877445 100644 --- a/noodles/tutorial.py +++ b/noodles/tutorial.py @@ -1,22 +1,26 @@ from inspect import Parameter from graphviz import Digraph -from . import schedule, schedule_hint +from . import schedule, schedule_hint, get_workflow -#scheduled functions + +# scheduled functions @schedule def add(x, y): return x + y + @schedule_hint(display="{a} + {b}", confirm=True) def log_add(a, b): return a + b + @schedule def sub(x, y): return x - y + @schedule def mul(x, y): return x*y @@ -26,7 +30,8 @@ def mul(x, y): def accumulate(lst, start=0): return sum(lst, start) -#functions for printing workflow graphs in notebooks + +# functions for printing workflow graphs in notebooks def _format_arg_list(a, v): if len(a) == 0: @@ -48,12 +53,18 @@ def _format_arg_list(a, v): s += ")" return s -def get_workflow_graph(workflow): + +def get_workflow_graph(promise): + workflow = get_workflow(promise) + dot = Digraph() for i,n in workflow.nodes.items(): - dot.node(str(i), label="{0} \n {1}".format(n.foo.__name__, - _format_arg_list(n.bound_args.args, None))) + dot.node(str(i), label="{0} \n {1}".format( + n.foo.__name__, + _format_arg_list(n.bound_args.args, None))) + for i in workflow.links: for j in workflow.links[i]: dot.edge(str(i), str(j[0]), label=str(j[1].name)) + return dot From 6563f7e7b26c7be1a0bb7522434a21e81cbabdf0 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Mon, 25 Sep 2017 23:11:23 +0200 Subject: [PATCH 147/155] add notebook on prime numbers --- doc/source/index.rst | 1 + doc/source/prime_numbers.ipynb | 1 + notebooks/prime_numbers.ipynb | 287 +++++++++++++++++++++++++++++++++ setup.py | 4 +- 4 files changed, 292 insertions(+), 1 deletion(-) create mode 120000 doc/source/prime_numbers.ipynb create mode 100644 notebooks/prime_numbers.ipynb diff --git a/doc/source/index.rst b/doc/source/index.rst index 506a383..870d213 100644 --- a/doc/source/index.rst +++ b/doc/source/index.rst @@ -68,6 +68,7 @@ Documentation Contents first_steps poetry_tutorial boil_tutorial + prime_numbers development scheduler brokers diff --git a/doc/source/prime_numbers.ipynb b/doc/source/prime_numbers.ipynb new file mode 120000 index 0000000..4f76e42 --- /dev/null +++ b/doc/source/prime_numbers.ipynb @@ -0,0 +1 @@ +../../notebooks/prime_numbers.ipynb \ No newline at end of file diff --git a/notebooks/prime_numbers.ipynb b/notebooks/prime_numbers.ipynb new file mode 100644 index 0000000..0c5200b --- /dev/null +++ b/notebooks/prime_numbers.ipynb @@ -0,0 +1,287 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Real World Tutorial 3: Parallel Number crunching using Cython\n", + "\n", + "Python was not designed to be very good at parallel processing. There are two major problems at the core of the language that make it hard to implement parallel algorithms.\n", + "\n", + "* The Global Interpreter Lock\n", + "* Flexible object model\n", + "\n", + "The first of these issues is the most famous obstacle towards a convincing multi-threading approach, where a single instance of the Python interpreter runs in several threads. The second point is more subtle, but makes it harder to do multi-processing, where several independent instances of the Python interpreter work together to achieve parallelism. We will first explain an elegant way to work around the Global Interpreter Lock, or GIL: use Cython.\n", + "\n", + "### Using Cython to lift the GIL\n", + "The GIL means that the Python interpreter will only operate on one thread at a time. Even when we think we run in a gazillion threads, Python itself uses only one. Multi-threading in Python is only usefull to wait for I/O and to perform system calls. To do useful CPU intensive work in multi-threaded mode, we need to develop functions that are implemented in C, and tell Python when we call these functions not to worry about the GIL. The easiest way to achieve this, is to use Cython. We develop a number-crunching prime adder, and have it run in parallel threads. \n", + "\n", + "We'll load the ``multiprocessing``, ``threading`` and ``queue`` modules to do our plumbing, and the ``cython`` extension so we can do the number crunching, as is shown in [this blog post](https://lbolla.info/blog/2013/12/23/python-threads-cython-gil)." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The cython extension is already loaded. To reload it, use:\n", + " %reload_ext cython\n" + ] + } + ], + "source": [ + "%load_ext cython\n", + "import multiprocessing\n", + "import threading\n", + "import queue" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We define a function that computes the sum of all primes below a certain integer `n`, and don't try to be smart about it; the point is that it needs a lot of computation. These functions are designated ``nogil``, so that we can be certain no Python objects are accessed. Finally we create a single Python exposed function that uses the:\n", + "\n", + "```python\n", + " with nogil:\n", + " ...\n", + "```\n", + "\n", + "statement. This is a context-manager that lifts the GIL for the duration of its contents." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "%%cython\n", + "\n", + "from libc.math cimport ceil, sqrt\n", + "\n", + "\n", + "cdef inline int _is_prime(int n) nogil:\n", + " \"\"\"return a boolean, is the input integer a prime?\"\"\"\n", + " if n == 2:\n", + " return True\n", + " cdef int max_i = ceil(sqrt(n))\n", + " cdef int i = 2\n", + " while i <= max_i:\n", + " if n % i == 0:\n", + " return False\n", + " i += 1\n", + " return True\n", + "\n", + "\n", + "cdef unsigned long _sum_primes(int n) nogil:\n", + " \"\"\"return sum of all primes less than n \"\"\"\n", + " cdef unsigned long i = 0\n", + " cdef int x\n", + " for x in range(2, n):\n", + " if _is_prime(x):\n", + " i += x\n", + " return i\n", + "\n", + "\n", + "def sum_primes(int n):\n", + " with nogil:\n", + " result = _sum_primes(n)\n", + " return result" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In fact, we only loaded the ``multiprocessing`` module to get the number of CPUs on this machine. We also get a decent amount of work to do in the ``input_range``." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "We have 4 cores to work on!\n" + ] + } + ], + "source": [ + "input_range = range(int(1e6), int(2e6), int(5e4))\n", + "ncpus = multiprocessing.cpu_count()\n", + "print(\"We have {} cores to work on!\".format(ncpus))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's first run our tests in a single thread:" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "37550402023 41276629127 45125753695 49161463647 53433406131 57759511224 62287995772 66955471633 71881256647 76875349479 82074443256 87423357964 92878592188 98576757977 104450958704 110431974857 116581137847 122913801665 129451433482 136136977177 \n", + "CPU times: user 8.6 s, sys: 6.99 ms, total: 8.61 s\n", + "Wall time: 8.62 s\n" + ] + } + ], + "source": [ + "%%time\n", + "\n", + "for i in input_range:\n", + " print(sum_primes(i), end=' ', flush=True)\n", + "print()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can do better than that! We now create a queue containing the work to be done, and a pool of threads eating from this queue. The workers will keep on working as long as the queue has work for them." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "37550402023 41276629127 45125753695 49161463647 53433406131 57759511224 62287995772 66955471633 71881256647 76875349479 82074443256 87423357964 92878592188 98576757977 104450958704 110431974857 116581137847 122913801665 129451433482 136136977177 CPU times: user 14.7 s, sys: 7.84 ms, total: 14.7 s\n", + "Wall time: 4.07 s\n" + ] + } + ], + "source": [ + "%%time\n", + "\n", + "### We need to define a worker function that fetches jobs from the queue.\n", + "def worker(q):\n", + " while True:\n", + " try:\n", + " x = q.get(block=False)\n", + " print(sum_primes(x), end=' ', flush=True)\n", + " except queue.Empty:\n", + " break\n", + "\n", + "### Create the queue, and fill it with input values\n", + "work_queue = queue.Queue()\n", + "for i in input_range:\n", + " work_queue.put(i)\n", + "\n", + "### Start a number of threads\n", + "threads = [\n", + " threading.Thread(target=worker, args=(work_queue,))\n", + " for i in range(ncpus)]\n", + "\n", + "for t in threads:\n", + " t.start()\n", + "\n", + "### Wait until all of them are done\n", + "for t in threads:\n", + " t.join()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "On my laptop, a dual-core hyper-threaded `Intel(R) Core(TM) i5-5300U CPU`, this runs just over two times faster than the single threaded code. Setting up a queue and a pool of workers is quite cumbersome. Also, this approach doesn't scale up if the dependencies between our computations get more complex. Next we'll use Noodles to provide the multi-threaded environment to execute our work. We'll need three functions:\n", + "* ``schedule`` to decorate our work function\n", + "* ``run_parallel`` to run the work in parallel\n", + "* ``gather`` to collect our work into a workflow" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "from noodles import (schedule, run_parallel, gather)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "37550402023 41276629127 45125753695 49161463647 53433406131 57759511224 62287995772 66955471633 71881256647 76875349479 82074443256 87423357964 92878592188 98576757977 104450958704 110431974857 116581137847 122913801665 129451433482 136136977177 \n", + "CPU times: user 14.6 s, sys: 15.8 ms, total: 14.6 s\n", + "Wall time: 4.07 s\n" + ] + } + ], + "source": [ + "%%time\n", + "\n", + "@schedule\n", + "def s_sum_primes(n):\n", + " result = sum_primes(n)\n", + " print(result, end=' ', flush=True)\n", + " return result\n", + "\n", + "p_prime_sums = gather(*(s_sum_primes(i) for i in input_range))\n", + "prime_sums = run_parallel(p_prime_sums, n_threads=ncpus)\n", + "print()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "That does look much nicer!" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/setup.py b/setup.py index eac68ce..adbf88f 100755 --- a/setup.py +++ b/setup.py @@ -34,9 +34,11 @@ install_requires=['graphviz'], extras_require={ + 'doc': ['sphinx', 'shpinx_rtd_theme', 'nbsphinx'], 'prov': ['tinydb', 'ujson'], 'xenon': ['pyxenon'], 'numpy': ['numpy', 'h5py', 'msgpack-python', 'filelock'], - 'test': ['pytest', 'pytest-cov', 'codacy-coverage', 'pyflakes', 'pep8', 'docker-py'] + 'test': ['pytest', 'pytest-cov', 'codacy-coverage', 'pyflakes', 'pep8', + 'docker-py'] }, ) From b6285bc03c0359beab82651994d242a04b0bc0e8 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Mon, 25 Sep 2017 23:17:55 +0200 Subject: [PATCH 148/155] add nbsphinx to requirements.txt --- requirements.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/requirements.txt b/requirements.txt index e69de29..9518256 100644 --- a/requirements.txt +++ b/requirements.txt @@ -0,0 +1 @@ +nbsphinx From 165d9671015137779510cf3e31a501f0a777785f Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Mon, 25 Sep 2017 23:21:55 +0200 Subject: [PATCH 149/155] fix requirements.txt for readthedocs --- requirements.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/requirements.txt b/requirements.txt index 9518256..8e30686 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1 +1,2 @@ nbsphinx +ipykernel From ac2144cfa8d5cfc188ecb16c95836b9802a6b1ea Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Mon, 25 Sep 2017 23:29:30 +0200 Subject: [PATCH 150/155] fix some markdown in prime-number example --- notebooks/prime_numbers.ipynb | 40 ++++++++++++++--------------------- 1 file changed, 16 insertions(+), 24 deletions(-) diff --git a/notebooks/prime_numbers.ipynb b/notebooks/prime_numbers.ipynb index 0c5200b..d93a401 100644 --- a/notebooks/prime_numbers.ipynb +++ b/notebooks/prime_numbers.ipynb @@ -21,18 +21,9 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 1, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The cython extension is already loaded. To reload it, use:\n", - " %reload_ext cython\n" - ] - } - ], + "outputs": [], "source": [ "%load_ext cython\n", "import multiprocessing\n", @@ -56,7 +47,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": { "collapsed": true }, @@ -105,7 +96,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -131,7 +122,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -139,8 +130,8 @@ "output_type": "stream", "text": [ "37550402023 41276629127 45125753695 49161463647 53433406131 57759511224 62287995772 66955471633 71881256647 76875349479 82074443256 87423357964 92878592188 98576757977 104450958704 110431974857 116581137847 122913801665 129451433482 136136977177 \n", - "CPU times: user 8.6 s, sys: 6.99 ms, total: 8.61 s\n", - "Wall time: 8.62 s\n" + "CPU times: user 8.73 s, sys: 9.63 ms, total: 8.74 s\n", + "Wall time: 8.76 s\n" ] } ], @@ -161,15 +152,15 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "37550402023 41276629127 45125753695 49161463647 53433406131 57759511224 62287995772 66955471633 71881256647 76875349479 82074443256 87423357964 92878592188 98576757977 104450958704 110431974857 116581137847 122913801665 129451433482 136136977177 CPU times: user 14.7 s, sys: 7.84 ms, total: 14.7 s\n", - "Wall time: 4.07 s\n" + "37550402023 41276629127 49161463647 45125753695 53433406131 57759511224 62287995772 66955471633 71881256647 76875349479 82074443256 87423357964 92878592188 98576757977 104450958704 110431974857 116581137847 122913801665 129451433482 136136977177 CPU times: user 14.5 s, sys: 9.86 ms, total: 14.6 s\n", + "Wall time: 4.16 s\n" ] } ], @@ -208,6 +199,7 @@ "metadata": {}, "source": [ "On my laptop, a dual-core hyper-threaded `Intel(R) Core(TM) i5-5300U CPU`, this runs just over two times faster than the single threaded code. Setting up a queue and a pool of workers is quite cumbersome. Also, this approach doesn't scale up if the dependencies between our computations get more complex. Next we'll use Noodles to provide the multi-threaded environment to execute our work. We'll need three functions:\n", + "\n", "* ``schedule`` to decorate our work function\n", "* ``run_parallel`` to run the work in parallel\n", "* ``gather`` to collect our work into a workflow" @@ -215,7 +207,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 6, "metadata": { "collapsed": true }, @@ -226,16 +218,16 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "37550402023 41276629127 45125753695 49161463647 53433406131 57759511224 62287995772 66955471633 71881256647 76875349479 82074443256 87423357964 92878592188 98576757977 104450958704 110431974857 116581137847 122913801665 129451433482 136136977177 \n", - "CPU times: user 14.6 s, sys: 15.8 ms, total: 14.6 s\n", - "Wall time: 4.07 s\n" + "37550402023 45125753695 41276629127 49161463647 53433406131 57759511224 62287995772 66955471633 76875349479 71881256647 82074443256 87423357964 92878592188 98576757977 104450958704 110431974857 116581137847 129451433482 122913801665 136136977177 \n", + "CPU times: user 14.6 s, sys: 10.9 ms, total: 14.6 s\n", + "Wall time: 4.28 s\n" ] } ], From f1a5c80344e28d343327a1457f107afa359f12fe Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Tue, 26 Sep 2017 15:19:45 +0200 Subject: [PATCH 151/155] fine tune prime number notebook --- notebooks/prime_numbers.ipynb | 35 +++++++++++++++++++++++------------ 1 file changed, 23 insertions(+), 12 deletions(-) diff --git a/notebooks/prime_numbers.ipynb b/notebooks/prime_numbers.ipynb index d93a401..a6dcd1d 100644 --- a/notebooks/prime_numbers.ipynb +++ b/notebooks/prime_numbers.ipynb @@ -13,7 +13,7 @@ "\n", "The first of these issues is the most famous obstacle towards a convincing multi-threading approach, where a single instance of the Python interpreter runs in several threads. The second point is more subtle, but makes it harder to do multi-processing, where several independent instances of the Python interpreter work together to achieve parallelism. We will first explain an elegant way to work around the Global Interpreter Lock, or GIL: use Cython.\n", "\n", - "### Using Cython to lift the GIL\n", + "## Using Cython to lift the GIL\n", "The GIL means that the Python interpreter will only operate on one thread at a time. Even when we think we run in a gazillion threads, Python itself uses only one. Multi-threading in Python is only usefull to wait for I/O and to perform system calls. To do useful CPU intensive work in multi-threaded mode, we need to develop functions that are implemented in C, and tell Python when we call these functions not to worry about the GIL. The easiest way to achieve this, is to use Cython. We develop a number-crunching prime adder, and have it run in parallel threads. \n", "\n", "We'll load the ``multiprocessing``, ``threading`` and ``queue`` modules to do our plumbing, and the ``cython`` extension so we can do the number crunching, as is shown in [this blog post](https://lbolla.info/blog/2013/12/23/python-threads-cython-gil)." @@ -22,7 +22,9 @@ { "cell_type": "code", "execution_count": 1, - "metadata": {}, + "metadata": { + "collapsed": true + }, "outputs": [], "source": [ "%load_ext cython\n", @@ -117,6 +119,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "## Single thread\n", + "\n", "Let's first run our tests in a single thread:" ] }, @@ -130,8 +134,8 @@ "output_type": "stream", "text": [ "37550402023 41276629127 45125753695 49161463647 53433406131 57759511224 62287995772 66955471633 71881256647 76875349479 82074443256 87423357964 92878592188 98576757977 104450958704 110431974857 116581137847 122913801665 129451433482 136136977177 \n", - "CPU times: user 8.73 s, sys: 9.63 ms, total: 8.74 s\n", - "Wall time: 8.76 s\n" + "CPU times: user 8.62 s, sys: 5.05 ms, total: 8.62 s\n", + "Wall time: 8.63 s\n" ] } ], @@ -147,6 +151,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "## Multi-threading: Worker pool\n", + "\n", "We can do better than that! We now create a queue containing the work to be done, and a pool of threads eating from this queue. The workers will keep on working as long as the queue has work for them." ] }, @@ -159,8 +165,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "37550402023 41276629127 49161463647 45125753695 53433406131 57759511224 62287995772 66955471633 71881256647 76875349479 82074443256 87423357964 92878592188 98576757977 104450958704 110431974857 116581137847 122913801665 129451433482 136136977177 CPU times: user 14.5 s, sys: 9.86 ms, total: 14.6 s\n", - "Wall time: 4.16 s\n" + "37550402023 41276629127 45125753695 49161463647 53433406131 57759511224 62287995772 66955471633 71881256647 76875349479 82074443256 87423357964 92878592188 98576757977 104450958704 110431974857 116581137847 122913801665 129451433482 136136977177 \n", + "CPU times: user 14.7 s, sys: 9.1 ms, total: 14.7 s\n", + "Wall time: 3.98 s\n" ] } ], @@ -191,14 +198,18 @@ "\n", "### Wait until all of them are done\n", "for t in threads:\n", - " t.join()" + " t.join()\n", + "\n", + "print()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "On my laptop, a dual-core hyper-threaded `Intel(R) Core(TM) i5-5300U CPU`, this runs just over two times faster than the single threaded code. Setting up a queue and a pool of workers is quite cumbersome. Also, this approach doesn't scale up if the dependencies between our computations get more complex. Next we'll use Noodles to provide the multi-threaded environment to execute our work. We'll need three functions:\n", + "## Using Noodles\n", + "\n", + "On my laptop, a dual-core hyper-threaded `Intel(R) Core(TM) i5-5300U CPU`, this runs just over two times faster than the single threaded code. However, setting up a queue and a pool of workers is quite cumbersome. Also, this approach doesn't scale up if the dependencies between our computations get more complex. Next we'll use Noodles to provide the multi-threaded environment to execute our work. We'll need three functions:\n", "\n", "* ``schedule`` to decorate our work function\n", "* ``run_parallel`` to run the work in parallel\n", @@ -225,9 +236,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "37550402023 45125753695 41276629127 49161463647 53433406131 57759511224 62287995772 66955471633 76875349479 71881256647 82074443256 87423357964 92878592188 98576757977 104450958704 110431974857 116581137847 129451433482 122913801665 136136977177 \n", - "CPU times: user 14.6 s, sys: 10.9 ms, total: 14.6 s\n", - "Wall time: 4.28 s\n" + "37550402023 41276629127 45125753695 49161463647 53433406131 57759511224 62287995772 66955471633 71881256647 76875349479 82074443256 87423357964 92878592188 98576757977 104450958704 110431974857 116581137847 122913801665 129451433482 136136977177 \n", + "CPU times: user 14.7 s, sys: 11.8 ms, total: 14.7 s\n", + "Wall time: 4.08 s\n" ] } ], @@ -251,7 +262,7 @@ "collapsed": true }, "source": [ - "That does look much nicer!" + "That does look much nicer! We have much less code, the code we do have is clearly separating function and form, and this approach is easily expandable to more complex situations." ] } ], From ffc557d63a9776581d578487c7889f53b5a2bcbe Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Tue, 26 Sep 2017 16:57:19 +0200 Subject: [PATCH 152/155] grouped documentation --- doc/source/an_interactive_introduction.ipynb | 1 - doc/source/eating.rst | 13 +- doc/source/implementation.rst | 9 + doc/source/index.rst | 10 +- doc/source/poetry_tutorial.rst | 377 ------------------- doc/source/tutorials.rst | 10 + notebooks/An interactive introduction.ipynb | 68 +--- notebooks/first_steps.ipynb | 14 +- notebooks/poetry_tutorial.ipynb | 2 +- 9 files changed, 58 insertions(+), 446 deletions(-) delete mode 120000 doc/source/an_interactive_introduction.ipynb create mode 100644 doc/source/implementation.rst delete mode 100644 doc/source/poetry_tutorial.rst create mode 100644 doc/source/tutorials.rst diff --git a/doc/source/an_interactive_introduction.ipynb b/doc/source/an_interactive_introduction.ipynb deleted file mode 120000 index 6a9792b..0000000 --- a/doc/source/an_interactive_introduction.ipynb +++ /dev/null @@ -1 +0,0 @@ -../../notebooks/An interactive introduction.ipynb \ No newline at end of file diff --git a/doc/source/eating.rst b/doc/source/eating.rst index 6a34db0..afc0e16 100644 --- a/doc/source/eating.rst +++ b/doc/source/eating.rst @@ -1,6 +1,3 @@ -.. highlight:: python - :linenothreshold: 5 - Eating noodles (user docs) ========================== @@ -12,7 +9,7 @@ A first example Let's look at a small example of creating a diamond workflow, which consists of simple (arithmetic) functions: -:: +.. code:: python from noodles import run_single from noodles.tutorial import (add, sub, mul) @@ -52,7 +49,7 @@ At this point it is good to know what the module ``noodles.tutorial`` looks like It looks very simple. However, you should be aware of what happens behind the curtains, to understand the limitations of this approach. -:: +.. code:: python from noodles import schedule @@ -89,7 +86,7 @@ Doing things parallel Using the Noodles approach it becomes very easy to paralellise computations. Let's look at a second example. -:: +.. code:: python from noodles import (gather, run_parallel) from noodles.tutorial import (add, sub, mul, accumulate) @@ -125,7 +122,7 @@ However, schedule-decorated functions cannot easily see which arguments contain The :py:func:`gather ` function converts the list of promises into a promise of a list, making it clear to the scheduled function this argument is a promise. The :py:func:`gather ` function is defined as follows: -:: +.. code:: python @schedule def gather(*lst): @@ -190,7 +187,7 @@ The Xenon runner needs a way to setup the virtualenv on the remote side, so a wo If you need to setup some more aspects of the environment, load modules, set variables etc., modify this script and put it in the directory where you want to run the jobs. Specify this directory in the Python script. -:: +.. code:: python from noodles import ( serial, gather) diff --git a/doc/source/implementation.rst b/doc/source/implementation.rst new file mode 100644 index 0000000..99156e7 --- /dev/null +++ b/doc/source/implementation.rst @@ -0,0 +1,9 @@ +Implementation +============== + +.. toctree:: + :maxdepth: 2 + + development + scheduler + brokers diff --git a/doc/source/index.rst b/doc/source/index.rst index 870d213..b2f5b97 100644 --- a/doc/source/index.rst +++ b/doc/source/index.rst @@ -65,14 +65,8 @@ Documentation Contents Introduction eating cooking - first_steps - poetry_tutorial - boil_tutorial - prime_numbers - development - scheduler - brokers - an_interactive_introduction + tutorials + implementation Indices and tables diff --git a/doc/source/poetry_tutorial.rst b/doc/source/poetry_tutorial.rst deleted file mode 100644 index 81b203c..0000000 --- a/doc/source/poetry_tutorial.rst +++ /dev/null @@ -1,377 +0,0 @@ -.. highlight:: python - -Real World Tutorial 1: Translating Poetry -========================================= - -First example -------------- - -We build workflows by calling functions. The simplest example of this -is the "diamond workflow": - -.. code:: python - - from noodles import run_single - from noodles.tutorial import (add, sub, mul) - - u = add(5, 4) - v = sub(u, 3) - w = sub(u, 2) - x = mul(v, w) - - answer = run_single(x) - - print("The answer is {0}.".format(answer)) - -That looks like any other Python code! But this example is a bit silly. -How do we leverage Noodles to earn an honest living? Here's a slightly less -silly example (but only just!). We will build a small translation engine -that translates sentences by submitting each word to an online dictionary -over a Rest API. To do this we make loops ("For thou shalt make loops of -blue"). First we build the program as you would do in Python, then we -sprinkle some Noodles magic and make it work parallel! Furthermore, we'll -see how to: - - * make more loops - * cache results for reuse - -Making loops ------------- - -How do we make a parallel loop? Let's look at a -``map`` operation; in Python there are several ways to perform a -function on all elements in an array. For this example, we will -translate some words using the Glosbe service, which has a nice REST -interface. We first build some functionality to use this interface. - -.. code:: python - - import urllib.request - import json - import re - - - class Translate: - """Translate words and sentences in the worst possible way. The Glosbe - dictionary has a nice REST interface that we query for a phrase. We - then take the first result. To translate a sentence, we cut it in - pieces, translate it and paste it back into a Frankenstein monster.""" - def __init__(self, src_lang='en', tgt_lang='fy'): - self.src = src_lang - self.tgt = tgt_lang - self.url = 'https://glosbe.com/gapi/translate?' \ - 'from={src}&dest={tgt}&' \ - 'phrase={{phrase}}&format=json'.format( - src=src_lang, tgt=tgt_lang) - - def query_phrase(self, phrase): - url = self.url.format(phrase=phrase.lower()) - with urllib.request.urlopen(url) as response: - translation = json.loads(response.read().decode()) - return translation - - def word(self, phrase): - translation = self.query_phrase(phrase) - - if len(translation['tuc']) > 0 and 'phrase' in translation['tuc'][0]: - result = translation['tuc'][0]['phrase']['text'] - if phrase[0].isupper(): - return result.title() - else: - return result - else: - return "<" + phrase + ">" - - def sentence(self, phrase): - """Split a sentence into a list of words and a format string, - replacing each occurance of a word with '{}'. Map the words through - the translation engine and join them using the format string.""" - words = re.sub("[^\w]", " ", phrase).split() - space = re.sub("[\w]+", "{}", phrase) - return space.format(*map(self.word, words)) - -We start with a list of strings that desparately need translation. And add a little -routine to print it in a gracious manner. - -.. code:: python - - shakespeare = [ - "If music be the food of love, play on,", - "Give me excess of it; that surfeiting,", - "The appetite may sicken, and so die."] - - def print_poem(intro, poem): - print(intro) - for line in poem: - print(" ", line) - print() - - print_poem("Original:", shakespeare) - - -.. parsed-literal:: - - Original: - If music be the food of love, play on, - Give me excess of it; that surfeiting, - The appetite may sicken, and so die. - - - -Beginning Python programmers like to append things; this is *not* how you -are supposed to program in Python; if you do, please go and read Jeff -Knupp's *Writing Idiomatic Python*. - -.. code:: python - - shakespeare_auf_deutsch = [] - for line in shakespeare: - shakespeare_auf_deutsch.append( - Translate('en', 'de').sentence(line)) - print_poem("Auf Deutsch:", shakespeare_auf_deutsch) - - -.. parsed-literal:: - - Auf Deutsch: - Wenn Musik sein der Essen von Minne, spielen an, - Geben ich Übermaß von es; das übersättigend, - Der Appetit dürfen ekeln, und so sterben. - - -Rather use a comprehension like so: - -.. code:: python - - shakespeare_ynt_frysk = \ - (Translate('en', 'fy').sentence(line) for line in shakespeare) - print_poem("Yn it Frysk:", shakespeare_ynt_frysk) - - -.. parsed-literal:: - - Yn it Frysk: - At muzyk wêze de fiedsel fan leafde, boartsje oan, - Jaan by fersin fan it; dat , - De maaie , en dus deagean. - - - -Or use ``map``: - -.. code:: python - - shakespeare_pa_dansk = \ - map(Translate('en', 'da').sentence, shakespeare) - print_poem("På Dansk:", shakespeare_pa_dansk) - - -.. parsed-literal:: - - På Dansk: - Hvis musik være de mad af kærlighed, spil på, - Give mig udskejelser af det; som , - De appetit må , og så dø. - - -Noodlify! ---------- - -If your connection is a bit slow, you may find that the translations -take a while to process. Wouldn't it be nice to do it in parallel? How -much code would we have to change to get there in Noodles? Let's take -the slow part of the program and add a ``@schedule`` decorator, and run! -Sadly, it is not that simple. We can add ``@schedule`` to the ``word`` -method. This means that it will return a promise. - -- Rule: *Functions that take promises need to be scheduled functions, - or refer to a scheduled function at some level.* - -We could write - -:: - - return schedule(space.format)(*(self.word(w) for w in words)) - -in the last line of the ``sentence`` method, but the string format -method doesn't support wrapping. We rely on getting the signature of a -function by calling ``inspect.signature``. When the built-in -function is implemented in C, this raises an `exception `_. -We may find a work around for these cases in future versions of -Noodles. For the moment we'll have to define a little wrapper function. - -.. code:: python - - from noodles import schedule - - - @schedule - def format_string(s, *args, **kwargs): - return s.format(*args, **kwargs) - - - import urllib.request - import json - import re - - - class Translate: - """Translate words and sentences in the worst possible way. The Glosbe - dictionary has a nice REST interface that we query for a phrase. We - then take the first result. To translate a sentence, we cut it in - pieces, translate it and paste it back into a Frankenstein monster.""" - def __init__(self, src_lang='en', tgt_lang='fy'): - self.src = src_lang - self.tgt = tgt_lang - self.url = 'https://glosbe.com/gapi/translate?' \ - 'from={src}&dest={tgt}&' \ - 'phrase={{phrase}}&format=json'.format( - src=src_lang, tgt=tgt_lang) - - def query_phrase(self, phrase): - url = self.url.format(phrase=phrase.lower()) - with urllib.request.urlopen(url) as response: - translation = json.loads(response.read().decode()) - return translation - - @schedule - def word(self, phrase): - translation = self.query_phrase(phrase) - - if len(translation['tuc']) > 0 and 'phrase' in translation['tuc'][0]: - result = translation['tuc'][0]['phrase']['text'] - if phrase[0].isupper(): - return result.title() - else: - return result - else: - return "<" + phrase + ">" - - def sentence(self, phrase): - words = re.sub("[^\w]", " ", phrase).split() - space = re.sub("[\w]+", "{}", phrase) - - # translated_words now is a sequence of promises! - translated_words = map(self.word, words) - - # we may only pass them to another `schedule` function - # since `string.format` has no knowledge about promises. - return format_string(space, *map(self.word, words)) - - def __str__(self): - return "[{} -> {}]".format(self.src, self.tgt) - - def __serialize__(self, pack): - return pack({'src_lang': self.src, - 'tgt_lang': self.tgt}) - - @classmethod - def __construct__(cls, msg): - return cls(**msg) - -Let's take stock of the mutations to the original. We've added a -``@schedule`` decorator to ``word``, and changed a function call in -``sentence``. Also we added the ``__str__`` method; this is only needed -to plot the workflow graph. Let's run the new script. - -.. code:: python - - from noodles import gather - - shakespeare_en_esperanto = \ - map(Translate('en', 'eo').sentence, shakespeare) - - wf = gather(*shakespeare_en_esperanto) - draw_workflow('poetry.png', wf._workflow) - result = run_parallel(wf, n_threads=8) - print_poem("Shakespeare en Esperanto:", result) - - -.. parsed-literal:: - - Shakespeare en Esperanto: - Se muziko esti la manĝaĵo de ami, ludi sur, - Doni mi eksceso de ĝi; tio , - La apetito povi naŭzi, kaj tiel morti. - -The last peculiar thing that you may notice, is the ``gather`` function. -It collects the promises that ``map`` generates and creates a single new -promise. The definition of ``gather`` is very simple: - -:: - - @schedule - def gather(*lst): - return lst - -The workflow graph of the Esperanto translator script looks like this: - -.. figure:: _static/images/poetry.png - :alt: a poetic workflow - :align: center - :figwidth: 100% - -Dealing with repetition ------------------------ - -In the following example we have a line with some repetition. It would -be a shame to look up the repeated words twice, wouldn't it? - -.. code:: python - - line = "Mein Gott, mein Gott, warum hast Du mich verlassen?" - run_parallel(Translate('de', 'fr').sentence(line), n_threads=4) - - -.. parsed-literal:: - - 'Mon Dieu, mon Dieu, pourquoi as Tu me quitter?' - - - -To see how this program is being run, we monitor the job submission, -retrieval and result storage in a ``JobKeeper`` instance. - -.. code:: python - - from noodles.run.job_keeper import JobKeeper - from noodles.run.run_with_prov import run_parallel - from noodles import serial - - J = JobKeeper(keep=True) - wf = Translate('de', 'fr').sentence(line) - run_parallel(wf, - n_threads=4, registry=serial.base, - jobdb_file='matthew.json', job_keeper=J) - - - - -.. parsed-literal:: - - 'Mon Dieu, mon Dieu, pourquoi as Tu me quitter?' - -Now we can see how the results were obtained by inspecting the -``JobKeeper`` object. Running the first time, you may see that -some jobs *attached* themselves to other jobs as they are identical. - -Then try running above cell again. All the results should be cached -in the `matthew.json` file, and no queries are send to Glosbe, saving -us from certain doom of IP black listing. - -.. code:: python - - from itertools import starmap - import time - - def format_log_entry(tm, what, data, msg): - return "{}: {:16} - {}".format( - time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime(tm)), - '[' + what + ']', - data) - - for k,j in J.items(): - print('\n'.join(starmap(format_log_entry, j.log))) - print("-------------------------------------") - - diff --git a/doc/source/tutorials.rst b/doc/source/tutorials.rst new file mode 100644 index 0000000..53c0059 --- /dev/null +++ b/doc/source/tutorials.rst @@ -0,0 +1,10 @@ +Tutorials +========= + +.. toctree:: + :maxdepth: 2 + + first_steps + poetry_tutorial + boil_tutorial + prime_numbers diff --git a/notebooks/An interactive introduction.ipynb b/notebooks/An interactive introduction.ipynb index 88c951c..81c94c4 100644 --- a/notebooks/An interactive introduction.ipynb +++ b/notebooks/An interactive introduction.ipynb @@ -13,9 +13,7 @@ { "cell_type": "code", "execution_count": 1, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "from noodles import schedule\n", @@ -39,9 +37,7 @@ { "cell_type": "code", "execution_count": 2, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "a = add(1, 1)\n", @@ -60,9 +56,7 @@ { "cell_type": "code", "execution_count": 3, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "from draw_workflow import draw_workflow\n", @@ -88,9 +82,7 @@ { "cell_type": "code", "execution_count": 4, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [ { "data": { @@ -179,9 +171,7 @@ { "cell_type": "code", "execution_count": 6, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -221,9 +211,7 @@ { "cell_type": "code", "execution_count": 7, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -255,9 +243,7 @@ { "cell_type": "code", "execution_count": 8, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -287,9 +273,7 @@ { "cell_type": "code", "execution_count": 9, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -328,9 +312,7 @@ { "cell_type": "code", "execution_count": 10, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "from noodles import schedule\n", @@ -405,9 +387,7 @@ { "cell_type": "code", "execution_count": 11, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -464,9 +444,7 @@ { "cell_type": "code", "execution_count": 12, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [ { "data": { @@ -496,9 +474,7 @@ { "cell_type": "code", "execution_count": 13, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [ { "data": { @@ -526,9 +502,7 @@ { "cell_type": "code", "execution_count": 14, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -650,9 +624,7 @@ { "cell_type": "code", "execution_count": 16, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "from noodles import run_single\n", @@ -697,9 +669,7 @@ { "cell_type": "code", "execution_count": 17, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "from noodles import (schedule_hint, gather)\n", @@ -743,9 +713,7 @@ { "cell_type": "code", "execution_count": 18, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -811,9 +779,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.2rc1" + "version": "3.6.2" } }, "nbformat": 4, - "nbformat_minor": 0 + "nbformat_minor": 1 } diff --git a/notebooks/first_steps.ipynb b/notebooks/first_steps.ipynb index ea9d4ef..e687b05 100644 --- a/notebooks/first_steps.ipynb +++ b/notebooks/first_steps.ipynb @@ -58,6 +58,18 @@ "That looks easy enough; the funny thing is though, that nothing has been computed yet! Noodles just created the workflow graphs corresponding to the values that still need to be computed. Until such time, we work with the *promise* of a future value. Using some function in `pygraphviz` we can look at the call graphs." ] }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "from noodles.tutorial import get_workflow_graph\n", + "\n", + "for i, wf in enumerate([a, b, c, d]):\n", + " get_workflow_graph(wf).render(\"wf{}.svg\".format(i))" + ] + }, { "cell_type": "code", "execution_count": 3, @@ -125,7 +137,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.2" + "version": "3.6.2" } }, "nbformat": 4, diff --git a/notebooks/poetry_tutorial.ipynb b/notebooks/poetry_tutorial.ipynb index 7fb797a..1e00152 100644 --- a/notebooks/poetry_tutorial.ipynb +++ b/notebooks/poetry_tutorial.ipynb @@ -894,7 +894,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.2" + "version": "3.6.2" } }, "nbformat": 4, From d4d7c45945540d929d2c6dfdcdf1807ece48bdf7 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Tue, 26 Sep 2017 17:00:14 +0200 Subject: [PATCH 153/155] fix license in documentation --- doc/source/index.rst | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/doc/source/index.rst b/doc/source/index.rst index b2f5b97..2e634d2 100644 --- a/doc/source/index.rst +++ b/doc/source/index.rst @@ -21,7 +21,7 @@ Assumed knowledge for this tutorial: Familiarity with basics of the Python langu Copyright & Licence ------------------- -Noodles 0.1.0 is copyright by the *Netherlands eScience Center (NLeSC)* and released under the `LGPLv3`_. +Noodles 0.1.0 is copyright by the *Netherlands eScience Center (NLeSC)* and released under the Apache v2 License. See http://www.esciencecenter.nl for more information on the NLeSC. @@ -30,13 +30,10 @@ Installation .. WARNING:: We don't support Python versions lower than 3.5. -The core of Noodles runs on **Python 3.5**. To run Noodles on your own machine, no extra dependencies are required. It is advised to install Noodles in a virtualenv. If you want support for `Xenon`_, install `pyxenon`_ too. +The core of Noodles runs on **Python 3.5** and above. To run Noodles on your own machine, no extra dependencies are required. It is advised to install Noodles in a virtualenv. If you want support for `Xenon`_, install `pyxenon`_ too. .. code-block:: bash - # pyxenon needs Java, which may need JAVA_HOME to be set, put it in .bashrc - export JAVA_HOME="/usr/lib/jvm/default-java" # or similar... - # create the virtualenv virtualenv -p python3 . /bin/activate @@ -78,6 +75,5 @@ Indices and tables .. _Xenon: http://nlesc.github.io/Xenon/ .. _pyxenon: http://github.com/NLeSC/pyxenon -.. _LGPLv3: http://www.gnu.org/licenses/lgpl-3.0.html .. _`generating SSH keys`: https://help.github.com/articles/generating-ssh-keys/ .. _`decorators`: https://www.thecodeship.com/patterns/guide-to-python-function-decorators/ From 16b5f64a07292075e3decd84150f61f20cde2f21 Mon Sep 17 00:00:00 2001 From: Johan Hidding Date: Tue, 26 Sep 2017 17:00:41 +0200 Subject: [PATCH 154/155] fix version number --- doc/source/index.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/source/index.rst b/doc/source/index.rst index 2e634d2..060c72e 100644 --- a/doc/source/index.rst +++ b/doc/source/index.rst @@ -21,7 +21,7 @@ Assumed knowledge for this tutorial: Familiarity with basics of the Python langu Copyright & Licence ------------------- -Noodles 0.1.0 is copyright by the *Netherlands eScience Center (NLeSC)* and released under the Apache v2 License. +Noodles 0.3.0 is copyright by the *Netherlands eScience Center (NLeSC)* and released under the Apache v2 License. See http://www.esciencecenter.nl for more information on the NLeSC. From 95beadaae06c568fa43b63f1d8245b68ce7fdf71 Mon Sep 17 00:00:00 2001 From: Johannes Hidding Date: Fri, 10 Nov 2017 12:50:33 +0100 Subject: [PATCH 155/155] Add Zenodo DOI badge to readme --- README.rst | 3 +++ 1 file changed, 3 insertions(+) diff --git a/README.rst b/README.rst index 658cecc..968888a 100644 --- a/README.rst +++ b/README.rst @@ -3,6 +3,9 @@ .. image:: https://api.codacy.com/project/badge/Grade/f45b3299dbb74ccb8f766701563a88db :target: https://www.codacy.com/app/Noodles/noodles?utm_source=github.com&utm_medium=referral&utm_content=NLeSC/noodles&utm_campaign=Badge_Grade :alt: Codacy Badge +.. image:: https://zenodo.org/badge/45391130.svg + :target: https://zenodo.org/badge/latestdoi/45391130 + :alt: DOI .. image:: https://api.codacy.com/project/badge/Coverage/f45b3299dbb74ccb8f766701563a88db :target: https://www.codacy.com/app/Noodles/noodles?utm_source=github.com&utm_medium=referral&utm_content=NLeSC/noodles&utm_campaign=Badge_Coverage :alt: Coverage Badge