From 678b0ec03f1b6911e36f066021d56fafe318c70c Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Tue, 25 Oct 2022 15:18:43 +0200 Subject: [PATCH 001/168] Add env EXEC_SCRIPT --- pynest/nest/server/hl_api_server.py | 36 +++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index be090d84da..229f53b7bf 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -41,6 +41,7 @@ import os +<<<<<<< HEAD MODULES = os.environ.get("NEST_SERVER_MODULES", "nest").split(",") RESTRICTION_OFF = bool(os.environ.get("NEST_SERVER_RESTRICTION_OFF", False)) EXCEPTION_ERROR_STATUS = 400 @@ -49,6 +50,29 @@ msg = "NEST Server runs without a RestrictedPython trusted environment." print(f"***\n*** WARNING: {msg}\n***") +======= +def get_boolean_environ(env_key, default_value = 'false'): + env_value = os.environ.get(env_key, default_value) + return env_value.lower() in ['yes', 'true', 't', '1'] + +EXEC_SCRIPT = get_boolean_environ('NEST_SERVER_EXEC_SCRIPT') +MODULES = os.environ.get('NEST_SERVER_MODULES', 'nest').split(',') +RESTRICTION_OFF = get_boolean_environ('NEST_SERVER_RESTRICTION_OFF') +EXCEPTION_ERROR_STATUS = 400 + +if EXEC_SCRIPT: + print(80 * '*') + msg = ("\n" + 9*" ").join([ + 'NEST Server runs with the `exec` command activated.', + 'This means that any code can be executed!', + 'The security of your system can not be ensured!' + ]) + print(f'WARNING: {msg}') + if RESTRICTION_OFF: + msg = 'NEST Server runs without a RestrictedPython trusted environment.' + print(f'WARNING: {msg}') + print(80 * '*') +>>>>>>> f3abc5e61 (Add env EXEC_SCRIPT) __all__ = [ "app", @@ -164,9 +188,21 @@ def do_call(call_name, args=[], kwargs={}): def route_exec(): """Route to execute script in Python.""" +<<<<<<< HEAD args, kwargs = get_arguments(request) response = do_call("exec", args, kwargs) return jsonify(response) +======= + if EXEC_SCRIPT: + args, kwargs = get_arguments(request) + response = do_call('exec', args, kwargs) + return jsonify(response) + else: + abort(Response( + 'The route `/exec` has been disabled. Please contact the server administrator.', + 403 + )) +>>>>>>> f3abc5e61 (Add env EXEC_SCRIPT) # -------------------------- From 50ffba03b4839cffa27fe72ebfa8fcb60018cd18 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Tue, 25 Oct 2022 15:18:59 +0200 Subject: [PATCH 002/168] Cleanup nest-server --- bin/nest-server | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bin/nest-server b/bin/nest-server index 9d8734b1b8..4c226a37c7 100755 --- a/bin/nest-server +++ b/bin/nest-server @@ -56,7 +56,7 @@ start() { if [ "${DAEMON}" -eq 0 ]; then echo "Use CTRL + C to stop this service." if [ "${STDOUT}" -eq 1 ]; then - echo "-------------------------------------------------" + echo "-----------------------------------------------------" fi fi From 1b2f5a1a033826e6b9cb20b370862c37a932ca4b Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Tue, 25 Oct 2022 15:19:08 +0200 Subject: [PATCH 003/168] Add changes for v3.4 --- doc/htmldoc/whats_new/v3.4/index.rst | 58 ++++++++++------------------ 1 file changed, 20 insertions(+), 38 deletions(-) diff --git a/doc/htmldoc/whats_new/v3.4/index.rst b/doc/htmldoc/whats_new/v3.4/index.rst index be69bbaa9a..ae80fe734b 100644 --- a/doc/htmldoc/whats_new/v3.4/index.rst +++ b/doc/htmldoc/whats_new/v3.4/index.rst @@ -17,10 +17,11 @@ If you transition from an earlier version, please see our extensive Documentation restructuring and new theme ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -NEST documentation has a new theme! We did a major overhaul of the -layout and structure of the documentation. The changes aim to improve -findability and access of content. With a more modern layout, our wide -range of docs can be discovered more easily. +NEST documentation has a new theme! We did a major overhaul of the layout and structure of the documentation. +The changes aim to improve findability and access of content. With a more modern +layout, our wide range of docs can be discovered more easily. +The table of contents is simplified and the content is grouped based on topic (neurons, synapses etc) +rather than type of documentation (e.g., 'guides'). The table of contents is simplified and the content is grouped based on topics (neurons, synapses etc) rather than type of documentation @@ -35,10 +36,12 @@ GitHub Query spatially structured networks from target neuron perspective ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -PyNEST now provides functions :py:func:`.GetSourceNodes`, -:py:func:`.GetSourcePositions`, and :py:func:`.PlotSources` which -allow you to query or plot the source neurons of a given target -neuron. +Spatial layers can be created by specifying only the node positions using ``spatial.free``, +without explicitly specifying the ``extent``. +In that case, in NEST 3.4 and later, the ``extent`` will be determined by the position of the +lower-leftmost and upper-rightmost nodes in the layer; earlier versions of NEST added a hard-coded +padding to the extent. The ``center`` is computed as the midpoint between the lower-leftmost and +upper-rightmost nodes. Extent and center for spatial layers with freely placed neurons ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -53,36 +56,15 @@ and upper-rightmost nodes in the layer, if omitted. While earlier versions of NEST added a hard-coded padding, NEST 3.4 will only use the node positions. -Likewise, the ``center`` of a layer is now automatically computed as -the midpoint between the lower-leftmost and the upper-rightmost nodes. +* Model ``spike_dilutor`` is now deprecated and can only be used + in single-threaded mode. To implement connections which transmit + spikes with fixed probability, use ``bernoulli_synapse`` instead. -When creating a layer with only a single node, the ``extent`` still -has to be specified explicitly. -Disconnect with ``SynapseCollection`` -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Changes in NEST Server +~~~~~~~~~~~~~~~~~~~~~~ -It is now possible to disconnect nodes using a ``SynapseCollection`` -as argument to either :py:func:`.disconnect` or the member function -``disconnect()`` of the ``SynapseCollection``. - -Removal of deprecated models -~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -* The models ``iaf_psc_alpha_canon`` and ``pp_pop_psc_delta`` have - long been deprecated and were now removed from NEST. In case you - depend on them, you will find similar functionality in the - replacement models :doc:`iaf_psc_alpha_ps - ` and :doc:`iaf_psc_alpha_ps - `, respectively. - -* Model ``spike_dilutor`` is now deprecated and can only be used in - single-threaded mode. To implement connections which transmit spikes - with fixed probability, use :doc:`bernoulli_synapse - ` instead. - -Changed port of NEST Server -~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -To avoid conflicts with other services, the default port for NEST -Server has been changed from 5000 to 52025. +* By default NEST Server runs on port 52425 (previously 5000). +* Minimize security risk in NEST Server. + * By default exec call is disabled, only API calls are enabled. + * The user is able to turn on exec call which means that the user is aware of the risk. From bb72edcf3c11b49f0a0d90a68f1af7ae78f804e0 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Thu, 27 Oct 2022 12:18:52 +0200 Subject: [PATCH 004/168] Set Origins in CORS --- pynest/nest/server/hl_api_server.py | 28 +++++++++------------------- 1 file changed, 9 insertions(+), 19 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 229f53b7bf..a95e721c38 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -41,20 +41,11 @@ import os -<<<<<<< HEAD -MODULES = os.environ.get("NEST_SERVER_MODULES", "nest").split(",") -RESTRICTION_OFF = bool(os.environ.get("NEST_SERVER_RESTRICTION_OFF", False)) -EXCEPTION_ERROR_STATUS = 400 - -if RESTRICTION_OFF: - msg = "NEST Server runs without a RestrictedPython trusted environment." - print(f"***\n*** WARNING: {msg}\n***") - -======= def get_boolean_environ(env_key, default_value = 'false'): env_value = os.environ.get(env_key, default_value) return env_value.lower() in ['yes', 'true', 't', '1'] +CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', 'localhost') EXEC_SCRIPT = get_boolean_environ('NEST_SERVER_EXEC_SCRIPT') MODULES = os.environ.get('NEST_SERVER_MODULES', 'nest').split(',') RESTRICTION_OFF = get_boolean_environ('NEST_SERVER_RESTRICTION_OFF') @@ -72,7 +63,6 @@ def get_boolean_environ(env_key, default_value = 'false'): msg = 'NEST Server runs without a RestrictedPython trusted environment.' print(f'WARNING: {msg}') print(80 * '*') ->>>>>>> f3abc5e61 (Add env EXEC_SCRIPT) __all__ = [ "app", @@ -83,12 +73,18 @@ def get_boolean_environ(env_key, default_value = 'false'): ] app = Flask(__name__) -CORS(app) +CORS(app, resources={r"/*": {"origins": f"{CORS_ORIGINS}"}) mpi_comm = None -@app.route("/", methods=["GET"]) +@app.after_request +def add_header(response): + response.headers['Access-Control-Allow-Origin'] = CORS_ORIGINS + return response + + +@app.route('/', methods=['GET']) def index(): return jsonify( { @@ -188,11 +184,6 @@ def do_call(call_name, args=[], kwargs={}): def route_exec(): """Route to execute script in Python.""" -<<<<<<< HEAD - args, kwargs = get_arguments(request) - response = do_call("exec", args, kwargs) - return jsonify(response) -======= if EXEC_SCRIPT: args, kwargs = get_arguments(request) response = do_call('exec', args, kwargs) @@ -202,7 +193,6 @@ def route_exec(): 'The route `/exec` has been disabled. Please contact the server administrator.', 403 )) ->>>>>>> f3abc5e61 (Add env EXEC_SCRIPT) # -------------------------- From 886ee907e760f95d0ad4aafa66eb8107e9249d94 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Thu, 27 Oct 2022 12:58:53 +0200 Subject: [PATCH 005/168] Add cross origin for / --- pynest/nest/server/hl_api_server.py | 1 + 1 file changed, 1 insertion(+) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index a95e721c38..86810a121e 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -85,6 +85,7 @@ def add_header(response): @app.route('/', methods=['GET']) +@cross_origin() def index(): return jsonify( { From 9f400467896b98efa8c3f0c2cb98271248f3315b Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Thu, 27 Oct 2022 14:53:42 +0200 Subject: [PATCH 006/168] Extend cors_origins --- pynest/nest/server/hl_api_server.py | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 86810a121e..76809e0a57 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -45,7 +45,7 @@ def get_boolean_environ(env_key, default_value = 'false'): env_value = os.environ.get(env_key, default_value) return env_value.lower() in ['yes', 'true', 't', '1'] -CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', 'localhost') +CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', 'http://localhost:8000').split(',') EXEC_SCRIPT = get_boolean_environ('NEST_SERVER_EXEC_SCRIPT') MODULES = os.environ.get('NEST_SERVER_MODULES', 'nest').split(',') RESTRICTION_OFF = get_boolean_environ('NEST_SERVER_RESTRICTION_OFF') @@ -73,14 +73,22 @@ def get_boolean_environ(env_key, default_value = 'false'): ] app = Flask(__name__) -CORS(app, resources={r"/*": {"origins": f"{CORS_ORIGINS}"}) +CORS(app, CORS_ORIGINS=CORS_ORIGINS) mpi_comm = None @app.after_request -def add_header(response): - response.headers['Access-Control-Allow-Origin'] = CORS_ORIGINS +def cors_origin(response): + # https://kurianbenoy.com/2021-07-04-CORS/ + response.headers["Access-Control-Allow-Origin"] = "null" + request_origin = request.headers['Origin'] + if len(CORS_ORIGINS) == 0 or "*" in CORS_ORIGINS: + response.headers["Access-Control-Allow-Origin"] = "*" + else: + for allowed_origin in CORS_ORIGINS: + if allowed_origin in request_origin: + response.headers["Access-Control-Allow-Origin"] = allowed_origin return response From 00eb651298170f908768979d3419c7e5dbcf2d18 Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Thu, 27 Oct 2022 15:18:56 +0200 Subject: [PATCH 007/168] Display Python `logging`, even while server is active. --- pynest/nest/server/hl_api_server.py | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 76809e0a57..17a3cd66c6 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -21,11 +21,18 @@ import importlib import inspect +import logging import io import sys from flask import Flask, request, jsonify from flask_cors import CORS, cross_origin +from flask.logging import default_handler + +# This ensures that the logging information shows up in the console running the server, +# even when Flask's event loop is running. +root = logging.getLogger() +root.addHandler(default_handler) from werkzeug.exceptions import abort from werkzeug.wrappers import Response From 6a5591b36444ceca43bd2daceb27e394fb238957 Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Thu, 27 Oct 2022 15:27:19 +0200 Subject: [PATCH 008/168] Apply CORS headers --- pynest/nest/server/hl_api_server.py | 30 ++++++++--------------------- 1 file changed, 8 insertions(+), 22 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 17a3cd66c6..cf9a8ec85a 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -26,7 +26,7 @@ import sys from flask import Flask, request, jsonify -from flask_cors import CORS, cross_origin +from flask_cors import CORS from flask.logging import default_handler # This ensures that the logging information shows up in the console running the server, @@ -52,7 +52,8 @@ def get_boolean_environ(env_key, default_value = 'false'): env_value = os.environ.get(env_key, default_value) return env_value.lower() in ['yes', 'true', 't', '1'] -CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', 'http://localhost:8000').split(',') +_default_origins = 'localhost,http://localhost,https://localhost' +CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', _default_origins).split(',') EXEC_SCRIPT = get_boolean_environ('NEST_SERVER_EXEC_SCRIPT') MODULES = os.environ.get('NEST_SERVER_MODULES', 'nest').split(',') RESTRICTION_OFF = get_boolean_environ('NEST_SERVER_RESTRICTION_OFF') @@ -80,27 +81,14 @@ def get_boolean_environ(env_key, default_value = 'false'): ] app = Flask(__name__) -CORS(app, CORS_ORIGINS=CORS_ORIGINS) +# Inform client-side user agents that they should not attempt to call our server from any +# non-whitelisted domain. +CORS(app, origins=CORS_ORIGINS, methods=["GET", "POST"]) mpi_comm = None -@app.after_request -def cors_origin(response): - # https://kurianbenoy.com/2021-07-04-CORS/ - response.headers["Access-Control-Allow-Origin"] = "null" - request_origin = request.headers['Origin'] - if len(CORS_ORIGINS) == 0 or "*" in CORS_ORIGINS: - response.headers["Access-Control-Allow-Origin"] = "*" - else: - for allowed_origin in CORS_ORIGINS: - if allowed_origin in request_origin: - response.headers["Access-Control-Allow-Origin"] = allowed_origin - return response - - @app.route('/', methods=['GET']) -@cross_origin() def index(): return jsonify( { @@ -195,8 +183,7 @@ def do_call(call_name, args=[], kwargs={}): return combine(call_name, response) -@app.route("/exec", methods=["GET", "POST"]) -@cross_origin() +@app.route('/exec', methods=['GET', 'POST']) def route_exec(): """Route to execute script in Python.""" @@ -227,8 +214,7 @@ def route_api(): return jsonify(nest_calls) -@app.route("/api/", methods=["GET", "POST"]) -@cross_origin() +@app.route('/api/', methods=['GET', 'POST']) def route_api_call(call): """Route to call function in NEST.""" print(f"\n{'='*40}\n", flush=True) From d6f87f834c4abf41c1b100b132f3de269908622a Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Thu, 27 Oct 2022 15:35:48 +0200 Subject: [PATCH 009/168] forgot 1 --- pynest/nest/server/hl_api_server.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index cf9a8ec85a..8210a0db6d 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -207,8 +207,7 @@ def route_exec(): nest_calls.sort() -@app.route("/api", methods=["GET"]) -@cross_origin() +@app.route('/api', methods=['GET']) def route_api(): """Route to list call functions in NEST.""" return jsonify(nest_calls) From ab2e525ec7bc2dafbcaf6a80de700c55d079fcb2 Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Thu, 27 Oct 2022 16:22:58 +0200 Subject: [PATCH 010/168] Vanishing application and authentication :) --- pynest/nest/server/hl_api_server.py | 73 ++++++++++++++++++++++++----- 1 file changed, 60 insertions(+), 13 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 8210a0db6d..dfc41e31cc 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -34,10 +34,7 @@ root = logging.getLogger() root.addHandler(default_handler) -from werkzeug.exceptions import abort -from werkzeug.wrappers import Response - -import nest +# import nest import RestrictedPython import time @@ -87,15 +84,65 @@ def get_boolean_environ(env_key, default_value = 'false'): mpi_comm = None +# Self sufficient, dissapearing authentication function: +# +# * Generates the login token based on salted hash of the ID of this object and the +# current time measured by `perf_counter` giving us enough entropy. +# * Stores the token on this function. +# * Removes all `nest` accessible references to it, only `app` and `gc` have it, and the +# reference this module holds to `app` is deleted before the first request goes through. +@app.before_request +def check_token(): + try: + import inspect + import gc + import time + import hashlib + import hmac + + + frame = inspect.currentframe() + code = frame.f_code + globs = frame.f_globals + functype = type(lambda: 0) + funcs = [] + for func in gc.get_referrers(code): + if type(func) is functype: + if getattr(func, "__code__", None) is code: + if getattr(func, "__globals__", None) is globs: + funcs.append(func) + if len(funcs) > 1: + return ("Unauthorized", 403) + self = funcs[0] + if not hasattr(self, "_hash"): + hasher = hashlib.sha512() + hasher.update(str(hash(id(self))).encode("utf-8")) + hasher.update(str(time.perf_counter()).encode("utf-8")) + self._hash = hasher.hexdigest() + print("") + print(" Bearer token to login to the NEST server with: ", self._hash) + print("") + auth = request.headers["Authorization"] + # The line above triggers an error because below we call `check_token` outside of + # any request context. The next time, before the app calls the request route + # handler, this line will remove the reference this module holds to `app` as well. + del globals()["app"] + # Use constant-time comparison to avoid timing attacks. + if not hmac.compare_digest(auth, f"Bearer {self._hash}"): + return ("Unauthorized", 403) + except Exception: + return ("Unauthorized", 403) + +check_token() +del check_token + @app.route('/', methods=['GET']) def index(): - return jsonify( - { - "nest": nest.__version__, - "mpi": mpi_comm is not None, - } - ) + return jsonify({ + 'nest': 1, + 'mpi': mpi_comm is not None, + }) def do_exec(args, kwargs): @@ -129,7 +176,7 @@ def do_exec(args, kwargs): except Exception as e: for line in traceback.format_exception(*sys.exc_info()): print(line, flush=True) - abort(Response(str(e), EXCEPTION_ERROR_STATUS)) + flask.abort(EXCEPTION_ERROR_STATUS, str(e)) def log(call_name, msg): @@ -202,8 +249,8 @@ def route_exec(): # RESTful API # -------------------------- -nest_calls = dir(nest) -nest_calls = list(filter(lambda x: not x.startswith("_"), nest_calls)) +nest_calls = [] +nest_calls = list(filter(lambda x: not x.startswith('_'), nest_calls)) nest_calls.sort() From b8417b87df228e80898c5a98d6f3a0aa26b14aa7 Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Thu, 27 Oct 2022 16:42:47 +0200 Subject: [PATCH 011/168] Allowed authentication to be disabled. --- pynest/nest/server/hl_api_server.py | 43 +++++++++++++++++++---------- 1 file changed, 29 insertions(+), 14 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index dfc41e31cc..9c365206ce 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -50,6 +50,7 @@ def get_boolean_environ(env_key, default_value = 'false'): return env_value.lower() in ['yes', 'true', 't', '1'] _default_origins = 'localhost,http://localhost,https://localhost' +DISABLE_AUTHENTICATION = os.environ.get('NEST_DISABLE_AUTHENTICATION', False) == "TRUE" CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', _default_origins).split(',') EXEC_SCRIPT = get_boolean_environ('NEST_SERVER_EXEC_SCRIPT') MODULES = os.environ.get('NEST_SERVER_MODULES', 'nest').split(',') @@ -84,7 +85,7 @@ def get_boolean_environ(env_key, default_value = 'false'): mpi_comm = None -# Self sufficient, dissapearing authentication function: +# Self sufficient, dissapearing authentication function # # * Generates the login token based on salted hash of the ID of this object and the # current time measured by `perf_counter` giving us enough entropy. @@ -92,7 +93,7 @@ def get_boolean_environ(env_key, default_value = 'false'): # * Removes all `nest` accessible references to it, only `app` and `gc` have it, and the # reference this module holds to `app` is deleted before the first request goes through. @app.before_request -def check_token(): +def setup_auth(): try: import inspect import gc @@ -119,22 +120,36 @@ def check_token(): hasher.update(str(hash(id(self))).encode("utf-8")) hasher.update(str(time.perf_counter()).encode("utf-8")) self._hash = hasher.hexdigest() - print("") - print(" Bearer token to login to the NEST server with: ", self._hash) - print("") + if not DISABLE_AUTHENTICATION: + print("") + print(" Bearer token to login to the NEST server with: ", self._hash) + print("") + # Control flow explanation: The first time we hit this line is when below the + # function definition we call `setup_auth` without any request existing yet, + # so the function exits here after generating and storing the auth hash. auth = request.headers["Authorization"] - # The line above triggers an error because below we call `check_token` outside of - # any request context. The next time, before the app calls the request route - # handler, this line will remove the reference this module holds to `app` as well. - del globals()["app"] - # Use constant-time comparison to avoid timing attacks. - if not hmac.compare_digest(auth, f"Bearer {self._hash}"): + # We continue here the next time this function is called, which is before the + # Flask app handles a request. At that point we also remove this module's + # reference to the running app. + try: + del globals()["app"] + except KeyError: + pass + # Things get simpler here: We just check if the user has given us the right token. + if not ( + DISABLE_AUTHENTICATION + # Use constant-time algorithm to campare the strings, to avoid timing attacks. + or hmac.compare_digest(auth, f"Bearer {self._hash}") + ): return ("Unauthorized", 403) - except Exception: + # DON'T LINT! Intentional bare except clause! Even `KeyboardInterrupt` and + # `SystemExit` exceptions should not bypass authentication! + except: return ("Unauthorized", 403) -check_token() -del check_token + +setup_auth() +del setup_auth @app.route('/', methods=['GET']) From a0c77747f66e0a87917ad8ff5e870271abb4f2a7 Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Thu, 27 Oct 2022 16:51:59 +0200 Subject: [PATCH 012/168] restored nest import --- pynest/nest/server/hl_api_server.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 9c365206ce..0f6fdb983a 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -34,7 +34,7 @@ root = logging.getLogger() root.addHandler(default_handler) -# import nest +import nest import RestrictedPython import time @@ -264,7 +264,7 @@ def route_exec(): # RESTful API # -------------------------- -nest_calls = [] +nest_calls = dir(nest) nest_calls = list(filter(lambda x: not x.startswith('_'), nest_calls)) nest_calls.sort() From ba35053b402a4d75b26aecd3447c15718daee7b9 Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Thu, 27 Oct 2022 17:14:08 +0200 Subject: [PATCH 013/168] Improved comments --- pynest/nest/server/hl_api_server.py | 35 ++++++++++++++++------------- 1 file changed, 19 insertions(+), 16 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 0f6fdb983a..a797cc3033 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -85,15 +85,15 @@ def get_boolean_environ(env_key, default_value = 'false'): mpi_comm = None -# Self sufficient, dissapearing authentication function -# -# * Generates the login token based on salted hash of the ID of this object and the -# current time measured by `perf_counter` giving us enough entropy. -# * Stores the token on this function. -# * Removes all `nest` accessible references to it, only `app` and `gc` have it, and the -# reference this module holds to `app` is deleted before the first request goes through. @app.before_request def setup_auth(): + """ + Authentication function that generates and validates the Authorization header with a + bearer token. + + Cleans up references to itself and the running `app` from this module, as it may be + accessible when the code execution sandbox fails. + """ try: import inspect import gc @@ -101,7 +101,7 @@ def setup_auth(): import hashlib import hmac - + # Find our reference to the current function in the garbage collector. frame = inspect.currentframe() code = frame.f_code globs = frame.f_globals @@ -115,6 +115,8 @@ def setup_auth(): if len(funcs) > 1: return ("Unauthorized", 403) self = funcs[0] + # Use the salted hash (unless `PYTHONHASHSEED` is fixed) of the location of this + # function in the Python heap and the current timestamp to create a SHA512 hash. if not hasattr(self, "_hash"): hasher = hashlib.sha512() hasher.update(str(hash(id(self))).encode("utf-8")) @@ -124,21 +126,22 @@ def setup_auth(): print("") print(" Bearer token to login to the NEST server with: ", self._hash) print("") - # Control flow explanation: The first time we hit this line is when below the - # function definition we call `setup_auth` without any request existing yet, - # so the function exits here after generating and storing the auth hash. + # The first time we hit the line below is when below the function definition we + # call `setup_auth` without any Flask request existing yet, so the function errors + # and exits here after generating and storing the auth hash. auth = request.headers["Authorization"] - # We continue here the next time this function is called, which is before the - # Flask app handles a request. At that point we also remove this module's - # reference to the running app. + # We continue here the next time this function is called, before the Flask app + # handles the first request. At that point we also remove this module's reference + # to the running app. try: del globals()["app"] except KeyError: pass - # Things get simpler here: We just check if the user has given us the right token. + # Things get more straightforward here: Every time a request is handled, compare + # the Authorization header to the hash, with a constant-time algorithm to avoid + # timing attacks. if not ( DISABLE_AUTHENTICATION - # Use constant-time algorithm to campare the strings, to avoid timing attacks. or hmac.compare_digest(auth, f"Bearer {self._hash}") ): return ("Unauthorized", 403) From d6d013f3478e156c457d78907a2af410815dc5cb Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Thu, 27 Oct 2022 17:20:42 +0200 Subject: [PATCH 014/168] reverted more things I did to test locally. --- pynest/nest/server/hl_api_server.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index a797cc3033..b82df79ca5 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -158,7 +158,7 @@ def setup_auth(): @app.route('/', methods=['GET']) def index(): return jsonify({ - 'nest': 1, + 'nest': nest.__version__, 'mpi': mpi_comm is not None, }) From 1d27bc9ffec4908911cebb2c5d22dcff4d2c82bb Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Fri, 28 Oct 2022 10:26:25 +0200 Subject: [PATCH 015/168] moved handler for pep8, use bool util --- pynest/nest/server/hl_api_server.py | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index b82df79ca5..211be2c52a 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -29,11 +29,6 @@ from flask_cors import CORS from flask.logging import default_handler -# This ensures that the logging information shows up in the console running the server, -# even when Flask's event loop is running. -root = logging.getLogger() -root.addHandler(default_handler) - import nest import RestrictedPython @@ -45,12 +40,20 @@ import os -def get_boolean_environ(env_key, default_value = 'false'): + +# This ensures that the logging information shows up in the console running the server, +# even when Flask's event loop is running. +root = logging.getLogger() +root.addHandler(default_handler) + + +def get_boolean_environ(env_key, default_value='false'): env_value = os.environ.get(env_key, default_value) return env_value.lower() in ['yes', 'true', 't', '1'] + _default_origins = 'localhost,http://localhost,https://localhost' -DISABLE_AUTHENTICATION = os.environ.get('NEST_DISABLE_AUTHENTICATION', False) == "TRUE" +DISABLE_AUTHENTICATION = get_boolean_environ('NEST_DISABLE_AUTHENTICATION') CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', _default_origins).split(',') EXEC_SCRIPT = get_boolean_environ('NEST_SERVER_EXEC_SCRIPT') MODULES = os.environ.get('NEST_SERVER_MODULES', 'nest').split(',') From 11ea078b3cf707a611419b53973d7d277bdb86b9 Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Fri, 28 Oct 2022 10:27:03 +0200 Subject: [PATCH 016/168] pep8 fixes --- pynest/nest/server/hl_api_server.py | 19 +++++++++++-------- 1 file changed, 11 insertions(+), 8 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 211be2c52a..4b7e8ffbbd 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -88,6 +88,7 @@ def get_boolean_environ(env_key, default_value='false'): mpi_comm = None + @app.before_request def setup_auth(): """ @@ -98,15 +99,17 @@ def setup_auth(): accessible when the code execution sandbox fails. """ try: - import inspect - import gc - import time - import hashlib - import hmac + # Import the modules inside of the auth function, so that if they fail the auth + # returns a forbidden error. + import inspect # noqa + import gc # noqa + import time # noqa + import hashlib # noqa + import hmac # noqa # Find our reference to the current function in the garbage collector. frame = inspect.currentframe() - code = frame.f_code + code = frame.f_code globs = frame.f_globals functype = type(lambda: 0) funcs = [] @@ -150,7 +153,7 @@ def setup_auth(): return ("Unauthorized", 403) # DON'T LINT! Intentional bare except clause! Even `KeyboardInterrupt` and # `SystemExit` exceptions should not bypass authentication! - except: + except: # noqa return ("Unauthorized", 403) @@ -297,7 +300,7 @@ def route_api_call(call): class Capturing(list): - """Monitor stdout contents i.e. print.""" + """ Monitor stdout contents i.e. print. """ def __enter__(self): self._stdout = sys.stdout From 0445157bae4415184a1678f0aed7a51b07566055 Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Fri, 28 Oct 2022 10:27:13 +0200 Subject: [PATCH 017/168] abort --> flask.abort --- pynest/nest/server/hl_api_server.py | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 4b7e8ffbbd..4267f183c6 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -263,10 +263,10 @@ def route_exec(): response = do_call('exec', args, kwargs) return jsonify(response) else: - abort(Response( + flask.abort( + 403, 'The route `/exec` has been disabled. Please contact the server administrator.', - 403 - )) + ) # -------------------------- @@ -366,8 +366,7 @@ def func_wrapper(call, args, kwargs): except Exception as e: for line in traceback.format_exception(*sys.exc_info()): print(line, flush=True) - abort(Response(str(e), EXCEPTION_ERROR_STATUS)) - + flask.abort(EXCEPTION_ERROR_STATUS, str(e)) return func_wrapper From b510def83d31d9992ee2f62e13ab6e9a2e0ce6d1 Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Fri, 28 Oct 2022 10:58:23 +0200 Subject: [PATCH 018/168] fixed unauthorized error when no auth header is given --- pynest/nest/server/hl_api_server.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 4267f183c6..e3c88571d8 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -135,7 +135,7 @@ def setup_auth(): # The first time we hit the line below is when below the function definition we # call `setup_auth` without any Flask request existing yet, so the function errors # and exits here after generating and storing the auth hash. - auth = request.headers["Authorization"] + auth = request.headers.get("Authorization", None) # We continue here the next time this function is called, before the Flask app # handles the first request. At that point we also remove this module's reference # to the running app. From 352f65cc3efb114cdfc64d9bb7edf345bffc1a6f Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Tue, 25 Oct 2022 15:18:43 +0200 Subject: [PATCH 019/168] Add env EXEC_SCRIPT --- pynest/nest/server/hl_api_server.py | 19 ++++--------------- 1 file changed, 4 insertions(+), 15 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index e3c88571d8..9b7bef9ba2 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -40,21 +40,10 @@ import os - -# This ensures that the logging information shows up in the console running the server, -# even when Flask's event loop is running. -root = logging.getLogger() -root.addHandler(default_handler) - - -def get_boolean_environ(env_key, default_value='false'): +def get_boolean_environ(env_key, default_value = 'false'): env_value = os.environ.get(env_key, default_value) return env_value.lower() in ['yes', 'true', 't', '1'] - -_default_origins = 'localhost,http://localhost,https://localhost' -DISABLE_AUTHENTICATION = get_boolean_environ('NEST_DISABLE_AUTHENTICATION') -CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', _default_origins).split(',') EXEC_SCRIPT = get_boolean_environ('NEST_SERVER_EXEC_SCRIPT') MODULES = os.environ.get('NEST_SERVER_MODULES', 'nest').split(',') RESTRICTION_OFF = get_boolean_environ('NEST_SERVER_RESTRICTION_OFF') @@ -263,10 +252,10 @@ def route_exec(): response = do_call('exec', args, kwargs) return jsonify(response) else: - flask.abort( - 403, + abort(Response( 'The route `/exec` has been disabled. Please contact the server administrator.', - ) + 403 + )) # -------------------------- From cb7a4ab87e52fdca6be541c5bf39e6adae153672 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Tue, 25 Oct 2022 15:18:59 +0200 Subject: [PATCH 020/168] Cleanup nest-server From 8fdffd6908ff4d09439a0995aa2e4c79223ea31b Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Tue, 25 Oct 2022 15:19:08 +0200 Subject: [PATCH 021/168] Add changes for v3.4 From 740bc8f53b4bf2b1af5ed56ce53cbdba1ddd077c Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Thu, 27 Oct 2022 12:18:52 +0200 Subject: [PATCH 022/168] Set Origins in CORS --- pynest/nest/server/hl_api_server.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 9b7bef9ba2..0da33a9c5e 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -44,6 +44,7 @@ def get_boolean_environ(env_key, default_value = 'false'): env_value = os.environ.get(env_key, default_value) return env_value.lower() in ['yes', 'true', 't', '1'] +CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', 'localhost') EXEC_SCRIPT = get_boolean_environ('NEST_SERVER_EXEC_SCRIPT') MODULES = os.environ.get('NEST_SERVER_MODULES', 'nest').split(',') RESTRICTION_OFF = get_boolean_environ('NEST_SERVER_RESTRICTION_OFF') @@ -71,9 +72,7 @@ def get_boolean_environ(env_key, default_value = 'false'): ] app = Flask(__name__) -# Inform client-side user agents that they should not attempt to call our server from any -# non-whitelisted domain. -CORS(app, origins=CORS_ORIGINS, methods=["GET", "POST"]) +CORS(app, resources={r"/*": {"origins": f"{CORS_ORIGINS}"}) mpi_comm = None From f9d0b56046de65597101d6940a8cbe2ed23b1f95 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Thu, 27 Oct 2022 12:58:53 +0200 Subject: [PATCH 023/168] Add cross origin for / --- pynest/nest/server/hl_api_server.py | 1 + 1 file changed, 1 insertion(+) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 0da33a9c5e..5b36ec08ff 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -150,6 +150,7 @@ def setup_auth(): @app.route('/', methods=['GET']) +@cross_origin() def index(): return jsonify({ 'nest': nest.__version__, From b29c2b2a35d1402de491352f8dd93a7337f95e14 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Thu, 27 Oct 2022 14:53:42 +0200 Subject: [PATCH 024/168] Extend cors_origins --- pynest/nest/server/hl_api_server.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 5b36ec08ff..f19e1b3581 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -44,7 +44,7 @@ def get_boolean_environ(env_key, default_value = 'false'): env_value = os.environ.get(env_key, default_value) return env_value.lower() in ['yes', 'true', 't', '1'] -CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', 'localhost') +CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', 'http://localhost:8000').split(',') EXEC_SCRIPT = get_boolean_environ('NEST_SERVER_EXEC_SCRIPT') MODULES = os.environ.get('NEST_SERVER_MODULES', 'nest').split(',') RESTRICTION_OFF = get_boolean_environ('NEST_SERVER_RESTRICTION_OFF') @@ -72,7 +72,7 @@ def get_boolean_environ(env_key, default_value = 'false'): ] app = Flask(__name__) -CORS(app, resources={r"/*": {"origins": f"{CORS_ORIGINS}"}) +CORS(app, CORS_ORIGINS=CORS_ORIGINS) mpi_comm = None From 31c0951eb395d6656cc9aa1fbcde5851dfd9dd66 Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Thu, 27 Oct 2022 15:27:19 +0200 Subject: [PATCH 025/168] Apply CORS headers --- pynest/nest/server/hl_api_server.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index f19e1b3581..ac6875491a 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -44,7 +44,8 @@ def get_boolean_environ(env_key, default_value = 'false'): env_value = os.environ.get(env_key, default_value) return env_value.lower() in ['yes', 'true', 't', '1'] -CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', 'http://localhost:8000').split(',') +_default_origins = 'localhost,http://localhost,https://localhost' +CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', _default_origins).split(',') EXEC_SCRIPT = get_boolean_environ('NEST_SERVER_EXEC_SCRIPT') MODULES = os.environ.get('NEST_SERVER_MODULES', 'nest').split(',') RESTRICTION_OFF = get_boolean_environ('NEST_SERVER_RESTRICTION_OFF') @@ -72,7 +73,9 @@ def get_boolean_environ(env_key, default_value = 'false'): ] app = Flask(__name__) -CORS(app, CORS_ORIGINS=CORS_ORIGINS) +# Inform client-side user agents that they should not attempt to call our server from any +# non-whitelisted domain. +CORS(app, origins=CORS_ORIGINS, methods=["GET", "POST"]) mpi_comm = None @@ -150,7 +153,6 @@ def setup_auth(): @app.route('/', methods=['GET']) -@cross_origin() def index(): return jsonify({ 'nest': nest.__version__, From c7f09ab2f152b8449648e017609f674643776966 Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Thu, 27 Oct 2022 15:35:48 +0200 Subject: [PATCH 026/168] forgot 1 From 84e82240131d0634519caefa31420185d998f336 Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Thu, 27 Oct 2022 16:22:58 +0200 Subject: [PATCH 027/168] Vanishing application and authentication :) --- pynest/nest/server/hl_api_server.py | 56 +++++++++++++++++++++++++++-- 1 file changed, 54 insertions(+), 2 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index ac6875491a..6fbd1ca5d0 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -79,6 +79,58 @@ def get_boolean_environ(env_key, default_value = 'false'): mpi_comm = None +# Self sufficient, dissapearing authentication function: +# +# * Generates the login token based on salted hash of the ID of this object and the +# current time measured by `perf_counter` giving us enough entropy. +# * Stores the token on this function. +# * Removes all `nest` accessible references to it, only `app` and `gc` have it, and the +# reference this module holds to `app` is deleted before the first request goes through. +@app.before_request +def check_token(): + try: + import inspect + import gc + import time + import hashlib + import hmac + + + frame = inspect.currentframe() + code = frame.f_code + globs = frame.f_globals + functype = type(lambda: 0) + funcs = [] + for func in gc.get_referrers(code): + if type(func) is functype: + if getattr(func, "__code__", None) is code: + if getattr(func, "__globals__", None) is globs: + funcs.append(func) + if len(funcs) > 1: + return ("Unauthorized", 403) + self = funcs[0] + if not hasattr(self, "_hash"): + hasher = hashlib.sha512() + hasher.update(str(hash(id(self))).encode("utf-8")) + hasher.update(str(time.perf_counter()).encode("utf-8")) + self._hash = hasher.hexdigest() + print("") + print(" Bearer token to login to the NEST server with: ", self._hash) + print("") + auth = request.headers["Authorization"] + # The line above triggers an error because below we call `check_token` outside of + # any request context. The next time, before the app calls the request route + # handler, this line will remove the reference this module holds to `app` as well. + del globals()["app"] + # Use constant-time comparison to avoid timing attacks. + if not hmac.compare_digest(auth, f"Bearer {self._hash}"): + return ("Unauthorized", 403) + except Exception: + return ("Unauthorized", 403) + +check_token() +del check_token + @app.before_request def setup_auth(): @@ -155,7 +207,7 @@ def setup_auth(): @app.route('/', methods=['GET']) def index(): return jsonify({ - 'nest': nest.__version__, + 'nest': 1, 'mpi': mpi_comm is not None, }) @@ -264,7 +316,7 @@ def route_exec(): # RESTful API # -------------------------- -nest_calls = dir(nest) +nest_calls = [] nest_calls = list(filter(lambda x: not x.startswith('_'), nest_calls)) nest_calls.sort() From 21b408feca4373a366fbd6ac4629809ed6b93fa2 Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Thu, 27 Oct 2022 16:42:47 +0200 Subject: [PATCH 028/168] Allowed authentication to be disabled. --- pynest/nest/server/hl_api_server.py | 43 +++++++++++++++++++---------- 1 file changed, 29 insertions(+), 14 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 6fbd1ca5d0..65b607cf0d 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -45,6 +45,7 @@ def get_boolean_environ(env_key, default_value = 'false'): return env_value.lower() in ['yes', 'true', 't', '1'] _default_origins = 'localhost,http://localhost,https://localhost' +DISABLE_AUTHENTICATION = os.environ.get('NEST_DISABLE_AUTHENTICATION', False) == "TRUE" CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', _default_origins).split(',') EXEC_SCRIPT = get_boolean_environ('NEST_SERVER_EXEC_SCRIPT') MODULES = os.environ.get('NEST_SERVER_MODULES', 'nest').split(',') @@ -79,7 +80,7 @@ def get_boolean_environ(env_key, default_value = 'false'): mpi_comm = None -# Self sufficient, dissapearing authentication function: +# Self sufficient, dissapearing authentication function # # * Generates the login token based on salted hash of the ID of this object and the # current time measured by `perf_counter` giving us enough entropy. @@ -87,7 +88,7 @@ def get_boolean_environ(env_key, default_value = 'false'): # * Removes all `nest` accessible references to it, only `app` and `gc` have it, and the # reference this module holds to `app` is deleted before the first request goes through. @app.before_request -def check_token(): +def setup_auth(): try: import inspect import gc @@ -114,22 +115,36 @@ def check_token(): hasher.update(str(hash(id(self))).encode("utf-8")) hasher.update(str(time.perf_counter()).encode("utf-8")) self._hash = hasher.hexdigest() - print("") - print(" Bearer token to login to the NEST server with: ", self._hash) - print("") + if not DISABLE_AUTHENTICATION: + print("") + print(" Bearer token to login to the NEST server with: ", self._hash) + print("") + # Control flow explanation: The first time we hit this line is when below the + # function definition we call `setup_auth` without any request existing yet, + # so the function exits here after generating and storing the auth hash. auth = request.headers["Authorization"] - # The line above triggers an error because below we call `check_token` outside of - # any request context. The next time, before the app calls the request route - # handler, this line will remove the reference this module holds to `app` as well. - del globals()["app"] - # Use constant-time comparison to avoid timing attacks. - if not hmac.compare_digest(auth, f"Bearer {self._hash}"): + # We continue here the next time this function is called, which is before the + # Flask app handles a request. At that point we also remove this module's + # reference to the running app. + try: + del globals()["app"] + except KeyError: + pass + # Things get simpler here: We just check if the user has given us the right token. + if not ( + DISABLE_AUTHENTICATION + # Use constant-time algorithm to campare the strings, to avoid timing attacks. + or hmac.compare_digest(auth, f"Bearer {self._hash}") + ): return ("Unauthorized", 403) - except Exception: + # DON'T LINT! Intentional bare except clause! Even `KeyboardInterrupt` and + # `SystemExit` exceptions should not bypass authentication! + except: return ("Unauthorized", 403) -check_token() -del check_token + +setup_auth() +del setup_auth @app.before_request From 3abc6a9ee3cbaeec9ad7379e7d22e4ab60876155 Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Thu, 27 Oct 2022 16:51:59 +0200 Subject: [PATCH 029/168] restored nest import --- pynest/nest/server/hl_api_server.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 65b607cf0d..bb64989489 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -331,7 +331,7 @@ def route_exec(): # RESTful API # -------------------------- -nest_calls = [] +nest_calls = dir(nest) nest_calls = list(filter(lambda x: not x.startswith('_'), nest_calls)) nest_calls.sort() From 9bf1ac52a7d88065b5c3a4d284f7106098348182 Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Thu, 27 Oct 2022 17:14:08 +0200 Subject: [PATCH 030/168] Improved comments --- pynest/nest/server/hl_api_server.py | 35 ++++++++++++++++------------- 1 file changed, 19 insertions(+), 16 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index bb64989489..21547361f9 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -80,15 +80,15 @@ def get_boolean_environ(env_key, default_value = 'false'): mpi_comm = None -# Self sufficient, dissapearing authentication function -# -# * Generates the login token based on salted hash of the ID of this object and the -# current time measured by `perf_counter` giving us enough entropy. -# * Stores the token on this function. -# * Removes all `nest` accessible references to it, only `app` and `gc` have it, and the -# reference this module holds to `app` is deleted before the first request goes through. @app.before_request def setup_auth(): + """ + Authentication function that generates and validates the Authorization header with a + bearer token. + + Cleans up references to itself and the running `app` from this module, as it may be + accessible when the code execution sandbox fails. + """ try: import inspect import gc @@ -96,7 +96,7 @@ def setup_auth(): import hashlib import hmac - + # Find our reference to the current function in the garbage collector. frame = inspect.currentframe() code = frame.f_code globs = frame.f_globals @@ -110,6 +110,8 @@ def setup_auth(): if len(funcs) > 1: return ("Unauthorized", 403) self = funcs[0] + # Use the salted hash (unless `PYTHONHASHSEED` is fixed) of the location of this + # function in the Python heap and the current timestamp to create a SHA512 hash. if not hasattr(self, "_hash"): hasher = hashlib.sha512() hasher.update(str(hash(id(self))).encode("utf-8")) @@ -119,21 +121,22 @@ def setup_auth(): print("") print(" Bearer token to login to the NEST server with: ", self._hash) print("") - # Control flow explanation: The first time we hit this line is when below the - # function definition we call `setup_auth` without any request existing yet, - # so the function exits here after generating and storing the auth hash. + # The first time we hit the line below is when below the function definition we + # call `setup_auth` without any Flask request existing yet, so the function errors + # and exits here after generating and storing the auth hash. auth = request.headers["Authorization"] - # We continue here the next time this function is called, which is before the - # Flask app handles a request. At that point we also remove this module's - # reference to the running app. + # We continue here the next time this function is called, before the Flask app + # handles the first request. At that point we also remove this module's reference + # to the running app. try: del globals()["app"] except KeyError: pass - # Things get simpler here: We just check if the user has given us the right token. + # Things get more straightforward here: Every time a request is handled, compare + # the Authorization header to the hash, with a constant-time algorithm to avoid + # timing attacks. if not ( DISABLE_AUTHENTICATION - # Use constant-time algorithm to campare the strings, to avoid timing attacks. or hmac.compare_digest(auth, f"Bearer {self._hash}") ): return ("Unauthorized", 403) From 68ed1cfab89f06e10bf8454f93124858ced8a37c Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Thu, 27 Oct 2022 17:20:42 +0200 Subject: [PATCH 031/168] reverted more things I did to test locally. --- pynest/nest/server/hl_api_server.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 21547361f9..c4c0891ec5 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -225,7 +225,7 @@ def setup_auth(): @app.route('/', methods=['GET']) def index(): return jsonify({ - 'nest': 1, + 'nest': nest.__version__, 'mpi': mpi_comm is not None, }) From cb1abfc2d1912e7de72dfb53c73d49b6fcbdf317 Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Fri, 28 Oct 2022 10:26:25 +0200 Subject: [PATCH 032/168] moved handler for pep8, use bool util --- pynest/nest/server/hl_api_server.py | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index c4c0891ec5..64a8a73ab5 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -40,12 +40,20 @@ import os -def get_boolean_environ(env_key, default_value = 'false'): + +# This ensures that the logging information shows up in the console running the server, +# even when Flask's event loop is running. +root = logging.getLogger() +root.addHandler(default_handler) + + +def get_boolean_environ(env_key, default_value='false'): env_value = os.environ.get(env_key, default_value) return env_value.lower() in ['yes', 'true', 't', '1'] + _default_origins = 'localhost,http://localhost,https://localhost' -DISABLE_AUTHENTICATION = os.environ.get('NEST_DISABLE_AUTHENTICATION', False) == "TRUE" +DISABLE_AUTHENTICATION = get_boolean_environ('NEST_DISABLE_AUTHENTICATION') CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', _default_origins).split(',') EXEC_SCRIPT = get_boolean_environ('NEST_SERVER_EXEC_SCRIPT') MODULES = os.environ.get('NEST_SERVER_MODULES', 'nest').split(',') From 98240d48f78b87308b52d6b8aacd54db6135c58e Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Fri, 28 Oct 2022 10:27:03 +0200 Subject: [PATCH 033/168] pep8 fixes --- pynest/nest/server/hl_api_server.py | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 64a8a73ab5..43c9d4514b 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -88,6 +88,7 @@ def get_boolean_environ(env_key, default_value='false'): mpi_comm = None + @app.before_request def setup_auth(): """ @@ -98,15 +99,17 @@ def setup_auth(): accessible when the code execution sandbox fails. """ try: - import inspect - import gc - import time - import hashlib - import hmac + # Import the modules inside of the auth function, so that if they fail the auth + # returns a forbidden error. + import inspect # noqa + import gc # noqa + import time # noqa + import hashlib # noqa + import hmac # noqa # Find our reference to the current function in the garbage collector. frame = inspect.currentframe() - code = frame.f_code + code = frame.f_code globs = frame.f_globals functype = type(lambda: 0) funcs = [] @@ -150,7 +153,7 @@ def setup_auth(): return ("Unauthorized", 403) # DON'T LINT! Intentional bare except clause! Even `KeyboardInterrupt` and # `SystemExit` exceptions should not bypass authentication! - except: + except: # noqa return ("Unauthorized", 403) From 6a88b5577578781600ab6ff27005fd938bcce0eb Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Fri, 28 Oct 2022 10:27:13 +0200 Subject: [PATCH 034/168] abort --> flask.abort --- pynest/nest/server/hl_api_server.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 43c9d4514b..860a92d73e 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -335,10 +335,10 @@ def route_exec(): response = do_call('exec', args, kwargs) return jsonify(response) else: - abort(Response( + flask.abort( + 403, 'The route `/exec` has been disabled. Please contact the server administrator.', - 403 - )) + ) # -------------------------- From b4ee911c161000ac1b57e1a233eb3a6230d5abf1 Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Fri, 28 Oct 2022 10:58:23 +0200 Subject: [PATCH 035/168] fixed unauthorized error when no auth header is given --- pynest/nest/server/hl_api_server.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 860a92d73e..9ed291310f 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -135,7 +135,7 @@ def setup_auth(): # The first time we hit the line below is when below the function definition we # call `setup_auth` without any Flask request existing yet, so the function errors # and exits here after generating and storing the auth hash. - auth = request.headers["Authorization"] + auth = request.headers.get("Authorization", None) # We continue here the next time this function is called, before the Flask app # handles the first request. At that point we also remove this module's reference # to the running app. From 98012d1c02774f8968c18331a8f03e7ae00666e6 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Fri, 28 Oct 2022 12:28:06 +0200 Subject: [PATCH 036/168] Rename env variables and notify before startup --- pynest/nest/server/hl_api_server.py | 47 +++++++++++++++++++++++------ 1 file changed, 38 insertions(+), 9 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 9ed291310f..3746ead3c9 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -53,14 +53,14 @@ def get_boolean_environ(env_key, default_value='false'): _default_origins = 'localhost,http://localhost,https://localhost' -DISABLE_AUTHENTICATION = get_boolean_environ('NEST_DISABLE_AUTHENTICATION') +AUTH_DISABLED = get_boolean_environ('NEST_SERVER_DISABLE_AUTH') CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', _default_origins).split(',') -EXEC_SCRIPT = get_boolean_environ('NEST_SERVER_EXEC_SCRIPT') +EXEC_CALL_ENABLED = get_boolean_environ('NEST_SERVER_ENABLE_EXEC_CALL') MODULES = os.environ.get('NEST_SERVER_MODULES', 'nest').split(',') -RESTRICTION_OFF = get_boolean_environ('NEST_SERVER_RESTRICTION_OFF') +RESTRICTION_DISABLED = get_boolean_environ('NEST_SERVER_DISABLE_RESTRICTION') EXCEPTION_ERROR_STATUS = 400 -if EXEC_SCRIPT: +if EXEC_CALL_ENABLED: print(80 * '*') msg = ("\n" + 9*" ").join([ 'NEST Server runs with the `exec` command activated.', @@ -68,11 +68,13 @@ def get_boolean_environ(env_key, default_value='false'): 'The security of your system can not be ensured!' ]) print(f'WARNING: {msg}') - if RESTRICTION_OFF: + if RESTRICTION_DISABLED: msg = 'NEST Server runs without a RestrictedPython trusted environment.' print(f'WARNING: {msg}') print(80 * '*') + + __all__ = [ "app", "do_exec", @@ -89,6 +91,30 @@ def get_boolean_environ(env_key, default_value='false'): mpi_comm = None +def check_security(): + """ + Checks the security level of the NEST Server instance. + """ + + msg = [] + if AUTH_DISABLED: + msg.append('AUTH:\tThe authentication is disabled.') + if '*' in CORS_ORIGINS: + msg.append('CORS:\tAllowed origins is unrestricted.') + if EXEC_CALL_ENABLED: + msg.append('EXEC CALL:\tAny code scripts can be executed!') + if RESTRICTION_DISABLED: + msg.append('RESTRICTION: Code scripts will be executed without a restricted environment.') + + level = ['HIGHEST', 'HIGH', 'MODERATE', 'LOW', 'LOWEST'] + print(f'The security level of NEST Server is {level[len(msg)]}.') + if len(msg) > 0: + print('WARNING: The security of your system can not be ensured!') + print('\n - '.join([' '] + msg) + '\n') + else: + print('INFO: The security of your system can be ensured!') + + @app.before_request def setup_auth(): """ @@ -128,7 +154,7 @@ def setup_auth(): hasher.update(str(hash(id(self))).encode("utf-8")) hasher.update(str(time.perf_counter()).encode("utf-8")) self._hash = hasher.hexdigest() - if not DISABLE_AUTHENTICATION: + if not AUTH_DISABLED: print("") print(" Bearer token to login to the NEST server with: ", self._hash) print("") @@ -147,7 +173,7 @@ def setup_auth(): # the Authorization header to the hash, with a constant-time algorithm to avoid # timing attacks. if not ( - DISABLE_AUTHENTICATION + AUTH_DISABLED or hmac.compare_digest(auth, f"Bearer {self._hash}") ): return ("Unauthorized", 403) @@ -157,8 +183,11 @@ def setup_auth(): return ("Unauthorized", 403) +print( 80 * '*') +check_security() setup_auth() del setup_auth +print( 80 * '*') @app.before_request @@ -248,7 +277,7 @@ def do_exec(args, kwargs): locals_ = dict() response = dict() - if RESTRICTION_OFF: + if RESTRICTION_DISABLED: with Capturing() as stdout: exec(source_cleaned, get_globals(), locals_) if len(stdout) > 0: @@ -330,7 +359,7 @@ def do_call(call_name, args=[], kwargs={}): def route_exec(): """Route to execute script in Python.""" - if EXEC_SCRIPT: + if EXEC_CALL_ENABLED: args, kwargs = get_arguments(request) response = do_call('exec', args, kwargs) return jsonify(response) From dbee4cc15cb1291b1e9d3aaeff6e43158bf83ddb Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Fri, 28 Oct 2022 12:42:09 +0200 Subject: [PATCH 037/168] Update notification --- pynest/nest/server/hl_api_server.py | 23 +++-------------------- 1 file changed, 3 insertions(+), 20 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 3746ead3c9..04173b9f4e 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -60,21 +60,6 @@ def get_boolean_environ(env_key, default_value='false'): RESTRICTION_DISABLED = get_boolean_environ('NEST_SERVER_DISABLE_RESTRICTION') EXCEPTION_ERROR_STATUS = 400 -if EXEC_CALL_ENABLED: - print(80 * '*') - msg = ("\n" + 9*" ").join([ - 'NEST Server runs with the `exec` command activated.', - 'This means that any code can be executed!', - 'The security of your system can not be ensured!' - ]) - print(f'WARNING: {msg}') - if RESTRICTION_DISABLED: - msg = 'NEST Server runs without a RestrictedPython trusted environment.' - print(f'WARNING: {msg}') - print(80 * '*') - - - __all__ = [ "app", "do_exec", @@ -100,7 +85,7 @@ def check_security(): if AUTH_DISABLED: msg.append('AUTH:\tThe authentication is disabled.') if '*' in CORS_ORIGINS: - msg.append('CORS:\tAllowed origins is unrestricted.') + msg.append('CORS:\tAllowed origins is not restricted.') if EXEC_CALL_ENABLED: msg.append('EXEC CALL:\tAny code scripts can be executed!') if RESTRICTION_DISABLED: @@ -153,11 +138,9 @@ def setup_auth(): hasher = hashlib.sha512() hasher.update(str(hash(id(self))).encode("utf-8")) hasher.update(str(time.perf_counter()).encode("utf-8")) - self._hash = hasher.hexdigest() + self._hash = hasher.hexdigest()[:48] if not AUTH_DISABLED: - print("") - print(" Bearer token to login to the NEST server with: ", self._hash) - print("") + print(f"\nBearer token to NEST server: {self._hash}\n") # The first time we hit the line below is when below the function definition we # call `setup_auth` without any Flask request existing yet, so the function errors # and exits here after generating and storing the auth hash. From 2d7e0c9810f4bfb6ffaacf76b9a5dffad39ed2a6 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Fri, 28 Oct 2022 12:44:21 +0200 Subject: [PATCH 038/168] Add changes in release notes --- doc/htmldoc/whats_new/v3.4/index.rst | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/doc/htmldoc/whats_new/v3.4/index.rst b/doc/htmldoc/whats_new/v3.4/index.rst index ae80fe734b..6b95e4e33f 100644 --- a/doc/htmldoc/whats_new/v3.4/index.rst +++ b/doc/htmldoc/whats_new/v3.4/index.rst @@ -64,7 +64,9 @@ the node positions. Changes in NEST Server ~~~~~~~~~~~~~~~~~~~~~~ -* By default NEST Server runs on port 52425 (previously 5000). -* Minimize security risk in NEST Server. - * By default exec call is disabled, only API calls are enabled. - * The user is able to turn on exec call which means that the user is aware of the risk. +* By default, the NEST Server now runs on port ``52425`` (previously ``5000``). +* Improve the security in NEST Server. The user can modify the security options in environment variables: + * Requests require Bearer tokens. By default, the authentication is on (``NEST_SERVER_DISABLE_AUTH=0``). + * The CORS origins are restricted. By default, the only allowed CORS origin is ``localhost`` (``NEST_SERVER_CORS_ORIGINS=localhost``). + * Only API calls are enabled. By default, the exec call is disabled (``NEST_SERVER_ENABLE_EXEC_CALL=0``). + * The code execution is restricted. By default, the restriction is activated (``NEST_SERVER_DISABLE_RESTRICTION=0``). From 8b3ca534c02541e7aeaf34e3d765b38517ff509e Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Fri, 28 Oct 2022 12:51:13 +0200 Subject: [PATCH 039/168] Set only 1 CORS_origin as default --- doc/htmldoc/whats_new/v3.4/index.rst | 2 +- pynest/nest/server/hl_api_server.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/doc/htmldoc/whats_new/v3.4/index.rst b/doc/htmldoc/whats_new/v3.4/index.rst index 6b95e4e33f..1d63e2ac91 100644 --- a/doc/htmldoc/whats_new/v3.4/index.rst +++ b/doc/htmldoc/whats_new/v3.4/index.rst @@ -67,6 +67,6 @@ Changes in NEST Server * By default, the NEST Server now runs on port ``52425`` (previously ``5000``). * Improve the security in NEST Server. The user can modify the security options in environment variables: * Requests require Bearer tokens. By default, the authentication is on (``NEST_SERVER_DISABLE_AUTH=0``). - * The CORS origins are restricted. By default, the only allowed CORS origin is ``localhost`` (``NEST_SERVER_CORS_ORIGINS=localhost``). + * The CORS origins are restricted. By default, the only allowed CORS origin is ``http://localhost`` (``NEST_SERVER_CORS_ORIGINS=localhost``). * Only API calls are enabled. By default, the exec call is disabled (``NEST_SERVER_ENABLE_EXEC_CALL=0``). * The code execution is restricted. By default, the restriction is activated (``NEST_SERVER_DISABLE_RESTRICTION=0``). diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 04173b9f4e..70ef6c509b 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -52,7 +52,7 @@ def get_boolean_environ(env_key, default_value='false'): return env_value.lower() in ['yes', 'true', 't', '1'] -_default_origins = 'localhost,http://localhost,https://localhost' +_default_origins = 'http://localhost' AUTH_DISABLED = get_boolean_environ('NEST_SERVER_DISABLE_AUTH') CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', _default_origins).split(',') EXEC_CALL_ENABLED = get_boolean_environ('NEST_SERVER_ENABLE_EXEC_CALL') From 63d9c92680bcddc54e59a983356b1eb5320987af Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Tue, 18 Jul 2023 12:06:04 +0200 Subject: [PATCH 040/168] Add option to apply user-custom token --- pynest/nest/server/hl_api_server.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 70ef6c509b..a278476e27 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -53,6 +53,7 @@ def get_boolean_environ(env_key, default_value='false'): _default_origins = 'http://localhost' +ACCESS_TOKEN = os.environ.get('NEST_SERVER_ACCESS_TOKEN', '') AUTH_DISABLED = get_boolean_environ('NEST_SERVER_DISABLE_AUTH') CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', _default_origins).split(',') EXEC_CALL_ENABLED = get_boolean_environ('NEST_SERVER_ENABLE_EXEC_CALL') @@ -118,6 +119,9 @@ def setup_auth(): import hashlib # noqa import hmac # noqa + if ACCESS_TOKEN: + self._hash = ACCESS_TOKEN + # Find our reference to the current function in the garbage collector. frame = inspect.currentframe() code = frame.f_code From d410f2892da1871ae2ed8f46dac4fe98679f6911 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Tue, 18 Jul 2023 12:57:40 +0200 Subject: [PATCH 041/168] Resolve merge conflicts --- doc/htmldoc/whats_new/v3.4/index.rst | 47 ++--- pynest/nest/server/hl_api_server.py | 246 ++++++++++----------------- 2 files changed, 109 insertions(+), 184 deletions(-) diff --git a/doc/htmldoc/whats_new/v3.4/index.rst b/doc/htmldoc/whats_new/v3.4/index.rst index 1d63e2ac91..a57ce8bd48 100644 --- a/doc/htmldoc/whats_new/v3.4/index.rst +++ b/doc/htmldoc/whats_new/v3.4/index.rst @@ -3,16 +3,16 @@ What's new in NEST 3.4 ====================== -This page contains a summary of important breaking and non-breaking -changes from NEST 3.3 to NEST 3.4. In addition to the `release notes -on GitHub `_, this -page also contains transition information that helps you to update -your simulation scripts when you come from an older version of NEST. +This page contains a summary of important breaking and non-breaking changes +from NEST 3.3 to NEST 3.4. In addition to the `release +notes on GitHub `_, +this page also contains transition information that helps you to +update your simulation scripts when you come from an older version of +NEST. -If you transition from an earlier version, please see our extensive -:ref:`transition guide from NEST 2.x to 3.0 ` and the -:ref:`list of updates for previous releases in the 3.x series -`. +If you transition from a version earlier than 3.3, please see our +extensive :ref:`transition guide from NEST 2.x to 3.0 +` or :ref:`release updates for previous releases in 3.x `. Documentation restructuring and new theme ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -23,18 +23,12 @@ layout, our wide range of docs can be discovered more easily. The table of contents is simplified and the content is grouped based on topic (neurons, synapses etc) rather than type of documentation (e.g., 'guides'). -The table of contents is simplified and the content is grouped based -on topics (neurons, synapses etc) rather than type of documentation -(e.g., 'guides'). -We would be highly interested in any feedback you might have on the -new look-and-feel either on `our mailing list -`_ or as an `issue on -GitHub -`_ +Changes in NEST behavior +~~~~~~~~~~~~~~~~~~~~~~~~ -Query spatially structured networks from target neuron perspective -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Inferred extent of spatial layers with freely placed neurons +............................................................ Spatial layers can be created by specifying only the node positions using ``spatial.free``, without explicitly specifying the ``extent``. @@ -43,18 +37,11 @@ lower-leftmost and upper-rightmost nodes in the layer; earlier versions of NEST padding to the extent. The ``center`` is computed as the midpoint between the lower-leftmost and upper-rightmost nodes. -Extent and center for spatial layers with freely placed neurons -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +When creating a layer with only a single node, the ``extent`` has to be specified explicitly. -Spatial layers in NEST can be created by specifying node positions in -the call to :py:func:`.Create` using :ref:`spatial distributions ` -from ``nest.spatial``. -When using :py:class:`.spatial.free`, the layer's ``extent`` will be -determined automatically based on the positions of the lower-leftmost -and upper-rightmost nodes in the layer, if omitted. While earlier -versions of NEST added a hard-coded padding, NEST 3.4 will only use -the node positions. +Deprecation information +~~~~~~~~~~~~~~~~~~~~~~~ * Model ``spike_dilutor`` is now deprecated and can only be used in single-threaded mode. To implement connections which transmit @@ -69,4 +56,4 @@ Changes in NEST Server * Requests require Bearer tokens. By default, the authentication is on (``NEST_SERVER_DISABLE_AUTH=0``). * The CORS origins are restricted. By default, the only allowed CORS origin is ``http://localhost`` (``NEST_SERVER_CORS_ORIGINS=localhost``). * Only API calls are enabled. By default, the exec call is disabled (``NEST_SERVER_ENABLE_EXEC_CALL=0``). - * The code execution is restricted. By default, the restriction is activated (``NEST_SERVER_DISABLE_RESTRICTION=0``). + * The code execution is restricted. By default, the restriction is activated (``NEST_SERVER_DISABLE_RESTRICTION=0``). \ No newline at end of file diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index a278476e27..8eb1c6527d 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -62,11 +62,11 @@ def get_boolean_environ(env_key, default_value='false'): EXCEPTION_ERROR_STATUS = 400 __all__ = [ - "app", - "do_exec", - "set_mpi_comm", - "run_mpi_app", - "nestify", + 'app', + 'do_exec', + 'set_mpi_comm', + 'run_mpi_app', + 'nestify', ] app = Flask(__name__) @@ -119,9 +119,6 @@ def setup_auth(): import hashlib # noqa import hmac # noqa - if ACCESS_TOKEN: - self._hash = ACCESS_TOKEN - # Find our reference to the current function in the garbage collector. frame = inspect.currentframe() code = frame.f_code @@ -136,6 +133,10 @@ def setup_auth(): if len(funcs) > 1: return ("Unauthorized", 403) self = funcs[0] + + if ACCESS_TOKEN: + self._hash = ACCESS_TOKEN + # Use the salted hash (unless `PYTHONHASHSEED` is fixed) of the location of this # function in the Python heap and the current timestamp to create a SHA512 hash. if not hasattr(self, "_hash"): @@ -177,78 +178,6 @@ def setup_auth(): print( 80 * '*') -@app.before_request -def setup_auth(): - """ - Authentication function that generates and validates the Authorization header with a - bearer token. - - Cleans up references to itself and the running `app` from this module, as it may be - accessible when the code execution sandbox fails. - """ - try: - # Import the modules inside of the auth function, so that if they fail the auth - # returns a forbidden error. - import inspect # noqa - import gc # noqa - import time # noqa - import hashlib # noqa - import hmac # noqa - - # Find our reference to the current function in the garbage collector. - frame = inspect.currentframe() - code = frame.f_code - globs = frame.f_globals - functype = type(lambda: 0) - funcs = [] - for func in gc.get_referrers(code): - if type(func) is functype: - if getattr(func, "__code__", None) is code: - if getattr(func, "__globals__", None) is globs: - funcs.append(func) - if len(funcs) > 1: - return ("Unauthorized", 403) - self = funcs[0] - # Use the salted hash (unless `PYTHONHASHSEED` is fixed) of the location of this - # function in the Python heap and the current timestamp to create a SHA512 hash. - if not hasattr(self, "_hash"): - hasher = hashlib.sha512() - hasher.update(str(hash(id(self))).encode("utf-8")) - hasher.update(str(time.perf_counter()).encode("utf-8")) - self._hash = hasher.hexdigest() - if not DISABLE_AUTHENTICATION: - print("") - print(" Bearer token to login to the NEST server with: ", self._hash) - print("") - # The first time we hit the line below is when below the function definition we - # call `setup_auth` without any Flask request existing yet, so the function errors - # and exits here after generating and storing the auth hash. - auth = request.headers.get("Authorization", None) - # We continue here the next time this function is called, before the Flask app - # handles the first request. At that point we also remove this module's reference - # to the running app. - try: - del globals()["app"] - except KeyError: - pass - # Things get more straightforward here: Every time a request is handled, compare - # the Authorization header to the hash, with a constant-time algorithm to avoid - # timing attacks. - if not ( - DISABLE_AUTHENTICATION - or hmac.compare_digest(auth, f"Bearer {self._hash}") - ): - return ("Unauthorized", 403) - # DON'T LINT! Intentional bare except clause! Even `KeyboardInterrupt` and - # `SystemExit` exceptions should not bypass authentication! - except: # noqa - return ("Unauthorized", 403) - - -setup_auth() -del setup_auth - - @app.route('/', methods=['GET']) def index(): return jsonify({ @@ -259,7 +188,7 @@ def index(): def do_exec(args, kwargs): try: - source_code = kwargs.get("source", "") + source_code = kwargs.get('source', '') source_cleaned = clean_code(source_code) locals_ = dict() @@ -268,21 +197,21 @@ def do_exec(args, kwargs): with Capturing() as stdout: exec(source_cleaned, get_globals(), locals_) if len(stdout) > 0: - response["stdout"] = "\n".join(stdout) + response['stdout'] = '\n'.join(stdout) else: - code = RestrictedPython.compile_restricted(source_cleaned, "", "exec") # noqa + code = RestrictedPython.compile_restricted(source_cleaned, '', 'exec') # noqa exec(code, get_restricted_globals(), locals_) - if "_print" in locals_: - response["stdout"] = "".join(locals_["_print"].txt) + if '_print' in locals_: + response['stdout'] = ''.join(locals_['_print'].txt) - if "return" in kwargs: - if isinstance(kwargs["return"], list): + if 'return' in kwargs: + if isinstance(kwargs['return'], list): data = dict() - for variable in kwargs["return"]: + for variable in kwargs['return']: data[variable] = locals_.get(variable, None) else: - data = locals_.get(kwargs["return"], None) - response["data"] = nest.serializable(data) + data = locals_.get(kwargs['return'], None) + response['data'] = nest.serializable(data) return response except Exception as e: @@ -292,7 +221,7 @@ def do_exec(args, kwargs): def log(call_name, msg): - msg = f"==> MASTER 0/{time.time():.7f} ({call_name}): {msg}" + msg = f'==> MASTER 0/{time.time():.7f} ({call_name}): {msg}' print(msg, flush=True) @@ -320,31 +249,32 @@ def do_call(call_name, args=[], kwargs={}): assert mpi_comm.Get_rank() == 0 if mpi_comm is not None: - log(call_name, "sending call bcast") + log(call_name, 'sending call bcast') mpi_comm.bcast(call_name, root=0) data = (args, kwargs) - log(call_name, f"sending data bcast, data={data}") + log(call_name, f'sending data bcast, data={data}') mpi_comm.bcast(data, root=0) - if call_name == "exec": + if call_name == 'exec': master_response = do_exec(args, kwargs) else: call, args, kwargs = nestify(call_name, args, kwargs) - log(call_name, f"local call, args={args}, kwargs={kwargs}") + log(call_name, f'local call, args={args}, kwargs={kwargs}') master_response = call(*args, **kwargs) response = [nest.serializable(master_response)] if mpi_comm is not None: - log(call_name, "waiting for response gather") + log(call_name, 'waiting for response gather') response = mpi_comm.gather(response[0], root=0) - log(call_name, f"received response gather, data={response}") + log(call_name, f'received response gather, data={response}') return combine(call_name, response) @app.route('/exec', methods=['GET', 'POST']) def route_exec(): - """Route to execute script in Python.""" + """ Route to execute script in Python. + """ if EXEC_CALL_ENABLED: args, kwargs = get_arguments(request) @@ -368,13 +298,15 @@ def route_exec(): @app.route('/api', methods=['GET']) def route_api(): - """Route to list call functions in NEST.""" + """ Route to list call functions in NEST. + """ return jsonify(nest_calls) @app.route('/api/', methods=['GET', 'POST']) def route_api_call(call): - """Route to call function in NEST.""" + """ Route to call function in NEST. + """ print(f"\n{'='*40}\n", flush=True) args, kwargs = get_arguments(request) log("route_api_call", f"call={call}, args={args}, kwargs={kwargs}") @@ -386,7 +318,6 @@ def route_api_call(call): # Helpers for the server # ---------------------- - class Capturing(list): """ Monitor stdout contents i.e. print. """ @@ -397,18 +328,19 @@ def __enter__(self): def __exit__(self, *args): self.extend(self._stringio.getvalue().splitlines()) - del self._stringio # free up some memory + del self._stringio # free up some memory sys.stdout = self._stdout def clean_code(source): - codes = source.split("\n") - code_cleaned = filter(lambda code: not (code.startswith("import") or code.startswith("from")), codes) # noqa - return "\n".join(code_cleaned) + codes = source.split('\n') + code_cleaned = filter(lambda code: not (code.startswith('import') or code.startswith('from')), codes) # noqa + return '\n'.join(code_cleaned) def get_arguments(request): - """Get arguments from the request.""" + """ Get arguments from the request. + """ args, kwargs = [], {} if request.is_json: json = request.get_json() @@ -418,23 +350,24 @@ def get_arguments(request): args = json elif isinstance(json, dict): kwargs = json - if "args" in kwargs: - args = kwargs.pop("args") + if 'args' in kwargs: + args = kwargs.pop('args') elif len(request.form) > 0: - if "args" in request.form: - args = request.form.getlist("args") + if 'args' in request.form: + args = request.form.getlist('args') else: kwargs = request.form.to_dict() elif len(request.args) > 0: - if "args" in request.args: - args = request.args.getlist("args") + if 'args' in request.args: + args = request.args.getlist('args') else: kwargs = request.args.to_dict() return list(args), kwargs def get_globals(): - """Get globals for exec function.""" + """ Get globals for exec function. + """ copied_globals = globals().copy() # Add modules to copied globals @@ -446,8 +379,8 @@ def get_globals(): def get_or_error(func): - """Wrapper to get data and status.""" - + """ Wrapper to get data and status. + """ def func_wrapper(call, args, kwargs): try: return func(call, args, kwargs) @@ -459,8 +392,8 @@ def func_wrapper(call, args, kwargs): def get_restricted_globals(): - """Get restricted globals for exec function.""" - + """ Get restricted globals for exec function. + """ def getitem(obj, index): typelist = (list, tuple, dict, nest.NodeCollection) if obj is not None and type(obj) in typelist: @@ -471,14 +404,12 @@ def getitem(obj, index): restricted_builtins = RestrictedPython.safe_builtins.copy() restricted_builtins.update(RestrictedPython.limited_builtins) restricted_builtins.update(RestrictedPython.utility_builtins) - restricted_builtins.update( - dict( - max=max, - min=min, - sum=sum, - time=time, - ) - ) + restricted_builtins.update(dict( + max=max, + min=min, + sum=sum, + time=time, + )) restricted_globals = dict( __builtins__=restricted_builtins, @@ -499,13 +430,15 @@ def getitem(obj, index): def nestify(call_name, args, kwargs): - """Get the NEST API call and convert arguments if neccessary.""" + """ Get the NEST API call and convert arguments if neccessary. + """ call = getattr(nest, call_name) - objectnames = ["nodes", "source", "target", "pre", "post"] + objectnames = ['nodes', 'source', 'target', 'pre', 'post'] paramKeys = list(inspect.signature(call).parameters.keys()) - args = [nest.NodeCollection(arg) if paramKeys[idx] in objectnames else arg for (idx, arg) in enumerate(args)] - for key, value in kwargs.items(): + args = [nest.NodeCollection(arg) if paramKeys[idx] in objectnames + else arg for (idx, arg) in enumerate(args)] + for (key, value) in kwargs.items(): if key in objectnames: kwargs[key] = nest.NodeCollection(value) @@ -514,13 +447,16 @@ def nestify(call_name, args, kwargs): @get_or_error def api_client(call_name, args, kwargs): - """API Client to call function in NEST.""" + """ API Client to call function in NEST. + """ call = getattr(nest, call_name) if callable(call): - if "inspect" in kwargs: - response = {"data": getattr(inspect, kwargs["inspect"])(call)} + if 'inspect' in kwargs: + response = { + 'data': getattr(inspect, kwargs['inspect'])(call) + } else: response = do_call(call_name, args, kwargs) else: @@ -542,7 +478,7 @@ def run_mpi_app(host="127.0.0.1", port=52425): def combine(call_name, response): - """Combine responses from different MPI processes. + """ Combine responses from different MPI processes. In a distributed scenario, each MPI process creates its own share of the response from the data available locally. To present a @@ -586,7 +522,8 @@ def combine(call_name, response): return None # return the master response if all responses are known to be the same - if call_name in ("exec", "Create", "GetDefaults", "GetKernelStatus", "SetKernelStatus", "SetStatus"): + if call_name in ('exec', 'Create', 'GetDefaults', 'GetKernelStatus', + 'SetKernelStatus', 'SetStatus'): return response[0] # return a single response if there is only one which is not None @@ -604,7 +541,7 @@ def combine(call_name, response): log("combine()", f"ERROR: cannot combine response={response}") msg = "Cannot combine data because of unknown reason" - raise Exception(msg) # pylint: disable=W0719 + raise Exception(msg) def merge_dicts(response): @@ -624,49 +561,50 @@ def merge_dicts(response): result = [] for device_dicts in zip(*response): + # TODO: either stip fields like thread, vp, thread_local_id, # and local or make them lists that contain the values from # all dicts. - element_type = device_dicts[0]["element_type"] + element_type = device_dicts[0]['element_type'] - if element_type not in ("neuron", "recorder", "stimulator"): + if element_type not in ('neuron', 'recorder', 'stimulator'): msg = f'Cannot combine data of element with type "{element_type}".' - raise Exception(msg) # pylint: disable=W0719 + raise Exception(msg) - if element_type == "neuron": - tmp = list(filter(lambda status: status["local"], device_dicts)) + if element_type == 'neuron': + tmp = list(filter(lambda status: status['local'], device_dicts)) assert len(tmp) == 1 result.append(tmp[0]) - if element_type == "recorder": + if element_type == 'recorder': tmp = deepcopy(device_dicts[0]) - tmp["n_events"] = 0 + tmp['n_events'] = 0 for device_dict in device_dicts: - tmp["n_events"] += device_dict["n_events"] + tmp['n_events'] += device_dict['n_events'] - record_to = tmp["record_to"] - if record_to not in ("ascii", "memory"): + record_to = tmp['record_to'] + if record_to not in ('ascii', 'memory'): msg = f'Cannot combine data when recording to "{record_to}".' - raise Exception(msg) # pylint: disable=W0719 + raise Exception(msg) - if record_to == "memory": - event_keys = tmp["events"].keys() + if record_to == 'memory': + event_keys = tmp['events'].keys() for key in event_keys: - tmp["events"][key] = [] + tmp['events'][key] = [] for device_dict in device_dicts: for key in event_keys: - tmp["events"][key].extend(device_dict["events"][key]) + tmp['events'][key].extend(device_dict['events'][key]) - if record_to == "ascii": - tmp["filenames"] = [] + if record_to == 'ascii': + tmp['filenames'] = [] for device_dict in device_dicts: - tmp["filenames"].extend(device_dict["filenames"]) + tmp['filenames'].extend(device_dict['filenames']) result.append(tmp) - if element_type == "stimulator": + if element_type == 'stimulator': result.append(device_dicts[0]) return result From d568fdb2b324eb3e95ee281d4bae3a728ec0f2c3 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Thu, 27 Oct 2022 12:58:53 +0200 Subject: [PATCH 042/168] Add cross origin for / --- pynest/nest/server/hl_api_server.py | 1 + 1 file changed, 1 insertion(+) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 8eb1c6527d..f0af635033 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -179,6 +179,7 @@ def setup_auth(): @app.route('/', methods=['GET']) +@cross_origin() def index(): return jsonify({ 'nest': nest.__version__, From 9bdba04d8f5d006c9441501161ea1ba595c9842d Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Tue, 18 Jul 2023 13:11:09 +0200 Subject: [PATCH 043/168] Add changes notes for nest server --- doc/htmldoc/whats_new/changes.rst | 10 ++++++++++ 1 file changed, 10 insertions(+) create mode 100644 doc/htmldoc/whats_new/changes.rst diff --git a/doc/htmldoc/whats_new/changes.rst b/doc/htmldoc/whats_new/changes.rst new file mode 100644 index 0000000000..f7593baf99 --- /dev/null +++ b/doc/htmldoc/whats_new/changes.rst @@ -0,0 +1,10 @@ + +Changes in NEST Server +~~~~~~~~~~~~~~~~~~~~~~ + +* Improve the security in NEST Server. The user can modify the security options in environment variables: + * Requests require Bearer tokens. By default, the authentication is on (``NEST_SERVER_DISABLE_AUTH=0``). + * The CORS origins are restricted. By default, the only allowed CORS origin is ``http://localhost`` (``NEST_SERVER_CORS_ORIGINS=localhost``). + * Only API calls are enabled. By default, the exec call is disabled (``NEST_SERVER_ENABLE_EXEC_CALL=0``). + * The code execution is restricted. By default, the restriction is activated (``NEST_SERVER_DISABLE_RESTRICTION=0``). + * NEST Server takes also custom token (``NEST_SERVER_ACCESS_TOKEN='abcdefghijk'``) \ No newline at end of file From 04c9420e0d19861481cf0c3e8d80e0852502ec95 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Tue, 18 Jul 2023 15:32:36 +0200 Subject: [PATCH 044/168] Fix correct sytax for custom token --- pynest/nest/server/hl_api_server.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index f0af635033..375a8a5fdb 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -134,16 +134,16 @@ def setup_auth(): return ("Unauthorized", 403) self = funcs[0] - if ACCESS_TOKEN: - self._hash = ACCESS_TOKEN - # Use the salted hash (unless `PYTHONHASHSEED` is fixed) of the location of this # function in the Python heap and the current timestamp to create a SHA512 hash. if not hasattr(self, "_hash"): - hasher = hashlib.sha512() - hasher.update(str(hash(id(self))).encode("utf-8")) - hasher.update(str(time.perf_counter()).encode("utf-8")) - self._hash = hasher.hexdigest()[:48] + if ACCESS_TOKEN: + self._hash = ACCESS_TOKEN + else: + hasher = hashlib.sha512() + hasher.update(str(hash(id(self))).encode("utf-8")) + hasher.update(str(time.perf_counter()).encode("utf-8")) + self._hash = hasher.hexdigest()[:48] if not AUTH_DISABLED: print(f"\nBearer token to NEST server: {self._hash}\n") # The first time we hit the line below is when below the function definition we From 63f674919c6e1bdd7a230c17f7dd1fd20a3775ac Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Wed, 19 Jul 2023 10:47:57 +0200 Subject: [PATCH 045/168] Do not auth for OPTIONS method --- pynest/nest/server/hl_api_server.py | 25 ++++++++++++++----------- 1 file changed, 14 insertions(+), 11 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 375a8a5fdb..522e09d5fc 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -25,6 +25,7 @@ import io import sys +import flask from flask import Flask, request, jsonify from flask_cors import CORS from flask.logging import default_handler @@ -72,19 +73,19 @@ def get_boolean_environ(env_key, default_value='false'): app = Flask(__name__) # Inform client-side user agents that they should not attempt to call our server from any # non-whitelisted domain. -CORS(app, origins=CORS_ORIGINS, methods=["GET", "POST"]) +CORS(app, origins=CORS_ORIGINS, methods=['GET', 'POST']) mpi_comm = None -def check_security(): +def _check_security(): """ Checks the security level of the NEST Server instance. """ msg = [] if AUTH_DISABLED: - msg.append('AUTH:\tThe authentication is disabled.') + msg.append('AUTH:\tThe authorization is disabled.') if '*' in CORS_ORIGINS: msg.append('CORS:\tAllowed origins is not restricted.') if EXEC_CALL_ENABLED: @@ -92,17 +93,15 @@ def check_security(): if RESTRICTION_DISABLED: msg.append('RESTRICTION: Code scripts will be executed without a restricted environment.') - level = ['HIGHEST', 'HIGH', 'MODERATE', 'LOW', 'LOWEST'] - print(f'The security level of NEST Server is {level[len(msg)]}.') if len(msg) > 0: print('WARNING: The security of your system can not be ensured!') print('\n - '.join([' '] + msg) + '\n') else: - print('INFO: The security of your system can be ensured!') + print('INFO: The security of your system can be ensured!\n') @app.before_request -def setup_auth(): +def _setup_auth(): """ Authentication function that generates and validates the Authorization header with a bearer token. @@ -145,7 +144,11 @@ def setup_auth(): hasher.update(str(time.perf_counter()).encode("utf-8")) self._hash = hasher.hexdigest()[:48] if not AUTH_DISABLED: - print(f"\nBearer token to NEST server: {self._hash}\n") + print(f" Bearer token to NEST server: {self._hash}\n") + + if request.method == 'OPTIONS': + return + # The first time we hit the line below is when below the function definition we # call `setup_auth` without any Flask request existing yet, so the function errors # and exits here after generating and storing the auth hash. @@ -172,9 +175,9 @@ def setup_auth(): print( 80 * '*') -check_security() -setup_auth() -del setup_auth +_check_security() +_setup_auth() +del _setup_auth print( 80 * '*') From 46cf50c6327f0da99695bfe683a60d06947cac32 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Wed, 19 Jul 2023 11:28:38 +0200 Subject: [PATCH 046/168] Undo doc for v3.4 --- doc/htmldoc/whats_new/v3.4/index.rst | 105 +++++++++++++++++---------- 1 file changed, 67 insertions(+), 38 deletions(-) diff --git a/doc/htmldoc/whats_new/v3.4/index.rst b/doc/htmldoc/whats_new/v3.4/index.rst index a57ce8bd48..be69bbaa9a 100644 --- a/doc/htmldoc/whats_new/v3.4/index.rst +++ b/doc/htmldoc/whats_new/v3.4/index.rst @@ -3,57 +3,86 @@ What's new in NEST 3.4 ====================== -This page contains a summary of important breaking and non-breaking changes -from NEST 3.3 to NEST 3.4. In addition to the `release -notes on GitHub `_, -this page also contains transition information that helps you to -update your simulation scripts when you come from an older version of -NEST. +This page contains a summary of important breaking and non-breaking +changes from NEST 3.3 to NEST 3.4. In addition to the `release notes +on GitHub `_, this +page also contains transition information that helps you to update +your simulation scripts when you come from an older version of NEST. -If you transition from a version earlier than 3.3, please see our -extensive :ref:`transition guide from NEST 2.x to 3.0 -` or :ref:`release updates for previous releases in 3.x `. +If you transition from an earlier version, please see our extensive +:ref:`transition guide from NEST 2.x to 3.0 ` and the +:ref:`list of updates for previous releases in the 3.x series +`. Documentation restructuring and new theme ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -NEST documentation has a new theme! We did a major overhaul of the layout and structure of the documentation. -The changes aim to improve findability and access of content. With a more modern -layout, our wide range of docs can be discovered more easily. -The table of contents is simplified and the content is grouped based on topic (neurons, synapses etc) -rather than type of documentation (e.g., 'guides'). +NEST documentation has a new theme! We did a major overhaul of the +layout and structure of the documentation. The changes aim to improve +findability and access of content. With a more modern layout, our wide +range of docs can be discovered more easily. +The table of contents is simplified and the content is grouped based +on topics (neurons, synapses etc) rather than type of documentation +(e.g., 'guides'). -Changes in NEST behavior -~~~~~~~~~~~~~~~~~~~~~~~~ +We would be highly interested in any feedback you might have on the +new look-and-feel either on `our mailing list +`_ or as an `issue on +GitHub +`_ -Inferred extent of spatial layers with freely placed neurons -............................................................ +Query spatially structured networks from target neuron perspective +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -Spatial layers can be created by specifying only the node positions using ``spatial.free``, -without explicitly specifying the ``extent``. -In that case, in NEST 3.4 and later, the ``extent`` will be determined by the position of the -lower-leftmost and upper-rightmost nodes in the layer; earlier versions of NEST added a hard-coded -padding to the extent. The ``center`` is computed as the midpoint between the lower-leftmost and -upper-rightmost nodes. +PyNEST now provides functions :py:func:`.GetSourceNodes`, +:py:func:`.GetSourcePositions`, and :py:func:`.PlotSources` which +allow you to query or plot the source neurons of a given target +neuron. -When creating a layer with only a single node, the ``extent`` has to be specified explicitly. +Extent and center for spatial layers with freely placed neurons +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Spatial layers in NEST can be created by specifying node positions in +the call to :py:func:`.Create` using :ref:`spatial distributions ` +from ``nest.spatial``. -Deprecation information -~~~~~~~~~~~~~~~~~~~~~~~ +When using :py:class:`.spatial.free`, the layer's ``extent`` will be +determined automatically based on the positions of the lower-leftmost +and upper-rightmost nodes in the layer, if omitted. While earlier +versions of NEST added a hard-coded padding, NEST 3.4 will only use +the node positions. -* Model ``spike_dilutor`` is now deprecated and can only be used - in single-threaded mode. To implement connections which transmit - spikes with fixed probability, use ``bernoulli_synapse`` instead. +Likewise, the ``center`` of a layer is now automatically computed as +the midpoint between the lower-leftmost and the upper-rightmost nodes. +When creating a layer with only a single node, the ``extent`` still +has to be specified explicitly. -Changes in NEST Server -~~~~~~~~~~~~~~~~~~~~~~ +Disconnect with ``SynapseCollection`` +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -* By default, the NEST Server now runs on port ``52425`` (previously ``5000``). -* Improve the security in NEST Server. The user can modify the security options in environment variables: - * Requests require Bearer tokens. By default, the authentication is on (``NEST_SERVER_DISABLE_AUTH=0``). - * The CORS origins are restricted. By default, the only allowed CORS origin is ``http://localhost`` (``NEST_SERVER_CORS_ORIGINS=localhost``). - * Only API calls are enabled. By default, the exec call is disabled (``NEST_SERVER_ENABLE_EXEC_CALL=0``). - * The code execution is restricted. By default, the restriction is activated (``NEST_SERVER_DISABLE_RESTRICTION=0``). \ No newline at end of file +It is now possible to disconnect nodes using a ``SynapseCollection`` +as argument to either :py:func:`.disconnect` or the member function +``disconnect()`` of the ``SynapseCollection``. + +Removal of deprecated models +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +* The models ``iaf_psc_alpha_canon`` and ``pp_pop_psc_delta`` have + long been deprecated and were now removed from NEST. In case you + depend on them, you will find similar functionality in the + replacement models :doc:`iaf_psc_alpha_ps + ` and :doc:`iaf_psc_alpha_ps + `, respectively. + +* Model ``spike_dilutor`` is now deprecated and can only be used in + single-threaded mode. To implement connections which transmit spikes + with fixed probability, use :doc:`bernoulli_synapse + ` instead. + +Changed port of NEST Server +~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +To avoid conflicts with other services, the default port for NEST +Server has been changed from 5000 to 52025. From 94b2024144c8e2757716784116a7c23619464fae Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Wed, 19 Jul 2023 11:30:27 +0200 Subject: [PATCH 047/168] Use black --- pynest/nest/server/hl_api_server.py | 232 ++++++++++++++-------------- 1 file changed, 112 insertions(+), 120 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 522e09d5fc..7e56413bb8 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -48,32 +48,32 @@ root.addHandler(default_handler) -def get_boolean_environ(env_key, default_value='false'): +def get_boolean_environ(env_key, default_value="false"): env_value = os.environ.get(env_key, default_value) - return env_value.lower() in ['yes', 'true', 't', '1'] + return env_value.lower() in ["yes", "true", "t", "1"] -_default_origins = 'http://localhost' -ACCESS_TOKEN = os.environ.get('NEST_SERVER_ACCESS_TOKEN', '') -AUTH_DISABLED = get_boolean_environ('NEST_SERVER_DISABLE_AUTH') -CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', _default_origins).split(',') -EXEC_CALL_ENABLED = get_boolean_environ('NEST_SERVER_ENABLE_EXEC_CALL') -MODULES = os.environ.get('NEST_SERVER_MODULES', 'nest').split(',') -RESTRICTION_DISABLED = get_boolean_environ('NEST_SERVER_DISABLE_RESTRICTION') +_default_origins = "http://localhost" +ACCESS_TOKEN = os.environ.get("NEST_SERVER_ACCESS_TOKEN", "") +AUTH_DISABLED = get_boolean_environ("NEST_SERVER_DISABLE_AUTH") +CORS_ORIGINS = os.environ.get("NEST_SERVER_CORS_ORIGINS", _default_origins).split(",") +EXEC_CALL_ENABLED = get_boolean_environ("NEST_SERVER_ENABLE_EXEC_CALL") +MODULES = os.environ.get("NEST_SERVER_MODULES", "nest").split(",") +RESTRICTION_DISABLED = get_boolean_environ("NEST_SERVER_DISABLE_RESTRICTION") EXCEPTION_ERROR_STATUS = 400 __all__ = [ - 'app', - 'do_exec', - 'set_mpi_comm', - 'run_mpi_app', - 'nestify', + "app", + "do_exec", + "set_mpi_comm", + "run_mpi_app", + "nestify", ] app = Flask(__name__) # Inform client-side user agents that they should not attempt to call our server from any # non-whitelisted domain. -CORS(app, origins=CORS_ORIGINS, methods=['GET', 'POST']) +CORS(app, origins=CORS_ORIGINS, methods=["GET", "POST"]) mpi_comm = None @@ -85,19 +85,19 @@ def _check_security(): msg = [] if AUTH_DISABLED: - msg.append('AUTH:\tThe authorization is disabled.') - if '*' in CORS_ORIGINS: - msg.append('CORS:\tAllowed origins is not restricted.') + msg.append("AUTH:\tThe authorization is disabled.") + if "*" in CORS_ORIGINS: + msg.append("CORS:\tAllowed origins is not restricted.") if EXEC_CALL_ENABLED: - msg.append('EXEC CALL:\tAny code scripts can be executed!') + msg.append("EXEC CALL:\tAny code scripts can be executed!") if RESTRICTION_DISABLED: - msg.append('RESTRICTION: Code scripts will be executed without a restricted environment.') + msg.append("RESTRICTION: Code scripts will be executed without a restricted environment.") if len(msg) > 0: - print('WARNING: The security of your system can not be ensured!') - print('\n - '.join([' '] + msg) + '\n') + print("WARNING: The security of your system can not be ensured!") + print("\n - ".join([" "] + msg) + "\n") else: - print('INFO: The security of your system can be ensured!\n') + print("INFO: The security of your system can be ensured!\n") @app.before_request @@ -146,7 +146,7 @@ def _setup_auth(): if not AUTH_DISABLED: print(f" Bearer token to NEST server: {self._hash}\n") - if request.method == 'OPTIONS': + if request.method == "OPTIONS": return # The first time we hit the line below is when below the function definition we @@ -163,10 +163,7 @@ def _setup_auth(): # Things get more straightforward here: Every time a request is handled, compare # the Authorization header to the hash, with a constant-time algorithm to avoid # timing attacks. - if not ( - AUTH_DISABLED - or hmac.compare_digest(auth, f"Bearer {self._hash}") - ): + if not (AUTH_DISABLED or hmac.compare_digest(auth, f"Bearer {self._hash}")): return ("Unauthorized", 403) # DON'T LINT! Intentional bare except clause! Even `KeyboardInterrupt` and # `SystemExit` exceptions should not bypass authentication! @@ -174,25 +171,27 @@ def _setup_auth(): return ("Unauthorized", 403) -print( 80 * '*') +print(80 * "*") _check_security() _setup_auth() del _setup_auth -print( 80 * '*') +print(80 * "*") -@app.route('/', methods=['GET']) +@app.route("/", methods=["GET"]) @cross_origin() def index(): - return jsonify({ - 'nest': nest.__version__, - 'mpi': mpi_comm is not None, - }) + return jsonify( + { + "nest": nest.__version__, + "mpi": mpi_comm is not None, + } + ) def do_exec(args, kwargs): try: - source_code = kwargs.get('source', '') + source_code = kwargs.get("source", "") source_cleaned = clean_code(source_code) locals_ = dict() @@ -201,21 +200,21 @@ def do_exec(args, kwargs): with Capturing() as stdout: exec(source_cleaned, get_globals(), locals_) if len(stdout) > 0: - response['stdout'] = '\n'.join(stdout) + response["stdout"] = "\n".join(stdout) else: - code = RestrictedPython.compile_restricted(source_cleaned, '', 'exec') # noqa + code = RestrictedPython.compile_restricted(source_cleaned, "", "exec") # noqa exec(code, get_restricted_globals(), locals_) - if '_print' in locals_: - response['stdout'] = ''.join(locals_['_print'].txt) + if "_print" in locals_: + response["stdout"] = "".join(locals_["_print"].txt) - if 'return' in kwargs: - if isinstance(kwargs['return'], list): + if "return" in kwargs: + if isinstance(kwargs["return"], list): data = dict() - for variable in kwargs['return']: + for variable in kwargs["return"]: data[variable] = locals_.get(variable, None) else: - data = locals_.get(kwargs['return'], None) - response['data'] = nest.serializable(data) + data = locals_.get(kwargs["return"], None) + response["data"] = nest.serializable(data) return response except Exception as e: @@ -225,7 +224,7 @@ def do_exec(args, kwargs): def log(call_name, msg): - msg = f'==> MASTER 0/{time.time():.7f} ({call_name}): {msg}' + msg = f"==> MASTER 0/{time.time():.7f} ({call_name}): {msg}" print(msg, flush=True) @@ -253,41 +252,40 @@ def do_call(call_name, args=[], kwargs={}): assert mpi_comm.Get_rank() == 0 if mpi_comm is not None: - log(call_name, 'sending call bcast') + log(call_name, "sending call bcast") mpi_comm.bcast(call_name, root=0) data = (args, kwargs) - log(call_name, f'sending data bcast, data={data}') + log(call_name, f"sending data bcast, data={data}") mpi_comm.bcast(data, root=0) - if call_name == 'exec': + if call_name == "exec": master_response = do_exec(args, kwargs) else: call, args, kwargs = nestify(call_name, args, kwargs) - log(call_name, f'local call, args={args}, kwargs={kwargs}') + log(call_name, f"local call, args={args}, kwargs={kwargs}") master_response = call(*args, **kwargs) response = [nest.serializable(master_response)] if mpi_comm is not None: - log(call_name, 'waiting for response gather') + log(call_name, "waiting for response gather") response = mpi_comm.gather(response[0], root=0) - log(call_name, f'received response gather, data={response}') + log(call_name, f"received response gather, data={response}") return combine(call_name, response) -@app.route('/exec', methods=['GET', 'POST']) +@app.route("/exec", methods=["GET", "POST"]) def route_exec(): - """ Route to execute script in Python. - """ + """Route to execute script in Python.""" if EXEC_CALL_ENABLED: args, kwargs = get_arguments(request) - response = do_call('exec', args, kwargs) + response = do_call("exec", args, kwargs) return jsonify(response) else: flask.abort( 403, - 'The route `/exec` has been disabled. Please contact the server administrator.', + "The route `/exec` has been disabled. Please contact the server administrator.", ) @@ -296,21 +294,19 @@ def route_exec(): # -------------------------- nest_calls = dir(nest) -nest_calls = list(filter(lambda x: not x.startswith('_'), nest_calls)) +nest_calls = list(filter(lambda x: not x.startswith("_"), nest_calls)) nest_calls.sort() -@app.route('/api', methods=['GET']) +@app.route("/api", methods=["GET"]) def route_api(): - """ Route to list call functions in NEST. - """ + """Route to list call functions in NEST.""" return jsonify(nest_calls) -@app.route('/api/', methods=['GET', 'POST']) +@app.route("/api/", methods=["GET", "POST"]) def route_api_call(call): - """ Route to call function in NEST. - """ + """Route to call function in NEST.""" print(f"\n{'='*40}\n", flush=True) args, kwargs = get_arguments(request) log("route_api_call", f"call={call}, args={args}, kwargs={kwargs}") @@ -322,8 +318,9 @@ def route_api_call(call): # Helpers for the server # ---------------------- + class Capturing(list): - """ Monitor stdout contents i.e. print. """ + """Monitor stdout contents i.e. print.""" def __enter__(self): self._stdout = sys.stdout @@ -332,19 +329,18 @@ def __enter__(self): def __exit__(self, *args): self.extend(self._stringio.getvalue().splitlines()) - del self._stringio # free up some memory + del self._stringio # free up some memory sys.stdout = self._stdout def clean_code(source): - codes = source.split('\n') - code_cleaned = filter(lambda code: not (code.startswith('import') or code.startswith('from')), codes) # noqa - return '\n'.join(code_cleaned) + codes = source.split("\n") + code_cleaned = filter(lambda code: not (code.startswith("import") or code.startswith("from")), codes) # noqa + return "\n".join(code_cleaned) def get_arguments(request): - """ Get arguments from the request. - """ + """Get arguments from the request.""" args, kwargs = [], {} if request.is_json: json = request.get_json() @@ -354,24 +350,23 @@ def get_arguments(request): args = json elif isinstance(json, dict): kwargs = json - if 'args' in kwargs: - args = kwargs.pop('args') + if "args" in kwargs: + args = kwargs.pop("args") elif len(request.form) > 0: - if 'args' in request.form: - args = request.form.getlist('args') + if "args" in request.form: + args = request.form.getlist("args") else: kwargs = request.form.to_dict() elif len(request.args) > 0: - if 'args' in request.args: - args = request.args.getlist('args') + if "args" in request.args: + args = request.args.getlist("args") else: kwargs = request.args.to_dict() return list(args), kwargs def get_globals(): - """ Get globals for exec function. - """ + """Get globals for exec function.""" copied_globals = globals().copy() # Add modules to copied globals @@ -383,8 +378,8 @@ def get_globals(): def get_or_error(func): - """ Wrapper to get data and status. - """ + """Wrapper to get data and status.""" + def func_wrapper(call, args, kwargs): try: return func(call, args, kwargs) @@ -392,12 +387,13 @@ def func_wrapper(call, args, kwargs): for line in traceback.format_exception(*sys.exc_info()): print(line, flush=True) flask.abort(EXCEPTION_ERROR_STATUS, str(e)) + return func_wrapper def get_restricted_globals(): - """ Get restricted globals for exec function. - """ + """Get restricted globals for exec function.""" + def getitem(obj, index): typelist = (list, tuple, dict, nest.NodeCollection) if obj is not None and type(obj) in typelist: @@ -408,12 +404,14 @@ def getitem(obj, index): restricted_builtins = RestrictedPython.safe_builtins.copy() restricted_builtins.update(RestrictedPython.limited_builtins) restricted_builtins.update(RestrictedPython.utility_builtins) - restricted_builtins.update(dict( - max=max, - min=min, - sum=sum, - time=time, - )) + restricted_builtins.update( + dict( + max=max, + min=min, + sum=sum, + time=time, + ) + ) restricted_globals = dict( __builtins__=restricted_builtins, @@ -434,14 +432,12 @@ def getitem(obj, index): def nestify(call_name, args, kwargs): - """ Get the NEST API call and convert arguments if neccessary. - """ + """Get the NEST API call and convert arguments if neccessary.""" call = getattr(nest, call_name) - objectnames = ['nodes', 'source', 'target', 'pre', 'post'] + objectnames = ["nodes", "source", "target", "pre", "post"] paramKeys = list(inspect.signature(call).parameters.keys()) - args = [nest.NodeCollection(arg) if paramKeys[idx] in objectnames - else arg for (idx, arg) in enumerate(args)] + args = [nest.NodeCollection(arg) if paramKeys[idx] in objectnames else arg for (idx, arg) in enumerate(args)] for (key, value) in kwargs.items(): if key in objectnames: kwargs[key] = nest.NodeCollection(value) @@ -451,16 +447,13 @@ def nestify(call_name, args, kwargs): @get_or_error def api_client(call_name, args, kwargs): - """ API Client to call function in NEST. - """ + """API Client to call function in NEST.""" call = getattr(nest, call_name) if callable(call): - if 'inspect' in kwargs: - response = { - 'data': getattr(inspect, kwargs['inspect'])(call) - } + if "inspect" in kwargs: + response = {"data": getattr(inspect, kwargs["inspect"])(call)} else: response = do_call(call_name, args, kwargs) else: @@ -482,7 +475,7 @@ def run_mpi_app(host="127.0.0.1", port=52425): def combine(call_name, response): - """ Combine responses from different MPI processes. + """Combine responses from different MPI processes. In a distributed scenario, each MPI process creates its own share of the response from the data available locally. To present a @@ -526,8 +519,7 @@ def combine(call_name, response): return None # return the master response if all responses are known to be the same - if call_name in ('exec', 'Create', 'GetDefaults', 'GetKernelStatus', - 'SetKernelStatus', 'SetStatus'): + if call_name in ("exec", "Create", "GetDefaults", "GetKernelStatus", "SetKernelStatus", "SetStatus"): return response[0] # return a single response if there is only one which is not None @@ -570,45 +562,45 @@ def merge_dicts(response): # and local or make them lists that contain the values from # all dicts. - element_type = device_dicts[0]['element_type'] + element_type = device_dicts[0]["element_type"] - if element_type not in ('neuron', 'recorder', 'stimulator'): + if element_type not in ("neuron", "recorder", "stimulator"): msg = f'Cannot combine data of element with type "{element_type}".' raise Exception(msg) - if element_type == 'neuron': - tmp = list(filter(lambda status: status['local'], device_dicts)) + if element_type == "neuron": + tmp = list(filter(lambda status: status["local"], device_dicts)) assert len(tmp) == 1 result.append(tmp[0]) - if element_type == 'recorder': + if element_type == "recorder": tmp = deepcopy(device_dicts[0]) - tmp['n_events'] = 0 + tmp["n_events"] = 0 for device_dict in device_dicts: - tmp['n_events'] += device_dict['n_events'] + tmp["n_events"] += device_dict["n_events"] - record_to = tmp['record_to'] - if record_to not in ('ascii', 'memory'): + record_to = tmp["record_to"] + if record_to not in ("ascii", "memory"): msg = f'Cannot combine data when recording to "{record_to}".' raise Exception(msg) - if record_to == 'memory': - event_keys = tmp['events'].keys() + if record_to == "memory": + event_keys = tmp["events"].keys() for key in event_keys: - tmp['events'][key] = [] + tmp["events"][key] = [] for device_dict in device_dicts: for key in event_keys: - tmp['events'][key].extend(device_dict['events'][key]) + tmp["events"][key].extend(device_dict["events"][key]) - if record_to == 'ascii': - tmp['filenames'] = [] + if record_to == "ascii": + tmp["filenames"] = [] for device_dict in device_dicts: - tmp['filenames'].extend(device_dict['filenames']) + tmp["filenames"].extend(device_dict["filenames"]) result.append(tmp) - if element_type == 'stimulator': + if element_type == "stimulator": result.append(device_dicts[0]) return result From 0d4e954f834ac33902c1a2ca00f1e3a0744c7afa Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Wed, 19 Jul 2023 11:33:13 +0200 Subject: [PATCH 048/168] Remove cors_origins() --- pynest/nest/server/hl_api_server.py | 1 - 1 file changed, 1 deletion(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 7e56413bb8..b60b268e09 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -179,7 +179,6 @@ def _setup_auth(): @app.route("/", methods=["GET"]) -@cross_origin() def index(): return jsonify( { From c01da1a21a85b992ee3202c5efe2f879ccffe803 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Wed, 19 Jul 2023 11:44:36 +0200 Subject: [PATCH 049/168] Update changes --- doc/htmldoc/whats_new/changes.rst | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/doc/htmldoc/whats_new/changes.rst b/doc/htmldoc/whats_new/changes.rst index f7593baf99..a90209d711 100644 --- a/doc/htmldoc/whats_new/changes.rst +++ b/doc/htmldoc/whats_new/changes.rst @@ -4,7 +4,8 @@ Changes in NEST Server * Improve the security in NEST Server. The user can modify the security options in environment variables: * Requests require Bearer tokens. By default, the authentication is on (``NEST_SERVER_DISABLE_AUTH=0``). - * The CORS origins are restricted. By default, the only allowed CORS origin is ``http://localhost`` (``NEST_SERVER_CORS_ORIGINS=localhost``). + * NEST Server takes also custom token (``NEST_SERVER_ACCESS_TOKEN='alongaccesstoken'``), otherwise it generates token. + * The CORS origins are restricted. By default, the only allowed CORS origin is ``http://localhost`` + (``NEST_SERVER_CORS_ORIGINS=http://localhost``). * Only API calls are enabled. By default, the exec call is disabled (``NEST_SERVER_ENABLE_EXEC_CALL=0``). - * The code execution is restricted. By default, the restriction is activated (``NEST_SERVER_DISABLE_RESTRICTION=0``). - * NEST Server takes also custom token (``NEST_SERVER_ACCESS_TOKEN='abcdefghijk'``) \ No newline at end of file + * The code execution is restricted. By default, the restriction is activated (``NEST_SERVER_DISABLE_RESTRICTION=0``). \ No newline at end of file From b920b4d81c5dad61c339a70891380165748f4c30 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Wed, 19 Jul 2023 11:50:52 +0200 Subject: [PATCH 050/168] Fix pylint --- pynest/nest/server/hl_api_server.py | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index b60b268e09..09522d5a32 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -167,10 +167,9 @@ def _setup_auth(): return ("Unauthorized", 403) # DON'T LINT! Intentional bare except clause! Even `KeyboardInterrupt` and # `SystemExit` exceptions should not bypass authentication! - except: # noqa + except Exception: # noqa return ("Unauthorized", 403) - print(80 * "*") _check_security() _setup_auth() @@ -536,7 +535,7 @@ def combine(call_name, response): log("combine()", f"ERROR: cannot combine response={response}") msg = "Cannot combine data because of unknown reason" - raise Exception(msg) + raise Exception(msg) # pylint: disable=W0719 def merge_dicts(response): @@ -565,7 +564,7 @@ def merge_dicts(response): if element_type not in ("neuron", "recorder", "stimulator"): msg = f'Cannot combine data of element with type "{element_type}".' - raise Exception(msg) + raise Exception(msg) # pylint: disable=W0719 if element_type == "neuron": tmp = list(filter(lambda status: status["local"], device_dicts)) @@ -582,7 +581,7 @@ def merge_dicts(response): record_to = tmp["record_to"] if record_to not in ("ascii", "memory"): msg = f'Cannot combine data when recording to "{record_to}".' - raise Exception(msg) + raise Exception(msg) # pylint: disable=W0719 if record_to == "memory": event_keys = tmp["events"].keys() From 65bd3af487ca809bc250964af64ac1a1638868d0 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Wed, 19 Jul 2023 11:51:20 +0200 Subject: [PATCH 051/168] Apply black --- pynest/nest/server/hl_api_server.py | 1 + 1 file changed, 1 insertion(+) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 09522d5a32..54d30a3239 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -170,6 +170,7 @@ def _setup_auth(): except Exception: # noqa return ("Unauthorized", 403) + print(80 * "*") _check_security() _setup_auth() From ae2ea1c84f33c076334f515b4a4852565b810d70 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Wed, 19 Jul 2023 11:54:15 +0200 Subject: [PATCH 052/168] try to fix black --- pynest/nest/server/hl_api_server.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 54d30a3239..8e5810fde1 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -437,7 +437,7 @@ def nestify(call_name, args, kwargs): objectnames = ["nodes", "source", "target", "pre", "post"] paramKeys = list(inspect.signature(call).parameters.keys()) args = [nest.NodeCollection(arg) if paramKeys[idx] in objectnames else arg for (idx, arg) in enumerate(args)] - for (key, value) in kwargs.items(): + for key, value in kwargs.items(): if key in objectnames: kwargs[key] = nest.NodeCollection(value) From b28bdee477128ce7f2125f1fd9860b36cafc2bdd Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Wed, 19 Jul 2023 11:57:11 +0200 Subject: [PATCH 053/168] Apply black --- pynest/nest/server/hl_api_server.py | 1 - 1 file changed, 1 deletion(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 8e5810fde1..7de488c7ad 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -556,7 +556,6 @@ def merge_dicts(response): result = [] for device_dicts in zip(*response): - # TODO: either stip fields like thread, vp, thread_local_id, # and local or make them lists that contain the values from # all dicts. From d2275d739b6fd234597b6be394496baacefa2a36 Mon Sep 17 00:00:00 2001 From: Nicolai Haug Date: Wed, 9 Aug 2023 16:49:11 +0200 Subject: [PATCH 054/168] Add isort runner --- .github/workflows/nestbuildmatrix.yml | 20 +++++++++++++++++--- 1 file changed, 17 insertions(+), 3 deletions(-) diff --git a/.github/workflows/nestbuildmatrix.yml b/.github/workflows/nestbuildmatrix.yml index d6d9362185..bc31c01a41 100644 --- a/.github/workflows/nestbuildmatrix.yml +++ b/.github/workflows/nestbuildmatrix.yml @@ -290,6 +290,19 @@ jobs: - name: "Run pylint..." run: | pylint --jobs=$(nproc) pynest/ testsuite/pytests/*.py testsuite/regressiontests/*.py + + isort: + runs-on: "ubuntu-20.04" + steps: + - name: "Checkout repository content" + uses: actions/checkout@v3 + with: + fetch-depth: 0 + + - name: "Run isort..." + uses: isort/isort-action@f14e57e1d457956c45a19c05a89cccdf087846e5 # 1.1.0 + with: + configuration: --profile black black: runs-on: "ubuntu-20.04" @@ -298,8 +311,9 @@ jobs: uses: actions/checkout@v3 with: fetch-depth: 0 + - name: "Run black..." - uses: psf/black@bf7a16254ec96b084a6caf3d435ec18f0f245cc7 # 23.3.0 + uses: psf/black@193ee766ca496871f93621d6b58d57a6564ff81b # 23.7.0 with: jupyter: true @@ -405,7 +419,7 @@ jobs: build_linux: if: ${{ !contains(github.event.head_commit.message, 'ci skip') }} runs-on: ${{ matrix.os }} - needs: [clang-format, mypy, copyright_headers, unused_names, forbidden_types, pylint, black, flake8] + needs: [clang-format, mypy, copyright_headers, unused_names, forbidden_types, pylint, isort, black, flake8] env: CXX_FLAGS: "-pedantic -Wextra -Woverloaded-virtual -Wno-unknown-pragmas" NEST_VPATH: "build" @@ -607,7 +621,7 @@ jobs: build_macos: if: ${{ !contains(github.event.head_commit.message, 'ci skip') }} runs-on: ${{ matrix.os }} - needs: [clang-format, mypy, copyright_headers, unused_names, forbidden_types, pylint, black, flake8] + needs: [clang-format, mypy, copyright_headers, unused_names, forbidden_types, pylint, isort, black, flake8] env: CXX_FLAGS: "-pedantic -Wextra -Woverloaded-virtual -Wno-unknown-pragmas" NEST_VPATH: "build" From 01a9f6702e27023fbd6586c9a6ba06e29622a26b Mon Sep 17 00:00:00 2001 From: Nicolai Haug Date: Wed, 9 Aug 2023 16:54:54 +0200 Subject: [PATCH 055/168] Add isort to config --- pyproject.toml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/pyproject.toml b/pyproject.toml index 05ffbca6fa..4c56a590cf 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -7,5 +7,8 @@ markers = [ "simulation: the simulation class to use. Always pass a 2nd dummy argument" ] +[tool.isort] +profile = "black" + [tool.black] line-length = 120 From 2f5d4a9a0a8848c28285136f4ac2a2bc982b4e5d Mon Sep 17 00:00:00 2001 From: Nicolai Haug Date: Wed, 9 Aug 2023 16:57:09 +0200 Subject: [PATCH 056/168] Debugging build matrix --- .github/workflows/nestbuildmatrix.yml | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/.github/workflows/nestbuildmatrix.yml b/.github/workflows/nestbuildmatrix.yml index bc31c01a41..f408cc23e3 100644 --- a/.github/workflows/nestbuildmatrix.yml +++ b/.github/workflows/nestbuildmatrix.yml @@ -291,18 +291,18 @@ jobs: run: | pylint --jobs=$(nproc) pynest/ testsuite/pytests/*.py testsuite/regressiontests/*.py - isort: - runs-on: "ubuntu-20.04" - steps: - - name: "Checkout repository content" - uses: actions/checkout@v3 - with: - fetch-depth: 0 - - - name: "Run isort..." - uses: isort/isort-action@f14e57e1d457956c45a19c05a89cccdf087846e5 # 1.1.0 - with: - configuration: --profile black + #isort: + # runs-on: "ubuntu-20.04" + # steps: + # - name: "Checkout repository content" + # uses: actions/checkout@v3 + # with: + # fetch-depth: 0 + + # - name: "Run isort..." + # uses: isort/isort-action@f14e57e1d457956c45a19c05a89cccdf087846e5 # 1.1.0 + # with: + # configuration: --profile black black: runs-on: "ubuntu-20.04" From 673f09c75d794f7ec082393dab88687775aa9a4b Mon Sep 17 00:00:00 2001 From: Nicolai Haug Date: Wed, 9 Aug 2023 17:07:02 +0200 Subject: [PATCH 057/168] Debug --- .github/workflows/nestbuildmatrix.yml | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/.github/workflows/nestbuildmatrix.yml b/.github/workflows/nestbuildmatrix.yml index f408cc23e3..b1c5559eb3 100644 --- a/.github/workflows/nestbuildmatrix.yml +++ b/.github/workflows/nestbuildmatrix.yml @@ -291,18 +291,18 @@ jobs: run: | pylint --jobs=$(nproc) pynest/ testsuite/pytests/*.py testsuite/regressiontests/*.py - #isort: - # runs-on: "ubuntu-20.04" - # steps: - # - name: "Checkout repository content" - # uses: actions/checkout@v3 - # with: - # fetch-depth: 0 - - # - name: "Run isort..." - # uses: isort/isort-action@f14e57e1d457956c45a19c05a89cccdf087846e5 # 1.1.0 - # with: - # configuration: --profile black + isort: + runs-on: "ubuntu-20.04" + steps: + - name: "Checkout repository content" + uses: actions/checkout@v3 + with: + fetch-depth: 0 + + - name: "Run isort..." + uses: isort/isort-action@f14e57e1d457956c45a19c05a89cccdf087846e5 # 1.1.0 + #with: + # configuration: --profile black black: runs-on: "ubuntu-20.04" From f3b00d063a3fbd0c57e98c55a34c1a8812a6c225 Mon Sep 17 00:00:00 2001 From: Nicolai Haug Date: Wed, 9 Aug 2023 17:15:07 +0200 Subject: [PATCH 058/168] Enable black profile --- .github/workflows/nestbuildmatrix.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/nestbuildmatrix.yml b/.github/workflows/nestbuildmatrix.yml index b1c5559eb3..ec79342f17 100644 --- a/.github/workflows/nestbuildmatrix.yml +++ b/.github/workflows/nestbuildmatrix.yml @@ -301,8 +301,8 @@ jobs: - name: "Run isort..." uses: isort/isort-action@f14e57e1d457956c45a19c05a89cccdf087846e5 # 1.1.0 - #with: - # configuration: --profile black + with: + configuration: --profile black black: runs-on: "ubuntu-20.04" From 89dcfe185d16018abf6a4fe5105a5bdb62fe8c52 Mon Sep 17 00:00:00 2001 From: Nicolai Haug Date: Wed, 9 Aug 2023 17:17:53 +0200 Subject: [PATCH 059/168] Add more to isort config --- .github/workflows/nestbuildmatrix.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/nestbuildmatrix.yml b/.github/workflows/nestbuildmatrix.yml index ec79342f17..571ebdae39 100644 --- a/.github/workflows/nestbuildmatrix.yml +++ b/.github/workflows/nestbuildmatrix.yml @@ -302,7 +302,7 @@ jobs: - name: "Run isort..." uses: isort/isort-action@f14e57e1d457956c45a19c05a89cccdf087846e5 # 1.1.0 with: - configuration: --profile black + configuration: --profile black --check-only --diff black: runs-on: "ubuntu-20.04" From 8b039cf769bb56f76e889e44540cecb9463d18e1 Mon Sep 17 00:00:00 2001 From: Nicolai Haug Date: Wed, 9 Aug 2023 17:28:49 +0200 Subject: [PATCH 060/168] Add isort to pre-commit hook --- .pre-commit-config.yaml | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 26ce0fca22..9c3003ad81 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -1,6 +1,11 @@ repos: + - repo: https://github.com/pycqa/isort + rev: 5.12.0 + hooks: + - id: isort + args: ["--profile", "black", "--check-only", "--diff"] - repo: https://github.com/psf/black - rev: 23.3.0 + rev: 23.7.0 hooks: - id: black language_version: python3 From 4d52bd9618d367bbb902abe8d674a28e15ac8cb7 Mon Sep 17 00:00:00 2001 From: Nicolai Haug Date: Wed, 9 Aug 2023 17:58:53 +0200 Subject: [PATCH 061/168] Sort imports --- .github/workflows/nestbuildmatrix.yml | 2 +- .pre-commit-config.yaml | 2 +- bin/nest-server-mpi | 24 +++++++++---------- build_support/check_copyright_headers.py | 2 +- build_support/check_unused_names.py | 2 +- build_support/generate_modelsmodule.py | 3 +-- doc/htmldoc/_ext/HoverXTooltip.py | 3 ++- doc/htmldoc/_ext/VersionSyncRole.py | 1 + doc/htmldoc/_ext/extractor_userdocs.py | 14 +++++------ doc/htmldoc/clean_source_dirs.py | 2 +- doc/htmldoc/conf.py | 8 +++---- doc/htmldoc/networks/scripts/connections.py | 2 +- doc/htmldoc/resolve_includes.py | 2 +- doc/slihelp_generator/generate_help.py | 12 ++++++---- doc/slihelp_generator/generate_helpindex.py | 1 + doc/slihelp_generator/helpers_sli.py | 4 ++-- doc/slihelp_generator/writers.py | 3 ++- examples/nest/Potjans_2014/spike_analysis.py | 5 ++-- pynest/examples/BrodyHopfield.py | 2 +- pynest/examples/CampbellSiegert.py | 8 +++---- pynest/examples/Potjans_2014/helpers.py | 5 ++-- pynest/examples/Potjans_2014/network.py | 7 +++--- .../examples/Potjans_2014/run_microcircuit.py | 11 +++++---- .../examples/aeif_cond_beta_multisynapse.py | 2 +- pynest/examples/balancedneuron.py | 5 ++-- pynest/examples/brette_gerstner_fig_2c.py | 2 +- pynest/examples/brette_gerstner_fig_3d.py | 2 +- .../brunel_alpha_evolution_strategies.py | 4 ++-- pynest/examples/brunel_alpha_nest.py | 7 +++--- pynest/examples/brunel_delta_nest.py | 3 ++- .../examples/brunel_exp_multisynapse_nest.py | 3 ++- .../examples/clopath_synapse_small_network.py | 5 ++-- .../examples/clopath_synapse_spike_pairing.py | 2 +- .../receptors_and_current.py | 2 +- .../examples/compartmental_model/two_comps.py | 2 +- pynest/examples/csa_example.py | 5 ++-- pynest/examples/csa_spatial_example.py | 2 +- pynest/examples/dev.py | 5 ++++ .../examples/evaluate_quantal_stp_synapse.py | 2 +- pynest/examples/evaluate_tsodyks2_synapse.py | 2 +- .../gap_junctions_inhibitory_network.py | 2 +- pynest/examples/gap_junctions_two_neurons.py | 2 +- pynest/examples/gif_cond_exp_multisynapse.py | 3 +-- pynest/examples/gif_pop_psc_exp.py | 4 ++-- pynest/examples/gif_population.py | 2 +- pynest/examples/glif_cond_neuron.py | 4 ++-- pynest/examples/glif_psc_neuron.py | 4 ++-- pynest/examples/hh_phaseplane.py | 1 - pynest/examples/hh_psc_alpha.py | 2 +- pynest/examples/hpc_benchmark.py | 4 ++-- pynest/examples/if_curve.py | 5 ++-- pynest/examples/intrinsic_currents_spiking.py | 2 +- .../intrinsic_currents_subthreshold.py | 2 +- pynest/examples/lin_rate_ipn_network.py | 2 +- pynest/examples/mc_neuron.py | 2 +- pynest/examples/multimeter_file.py | 2 +- .../receiver_script.py | 3 ++- pynest/examples/one_neuron.py | 2 +- pynest/examples/one_neuron_with_noise.py | 2 +- pynest/examples/plot_weight_matrices.py | 4 ++-- pynest/examples/pong/generate_gif.py | 11 ++++----- pynest/examples/pong/networks.py | 5 ++-- pynest/examples/pong/run_simulations.py | 5 ++-- pynest/examples/precise_spiking.py | 3 +-- pynest/examples/pulsepacket.py | 4 ++-- pynest/examples/rate_neuron_dm.py | 2 +- pynest/examples/repeated_stimulation.py | 2 +- .../examples/sensitivity_to_perturbation.py | 3 +-- pynest/examples/sinusoidal_gamma_generator.py | 2 +- .../examples/sinusoidal_poisson_generator.py | 2 +- .../examples/sonata_example/sonata_network.py | 5 ++-- pynest/examples/spatial/conncomp.py | 2 +- pynest/examples/spatial/conncon_sources.py | 2 +- pynest/examples/spatial/conncon_targets.py | 2 +- pynest/examples/spatial/connex.py | 2 +- pynest/examples/spatial/connex_ew.py | 2 +- pynest/examples/spatial/ctx_2n.py | 2 +- pynest/examples/spatial/gaussex.py | 2 +- pynest/examples/spatial/grid_iaf.py | 2 +- pynest/examples/spatial/grid_iaf_irr.py | 2 +- pynest/examples/spatial/grid_iaf_oc.py | 2 +- pynest/examples/spatial/test_3d.py | 2 +- pynest/examples/spatial/test_3d_exp.py | 2 +- pynest/examples/spatial/test_3d_gauss.py | 2 +- pynest/examples/store_restore_network.py | 13 +++++----- pynest/examples/structural_plasticity.py | 6 ++--- pynest/examples/sudoku/helpers_sudoku.py | 2 +- pynest/examples/sudoku/plot_progress.py | 7 +++--- pynest/examples/sudoku/sudoku_net.py | 4 ++-- pynest/examples/sudoku/sudoku_solver.py | 9 +++---- pynest/examples/synapsecollection.py | 2 +- pynest/examples/testiaf.py | 2 +- pynest/examples/tsodyks_depressing.py | 2 +- pynest/examples/tsodyks_facilitating.py | 2 +- pynest/examples/twoneurons.py | 2 +- pynest/examples/urbanczik_synapse_example.py | 2 +- pynest/examples/vinit_example.py | 2 +- pynest/nest/__init__.py | 11 +++++---- pynest/nest/lib/hl_api_connection_helpers.py | 5 ++-- pynest/nest/lib/hl_api_connections.py | 5 ++-- pynest/nest/lib/hl_api_helper.py | 9 ++++--- pynest/nest/lib/hl_api_info.py | 13 +++++++--- pynest/nest/lib/hl_api_models.py | 11 ++++++--- pynest/nest/lib/hl_api_nodes.py | 3 ++- pynest/nest/lib/hl_api_parallel_computing.py | 2 +- pynest/nest/lib/hl_api_simulation.py | 4 ++-- pynest/nest/lib/hl_api_spatial.py | 6 ++--- pynest/nest/lib/hl_api_types.py | 11 +++++---- pynest/nest/ll_api.py | 3 +-- pynest/nest/ll_api_kernel_attributes.py | 2 +- pynest/nest/logic/hl_api_logic.py | 2 +- pynest/nest/raster_plot.py | 2 +- pynest/nest/server/hl_api_server.py | 20 ++++++---------- pynest/nest/spatial/__init__.py | 3 ++- pynest/nest/spatial/hl_api_spatial.py | 1 + pynest/nest/visualization.py | 2 +- pynest/pynestkernel.pxd | 3 +-- pynest/pynestkernel.pyx | 18 ++++++-------- pyproject.toml | 1 + testsuite/pytests/conftest.py | 3 +-- testsuite/pytests/connect_test_base.py | 5 ++-- .../pytests/mpi/2/test_connect_arrays_mpi.py | 1 + testsuite/pytests/mpi/2/test_issue_576.py | 3 ++- .../mpi/4/test_consistent_local_vps.py | 2 +- .../sli2py_connect/test_delay_check.py | 2 +- .../iaf_psc_alpha/test_iaf_psc_alpha.py | 3 +-- .../iaf_psc_alpha/test_iaf_psc_alpha_1to2.py | 2 +- .../iaf_psc_alpha/test_iaf_psc_alpha_dc.py | 4 ++-- .../sli2py_neurons/test_add_freeze_thaw.py | 2 +- .../sli2py_neurons/test_amat2_psc_exp.py | 3 +-- .../sli2py_neurons/test_mat2_psc_exp.py | 3 +-- .../sli2py_neurons/test_model_node_init.py | 2 +- .../test_neurons_handle_multiplicity.py | 2 +- .../pytests/sli2py_neurons/test_set_vm.py | 3 ++- .../sli2py_other/test_corr_matrix_det.py | 2 +- .../sli2py_other/test_multithreading.py | 2 +- .../pytests/sli2py_other/test_set_tics.py | 3 +-- .../pytests/sli2py_recording/test_corr_det.py | 2 +- .../test_multimeter_freeze_thaw.py | 3 +-- .../test_multimeter_offset.py | 3 +-- .../test_multimeter_stepping.py | 3 +-- .../sli2py_regressions/test_issue_1242.py | 3 +-- .../sli2py_regressions/test_issue_1305.py | 3 +-- .../sli2py_regressions/test_issue_1366.py | 3 +-- .../sli2py_regressions/test_issue_351.py | 3 +-- .../sli2py_regressions/test_issue_368.py | 3 +-- .../sli2py_regressions/test_issue_410.py | 3 +-- .../pytests/sli2py_regressions/ticket_754.py | 3 +-- .../sli2py_stimulating/test_ac_generator.py | 5 ++-- .../test_noise_generator.py | 2 +- .../test_pulsepacket_generator.py | 3 +-- .../test_sinusoidal_poisson_generator.py | 3 +-- .../test_spike_generator.py | 2 +- .../test_spike_poisson_ps.py | 3 +-- .../test_cont_delay_synapse.py | 2 +- .../sli2py_synapses/test_hh_cond_exp_traub.py | 2 +- testsuite/pytests/test_NodeCollection.py | 1 + testsuite/pytests/test_aeif_lsodar.py | 6 ++--- testsuite/pytests/test_changing_tic_base.py | 1 + testsuite/pytests/test_clopath_synapse.py | 1 + testsuite/pytests/test_compartmental_model.py | 4 ++-- testsuite/pytests/test_connect_all_to_all.py | 6 ++--- .../test_connect_array_fixed_indegree.py | 1 + .../test_connect_array_fixed_outdegree.py | 2 +- testsuite/pytests/test_connect_arrays.py | 2 +- testsuite/pytests/test_connect_conngen.py | 1 + .../pytests/test_connect_fixed_indegree.py | 6 ++--- .../pytests/test_connect_fixed_outdegree.py | 6 ++--- .../test_connect_fixed_total_number.py | 6 ++--- testsuite/pytests/test_connect_one_to_one.py | 4 ++-- .../test_connect_pairwise_bernoulli.py | 6 ++--- ...st_connect_symmetric_pairwise_bernoulli.py | 6 ++--- .../test_correlospinmatrix_detector.py | 2 +- testsuite/pytests/test_create.py | 1 + .../test_current_recording_generators.py | 3 ++- testsuite/pytests/test_erfc_neuron.py | 1 + testsuite/pytests/test_errors.py | 1 + testsuite/pytests/test_events.py | 1 + testsuite/pytests/test_facetshw_stdp.py | 3 ++- testsuite/pytests/test_get_set.py | 3 ++- testsuite/pytests/test_getconnections.py | 1 + testsuite/pytests/test_getnodes.py | 1 + testsuite/pytests/test_glif_cond.py | 1 + testsuite/pytests/test_glif_psc.py | 1 + testsuite/pytests/test_helper_functions.py | 1 + testsuite/pytests/test_iaf_singularity.py | 2 +- testsuite/pytests/test_json.py | 1 + testsuite/pytests/test_labeled_synapses.py | 1 + testsuite/pytests/test_mc_neuron.py | 1 + testsuite/pytests/test_mip_corrdet.py | 2 +- testsuite/pytests/test_multimeter.py | 3 +-- testsuite/pytests/test_multiple_synapses.py | 1 + testsuite/pytests/test_nodeParametrization.py | 5 ++-- testsuite/pytests/test_onetooneconnect.py | 1 + testsuite/pytests/test_parameter_operators.py | 3 ++- testsuite/pytests/test_parrot_neuron.py | 5 ++-- testsuite/pytests/test_parrot_neuron_ps.py | 5 ++-- .../test_poisson_generator_campbell_alpha.py | 2 +- .../pytests/test_poisson_generator_ps.py | 2 +- .../test_poisson_generator_rate_change.py | 5 ++-- .../pytests/test_poisson_ps_intervals.py | 3 +-- .../pytests/test_poisson_ps_min_interval.py | 3 +-- testsuite/pytests/test_pp_psc_delta.py | 1 + testsuite/pytests/test_pp_psc_delta_stdp.py | 1 + testsuite/pytests/test_quantal_stp_synapse.py | 3 ++- testsuite/pytests/test_random123.py | 2 +- testsuite/pytests/test_random_parameter.py | 1 + testsuite/pytests/test_rate_copy_model.py | 3 ++- .../test_rate_instantaneous_and_delayed.py | 3 ++- testsuite/pytests/test_rate_neuron.py | 3 ++- .../pytests/test_rate_neuron_communication.py | 3 ++- .../pytests/test_recording_backend_ascii.py | 1 + .../pytests/test_recording_backend_memory.py | 1 + testsuite/pytests/test_recording_backends.py | 1 + testsuite/pytests/test_refractory.py | 3 +-- .../pytests/test_regression_issue-1034.py | 3 ++- .../pytests/test_regression_issue-1409.py | 3 ++- .../pytests/test_regression_issue-2069.py | 3 ++- .../pytests/test_regression_issue-2125.py | 3 ++- .../pytests/test_regression_issue-2480.py | 3 ++- testsuite/pytests/test_siegert_neuron.py | 3 ++- testsuite/pytests/test_sonata.py | 3 +-- .../pytests/test_sp/test_conn_builder.py | 3 ++- testsuite/pytests/test_sp/test_disconnect.py | 3 ++- .../test_sp/test_disconnect_multiple.py | 3 ++- .../test_sp/test_enable_multithread.py | 2 +- .../pytests/test_sp/test_growth_curves.py | 7 +++--- testsuite/pytests/test_sp/test_sp_manager.py | 3 ++- .../pytests/test_sp/test_synaptic_elements.py | 3 ++- .../test_sp/test_update_synaptic_elements.py | 3 ++- .../test_SynapseCollection_distance.py | 5 ++-- testsuite/pytests/test_spatial/test_basics.py | 1 + .../test_spatial/test_connect_layers.py | 2 +- .../test_spatial/test_connect_sliced.py | 1 + .../test_connection_with_elliptical_mask.py | 1 + .../test_spatial/test_create_spatial.py | 1 + .../pytests/test_spatial/test_dumping.py | 3 ++- .../test_spatial/test_layerNodeCollection.py | 1 + .../test_layer_GetStatus_SetStatus.py | 1 + .../pytests/test_spatial/test_plotting.py | 2 +- .../test_spatial/test_rotated_rect_mask.py | 1 + ..._selection_function_and_elliptical_mask.py | 1 + .../test_spatial_distributions.py | 9 ++++--- .../pytests/test_spike_train_injector.py | 3 ++- testsuite/pytests/test_split_simulation.py | 1 + testsuite/pytests/test_stack.py | 4 ++-- testsuite/pytests/test_status.py | 1 + testsuite/pytests/test_stdp_nn_synapses.py | 4 ++-- testsuite/pytests/test_stdp_synapse.py | 3 ++- .../pytests/test_stdp_triplet_synapse.py | 3 ++- testsuite/pytests/test_step_rate_generator.py | 3 ++- testsuite/pytests/test_synapsecollection.py | 1 + testsuite/pytests/test_threads.py | 1 + testsuite/pytests/test_tsodyks2_synapse.py | 5 ++-- testsuite/pytests/test_urbanczik_synapse.py | 1 + testsuite/pytests/test_visualization.py | 3 ++- .../pytests/test_vogels_sprekeler_synapse.py | 3 ++- testsuite/pytests/test_weight_recorder.py | 1 + testsuite/pytests/test_weights_as_lists.py | 1 + testsuite/pytests/utilities/testsimulation.py | 3 +-- testsuite/pytests/utilities/testutil.py | 3 ++- testsuite/regressiontests/issue-1703.py | 4 ++-- testsuite/regressiontests/issue-779-1016.py | 4 ++-- testsuite/summarize_tests.py | 2 +- 264 files changed, 473 insertions(+), 405 deletions(-) create mode 100644 pynest/examples/dev.py diff --git a/.github/workflows/nestbuildmatrix.yml b/.github/workflows/nestbuildmatrix.yml index 571ebdae39..56a79017a2 100644 --- a/.github/workflows/nestbuildmatrix.yml +++ b/.github/workflows/nestbuildmatrix.yml @@ -302,7 +302,7 @@ jobs: - name: "Run isort..." uses: isort/isort-action@f14e57e1d457956c45a19c05a89cccdf087846e5 # 1.1.0 with: - configuration: --profile black --check-only --diff + configuration: --profile=black --thirdparty="nest" --check-only --diff black: runs-on: "ubuntu-20.04" diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 9c3003ad81..2f00e71081 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -3,7 +3,7 @@ repos: rev: 5.12.0 hooks: - id: isort - args: ["--profile", "black", "--check-only", "--diff"] + args: ["--profile", "black", "--thirdparty", "nest", "--check-only", "--diff"] - repo: https://github.com/psf/black rev: 23.7.0 hooks: diff --git a/bin/nest-server-mpi b/bin/nest-server-mpi index 2eb46c406d..900d15e20b 100755 --- a/bin/nest-server-mpi +++ b/bin/nest-server-mpi @@ -16,17 +16,16 @@ Options: from docopt import docopt from mpi4py import MPI -if __name__ == '__main__': +if __name__ == "__main__": opt = docopt(__doc__) -import time +import os import sys +import time import nest import nest.server -import os - HOST = os.getenv("NEST_SERVER_HOST", "127.0.0.1") PORT = os.getenv("NEST_SERVER_PORT", "52425") @@ -35,34 +34,33 @@ rank = comm.Get_rank() def log(call_name, msg): - msg = f'==> WORKER {rank}/{time.time():.7f} ({call_name}): {msg}' + msg = f"==> WORKER {rank}/{time.time():.7f} ({call_name}): {msg}" print(msg, flush=True) if rank == 0: print("==> Starting NEST Server Master on rank 0", flush=True) nest.server.set_mpi_comm(comm) - nest.server.run_mpi_app(host=opt.get('--host', HOST), port=opt.get('--port', PORT)) + nest.server.run_mpi_app(host=opt.get("--host", HOST), port=opt.get("--port", PORT)) else: print(f"==> Starting NEST Server Worker on rank {rank}", flush=True) nest.server.set_mpi_comm(comm) while True: - - log('spinwait', 'waiting for call bcast') + log("spinwait", "waiting for call bcast") call_name = comm.bcast(None, root=0) - log(call_name, 'received call bcast, waiting for data bcast') + log(call_name, "received call bcast, waiting for data bcast") data = comm.bcast(None, root=0) - log(call_name, f'received data bcast, data={data}') + log(call_name, f"received data bcast, data={data}") args, kwargs = data - if call_name == 'exec': + if call_name == "exec": response = nest.server.do_exec(args, kwargs) else: call, args, kwargs = nest.server.nestify(call_name, args, kwargs) - log(call_name, f'local call, args={args}, kwargs={kwargs}') + log(call_name, f"local call, args={args}, kwargs={kwargs}") # The following exception handler is useful if an error # occurs simulataneously on all processes. If only a @@ -74,5 +72,5 @@ else: except Exception: continue - log(call_name, f'sending reponse gather, data={response}') + log(call_name, f"sending reponse gather, data={response}") comm.gather(nest.serializable(response), root=0) diff --git a/build_support/check_copyright_headers.py b/build_support/check_copyright_headers.py index 0d23d5e4c9..b54eaec464 100644 --- a/build_support/check_copyright_headers.py +++ b/build_support/check_copyright_headers.py @@ -40,8 +40,8 @@ import os -import sys import re +import sys def eprint(*args, **kwargs): diff --git a/build_support/check_unused_names.py b/build_support/check_unused_names.py index 169156bc65..2dc2675498 100644 --- a/build_support/check_unused_names.py +++ b/build_support/check_unused_names.py @@ -40,8 +40,8 @@ """ import os -import sys import re +import sys from subprocess import check_output diff --git a/build_support/generate_modelsmodule.py b/build_support/generate_modelsmodule.py index 09d1c8581a..7540499a29 100644 --- a/build_support/generate_modelsmodule.py +++ b/build_support/generate_modelsmodule.py @@ -26,10 +26,9 @@ compiled by CMake. """ +import argparse import os import sys -import argparse - from pathlib import Path from textwrap import dedent diff --git a/doc/htmldoc/_ext/HoverXTooltip.py b/doc/htmldoc/_ext/HoverXTooltip.py index 2464c6df77..474baf05a9 100644 --- a/doc/htmldoc/_ext/HoverXTooltip.py +++ b/doc/htmldoc/_ext/HoverXTooltip.py @@ -19,9 +19,10 @@ # You should have received a copy of the GNU General Public License # along with NEST. If not, see . -import re import os +import re import sys + from docutils import nodes from docutils.parsers.rst import Directive, directives diff --git a/doc/htmldoc/_ext/VersionSyncRole.py b/doc/htmldoc/_ext/VersionSyncRole.py index c30fdb9c06..0f52dc51ce 100644 --- a/doc/htmldoc/_ext/VersionSyncRole.py +++ b/doc/htmldoc/_ext/VersionSyncRole.py @@ -21,6 +21,7 @@ import json from pathlib import Path + from docutils import nodes diff --git a/doc/htmldoc/_ext/extractor_userdocs.py b/doc/htmldoc/_ext/extractor_userdocs.py index 147888a7f2..77ebf89a40 100644 --- a/doc/htmldoc/_ext/extractor_userdocs.py +++ b/doc/htmldoc/_ext/extractor_userdocs.py @@ -19,17 +19,17 @@ # You should have received a copy of the GNU General Public License # along with NEST. If not, see . -import re -from tqdm import tqdm -from pprint import pformat -from math import comb - -import os import glob import json -from itertools import chain, combinations import logging +import os +import re from collections import Counter +from itertools import chain, combinations +from math import comb +from pprint import pformat + +from tqdm import tqdm logging.basicConfig(level=logging.WARNING) log = logging.getLogger() diff --git a/doc/htmldoc/clean_source_dirs.py b/doc/htmldoc/clean_source_dirs.py index 1e4885385e..7a499e3d7d 100644 --- a/doc/htmldoc/clean_source_dirs.py +++ b/doc/htmldoc/clean_source_dirs.py @@ -19,8 +19,8 @@ # You should have received a copy of the GNU General Public License # along with NEST. If not, see . import os -import shutil import pathlib +import shutil from glob import glob for dir_ in ("auto_examples", "models"): diff --git a/doc/htmldoc/conf.py b/doc/htmldoc/conf.py index ebf1135b17..fca936617c 100644 --- a/doc/htmldoc/conf.py +++ b/doc/htmldoc/conf.py @@ -20,15 +20,13 @@ # along with NEST. If not, see . -import sys -import os import json +import os import subprocess - -from urllib.request import urlretrieve - +import sys from pathlib import Path from shutil import copyfile +from urllib.request import urlretrieve # Add the extension modules to the path extension_module_dir = os.path.abspath("./_ext") diff --git a/doc/htmldoc/networks/scripts/connections.py b/doc/htmldoc/networks/scripts/connections.py index 5663636a7b..5015ce976f 100644 --- a/doc/htmldoc/networks/scripts/connections.py +++ b/doc/htmldoc/networks/scripts/connections.py @@ -21,8 +21,8 @@ # create connectivity figures for spatial manual -import nest import matplotlib.pyplot as plt +import nest import numpy as np # seed NumPy RNG to ensure identical results for runs with random placement diff --git a/doc/htmldoc/resolve_includes.py b/doc/htmldoc/resolve_includes.py index 1133262e6a..20badc28b3 100644 --- a/doc/htmldoc/resolve_includes.py +++ b/doc/htmldoc/resolve_includes.py @@ -32,10 +32,10 @@ """ +import glob import os import re import sys -import glob from fileinput import FileInput pattern = re.compile("^.. include:: (.*)") diff --git a/doc/slihelp_generator/generate_help.py b/doc/slihelp_generator/generate_help.py index a733ba5eef..bb87425721 100755 --- a/doc/slihelp_generator/generate_help.py +++ b/doc/slihelp_generator/generate_help.py @@ -28,17 +28,21 @@ The helpindex is built during installation in a separate step. """ -import os import html import io +import os import re import sys import textwrap +from helpers_sli import ( + check_ifdef, + create_helpdirs, + cut_it, + delete_helpdir, + help_generation_required, +) from writers import coll_data -from helpers_sli import check_ifdef, create_helpdirs, cut_it -from helpers_sli import delete_helpdir -from helpers_sli import help_generation_required if len(sys.argv) != 3: print("Usage: python3 generate_help.py ") diff --git a/doc/slihelp_generator/generate_helpindex.py b/doc/slihelp_generator/generate_helpindex.py index 430061db48..2901540c9d 100755 --- a/doc/slihelp_generator/generate_helpindex.py +++ b/doc/slihelp_generator/generate_helpindex.py @@ -30,6 +30,7 @@ import os import sys + from writers import write_helpindex if len(sys.argv) != 2: diff --git a/doc/slihelp_generator/helpers_sli.py b/doc/slihelp_generator/helpers_sli.py index e9052af1d8..91f859d007 100644 --- a/doc/slihelp_generator/helpers_sli.py +++ b/doc/slihelp_generator/helpers_sli.py @@ -19,10 +19,10 @@ # You should have received a copy of the GNU General Public License # along with NEST. If not, see . -import re +import errno import os +import re import shutil -import errno def cut_it(separator, text): diff --git a/doc/slihelp_generator/writers.py b/doc/slihelp_generator/writers.py index 04eba60b45..735c892b0d 100644 --- a/doc/slihelp_generator/writers.py +++ b/doc/slihelp_generator/writers.py @@ -31,9 +31,10 @@ import os import re import textwrap -from helpers_sli import cut_it from string import Template +from helpers_sli import cut_it + def write_help_html(doc_dic, helpdir, fname, sli_command_list, keywords): """ diff --git a/examples/nest/Potjans_2014/spike_analysis.py b/examples/nest/Potjans_2014/spike_analysis.py index cdecf4b086..47061630a4 100644 --- a/examples/nest/Potjans_2014/spike_analysis.py +++ b/examples/nest/Potjans_2014/spike_analysis.py @@ -21,12 +21,13 @@ # Merges spike files, produces raster plots, calculates and plots firing rates -import numpy as np import glob -import matplotlib.pyplot as plt import os import re +import matplotlib.pyplot as plt +import numpy as np + datapath = "." # get simulation time and numbers of neurons recorded from sim_params.sli diff --git a/pynest/examples/BrodyHopfield.py b/pynest/examples/BrodyHopfield.py index c48de4c7cc..66c1357a91 100755 --- a/pynest/examples/BrodyHopfield.py +++ b/pynest/examples/BrodyHopfield.py @@ -45,9 +45,9 @@ ################################################################################# # First, we import all necessary modules for simulation, analysis, and plotting. +import matplotlib.pyplot as plt import nest import nest.raster_plot -import matplotlib.pyplot as plt ############################################################################### # Second, the simulation parameters are assigned to variables. diff --git a/pynest/examples/CampbellSiegert.py b/pynest/examples/CampbellSiegert.py index 1eed125df9..fd34edcf6d 100755 --- a/pynest/examples/CampbellSiegert.py +++ b/pynest/examples/CampbellSiegert.py @@ -51,12 +51,10 @@ # First, we import all necessary modules for simulation and analysis. Scipy # should be imported before nest. -from scipy.special import erf -from scipy.optimize import fmin - -import numpy as np - import nest +import numpy as np +from scipy.optimize import fmin +from scipy.special import erf ############################################################################### # We first set the parameters of neurons, noise and the simulation. First diff --git a/pynest/examples/Potjans_2014/helpers.py b/pynest/examples/Potjans_2014/helpers.py index 4e835a37c2..92a53b624b 100644 --- a/pynest/examples/Potjans_2014/helpers.py +++ b/pynest/examples/Potjans_2014/helpers.py @@ -27,10 +27,11 @@ """ -from matplotlib.patches import Polygon -import matplotlib.pyplot as plt import os + +import matplotlib.pyplot as plt import numpy as np +from matplotlib.patches import Polygon if "DISPLAY" not in os.environ: import matplotlib diff --git a/pynest/examples/Potjans_2014/network.py b/pynest/examples/Potjans_2014/network.py index 5c6c9a47ff..a2c59b9778 100644 --- a/pynest/examples/Potjans_2014/network.py +++ b/pynest/examples/Potjans_2014/network.py @@ -28,11 +28,12 @@ """ import os -import numpy as np -import nest -import helpers import warnings +import helpers +import nest +import numpy as np + class Network: """Provides functions to setup NEST, to create and connect all nodes of diff --git a/pynest/examples/Potjans_2014/run_microcircuit.py b/pynest/examples/Potjans_2014/run_microcircuit.py index 1c43af95c6..a6c75cad3a 100644 --- a/pynest/examples/Potjans_2014/run_microcircuit.py +++ b/pynest/examples/Potjans_2014/run_microcircuit.py @@ -30,13 +30,14 @@ ############################################################################### # Import the necessary modules and start the time measurements. -from stimulus_params import stim_dict -from network_params import net_dict -from sim_params import sim_dict -import network +import time + import nest +import network import numpy as np -import time +from network_params import net_dict +from sim_params import sim_dict +from stimulus_params import stim_dict time_start = time.time() diff --git a/pynest/examples/aeif_cond_beta_multisynapse.py b/pynest/examples/aeif_cond_beta_multisynapse.py index 0a36e7f266..6eed64f91d 100644 --- a/pynest/examples/aeif_cond_beta_multisynapse.py +++ b/pynest/examples/aeif_cond_beta_multisynapse.py @@ -25,9 +25,9 @@ """ +import matplotlib.pyplot as plt import nest import numpy as np -import matplotlib.pyplot as plt neuron = nest.Create("aeif_cond_beta_multisynapse") nest.SetStatus(neuron, {"V_peak": 0.0, "a": 4.0, "b": 80.5}) diff --git a/pynest/examples/balancedneuron.py b/pynest/examples/balancedneuron.py index 3baaabb0a9..d815a07c06 100644 --- a/pynest/examples/balancedneuron.py +++ b/pynest/examples/balancedneuron.py @@ -46,11 +46,10 @@ # First, we import all necessary modules for simulation, analysis and # plotting. Scipy should be imported before nest. -from scipy.optimize import bisect - +import matplotlib.pyplot as plt import nest import nest.voltage_trace -import matplotlib.pyplot as plt +from scipy.optimize import bisect ############################################################################### # Additionally, we set the verbosity using ``set_verbosity`` to diff --git a/pynest/examples/brette_gerstner_fig_2c.py b/pynest/examples/brette_gerstner_fig_2c.py index 89f0c88dec..085ae7f77c 100755 --- a/pynest/examples/brette_gerstner_fig_2c.py +++ b/pynest/examples/brette_gerstner_fig_2c.py @@ -38,9 +38,9 @@ """ +import matplotlib.pyplot as plt import nest import nest.voltage_trace -import matplotlib.pyplot as plt nest.ResetKernel() diff --git a/pynest/examples/brette_gerstner_fig_3d.py b/pynest/examples/brette_gerstner_fig_3d.py index 9c991c43b8..b2002e04d7 100755 --- a/pynest/examples/brette_gerstner_fig_3d.py +++ b/pynest/examples/brette_gerstner_fig_3d.py @@ -38,9 +38,9 @@ """ +import matplotlib.pyplot as plt import nest import nest.voltage_trace -import matplotlib.pyplot as plt nest.ResetKernel() diff --git a/pynest/examples/brunel_alpha_evolution_strategies.py b/pynest/examples/brunel_alpha_evolution_strategies.py index ab980f9007..53a9f17699 100644 --- a/pynest/examples/brunel_alpha_evolution_strategies.py +++ b/pynest/examples/brunel_alpha_evolution_strategies.py @@ -77,10 +77,10 @@ """ import matplotlib.pyplot as plt -from matplotlib.patches import Ellipse +import nest import numpy as np import scipy.special as sp -import nest +from matplotlib.patches import Ellipse ############################################################################### # Analysis diff --git a/pynest/examples/brunel_alpha_nest.py b/pynest/examples/brunel_alpha_nest.py index 05f9cdd53a..cae0a6ca1e 100755 --- a/pynest/examples/brunel_alpha_nest.py +++ b/pynest/examples/brunel_alpha_nest.py @@ -49,13 +49,12 @@ # should be imported before nest. import time -import numpy as np -import scipy.special as sp +import matplotlib.pyplot as plt import nest import nest.raster_plot -import matplotlib.pyplot as plt - +import numpy as np +import scipy.special as sp ############################################################################### # Definition of functions used in this example. First, define the `Lambert W` diff --git a/pynest/examples/brunel_delta_nest.py b/pynest/examples/brunel_delta_nest.py index 7c8c411211..6d8d27bd69 100755 --- a/pynest/examples/brunel_delta_nest.py +++ b/pynest/examples/brunel_delta_nest.py @@ -45,9 +45,10 @@ # Import all necessary modules for simulation, analysis and plotting. import time + +import matplotlib.pyplot as plt import nest import nest.raster_plot -import matplotlib.pyplot as plt nest.ResetKernel() diff --git a/pynest/examples/brunel_exp_multisynapse_nest.py b/pynest/examples/brunel_exp_multisynapse_nest.py index 87b443bb73..bcd5eec8ca 100644 --- a/pynest/examples/brunel_exp_multisynapse_nest.py +++ b/pynest/examples/brunel_exp_multisynapse_nest.py @@ -57,9 +57,10 @@ # Import all necessary modules for simulation, analysis and plotting. import time + +import matplotlib.pyplot as plt import nest import nest.raster_plot -import matplotlib.pyplot as plt nest.ResetKernel() diff --git a/pynest/examples/clopath_synapse_small_network.py b/pynest/examples/clopath_synapse_small_network.py index c1be8925ea..eda5541efd 100644 --- a/pynest/examples/clopath_synapse_small_network.py +++ b/pynest/examples/clopath_synapse_small_network.py @@ -41,10 +41,11 @@ Nature Neuroscience 13:3, 344--352 """ +import random + +import matplotlib.pyplot as plt import nest import numpy as np -import matplotlib.pyplot as plt -import random ############################################################################## # Set the parameters diff --git a/pynest/examples/clopath_synapse_spike_pairing.py b/pynest/examples/clopath_synapse_spike_pairing.py index 7752b0b08f..413744f851 100644 --- a/pynest/examples/clopath_synapse_spike_pairing.py +++ b/pynest/examples/clopath_synapse_spike_pairing.py @@ -38,9 +38,9 @@ Nature Neuroscience 13:3, 344--352 """ -import numpy as np import matplotlib.pyplot as plt import nest +import numpy as np ############################################################################## # First we specify the neuron parameters. To enable voltage dependent diff --git a/pynest/examples/compartmental_model/receptors_and_current.py b/pynest/examples/compartmental_model/receptors_and_current.py index 76b3923354..ab629b10fb 100644 --- a/pynest/examples/compartmental_model/receptors_and_current.py +++ b/pynest/examples/compartmental_model/receptors_and_current.py @@ -29,8 +29,8 @@ :Authors: WAM Wybo """ -import nest import matplotlib.pyplot as plt +import nest nest.ResetKernel() diff --git a/pynest/examples/compartmental_model/two_comps.py b/pynest/examples/compartmental_model/two_comps.py index bb5b0a182b..f2e8253583 100644 --- a/pynest/examples/compartmental_model/two_comps.py +++ b/pynest/examples/compartmental_model/two_comps.py @@ -31,8 +31,8 @@ :Authors: WAM Wybo """ -import nest import matplotlib.pyplot as plt +import nest nest.ResetKernel() diff --git a/pynest/examples/csa_example.py b/pynest/examples/csa_example.py index a3f81cd57e..3a87ff82c6 100644 --- a/pynest/examples/csa_example.py +++ b/pynest/examples/csa_example.py @@ -47,10 +47,9 @@ ############################################################################### # First, we import all necessary modules for simulation and plotting. -import nest -from nest import voltage_trace -from nest import visualization import matplotlib.pyplot as plt +import nest +from nest import visualization, voltage_trace ############################################################################### # Next, we check for the availability of the CSA Python module. If it does diff --git a/pynest/examples/csa_spatial_example.py b/pynest/examples/csa_spatial_example.py index e871716567..64a0e1945c 100644 --- a/pynest/examples/csa_spatial_example.py +++ b/pynest/examples/csa_spatial_example.py @@ -48,8 +48,8 @@ ############################################################################### # First, we import all necessary modules. -import nest import matplotlib.pyplot as plt +import nest ############################################################################### # Next, we check for the availability of the CSA Python module. If it does diff --git a/pynest/examples/dev.py b/pynest/examples/dev.py new file mode 100644 index 0000000000..258b92dc78 --- /dev/null +++ b/pynest/examples/dev.py @@ -0,0 +1,5 @@ +import matplotlib.pyplot as plt +import nest +import numpy as np +import scipy.special as sp +from matplotlib.patches import Ellipse diff --git a/pynest/examples/evaluate_quantal_stp_synapse.py b/pynest/examples/evaluate_quantal_stp_synapse.py index d389bd5f04..a3952f80b0 100644 --- a/pynest/examples/evaluate_quantal_stp_synapse.py +++ b/pynest/examples/evaluate_quantal_stp_synapse.py @@ -70,8 +70,8 @@ """ -import nest import matplotlib.pyplot as plt +import nest ################################################################################ # On average, the ``quantal_stp_synapse`` converges to the ``tsodyks2_synapse``, diff --git a/pynest/examples/evaluate_tsodyks2_synapse.py b/pynest/examples/evaluate_tsodyks2_synapse.py index 02830107a2..d458fc1772 100644 --- a/pynest/examples/evaluate_tsodyks2_synapse.py +++ b/pynest/examples/evaluate_tsodyks2_synapse.py @@ -70,9 +70,9 @@ http://dx.doi.org/10.1016/S0893-6080(01)00144-7 """ +import matplotlib.pyplot as plt import nest import nest.voltage_trace -import matplotlib.pyplot as plt nest.ResetKernel() diff --git a/pynest/examples/gap_junctions_inhibitory_network.py b/pynest/examples/gap_junctions_inhibitory_network.py index 346ea3e609..18a0d0d9a0 100644 --- a/pynest/examples/gap_junctions_inhibitory_network.py +++ b/pynest/examples/gap_junctions_inhibitory_network.py @@ -45,8 +45,8 @@ Neuroinform. http://dx.doi.org/10.3389/neuro.11.012.2008 """ -import nest import matplotlib.pyplot as plt +import nest import numpy n_neuron = 500 diff --git a/pynest/examples/gap_junctions_two_neurons.py b/pynest/examples/gap_junctions_two_neurons.py index 68d7ca902c..8a4fab0621 100644 --- a/pynest/examples/gap_junctions_two_neurons.py +++ b/pynest/examples/gap_junctions_two_neurons.py @@ -30,8 +30,8 @@ """ -import nest import matplotlib.pyplot as plt +import nest import numpy nest.ResetKernel() diff --git a/pynest/examples/gif_cond_exp_multisynapse.py b/pynest/examples/gif_cond_exp_multisynapse.py index ebbf83bd6b..0cadf7408d 100644 --- a/pynest/examples/gif_cond_exp_multisynapse.py +++ b/pynest/examples/gif_cond_exp_multisynapse.py @@ -25,9 +25,8 @@ """ -import numpy as np - import nest +import numpy as np neuron = nest.Create("gif_cond_exp_multisynapse", params={"E_rev": [0.0, -85.0], "tau_syn": [4.0, 8.0]}) diff --git a/pynest/examples/gif_pop_psc_exp.py b/pynest/examples/gif_pop_psc_exp.py index f2fdcbf71f..0a77646c1b 100644 --- a/pynest/examples/gif_pop_psc_exp.py +++ b/pynest/examples/gif_pop_psc_exp.py @@ -45,11 +45,11 @@ """ -# Loading the necessary modules: -import numpy as np import matplotlib.pyplot as plt import nest +# Loading the necessary modules: +import numpy as np ############################################################################### # We first set the parameters of the microscopic model: diff --git a/pynest/examples/gif_population.py b/pynest/examples/gif_population.py index 3da1833e54..9f73dbccdb 100644 --- a/pynest/examples/gif_population.py +++ b/pynest/examples/gif_population.py @@ -50,9 +50,9 @@ ############################################################################### # Import all necessary modules for simulation and plotting. +import matplotlib.pyplot as plt import nest import nest.raster_plot -import matplotlib.pyplot as plt nest.ResetKernel() diff --git a/pynest/examples/glif_cond_neuron.py b/pynest/examples/glif_cond_neuron.py index 682dd1a6ff..008a61f70e 100644 --- a/pynest/examples/glif_cond_neuron.py +++ b/pynest/examples/glif_cond_neuron.py @@ -38,9 +38,9 @@ # First, we import all necessary modules to simulate, analyze and plot this # example. -import nest -import matplotlib.pyplot as plt import matplotlib.gridspec as gridspec +import matplotlib.pyplot as plt +import nest ############################################################################## # We initialize NEST and set the simulation resolution. diff --git a/pynest/examples/glif_psc_neuron.py b/pynest/examples/glif_psc_neuron.py index b1278c736d..1893a167e7 100644 --- a/pynest/examples/glif_psc_neuron.py +++ b/pynest/examples/glif_psc_neuron.py @@ -37,9 +37,9 @@ # First, we import all necessary modules to simulate, analyze and plot this # example. -import nest -import matplotlib.pyplot as plt import matplotlib.gridspec as gridspec +import matplotlib.pyplot as plt +import nest ############################################################################## # We initialize NEST and set the simulation resolution. diff --git a/pynest/examples/hh_phaseplane.py b/pynest/examples/hh_phaseplane.py index 1a109a522a..cd0d2051d9 100644 --- a/pynest/examples/hh_phaseplane.py +++ b/pynest/examples/hh_phaseplane.py @@ -42,7 +42,6 @@ import numpy as np from matplotlib import pyplot as plt - amplitude = 100.0 # Set externally applied current amplitude in pA dt = 0.1 # simulation step length [ms] diff --git a/pynest/examples/hh_psc_alpha.py b/pynest/examples/hh_psc_alpha.py index 7537f127cf..e1f272a8d5 100644 --- a/pynest/examples/hh_psc_alpha.py +++ b/pynest/examples/hh_psc_alpha.py @@ -31,9 +31,9 @@ does not yet check correctness of synaptic response. """ +import matplotlib.pyplot as plt import nest import numpy as np -import matplotlib.pyplot as plt nest.set_verbosity("M_WARNING") nest.ResetKernel() diff --git a/pynest/examples/hpc_benchmark.py b/pynest/examples/hpc_benchmark.py index c8e3412df5..87e1691da6 100644 --- a/pynest/examples/hpc_benchmark.py +++ b/pynest/examples/hpc_benchmark.py @@ -90,14 +90,14 @@ """ -import numpy as np import os import sys import time -import scipy.special as sp import nest import nest.raster_plot +import numpy as np +import scipy.special as sp M_INFO = 10 M_ERROR = 30 diff --git a/pynest/examples/if_curve.py b/pynest/examples/if_curve.py index d9ffba43c0..fb0b9d1d27 100644 --- a/pynest/examples/if_curve.py +++ b/pynest/examples/if_curve.py @@ -38,10 +38,11 @@ """ -import numpy -import nest import shelve +import nest +import numpy + ############################################################################### # Here we define which model and the neuron parameters to use for measuring # the transfer function. diff --git a/pynest/examples/intrinsic_currents_spiking.py b/pynest/examples/intrinsic_currents_spiking.py index 372a1cda1c..22a69f79ed 100644 --- a/pynest/examples/intrinsic_currents_spiking.py +++ b/pynest/examples/intrinsic_currents_spiking.py @@ -51,8 +51,8 @@ ############################################################################### # We imported all necessary modules for simulation, analysis and plotting. -import nest import matplotlib.pyplot as plt +import nest ############################################################################### # Additionally, we set the verbosity using ``set_verbosity`` to suppress info diff --git a/pynest/examples/intrinsic_currents_subthreshold.py b/pynest/examples/intrinsic_currents_subthreshold.py index c323e50a6d..27c36e481d 100644 --- a/pynest/examples/intrinsic_currents_subthreshold.py +++ b/pynest/examples/intrinsic_currents_subthreshold.py @@ -50,8 +50,8 @@ ############################################################################### # We imported all necessary modules for simulation, analysis and plotting. -import nest import matplotlib.pyplot as plt +import nest ############################################################################### # Additionally, we set the verbosity using ``set_verbosity`` to suppress info diff --git a/pynest/examples/lin_rate_ipn_network.py b/pynest/examples/lin_rate_ipn_network.py index 13d110c5d6..a8b8140b54 100644 --- a/pynest/examples/lin_rate_ipn_network.py +++ b/pynest/examples/lin_rate_ipn_network.py @@ -31,9 +31,9 @@ """ +import matplotlib.pyplot as plt import nest import numpy -import matplotlib.pyplot as plt ############################################################################### # Assigning the simulation parameters to variables. diff --git a/pynest/examples/mc_neuron.py b/pynest/examples/mc_neuron.py index 2e07fcbac4..20d92f2770 100644 --- a/pynest/examples/mc_neuron.py +++ b/pynest/examples/mc_neuron.py @@ -41,8 +41,8 @@ # example. -import nest import matplotlib.pyplot as plt +import nest nest.ResetKernel() diff --git a/pynest/examples/multimeter_file.py b/pynest/examples/multimeter_file.py index dde1d7537f..4b288c87ad 100644 --- a/pynest/examples/multimeter_file.py +++ b/pynest/examples/multimeter_file.py @@ -32,9 +32,9 @@ # First, we import the necessary modules to simulate and plot this example. # The simulation kernel is put back to its initial state using ``ResetKernel``. +import matplotlib.pyplot as plt import nest import numpy -import matplotlib.pyplot as plt nest.ResetKernel() diff --git a/pynest/examples/music_cont_out_proxy_example/receiver_script.py b/pynest/examples/music_cont_out_proxy_example/receiver_script.py index cbea426a97..10b399732a 100755 --- a/pynest/examples/music_cont_out_proxy_example/receiver_script.py +++ b/pynest/examples/music_cont_out_proxy_example/receiver_script.py @@ -26,9 +26,10 @@ """ import sys +from itertools import dropwhile, takewhile + import music import numpy -from itertools import takewhile, dropwhile setup = music.Setup() stoptime = setup.config("stoptime") diff --git a/pynest/examples/one_neuron.py b/pynest/examples/one_neuron.py index 3fa7143eca..9b28363e1e 100755 --- a/pynest/examples/one_neuron.py +++ b/pynest/examples/one_neuron.py @@ -43,9 +43,9 @@ # including connections between nodes, status of neurons, devices and # intrinsic time clocks, is kept and influences the next simulations. +import matplotlib.pyplot as plt import nest import nest.voltage_trace -import matplotlib.pyplot as plt nest.set_verbosity("M_WARNING") nest.ResetKernel() diff --git a/pynest/examples/one_neuron_with_noise.py b/pynest/examples/one_neuron_with_noise.py index 39b31e1a20..df2d7f009d 100755 --- a/pynest/examples/one_neuron_with_noise.py +++ b/pynest/examples/one_neuron_with_noise.py @@ -37,9 +37,9 @@ # several times in a Python shell without interference from previous NEST # simulations. +import matplotlib.pyplot as plt import nest import nest.voltage_trace -import matplotlib.pyplot as plt nest.set_verbosity("M_WARNING") nest.ResetKernel() diff --git a/pynest/examples/plot_weight_matrices.py b/pynest/examples/plot_weight_matrices.py index ae7d200082..efa77ce0c6 100644 --- a/pynest/examples/plot_weight_matrices.py +++ b/pynest/examples/plot_weight_matrices.py @@ -35,10 +35,10 @@ # First, we import all necessary modules to extract, handle and plot # the connectivity matrices -import numpy as np +import matplotlib.gridspec as gridspec import matplotlib.pyplot as plt import nest -import matplotlib.gridspec as gridspec +import numpy as np from mpl_toolkits.axes_grid1 import make_axes_locatable ############################################################################### diff --git a/pynest/examples/pong/generate_gif.py b/pynest/examples/pong/generate_gif.py index fb16f385a1..a90fb3f728 100644 --- a/pynest/examples/pong/generate_gif.py +++ b/pynest/examples/pong/generate_gif.py @@ -28,17 +28,16 @@ :Authors: J Gille, T Wunderlich, Electronic Vision(s) """ -from copy import copy import gzip import os -import sys - -import numpy as np import pickle -import matplotlib.pyplot as plt -import imageio.v2 as imageio +import sys +from copy import copy from glob import glob +import imageio.v2 as imageio +import matplotlib.pyplot as plt +import numpy as np from pong import GameOfPong as Pong px = 1 / plt.rcParams["figure.dpi"] diff --git a/pynest/examples/pong/networks.py b/pynest/examples/pong/networks.py index 9ed7b577ec..4081888d6f 100644 --- a/pynest/examples/pong/networks.py +++ b/pynest/examples/pong/networks.py @@ -52,13 +52,12 @@ :Authors: J Gille, T Wunderlich, Electronic Vision(s) """ +import logging from abc import ABC, abstractmethod from copy import copy -import logging - -import numpy as np import nest +import numpy as np # Simulation time per iteration in milliseconds. POLL_TIME = 200 diff --git a/pynest/examples/pong/run_simulations.py b/pynest/examples/pong/run_simulations.py index 113c387beb..6079d4d8b7 100644 --- a/pynest/examples/pong/run_simulations.py +++ b/pynest/examples/pong/run_simulations.py @@ -59,14 +59,13 @@ import datetime import gzip import logging -import nest import os +import pickle import sys import time +import nest import numpy as np -import pickle - import pong from networks import POLL_TIME, PongNetDopa, PongNetRSTDP diff --git a/pynest/examples/precise_spiking.py b/pynest/examples/precise_spiking.py index 77730ed741..609198717b 100644 --- a/pynest/examples/precise_spiking.py +++ b/pynest/examples/precise_spiking.py @@ -58,9 +58,8 @@ # plotting. -import nest import matplotlib.pyplot as plt - +import nest ############################################################################### # Second, we assign the simulation parameters to variables. diff --git a/pynest/examples/pulsepacket.py b/pynest/examples/pulsepacket.py index f2413277eb..98e3696c8c 100755 --- a/pynest/examples/pulsepacket.py +++ b/pynest/examples/pulsepacket.py @@ -46,10 +46,10 @@ # First, we import all necessary modules for simulation, analysis and # plotting. -import scipy.special as sp +import matplotlib.pyplot as plt import nest import numpy -import matplotlib.pyplot as plt +import scipy.special as sp # Properties of pulse packet: diff --git a/pynest/examples/rate_neuron_dm.py b/pynest/examples/rate_neuron_dm.py index a31228132f..7fecf3b865 100644 --- a/pynest/examples/rate_neuron_dm.py +++ b/pynest/examples/rate_neuron_dm.py @@ -35,8 +35,8 @@ decision will be made. """ -import nest import matplotlib.pyplot as plt +import nest import numpy ########################################################################## diff --git a/pynest/examples/repeated_stimulation.py b/pynest/examples/repeated_stimulation.py index 7460fe12c1..cd2fe44513 100644 --- a/pynest/examples/repeated_stimulation.py +++ b/pynest/examples/repeated_stimulation.py @@ -44,9 +44,9 @@ # First, the modules needed for simulation and analysis are imported. +import matplotlib.pyplot as plt import nest import nest.raster_plot -import matplotlib.pyplot as plt ############################################################################### # Second, we set the parameters so the ``poisson_generator`` generates 1000 diff --git a/pynest/examples/sensitivity_to_perturbation.py b/pynest/examples/sensitivity_to_perturbation.py index f0b396247c..58b237f9c2 100644 --- a/pynest/examples/sensitivity_to_perturbation.py +++ b/pynest/examples/sensitivity_to_perturbation.py @@ -45,10 +45,9 @@ # Importing all necessary modules for simulation, analysis and plotting. -import numpy import matplotlib.pyplot as plt import nest - +import numpy ############################################################################### # Here we define all parameters necessary for building and simulating the diff --git a/pynest/examples/sinusoidal_gamma_generator.py b/pynest/examples/sinusoidal_gamma_generator.py index 59e568d21d..f6dced81c1 100644 --- a/pynest/examples/sinusoidal_gamma_generator.py +++ b/pynest/examples/sinusoidal_gamma_generator.py @@ -43,8 +43,8 @@ # plot this example. -import nest import matplotlib.pyplot as plt +import nest import numpy as np nest.ResetKernel() # in case we run the script multiple times from iPython diff --git a/pynest/examples/sinusoidal_poisson_generator.py b/pynest/examples/sinusoidal_poisson_generator.py index 5607f9dbca..f33cf5d7f9 100644 --- a/pynest/examples/sinusoidal_poisson_generator.py +++ b/pynest/examples/sinusoidal_poisson_generator.py @@ -40,8 +40,8 @@ # We import the modules required to simulate, analyze and plot this example. -import nest import matplotlib.pyplot as plt +import nest import numpy as np nest.ResetKernel() # in case we run the script multiple times from iPython diff --git a/pynest/examples/sonata_example/sonata_network.py b/pynest/examples/sonata_example/sonata_network.py index 9f0500817c..f01b7be2c7 100644 --- a/pynest/examples/sonata_example/sonata_network.py +++ b/pynest/examples/sonata_example/sonata_network.py @@ -45,10 +45,11 @@ ############################################################################### # Import all necessary packages for simulation, analysis and plotting. -import nest -import matplotlib.pyplot as plt from pathlib import Path +import matplotlib.pyplot as plt +import nest + nest.set_verbosity("M_ERROR") nest.ResetKernel() diff --git a/pynest/examples/spatial/conncomp.py b/pynest/examples/spatial/conncomp.py index 6924f28441..004c573508 100644 --- a/pynest/examples/spatial/conncomp.py +++ b/pynest/examples/spatial/conncomp.py @@ -31,8 +31,8 @@ Hans Ekkehard Plesser, UMB """ -import nest import matplotlib.pyplot as plt +import nest import numpy as np nest.ResetKernel() diff --git a/pynest/examples/spatial/conncon_sources.py b/pynest/examples/spatial/conncon_sources.py index 4201b065fb..8291e3e3e6 100644 --- a/pynest/examples/spatial/conncon_sources.py +++ b/pynest/examples/spatial/conncon_sources.py @@ -32,8 +32,8 @@ Hans Ekkehard Plesser, UMB """ -import nest import matplotlib.pyplot as plt +import nest import numpy as np nest.ResetKernel() diff --git a/pynest/examples/spatial/conncon_targets.py b/pynest/examples/spatial/conncon_targets.py index d96f13f7a5..9cdc47e6ff 100644 --- a/pynest/examples/spatial/conncon_targets.py +++ b/pynest/examples/spatial/conncon_targets.py @@ -31,8 +31,8 @@ Hans Ekkehard Plesser, UMB """ -import nest import matplotlib.pyplot as plt +import nest import numpy as np nest.ResetKernel() diff --git a/pynest/examples/spatial/connex.py b/pynest/examples/spatial/connex.py index dafdb380de..69c47a6449 100644 --- a/pynest/examples/spatial/connex.py +++ b/pynest/examples/spatial/connex.py @@ -31,8 +31,8 @@ Hans Ekkehard Plesser, UMB """ -import nest import matplotlib.pyplot as plt +import nest import numpy as np nest.ResetKernel() diff --git a/pynest/examples/spatial/connex_ew.py b/pynest/examples/spatial/connex_ew.py index c73d7cd42e..6fac9ce4f3 100644 --- a/pynest/examples/spatial/connex_ew.py +++ b/pynest/examples/spatial/connex_ew.py @@ -32,8 +32,8 @@ """ import matplotlib.pyplot as plt -import numpy as np import nest +import numpy as np nest.ResetKernel() diff --git a/pynest/examples/spatial/ctx_2n.py b/pynest/examples/spatial/ctx_2n.py index c767ada5ff..b46f48e1d5 100644 --- a/pynest/examples/spatial/ctx_2n.py +++ b/pynest/examples/spatial/ctx_2n.py @@ -29,8 +29,8 @@ Hans Ekkehard Plesser, UMB """ -import nest import matplotlib.pyplot as plt +import nest import numpy as np nest.ResetKernel() diff --git a/pynest/examples/spatial/gaussex.py b/pynest/examples/spatial/gaussex.py index 98d474fce7..1d72b04d62 100644 --- a/pynest/examples/spatial/gaussex.py +++ b/pynest/examples/spatial/gaussex.py @@ -29,8 +29,8 @@ """ import matplotlib.pyplot as plt -import numpy as np import nest +import numpy as np nest.ResetKernel() diff --git a/pynest/examples/spatial/grid_iaf.py b/pynest/examples/spatial/grid_iaf.py index 826235cf07..3a33338f6c 100644 --- a/pynest/examples/spatial/grid_iaf.py +++ b/pynest/examples/spatial/grid_iaf.py @@ -29,8 +29,8 @@ Hans Ekkehard Plesser, UMB """ -import nest import matplotlib.pyplot as plt +import nest nest.ResetKernel() diff --git a/pynest/examples/spatial/grid_iaf_irr.py b/pynest/examples/spatial/grid_iaf_irr.py index 9a9924060f..5281d37983 100644 --- a/pynest/examples/spatial/grid_iaf_irr.py +++ b/pynest/examples/spatial/grid_iaf_irr.py @@ -29,8 +29,8 @@ Hans Ekkehard Plesser, UMB """ -import nest import matplotlib.pyplot as plt +import nest nest.ResetKernel() diff --git a/pynest/examples/spatial/grid_iaf_oc.py b/pynest/examples/spatial/grid_iaf_oc.py index a4c025f222..2f7585c344 100644 --- a/pynest/examples/spatial/grid_iaf_oc.py +++ b/pynest/examples/spatial/grid_iaf_oc.py @@ -29,8 +29,8 @@ Hans Ekkehard Plesser, UMB """ -import nest import matplotlib.pyplot as plt +import nest import numpy as np for ctr in [(0.0, 0.0), (-2.0, 2.0), (0.5, 1.0)]: diff --git a/pynest/examples/spatial/test_3d.py b/pynest/examples/spatial/test_3d.py index d5fe3d9d0c..20e25f1b86 100644 --- a/pynest/examples/spatial/test_3d.py +++ b/pynest/examples/spatial/test_3d.py @@ -26,8 +26,8 @@ Hans Ekkehard Plesser, UMB """ -import nest import matplotlib.pyplot as plt +import nest nest.ResetKernel() diff --git a/pynest/examples/spatial/test_3d_exp.py b/pynest/examples/spatial/test_3d_exp.py index ac734556bc..587092a186 100644 --- a/pynest/examples/spatial/test_3d_exp.py +++ b/pynest/examples/spatial/test_3d_exp.py @@ -26,8 +26,8 @@ Hans Ekkehard Plesser, UMB """ -import nest import matplotlib.pyplot as plt +import nest nest.ResetKernel() diff --git a/pynest/examples/spatial/test_3d_gauss.py b/pynest/examples/spatial/test_3d_gauss.py index 5f957defbf..2944cdac1e 100644 --- a/pynest/examples/spatial/test_3d_gauss.py +++ b/pynest/examples/spatial/test_3d_gauss.py @@ -26,8 +26,8 @@ Hans Ekkehard Plesser, UMB """ -import nest import matplotlib.pyplot as plt +import nest nest.ResetKernel() diff --git a/pynest/examples/store_restore_network.py b/pynest/examples/store_restore_network.py index 1b6ddac39f..6d4f4f3ad0 100644 --- a/pynest/examples/store_restore_network.py +++ b/pynest/examples/store_restore_network.py @@ -47,17 +47,18 @@ ############################################################################### # Import necessary modules. -import nest import pickle - -############################################################################### -# These modules are only needed for illustrative plotting. +import textwrap import matplotlib.pyplot as plt -from matplotlib import gridspec +import nest import numpy as np import pandas as pd -import textwrap +from matplotlib import gridspec + +############################################################################### +# These modules are only needed for illustrative plotting. + ############################################################################### # Implement network as class. diff --git a/pynest/examples/structural_plasticity.py b/pynest/examples/structural_plasticity.py index cf79fce843..d7809474fe 100644 --- a/pynest/examples/structural_plasticity.py +++ b/pynest/examples/structural_plasticity.py @@ -45,11 +45,11 @@ #################################################################################### # First, we have import all necessary modules. -import nest -import numpy -import matplotlib.pyplot as plt import sys +import matplotlib.pyplot as plt +import nest +import numpy #################################################################################### # We define general simulation parameters diff --git a/pynest/examples/sudoku/helpers_sudoku.py b/pynest/examples/sudoku/helpers_sudoku.py index 4eb767d7ff..3054a2fa24 100644 --- a/pynest/examples/sudoku/helpers_sudoku.py +++ b/pynest/examples/sudoku/helpers_sudoku.py @@ -24,8 +24,8 @@ :Authors: J Gille, S Furber, A Rowley """ -import numpy as np import matplotlib.patches as patch +import numpy as np def get_puzzle(puzzle_index): diff --git a/pynest/examples/sudoku/plot_progress.py b/pynest/examples/sudoku/plot_progress.py index bbdfdbdce9..19100b2ae8 100644 --- a/pynest/examples/sudoku/plot_progress.py +++ b/pynest/examples/sudoku/plot_progress.py @@ -40,12 +40,13 @@ """ import os import pickle -import imageio -from glob import glob -import numpy as np import sys +from glob import glob + import helpers_sudoku +import imageio import matplotlib.pyplot as plt +import numpy as np def get_progress(puzzle, solution): diff --git a/pynest/examples/sudoku/sudoku_net.py b/pynest/examples/sudoku/sudoku_net.py index af133cc242..b709010fae 100644 --- a/pynest/examples/sudoku/sudoku_net.py +++ b/pynest/examples/sudoku/sudoku_net.py @@ -47,10 +47,10 @@ :Authors: J Gille, S Furber, A Rowley """ -import nest -import numpy as np import logging +import nest +import numpy as np inter_neuron_weight = -0.2 # inhibitory weight for synapses between neurons weight_stim = 1.3 # weight from stimulation sources to neurons diff --git a/pynest/examples/sudoku/sudoku_solver.py b/pynest/examples/sudoku/sudoku_solver.py index 9311552e1c..936959092a 100644 --- a/pynest/examples/sudoku/sudoku_solver.py +++ b/pynest/examples/sudoku/sudoku_solver.py @@ -56,13 +56,14 @@ :Authors: J Gille, S Furber, A Rowley """ -import nest -import sudoku_net -import numpy as np import logging import pickle -from helpers_sudoku import get_puzzle, validate_solution, plot_field + import matplotlib.pyplot as plt +import nest +import numpy as np +import sudoku_net +from helpers_sudoku import get_puzzle, plot_field, validate_solution nest.SetKernelStatus({"local_num_threads": 8}) nest.set_verbosity("M_WARNING") diff --git a/pynest/examples/synapsecollection.py b/pynest/examples/synapsecollection.py index fe5f810775..23cd171a33 100644 --- a/pynest/examples/synapsecollection.py +++ b/pynest/examples/synapsecollection.py @@ -29,8 +29,8 @@ source and targets. """ -import nest import matplotlib.pyplot as plt +import nest import numpy as np diff --git a/pynest/examples/testiaf.py b/pynest/examples/testiaf.py index e8c6b41140..1eba09337f 100755 --- a/pynest/examples/testiaf.py +++ b/pynest/examples/testiaf.py @@ -36,8 +36,8 @@ ############################################################################### # First, we import all necessary modules for simulation and plotting -import nest import matplotlib.pyplot as plt +import nest ############################################################################### # Second the function ``build_network`` is defined to build the network and diff --git a/pynest/examples/tsodyks_depressing.py b/pynest/examples/tsodyks_depressing.py index 978f4f7632..8ac0d1f49f 100644 --- a/pynest/examples/tsodyks_depressing.py +++ b/pynest/examples/tsodyks_depressing.py @@ -49,9 +49,9 @@ ############################################################################### # First, we import all necessary modules for simulation and plotting. +import matplotlib.pyplot as plt import nest import nest.voltage_trace -import matplotlib.pyplot as plt from numpy import exp ############################################################################### diff --git a/pynest/examples/tsodyks_facilitating.py b/pynest/examples/tsodyks_facilitating.py index d764dc8e76..b5a298a28c 100644 --- a/pynest/examples/tsodyks_facilitating.py +++ b/pynest/examples/tsodyks_facilitating.py @@ -48,9 +48,9 @@ ############################################################################### # First, we import all necessary modules for simulation and plotting. +import matplotlib.pyplot as plt import nest import nest.voltage_trace -import matplotlib.pyplot as plt from numpy import exp ############################################################################### diff --git a/pynest/examples/twoneurons.py b/pynest/examples/twoneurons.py index 396600f327..9e1e263a97 100644 --- a/pynest/examples/twoneurons.py +++ b/pynest/examples/twoneurons.py @@ -39,9 +39,9 @@ # Additionally, we set the verbosity to suppress info messages and reset # the kernel. +import matplotlib.pyplot as plt import nest import nest.voltage_trace -import matplotlib.pyplot as plt nest.set_verbosity("M_WARNING") nest.ResetKernel() diff --git a/pynest/examples/urbanczik_synapse_example.py b/pynest/examples/urbanczik_synapse_example.py index 17793c50dd..be5ec7f791 100644 --- a/pynest/examples/urbanczik_synapse_example.py +++ b/pynest/examples/urbanczik_synapse_example.py @@ -39,9 +39,9 @@ .. [1] R. Urbanczik, W. Senn (2014): Learning by the Dendritic Prediction of Somatic Spiking. Neuron, 81, 521-528. """ +import nest import numpy as np from matplotlib import pyplot as plt -import nest def g_inh(amplitude, t_start, t_end): diff --git a/pynest/examples/vinit_example.py b/pynest/examples/vinit_example.py index ce468043ea..6c5cdf6920 100755 --- a/pynest/examples/vinit_example.py +++ b/pynest/examples/vinit_example.py @@ -37,9 +37,9 @@ ############################################################################### # First, the necessary modules for simulation and plotting are imported. +import matplotlib.pyplot as plt import nest import numpy -import matplotlib.pyplot as plt ############################################################################### # A loop runs over a range of initial membrane voltages. diff --git a/pynest/nest/__init__.py b/pynest/nest/__init__.py index 609eb780df..1652f93683 100644 --- a/pynest/nest/__init__.py +++ b/pynest/nest/__init__.py @@ -56,10 +56,11 @@ # instance later on. Use `.copy()` to prevent pollution with other variables _original_module_attrs = globals().copy() +import builtins # noqa +import importlib # noqa import sys # noqa import types # noqa -import importlib # noqa -import builtins # noqa + from .ll_api_kernel_attributes import KernelAttribute # noqa try: @@ -76,11 +77,11 @@ class NestModule(types.ModuleType): """ from . import ll_api # noqa - from . import pynestkernel as kernel # noqa - from . import random # noqa + from . import logic # noqa from . import math # noqa + from . import random # noqa from . import spatial_distributions # noqa - from . import logic # noqa + from . import pynestkernel as kernel # noqa from .ll_api import set_communicator def __init__(self, name): diff --git a/pynest/nest/lib/hl_api_connection_helpers.py b/pynest/nest/lib/hl_api_connection_helpers.py index d03f34f85c..2cceb09533 100644 --- a/pynest/nest/lib/hl_api_connection_helpers.py +++ b/pynest/nest/lib/hl_api_connection_helpers.py @@ -25,12 +25,13 @@ """ import copy + import numpy as np -from ..ll_api import sps, sr, spp from .. import pynestkernel as kernel -from .hl_api_types import CollocatedSynapses, Mask, NodeCollection, Parameter +from ..ll_api import spp, sps, sr from .hl_api_exceptions import NESTErrors +from .hl_api_types import CollocatedSynapses, Mask, NodeCollection, Parameter __all__ = [ "_connect_layers_needed", diff --git a/pynest/nest/lib/hl_api_connections.py b/pynest/nest/lib/hl_api_connections.py index 32d1ac3a51..5c1673cf74 100644 --- a/pynest/nest/lib/hl_api_connections.py +++ b/pynest/nest/lib/hl_api_connections.py @@ -25,14 +25,13 @@ import numpy -from ..ll_api import check_stack, connect_arrays, sps, sr, spp from .. import pynestkernel as kernel - +from ..ll_api import check_stack, connect_arrays, spp, sps, sr from .hl_api_connection_helpers import ( - _process_input_nodes, _connect_layers_needed, _connect_spatial, _process_conn_spec, + _process_input_nodes, _process_spatial_projections, _process_syn_spec, ) diff --git a/pynest/nest/lib/hl_api_helper.py b/pynest/nest/lib/hl_api_helper.py index 8b602fd30b..8462cd16eb 100644 --- a/pynest/nest/lib/hl_api_helper.py +++ b/pynest/nest/lib/hl_api_helper.py @@ -24,17 +24,16 @@ API of the PyNEST wrapper. """ -import warnings -import json import functools -import textwrap +import json import os import pydoc - +import textwrap +import warnings from string import Template -from ..ll_api import sli_func, sps, sr, spp from .. import pynestkernel as kernel +from ..ll_api import sli_func, spp, sps, sr __all__ = [ "broadcast", diff --git a/pynest/nest/lib/hl_api_info.py b/pynest/nest/lib/hl_api_info.py index 6379a7eab8..5a878c6c1f 100644 --- a/pynest/nest/lib/hl_api_info.py +++ b/pynest/nest/lib/hl_api_info.py @@ -27,11 +27,18 @@ import textwrap import webbrowser -from ..ll_api import check_stack, sli_func, sps, sr, spp -from .hl_api_helper import broadcast, is_iterable, is_literal, load_help, show_help_with_pager -from .hl_api_types import to_json import nest +from ..ll_api import check_stack, sli_func, spp, sps, sr +from .hl_api_helper import ( + broadcast, + is_iterable, + is_literal, + load_help, + show_help_with_pager, +) +from .hl_api_types import to_json + __all__ = [ "authors", "get_argv", diff --git a/pynest/nest/lib/hl_api_models.py b/pynest/nest/lib/hl_api_models.py index b48e06ec58..688df98f7a 100644 --- a/pynest/nest/lib/hl_api_models.py +++ b/pynest/nest/lib/hl_api_models.py @@ -23,10 +23,15 @@ Functions for model handling """ -from ..ll_api import check_stack, sps, sr, spp -from .hl_api_helper import deprecated, is_iterable, is_literal, model_deprecation_warning -from .hl_api_types import to_json +from ..ll_api import check_stack, spp, sps, sr +from .hl_api_helper import ( + deprecated, + is_iterable, + is_literal, + model_deprecation_warning, +) from .hl_api_simulation import GetKernelStatus +from .hl_api_types import to_json __all__ = [ "ConnectionRules", diff --git a/pynest/nest/lib/hl_api_nodes.py b/pynest/nest/lib/hl_api_nodes.py index 7d6b208fe5..bb338c2457 100644 --- a/pynest/nest/lib/hl_api_nodes.py +++ b/pynest/nest/lib/hl_api_nodes.py @@ -26,8 +26,9 @@ import warnings import nest -from ..ll_api import check_stack, sli_func, sps, sr, spp + from .. import pynestkernel as kernel +from ..ll_api import check_stack, sli_func, spp, sps, sr from .hl_api_helper import is_iterable, model_deprecation_warning from .hl_api_info import SetStatus from .hl_api_types import NodeCollection, Parameter diff --git a/pynest/nest/lib/hl_api_parallel_computing.py b/pynest/nest/lib/hl_api_parallel_computing.py index 36040b6376..9ad6c40f8e 100644 --- a/pynest/nest/lib/hl_api_parallel_computing.py +++ b/pynest/nest/lib/hl_api_parallel_computing.py @@ -23,8 +23,8 @@ Functions for parallel computing """ -from ..ll_api import check_stack, sps, sr, spp, sli_func from .. import pynestkernel as kernel +from ..ll_api import check_stack, sli_func, spp, sps, sr __all__ = [ "NumProcesses", diff --git a/pynest/nest/lib/hl_api_simulation.py b/pynest/nest/lib/hl_api_simulation.py index 98cec2fe55..30f74885de 100644 --- a/pynest/nest/lib/hl_api_simulation.py +++ b/pynest/nest/lib/hl_api_simulation.py @@ -23,10 +23,10 @@ Functions for simulation control """ -from contextlib import contextmanager import warnings +from contextlib import contextmanager -from ..ll_api import check_stack, sps, sr, spp +from ..ll_api import check_stack, spp, sps, sr from .hl_api_helper import is_iterable, is_literal __all__ = [ diff --git a/pynest/nest/lib/hl_api_spatial.py b/pynest/nest/lib/hl_api_spatial.py index 19bfe1c952..e1d0865fc1 100644 --- a/pynest/nest/lib/hl_api_spatial.py +++ b/pynest/nest/lib/hl_api_spatial.py @@ -27,15 +27,15 @@ import numpy as np from ..ll_api import sli_func -from .hl_api_helper import is_iterable from .hl_api_connections import GetConnections +from .hl_api_helper import is_iterable from .hl_api_parallel_computing import NumProcesses, Rank from .hl_api_types import NodeCollection try: import matplotlib as mpl - import matplotlib.path as mpath import matplotlib.patches as mpatches + import matplotlib.path as mpath HAVE_MPL = True except ImportError: @@ -1467,8 +1467,8 @@ def _create_mask_patches(mask, periodic, extent, source_pos, face_color="yellow" # import pyplot here and not at toplevel to avoid preventing users # from changing matplotlib backend after importing nest - import matplotlib.pyplot as plt import matplotlib as mtpl + import matplotlib.pyplot as plt edge_color = "black" alpha = 0.2 diff --git a/pynest/nest/lib/hl_api_types.py b/pynest/nest/lib/hl_api_types.py index ca41b4c0a0..c9420a0bd1 100644 --- a/pynest/nest/lib/hl_api_types.py +++ b/pynest/nest/lib/hl_api_types.py @@ -23,8 +23,13 @@ Classes defining the different PyNEST types """ -from ..ll_api import sli_func, sps, sr, spp, take_array_index +import json +from math import floor, log + +import numpy + from .. import pynestkernel as kernel +from ..ll_api import sli_func, spp, sps, sr, take_array_index from .hl_api_helper import ( broadcast, get_parameters, @@ -35,10 +40,6 @@ ) from .hl_api_simulation import GetKernelStatus -import numpy -import json -from math import floor, log - try: import pandas diff --git a/pynest/nest/ll_api.py b/pynest/nest/ll_api.py index 6797e4e49d..7958126e0a 100644 --- a/pynest/nest/ll_api.py +++ b/pynest/nest/ll_api.py @@ -29,9 +29,8 @@ import functools import inspect import keyword - -import sys import os +import sys # This is a workaround for readline import errors encountered with Anaconda # Python running on Ubuntu, when invoked from the terminal diff --git a/pynest/nest/ll_api_kernel_attributes.py b/pynest/nest/ll_api_kernel_attributes.py index a595af1786..dc68f44d3a 100644 --- a/pynest/nest/ll_api_kernel_attributes.py +++ b/pynest/nest/ll_api_kernel_attributes.py @@ -19,7 +19,7 @@ # You should have received a copy of the GNU General Public License # along with NEST. If not, see . -from .ll_api import sr, stack_checker, sps, spp +from .ll_api import spp, sps, sr, stack_checker class KernelAttribute: diff --git a/pynest/nest/logic/hl_api_logic.py b/pynest/nest/logic/hl_api_logic.py index 3cdd6f9602..b9ff2e2c84 100644 --- a/pynest/nest/logic/hl_api_logic.py +++ b/pynest/nest/logic/hl_api_logic.py @@ -19,8 +19,8 @@ # You should have received a copy of the GNU General Public License # along with NEST. If not, see . -from ..ll_api import sli_func from ..lib.hl_api_types import CreateParameter +from ..ll_api import sli_func __all__ = [ "conditional", diff --git a/pynest/nest/raster_plot.py b/pynest/nest/raster_plot.py index 486b8c8549..811ecfeedd 100644 --- a/pynest/nest/raster_plot.py +++ b/pynest/nest/raster_plot.py @@ -305,7 +305,7 @@ def _histogram(a, bins=10, bin_range=None, normed=False): ------ ValueError """ - from numpy import asarray, iterable, linspace, sort, concatenate + from numpy import asarray, concatenate, iterable, linspace, sort a = asarray(a).ravel() diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index f736291749..595cf614d6 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -23,24 +23,18 @@ import importlib import inspect import io +import os import sys - -from flask import Flask, request, jsonify -from flask_cors import CORS, cross_origin - -from werkzeug.exceptions import abort -from werkzeug.wrappers import Response - -import nest - -import RestrictedPython import time - import traceback - from copy import deepcopy -import os +import nest +import RestrictedPython +from flask import Flask, jsonify, request +from flask_cors import CORS, cross_origin +from werkzeug.exceptions import abort +from werkzeug.wrappers import Response MODULES = os.environ.get("NEST_SERVER_MODULES", "nest").split(",") RESTRICTION_OFF = bool(os.environ.get("NEST_SERVER_RESTRICTION_OFF", False)) diff --git a/pynest/nest/spatial/__init__.py b/pynest/nest/spatial/__init__.py index d2c464ff0b..94e1fa6e5f 100644 --- a/pynest/nest/spatial/__init__.py +++ b/pynest/nest/spatial/__init__.py @@ -20,8 +20,9 @@ # along with NEST. If not, see . import functools as _functools -from .hl_api_spatial import * # noqa: F401,F403 + from .hl_api_spatial import DistanceParameter as _DistanceParameter +from .hl_api_spatial import * # noqa: F401,F403 @_functools.lru_cache(maxsize=None) diff --git a/pynest/nest/spatial/hl_api_spatial.py b/pynest/nest/spatial/hl_api_spatial.py index 9c036f9dc8..e70e3b8d6a 100644 --- a/pynest/nest/spatial/hl_api_spatial.py +++ b/pynest/nest/spatial/hl_api_spatial.py @@ -20,6 +20,7 @@ # along with NEST. If not, see . import numpy as np + from ..lib.hl_api_types import CreateParameter, Parameter from ..ll_api import sli_func diff --git a/pynest/nest/visualization.py b/pynest/nest/visualization.py index 3637f3db2a..2d86486583 100644 --- a/pynest/nest/visualization.py +++ b/pynest/nest/visualization.py @@ -23,8 +23,8 @@ Functions to visualize a network built in NEST. """ -import pydot import nest +import pydot __all__ = [ "plot_network", diff --git a/pynest/pynestkernel.pxd b/pynest/pynestkernel.pxd index 2e3eba10fc..7a766f4696 100644 --- a/pynest/pynestkernel.pxd +++ b/pynest/pynestkernel.pxd @@ -19,12 +19,11 @@ # You should have received a copy of the GNU General Public License # along with NEST. If not, see . +from cpython.ref cimport PyObject from libcpp cimport bool as cbool - from libcpp.string cimport string from libcpp.vector cimport vector -from cpython.ref cimport PyObject cdef extern from "name.h": cppclass Name: diff --git a/pynest/pynestkernel.pyx b/pynest/pynestkernel.pyx index b69544306d..d41f118af9 100644 --- a/pynest/pynestkernel.pyx +++ b/pynest/pynestkernel.pyx @@ -24,22 +24,18 @@ import cython -from libc.stdlib cimport malloc, free +from cpython cimport array +from cpython.object cimport Py_EQ, Py_GE, Py_GT, Py_LE, Py_LT, Py_NE +from cpython.ref cimport PyObject +from cython.operator cimport dereference as deref +from cython.operator cimport preincrement as inc +from libc.stdlib cimport free, malloc from libc.string cimport memcpy - from libcpp.string cimport string from libcpp.vector cimport vector -from cython.operator cimport dereference as deref -from cython.operator cimport preincrement as inc - -from cpython cimport array - -from cpython.ref cimport PyObject -from cpython.object cimport Py_LT, Py_LE, Py_EQ, Py_NE, Py_GT, Py_GE - import nest -from nest.lib.hl_api_exceptions import NESTMappedException, NESTErrors, NESTError +from nest.lib.hl_api_exceptions import NESTError, NESTErrors, NESTMappedException cdef string SLI_TYPE_BOOL = b"booltype" diff --git a/pyproject.toml b/pyproject.toml index 4c56a590cf..9f7cc6f130 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -9,6 +9,7 @@ markers = [ [tool.isort] profile = "black" +known_third_party = "nest" [tool.black] line-length = 120 diff --git a/testsuite/pytests/conftest.py b/testsuite/pytests/conftest.py index 835ac35a82..163aca8ba4 100644 --- a/testsuite/pytests/conftest.py +++ b/testsuite/pytests/conftest.py @@ -35,9 +35,8 @@ def test_gsl(): import pathlib import sys -import pytest - import nest +import pytest # Make all modules in the `utilities` folder available to import in any test sys.path.append(str(pathlib.Path(__file__).parent / "utilities")) diff --git a/testsuite/pytests/connect_test_base.py b/testsuite/pytests/connect_test_base.py index 858d1a7f0d..7c25a7b1c6 100644 --- a/testsuite/pytests/connect_test_base.py +++ b/testsuite/pytests/connect_test_base.py @@ -19,10 +19,11 @@ # You should have received a copy of the GNU General Public License # along with NEST. If not, see . +import unittest + +import nest import numpy as np import scipy.stats -import nest -import unittest try: from mpi4py import MPI diff --git a/testsuite/pytests/mpi/2/test_connect_arrays_mpi.py b/testsuite/pytests/mpi/2/test_connect_arrays_mpi.py index 1cf764cdfd..d20e8c9311 100644 --- a/testsuite/pytests/mpi/2/test_connect_arrays_mpi.py +++ b/testsuite/pytests/mpi/2/test_connect_arrays_mpi.py @@ -20,6 +20,7 @@ # along with NEST. If not, see . import unittest + import nest import numpy as np diff --git a/testsuite/pytests/mpi/2/test_issue_576.py b/testsuite/pytests/mpi/2/test_issue_576.py index 515167fac3..63095a95c3 100644 --- a/testsuite/pytests/mpi/2/test_issue_576.py +++ b/testsuite/pytests/mpi/2/test_issue_576.py @@ -20,9 +20,10 @@ # along with NEST. If not, see . -import nest import unittest +import nest + HAVE_GSL = nest.ll_api.sli_func("statusdict/have_gsl ::") diff --git a/testsuite/pytests/mpi/4/test_consistent_local_vps.py b/testsuite/pytests/mpi/4/test_consistent_local_vps.py index 62ce5ac55f..c27ff277ad 100644 --- a/testsuite/pytests/mpi/4/test_consistent_local_vps.py +++ b/testsuite/pytests/mpi/4/test_consistent_local_vps.py @@ -20,8 +20,8 @@ # along with NEST. If not, see . import unittest -import nest +import nest HAVE_OPENMP = nest.ll_api.sli_func("is_threaded") diff --git a/testsuite/pytests/sli2py_connect/test_delay_check.py b/testsuite/pytests/sli2py_connect/test_delay_check.py index 43a040e860..d170f006f0 100644 --- a/testsuite/pytests/sli2py_connect/test_delay_check.py +++ b/testsuite/pytests/sli2py_connect/test_delay_check.py @@ -27,8 +27,8 @@ """ -import pytest import nest +import pytest @pytest.fixture(autouse=True) diff --git a/testsuite/pytests/sli2py_neurons/iaf_psc_alpha/test_iaf_psc_alpha.py b/testsuite/pytests/sli2py_neurons/iaf_psc_alpha/test_iaf_psc_alpha.py index 7cb833f065..8ef1815eb0 100644 --- a/testsuite/pytests/sli2py_neurons/iaf_psc_alpha/test_iaf_psc_alpha.py +++ b/testsuite/pytests/sli2py_neurons/iaf_psc_alpha/test_iaf_psc_alpha.py @@ -22,14 +22,13 @@ import dataclasses import math +import nest import numpy as np import pytest -import nest import testsimulation import testutil from scipy.special import lambertw - # Notes: # * copy docs # * add docs & examples diff --git a/testsuite/pytests/sli2py_neurons/iaf_psc_alpha/test_iaf_psc_alpha_1to2.py b/testsuite/pytests/sli2py_neurons/iaf_psc_alpha/test_iaf_psc_alpha_1to2.py index 3e4b7045c0..ce7fcc9d8d 100644 --- a/testsuite/pytests/sli2py_neurons/iaf_psc_alpha/test_iaf_psc_alpha_1to2.py +++ b/testsuite/pytests/sli2py_neurons/iaf_psc_alpha/test_iaf_psc_alpha_1to2.py @@ -21,9 +21,9 @@ import dataclasses +import nest import numpy as np import pytest -import nest import testsimulation import testutil diff --git a/testsuite/pytests/sli2py_neurons/iaf_psc_alpha/test_iaf_psc_alpha_dc.py b/testsuite/pytests/sli2py_neurons/iaf_psc_alpha/test_iaf_psc_alpha_dc.py index 23838405b1..666f339da9 100644 --- a/testsuite/pytests/sli2py_neurons/iaf_psc_alpha/test_iaf_psc_alpha_dc.py +++ b/testsuite/pytests/sli2py_neurons/iaf_psc_alpha/test_iaf_psc_alpha_dc.py @@ -21,11 +21,11 @@ import dataclasses +import nest import numpy as np import pytest -import nest -import testutil import testsimulation +import testutil @dataclasses.dataclass diff --git a/testsuite/pytests/sli2py_neurons/test_add_freeze_thaw.py b/testsuite/pytests/sli2py_neurons/test_add_freeze_thaw.py index 3877ba3a17..ee60d9a650 100644 --- a/testsuite/pytests/sli2py_neurons/test_add_freeze_thaw.py +++ b/testsuite/pytests/sli2py_neurons/test_add_freeze_thaw.py @@ -23,9 +23,9 @@ Test that per-thread nodes vectors are updated. """ +import nest import numpy as np import pytest -import nest @pytest.mark.skipif_missing_threads diff --git a/testsuite/pytests/sli2py_neurons/test_amat2_psc_exp.py b/testsuite/pytests/sli2py_neurons/test_amat2_psc_exp.py index e33e89c4cb..ddcf49929d 100644 --- a/testsuite/pytests/sli2py_neurons/test_amat2_psc_exp.py +++ b/testsuite/pytests/sli2py_neurons/test_amat2_psc_exp.py @@ -35,14 +35,13 @@ from collections import namedtuple +import nest import numpy as np import numpy.testing as nptest import pandas as pd import pandas.testing as pdtest import pytest -import nest - @pytest.fixture(scope="module") def simulation(): diff --git a/testsuite/pytests/sli2py_neurons/test_mat2_psc_exp.py b/testsuite/pytests/sli2py_neurons/test_mat2_psc_exp.py index 919b9c79fd..4057da7a7d 100644 --- a/testsuite/pytests/sli2py_neurons/test_mat2_psc_exp.py +++ b/testsuite/pytests/sli2py_neurons/test_mat2_psc_exp.py @@ -28,14 +28,13 @@ from collections import namedtuple +import nest import numpy as np import numpy.testing as nptest import pandas as pd import pandas.testing as pdtest import pytest -import nest - @pytest.fixture(scope="module") def simulation(): diff --git a/testsuite/pytests/sli2py_neurons/test_model_node_init.py b/testsuite/pytests/sli2py_neurons/test_model_node_init.py index 22b7ca5b9c..3179a2b3cf 100644 --- a/testsuite/pytests/sli2py_neurons/test_model_node_init.py +++ b/testsuite/pytests/sli2py_neurons/test_model_node_init.py @@ -29,8 +29,8 @@ and comparing traces. """ -import pytest import nest +import pytest def _get_network_state(nc): diff --git a/testsuite/pytests/sli2py_neurons/test_neurons_handle_multiplicity.py b/testsuite/pytests/sli2py_neurons/test_neurons_handle_multiplicity.py index e5a73b69a3..de32bdc67a 100644 --- a/testsuite/pytests/sli2py_neurons/test_neurons_handle_multiplicity.py +++ b/testsuite/pytests/sli2py_neurons/test_neurons_handle_multiplicity.py @@ -27,9 +27,9 @@ """ import nest -import pytest import numpy as np import numpy.testing as nptest +import pytest skip_list = [ "ginzburg_neuron", # binary neuron diff --git a/testsuite/pytests/sli2py_neurons/test_set_vm.py b/testsuite/pytests/sli2py_neurons/test_set_vm.py index 9b87d6cbb7..260a15a978 100644 --- a/testsuite/pytests/sli2py_neurons/test_set_vm.py +++ b/testsuite/pytests/sli2py_neurons/test_set_vm.py @@ -35,9 +35,10 @@ cases it may lead to the exclusion of a model that should be tested. """ +import random + import nest import pytest -import random @pytest.fixture(autouse=True) diff --git a/testsuite/pytests/sli2py_other/test_corr_matrix_det.py b/testsuite/pytests/sli2py_other/test_corr_matrix_det.py index cd5aa7ff40..e8639efe60 100644 --- a/testsuite/pytests/sli2py_other/test_corr_matrix_det.py +++ b/testsuite/pytests/sli2py_other/test_corr_matrix_det.py @@ -28,9 +28,9 @@ The test does not test weighted correlations. """ -import pytest import nest import numpy as np +import pytest @pytest.fixture() diff --git a/testsuite/pytests/sli2py_other/test_multithreading.py b/testsuite/pytests/sli2py_other/test_multithreading.py index 74eff82c0b..b1834d2252 100644 --- a/testsuite/pytests/sli2py_other/test_multithreading.py +++ b/testsuite/pytests/sli2py_other/test_multithreading.py @@ -28,10 +28,10 @@ * Does default node distribution (modulo) work as expected? * Are spikes transmitted between threads as expected? """ -import pytest import nest import numpy as np import numpy.testing as nptest +import pytest pytestmark = pytest.mark.skipif_missing_threads diff --git a/testsuite/pytests/sli2py_other/test_set_tics.py b/testsuite/pytests/sli2py_other/test_set_tics.py index 607968f548..e3161e40a2 100644 --- a/testsuite/pytests/sli2py_other/test_set_tics.py +++ b/testsuite/pytests/sli2py_other/test_set_tics.py @@ -38,11 +38,10 @@ parameters and whether the corresponding conversions are correct. """ +import nest import numpy as np import pytest -import nest - @pytest.fixture(autouse=True) def prepare(): diff --git a/testsuite/pytests/sli2py_recording/test_corr_det.py b/testsuite/pytests/sli2py_recording/test_corr_det.py index 7c9126daf6..d9c941d722 100644 --- a/testsuite/pytests/sli2py_recording/test_corr_det.py +++ b/testsuite/pytests/sli2py_recording/test_corr_det.py @@ -29,8 +29,8 @@ """ import nest -import pytest import numpy as np +import pytest @pytest.fixture(autouse=True) diff --git a/testsuite/pytests/sli2py_recording/test_multimeter_freeze_thaw.py b/testsuite/pytests/sli2py_recording/test_multimeter_freeze_thaw.py index dd37127108..482b92e701 100644 --- a/testsuite/pytests/sli2py_recording/test_multimeter_freeze_thaw.py +++ b/testsuite/pytests/sli2py_recording/test_multimeter_freeze_thaw.py @@ -19,12 +19,11 @@ # You should have received a copy of the GNU General Public License # along with NEST. If not, see . +import nest import numpy as np import numpy.testing as nptest import pytest -import nest - def build_net(num_neurons): """ diff --git a/testsuite/pytests/sli2py_recording/test_multimeter_offset.py b/testsuite/pytests/sli2py_recording/test_multimeter_offset.py index 22b16e70de..e9818b19c9 100644 --- a/testsuite/pytests/sli2py_recording/test_multimeter_offset.py +++ b/testsuite/pytests/sli2py_recording/test_multimeter_offset.py @@ -23,12 +23,11 @@ This set of tests verify the behavior of the offset attribute of multimeter. """ +import nest import numpy as np import numpy.testing as nptest import pytest -import nest - @pytest.fixture(autouse=True) def reset_kernel(): diff --git a/testsuite/pytests/sli2py_recording/test_multimeter_stepping.py b/testsuite/pytests/sli2py_recording/test_multimeter_stepping.py index 5f5451e1a6..b785806ebb 100644 --- a/testsuite/pytests/sli2py_recording/test_multimeter_stepping.py +++ b/testsuite/pytests/sli2py_recording/test_multimeter_stepping.py @@ -23,12 +23,11 @@ Test multimeter recording in stepwise simulation. """ +import nest import pandas as pd import pandas.testing as pdtest import pytest -import nest - skip_models = [ "gauss_rate_ipn", "lin_rate_ipn", diff --git a/testsuite/pytests/sli2py_regressions/test_issue_1242.py b/testsuite/pytests/sli2py_regressions/test_issue_1242.py index 9074908a56..483f6466fc 100644 --- a/testsuite/pytests/sli2py_regressions/test_issue_1242.py +++ b/testsuite/pytests/sli2py_regressions/test_issue_1242.py @@ -23,9 +23,8 @@ Regression test for Issue #1242 (GitHub). """ -import pytest - import nest +import pytest def test_volume_transmitter_illegal_connection(): diff --git a/testsuite/pytests/sli2py_regressions/test_issue_1305.py b/testsuite/pytests/sli2py_regressions/test_issue_1305.py index c5e894dfeb..d887295e8f 100644 --- a/testsuite/pytests/sli2py_regressions/test_issue_1305.py +++ b/testsuite/pytests/sli2py_regressions/test_issue_1305.py @@ -26,9 +26,8 @@ rounding errors correctly. """ -import pytest - import nest +import pytest @pytest.fixture(autouse=True) diff --git a/testsuite/pytests/sli2py_regressions/test_issue_1366.py b/testsuite/pytests/sli2py_regressions/test_issue_1366.py index 86e1f12922..fc2b85ff3c 100644 --- a/testsuite/pytests/sli2py_regressions/test_issue_1366.py +++ b/testsuite/pytests/sli2py_regressions/test_issue_1366.py @@ -26,9 +26,8 @@ to 1 when we have more than 1 virtual process and more than 1 node per process. """ -import pytest - import nest +import pytest @pytest.mark.skipif_missing_threads diff --git a/testsuite/pytests/sli2py_regressions/test_issue_351.py b/testsuite/pytests/sli2py_regressions/test_issue_351.py index da4c1c3402..abe416a983 100644 --- a/testsuite/pytests/sli2py_regressions/test_issue_351.py +++ b/testsuite/pytests/sli2py_regressions/test_issue_351.py @@ -25,9 +25,8 @@ This test ensures `Connect` raises exception if connecting to recording device with probabilistic connection rule. """ -import pytest - import nest +import pytest @pytest.fixture(autouse=True) diff --git a/testsuite/pytests/sli2py_regressions/test_issue_368.py b/testsuite/pytests/sli2py_regressions/test_issue_368.py index df68aa42d1..a06fda3f8a 100644 --- a/testsuite/pytests/sli2py_regressions/test_issue_368.py +++ b/testsuite/pytests/sli2py_regressions/test_issue_368.py @@ -26,9 +26,8 @@ arriving at exactly the same times correctly. """ -import pytest - import nest +import pytest @pytest.fixture(autouse=True) diff --git a/testsuite/pytests/sli2py_regressions/test_issue_410.py b/testsuite/pytests/sli2py_regressions/test_issue_410.py index c039a1b05b..a8d9080cb3 100644 --- a/testsuite/pytests/sli2py_regressions/test_issue_410.py +++ b/testsuite/pytests/sli2py_regressions/test_issue_410.py @@ -23,9 +23,8 @@ Regression test for Issue #410 (GitHub). """ -import pytest - import nest +import pytest pytestmark = [pytest.mark.skipif_missing_gsl, pytest.mark.skipif_missing_threads] diff --git a/testsuite/pytests/sli2py_regressions/ticket_754.py b/testsuite/pytests/sli2py_regressions/ticket_754.py index 9f2ec3ff40..3c95e46661 100644 --- a/testsuite/pytests/sli2py_regressions/ticket_754.py +++ b/testsuite/pytests/sli2py_regressions/ticket_754.py @@ -23,9 +23,8 @@ Test that rng_seed and rng_type is handled correctly also in connection with changing VP numbers. """ -import pytest - import nest +import pytest @pytest.fixture(autouse=True) diff --git a/testsuite/pytests/sli2py_stimulating/test_ac_generator.py b/testsuite/pytests/sli2py_stimulating/test_ac_generator.py index f389af9c27..9d0d7be3ec 100644 --- a/testsuite/pytests/sli2py_stimulating/test_ac_generator.py +++ b/testsuite/pytests/sli2py_stimulating/test_ac_generator.py @@ -25,10 +25,11 @@ corresponding to the current expected from the ac_generator. """ -import nest -import pytest import math + +import nest import numpy as np +import pytest def test_ac_generaor(): diff --git a/testsuite/pytests/sli2py_stimulating/test_noise_generator.py b/testsuite/pytests/sli2py_stimulating/test_noise_generator.py index 39e4e748b3..66040d48f4 100644 --- a/testsuite/pytests/sli2py_stimulating/test_noise_generator.py +++ b/testsuite/pytests/sli2py_stimulating/test_noise_generator.py @@ -24,8 +24,8 @@ """ import nest -import pytest import numpy as np +import pytest @pytest.fixture diff --git a/testsuite/pytests/sli2py_stimulating/test_pulsepacket_generator.py b/testsuite/pytests/sli2py_stimulating/test_pulsepacket_generator.py index 120d081639..13b839cad2 100644 --- a/testsuite/pytests/sli2py_stimulating/test_pulsepacket_generator.py +++ b/testsuite/pytests/sli2py_stimulating/test_pulsepacket_generator.py @@ -23,13 +23,12 @@ Test parameter setting and correct number of spikes emitted by `pulsepacket_generator`. """ +import nest import numpy as np import pandas as pd import pandas.testing as pdtest import pytest -import nest - @pytest.fixture(autouse=True) def reset(): diff --git a/testsuite/pytests/sli2py_stimulating/test_sinusoidal_poisson_generator.py b/testsuite/pytests/sli2py_stimulating/test_sinusoidal_poisson_generator.py index 46ac98e3ca..308351e3bc 100644 --- a/testsuite/pytests/sli2py_stimulating/test_sinusoidal_poisson_generator.py +++ b/testsuite/pytests/sli2py_stimulating/test_sinusoidal_poisson_generator.py @@ -23,12 +23,11 @@ Test basic properties of `sinusoidal_poisson_generator`. """ +import nest import numpy as np import numpy.testing as nptest import pytest -import nest - @pytest.fixture(autouse=True) def reset(): diff --git a/testsuite/pytests/sli2py_stimulating/test_spike_generator.py b/testsuite/pytests/sli2py_stimulating/test_spike_generator.py index 8bf90905d9..d92ae1d1b3 100644 --- a/testsuite/pytests/sli2py_stimulating/test_spike_generator.py +++ b/testsuite/pytests/sli2py_stimulating/test_spike_generator.py @@ -24,8 +24,8 @@ """ import nest -import pytest import numpy.testing as nptest +import pytest @pytest.fixture diff --git a/testsuite/pytests/sli2py_stimulating/test_spike_poisson_ps.py b/testsuite/pytests/sli2py_stimulating/test_spike_poisson_ps.py index 4473db2d22..e3a58b9868 100644 --- a/testsuite/pytests/sli2py_stimulating/test_spike_poisson_ps.py +++ b/testsuite/pytests/sli2py_stimulating/test_spike_poisson_ps.py @@ -28,12 +28,11 @@ the spike times indeed are independent of the resolution. """ +import nest import numpy as np import numpy.testing as nptest import pytest -import nest - def simulator(resolution): """ diff --git a/testsuite/pytests/sli2py_synapses/test_cont_delay_synapse.py b/testsuite/pytests/sli2py_synapses/test_cont_delay_synapse.py index 8abe46d99d..8d5bb52413 100644 --- a/testsuite/pytests/sli2py_synapses/test_cont_delay_synapse.py +++ b/testsuite/pytests/sli2py_synapses/test_cont_delay_synapse.py @@ -20,8 +20,8 @@ # along with NEST. If not, see . import nest -import pytest import numpy as np +import pytest @pytest.fixture diff --git a/testsuite/pytests/sli2py_synapses/test_hh_cond_exp_traub.py b/testsuite/pytests/sli2py_synapses/test_hh_cond_exp_traub.py index 14b6a09abe..49889ba8a1 100644 --- a/testsuite/pytests/sli2py_synapses/test_hh_cond_exp_traub.py +++ b/testsuite/pytests/sli2py_synapses/test_hh_cond_exp_traub.py @@ -21,9 +21,9 @@ import nest -import pytest import numpy as np import numpy.testing as nptest +import pytest pytestmark = pytest.mark.skipif_missing_gsl diff --git a/testsuite/pytests/test_NodeCollection.py b/testsuite/pytests/test_NodeCollection.py index 77d3bed536..f558d70da0 100644 --- a/testsuite/pytests/test_NodeCollection.py +++ b/testsuite/pytests/test_NodeCollection.py @@ -24,6 +24,7 @@ """ import unittest + import nest try: diff --git a/testsuite/pytests/test_aeif_lsodar.py b/testsuite/pytests/test_aeif_lsodar.py index a2fb5a2cb9..845dc3414e 100644 --- a/testsuite/pytests/test_aeif_lsodar.py +++ b/testsuite/pytests/test_aeif_lsodar.py @@ -21,13 +21,11 @@ import os import unittest - -import numpy as np -from scipy.interpolate import interp1d - from collections import defaultdict import nest +import numpy as np +from scipy.interpolate import interp1d """ Comparing the new implementations the aeif models to the reference solution diff --git a/testsuite/pytests/test_changing_tic_base.py b/testsuite/pytests/test_changing_tic_base.py index 3814bf0a6c..6caa62b353 100644 --- a/testsuite/pytests/test_changing_tic_base.py +++ b/testsuite/pytests/test_changing_tic_base.py @@ -20,6 +20,7 @@ # along with NEST. If not, see . import unittest + import nest import numpy as np diff --git a/testsuite/pytests/test_clopath_synapse.py b/testsuite/pytests/test_clopath_synapse.py index 19a5746fb8..96e10451d4 100644 --- a/testsuite/pytests/test_clopath_synapse.py +++ b/testsuite/pytests/test_clopath_synapse.py @@ -24,6 +24,7 @@ """ import unittest + import nest import numpy as np diff --git a/testsuite/pytests/test_compartmental_model.py b/testsuite/pytests/test_compartmental_model.py index 70565b7840..4a6f362ebe 100644 --- a/testsuite/pytests/test_compartmental_model.py +++ b/testsuite/pytests/test_compartmental_model.py @@ -23,10 +23,10 @@ Tests for the compartmental model """ -import nest import unittest -import numpy as np +import nest +import numpy as np SP = {"C_m": 1.00, "g_C": 0.00, "g_L": 0.100, "e_L": -70.0} DP = [ diff --git a/testsuite/pytests/test_connect_all_to_all.py b/testsuite/pytests/test_connect_all_to_all.py index d945232a0e..157f54942d 100644 --- a/testsuite/pytests/test_connect_all_to_all.py +++ b/testsuite/pytests/test_connect_all_to_all.py @@ -21,11 +21,11 @@ import unittest -import numpy as np -import scipy.stats + import connect_test_base import nest - +import numpy as np +import scipy.stats HAVE_OPENMP = nest.ll_api.sli_func("is_threaded") diff --git a/testsuite/pytests/test_connect_array_fixed_indegree.py b/testsuite/pytests/test_connect_array_fixed_indegree.py index 33608d31f8..80313e7793 100644 --- a/testsuite/pytests/test_connect_array_fixed_indegree.py +++ b/testsuite/pytests/test_connect_array_fixed_indegree.py @@ -25,6 +25,7 @@ """ import unittest + import nest diff --git a/testsuite/pytests/test_connect_array_fixed_outdegree.py b/testsuite/pytests/test_connect_array_fixed_outdegree.py index 9d7985b4f5..f867b4e161 100644 --- a/testsuite/pytests/test_connect_array_fixed_outdegree.py +++ b/testsuite/pytests/test_connect_array_fixed_outdegree.py @@ -25,8 +25,8 @@ """ import unittest -import nest +import nest HAVE_OPENMP = nest.ll_api.sli_func("is_threaded") diff --git a/testsuite/pytests/test_connect_arrays.py b/testsuite/pytests/test_connect_arrays.py index f615fcc30c..23833ce351 100644 --- a/testsuite/pytests/test_connect_arrays.py +++ b/testsuite/pytests/test_connect_arrays.py @@ -20,9 +20,9 @@ # along with NEST. If not, see . import unittest -import numpy as np import nest +import numpy as np nest.set_verbosity("M_WARNING") diff --git a/testsuite/pytests/test_connect_conngen.py b/testsuite/pytests/test_connect_conngen.py index 9067b4b80b..8b8317cf11 100644 --- a/testsuite/pytests/test_connect_conngen.py +++ b/testsuite/pytests/test_connect_conngen.py @@ -24,6 +24,7 @@ """ import unittest + import nest try: diff --git a/testsuite/pytests/test_connect_fixed_indegree.py b/testsuite/pytests/test_connect_fixed_indegree.py index 9920480057..9324f27dc3 100644 --- a/testsuite/pytests/test_connect_fixed_indegree.py +++ b/testsuite/pytests/test_connect_fixed_indegree.py @@ -20,12 +20,12 @@ # along with NEST. If not, see . -import numpy as np import unittest -import scipy.stats + import connect_test_base import nest - +import numpy as np +import scipy.stats HAVE_OPENMP = nest.ll_api.sli_func("is_threaded") diff --git a/testsuite/pytests/test_connect_fixed_outdegree.py b/testsuite/pytests/test_connect_fixed_outdegree.py index bbea1f9989..01240a58d3 100644 --- a/testsuite/pytests/test_connect_fixed_outdegree.py +++ b/testsuite/pytests/test_connect_fixed_outdegree.py @@ -19,12 +19,12 @@ # You should have received a copy of the GNU General Public License # along with NEST. If not, see . -import numpy as np import unittest -import scipy.stats + import connect_test_base import nest - +import numpy as np +import scipy.stats HAVE_OPENMP = nest.ll_api.sli_func("is_threaded") diff --git a/testsuite/pytests/test_connect_fixed_total_number.py b/testsuite/pytests/test_connect_fixed_total_number.py index 30b1d10ba3..d56ade993d 100644 --- a/testsuite/pytests/test_connect_fixed_total_number.py +++ b/testsuite/pytests/test_connect_fixed_total_number.py @@ -19,12 +19,12 @@ # You should have received a copy of the GNU General Public License # along with NEST. If not, see . -import numpy as np import unittest -import scipy.stats + import connect_test_base import nest - +import numpy as np +import scipy.stats HAVE_OPENMP = nest.ll_api.sli_func("is_threaded") diff --git a/testsuite/pytests/test_connect_one_to_one.py b/testsuite/pytests/test_connect_one_to_one.py index 7c1726fc86..7bcce2f8f4 100644 --- a/testsuite/pytests/test_connect_one_to_one.py +++ b/testsuite/pytests/test_connect_one_to_one.py @@ -19,11 +19,11 @@ # You should have received a copy of the GNU General Public License # along with NEST. If not, see . -import numpy as np import unittest + import connect_test_base import nest - +import numpy as np HAVE_OPENMP = nest.ll_api.sli_func("is_threaded") diff --git a/testsuite/pytests/test_connect_pairwise_bernoulli.py b/testsuite/pytests/test_connect_pairwise_bernoulli.py index 21ed8a570b..cb8e2a110e 100644 --- a/testsuite/pytests/test_connect_pairwise_bernoulli.py +++ b/testsuite/pytests/test_connect_pairwise_bernoulli.py @@ -20,12 +20,12 @@ # along with NEST. If not, see . -import numpy as np import unittest -import scipy.stats + import connect_test_base import nest - +import numpy as np +import scipy.stats HAVE_OPENMP = nest.ll_api.sli_func("is_threaded") diff --git a/testsuite/pytests/test_connect_symmetric_pairwise_bernoulli.py b/testsuite/pytests/test_connect_symmetric_pairwise_bernoulli.py index bc62c0a5a6..f7c663fe7d 100644 --- a/testsuite/pytests/test_connect_symmetric_pairwise_bernoulli.py +++ b/testsuite/pytests/test_connect_symmetric_pairwise_bernoulli.py @@ -21,12 +21,12 @@ import collections -import numpy as np import unittest -import scipy.stats + import connect_test_base import nest - +import numpy as np +import scipy.stats HAVE_OPENMP = nest.ll_api.sli_func("is_threaded") diff --git a/testsuite/pytests/test_correlospinmatrix_detector.py b/testsuite/pytests/test_correlospinmatrix_detector.py index 21bd14eb22..289f7529c7 100644 --- a/testsuite/pytests/test_correlospinmatrix_detector.py +++ b/testsuite/pytests/test_correlospinmatrix_detector.py @@ -21,8 +21,8 @@ import nest -import pytest import numpy as np +import pytest def test_correlospinmatrix_detector(): diff --git a/testsuite/pytests/test_create.py b/testsuite/pytests/test_create.py index e169c75b43..ca302db8ce 100644 --- a/testsuite/pytests/test_create.py +++ b/testsuite/pytests/test_create.py @@ -25,6 +25,7 @@ import unittest import warnings + import nest diff --git a/testsuite/pytests/test_current_recording_generators.py b/testsuite/pytests/test_current_recording_generators.py index b753b8796f..40aeeae577 100644 --- a/testsuite/pytests/test_current_recording_generators.py +++ b/testsuite/pytests/test_current_recording_generators.py @@ -23,9 +23,10 @@ Test if currents from generators are being recorded properly """ -import numpy import unittest + import nest +import numpy @nest.ll_api.check_stack diff --git a/testsuite/pytests/test_erfc_neuron.py b/testsuite/pytests/test_erfc_neuron.py index 6d3c565da8..a6ec3f10e8 100644 --- a/testsuite/pytests/test_erfc_neuron.py +++ b/testsuite/pytests/test_erfc_neuron.py @@ -24,6 +24,7 @@ """ import unittest + import nest import numpy as np from scipy.special import erfc diff --git a/testsuite/pytests/test_errors.py b/testsuite/pytests/test_errors.py index 4ea4a5aaa2..f980171226 100644 --- a/testsuite/pytests/test_errors.py +++ b/testsuite/pytests/test_errors.py @@ -24,6 +24,7 @@ """ import unittest + import nest diff --git a/testsuite/pytests/test_events.py b/testsuite/pytests/test_events.py index 04f250c100..0e3ba9f68b 100644 --- a/testsuite/pytests/test_events.py +++ b/testsuite/pytests/test_events.py @@ -24,6 +24,7 @@ """ import unittest + import nest diff --git a/testsuite/pytests/test_facetshw_stdp.py b/testsuite/pytests/test_facetshw_stdp.py index 3bb765c301..d5c794f6f4 100644 --- a/testsuite/pytests/test_facetshw_stdp.py +++ b/testsuite/pytests/test_facetshw_stdp.py @@ -19,9 +19,10 @@ # You should have received a copy of the GNU General Public License # along with NEST. If not, see . +import unittest + import nest import numpy as np -import unittest class FacetsTestCase(unittest.TestCase): diff --git a/testsuite/pytests/test_get_set.py b/testsuite/pytests/test_get_set.py index 1f6deb4bcb..48d424eb4a 100644 --- a/testsuite/pytests/test_get_set.py +++ b/testsuite/pytests/test_get_set.py @@ -23,9 +23,10 @@ NodeCollection get/set tests """ +import json import unittest + import nest -import json try: import numpy as np diff --git a/testsuite/pytests/test_getconnections.py b/testsuite/pytests/test_getconnections.py index 432325ac1d..1f52e9bcc8 100644 --- a/testsuite/pytests/test_getconnections.py +++ b/testsuite/pytests/test_getconnections.py @@ -24,6 +24,7 @@ """ import unittest + import nest nest.set_verbosity("M_ERROR") diff --git a/testsuite/pytests/test_getnodes.py b/testsuite/pytests/test_getnodes.py index 9b29c2c6bf..1eb6143354 100644 --- a/testsuite/pytests/test_getnodes.py +++ b/testsuite/pytests/test_getnodes.py @@ -24,6 +24,7 @@ """ import unittest + import nest diff --git a/testsuite/pytests/test_glif_cond.py b/testsuite/pytests/test_glif_cond.py index 6b6c48aab6..4ee25f3fbe 100644 --- a/testsuite/pytests/test_glif_cond.py +++ b/testsuite/pytests/test_glif_cond.py @@ -20,6 +20,7 @@ # along with NEST. If not, see . import unittest + import nest try: diff --git a/testsuite/pytests/test_glif_psc.py b/testsuite/pytests/test_glif_psc.py index 49d07bec1c..f5bc1f509f 100644 --- a/testsuite/pytests/test_glif_psc.py +++ b/testsuite/pytests/test_glif_psc.py @@ -20,6 +20,7 @@ # along with NEST. If not, see . import unittest + import nest try: diff --git a/testsuite/pytests/test_helper_functions.py b/testsuite/pytests/test_helper_functions.py index 22e8460266..6ab61144ba 100644 --- a/testsuite/pytests/test_helper_functions.py +++ b/testsuite/pytests/test_helper_functions.py @@ -20,6 +20,7 @@ # along with NEST. If not, see . import unittest + import nest diff --git a/testsuite/pytests/test_iaf_singularity.py b/testsuite/pytests/test_iaf_singularity.py index 5190582cea..6af054cf03 100644 --- a/testsuite/pytests/test_iaf_singularity.py +++ b/testsuite/pytests/test_iaf_singularity.py @@ -25,9 +25,9 @@ """ import nest -import pytest import numpy as np import pandas as pd +import pytest @nest.ll_api.check_stack diff --git a/testsuite/pytests/test_json.py b/testsuite/pytests/test_json.py index 920a576dc8..668c4080d7 100644 --- a/testsuite/pytests/test_json.py +++ b/testsuite/pytests/test_json.py @@ -24,6 +24,7 @@ """ import unittest + import nest diff --git a/testsuite/pytests/test_labeled_synapses.py b/testsuite/pytests/test_labeled_synapses.py index 89146ded37..5bfe553c7e 100644 --- a/testsuite/pytests/test_labeled_synapses.py +++ b/testsuite/pytests/test_labeled_synapses.py @@ -24,6 +24,7 @@ """ import unittest + import nest HAVE_GSL = nest.ll_api.sli_func("statusdict/have_gsl ::") diff --git a/testsuite/pytests/test_mc_neuron.py b/testsuite/pytests/test_mc_neuron.py index 9b86b4e3a9..86f51bb14a 100644 --- a/testsuite/pytests/test_mc_neuron.py +++ b/testsuite/pytests/test_mc_neuron.py @@ -20,6 +20,7 @@ # along with NEST. If not, see . import unittest + import nest import numpy as np diff --git a/testsuite/pytests/test_mip_corrdet.py b/testsuite/pytests/test_mip_corrdet.py index e36e6b99a6..613a60e06f 100644 --- a/testsuite/pytests/test_mip_corrdet.py +++ b/testsuite/pytests/test_mip_corrdet.py @@ -26,8 +26,8 @@ import nest -import pytest import numpy.testing as nptest +import pytest def test_correlation_detector_mip(): diff --git a/testsuite/pytests/test_multimeter.py b/testsuite/pytests/test_multimeter.py index f9a9ad4b41..90d3723814 100644 --- a/testsuite/pytests/test_multimeter.py +++ b/testsuite/pytests/test_multimeter.py @@ -19,9 +19,8 @@ # You should have received a copy of the GNU General Public License # along with NEST. If not, see . -import pytest - import nest +import pytest @pytest.fixture diff --git a/testsuite/pytests/test_multiple_synapses.py b/testsuite/pytests/test_multiple_synapses.py index dc8f7cf2a6..c85e9af2b4 100644 --- a/testsuite/pytests/test_multiple_synapses.py +++ b/testsuite/pytests/test_multiple_synapses.py @@ -24,6 +24,7 @@ """ import unittest + import nest diff --git a/testsuite/pytests/test_nodeParametrization.py b/testsuite/pytests/test_nodeParametrization.py index 9378dcdfe4..857b0c4bef 100644 --- a/testsuite/pytests/test_nodeParametrization.py +++ b/testsuite/pytests/test_nodeParametrization.py @@ -23,11 +23,12 @@ Node Parametrization tests """ -import nest -import numpy as np import unittest import warnings +import nest +import numpy as np + class TestNodeParametrization(unittest.TestCase): def setUp(self): diff --git a/testsuite/pytests/test_onetooneconnect.py b/testsuite/pytests/test_onetooneconnect.py index 1dfc96fd7b..06babb5ffc 100644 --- a/testsuite/pytests/test_onetooneconnect.py +++ b/testsuite/pytests/test_onetooneconnect.py @@ -24,6 +24,7 @@ """ import unittest + import nest diff --git a/testsuite/pytests/test_parameter_operators.py b/testsuite/pytests/test_parameter_operators.py index 9865413121..3783e70af3 100644 --- a/testsuite/pytests/test_parameter_operators.py +++ b/testsuite/pytests/test_parameter_operators.py @@ -32,9 +32,10 @@ we can use constant parameters for simplicity. """ +import operator as ops + import nest import pytest -import operator as ops def _const_param(val): diff --git a/testsuite/pytests/test_parrot_neuron.py b/testsuite/pytests/test_parrot_neuron.py index 09a0f7163b..341d6166ac 100644 --- a/testsuite/pytests/test_parrot_neuron.py +++ b/testsuite/pytests/test_parrot_neuron.py @@ -22,9 +22,10 @@ # This script tests the parrot_neuron in NEST. # See test_parrot_neuron_ps.py for an equivalent test of the precise parrot. -import nest -import unittest import math +import unittest + +import nest @nest.ll_api.check_stack diff --git a/testsuite/pytests/test_parrot_neuron_ps.py b/testsuite/pytests/test_parrot_neuron_ps.py index d9cb106a31..27240e4b5e 100644 --- a/testsuite/pytests/test_parrot_neuron_ps.py +++ b/testsuite/pytests/test_parrot_neuron_ps.py @@ -22,9 +22,10 @@ # This script tests the parrot_neuron_ps in NEST. # It is very similar to test_parrot_neuron.py, but uses precise spike times. -import nest -import unittest import math +import unittest + +import nest def _round_up(simtime): diff --git a/testsuite/pytests/test_poisson_generator_campbell_alpha.py b/testsuite/pytests/test_poisson_generator_campbell_alpha.py index 4bc0cc02ba..1c3e427b09 100644 --- a/testsuite/pytests/test_poisson_generator_campbell_alpha.py +++ b/testsuite/pytests/test_poisson_generator_campbell_alpha.py @@ -31,8 +31,8 @@ import nest -import pytest import numpy as np +import pytest def test_poisson_generator_alpha(): diff --git a/testsuite/pytests/test_poisson_generator_ps.py b/testsuite/pytests/test_poisson_generator_ps.py index bab255818b..4ebb36776c 100644 --- a/testsuite/pytests/test_poisson_generator_ps.py +++ b/testsuite/pytests/test_poisson_generator_ps.py @@ -33,8 +33,8 @@ import nest -import pytest import numpy as np +import pytest def test_poisson_generator_ps(): diff --git a/testsuite/pytests/test_poisson_generator_rate_change.py b/testsuite/pytests/test_poisson_generator_rate_change.py index f3e70f4111..d15a15f717 100644 --- a/testsuite/pytests/test_poisson_generator_rate_change.py +++ b/testsuite/pytests/test_poisson_generator_rate_change.py @@ -20,10 +20,11 @@ # along with NEST. If not, see . -import nest import unittest -import scipy.stats + +import nest import numpy as np +import scipy.stats class TestPgRateChange(unittest.TestCase): diff --git a/testsuite/pytests/test_poisson_ps_intervals.py b/testsuite/pytests/test_poisson_ps_intervals.py index 163ebb98f5..314e259470 100644 --- a/testsuite/pytests/test_poisson_ps_intervals.py +++ b/testsuite/pytests/test_poisson_ps_intervals.py @@ -21,9 +21,8 @@ import nest -import pytest import numpy as np - +import pytest """ Name: testsuite::test_poisson_ps_intervals - checks coefficient of variation diff --git a/testsuite/pytests/test_poisson_ps_min_interval.py b/testsuite/pytests/test_poisson_ps_min_interval.py index 08f2087a94..3bb61e8a65 100644 --- a/testsuite/pytests/test_poisson_ps_min_interval.py +++ b/testsuite/pytests/test_poisson_ps_min_interval.py @@ -21,9 +21,8 @@ import nest -import pytest import numpy as np - +import pytest """ Name: testsuite::test_poisson_ps_min_interval - checks that intervals are independent of tic size diff --git a/testsuite/pytests/test_pp_psc_delta.py b/testsuite/pytests/test_pp_psc_delta.py index e8974e6488..7b971514ba 100644 --- a/testsuite/pytests/test_pp_psc_delta.py +++ b/testsuite/pytests/test_pp_psc_delta.py @@ -20,6 +20,7 @@ # along with NEST. If not, see . import unittest + import nest import numpy as np diff --git a/testsuite/pytests/test_pp_psc_delta_stdp.py b/testsuite/pytests/test_pp_psc_delta_stdp.py index 4d08d529fb..898b1ccdc1 100644 --- a/testsuite/pytests/test_pp_psc_delta_stdp.py +++ b/testsuite/pytests/test_pp_psc_delta_stdp.py @@ -20,6 +20,7 @@ # along with NEST. If not, see . import unittest + import nest import numpy as np diff --git a/testsuite/pytests/test_quantal_stp_synapse.py b/testsuite/pytests/test_quantal_stp_synapse.py index f1d6c5dc0b..5ce1f4a146 100644 --- a/testsuite/pytests/test_quantal_stp_synapse.py +++ b/testsuite/pytests/test_quantal_stp_synapse.py @@ -21,9 +21,10 @@ # This script compares the two variants of the Tsodyks/Markram synapse in NEST. +import unittest + import nest import numpy -import unittest @nest.ll_api.check_stack diff --git a/testsuite/pytests/test_random123.py b/testsuite/pytests/test_random123.py index c8b32dcdfd..349fd0b038 100644 --- a/testsuite/pytests/test_random123.py +++ b/testsuite/pytests/test_random123.py @@ -28,8 +28,8 @@ """ import unittest -import nest +import nest try: import scipy.stats diff --git a/testsuite/pytests/test_random_parameter.py b/testsuite/pytests/test_random_parameter.py index 0cfc72fa34..daa7903bfe 100644 --- a/testsuite/pytests/test_random_parameter.py +++ b/testsuite/pytests/test_random_parameter.py @@ -24,6 +24,7 @@ """ import unittest + import nest import numpy as np diff --git a/testsuite/pytests/test_rate_copy_model.py b/testsuite/pytests/test_rate_copy_model.py index de53eb34d1..39bcad06dc 100644 --- a/testsuite/pytests/test_rate_copy_model.py +++ b/testsuite/pytests/test_rate_copy_model.py @@ -19,8 +19,9 @@ # You should have received a copy of the GNU General Public License # along with NEST. If not, see . -import nest import unittest + +import nest import numpy as np diff --git a/testsuite/pytests/test_rate_instantaneous_and_delayed.py b/testsuite/pytests/test_rate_instantaneous_and_delayed.py index c7a37fa037..669765788b 100644 --- a/testsuite/pytests/test_rate_instantaneous_and_delayed.py +++ b/testsuite/pytests/test_rate_instantaneous_and_delayed.py @@ -19,8 +19,9 @@ # You should have received a copy of the GNU General Public License # along with NEST. If not, see . -import nest import unittest + +import nest import numpy as np diff --git a/testsuite/pytests/test_rate_neuron.py b/testsuite/pytests/test_rate_neuron.py index 94700e4978..05f784e300 100644 --- a/testsuite/pytests/test_rate_neuron.py +++ b/testsuite/pytests/test_rate_neuron.py @@ -25,8 +25,9 @@ # standard deviation of the output noise, which already determines the variance # of the rate. -import nest import unittest + +import nest import numpy as np diff --git a/testsuite/pytests/test_rate_neuron_communication.py b/testsuite/pytests/test_rate_neuron_communication.py index c615dc6287..9ccda06064 100644 --- a/testsuite/pytests/test_rate_neuron_communication.py +++ b/testsuite/pytests/test_rate_neuron_communication.py @@ -22,8 +22,9 @@ # This test checks interactions between rate neurons, i.e. # the delay, weight and nonlinearities of rate neurons. -import nest import unittest + +import nest import numpy as np diff --git a/testsuite/pytests/test_recording_backend_ascii.py b/testsuite/pytests/test_recording_backend_ascii.py index 252b228c4c..f87842bcb3 100644 --- a/testsuite/pytests/test_recording_backend_ascii.py +++ b/testsuite/pytests/test_recording_backend_ascii.py @@ -21,6 +21,7 @@ import os import unittest + import nest HAVE_OPENMP = nest.ll_api.sli_func("is_threaded") diff --git a/testsuite/pytests/test_recording_backend_memory.py b/testsuite/pytests/test_recording_backend_memory.py index 19674d4d1b..e75a646d3c 100644 --- a/testsuite/pytests/test_recording_backend_memory.py +++ b/testsuite/pytests/test_recording_backend_memory.py @@ -20,6 +20,7 @@ # along with NEST. If not, see . import unittest + import nest HAVE_OPENMP = nest.ll_api.sli_func("is_threaded") diff --git a/testsuite/pytests/test_recording_backends.py b/testsuite/pytests/test_recording_backends.py index f1a73a65c9..0eec4c792c 100644 --- a/testsuite/pytests/test_recording_backends.py +++ b/testsuite/pytests/test_recording_backends.py @@ -20,6 +20,7 @@ # along with NEST. If not, see . import unittest + import nest HAVE_SIONLIB = nest.ll_api.sli_func("statusdict/have_sionlib ::") diff --git a/testsuite/pytests/test_refractory.py b/testsuite/pytests/test_refractory.py index c673a8d837..825c0ec8cd 100644 --- a/testsuite/pytests/test_refractory.py +++ b/testsuite/pytests/test_refractory.py @@ -21,9 +21,8 @@ import unittest -import numpy as np - import nest +import numpy as np """ Assert that all neuronal models that have a refractory period implement it diff --git a/testsuite/pytests/test_regression_issue-1034.py b/testsuite/pytests/test_regression_issue-1034.py index 7d3743b8c4..4ca862837c 100644 --- a/testsuite/pytests/test_regression_issue-1034.py +++ b/testsuite/pytests/test_regression_issue-1034.py @@ -19,11 +19,12 @@ # You should have received a copy of the GNU General Public License # along with NEST. If not, see . +import unittest + import nest import numpy as np import scipy as sp import scipy.stats -import unittest class PostTraceTester: diff --git a/testsuite/pytests/test_regression_issue-1409.py b/testsuite/pytests/test_regression_issue-1409.py index ae0f63f526..f27d94c12e 100644 --- a/testsuite/pytests/test_regression_issue-1409.py +++ b/testsuite/pytests/test_regression_issue-1409.py @@ -19,9 +19,10 @@ # You should have received a copy of the GNU General Public License # along with NEST. If not, see . +import unittest + import nest import numpy as np -import unittest HAVE_OPENMP = nest.ll_api.sli_func("is_threaded") diff --git a/testsuite/pytests/test_regression_issue-2069.py b/testsuite/pytests/test_regression_issue-2069.py index 292cb80913..df9aa88f8f 100644 --- a/testsuite/pytests/test_regression_issue-2069.py +++ b/testsuite/pytests/test_regression_issue-2069.py @@ -19,9 +19,10 @@ # You should have received a copy of the GNU General Public License # along with NEST. If not, see . -import nest import unittest +import nest + class SynSpecCopyTestCase(unittest.TestCase): def test_syn_spec_copied(self): diff --git a/testsuite/pytests/test_regression_issue-2125.py b/testsuite/pytests/test_regression_issue-2125.py index ac6701af24..ab0339a74d 100644 --- a/testsuite/pytests/test_regression_issue-2125.py +++ b/testsuite/pytests/test_regression_issue-2125.py @@ -19,9 +19,10 @@ # You should have received a copy of the GNU General Public License # along with NEST. If not, see . -import nest import unittest +import nest + HAVE_OPENMP = nest.ll_api.sli_func("is_threaded") diff --git a/testsuite/pytests/test_regression_issue-2480.py b/testsuite/pytests/test_regression_issue-2480.py index 38971dcbb0..190d67a4e6 100644 --- a/testsuite/pytests/test_regression_issue-2480.py +++ b/testsuite/pytests/test_regression_issue-2480.py @@ -19,9 +19,10 @@ # You should have received a copy of the GNU General Public License # along with NEST. If not, see . +import warnings + import nest import pytest -import warnings @pytest.fixture(autouse=True) diff --git a/testsuite/pytests/test_siegert_neuron.py b/testsuite/pytests/test_siegert_neuron.py index f633dce838..787a568ee5 100644 --- a/testsuite/pytests/test_siegert_neuron.py +++ b/testsuite/pytests/test_siegert_neuron.py @@ -21,8 +21,9 @@ # This script tests the siegert_neuron in NEST. -import nest import unittest + +import nest import numpy as np HAVE_GSL = nest.ll_api.sli_func("statusdict/have_gsl ::") diff --git a/testsuite/pytests/test_sonata.py b/testsuite/pytests/test_sonata.py index 27d037439a..7497c64a74 100644 --- a/testsuite/pytests/test_sonata.py +++ b/testsuite/pytests/test_sonata.py @@ -21,9 +21,8 @@ from pathlib import Path -import pytest - import nest +import pytest # Skip all tests in this module if no HDF5 or OpenMP threads pytestmark = [pytest.mark.skipif_missing_hdf5, pytest.mark.skipif_missing_threads] diff --git a/testsuite/pytests/test_sp/test_conn_builder.py b/testsuite/pytests/test_sp/test_conn_builder.py index a2d7470c4d..d2346d4304 100644 --- a/testsuite/pytests/test_sp/test_conn_builder.py +++ b/testsuite/pytests/test_sp/test_conn_builder.py @@ -19,9 +19,10 @@ # You should have received a copy of the GNU General Public License # along with NEST. If not, see . -import nest import unittest +import nest + __author__ = "naveau" diff --git a/testsuite/pytests/test_sp/test_disconnect.py b/testsuite/pytests/test_sp/test_disconnect.py index ec4c5c97f3..80107fcbc4 100644 --- a/testsuite/pytests/test_sp/test_disconnect.py +++ b/testsuite/pytests/test_sp/test_disconnect.py @@ -19,9 +19,10 @@ # You should have received a copy of the GNU General Public License # along with NEST. If not, see . -import nest import unittest +import nest + try: from mpi4py import MPI diff --git a/testsuite/pytests/test_sp/test_disconnect_multiple.py b/testsuite/pytests/test_sp/test_disconnect_multiple.py index b5f9a9eb67..4c3331d21b 100644 --- a/testsuite/pytests/test_sp/test_disconnect_multiple.py +++ b/testsuite/pytests/test_sp/test_disconnect_multiple.py @@ -19,9 +19,10 @@ # You should have received a copy of the GNU General Public License # along with NEST. If not, see . -import nest import unittest +import nest + __author__ = "naveau" diff --git a/testsuite/pytests/test_sp/test_enable_multithread.py b/testsuite/pytests/test_sp/test_enable_multithread.py index ac36ca9dcc..e4fad99d08 100644 --- a/testsuite/pytests/test_sp/test_enable_multithread.py +++ b/testsuite/pytests/test_sp/test_enable_multithread.py @@ -19,9 +19,9 @@ # You should have received a copy of the GNU General Public License # along with NEST. If not, see . -import nest import unittest +import nest __author__ = "sdiaz" diff --git a/testsuite/pytests/test_sp/test_growth_curves.py b/testsuite/pytests/test_sp/test_growth_curves.py index af269f3c4b..7097fcee23 100644 --- a/testsuite/pytests/test_sp/test_growth_curves.py +++ b/testsuite/pytests/test_sp/test_growth_curves.py @@ -19,12 +19,13 @@ # You should have received a copy of the GNU General Public License # along with NEST. If not, see . -from scipy.integrate import quad import math -import numpy -from numpy import testing import unittest + import nest +import numpy +from numpy import testing +from scipy.integrate import quad HAVE_OPENMP = nest.ll_api.sli_func("is_threaded") diff --git a/testsuite/pytests/test_sp/test_sp_manager.py b/testsuite/pytests/test_sp/test_sp_manager.py index 8017e560f1..14f20a3697 100644 --- a/testsuite/pytests/test_sp/test_sp_manager.py +++ b/testsuite/pytests/test_sp/test_sp_manager.py @@ -19,9 +19,10 @@ # You should have received a copy of the GNU General Public License # along with NEST. If not, see . -import nest import unittest +import nest + __author__ = "naveau" diff --git a/testsuite/pytests/test_sp/test_synaptic_elements.py b/testsuite/pytests/test_sp/test_synaptic_elements.py index 152d7cb6ef..0cb66507c6 100644 --- a/testsuite/pytests/test_sp/test_synaptic_elements.py +++ b/testsuite/pytests/test_sp/test_synaptic_elements.py @@ -19,9 +19,10 @@ # You should have received a copy of the GNU General Public License # along with NEST. If not, see . -import nest import unittest +import nest + __author__ = "naveau" diff --git a/testsuite/pytests/test_sp/test_update_synaptic_elements.py b/testsuite/pytests/test_sp/test_update_synaptic_elements.py index 9dbc29d8f3..01e6da138f 100644 --- a/testsuite/pytests/test_sp/test_update_synaptic_elements.py +++ b/testsuite/pytests/test_sp/test_update_synaptic_elements.py @@ -19,9 +19,10 @@ # You should have received a copy of the GNU General Public License # along with NEST. If not, see . -import nest import unittest +import nest + class TestUpdateSynapticElements(unittest.TestCase): def setUp(self): diff --git a/testsuite/pytests/test_spatial/test_SynapseCollection_distance.py b/testsuite/pytests/test_spatial/test_SynapseCollection_distance.py index c83f78b9ac..854c425d48 100644 --- a/testsuite/pytests/test_spatial/test_SynapseCollection_distance.py +++ b/testsuite/pytests/test_spatial/test_SynapseCollection_distance.py @@ -23,10 +23,11 @@ Tests distance between sources and targets of SynapseCollection """ -import pytest import math -import numpy as np + import nest +import numpy as np +import pytest @pytest.fixture(autouse=True) diff --git a/testsuite/pytests/test_spatial/test_basics.py b/testsuite/pytests/test_spatial/test_basics.py index e52649415d..cbc165369d 100644 --- a/testsuite/pytests/test_spatial/test_basics.py +++ b/testsuite/pytests/test_spatial/test_basics.py @@ -24,6 +24,7 @@ """ import unittest + import nest try: diff --git a/testsuite/pytests/test_spatial/test_connect_layers.py b/testsuite/pytests/test_spatial/test_connect_layers.py index 848bd959aa..d76da7dcdb 100644 --- a/testsuite/pytests/test_spatial/test_connect_layers.py +++ b/testsuite/pytests/test_spatial/test_connect_layers.py @@ -23,10 +23,10 @@ """ import unittest + import nest import numpy as np - try: import scipy.stats diff --git a/testsuite/pytests/test_spatial/test_connect_sliced.py b/testsuite/pytests/test_spatial/test_connect_sliced.py index 5e0d690ee6..a3236b0d84 100644 --- a/testsuite/pytests/test_spatial/test_connect_sliced.py +++ b/testsuite/pytests/test_spatial/test_connect_sliced.py @@ -23,6 +23,7 @@ """ import unittest + import nest import numpy as np import numpy.testing as np_testing diff --git a/testsuite/pytests/test_spatial/test_connection_with_elliptical_mask.py b/testsuite/pytests/test_spatial/test_connection_with_elliptical_mask.py index d1c4d11bba..478fc78fe4 100644 --- a/testsuite/pytests/test_spatial/test_connection_with_elliptical_mask.py +++ b/testsuite/pytests/test_spatial/test_connection_with_elliptical_mask.py @@ -24,6 +24,7 @@ """ import unittest + import nest diff --git a/testsuite/pytests/test_spatial/test_create_spatial.py b/testsuite/pytests/test_spatial/test_create_spatial.py index d57e7d7faf..6ba23a93ee 100644 --- a/testsuite/pytests/test_spatial/test_create_spatial.py +++ b/testsuite/pytests/test_spatial/test_create_spatial.py @@ -24,6 +24,7 @@ """ import unittest + import nest diff --git a/testsuite/pytests/test_spatial/test_dumping.py b/testsuite/pytests/test_spatial/test_dumping.py index 7b836ec022..20b7a797a3 100644 --- a/testsuite/pytests/test_spatial/test_dumping.py +++ b/testsuite/pytests/test_spatial/test_dumping.py @@ -23,9 +23,10 @@ Tests for hl_api_spatial dumping functions. """ +import os import unittest + import nest -import os import numpy as np diff --git a/testsuite/pytests/test_spatial/test_layerNodeCollection.py b/testsuite/pytests/test_spatial/test_layerNodeCollection.py index ea5b6db27d..b13b62b719 100644 --- a/testsuite/pytests/test_spatial/test_layerNodeCollection.py +++ b/testsuite/pytests/test_spatial/test_layerNodeCollection.py @@ -24,6 +24,7 @@ """ import unittest + import nest import numpy as np diff --git a/testsuite/pytests/test_spatial/test_layer_GetStatus_SetStatus.py b/testsuite/pytests/test_spatial/test_layer_GetStatus_SetStatus.py index 241f0c986e..b36bd24f42 100644 --- a/testsuite/pytests/test_spatial/test_layer_GetStatus_SetStatus.py +++ b/testsuite/pytests/test_spatial/test_layer_GetStatus_SetStatus.py @@ -24,6 +24,7 @@ """ import unittest + import nest diff --git a/testsuite/pytests/test_spatial/test_plotting.py b/testsuite/pytests/test_spatial/test_plotting.py index 5f4f74ca1a..ec88193180 100644 --- a/testsuite/pytests/test_spatial/test_plotting.py +++ b/testsuite/pytests/test_spatial/test_plotting.py @@ -23,9 +23,9 @@ Tests for basic spatial plotting functions. """ -import pytest import nest import numpy as np +import pytest try: import matplotlib diff --git a/testsuite/pytests/test_spatial/test_rotated_rect_mask.py b/testsuite/pytests/test_spatial/test_rotated_rect_mask.py index 5bd80f6b5c..8412c9c931 100644 --- a/testsuite/pytests/test_spatial/test_rotated_rect_mask.py +++ b/testsuite/pytests/test_spatial/test_rotated_rect_mask.py @@ -24,6 +24,7 @@ """ import unittest + import nest diff --git a/testsuite/pytests/test_spatial/test_selection_function_and_elliptical_mask.py b/testsuite/pytests/test_spatial/test_selection_function_and_elliptical_mask.py index ef6675ca61..6df130f8fe 100644 --- a/testsuite/pytests/test_spatial/test_selection_function_and_elliptical_mask.py +++ b/testsuite/pytests/test_spatial/test_selection_function_and_elliptical_mask.py @@ -24,6 +24,7 @@ """ import unittest + import nest diff --git a/testsuite/pytests/test_spatial/test_spatial_distributions.py b/testsuite/pytests/test_spatial/test_spatial_distributions.py index d4bcb775ed..0e679caca9 100644 --- a/testsuite/pytests/test_spatial/test_spatial_distributions.py +++ b/testsuite/pytests/test_spatial/test_spatial_distributions.py @@ -32,15 +32,14 @@ """ import math +import unittest + +import nest import numpy as np import numpy.random as rnd import scipy.integrate -import scipy.stats import scipy.special -import unittest - -import nest - +import scipy.stats try: # for debugging diff --git a/testsuite/pytests/test_spike_train_injector.py b/testsuite/pytests/test_spike_train_injector.py index 2f3a28bcf7..07e000b0d6 100644 --- a/testsuite/pytests/test_spike_train_injector.py +++ b/testsuite/pytests/test_spike_train_injector.py @@ -27,9 +27,10 @@ simulation. """ +import math + import nest import pytest -import math @pytest.fixture diff --git a/testsuite/pytests/test_split_simulation.py b/testsuite/pytests/test_split_simulation.py index ee85225d39..8ac045357f 100644 --- a/testsuite/pytests/test_split_simulation.py +++ b/testsuite/pytests/test_split_simulation.py @@ -20,6 +20,7 @@ # along with NEST. If not, see . import unittest + import nest diff --git a/testsuite/pytests/test_stack.py b/testsuite/pytests/test_stack.py index 37d8006801..54c94657b5 100644 --- a/testsuite/pytests/test_stack.py +++ b/testsuite/pytests/test_stack.py @@ -24,10 +24,10 @@ """ import unittest -import nest - from array import array +import nest + try: import numpy diff --git a/testsuite/pytests/test_status.py b/testsuite/pytests/test_status.py index 75eabd1360..e0ddf76c8f 100644 --- a/testsuite/pytests/test_status.py +++ b/testsuite/pytests/test_status.py @@ -24,6 +24,7 @@ """ import unittest + import nest diff --git a/testsuite/pytests/test_stdp_nn_synapses.py b/testsuite/pytests/test_stdp_nn_synapses.py index 381517343d..6beb1a55e4 100644 --- a/testsuite/pytests/test_stdp_nn_synapses.py +++ b/testsuite/pytests/test_stdp_nn_synapses.py @@ -22,12 +22,12 @@ # This script tests the stdp_nn_symm_synapse, stdp_nn_pre_centered_synapse, # and stdp_nn_restr_synapse in NEST. +from math import exp + import nest import numpy as np import pytest -from math import exp - @nest.ll_api.check_stack class TestSTDPNNSynapses: diff --git a/testsuite/pytests/test_stdp_synapse.py b/testsuite/pytests/test_stdp_synapse.py index 9924d515f0..ef2206cb28 100644 --- a/testsuite/pytests/test_stdp_synapse.py +++ b/testsuite/pytests/test_stdp_synapse.py @@ -19,8 +19,9 @@ # You should have received a copy of the GNU General Public License # along with NEST. If not, see . -import nest from math import exp + +import nest import numpy as np try: diff --git a/testsuite/pytests/test_stdp_triplet_synapse.py b/testsuite/pytests/test_stdp_triplet_synapse.py index 5e34922c5f..e311298c59 100644 --- a/testsuite/pytests/test_stdp_triplet_synapse.py +++ b/testsuite/pytests/test_stdp_triplet_synapse.py @@ -21,9 +21,10 @@ # This script tests the stdp_triplet_synapse in NEST. -import nest import unittest from math import exp + +import nest import numpy as np diff --git a/testsuite/pytests/test_step_rate_generator.py b/testsuite/pytests/test_step_rate_generator.py index 873a2e6dd7..83d15f876f 100644 --- a/testsuite/pytests/test_step_rate_generator.py +++ b/testsuite/pytests/test_step_rate_generator.py @@ -19,8 +19,9 @@ # You should have received a copy of the GNU General Public License # along with NEST. If not, see . -import nest import unittest + +import nest import numpy as np diff --git a/testsuite/pytests/test_synapsecollection.py b/testsuite/pytests/test_synapsecollection.py index 5652d134ae..67a590d4d8 100644 --- a/testsuite/pytests/test_synapsecollection.py +++ b/testsuite/pytests/test_synapsecollection.py @@ -24,6 +24,7 @@ """ import unittest + import nest try: diff --git a/testsuite/pytests/test_threads.py b/testsuite/pytests/test_threads.py index b243b22d78..dc3d2840cc 100644 --- a/testsuite/pytests/test_threads.py +++ b/testsuite/pytests/test_threads.py @@ -24,6 +24,7 @@ """ import unittest + import nest diff --git a/testsuite/pytests/test_tsodyks2_synapse.py b/testsuite/pytests/test_tsodyks2_synapse.py index 61f28841d3..f5746c7041 100644 --- a/testsuite/pytests/test_tsodyks2_synapse.py +++ b/testsuite/pytests/test_tsodyks2_synapse.py @@ -19,10 +19,11 @@ # You should have received a copy of the GNU General Public License # along with NEST. If not, see . -import numpy as np -import nest import unittest +import nest +import numpy as np + @nest.ll_api.check_stack class Tsodyks2SynapseTest(unittest.TestCase): diff --git a/testsuite/pytests/test_urbanczik_synapse.py b/testsuite/pytests/test_urbanczik_synapse.py index 26a4006d55..0b057fdd0a 100644 --- a/testsuite/pytests/test_urbanczik_synapse.py +++ b/testsuite/pytests/test_urbanczik_synapse.py @@ -24,6 +24,7 @@ """ import unittest + import nest import numpy as np diff --git a/testsuite/pytests/test_visualization.py b/testsuite/pytests/test_visualization.py index acd214501c..7e8be370a5 100644 --- a/testsuite/pytests/test_visualization.py +++ b/testsuite/pytests/test_visualization.py @@ -23,9 +23,10 @@ Tests for visualization functions. """ +import os + import nest import numpy as np -import os import pytest try: diff --git a/testsuite/pytests/test_vogels_sprekeler_synapse.py b/testsuite/pytests/test_vogels_sprekeler_synapse.py index 72981ba212..59cb87e5c1 100644 --- a/testsuite/pytests/test_vogels_sprekeler_synapse.py +++ b/testsuite/pytests/test_vogels_sprekeler_synapse.py @@ -21,10 +21,11 @@ # This script tests the vogels_sprekeler_synapse in NEST. -import nest import unittest from math import exp +import nest + @nest.ll_api.check_stack class VogelsSprekelerConnectionTestCase(unittest.TestCase): diff --git a/testsuite/pytests/test_weight_recorder.py b/testsuite/pytests/test_weight_recorder.py index 57ad6b9288..39ef0d24bc 100644 --- a/testsuite/pytests/test_weight_recorder.py +++ b/testsuite/pytests/test_weight_recorder.py @@ -24,6 +24,7 @@ """ import unittest + import nest import numpy as np diff --git a/testsuite/pytests/test_weights_as_lists.py b/testsuite/pytests/test_weights_as_lists.py index d982661cd2..ec9cc08199 100644 --- a/testsuite/pytests/test_weights_as_lists.py +++ b/testsuite/pytests/test_weights_as_lists.py @@ -24,6 +24,7 @@ """ import unittest + import nest diff --git a/testsuite/pytests/utilities/testsimulation.py b/testsuite/pytests/utilities/testsimulation.py index 0339835bf6..53db86a37b 100644 --- a/testsuite/pytests/utilities/testsimulation.py +++ b/testsuite/pytests/utilities/testsimulation.py @@ -21,9 +21,8 @@ import dataclasses -import numpy as np - import nest +import numpy as np import testutil diff --git a/testsuite/pytests/utilities/testutil.py b/testsuite/pytests/utilities/testutil.py index 58dc2c56f5..9169c50c93 100644 --- a/testsuite/pytests/utilities/testutil.py +++ b/testsuite/pytests/utilities/testutil.py @@ -20,9 +20,10 @@ # along with NEST. If not, see . import dataclasses +import sys + import numpy as np import pytest -import sys def parameter_fixture(name, default_factory=lambda: None): diff --git a/testsuite/regressiontests/issue-1703.py b/testsuite/regressiontests/issue-1703.py index 187d894f7d..099f3205bc 100644 --- a/testsuite/regressiontests/issue-1703.py +++ b/testsuite/regressiontests/issue-1703.py @@ -27,9 +27,9 @@ """ import os -import sys -import subprocess import shlex +import subprocess +import sys EXIT_CODE_SUCCESS = 0 EXIT_CODE_ERROR = 1 diff --git a/testsuite/regressiontests/issue-779-1016.py b/testsuite/regressiontests/issue-779-1016.py index 42fd66ce05..e182bc8cdd 100644 --- a/testsuite/regressiontests/issue-779-1016.py +++ b/testsuite/regressiontests/issue-779-1016.py @@ -26,9 +26,9 @@ This is a regression test for GitHub issues 779 and 1016. """ -from subprocess import check_output, STDOUT -from tempfile import mktemp import sys +from subprocess import STDOUT, check_output +from tempfile import mktemp EXIT_SUCCESS = 0 EXIT_FAILURE = 126 diff --git a/testsuite/summarize_tests.py b/testsuite/summarize_tests.py index 1497601fc4..de26ecfedd 100644 --- a/testsuite/summarize_tests.py +++ b/testsuite/summarize_tests.py @@ -27,11 +27,11 @@ # # -import junitparser as jp import glob import os import sys +import junitparser as jp assert int(jp.version.split(".")[0]) >= 2, "junitparser version must be >= 2" From 0420d7b53e712f09ad396d137abcfb505316a160 Mon Sep 17 00:00:00 2001 From: Nicolai Haug Date: Wed, 9 Aug 2023 18:02:49 +0200 Subject: [PATCH 062/168] Remove dev script --- pynest/examples/dev.py | 5 ----- 1 file changed, 5 deletions(-) delete mode 100644 pynest/examples/dev.py diff --git a/pynest/examples/dev.py b/pynest/examples/dev.py deleted file mode 100644 index 258b92dc78..0000000000 --- a/pynest/examples/dev.py +++ /dev/null @@ -1,5 +0,0 @@ -import matplotlib.pyplot as plt -import nest -import numpy as np -import scipy.special as sp -from matplotlib.patches import Ellipse From 323e4ff122794711e18e806c2cea4e3594d8e916 Mon Sep 17 00:00:00 2001 From: Nicolai Haug Date: Wed, 9 Aug 2023 18:32:10 +0200 Subject: [PATCH 063/168] Fix imports and text --- pynest/examples/gif_pop_psc_exp.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pynest/examples/gif_pop_psc_exp.py b/pynest/examples/gif_pop_psc_exp.py index 0a77646c1b..6867ff4206 100644 --- a/pynest/examples/gif_pop_psc_exp.py +++ b/pynest/examples/gif_pop_psc_exp.py @@ -44,11 +44,11 @@ """ +############################################################################### +# Import necessary modules. import matplotlib.pyplot as plt import nest - -# Loading the necessary modules: import numpy as np ############################################################################### From f5e6fc66272b469eb77071165551fa9977284b2e Mon Sep 17 00:00:00 2001 From: Nicolai Haug Date: Wed, 9 Aug 2023 18:32:28 +0200 Subject: [PATCH 064/168] Skip isort --- pynest/examples/store_restore_network.py | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/pynest/examples/store_restore_network.py b/pynest/examples/store_restore_network.py index 6d4f4f3ad0..cff01bdcdd 100644 --- a/pynest/examples/store_restore_network.py +++ b/pynest/examples/store_restore_network.py @@ -18,6 +18,8 @@ # # You should have received a copy of the GNU General Public License # along with NEST. If not, see . +# +# isort: skip_file """ Store and restore a network simulation @@ -47,18 +49,17 @@ ############################################################################### # Import necessary modules. -import pickle -import textwrap - -import matplotlib.pyplot as plt import nest -import numpy as np -import pandas as pd -from matplotlib import gridspec +import pickle ############################################################################### # These modules are only needed for illustrative plotting. +import matplotlib.pyplot as plt +from matplotlib import gridspec +import numpy as np +import pandas as pd +import textwrap ############################################################################### # Implement network as class. From 2491f761ebda664387b71decc3ed36d578620cab Mon Sep 17 00:00:00 2001 From: Hans Ekkehard Plesser Date: Fri, 25 Aug 2023 13:15:46 +0200 Subject: [PATCH 065/168] Removed assimulo from environment and updated assimulo instructions in notebook. --- .../aeif_models_implementation.ipynb | 97 +++++++++++-------- environment.yml | 1 - 2 files changed, 54 insertions(+), 44 deletions(-) diff --git a/doc/htmldoc/model_details/aeif_models_implementation.ipynb b/doc/htmldoc/model_details/aeif_models_implementation.ipynb index 00d25e4e1d..5f7188dc33 100644 --- a/doc/htmldoc/model_details/aeif_models_implementation.ipynb +++ b/doc/htmldoc/model_details/aeif_models_implementation.ipynb @@ -7,6 +7,7 @@ "# NEST implementation of the `aeif` models\n", "\n", "#### Hans Ekkehard Plesser and Tanguy Fardet, 2016-09-09\n", + "#### Updated by Hans Ekkehard Plesser, 2023-08-25\n", "\n", "This notebook provides a reference solution for the _Adaptive Exponential Integrate and Fire_\n", "(AEIF) neuronal model and compares it with several numerical implementations using simpler solvers.\n", @@ -75,19 +76,9 @@ "\n", "* [numpy](http://www.numpy.org/) and [scipy](http://www.scipy.org/)\n", "* [assimulo](http://www.jmodelica.org/assimulo)\n", - "* [matplotlib](http://matplotlib.org/)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Install assimulo package in the current Jupyter kernel\n", - "import sys\n", + "* [matplotlib](http://matplotlib.org/)\n", "\n", - "!{sys.executable} -m pip install assimulo" + "Note that the last version of Assimulo available from PyPI is version 3.0, which is not compatible with current versions of Python distribution tools. If you use conda/mamba, you can install a current version of Assimulo from `conda-forge`." ] }, { @@ -540,7 +531,15 @@ " Starter : classical\n", "\n", "Simulation interval : 0.0 - 100.0 seconds.\n", - "Elapsed simulation time: 0.07648879801854491 seconds.\n" + "Elapsed simulation time: 0.06999148603063077 seconds.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/5k/0gyqhsf50418tc1x1l1t5lsw0000gn/T/ipykernel_86976/3648738050.py:44: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n", + " t, y = exp_sim.simulate(simtime) # Simulate 10 seconds\n" ] } ], @@ -569,14 +568,12 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -620,14 +617,12 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -682,8 +677,8 @@ "---------------\n", "ref [0.006 0.03 0.025 0.036 0.033 0.031 0.041]\n", "old [ 6.128 5.615 6.107 10.186 17.895 4.997 20.766]\n", - "new [32413643.009 32591616.327 35974587.741 51016349.639 77907589.627\n", - " 37451353.637 11279320.151]\n", + "new [32413643.009 32591616.326 35974587.74 51016349.64 77907589.627\n", + " 37451353.635 11279320.152]\n", "\n", "w at spike time:\n", "---------------\n", @@ -724,14 +719,12 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -757,16 +750,36 @@ "execution_count": 12, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " lsoda-- warning..internal t (=r1) and h (=r2) are\u0000\u0000\n", + " such that in the machine, t + h = t on the next step \n", + " (h = step size). solver will continue anyway\u0000\u0000\n", + " in above, r1 = 0.6691731905434D+02 r2 = 0.4368716407574D-14\n", + " lsoda-- warning..internal t (=r1) and h (=r2) are\u0000\u0000\n", + " such that in the machine, t + h = t on the next step \n", + " (h = step size). solver will continue anyway\u0000\u0000\n", + " in above, r1 = 0.6691731905434D+02 r2 = 0.4368716407574D-14\n", + " lsoda-- warning..internal t (=r1) and h (=r2) are\u0000\u0000\n", + " such that in the machine, t + h = t on the next step \n", + " (h = step size). solver will continue anyway\u0000\u0000\n", + " in above, r1 = 0.6691731905434D+02 r2 = 0.4368716407574D-14\n", + " lsoda-- warning..internal t (=r1) and h (=r2) are\u0000\u0000\n", + " such that in the machine, t + h = t on the next step \n", + " (h = step size). solver will continue anyway\u0000\u0000\n", + " in above, r1 = 0.6691731905434D+02 r2 = 0.4368716407574D-14\n" + ] + }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -802,14 +815,12 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -845,7 +856,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -859,9 +870,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.6" + "version": "3.11.4" } }, "nbformat": 4, - "nbformat_minor": 1 + "nbformat_minor": 4 } diff --git a/environment.yml b/environment.yml index 20bb2638e5..3b2417759c 100644 --- a/environment.yml +++ b/environment.yml @@ -73,7 +73,6 @@ dependencies: # Building NEST documentation - PyYAML>=4.2b1 - - assimulo - breathe - csvkit - docutils From 5a46a2c276a9a95478be10b31089865e68f5eb03 Mon Sep 17 00:00:00 2001 From: Nicolai Haug Date: Tue, 29 Aug 2023 13:01:26 +0200 Subject: [PATCH 066/168] Sort imports --- doc/htmldoc/_ext/extract_api_functions.py | 5 ++--- testsuite/pytests/sli2py_regressions/test_issue_2636_2795.py | 3 +-- testsuite/pytests/sli2py_regressions/test_issue_2637.py | 3 +-- testsuite/pytests/test_iaf_ps_psp_accuracy.py | 5 +++-- testsuite/pytests/test_iaf_ps_psp_poisson_accuracy.py | 5 +++-- 5 files changed, 10 insertions(+), 11 deletions(-) diff --git a/doc/htmldoc/_ext/extract_api_functions.py b/doc/htmldoc/_ext/extract_api_functions.py index 04bd8f2e60..2a39cb43cf 100644 --- a/doc/htmldoc/_ext/extract_api_functions.py +++ b/doc/htmldoc/_ext/extract_api_functions.py @@ -18,12 +18,11 @@ # # You should have received a copy of the GNU General Public License # along with NEST. If not, see . -import os import ast +import glob import json +import os import re -import glob - """ Generate a JSON dictionary that stores the module name as key and corresponding diff --git a/testsuite/pytests/sli2py_regressions/test_issue_2636_2795.py b/testsuite/pytests/sli2py_regressions/test_issue_2636_2795.py index c14dcaa713..af2b798dc2 100644 --- a/testsuite/pytests/sli2py_regressions/test_issue_2636_2795.py +++ b/testsuite/pytests/sli2py_regressions/test_issue_2636_2795.py @@ -40,9 +40,8 @@ The consistency check now addresses the edge case of ``node_id=0``. """ -import pytest - import nest +import pytest @pytest.mark.parametrize("node_id", [0, 1]) diff --git a/testsuite/pytests/sli2py_regressions/test_issue_2637.py b/testsuite/pytests/sli2py_regressions/test_issue_2637.py index e84674acb6..44a813f6ea 100644 --- a/testsuite/pytests/sli2py_regressions/test_issue_2637.py +++ b/testsuite/pytests/sli2py_regressions/test_issue_2637.py @@ -26,11 +26,10 @@ a Python ``list`` of NumPy integers. """ +import nest import numpy as np import pytest -import nest - @pytest.mark.parametrize("dtype", [int, np.int32, np.int64]) def test_nc_slice_list_of_numpy_ints(dtype): diff --git a/testsuite/pytests/test_iaf_ps_psp_accuracy.py b/testsuite/pytests/test_iaf_ps_psp_accuracy.py index b7ef4c53d4..d67679533b 100644 --- a/testsuite/pytests/test_iaf_ps_psp_accuracy.py +++ b/testsuite/pytests/test_iaf_ps_psp_accuracy.py @@ -63,11 +63,12 @@ SeeAlso: testsuite::test_iaf_psp, testsuite::test_iaf_ps_dc_accuracy """ -import nest -import pytest import math from math import exp +import nest +import pytest + # Global parameters T1 = 3.0 T2 = 6.0 diff --git a/testsuite/pytests/test_iaf_ps_psp_poisson_accuracy.py b/testsuite/pytests/test_iaf_ps_psp_poisson_accuracy.py index c9aaeeee28..8dcc3f03f3 100644 --- a/testsuite/pytests/test_iaf_ps_psp_poisson_accuracy.py +++ b/testsuite/pytests/test_iaf_ps_psp_poisson_accuracy.py @@ -47,11 +47,12 @@ """ -import nest -import pytest import math from math import exp +import nest +import pytest + DEBUG = False # Global parameters From da8abd39973dba94c4dcb46292e9d6223697a213 Mon Sep 17 00:00:00 2001 From: Hans Ekkehard Plesser Date: Wed, 30 Aug 2023 23:36:38 +0200 Subject: [PATCH 067/168] Rephrased text on assimulo versions --- doc/htmldoc/model_details/aeif_models_implementation.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/htmldoc/model_details/aeif_models_implementation.ipynb b/doc/htmldoc/model_details/aeif_models_implementation.ipynb index 5f7188dc33..38f1bce242 100644 --- a/doc/htmldoc/model_details/aeif_models_implementation.ipynb +++ b/doc/htmldoc/model_details/aeif_models_implementation.ipynb @@ -78,7 +78,7 @@ "* [assimulo](http://www.jmodelica.org/assimulo)\n", "* [matplotlib](http://matplotlib.org/)\n", "\n", - "Note that the last version of Assimulo available from PyPI is version 3.0, which is not compatible with current versions of Python distribution tools. If you use conda/mamba, you can install a current version of Assimulo from `conda-forge`." + "The assimulo package from PyPI is quite old and cannot be installed with current versions of Python distribution tools. If you use conda/mamba, you can install a current version of Assimulo from `conda-forge`. We have tested this notebook with assimulo 3.4.1." ] }, { From 8edff3f702144dc4e2c8492bea2922a993237921 Mon Sep 17 00:00:00 2001 From: Nicolai Haug Date: Tue, 12 Sep 2023 16:05:58 +0200 Subject: [PATCH 068/168] Fix merge error --- testsuite/pytests/test_multimeter.py | 1 + 1 file changed, 1 insertion(+) diff --git a/testsuite/pytests/test_multimeter.py b/testsuite/pytests/test_multimeter.py index 3d377de227..9cbcacece2 100644 --- a/testsuite/pytests/test_multimeter.py +++ b/testsuite/pytests/test_multimeter.py @@ -19,6 +19,7 @@ # You should have received a copy of the GNU General Public License # along with NEST. If not, see . +import nest import numpy.testing as nptest import pytest From 51ebf1c27bcd07982726c6f7727c2a93743e88e5 Mon Sep 17 00:00:00 2001 From: Nicolai Haug Date: Wed, 13 Sep 2023 09:54:45 +0200 Subject: [PATCH 069/168] Run isort --- doc/htmldoc/_ext/extractor_userdocs.py | 1 - doc/htmldoc/_ext/list_examples.py | 9 ++++----- testsuite/pytests/sli2py_regressions/test_ticket_459.py | 3 +-- 3 files changed, 5 insertions(+), 8 deletions(-) diff --git a/doc/htmldoc/_ext/extractor_userdocs.py b/doc/htmldoc/_ext/extractor_userdocs.py index 871a5b2265..160982a645 100644 --- a/doc/htmldoc/_ext/extractor_userdocs.py +++ b/doc/htmldoc/_ext/extractor_userdocs.py @@ -31,7 +31,6 @@ from tqdm import tqdm - logging.basicConfig(level=logging.WARNING) log = logging.getLogger(__name__) diff --git a/doc/htmldoc/_ext/list_examples.py b/doc/htmldoc/_ext/list_examples.py index 95dcec0840..0775fc5735 100644 --- a/doc/htmldoc/_ext/list_examples.py +++ b/doc/htmldoc/_ext/list_examples.py @@ -19,15 +19,14 @@ # You should have received a copy of the GNU General Public License # along with NEST. If not, see . +import glob +import logging +import os + from docutils import nodes from docutils.parsers.rst import Directive, Parser - from sphinx.application import Sphinx from sphinx.util.docutils import SphinxDirective -import os -import glob - -import logging logging.basicConfig(level=logging.WARNING) log = logging.getLogger(__name__) diff --git a/testsuite/pytests/sli2py_regressions/test_ticket_459.py b/testsuite/pytests/sli2py_regressions/test_ticket_459.py index 103a0497e3..ae75759f3d 100644 --- a/testsuite/pytests/sli2py_regressions/test_ticket_459.py +++ b/testsuite/pytests/sli2py_regressions/test_ticket_459.py @@ -23,9 +23,8 @@ Test that changing E_L in any neuron with this parameter leaves all other parameters unchanged. """ -import pytest - import nest +import pytest @pytest.fixture(autouse=True) From 6b4262a9cefc2e8b2f757f67b8177b146d3d6cea Mon Sep 17 00:00:00 2001 From: Nicolai Haug Date: Wed, 13 Sep 2023 13:57:07 +0200 Subject: [PATCH 070/168] Let isort modify files --- .pre-commit-config.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 2f00e71081..463d0b094e 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -3,7 +3,7 @@ repos: rev: 5.12.0 hooks: - id: isort - args: ["--profile", "black", "--thirdparty", "nest", "--check-only", "--diff"] + args: ["--profile", "black", "--thirdparty", "nest", "--diff"] - repo: https://github.com/psf/black rev: 23.7.0 hooks: From a6ad33310906123cc8ece0be27679777a123f330 Mon Sep 17 00:00:00 2001 From: Nicolai Haug Date: Wed, 13 Sep 2023 13:57:56 +0200 Subject: [PATCH 071/168] State required clang-format version --- build_support/format_all_c_c++_files.sh | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/build_support/format_all_c_c++_files.sh b/build_support/format_all_c_c++_files.sh index ed2b659c2a..b25942a653 100755 --- a/build_support/format_all_c_c++_files.sh +++ b/build_support/format_all_c_c++_files.sh @@ -2,10 +2,15 @@ # With this script you can easily format all C/C++ files contained in # any (sub)directory of NEST. Internally it uses clang-format to do -# the actual formatting. You can give a different clang-format command, -# e.g. by executing `CLANG_FORMAT=clang-format-14 ./format_all_c_c++_files.sh`. +# the actual formatting. +# +# NEST C/C++ code should be formatted according to clang-format version 13.0.0. +# If you would like to see how the code will be formatted with a different +# clang-format version, execute e.g. `CLANG_FORMAT=clang-format-14 ./format_all_c_c++_files.sh`. +# # By default the script starts at the current working directory ($PWD), but # supply a different starting directory as the first argument to the command. + CLANG_FORMAT=${CLANG_FORMAT:-clang-format} CLANG_FORMAT_FILE=${CLANG_FORMAT_FILE:-.clang-format} From 0711a7fdaec640122941d59e2f89f9583c35ec98 Mon Sep 17 00:00:00 2001 From: Nicolai Haug Date: Wed, 13 Sep 2023 13:58:48 +0200 Subject: [PATCH 072/168] Update required dev tools doc --- .../guidelines/coding_guidelines_check.rst | 107 +++++++++--------- doc/htmldoc/developer_space/index.rst | 2 +- 2 files changed, 57 insertions(+), 52 deletions(-) diff --git a/doc/htmldoc/developer_space/guidelines/coding_guidelines_check.rst b/doc/htmldoc/developer_space/guidelines/coding_guidelines_check.rst index 08ad072266..963b5f5811 100644 --- a/doc/htmldoc/developer_space/guidelines/coding_guidelines_check.rst +++ b/doc/htmldoc/developer_space/guidelines/coding_guidelines_check.rst @@ -1,92 +1,97 @@ -.. _check_code: +.. _required_dev_tools: -Check your code -=============== +Required development tools +========================== -Below, we provide tools and scripts that you can use to check the formatting of your code. -Before you get started, please take a look at our :ref:`detailed guidelines for C++ coding in NEST ` +Here, we list required tools for NEST development and explain their usage. The +tools are mostly for formatting your code. Before you get started, please take +a look at our :ref:`detailed guidelines for C++ coding in NEST `. Development environment ----------------------- -We have provided an `environment.yml `_ file that contains all packages to do development -in NEST, including the tools to check coding style. +We have provided an `environment.yml `_ +file that contains all packages to do development in NEST, including the tools listed below. See our :ref:`instructions on installing NEST from source `. - Tooling ------- -The `clang-format `_ tool is built -on the clang compiler frontend. It prettyprints input files in a -configurable manner, and also has Vim and Emacs integration. We supply a -clang-format-file (```` to enforce some parts of the coding style. During -the code review process we check that there is no difference between the committed -files and the formatted version of the committed files. - +pre-commit +~~~~~~~~~~ -Developers can benefit from the tool by formatting their changes -before issuing a pull request. For fixing more files at once we -provide a script that applies the formatting. +We use `pre-commit `_ to run Git hooks on every commit to identify simple issues such as +trailing whitespace or not complying with the required formatting. Our ``pre-commit`` configuration is +specified in the `.pre-commit-config.yaml `_ +file. -From the source directory call: +To set up the Git hook scripts specified in ``.pre-commit-config.yaml``, run -.. code:: +.. code-block:: bash - ./build_support/format_all_c_c++_files.sh [start folder, defaults to '$PWD'] + pre-commit install -The code has to compile without warnings (in the default settings of the build -infrastructure). We restrict ourselves to the C++11 standard for a larger support of -compilers on various cluster systems and supercomputers. +.. note:: -We use clang-format version 13 in our CI. If your `clang-format` executable is not version 13, you need to specify an executable with version 13 explicitly with the `--clang-format` option to ensure consistency with the NEST CI. + If ``pre-commit`` identifies formatting issues in the commited code, the ``pre-commit`` Git hooks will reformat + the code. If code is reformatted, it will show up in your unstaged changes. Stage them and recommit to + successfully commit your code. -Furthermore, we use `Vera++ `_, which -'is a programmable tool for verification, analysis and transformation of C++ -source code'. It enables further checks for the code complying to the coding -guidelines. We provide the vera-profile-nest (````) file in the -repository (which needs to be copied/symlinked into ``vera++home>/lib/vera++/profiles/``). -We then check that there are no messages generated by the execution of the following command: +Black +~~~~~ -.. code:: sh +We enforce `PEP8 `_ formatting of Python code by using the uncompromising +`Black `_ formatter. - vera++ -profile nest +``Black`` is run automatically with ``pre-commit``. +Run ``Black`` manually with -Finally, we let `cppcheck `_ statically analyse -the committed files and check for severe errors. We require cppcheck version -1.69 or later. +.. code-block:: bash -.. code:: sh + black . - cppcheck --enable=all +isort +~~~~~ +We use `isort `_ to sort imports in Python code. -Python ------- +``isort`` is run automatically with ``pre-commit``. -We enforce `PEP8 `_ formatting, using `Black -`_. You can automatically have your code reformatted before -you commit using pre-commit hooks: +Run ``isort`` manually with .. code-block:: bash - pip install pre-commit - pre-commit install + isort --profile=black --thirdparty="nest" . + +clang-format +~~~~~~~~~~~~ + +We use `clang-format `_ to format C/C++ code. +Our ``clang-format`` configuration is specified in the +`.clang-format `_ file. + +``clang-format`` is run automatically with ``pre-commit``. -Now, whenever you commit, Black will check your code. If something was reformatted it -will show up in your unstaged changes. Stage them and recommit to succesfully commit -your code. Alternatively, you can run black manually: +We supply the +`build_support/format_all_c_c++_files.sh `_ +shell script to run ``clang-format`` manually: .. code-block:: bash - pip install black - black . + ./build_support/format_all_c_c++_files.sh [start folder, defaults to '$PWD'] + +.. note:: + We use ``clang-format`` version 13.0.0 in our CI. If your ``clang-format`` executable is + not version 13, you need to specify an executable with version 13.0.0 explicitly with + the `--clang-format` option to ensure consistency with the NEST CI. Local static analysis --------------------- -To run local static code checks, please refer to the "run" lines in the GitHub Actions CI definition at https://github.com/nest/nest-simulator/blob/master/.github/workflows/nestbuildmatrix.yml. +We have several static code analyzers in the GitHub Actions CI. To run static code checks locally, +please refer to the "run" lines in the GitHub Actions CI definition at +https://github.com/nest/nest-simulator/blob/master/.github/workflows/nestbuildmatrix.yml. diff --git a/doc/htmldoc/developer_space/index.rst b/doc/htmldoc/developer_space/index.rst index 085186d23c..808ad16670 100644 --- a/doc/htmldoc/developer_space/index.rst +++ b/doc/htmldoc/developer_space/index.rst @@ -51,7 +51,7 @@ Please familiarize yourself with our guides and workflows: * Follow the :ref:`C++ coding style guidelines ` * Review the :ref:`naming conventions for NEST ` * Writing an extension module? See :doc:`extmod:index` - * :ref:`check_code` to ensure correct formatting + * :ref:`required_dev_tools` .. grid-item-card:: Contribute documentation From 6b0c69eaae0b7e4a2b56767452bf8fd2b563c613 Mon Sep 17 00:00:00 2001 From: Nicolai Haug Date: Wed, 13 Sep 2023 14:04:32 +0200 Subject: [PATCH 073/168] Run isort --- testsuite/pytests/test_spike_transmission.py | 1 - 1 file changed, 1 deletion(-) diff --git a/testsuite/pytests/test_spike_transmission.py b/testsuite/pytests/test_spike_transmission.py index 590283da1b..58b95e7f1a 100644 --- a/testsuite/pytests/test_spike_transmission.py +++ b/testsuite/pytests/test_spike_transmission.py @@ -26,7 +26,6 @@ import nest import pytest - # This is a hack until I find out how to use the have_threads fixture to # implement this switch. Then, one should also see if we can parametrize # the entire class instead of parametrizing each test in the class in the From 3a0c0cc13614e2a3b094dd6905888de9a84340c1 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Tue, 25 Oct 2022 15:18:43 +0200 Subject: [PATCH 074/168] Add env EXEC_SCRIPT --- pynest/nest/server/hl_api_server.py | 36 +++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index d167ef4d91..9e34c4252a 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -42,6 +42,7 @@ import os +<<<<<<< HEAD MODULES = os.environ.get("NEST_SERVER_MODULES", "nest").split(",") RESTRICTION_OFF = bool(os.environ.get("NEST_SERVER_RESTRICTION_OFF", False)) EXCEPTION_ERROR_STATUS = 400 @@ -50,6 +51,29 @@ msg = "NEST Server runs without a RestrictedPython trusted environment." print(f"***\n*** WARNING: {msg}\n***") +======= +def get_boolean_environ(env_key, default_value = 'false'): + env_value = os.environ.get(env_key, default_value) + return env_value.lower() in ['yes', 'true', 't', '1'] + +EXEC_SCRIPT = get_boolean_environ('NEST_SERVER_EXEC_SCRIPT') +MODULES = os.environ.get('NEST_SERVER_MODULES', 'nest').split(',') +RESTRICTION_OFF = get_boolean_environ('NEST_SERVER_RESTRICTION_OFF') +EXCEPTION_ERROR_STATUS = 400 + +if EXEC_SCRIPT: + print(80 * '*') + msg = ("\n" + 9*" ").join([ + 'NEST Server runs with the `exec` command activated.', + 'This means that any code can be executed!', + 'The security of your system can not be ensured!' + ]) + print(f'WARNING: {msg}') + if RESTRICTION_OFF: + msg = 'NEST Server runs without a RestrictedPython trusted environment.' + print(f'WARNING: {msg}') + print(80 * '*') +>>>>>>> f3abc5e61 (Add env EXEC_SCRIPT) __all__ = [ "app", @@ -169,9 +193,21 @@ def do_call(call_name, args=[], kwargs={}): def route_exec(): """Route to execute script in Python.""" +<<<<<<< HEAD args, kwargs = get_arguments(request) response = do_call("exec", args, kwargs) return jsonify(response) +======= + if EXEC_SCRIPT: + args, kwargs = get_arguments(request) + response = do_call('exec', args, kwargs) + return jsonify(response) + else: + abort(Response( + 'The route `/exec` has been disabled. Please contact the server administrator.', + 403 + )) +>>>>>>> f3abc5e61 (Add env EXEC_SCRIPT) # -------------------------- From d21a4f5d126c6374bcb2a5ebe09e421e18a06874 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Tue, 25 Oct 2022 15:18:59 +0200 Subject: [PATCH 075/168] Cleanup nest-server --- bin/nest-server | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bin/nest-server b/bin/nest-server index 9d8734b1b8..4c226a37c7 100755 --- a/bin/nest-server +++ b/bin/nest-server @@ -56,7 +56,7 @@ start() { if [ "${DAEMON}" -eq 0 ]; then echo "Use CTRL + C to stop this service." if [ "${STDOUT}" -eq 1 ]; then - echo "-------------------------------------------------" + echo "-----------------------------------------------------" fi fi From 2e088e56ecee365481f6c0a18a36eaaac7d4b2ca Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Tue, 25 Oct 2022 15:19:08 +0200 Subject: [PATCH 076/168] Add changes for v3.4 --- doc/htmldoc/whats_new/v3.4/index.rst | 58 ++++++++++------------------ 1 file changed, 20 insertions(+), 38 deletions(-) diff --git a/doc/htmldoc/whats_new/v3.4/index.rst b/doc/htmldoc/whats_new/v3.4/index.rst index be69bbaa9a..ae80fe734b 100644 --- a/doc/htmldoc/whats_new/v3.4/index.rst +++ b/doc/htmldoc/whats_new/v3.4/index.rst @@ -17,10 +17,11 @@ If you transition from an earlier version, please see our extensive Documentation restructuring and new theme ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -NEST documentation has a new theme! We did a major overhaul of the -layout and structure of the documentation. The changes aim to improve -findability and access of content. With a more modern layout, our wide -range of docs can be discovered more easily. +NEST documentation has a new theme! We did a major overhaul of the layout and structure of the documentation. +The changes aim to improve findability and access of content. With a more modern +layout, our wide range of docs can be discovered more easily. +The table of contents is simplified and the content is grouped based on topic (neurons, synapses etc) +rather than type of documentation (e.g., 'guides'). The table of contents is simplified and the content is grouped based on topics (neurons, synapses etc) rather than type of documentation @@ -35,10 +36,12 @@ GitHub Query spatially structured networks from target neuron perspective ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -PyNEST now provides functions :py:func:`.GetSourceNodes`, -:py:func:`.GetSourcePositions`, and :py:func:`.PlotSources` which -allow you to query or plot the source neurons of a given target -neuron. +Spatial layers can be created by specifying only the node positions using ``spatial.free``, +without explicitly specifying the ``extent``. +In that case, in NEST 3.4 and later, the ``extent`` will be determined by the position of the +lower-leftmost and upper-rightmost nodes in the layer; earlier versions of NEST added a hard-coded +padding to the extent. The ``center`` is computed as the midpoint between the lower-leftmost and +upper-rightmost nodes. Extent and center for spatial layers with freely placed neurons ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -53,36 +56,15 @@ and upper-rightmost nodes in the layer, if omitted. While earlier versions of NEST added a hard-coded padding, NEST 3.4 will only use the node positions. -Likewise, the ``center`` of a layer is now automatically computed as -the midpoint between the lower-leftmost and the upper-rightmost nodes. +* Model ``spike_dilutor`` is now deprecated and can only be used + in single-threaded mode. To implement connections which transmit + spikes with fixed probability, use ``bernoulli_synapse`` instead. -When creating a layer with only a single node, the ``extent`` still -has to be specified explicitly. -Disconnect with ``SynapseCollection`` -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Changes in NEST Server +~~~~~~~~~~~~~~~~~~~~~~ -It is now possible to disconnect nodes using a ``SynapseCollection`` -as argument to either :py:func:`.disconnect` or the member function -``disconnect()`` of the ``SynapseCollection``. - -Removal of deprecated models -~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -* The models ``iaf_psc_alpha_canon`` and ``pp_pop_psc_delta`` have - long been deprecated and were now removed from NEST. In case you - depend on them, you will find similar functionality in the - replacement models :doc:`iaf_psc_alpha_ps - ` and :doc:`iaf_psc_alpha_ps - `, respectively. - -* Model ``spike_dilutor`` is now deprecated and can only be used in - single-threaded mode. To implement connections which transmit spikes - with fixed probability, use :doc:`bernoulli_synapse - ` instead. - -Changed port of NEST Server -~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -To avoid conflicts with other services, the default port for NEST -Server has been changed from 5000 to 52025. +* By default NEST Server runs on port 52425 (previously 5000). +* Minimize security risk in NEST Server. + * By default exec call is disabled, only API calls are enabled. + * The user is able to turn on exec call which means that the user is aware of the risk. From 9fad24cbf3385d0aa21d443f24a49d05a28d4df2 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Thu, 27 Oct 2022 12:18:52 +0200 Subject: [PATCH 077/168] Set Origins in CORS --- pynest/nest/server/hl_api_server.py | 28 +++++++++------------------- 1 file changed, 9 insertions(+), 19 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 9e34c4252a..59397b4694 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -42,20 +42,11 @@ import os -<<<<<<< HEAD -MODULES = os.environ.get("NEST_SERVER_MODULES", "nest").split(",") -RESTRICTION_OFF = bool(os.environ.get("NEST_SERVER_RESTRICTION_OFF", False)) -EXCEPTION_ERROR_STATUS = 400 - -if RESTRICTION_OFF: - msg = "NEST Server runs without a RestrictedPython trusted environment." - print(f"***\n*** WARNING: {msg}\n***") - -======= def get_boolean_environ(env_key, default_value = 'false'): env_value = os.environ.get(env_key, default_value) return env_value.lower() in ['yes', 'true', 't', '1'] +CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', 'localhost') EXEC_SCRIPT = get_boolean_environ('NEST_SERVER_EXEC_SCRIPT') MODULES = os.environ.get('NEST_SERVER_MODULES', 'nest').split(',') RESTRICTION_OFF = get_boolean_environ('NEST_SERVER_RESTRICTION_OFF') @@ -73,7 +64,6 @@ def get_boolean_environ(env_key, default_value = 'false'): msg = 'NEST Server runs without a RestrictedPython trusted environment.' print(f'WARNING: {msg}') print(80 * '*') ->>>>>>> f3abc5e61 (Add env EXEC_SCRIPT) __all__ = [ "app", @@ -84,12 +74,18 @@ def get_boolean_environ(env_key, default_value = 'false'): ] app = Flask(__name__) -CORS(app) +CORS(app, resources={r"/*": {"origins": f"{CORS_ORIGINS}"}) mpi_comm = None -@app.route("/", methods=["GET"]) +@app.after_request +def add_header(response): + response.headers['Access-Control-Allow-Origin'] = CORS_ORIGINS + return response + + +@app.route('/', methods=['GET']) def index(): return jsonify( { @@ -193,11 +189,6 @@ def do_call(call_name, args=[], kwargs={}): def route_exec(): """Route to execute script in Python.""" -<<<<<<< HEAD - args, kwargs = get_arguments(request) - response = do_call("exec", args, kwargs) - return jsonify(response) -======= if EXEC_SCRIPT: args, kwargs = get_arguments(request) response = do_call('exec', args, kwargs) @@ -207,7 +198,6 @@ def route_exec(): 'The route `/exec` has been disabled. Please contact the server administrator.', 403 )) ->>>>>>> f3abc5e61 (Add env EXEC_SCRIPT) # -------------------------- From 7c8a3aa55f27e50e05cfd1fdb32c30c09f87cfef Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Thu, 27 Oct 2022 12:58:53 +0200 Subject: [PATCH 078/168] Add cross origin for / --- pynest/nest/server/hl_api_server.py | 1 + 1 file changed, 1 insertion(+) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 59397b4694..16225fe07a 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -86,6 +86,7 @@ def add_header(response): @app.route('/', methods=['GET']) +@cross_origin() def index(): return jsonify( { From 9b93d9159466ec7598f0892012fbe4464ff1a787 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Thu, 27 Oct 2022 14:53:42 +0200 Subject: [PATCH 079/168] Extend cors_origins --- pynest/nest/server/hl_api_server.py | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 16225fe07a..249690ef40 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -46,7 +46,7 @@ def get_boolean_environ(env_key, default_value = 'false'): env_value = os.environ.get(env_key, default_value) return env_value.lower() in ['yes', 'true', 't', '1'] -CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', 'localhost') +CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', 'http://localhost:8000').split(',') EXEC_SCRIPT = get_boolean_environ('NEST_SERVER_EXEC_SCRIPT') MODULES = os.environ.get('NEST_SERVER_MODULES', 'nest').split(',') RESTRICTION_OFF = get_boolean_environ('NEST_SERVER_RESTRICTION_OFF') @@ -74,14 +74,22 @@ def get_boolean_environ(env_key, default_value = 'false'): ] app = Flask(__name__) -CORS(app, resources={r"/*": {"origins": f"{CORS_ORIGINS}"}) +CORS(app, CORS_ORIGINS=CORS_ORIGINS) mpi_comm = None @app.after_request -def add_header(response): - response.headers['Access-Control-Allow-Origin'] = CORS_ORIGINS +def cors_origin(response): + # https://kurianbenoy.com/2021-07-04-CORS/ + response.headers["Access-Control-Allow-Origin"] = "null" + request_origin = request.headers['Origin'] + if len(CORS_ORIGINS) == 0 or "*" in CORS_ORIGINS: + response.headers["Access-Control-Allow-Origin"] = "*" + else: + for allowed_origin in CORS_ORIGINS: + if allowed_origin in request_origin: + response.headers["Access-Control-Allow-Origin"] = allowed_origin return response From 754f3b6cfb79c927dead9db07b05c246ce8b84b1 Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Thu, 27 Oct 2022 15:18:56 +0200 Subject: [PATCH 080/168] Display Python `logging`, even while server is active. --- pynest/nest/server/hl_api_server.py | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 249690ef40..ee3a4dea13 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -22,11 +22,18 @@ import ast import importlib import inspect +import logging import io import sys from flask import Flask, request, jsonify from flask_cors import CORS, cross_origin +from flask.logging import default_handler + +# This ensures that the logging information shows up in the console running the server, +# even when Flask's event loop is running. +root = logging.getLogger() +root.addHandler(default_handler) from werkzeug.exceptions import abort from werkzeug.wrappers import Response From 2e34bab261c62a8b3ef7131859770a18538f339d Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Thu, 27 Oct 2022 15:27:19 +0200 Subject: [PATCH 081/168] Apply CORS headers --- pynest/nest/server/hl_api_server.py | 30 ++++++++--------------------- 1 file changed, 8 insertions(+), 22 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index ee3a4dea13..430fd223e3 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -27,7 +27,7 @@ import sys from flask import Flask, request, jsonify -from flask_cors import CORS, cross_origin +from flask_cors import CORS from flask.logging import default_handler # This ensures that the logging information shows up in the console running the server, @@ -53,7 +53,8 @@ def get_boolean_environ(env_key, default_value = 'false'): env_value = os.environ.get(env_key, default_value) return env_value.lower() in ['yes', 'true', 't', '1'] -CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', 'http://localhost:8000').split(',') +_default_origins = 'localhost,http://localhost,https://localhost' +CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', _default_origins).split(',') EXEC_SCRIPT = get_boolean_environ('NEST_SERVER_EXEC_SCRIPT') MODULES = os.environ.get('NEST_SERVER_MODULES', 'nest').split(',') RESTRICTION_OFF = get_boolean_environ('NEST_SERVER_RESTRICTION_OFF') @@ -81,27 +82,14 @@ def get_boolean_environ(env_key, default_value = 'false'): ] app = Flask(__name__) -CORS(app, CORS_ORIGINS=CORS_ORIGINS) +# Inform client-side user agents that they should not attempt to call our server from any +# non-whitelisted domain. +CORS(app, origins=CORS_ORIGINS, methods=["GET", "POST"]) mpi_comm = None -@app.after_request -def cors_origin(response): - # https://kurianbenoy.com/2021-07-04-CORS/ - response.headers["Access-Control-Allow-Origin"] = "null" - request_origin = request.headers['Origin'] - if len(CORS_ORIGINS) == 0 or "*" in CORS_ORIGINS: - response.headers["Access-Control-Allow-Origin"] = "*" - else: - for allowed_origin in CORS_ORIGINS: - if allowed_origin in request_origin: - response.headers["Access-Control-Allow-Origin"] = allowed_origin - return response - - @app.route('/', methods=['GET']) -@cross_origin() def index(): return jsonify( { @@ -200,8 +188,7 @@ def do_call(call_name, args=[], kwargs={}): return combine(call_name, response) -@app.route("/exec", methods=["GET", "POST"]) -@cross_origin() +@app.route('/exec', methods=['GET', 'POST']) def route_exec(): """Route to execute script in Python.""" @@ -232,8 +219,7 @@ def route_api(): return jsonify(nest_calls) -@app.route("/api/", methods=["GET", "POST"]) -@cross_origin() +@app.route('/api/', methods=['GET', 'POST']) def route_api_call(call): """Route to call function in NEST.""" print(f"\n{'='*40}\n", flush=True) From dc55bce056ed2b513efa4a17509e3449aaf58405 Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Thu, 27 Oct 2022 15:35:48 +0200 Subject: [PATCH 082/168] forgot 1 --- pynest/nest/server/hl_api_server.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 430fd223e3..1bf8ab6297 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -212,8 +212,7 @@ def route_exec(): nest_calls.sort() -@app.route("/api", methods=["GET"]) -@cross_origin() +@app.route('/api', methods=['GET']) def route_api(): """Route to list call functions in NEST.""" return jsonify(nest_calls) From 14a961c986086d2ec66ce5b3ba854aeefed5abe2 Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Thu, 27 Oct 2022 16:22:58 +0200 Subject: [PATCH 083/168] Vanishing application and authentication :) --- pynest/nest/server/hl_api_server.py | 73 ++++++++++++++++++++++++----- 1 file changed, 60 insertions(+), 13 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 1bf8ab6297..8fb896ea4a 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -35,10 +35,7 @@ root = logging.getLogger() root.addHandler(default_handler) -from werkzeug.exceptions import abort -from werkzeug.wrappers import Response - -import nest +# import nest import RestrictedPython import time @@ -88,15 +85,65 @@ def get_boolean_environ(env_key, default_value = 'false'): mpi_comm = None +# Self sufficient, dissapearing authentication function: +# +# * Generates the login token based on salted hash of the ID of this object and the +# current time measured by `perf_counter` giving us enough entropy. +# * Stores the token on this function. +# * Removes all `nest` accessible references to it, only `app` and `gc` have it, and the +# reference this module holds to `app` is deleted before the first request goes through. +@app.before_request +def check_token(): + try: + import inspect + import gc + import time + import hashlib + import hmac + + + frame = inspect.currentframe() + code = frame.f_code + globs = frame.f_globals + functype = type(lambda: 0) + funcs = [] + for func in gc.get_referrers(code): + if type(func) is functype: + if getattr(func, "__code__", None) is code: + if getattr(func, "__globals__", None) is globs: + funcs.append(func) + if len(funcs) > 1: + return ("Unauthorized", 403) + self = funcs[0] + if not hasattr(self, "_hash"): + hasher = hashlib.sha512() + hasher.update(str(hash(id(self))).encode("utf-8")) + hasher.update(str(time.perf_counter()).encode("utf-8")) + self._hash = hasher.hexdigest() + print("") + print(" Bearer token to login to the NEST server with: ", self._hash) + print("") + auth = request.headers["Authorization"] + # The line above triggers an error because below we call `check_token` outside of + # any request context. The next time, before the app calls the request route + # handler, this line will remove the reference this module holds to `app` as well. + del globals()["app"] + # Use constant-time comparison to avoid timing attacks. + if not hmac.compare_digest(auth, f"Bearer {self._hash}"): + return ("Unauthorized", 403) + except Exception: + return ("Unauthorized", 403) + +check_token() +del check_token + @app.route('/', methods=['GET']) def index(): - return jsonify( - { - "nest": nest.__version__, - "mpi": mpi_comm is not None, - } - ) + return jsonify({ + 'nest': 1, + 'mpi': mpi_comm is not None, + }) def do_exec(args, kwargs): @@ -134,7 +181,7 @@ def do_exec(args, kwargs): except Exception as e: for line in traceback.format_exception(*sys.exc_info()): print(line, flush=True) - abort(Response(str(e), EXCEPTION_ERROR_STATUS)) + flask.abort(EXCEPTION_ERROR_STATUS, str(e)) def log(call_name, msg): @@ -207,8 +254,8 @@ def route_exec(): # RESTful API # -------------------------- -nest_calls = dir(nest) -nest_calls = list(filter(lambda x: not x.startswith("_"), nest_calls)) +nest_calls = [] +nest_calls = list(filter(lambda x: not x.startswith('_'), nest_calls)) nest_calls.sort() From 639acb2f179307fc0a410aaf7ba2a4203fc75024 Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Thu, 27 Oct 2022 16:42:47 +0200 Subject: [PATCH 084/168] Allowed authentication to be disabled. --- pynest/nest/server/hl_api_server.py | 43 +++++++++++++++++++---------- 1 file changed, 29 insertions(+), 14 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 8fb896ea4a..3f87e0e430 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -51,6 +51,7 @@ def get_boolean_environ(env_key, default_value = 'false'): return env_value.lower() in ['yes', 'true', 't', '1'] _default_origins = 'localhost,http://localhost,https://localhost' +DISABLE_AUTHENTICATION = os.environ.get('NEST_DISABLE_AUTHENTICATION', False) == "TRUE" CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', _default_origins).split(',') EXEC_SCRIPT = get_boolean_environ('NEST_SERVER_EXEC_SCRIPT') MODULES = os.environ.get('NEST_SERVER_MODULES', 'nest').split(',') @@ -85,7 +86,7 @@ def get_boolean_environ(env_key, default_value = 'false'): mpi_comm = None -# Self sufficient, dissapearing authentication function: +# Self sufficient, dissapearing authentication function # # * Generates the login token based on salted hash of the ID of this object and the # current time measured by `perf_counter` giving us enough entropy. @@ -93,7 +94,7 @@ def get_boolean_environ(env_key, default_value = 'false'): # * Removes all `nest` accessible references to it, only `app` and `gc` have it, and the # reference this module holds to `app` is deleted before the first request goes through. @app.before_request -def check_token(): +def setup_auth(): try: import inspect import gc @@ -120,22 +121,36 @@ def check_token(): hasher.update(str(hash(id(self))).encode("utf-8")) hasher.update(str(time.perf_counter()).encode("utf-8")) self._hash = hasher.hexdigest() - print("") - print(" Bearer token to login to the NEST server with: ", self._hash) - print("") + if not DISABLE_AUTHENTICATION: + print("") + print(" Bearer token to login to the NEST server with: ", self._hash) + print("") + # Control flow explanation: The first time we hit this line is when below the + # function definition we call `setup_auth` without any request existing yet, + # so the function exits here after generating and storing the auth hash. auth = request.headers["Authorization"] - # The line above triggers an error because below we call `check_token` outside of - # any request context. The next time, before the app calls the request route - # handler, this line will remove the reference this module holds to `app` as well. - del globals()["app"] - # Use constant-time comparison to avoid timing attacks. - if not hmac.compare_digest(auth, f"Bearer {self._hash}"): + # We continue here the next time this function is called, which is before the + # Flask app handles a request. At that point we also remove this module's + # reference to the running app. + try: + del globals()["app"] + except KeyError: + pass + # Things get simpler here: We just check if the user has given us the right token. + if not ( + DISABLE_AUTHENTICATION + # Use constant-time algorithm to campare the strings, to avoid timing attacks. + or hmac.compare_digest(auth, f"Bearer {self._hash}") + ): return ("Unauthorized", 403) - except Exception: + # DON'T LINT! Intentional bare except clause! Even `KeyboardInterrupt` and + # `SystemExit` exceptions should not bypass authentication! + except: return ("Unauthorized", 403) -check_token() -del check_token + +setup_auth() +del setup_auth @app.route('/', methods=['GET']) From 06b63817e18a7a9901ff81381ec4e9b73aea967a Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Thu, 27 Oct 2022 16:51:59 +0200 Subject: [PATCH 085/168] restored nest import --- pynest/nest/server/hl_api_server.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 3f87e0e430..84f4b86287 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -35,7 +35,7 @@ root = logging.getLogger() root.addHandler(default_handler) -# import nest +import nest import RestrictedPython import time @@ -269,7 +269,7 @@ def route_exec(): # RESTful API # -------------------------- -nest_calls = [] +nest_calls = dir(nest) nest_calls = list(filter(lambda x: not x.startswith('_'), nest_calls)) nest_calls.sort() From 5a3aaec82cffc6a44e4fda1cf0265b552014ebfd Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Thu, 27 Oct 2022 17:14:08 +0200 Subject: [PATCH 086/168] Improved comments --- pynest/nest/server/hl_api_server.py | 35 ++++++++++++++++------------- 1 file changed, 19 insertions(+), 16 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 84f4b86287..66b704f766 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -86,15 +86,15 @@ def get_boolean_environ(env_key, default_value = 'false'): mpi_comm = None -# Self sufficient, dissapearing authentication function -# -# * Generates the login token based on salted hash of the ID of this object and the -# current time measured by `perf_counter` giving us enough entropy. -# * Stores the token on this function. -# * Removes all `nest` accessible references to it, only `app` and `gc` have it, and the -# reference this module holds to `app` is deleted before the first request goes through. @app.before_request def setup_auth(): + """ + Authentication function that generates and validates the Authorization header with a + bearer token. + + Cleans up references to itself and the running `app` from this module, as it may be + accessible when the code execution sandbox fails. + """ try: import inspect import gc @@ -102,7 +102,7 @@ def setup_auth(): import hashlib import hmac - + # Find our reference to the current function in the garbage collector. frame = inspect.currentframe() code = frame.f_code globs = frame.f_globals @@ -116,6 +116,8 @@ def setup_auth(): if len(funcs) > 1: return ("Unauthorized", 403) self = funcs[0] + # Use the salted hash (unless `PYTHONHASHSEED` is fixed) of the location of this + # function in the Python heap and the current timestamp to create a SHA512 hash. if not hasattr(self, "_hash"): hasher = hashlib.sha512() hasher.update(str(hash(id(self))).encode("utf-8")) @@ -125,21 +127,22 @@ def setup_auth(): print("") print(" Bearer token to login to the NEST server with: ", self._hash) print("") - # Control flow explanation: The first time we hit this line is when below the - # function definition we call `setup_auth` without any request existing yet, - # so the function exits here after generating and storing the auth hash. + # The first time we hit the line below is when below the function definition we + # call `setup_auth` without any Flask request existing yet, so the function errors + # and exits here after generating and storing the auth hash. auth = request.headers["Authorization"] - # We continue here the next time this function is called, which is before the - # Flask app handles a request. At that point we also remove this module's - # reference to the running app. + # We continue here the next time this function is called, before the Flask app + # handles the first request. At that point we also remove this module's reference + # to the running app. try: del globals()["app"] except KeyError: pass - # Things get simpler here: We just check if the user has given us the right token. + # Things get more straightforward here: Every time a request is handled, compare + # the Authorization header to the hash, with a constant-time algorithm to avoid + # timing attacks. if not ( DISABLE_AUTHENTICATION - # Use constant-time algorithm to campare the strings, to avoid timing attacks. or hmac.compare_digest(auth, f"Bearer {self._hash}") ): return ("Unauthorized", 403) From 01ed58e43016f4839931d6d02115cc447dd39a08 Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Thu, 27 Oct 2022 17:20:42 +0200 Subject: [PATCH 087/168] reverted more things I did to test locally. --- pynest/nest/server/hl_api_server.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 66b704f766..a1cf4009db 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -159,7 +159,7 @@ def setup_auth(): @app.route('/', methods=['GET']) def index(): return jsonify({ - 'nest': 1, + 'nest': nest.__version__, 'mpi': mpi_comm is not None, }) From 3d957dfc34b269e6fb5a1f023d0c18e94e3ee386 Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Fri, 28 Oct 2022 10:26:25 +0200 Subject: [PATCH 088/168] moved handler for pep8, use bool util --- pynest/nest/server/hl_api_server.py | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index a1cf4009db..b1f0765e48 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -30,11 +30,6 @@ from flask_cors import CORS from flask.logging import default_handler -# This ensures that the logging information shows up in the console running the server, -# even when Flask's event loop is running. -root = logging.getLogger() -root.addHandler(default_handler) - import nest import RestrictedPython @@ -46,12 +41,20 @@ import os -def get_boolean_environ(env_key, default_value = 'false'): + +# This ensures that the logging information shows up in the console running the server, +# even when Flask's event loop is running. +root = logging.getLogger() +root.addHandler(default_handler) + + +def get_boolean_environ(env_key, default_value='false'): env_value = os.environ.get(env_key, default_value) return env_value.lower() in ['yes', 'true', 't', '1'] + _default_origins = 'localhost,http://localhost,https://localhost' -DISABLE_AUTHENTICATION = os.environ.get('NEST_DISABLE_AUTHENTICATION', False) == "TRUE" +DISABLE_AUTHENTICATION = get_boolean_environ('NEST_DISABLE_AUTHENTICATION') CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', _default_origins).split(',') EXEC_SCRIPT = get_boolean_environ('NEST_SERVER_EXEC_SCRIPT') MODULES = os.environ.get('NEST_SERVER_MODULES', 'nest').split(',') From 8acbb78339352a83eaaa29d69d90e5c251df2a88 Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Fri, 28 Oct 2022 10:27:03 +0200 Subject: [PATCH 089/168] pep8 fixes --- pynest/nest/server/hl_api_server.py | 19 +++++++++++-------- 1 file changed, 11 insertions(+), 8 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index b1f0765e48..ad107d859d 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -89,6 +89,7 @@ def get_boolean_environ(env_key, default_value='false'): mpi_comm = None + @app.before_request def setup_auth(): """ @@ -99,15 +100,17 @@ def setup_auth(): accessible when the code execution sandbox fails. """ try: - import inspect - import gc - import time - import hashlib - import hmac + # Import the modules inside of the auth function, so that if they fail the auth + # returns a forbidden error. + import inspect # noqa + import gc # noqa + import time # noqa + import hashlib # noqa + import hmac # noqa # Find our reference to the current function in the garbage collector. frame = inspect.currentframe() - code = frame.f_code + code = frame.f_code globs = frame.f_globals functype = type(lambda: 0) funcs = [] @@ -151,7 +154,7 @@ def setup_auth(): return ("Unauthorized", 403) # DON'T LINT! Intentional bare except clause! Even `KeyboardInterrupt` and # `SystemExit` exceptions should not bypass authentication! - except: + except: # noqa return ("Unauthorized", 403) @@ -302,7 +305,7 @@ def route_api_call(call): class Capturing(list): - """Monitor stdout contents i.e. print.""" + """ Monitor stdout contents i.e. print. """ def __enter__(self): self._stdout = sys.stdout From 232195595b3bfadbb6c81856e5f9787a2e380f89 Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Fri, 28 Oct 2022 10:27:13 +0200 Subject: [PATCH 090/168] abort --> flask.abort --- pynest/nest/server/hl_api_server.py | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index ad107d859d..6a4e72bd10 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -268,10 +268,10 @@ def route_exec(): response = do_call('exec', args, kwargs) return jsonify(response) else: - abort(Response( + flask.abort( + 403, 'The route `/exec` has been disabled. Please contact the server administrator.', - 403 - )) + ) # -------------------------- @@ -385,8 +385,7 @@ def func_wrapper(call, args, kwargs): except Exception as e: for line in traceback.format_exception(*sys.exc_info()): print(line, flush=True) - abort(Response(str(e), EXCEPTION_ERROR_STATUS)) - + flask.abort(EXCEPTION_ERROR_STATUS, str(e)) return func_wrapper From 45bb9e48b29cac6c2454faaa4ec9e7c26c84e844 Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Fri, 28 Oct 2022 10:58:23 +0200 Subject: [PATCH 091/168] fixed unauthorized error when no auth header is given --- pynest/nest/server/hl_api_server.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 6a4e72bd10..01de03c453 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -136,7 +136,7 @@ def setup_auth(): # The first time we hit the line below is when below the function definition we # call `setup_auth` without any Flask request existing yet, so the function errors # and exits here after generating and storing the auth hash. - auth = request.headers["Authorization"] + auth = request.headers.get("Authorization", None) # We continue here the next time this function is called, before the Flask app # handles the first request. At that point we also remove this module's reference # to the running app. From 4dc0115eb7299ecfb399dc33ae3390a4e7c9431c Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Tue, 25 Oct 2022 15:18:43 +0200 Subject: [PATCH 092/168] Add env EXEC_SCRIPT --- pynest/nest/server/hl_api_server.py | 19 ++++--------------- 1 file changed, 4 insertions(+), 15 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 01de03c453..3b045e3c51 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -41,21 +41,10 @@ import os - -# This ensures that the logging information shows up in the console running the server, -# even when Flask's event loop is running. -root = logging.getLogger() -root.addHandler(default_handler) - - -def get_boolean_environ(env_key, default_value='false'): +def get_boolean_environ(env_key, default_value = 'false'): env_value = os.environ.get(env_key, default_value) return env_value.lower() in ['yes', 'true', 't', '1'] - -_default_origins = 'localhost,http://localhost,https://localhost' -DISABLE_AUTHENTICATION = get_boolean_environ('NEST_DISABLE_AUTHENTICATION') -CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', _default_origins).split(',') EXEC_SCRIPT = get_boolean_environ('NEST_SERVER_EXEC_SCRIPT') MODULES = os.environ.get('NEST_SERVER_MODULES', 'nest').split(',') RESTRICTION_OFF = get_boolean_environ('NEST_SERVER_RESTRICTION_OFF') @@ -268,10 +257,10 @@ def route_exec(): response = do_call('exec', args, kwargs) return jsonify(response) else: - flask.abort( - 403, + abort(Response( 'The route `/exec` has been disabled. Please contact the server administrator.', - ) + 403 + )) # -------------------------- From ae850dd21ce96cb395892475c6097fdb1efc3f84 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Tue, 25 Oct 2022 15:18:59 +0200 Subject: [PATCH 093/168] Cleanup nest-server From 02ffe29ed38b95f5c4a76799cdecfcaedec5a5ec Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Tue, 25 Oct 2022 15:19:08 +0200 Subject: [PATCH 094/168] Add changes for v3.4 From e7fed2d7e3e342095c74a90b5286f624eb448b18 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Thu, 27 Oct 2022 12:18:52 +0200 Subject: [PATCH 095/168] Set Origins in CORS --- pynest/nest/server/hl_api_server.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 3b045e3c51..d1631a6045 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -45,6 +45,7 @@ def get_boolean_environ(env_key, default_value = 'false'): env_value = os.environ.get(env_key, default_value) return env_value.lower() in ['yes', 'true', 't', '1'] +CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', 'localhost') EXEC_SCRIPT = get_boolean_environ('NEST_SERVER_EXEC_SCRIPT') MODULES = os.environ.get('NEST_SERVER_MODULES', 'nest').split(',') RESTRICTION_OFF = get_boolean_environ('NEST_SERVER_RESTRICTION_OFF') @@ -72,9 +73,7 @@ def get_boolean_environ(env_key, default_value = 'false'): ] app = Flask(__name__) -# Inform client-side user agents that they should not attempt to call our server from any -# non-whitelisted domain. -CORS(app, origins=CORS_ORIGINS, methods=["GET", "POST"]) +CORS(app, resources={r"/*": {"origins": f"{CORS_ORIGINS}"}) mpi_comm = None From 49813b4544d72b40bac2557098b16394a3030614 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Thu, 27 Oct 2022 12:58:53 +0200 Subject: [PATCH 096/168] Add cross origin for / --- pynest/nest/server/hl_api_server.py | 1 + 1 file changed, 1 insertion(+) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index d1631a6045..837b5637bc 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -151,6 +151,7 @@ def setup_auth(): @app.route('/', methods=['GET']) +@cross_origin() def index(): return jsonify({ 'nest': nest.__version__, From 32db7408ae8764ae96acfdefb497a863e4761ab3 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Thu, 27 Oct 2022 14:53:42 +0200 Subject: [PATCH 097/168] Extend cors_origins --- pynest/nest/server/hl_api_server.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 837b5637bc..feac18bab2 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -45,7 +45,7 @@ def get_boolean_environ(env_key, default_value = 'false'): env_value = os.environ.get(env_key, default_value) return env_value.lower() in ['yes', 'true', 't', '1'] -CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', 'localhost') +CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', 'http://localhost:8000').split(',') EXEC_SCRIPT = get_boolean_environ('NEST_SERVER_EXEC_SCRIPT') MODULES = os.environ.get('NEST_SERVER_MODULES', 'nest').split(',') RESTRICTION_OFF = get_boolean_environ('NEST_SERVER_RESTRICTION_OFF') @@ -73,7 +73,7 @@ def get_boolean_environ(env_key, default_value = 'false'): ] app = Flask(__name__) -CORS(app, resources={r"/*": {"origins": f"{CORS_ORIGINS}"}) +CORS(app, CORS_ORIGINS=CORS_ORIGINS) mpi_comm = None From 4dec831a22cce752b31afab79744a28f633c35f9 Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Thu, 27 Oct 2022 15:27:19 +0200 Subject: [PATCH 098/168] Apply CORS headers --- pynest/nest/server/hl_api_server.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index feac18bab2..bb21f8eb9e 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -45,7 +45,8 @@ def get_boolean_environ(env_key, default_value = 'false'): env_value = os.environ.get(env_key, default_value) return env_value.lower() in ['yes', 'true', 't', '1'] -CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', 'http://localhost:8000').split(',') +_default_origins = 'localhost,http://localhost,https://localhost' +CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', _default_origins).split(',') EXEC_SCRIPT = get_boolean_environ('NEST_SERVER_EXEC_SCRIPT') MODULES = os.environ.get('NEST_SERVER_MODULES', 'nest').split(',') RESTRICTION_OFF = get_boolean_environ('NEST_SERVER_RESTRICTION_OFF') @@ -73,7 +74,9 @@ def get_boolean_environ(env_key, default_value = 'false'): ] app = Flask(__name__) -CORS(app, CORS_ORIGINS=CORS_ORIGINS) +# Inform client-side user agents that they should not attempt to call our server from any +# non-whitelisted domain. +CORS(app, origins=CORS_ORIGINS, methods=["GET", "POST"]) mpi_comm = None @@ -151,7 +154,6 @@ def setup_auth(): @app.route('/', methods=['GET']) -@cross_origin() def index(): return jsonify({ 'nest': nest.__version__, From 42558c2d8bfc426b55e1dcb4a4b2cac6babab391 Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Thu, 27 Oct 2022 15:35:48 +0200 Subject: [PATCH 099/168] forgot 1 From 29bba91b5a5fcb72770a8fedb9ad607c6658728d Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Thu, 27 Oct 2022 16:22:58 +0200 Subject: [PATCH 100/168] Vanishing application and authentication :) --- pynest/nest/server/hl_api_server.py | 56 +++++++++++++++++++++++++++-- 1 file changed, 54 insertions(+), 2 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index bb21f8eb9e..659dc64e92 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -80,6 +80,58 @@ def get_boolean_environ(env_key, default_value = 'false'): mpi_comm = None +# Self sufficient, dissapearing authentication function: +# +# * Generates the login token based on salted hash of the ID of this object and the +# current time measured by `perf_counter` giving us enough entropy. +# * Stores the token on this function. +# * Removes all `nest` accessible references to it, only `app` and `gc` have it, and the +# reference this module holds to `app` is deleted before the first request goes through. +@app.before_request +def check_token(): + try: + import inspect + import gc + import time + import hashlib + import hmac + + + frame = inspect.currentframe() + code = frame.f_code + globs = frame.f_globals + functype = type(lambda: 0) + funcs = [] + for func in gc.get_referrers(code): + if type(func) is functype: + if getattr(func, "__code__", None) is code: + if getattr(func, "__globals__", None) is globs: + funcs.append(func) + if len(funcs) > 1: + return ("Unauthorized", 403) + self = funcs[0] + if not hasattr(self, "_hash"): + hasher = hashlib.sha512() + hasher.update(str(hash(id(self))).encode("utf-8")) + hasher.update(str(time.perf_counter()).encode("utf-8")) + self._hash = hasher.hexdigest() + print("") + print(" Bearer token to login to the NEST server with: ", self._hash) + print("") + auth = request.headers["Authorization"] + # The line above triggers an error because below we call `check_token` outside of + # any request context. The next time, before the app calls the request route + # handler, this line will remove the reference this module holds to `app` as well. + del globals()["app"] + # Use constant-time comparison to avoid timing attacks. + if not hmac.compare_digest(auth, f"Bearer {self._hash}"): + return ("Unauthorized", 403) + except Exception: + return ("Unauthorized", 403) + +check_token() +del check_token + @app.before_request def setup_auth(): @@ -156,7 +208,7 @@ def setup_auth(): @app.route('/', methods=['GET']) def index(): return jsonify({ - 'nest': nest.__version__, + 'nest': 1, 'mpi': mpi_comm is not None, }) @@ -269,7 +321,7 @@ def route_exec(): # RESTful API # -------------------------- -nest_calls = dir(nest) +nest_calls = [] nest_calls = list(filter(lambda x: not x.startswith('_'), nest_calls)) nest_calls.sort() From 660b221382fa8061c4ee6d63e283d7d3ed121e13 Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Thu, 27 Oct 2022 16:42:47 +0200 Subject: [PATCH 101/168] Allowed authentication to be disabled. --- pynest/nest/server/hl_api_server.py | 43 +++++++++++++++++++---------- 1 file changed, 29 insertions(+), 14 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 659dc64e92..cf4d0b8ac4 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -46,6 +46,7 @@ def get_boolean_environ(env_key, default_value = 'false'): return env_value.lower() in ['yes', 'true', 't', '1'] _default_origins = 'localhost,http://localhost,https://localhost' +DISABLE_AUTHENTICATION = os.environ.get('NEST_DISABLE_AUTHENTICATION', False) == "TRUE" CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', _default_origins).split(',') EXEC_SCRIPT = get_boolean_environ('NEST_SERVER_EXEC_SCRIPT') MODULES = os.environ.get('NEST_SERVER_MODULES', 'nest').split(',') @@ -80,7 +81,7 @@ def get_boolean_environ(env_key, default_value = 'false'): mpi_comm = None -# Self sufficient, dissapearing authentication function: +# Self sufficient, dissapearing authentication function # # * Generates the login token based on salted hash of the ID of this object and the # current time measured by `perf_counter` giving us enough entropy. @@ -88,7 +89,7 @@ def get_boolean_environ(env_key, default_value = 'false'): # * Removes all `nest` accessible references to it, only `app` and `gc` have it, and the # reference this module holds to `app` is deleted before the first request goes through. @app.before_request -def check_token(): +def setup_auth(): try: import inspect import gc @@ -115,22 +116,36 @@ def check_token(): hasher.update(str(hash(id(self))).encode("utf-8")) hasher.update(str(time.perf_counter()).encode("utf-8")) self._hash = hasher.hexdigest() - print("") - print(" Bearer token to login to the NEST server with: ", self._hash) - print("") + if not DISABLE_AUTHENTICATION: + print("") + print(" Bearer token to login to the NEST server with: ", self._hash) + print("") + # Control flow explanation: The first time we hit this line is when below the + # function definition we call `setup_auth` without any request existing yet, + # so the function exits here after generating and storing the auth hash. auth = request.headers["Authorization"] - # The line above triggers an error because below we call `check_token` outside of - # any request context. The next time, before the app calls the request route - # handler, this line will remove the reference this module holds to `app` as well. - del globals()["app"] - # Use constant-time comparison to avoid timing attacks. - if not hmac.compare_digest(auth, f"Bearer {self._hash}"): + # We continue here the next time this function is called, which is before the + # Flask app handles a request. At that point we also remove this module's + # reference to the running app. + try: + del globals()["app"] + except KeyError: + pass + # Things get simpler here: We just check if the user has given us the right token. + if not ( + DISABLE_AUTHENTICATION + # Use constant-time algorithm to campare the strings, to avoid timing attacks. + or hmac.compare_digest(auth, f"Bearer {self._hash}") + ): return ("Unauthorized", 403) - except Exception: + # DON'T LINT! Intentional bare except clause! Even `KeyboardInterrupt` and + # `SystemExit` exceptions should not bypass authentication! + except: return ("Unauthorized", 403) -check_token() -del check_token + +setup_auth() +del setup_auth @app.before_request From b1f73a7b93b10c19744421f72a69961c31a07ce3 Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Thu, 27 Oct 2022 16:51:59 +0200 Subject: [PATCH 102/168] restored nest import --- pynest/nest/server/hl_api_server.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index cf4d0b8ac4..682b1527ae 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -336,7 +336,7 @@ def route_exec(): # RESTful API # -------------------------- -nest_calls = [] +nest_calls = dir(nest) nest_calls = list(filter(lambda x: not x.startswith('_'), nest_calls)) nest_calls.sort() From d654b42939e2eff5bd2219f5eea908cc711d5a5a Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Thu, 27 Oct 2022 17:14:08 +0200 Subject: [PATCH 103/168] Improved comments --- pynest/nest/server/hl_api_server.py | 35 ++++++++++++++++------------- 1 file changed, 19 insertions(+), 16 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 682b1527ae..c3014ac492 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -81,15 +81,15 @@ def get_boolean_environ(env_key, default_value = 'false'): mpi_comm = None -# Self sufficient, dissapearing authentication function -# -# * Generates the login token based on salted hash of the ID of this object and the -# current time measured by `perf_counter` giving us enough entropy. -# * Stores the token on this function. -# * Removes all `nest` accessible references to it, only `app` and `gc` have it, and the -# reference this module holds to `app` is deleted before the first request goes through. @app.before_request def setup_auth(): + """ + Authentication function that generates and validates the Authorization header with a + bearer token. + + Cleans up references to itself and the running `app` from this module, as it may be + accessible when the code execution sandbox fails. + """ try: import inspect import gc @@ -97,7 +97,7 @@ def setup_auth(): import hashlib import hmac - + # Find our reference to the current function in the garbage collector. frame = inspect.currentframe() code = frame.f_code globs = frame.f_globals @@ -111,6 +111,8 @@ def setup_auth(): if len(funcs) > 1: return ("Unauthorized", 403) self = funcs[0] + # Use the salted hash (unless `PYTHONHASHSEED` is fixed) of the location of this + # function in the Python heap and the current timestamp to create a SHA512 hash. if not hasattr(self, "_hash"): hasher = hashlib.sha512() hasher.update(str(hash(id(self))).encode("utf-8")) @@ -120,21 +122,22 @@ def setup_auth(): print("") print(" Bearer token to login to the NEST server with: ", self._hash) print("") - # Control flow explanation: The first time we hit this line is when below the - # function definition we call `setup_auth` without any request existing yet, - # so the function exits here after generating and storing the auth hash. + # The first time we hit the line below is when below the function definition we + # call `setup_auth` without any Flask request existing yet, so the function errors + # and exits here after generating and storing the auth hash. auth = request.headers["Authorization"] - # We continue here the next time this function is called, which is before the - # Flask app handles a request. At that point we also remove this module's - # reference to the running app. + # We continue here the next time this function is called, before the Flask app + # handles the first request. At that point we also remove this module's reference + # to the running app. try: del globals()["app"] except KeyError: pass - # Things get simpler here: We just check if the user has given us the right token. + # Things get more straightforward here: Every time a request is handled, compare + # the Authorization header to the hash, with a constant-time algorithm to avoid + # timing attacks. if not ( DISABLE_AUTHENTICATION - # Use constant-time algorithm to campare the strings, to avoid timing attacks. or hmac.compare_digest(auth, f"Bearer {self._hash}") ): return ("Unauthorized", 403) From 45332d949378b5d71101a09da0b4267b8ef5fd95 Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Thu, 27 Oct 2022 17:20:42 +0200 Subject: [PATCH 104/168] reverted more things I did to test locally. --- pynest/nest/server/hl_api_server.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index c3014ac492..2393e90358 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -226,7 +226,7 @@ def setup_auth(): @app.route('/', methods=['GET']) def index(): return jsonify({ - 'nest': 1, + 'nest': nest.__version__, 'mpi': mpi_comm is not None, }) From 9c900dc6497a616aecca0a30559aea089fa2614a Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Fri, 28 Oct 2022 10:26:25 +0200 Subject: [PATCH 105/168] moved handler for pep8, use bool util --- pynest/nest/server/hl_api_server.py | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 2393e90358..2dee9d64ef 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -41,12 +41,20 @@ import os -def get_boolean_environ(env_key, default_value = 'false'): + +# This ensures that the logging information shows up in the console running the server, +# even when Flask's event loop is running. +root = logging.getLogger() +root.addHandler(default_handler) + + +def get_boolean_environ(env_key, default_value='false'): env_value = os.environ.get(env_key, default_value) return env_value.lower() in ['yes', 'true', 't', '1'] + _default_origins = 'localhost,http://localhost,https://localhost' -DISABLE_AUTHENTICATION = os.environ.get('NEST_DISABLE_AUTHENTICATION', False) == "TRUE" +DISABLE_AUTHENTICATION = get_boolean_environ('NEST_DISABLE_AUTHENTICATION') CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', _default_origins).split(',') EXEC_SCRIPT = get_boolean_environ('NEST_SERVER_EXEC_SCRIPT') MODULES = os.environ.get('NEST_SERVER_MODULES', 'nest').split(',') From b65957075c9a89eabbd2bb9c2aa2576b12511296 Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Fri, 28 Oct 2022 10:27:03 +0200 Subject: [PATCH 106/168] pep8 fixes --- pynest/nest/server/hl_api_server.py | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 2dee9d64ef..e3bac0c21c 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -89,6 +89,7 @@ def get_boolean_environ(env_key, default_value='false'): mpi_comm = None + @app.before_request def setup_auth(): """ @@ -99,15 +100,17 @@ def setup_auth(): accessible when the code execution sandbox fails. """ try: - import inspect - import gc - import time - import hashlib - import hmac + # Import the modules inside of the auth function, so that if they fail the auth + # returns a forbidden error. + import inspect # noqa + import gc # noqa + import time # noqa + import hashlib # noqa + import hmac # noqa # Find our reference to the current function in the garbage collector. frame = inspect.currentframe() - code = frame.f_code + code = frame.f_code globs = frame.f_globals functype = type(lambda: 0) funcs = [] @@ -151,7 +154,7 @@ def setup_auth(): return ("Unauthorized", 403) # DON'T LINT! Intentional bare except clause! Even `KeyboardInterrupt` and # `SystemExit` exceptions should not bypass authentication! - except: + except: # noqa return ("Unauthorized", 403) From 5d00eac83be289892f5f987e3be189edae5f4843 Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Fri, 28 Oct 2022 10:27:13 +0200 Subject: [PATCH 107/168] abort --> flask.abort --- pynest/nest/server/hl_api_server.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index e3bac0c21c..44ecdc30bf 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -340,10 +340,10 @@ def route_exec(): response = do_call('exec', args, kwargs) return jsonify(response) else: - abort(Response( + flask.abort( + 403, 'The route `/exec` has been disabled. Please contact the server administrator.', - 403 - )) + ) # -------------------------- From 685c072cf938dd6717fdf73fc78c46d26d4c24c7 Mon Sep 17 00:00:00 2001 From: Robin De Schepper Date: Fri, 28 Oct 2022 10:58:23 +0200 Subject: [PATCH 108/168] fixed unauthorized error when no auth header is given --- pynest/nest/server/hl_api_server.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 44ecdc30bf..66927283f9 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -136,7 +136,7 @@ def setup_auth(): # The first time we hit the line below is when below the function definition we # call `setup_auth` without any Flask request existing yet, so the function errors # and exits here after generating and storing the auth hash. - auth = request.headers["Authorization"] + auth = request.headers.get("Authorization", None) # We continue here the next time this function is called, before the Flask app # handles the first request. At that point we also remove this module's reference # to the running app. From a33759f5b46b777b0ccb131893152faa86d3fcb3 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Fri, 28 Oct 2022 12:28:06 +0200 Subject: [PATCH 109/168] Rename env variables and notify before startup --- pynest/nest/server/hl_api_server.py | 47 +++++++++++++++++++++++------ 1 file changed, 38 insertions(+), 9 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 66927283f9..93d7a27d37 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -54,14 +54,14 @@ def get_boolean_environ(env_key, default_value='false'): _default_origins = 'localhost,http://localhost,https://localhost' -DISABLE_AUTHENTICATION = get_boolean_environ('NEST_DISABLE_AUTHENTICATION') +AUTH_DISABLED = get_boolean_environ('NEST_SERVER_DISABLE_AUTH') CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', _default_origins).split(',') -EXEC_SCRIPT = get_boolean_environ('NEST_SERVER_EXEC_SCRIPT') +EXEC_CALL_ENABLED = get_boolean_environ('NEST_SERVER_ENABLE_EXEC_CALL') MODULES = os.environ.get('NEST_SERVER_MODULES', 'nest').split(',') -RESTRICTION_OFF = get_boolean_environ('NEST_SERVER_RESTRICTION_OFF') +RESTRICTION_DISABLED = get_boolean_environ('NEST_SERVER_DISABLE_RESTRICTION') EXCEPTION_ERROR_STATUS = 400 -if EXEC_SCRIPT: +if EXEC_CALL_ENABLED: print(80 * '*') msg = ("\n" + 9*" ").join([ 'NEST Server runs with the `exec` command activated.', @@ -69,11 +69,13 @@ def get_boolean_environ(env_key, default_value='false'): 'The security of your system can not be ensured!' ]) print(f'WARNING: {msg}') - if RESTRICTION_OFF: + if RESTRICTION_DISABLED: msg = 'NEST Server runs without a RestrictedPython trusted environment.' print(f'WARNING: {msg}') print(80 * '*') + + __all__ = [ "app", "do_exec", @@ -90,6 +92,30 @@ def get_boolean_environ(env_key, default_value='false'): mpi_comm = None +def check_security(): + """ + Checks the security level of the NEST Server instance. + """ + + msg = [] + if AUTH_DISABLED: + msg.append('AUTH:\tThe authentication is disabled.') + if '*' in CORS_ORIGINS: + msg.append('CORS:\tAllowed origins is unrestricted.') + if EXEC_CALL_ENABLED: + msg.append('EXEC CALL:\tAny code scripts can be executed!') + if RESTRICTION_DISABLED: + msg.append('RESTRICTION: Code scripts will be executed without a restricted environment.') + + level = ['HIGHEST', 'HIGH', 'MODERATE', 'LOW', 'LOWEST'] + print(f'The security level of NEST Server is {level[len(msg)]}.') + if len(msg) > 0: + print('WARNING: The security of your system can not be ensured!') + print('\n - '.join([' '] + msg) + '\n') + else: + print('INFO: The security of your system can be ensured!') + + @app.before_request def setup_auth(): """ @@ -129,7 +155,7 @@ def setup_auth(): hasher.update(str(hash(id(self))).encode("utf-8")) hasher.update(str(time.perf_counter()).encode("utf-8")) self._hash = hasher.hexdigest() - if not DISABLE_AUTHENTICATION: + if not AUTH_DISABLED: print("") print(" Bearer token to login to the NEST server with: ", self._hash) print("") @@ -148,7 +174,7 @@ def setup_auth(): # the Authorization header to the hash, with a constant-time algorithm to avoid # timing attacks. if not ( - DISABLE_AUTHENTICATION + AUTH_DISABLED or hmac.compare_digest(auth, f"Bearer {self._hash}") ): return ("Unauthorized", 403) @@ -158,8 +184,11 @@ def setup_auth(): return ("Unauthorized", 403) +print( 80 * '*') +check_security() setup_auth() del setup_auth +print( 80 * '*') @app.before_request @@ -249,7 +278,7 @@ def do_exec(args, kwargs): locals_ = dict() response = dict() - if RESTRICTION_OFF: + if RESTRICTION_DISABLED: with Capturing() as stdout: globals_ = globals().copy() globals_.update(get_modules_from_env()) @@ -335,7 +364,7 @@ def do_call(call_name, args=[], kwargs={}): def route_exec(): """Route to execute script in Python.""" - if EXEC_SCRIPT: + if EXEC_CALL_ENABLED: args, kwargs = get_arguments(request) response = do_call('exec', args, kwargs) return jsonify(response) From 2a801138f5b867dbd67961f5256ef8585ecc1df2 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Fri, 28 Oct 2022 12:42:09 +0200 Subject: [PATCH 110/168] Update notification --- pynest/nest/server/hl_api_server.py | 23 +++-------------------- 1 file changed, 3 insertions(+), 20 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 93d7a27d37..c0bbacddc9 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -61,21 +61,6 @@ def get_boolean_environ(env_key, default_value='false'): RESTRICTION_DISABLED = get_boolean_environ('NEST_SERVER_DISABLE_RESTRICTION') EXCEPTION_ERROR_STATUS = 400 -if EXEC_CALL_ENABLED: - print(80 * '*') - msg = ("\n" + 9*" ").join([ - 'NEST Server runs with the `exec` command activated.', - 'This means that any code can be executed!', - 'The security of your system can not be ensured!' - ]) - print(f'WARNING: {msg}') - if RESTRICTION_DISABLED: - msg = 'NEST Server runs without a RestrictedPython trusted environment.' - print(f'WARNING: {msg}') - print(80 * '*') - - - __all__ = [ "app", "do_exec", @@ -101,7 +86,7 @@ def check_security(): if AUTH_DISABLED: msg.append('AUTH:\tThe authentication is disabled.') if '*' in CORS_ORIGINS: - msg.append('CORS:\tAllowed origins is unrestricted.') + msg.append('CORS:\tAllowed origins is not restricted.') if EXEC_CALL_ENABLED: msg.append('EXEC CALL:\tAny code scripts can be executed!') if RESTRICTION_DISABLED: @@ -154,11 +139,9 @@ def setup_auth(): hasher = hashlib.sha512() hasher.update(str(hash(id(self))).encode("utf-8")) hasher.update(str(time.perf_counter()).encode("utf-8")) - self._hash = hasher.hexdigest() + self._hash = hasher.hexdigest()[:48] if not AUTH_DISABLED: - print("") - print(" Bearer token to login to the NEST server with: ", self._hash) - print("") + print(f"\nBearer token to NEST server: {self._hash}\n") # The first time we hit the line below is when below the function definition we # call `setup_auth` without any Flask request existing yet, so the function errors # and exits here after generating and storing the auth hash. From 73777781960f1075d16df2b9db27ec76faaf1092 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Fri, 28 Oct 2022 12:44:21 +0200 Subject: [PATCH 111/168] Add changes in release notes --- doc/htmldoc/whats_new/v3.4/index.rst | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/doc/htmldoc/whats_new/v3.4/index.rst b/doc/htmldoc/whats_new/v3.4/index.rst index ae80fe734b..6b95e4e33f 100644 --- a/doc/htmldoc/whats_new/v3.4/index.rst +++ b/doc/htmldoc/whats_new/v3.4/index.rst @@ -64,7 +64,9 @@ the node positions. Changes in NEST Server ~~~~~~~~~~~~~~~~~~~~~~ -* By default NEST Server runs on port 52425 (previously 5000). -* Minimize security risk in NEST Server. - * By default exec call is disabled, only API calls are enabled. - * The user is able to turn on exec call which means that the user is aware of the risk. +* By default, the NEST Server now runs on port ``52425`` (previously ``5000``). +* Improve the security in NEST Server. The user can modify the security options in environment variables: + * Requests require Bearer tokens. By default, the authentication is on (``NEST_SERVER_DISABLE_AUTH=0``). + * The CORS origins are restricted. By default, the only allowed CORS origin is ``localhost`` (``NEST_SERVER_CORS_ORIGINS=localhost``). + * Only API calls are enabled. By default, the exec call is disabled (``NEST_SERVER_ENABLE_EXEC_CALL=0``). + * The code execution is restricted. By default, the restriction is activated (``NEST_SERVER_DISABLE_RESTRICTION=0``). From 6a8f3e69ad071906573ea2a2af57b47263f2614b Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Fri, 28 Oct 2022 12:51:13 +0200 Subject: [PATCH 112/168] Set only 1 CORS_origin as default --- doc/htmldoc/whats_new/v3.4/index.rst | 2 +- pynest/nest/server/hl_api_server.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/doc/htmldoc/whats_new/v3.4/index.rst b/doc/htmldoc/whats_new/v3.4/index.rst index 6b95e4e33f..1d63e2ac91 100644 --- a/doc/htmldoc/whats_new/v3.4/index.rst +++ b/doc/htmldoc/whats_new/v3.4/index.rst @@ -67,6 +67,6 @@ Changes in NEST Server * By default, the NEST Server now runs on port ``52425`` (previously ``5000``). * Improve the security in NEST Server. The user can modify the security options in environment variables: * Requests require Bearer tokens. By default, the authentication is on (``NEST_SERVER_DISABLE_AUTH=0``). - * The CORS origins are restricted. By default, the only allowed CORS origin is ``localhost`` (``NEST_SERVER_CORS_ORIGINS=localhost``). + * The CORS origins are restricted. By default, the only allowed CORS origin is ``http://localhost`` (``NEST_SERVER_CORS_ORIGINS=localhost``). * Only API calls are enabled. By default, the exec call is disabled (``NEST_SERVER_ENABLE_EXEC_CALL=0``). * The code execution is restricted. By default, the restriction is activated (``NEST_SERVER_DISABLE_RESTRICTION=0``). diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index c0bbacddc9..819361f0d6 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -53,7 +53,7 @@ def get_boolean_environ(env_key, default_value='false'): return env_value.lower() in ['yes', 'true', 't', '1'] -_default_origins = 'localhost,http://localhost,https://localhost' +_default_origins = 'http://localhost' AUTH_DISABLED = get_boolean_environ('NEST_SERVER_DISABLE_AUTH') CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', _default_origins).split(',') EXEC_CALL_ENABLED = get_boolean_environ('NEST_SERVER_ENABLE_EXEC_CALL') From 4327088c5ee1fcff8afc5092c67f8706a794ba55 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Tue, 18 Jul 2023 12:06:04 +0200 Subject: [PATCH 113/168] Add option to apply user-custom token --- pynest/nest/server/hl_api_server.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 819361f0d6..154a3c6ac4 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -54,6 +54,7 @@ def get_boolean_environ(env_key, default_value='false'): _default_origins = 'http://localhost' +ACCESS_TOKEN = os.environ.get('NEST_SERVER_ACCESS_TOKEN', '') AUTH_DISABLED = get_boolean_environ('NEST_SERVER_DISABLE_AUTH') CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', _default_origins).split(',') EXEC_CALL_ENABLED = get_boolean_environ('NEST_SERVER_ENABLE_EXEC_CALL') @@ -119,6 +120,9 @@ def setup_auth(): import hashlib # noqa import hmac # noqa + if ACCESS_TOKEN: + self._hash = ACCESS_TOKEN + # Find our reference to the current function in the garbage collector. frame = inspect.currentframe() code = frame.f_code From e38128b995c9f7ec018be5e441c7c344743e5d9d Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Tue, 18 Jul 2023 12:57:40 +0200 Subject: [PATCH 114/168] Resolve merge conflicts --- doc/htmldoc/whats_new/v3.4/index.rst | 47 ++---- pynest/nest/server/hl_api_server.py | 233 ++++++++++----------------- 2 files changed, 102 insertions(+), 178 deletions(-) diff --git a/doc/htmldoc/whats_new/v3.4/index.rst b/doc/htmldoc/whats_new/v3.4/index.rst index 1d63e2ac91..a57ce8bd48 100644 --- a/doc/htmldoc/whats_new/v3.4/index.rst +++ b/doc/htmldoc/whats_new/v3.4/index.rst @@ -3,16 +3,16 @@ What's new in NEST 3.4 ====================== -This page contains a summary of important breaking and non-breaking -changes from NEST 3.3 to NEST 3.4. In addition to the `release notes -on GitHub `_, this -page also contains transition information that helps you to update -your simulation scripts when you come from an older version of NEST. +This page contains a summary of important breaking and non-breaking changes +from NEST 3.3 to NEST 3.4. In addition to the `release +notes on GitHub `_, +this page also contains transition information that helps you to +update your simulation scripts when you come from an older version of +NEST. -If you transition from an earlier version, please see our extensive -:ref:`transition guide from NEST 2.x to 3.0 ` and the -:ref:`list of updates for previous releases in the 3.x series -`. +If you transition from a version earlier than 3.3, please see our +extensive :ref:`transition guide from NEST 2.x to 3.0 +` or :ref:`release updates for previous releases in 3.x `. Documentation restructuring and new theme ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -23,18 +23,12 @@ layout, our wide range of docs can be discovered more easily. The table of contents is simplified and the content is grouped based on topic (neurons, synapses etc) rather than type of documentation (e.g., 'guides'). -The table of contents is simplified and the content is grouped based -on topics (neurons, synapses etc) rather than type of documentation -(e.g., 'guides'). -We would be highly interested in any feedback you might have on the -new look-and-feel either on `our mailing list -`_ or as an `issue on -GitHub -`_ +Changes in NEST behavior +~~~~~~~~~~~~~~~~~~~~~~~~ -Query spatially structured networks from target neuron perspective -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Inferred extent of spatial layers with freely placed neurons +............................................................ Spatial layers can be created by specifying only the node positions using ``spatial.free``, without explicitly specifying the ``extent``. @@ -43,18 +37,11 @@ lower-leftmost and upper-rightmost nodes in the layer; earlier versions of NEST padding to the extent. The ``center`` is computed as the midpoint between the lower-leftmost and upper-rightmost nodes. -Extent and center for spatial layers with freely placed neurons -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +When creating a layer with only a single node, the ``extent`` has to be specified explicitly. -Spatial layers in NEST can be created by specifying node positions in -the call to :py:func:`.Create` using :ref:`spatial distributions ` -from ``nest.spatial``. -When using :py:class:`.spatial.free`, the layer's ``extent`` will be -determined automatically based on the positions of the lower-leftmost -and upper-rightmost nodes in the layer, if omitted. While earlier -versions of NEST added a hard-coded padding, NEST 3.4 will only use -the node positions. +Deprecation information +~~~~~~~~~~~~~~~~~~~~~~~ * Model ``spike_dilutor`` is now deprecated and can only be used in single-threaded mode. To implement connections which transmit @@ -69,4 +56,4 @@ Changes in NEST Server * Requests require Bearer tokens. By default, the authentication is on (``NEST_SERVER_DISABLE_AUTH=0``). * The CORS origins are restricted. By default, the only allowed CORS origin is ``http://localhost`` (``NEST_SERVER_CORS_ORIGINS=localhost``). * Only API calls are enabled. By default, the exec call is disabled (``NEST_SERVER_ENABLE_EXEC_CALL=0``). - * The code execution is restricted. By default, the restriction is activated (``NEST_SERVER_DISABLE_RESTRICTION=0``). + * The code execution is restricted. By default, the restriction is activated (``NEST_SERVER_DISABLE_RESTRICTION=0``). \ No newline at end of file diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 154a3c6ac4..fcd7dc6427 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -63,11 +63,11 @@ def get_boolean_environ(env_key, default_value='false'): EXCEPTION_ERROR_STATUS = 400 __all__ = [ - "app", - "do_exec", - "set_mpi_comm", - "run_mpi_app", - "nestify", + 'app', + 'do_exec', + 'set_mpi_comm', + 'run_mpi_app', + 'nestify', ] app = Flask(__name__) @@ -120,9 +120,6 @@ def setup_auth(): import hashlib # noqa import hmac # noqa - if ACCESS_TOKEN: - self._hash = ACCESS_TOKEN - # Find our reference to the current function in the garbage collector. frame = inspect.currentframe() code = frame.f_code @@ -137,6 +134,10 @@ def setup_auth(): if len(funcs) > 1: return ("Unauthorized", 403) self = funcs[0] + + if ACCESS_TOKEN: + self._hash = ACCESS_TOKEN + # Use the salted hash (unless `PYTHONHASHSEED` is fixed) of the location of this # function in the Python heap and the current timestamp to create a SHA512 hash. if not hasattr(self, "_hash"): @@ -178,78 +179,6 @@ def setup_auth(): print( 80 * '*') -@app.before_request -def setup_auth(): - """ - Authentication function that generates and validates the Authorization header with a - bearer token. - - Cleans up references to itself and the running `app` from this module, as it may be - accessible when the code execution sandbox fails. - """ - try: - # Import the modules inside of the auth function, so that if they fail the auth - # returns a forbidden error. - import inspect # noqa - import gc # noqa - import time # noqa - import hashlib # noqa - import hmac # noqa - - # Find our reference to the current function in the garbage collector. - frame = inspect.currentframe() - code = frame.f_code - globs = frame.f_globals - functype = type(lambda: 0) - funcs = [] - for func in gc.get_referrers(code): - if type(func) is functype: - if getattr(func, "__code__", None) is code: - if getattr(func, "__globals__", None) is globs: - funcs.append(func) - if len(funcs) > 1: - return ("Unauthorized", 403) - self = funcs[0] - # Use the salted hash (unless `PYTHONHASHSEED` is fixed) of the location of this - # function in the Python heap and the current timestamp to create a SHA512 hash. - if not hasattr(self, "_hash"): - hasher = hashlib.sha512() - hasher.update(str(hash(id(self))).encode("utf-8")) - hasher.update(str(time.perf_counter()).encode("utf-8")) - self._hash = hasher.hexdigest() - if not DISABLE_AUTHENTICATION: - print("") - print(" Bearer token to login to the NEST server with: ", self._hash) - print("") - # The first time we hit the line below is when below the function definition we - # call `setup_auth` without any Flask request existing yet, so the function errors - # and exits here after generating and storing the auth hash. - auth = request.headers.get("Authorization", None) - # We continue here the next time this function is called, before the Flask app - # handles the first request. At that point we also remove this module's reference - # to the running app. - try: - del globals()["app"] - except KeyError: - pass - # Things get more straightforward here: Every time a request is handled, compare - # the Authorization header to the hash, with a constant-time algorithm to avoid - # timing attacks. - if not ( - DISABLE_AUTHENTICATION - or hmac.compare_digest(auth, f"Bearer {self._hash}") - ): - return ("Unauthorized", 403) - # DON'T LINT! Intentional bare except clause! Even `KeyboardInterrupt` and - # `SystemExit` exceptions should not bypass authentication! - except: # noqa - return ("Unauthorized", 403) - - -setup_auth() -del setup_auth - - @app.route('/', methods=['GET']) def index(): return jsonify({ @@ -260,7 +189,7 @@ def index(): def do_exec(args, kwargs): try: - source_code = kwargs.get("source", "") + source_code = kwargs.get('source', '') source_cleaned = clean_code(source_code) locals_ = dict() @@ -271,7 +200,7 @@ def do_exec(args, kwargs): globals_.update(get_modules_from_env()) exec(source_cleaned, globals_, locals_) if len(stdout) > 0: - response["stdout"] = "\n".join(stdout) + response['stdout'] = '\n'.join(stdout) else: code = RestrictedPython.compile_restricted(source_cleaned, "", "exec") # noqa globals_ = get_restricted_globals() @@ -280,10 +209,10 @@ def do_exec(args, kwargs): if "_print" in locals_: response["stdout"] = "".join(locals_["_print"].txt) - if "return" in kwargs: - if isinstance(kwargs["return"], list): + if 'return' in kwargs: + if isinstance(kwargs['return'], list): data = dict() - for variable in kwargs["return"]: + for variable in kwargs['return']: data[variable] = locals_.get(variable, None) else: data = locals_.get(kwargs["return"], None) @@ -297,7 +226,7 @@ def do_exec(args, kwargs): def log(call_name, msg): - msg = f"==> MASTER 0/{time.time():.7f} ({call_name}): {msg}" + msg = f'==> MASTER 0/{time.time():.7f} ({call_name}): {msg}' print(msg, flush=True) @@ -325,31 +254,32 @@ def do_call(call_name, args=[], kwargs={}): assert mpi_comm.Get_rank() == 0 if mpi_comm is not None: - log(call_name, "sending call bcast") + log(call_name, 'sending call bcast') mpi_comm.bcast(call_name, root=0) data = (args, kwargs) - log(call_name, f"sending data bcast, data={data}") + log(call_name, f'sending data bcast, data={data}') mpi_comm.bcast(data, root=0) - if call_name == "exec": + if call_name == 'exec': master_response = do_exec(args, kwargs) else: call, args, kwargs = nestify(call_name, args, kwargs) - log(call_name, f"local call, args={args}, kwargs={kwargs}") + log(call_name, f'local call, args={args}, kwargs={kwargs}') master_response = call(*args, **kwargs) response = [master_response] if mpi_comm is not None: - log(call_name, "waiting for response gather") + log(call_name, 'waiting for response gather') response = mpi_comm.gather(response[0], root=0) - log(call_name, f"received response gather, data={response}") + log(call_name, f'received response gather, data={response}') return combine(call_name, response) @app.route('/exec', methods=['GET', 'POST']) def route_exec(): - """Route to execute script in Python.""" + """ Route to execute script in Python. + """ if EXEC_CALL_ENABLED: args, kwargs = get_arguments(request) @@ -373,13 +303,15 @@ def route_exec(): @app.route('/api', methods=['GET']) def route_api(): - """Route to list call functions in NEST.""" + """ Route to list call functions in NEST. + """ return jsonify(nest_calls) @app.route('/api/', methods=['GET', 'POST']) def route_api_call(call): - """Route to call function in NEST.""" + """ Route to call function in NEST. + """ print(f"\n{'='*40}\n", flush=True) args, kwargs = get_arguments(request) log("route_api_call", f"call={call}, args={args}, kwargs={kwargs}") @@ -391,7 +323,6 @@ def route_api_call(call): # Helpers for the server # ---------------------- - class Capturing(list): """ Monitor stdout contents i.e. print. """ @@ -402,18 +333,19 @@ def __enter__(self): def __exit__(self, *args): self.extend(self._stringio.getvalue().splitlines()) - del self._stringio # free up some memory + del self._stringio # free up some memory sys.stdout = self._stdout def clean_code(source): - codes = source.split("\n") - code_cleaned = filter(lambda code: not (code.startswith("import") or code.startswith("from")), codes) # noqa - return "\n".join(code_cleaned) + codes = source.split('\n') + code_cleaned = filter(lambda code: not (code.startswith('import') or code.startswith('from')), codes) # noqa + return '\n'.join(code_cleaned) def get_arguments(request): - """Get arguments from the request.""" + """ Get arguments from the request. + """ args, kwargs = [], {} if request.is_json: json = request.get_json() @@ -423,16 +355,16 @@ def get_arguments(request): args = json elif isinstance(json, dict): kwargs = json - if "args" in kwargs: - args = kwargs.pop("args") + if 'args' in kwargs: + args = kwargs.pop('args') elif len(request.form) > 0: - if "args" in request.form: - args = request.form.getlist("args") + if 'args' in request.form: + args = request.form.getlist('args') else: kwargs = request.form.to_dict() elif len(request.args) > 0: - if "args" in request.args: - args = request.args.getlist("args") + if 'args' in request.args: + args = request.args.getlist('args') else: kwargs = request.args.to_dict() return list(args), kwargs @@ -465,8 +397,8 @@ def get_modules_from_env(): def get_or_error(func): - """Wrapper to get data and status.""" - + """ Wrapper to get data and status. + """ def func_wrapper(call, args, kwargs): try: return func(call, args, kwargs) @@ -478,8 +410,8 @@ def func_wrapper(call, args, kwargs): def get_restricted_globals(): - """Get restricted globals for exec function.""" - + """ Get restricted globals for exec function. + """ def getitem(obj, index): typelist = (list, tuple, dict, nest.NodeCollection) if obj is not None and type(obj) in typelist: @@ -490,14 +422,12 @@ def getitem(obj, index): restricted_builtins = RestrictedPython.safe_builtins.copy() restricted_builtins.update(RestrictedPython.limited_builtins) restricted_builtins.update(RestrictedPython.utility_builtins) - restricted_builtins.update( - dict( - max=max, - min=min, - sum=sum, - time=time, - ) - ) + restricted_builtins.update(dict( + max=max, + min=min, + sum=sum, + time=time, + )) restricted_globals = dict( __builtins__=restricted_builtins, @@ -513,13 +443,15 @@ def getitem(obj, index): def nestify(call_name, args, kwargs): - """Get the NEST API call and convert arguments if neccessary.""" + """ Get the NEST API call and convert arguments if neccessary. + """ call = getattr(nest, call_name) - objectnames = ["nodes", "source", "target", "pre", "post"] + objectnames = ['nodes', 'source', 'target', 'pre', 'post'] paramKeys = list(inspect.signature(call).parameters.keys()) - args = [nest.NodeCollection(arg) if paramKeys[idx] in objectnames else arg for (idx, arg) in enumerate(args)] - for key, value in kwargs.items(): + args = [nest.NodeCollection(arg) if paramKeys[idx] in objectnames + else arg for (idx, arg) in enumerate(args)] + for (key, value) in kwargs.items(): if key in objectnames: kwargs[key] = nest.NodeCollection(value) @@ -528,13 +460,16 @@ def nestify(call_name, args, kwargs): @get_or_error def api_client(call_name, args, kwargs): - """API Client to call function in NEST.""" + """ API Client to call function in NEST. + """ call = getattr(nest, call_name) if callable(call): - if "inspect" in kwargs: - response = {"data": getattr(inspect, kwargs["inspect"])(call)} + if 'inspect' in kwargs: + response = { + 'data': getattr(inspect, kwargs['inspect'])(call) + } else: response = do_call(call_name, args, kwargs) else: @@ -556,7 +491,7 @@ def run_mpi_app(host="127.0.0.1", port=52425): def combine(call_name, response): - """Combine responses from different MPI processes. + """ Combine responses from different MPI processes. In a distributed scenario, each MPI process creates its own share of the response from the data available locally. To present a @@ -600,7 +535,8 @@ def combine(call_name, response): return None # return the master response if all responses are known to be the same - if call_name in ("exec", "Create", "GetDefaults", "GetKernelStatus", "SetKernelStatus", "SetStatus"): + if call_name in ('exec', 'Create', 'GetDefaults', 'GetKernelStatus', + 'SetKernelStatus', 'SetStatus'): return response[0] # return a single response if there is only one which is not None @@ -618,7 +554,7 @@ def combine(call_name, response): log("combine()", f"ERROR: cannot combine response={response}") msg = "Cannot combine data because of unknown reason" - raise Exception(msg) # pylint: disable=W0719 + raise Exception(msg) def merge_dicts(response): @@ -638,49 +574,50 @@ def merge_dicts(response): result = [] for device_dicts in zip(*response): + # TODO: either stip fields like thread, vp, thread_local_id, # and local or make them lists that contain the values from # all dicts. - element_type = device_dicts[0]["element_type"] + element_type = device_dicts[0]['element_type'] - if element_type not in ("neuron", "recorder", "stimulator"): + if element_type not in ('neuron', 'recorder', 'stimulator'): msg = f'Cannot combine data of element with type "{element_type}".' - raise Exception(msg) # pylint: disable=W0719 + raise Exception(msg) - if element_type == "neuron": - tmp = list(filter(lambda status: status["local"], device_dicts)) + if element_type == 'neuron': + tmp = list(filter(lambda status: status['local'], device_dicts)) assert len(tmp) == 1 result.append(tmp[0]) - if element_type == "recorder": + if element_type == 'recorder': tmp = deepcopy(device_dicts[0]) - tmp["n_events"] = 0 + tmp['n_events'] = 0 for device_dict in device_dicts: - tmp["n_events"] += device_dict["n_events"] + tmp['n_events'] += device_dict['n_events'] - record_to = tmp["record_to"] - if record_to not in ("ascii", "memory"): + record_to = tmp['record_to'] + if record_to not in ('ascii', 'memory'): msg = f'Cannot combine data when recording to "{record_to}".' - raise Exception(msg) # pylint: disable=W0719 + raise Exception(msg) - if record_to == "memory": - event_keys = tmp["events"].keys() + if record_to == 'memory': + event_keys = tmp['events'].keys() for key in event_keys: - tmp["events"][key] = [] + tmp['events'][key] = [] for device_dict in device_dicts: for key in event_keys: - tmp["events"][key].extend(device_dict["events"][key]) + tmp['events'][key].extend(device_dict['events'][key]) - if record_to == "ascii": - tmp["filenames"] = [] + if record_to == 'ascii': + tmp['filenames'] = [] for device_dict in device_dicts: - tmp["filenames"].extend(device_dict["filenames"]) + tmp['filenames'].extend(device_dict['filenames']) result.append(tmp) - if element_type == "stimulator": + if element_type == 'stimulator': result.append(device_dicts[0]) return result From 54581f1ea1cd54c19615dd99e48089da37ffa5b3 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Thu, 27 Oct 2022 12:58:53 +0200 Subject: [PATCH 115/168] Add cross origin for / --- pynest/nest/server/hl_api_server.py | 1 + 1 file changed, 1 insertion(+) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index fcd7dc6427..7cb221633f 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -180,6 +180,7 @@ def setup_auth(): @app.route('/', methods=['GET']) +@cross_origin() def index(): return jsonify({ 'nest': nest.__version__, From 84d5580e061a8892eeaea647bf86290036164cd3 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Tue, 18 Jul 2023 13:11:09 +0200 Subject: [PATCH 116/168] Add changes notes for nest server --- doc/htmldoc/whats_new/changes.rst | 10 ++++++++++ 1 file changed, 10 insertions(+) create mode 100644 doc/htmldoc/whats_new/changes.rst diff --git a/doc/htmldoc/whats_new/changes.rst b/doc/htmldoc/whats_new/changes.rst new file mode 100644 index 0000000000..f7593baf99 --- /dev/null +++ b/doc/htmldoc/whats_new/changes.rst @@ -0,0 +1,10 @@ + +Changes in NEST Server +~~~~~~~~~~~~~~~~~~~~~~ + +* Improve the security in NEST Server. The user can modify the security options in environment variables: + * Requests require Bearer tokens. By default, the authentication is on (``NEST_SERVER_DISABLE_AUTH=0``). + * The CORS origins are restricted. By default, the only allowed CORS origin is ``http://localhost`` (``NEST_SERVER_CORS_ORIGINS=localhost``). + * Only API calls are enabled. By default, the exec call is disabled (``NEST_SERVER_ENABLE_EXEC_CALL=0``). + * The code execution is restricted. By default, the restriction is activated (``NEST_SERVER_DISABLE_RESTRICTION=0``). + * NEST Server takes also custom token (``NEST_SERVER_ACCESS_TOKEN='abcdefghijk'``) \ No newline at end of file From b6792d5a0596e01af9d649586c0d4298fca7b80e Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Tue, 18 Jul 2023 15:32:36 +0200 Subject: [PATCH 117/168] Fix correct sytax for custom token --- pynest/nest/server/hl_api_server.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 7cb221633f..4a61d0eeec 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -135,16 +135,16 @@ def setup_auth(): return ("Unauthorized", 403) self = funcs[0] - if ACCESS_TOKEN: - self._hash = ACCESS_TOKEN - # Use the salted hash (unless `PYTHONHASHSEED` is fixed) of the location of this # function in the Python heap and the current timestamp to create a SHA512 hash. if not hasattr(self, "_hash"): - hasher = hashlib.sha512() - hasher.update(str(hash(id(self))).encode("utf-8")) - hasher.update(str(time.perf_counter()).encode("utf-8")) - self._hash = hasher.hexdigest()[:48] + if ACCESS_TOKEN: + self._hash = ACCESS_TOKEN + else: + hasher = hashlib.sha512() + hasher.update(str(hash(id(self))).encode("utf-8")) + hasher.update(str(time.perf_counter()).encode("utf-8")) + self._hash = hasher.hexdigest()[:48] if not AUTH_DISABLED: print(f"\nBearer token to NEST server: {self._hash}\n") # The first time we hit the line below is when below the function definition we From 776af77358d831c6e3b1999b97b7e21756f52470 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Wed, 19 Jul 2023 10:47:57 +0200 Subject: [PATCH 118/168] Do not auth for OPTIONS method --- pynest/nest/server/hl_api_server.py | 25 ++++++++++++++----------- 1 file changed, 14 insertions(+), 11 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 4a61d0eeec..33ca9c612c 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -26,6 +26,7 @@ import io import sys +import flask from flask import Flask, request, jsonify from flask_cors import CORS from flask.logging import default_handler @@ -73,19 +74,19 @@ def get_boolean_environ(env_key, default_value='false'): app = Flask(__name__) # Inform client-side user agents that they should not attempt to call our server from any # non-whitelisted domain. -CORS(app, origins=CORS_ORIGINS, methods=["GET", "POST"]) +CORS(app, origins=CORS_ORIGINS, methods=['GET', 'POST']) mpi_comm = None -def check_security(): +def _check_security(): """ Checks the security level of the NEST Server instance. """ msg = [] if AUTH_DISABLED: - msg.append('AUTH:\tThe authentication is disabled.') + msg.append('AUTH:\tThe authorization is disabled.') if '*' in CORS_ORIGINS: msg.append('CORS:\tAllowed origins is not restricted.') if EXEC_CALL_ENABLED: @@ -93,17 +94,15 @@ def check_security(): if RESTRICTION_DISABLED: msg.append('RESTRICTION: Code scripts will be executed without a restricted environment.') - level = ['HIGHEST', 'HIGH', 'MODERATE', 'LOW', 'LOWEST'] - print(f'The security level of NEST Server is {level[len(msg)]}.') if len(msg) > 0: print('WARNING: The security of your system can not be ensured!') print('\n - '.join([' '] + msg) + '\n') else: - print('INFO: The security of your system can be ensured!') + print('INFO: The security of your system can be ensured!\n') @app.before_request -def setup_auth(): +def _setup_auth(): """ Authentication function that generates and validates the Authorization header with a bearer token. @@ -146,7 +145,11 @@ def setup_auth(): hasher.update(str(time.perf_counter()).encode("utf-8")) self._hash = hasher.hexdigest()[:48] if not AUTH_DISABLED: - print(f"\nBearer token to NEST server: {self._hash}\n") + print(f" Bearer token to NEST server: {self._hash}\n") + + if request.method == 'OPTIONS': + return + # The first time we hit the line below is when below the function definition we # call `setup_auth` without any Flask request existing yet, so the function errors # and exits here after generating and storing the auth hash. @@ -173,9 +176,9 @@ def setup_auth(): print( 80 * '*') -check_security() -setup_auth() -del setup_auth +_check_security() +_setup_auth() +del _setup_auth print( 80 * '*') From 11a3d38bb4564b5834ff01cab47154404156440e Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Wed, 19 Jul 2023 11:28:38 +0200 Subject: [PATCH 119/168] Undo doc for v3.4 --- doc/htmldoc/whats_new/v3.4/index.rst | 105 +++++++++++++++++---------- 1 file changed, 67 insertions(+), 38 deletions(-) diff --git a/doc/htmldoc/whats_new/v3.4/index.rst b/doc/htmldoc/whats_new/v3.4/index.rst index a57ce8bd48..be69bbaa9a 100644 --- a/doc/htmldoc/whats_new/v3.4/index.rst +++ b/doc/htmldoc/whats_new/v3.4/index.rst @@ -3,57 +3,86 @@ What's new in NEST 3.4 ====================== -This page contains a summary of important breaking and non-breaking changes -from NEST 3.3 to NEST 3.4. In addition to the `release -notes on GitHub `_, -this page also contains transition information that helps you to -update your simulation scripts when you come from an older version of -NEST. +This page contains a summary of important breaking and non-breaking +changes from NEST 3.3 to NEST 3.4. In addition to the `release notes +on GitHub `_, this +page also contains transition information that helps you to update +your simulation scripts when you come from an older version of NEST. -If you transition from a version earlier than 3.3, please see our -extensive :ref:`transition guide from NEST 2.x to 3.0 -` or :ref:`release updates for previous releases in 3.x `. +If you transition from an earlier version, please see our extensive +:ref:`transition guide from NEST 2.x to 3.0 ` and the +:ref:`list of updates for previous releases in the 3.x series +`. Documentation restructuring and new theme ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -NEST documentation has a new theme! We did a major overhaul of the layout and structure of the documentation. -The changes aim to improve findability and access of content. With a more modern -layout, our wide range of docs can be discovered more easily. -The table of contents is simplified and the content is grouped based on topic (neurons, synapses etc) -rather than type of documentation (e.g., 'guides'). +NEST documentation has a new theme! We did a major overhaul of the +layout and structure of the documentation. The changes aim to improve +findability and access of content. With a more modern layout, our wide +range of docs can be discovered more easily. +The table of contents is simplified and the content is grouped based +on topics (neurons, synapses etc) rather than type of documentation +(e.g., 'guides'). -Changes in NEST behavior -~~~~~~~~~~~~~~~~~~~~~~~~ +We would be highly interested in any feedback you might have on the +new look-and-feel either on `our mailing list +`_ or as an `issue on +GitHub +`_ -Inferred extent of spatial layers with freely placed neurons -............................................................ +Query spatially structured networks from target neuron perspective +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -Spatial layers can be created by specifying only the node positions using ``spatial.free``, -without explicitly specifying the ``extent``. -In that case, in NEST 3.4 and later, the ``extent`` will be determined by the position of the -lower-leftmost and upper-rightmost nodes in the layer; earlier versions of NEST added a hard-coded -padding to the extent. The ``center`` is computed as the midpoint between the lower-leftmost and -upper-rightmost nodes. +PyNEST now provides functions :py:func:`.GetSourceNodes`, +:py:func:`.GetSourcePositions`, and :py:func:`.PlotSources` which +allow you to query or plot the source neurons of a given target +neuron. -When creating a layer with only a single node, the ``extent`` has to be specified explicitly. +Extent and center for spatial layers with freely placed neurons +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Spatial layers in NEST can be created by specifying node positions in +the call to :py:func:`.Create` using :ref:`spatial distributions ` +from ``nest.spatial``. -Deprecation information -~~~~~~~~~~~~~~~~~~~~~~~ +When using :py:class:`.spatial.free`, the layer's ``extent`` will be +determined automatically based on the positions of the lower-leftmost +and upper-rightmost nodes in the layer, if omitted. While earlier +versions of NEST added a hard-coded padding, NEST 3.4 will only use +the node positions. -* Model ``spike_dilutor`` is now deprecated and can only be used - in single-threaded mode. To implement connections which transmit - spikes with fixed probability, use ``bernoulli_synapse`` instead. +Likewise, the ``center`` of a layer is now automatically computed as +the midpoint between the lower-leftmost and the upper-rightmost nodes. +When creating a layer with only a single node, the ``extent`` still +has to be specified explicitly. -Changes in NEST Server -~~~~~~~~~~~~~~~~~~~~~~ +Disconnect with ``SynapseCollection`` +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -* By default, the NEST Server now runs on port ``52425`` (previously ``5000``). -* Improve the security in NEST Server. The user can modify the security options in environment variables: - * Requests require Bearer tokens. By default, the authentication is on (``NEST_SERVER_DISABLE_AUTH=0``). - * The CORS origins are restricted. By default, the only allowed CORS origin is ``http://localhost`` (``NEST_SERVER_CORS_ORIGINS=localhost``). - * Only API calls are enabled. By default, the exec call is disabled (``NEST_SERVER_ENABLE_EXEC_CALL=0``). - * The code execution is restricted. By default, the restriction is activated (``NEST_SERVER_DISABLE_RESTRICTION=0``). \ No newline at end of file +It is now possible to disconnect nodes using a ``SynapseCollection`` +as argument to either :py:func:`.disconnect` or the member function +``disconnect()`` of the ``SynapseCollection``. + +Removal of deprecated models +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +* The models ``iaf_psc_alpha_canon`` and ``pp_pop_psc_delta`` have + long been deprecated and were now removed from NEST. In case you + depend on them, you will find similar functionality in the + replacement models :doc:`iaf_psc_alpha_ps + ` and :doc:`iaf_psc_alpha_ps + `, respectively. + +* Model ``spike_dilutor`` is now deprecated and can only be used in + single-threaded mode. To implement connections which transmit spikes + with fixed probability, use :doc:`bernoulli_synapse + ` instead. + +Changed port of NEST Server +~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +To avoid conflicts with other services, the default port for NEST +Server has been changed from 5000 to 52025. From ee005640dd6bf8d4a584257e98a2844f0be2e2e4 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Wed, 19 Jul 2023 11:30:27 +0200 Subject: [PATCH 120/168] Use black --- pynest/nest/server/hl_api_server.py | 219 ++++++++++++++-------------- 1 file changed, 106 insertions(+), 113 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 33ca9c612c..02cc81fb5f 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -49,32 +49,32 @@ root.addHandler(default_handler) -def get_boolean_environ(env_key, default_value='false'): +def get_boolean_environ(env_key, default_value="false"): env_value = os.environ.get(env_key, default_value) - return env_value.lower() in ['yes', 'true', 't', '1'] + return env_value.lower() in ["yes", "true", "t", "1"] -_default_origins = 'http://localhost' -ACCESS_TOKEN = os.environ.get('NEST_SERVER_ACCESS_TOKEN', '') -AUTH_DISABLED = get_boolean_environ('NEST_SERVER_DISABLE_AUTH') -CORS_ORIGINS = os.environ.get('NEST_SERVER_CORS_ORIGINS', _default_origins).split(',') -EXEC_CALL_ENABLED = get_boolean_environ('NEST_SERVER_ENABLE_EXEC_CALL') -MODULES = os.environ.get('NEST_SERVER_MODULES', 'nest').split(',') -RESTRICTION_DISABLED = get_boolean_environ('NEST_SERVER_DISABLE_RESTRICTION') +_default_origins = "http://localhost" +ACCESS_TOKEN = os.environ.get("NEST_SERVER_ACCESS_TOKEN", "") +AUTH_DISABLED = get_boolean_environ("NEST_SERVER_DISABLE_AUTH") +CORS_ORIGINS = os.environ.get("NEST_SERVER_CORS_ORIGINS", _default_origins).split(",") +EXEC_CALL_ENABLED = get_boolean_environ("NEST_SERVER_ENABLE_EXEC_CALL") +MODULES = os.environ.get("NEST_SERVER_MODULES", "nest").split(",") +RESTRICTION_DISABLED = get_boolean_environ("NEST_SERVER_DISABLE_RESTRICTION") EXCEPTION_ERROR_STATUS = 400 __all__ = [ - 'app', - 'do_exec', - 'set_mpi_comm', - 'run_mpi_app', - 'nestify', + "app", + "do_exec", + "set_mpi_comm", + "run_mpi_app", + "nestify", ] app = Flask(__name__) # Inform client-side user agents that they should not attempt to call our server from any # non-whitelisted domain. -CORS(app, origins=CORS_ORIGINS, methods=['GET', 'POST']) +CORS(app, origins=CORS_ORIGINS, methods=["GET", "POST"]) mpi_comm = None @@ -86,19 +86,19 @@ def _check_security(): msg = [] if AUTH_DISABLED: - msg.append('AUTH:\tThe authorization is disabled.') - if '*' in CORS_ORIGINS: - msg.append('CORS:\tAllowed origins is not restricted.') + msg.append("AUTH:\tThe authorization is disabled.") + if "*" in CORS_ORIGINS: + msg.append("CORS:\tAllowed origins is not restricted.") if EXEC_CALL_ENABLED: - msg.append('EXEC CALL:\tAny code scripts can be executed!') + msg.append("EXEC CALL:\tAny code scripts can be executed!") if RESTRICTION_DISABLED: - msg.append('RESTRICTION: Code scripts will be executed without a restricted environment.') + msg.append("RESTRICTION: Code scripts will be executed without a restricted environment.") if len(msg) > 0: - print('WARNING: The security of your system can not be ensured!') - print('\n - '.join([' '] + msg) + '\n') + print("WARNING: The security of your system can not be ensured!") + print("\n - ".join([" "] + msg) + "\n") else: - print('INFO: The security of your system can be ensured!\n') + print("INFO: The security of your system can be ensured!\n") @app.before_request @@ -147,7 +147,7 @@ def _setup_auth(): if not AUTH_DISABLED: print(f" Bearer token to NEST server: {self._hash}\n") - if request.method == 'OPTIONS': + if request.method == "OPTIONS": return # The first time we hit the line below is when below the function definition we @@ -164,10 +164,7 @@ def _setup_auth(): # Things get more straightforward here: Every time a request is handled, compare # the Authorization header to the hash, with a constant-time algorithm to avoid # timing attacks. - if not ( - AUTH_DISABLED - or hmac.compare_digest(auth, f"Bearer {self._hash}") - ): + if not (AUTH_DISABLED or hmac.compare_digest(auth, f"Bearer {self._hash}")): return ("Unauthorized", 403) # DON'T LINT! Intentional bare except clause! Even `KeyboardInterrupt` and # `SystemExit` exceptions should not bypass authentication! @@ -175,25 +172,27 @@ def _setup_auth(): return ("Unauthorized", 403) -print( 80 * '*') +print(80 * "*") _check_security() _setup_auth() del _setup_auth -print( 80 * '*') +print(80 * "*") -@app.route('/', methods=['GET']) +@app.route("/", methods=["GET"]) @cross_origin() def index(): - return jsonify({ - 'nest': nest.__version__, - 'mpi': mpi_comm is not None, - }) + return jsonify( + { + "nest": nest.__version__, + "mpi": mpi_comm is not None, + } + ) def do_exec(args, kwargs): try: - source_code = kwargs.get('source', '') + source_code = kwargs.get("source", "") source_cleaned = clean_code(source_code) locals_ = dict() @@ -204,7 +203,7 @@ def do_exec(args, kwargs): globals_.update(get_modules_from_env()) exec(source_cleaned, globals_, locals_) if len(stdout) > 0: - response['stdout'] = '\n'.join(stdout) + response["stdout"] = "\n".join(stdout) else: code = RestrictedPython.compile_restricted(source_cleaned, "", "exec") # noqa globals_ = get_restricted_globals() @@ -213,10 +212,10 @@ def do_exec(args, kwargs): if "_print" in locals_: response["stdout"] = "".join(locals_["_print"].txt) - if 'return' in kwargs: - if isinstance(kwargs['return'], list): + if "return" in kwargs: + if isinstance(kwargs["return"], list): data = dict() - for variable in kwargs['return']: + for variable in kwargs["return"]: data[variable] = locals_.get(variable, None) else: data = locals_.get(kwargs["return"], None) @@ -230,7 +229,7 @@ def do_exec(args, kwargs): def log(call_name, msg): - msg = f'==> MASTER 0/{time.time():.7f} ({call_name}): {msg}' + msg = f"==> MASTER 0/{time.time():.7f} ({call_name}): {msg}" print(msg, flush=True) @@ -258,41 +257,40 @@ def do_call(call_name, args=[], kwargs={}): assert mpi_comm.Get_rank() == 0 if mpi_comm is not None: - log(call_name, 'sending call bcast') + log(call_name, "sending call bcast") mpi_comm.bcast(call_name, root=0) data = (args, kwargs) - log(call_name, f'sending data bcast, data={data}') + log(call_name, f"sending data bcast, data={data}") mpi_comm.bcast(data, root=0) - if call_name == 'exec': + if call_name == "exec": master_response = do_exec(args, kwargs) else: call, args, kwargs = nestify(call_name, args, kwargs) - log(call_name, f'local call, args={args}, kwargs={kwargs}') + log(call_name, f"local call, args={args}, kwargs={kwargs}") master_response = call(*args, **kwargs) response = [master_response] if mpi_comm is not None: - log(call_name, 'waiting for response gather') + log(call_name, "waiting for response gather") response = mpi_comm.gather(response[0], root=0) - log(call_name, f'received response gather, data={response}') + log(call_name, f"received response gather, data={response}") return combine(call_name, response) -@app.route('/exec', methods=['GET', 'POST']) +@app.route("/exec", methods=["GET", "POST"]) def route_exec(): - """ Route to execute script in Python. - """ + """Route to execute script in Python.""" if EXEC_CALL_ENABLED: args, kwargs = get_arguments(request) - response = do_call('exec', args, kwargs) + response = do_call("exec", args, kwargs) return jsonify(response) else: flask.abort( 403, - 'The route `/exec` has been disabled. Please contact the server administrator.', + "The route `/exec` has been disabled. Please contact the server administrator.", ) @@ -301,21 +299,19 @@ def route_exec(): # -------------------------- nest_calls = dir(nest) -nest_calls = list(filter(lambda x: not x.startswith('_'), nest_calls)) +nest_calls = list(filter(lambda x: not x.startswith("_"), nest_calls)) nest_calls.sort() -@app.route('/api', methods=['GET']) +@app.route("/api", methods=["GET"]) def route_api(): - """ Route to list call functions in NEST. - """ + """Route to list call functions in NEST.""" return jsonify(nest_calls) -@app.route('/api/', methods=['GET', 'POST']) +@app.route("/api/", methods=["GET", "POST"]) def route_api_call(call): - """ Route to call function in NEST. - """ + """Route to call function in NEST.""" print(f"\n{'='*40}\n", flush=True) args, kwargs = get_arguments(request) log("route_api_call", f"call={call}, args={args}, kwargs={kwargs}") @@ -327,8 +323,9 @@ def route_api_call(call): # Helpers for the server # ---------------------- + class Capturing(list): - """ Monitor stdout contents i.e. print. """ + """Monitor stdout contents i.e. print.""" def __enter__(self): self._stdout = sys.stdout @@ -337,19 +334,18 @@ def __enter__(self): def __exit__(self, *args): self.extend(self._stringio.getvalue().splitlines()) - del self._stringio # free up some memory + del self._stringio # free up some memory sys.stdout = self._stdout def clean_code(source): - codes = source.split('\n') - code_cleaned = filter(lambda code: not (code.startswith('import') or code.startswith('from')), codes) # noqa - return '\n'.join(code_cleaned) + codes = source.split("\n") + code_cleaned = filter(lambda code: not (code.startswith("import") or code.startswith("from")), codes) # noqa + return "\n".join(code_cleaned) def get_arguments(request): - """ Get arguments from the request. - """ + """Get arguments from the request.""" args, kwargs = [], {} if request.is_json: json = request.get_json() @@ -359,16 +355,16 @@ def get_arguments(request): args = json elif isinstance(json, dict): kwargs = json - if 'args' in kwargs: - args = kwargs.pop('args') + if "args" in kwargs: + args = kwargs.pop("args") elif len(request.form) > 0: - if 'args' in request.form: - args = request.form.getlist('args') + if "args" in request.form: + args = request.form.getlist("args") else: kwargs = request.form.to_dict() elif len(request.args) > 0: - if 'args' in request.args: - args = request.args.getlist('args') + if "args" in request.args: + args = request.args.getlist("args") else: kwargs = request.args.to_dict() return list(args), kwargs @@ -401,8 +397,8 @@ def get_modules_from_env(): def get_or_error(func): - """ Wrapper to get data and status. - """ + """Wrapper to get data and status.""" + def func_wrapper(call, args, kwargs): try: return func(call, args, kwargs) @@ -410,12 +406,13 @@ def func_wrapper(call, args, kwargs): for line in traceback.format_exception(*sys.exc_info()): print(line, flush=True) flask.abort(EXCEPTION_ERROR_STATUS, str(e)) + return func_wrapper def get_restricted_globals(): - """ Get restricted globals for exec function. - """ + """Get restricted globals for exec function.""" + def getitem(obj, index): typelist = (list, tuple, dict, nest.NodeCollection) if obj is not None and type(obj) in typelist: @@ -426,12 +423,14 @@ def getitem(obj, index): restricted_builtins = RestrictedPython.safe_builtins.copy() restricted_builtins.update(RestrictedPython.limited_builtins) restricted_builtins.update(RestrictedPython.utility_builtins) - restricted_builtins.update(dict( - max=max, - min=min, - sum=sum, - time=time, - )) + restricted_builtins.update( + dict( + max=max, + min=min, + sum=sum, + time=time, + ) + ) restricted_globals = dict( __builtins__=restricted_builtins, @@ -447,14 +446,12 @@ def getitem(obj, index): def nestify(call_name, args, kwargs): - """ Get the NEST API call and convert arguments if neccessary. - """ + """Get the NEST API call and convert arguments if neccessary.""" call = getattr(nest, call_name) - objectnames = ['nodes', 'source', 'target', 'pre', 'post'] + objectnames = ["nodes", "source", "target", "pre", "post"] paramKeys = list(inspect.signature(call).parameters.keys()) - args = [nest.NodeCollection(arg) if paramKeys[idx] in objectnames - else arg for (idx, arg) in enumerate(args)] + args = [nest.NodeCollection(arg) if paramKeys[idx] in objectnames else arg for (idx, arg) in enumerate(args)] for (key, value) in kwargs.items(): if key in objectnames: kwargs[key] = nest.NodeCollection(value) @@ -464,16 +461,13 @@ def nestify(call_name, args, kwargs): @get_or_error def api_client(call_name, args, kwargs): - """ API Client to call function in NEST. - """ + """API Client to call function in NEST.""" call = getattr(nest, call_name) if callable(call): - if 'inspect' in kwargs: - response = { - 'data': getattr(inspect, kwargs['inspect'])(call) - } + if "inspect" in kwargs: + response = {"data": getattr(inspect, kwargs["inspect"])(call)} else: response = do_call(call_name, args, kwargs) else: @@ -495,7 +489,7 @@ def run_mpi_app(host="127.0.0.1", port=52425): def combine(call_name, response): - """ Combine responses from different MPI processes. + """Combine responses from different MPI processes. In a distributed scenario, each MPI process creates its own share of the response from the data available locally. To present a @@ -539,8 +533,7 @@ def combine(call_name, response): return None # return the master response if all responses are known to be the same - if call_name in ('exec', 'Create', 'GetDefaults', 'GetKernelStatus', - 'SetKernelStatus', 'SetStatus'): + if call_name in ("exec", "Create", "GetDefaults", "GetKernelStatus", "SetKernelStatus", "SetStatus"): return response[0] # return a single response if there is only one which is not None @@ -583,45 +576,45 @@ def merge_dicts(response): # and local or make them lists that contain the values from # all dicts. - element_type = device_dicts[0]['element_type'] + element_type = device_dicts[0]["element_type"] - if element_type not in ('neuron', 'recorder', 'stimulator'): + if element_type not in ("neuron", "recorder", "stimulator"): msg = f'Cannot combine data of element with type "{element_type}".' raise Exception(msg) - if element_type == 'neuron': - tmp = list(filter(lambda status: status['local'], device_dicts)) + if element_type == "neuron": + tmp = list(filter(lambda status: status["local"], device_dicts)) assert len(tmp) == 1 result.append(tmp[0]) - if element_type == 'recorder': + if element_type == "recorder": tmp = deepcopy(device_dicts[0]) - tmp['n_events'] = 0 + tmp["n_events"] = 0 for device_dict in device_dicts: - tmp['n_events'] += device_dict['n_events'] + tmp["n_events"] += device_dict["n_events"] - record_to = tmp['record_to'] - if record_to not in ('ascii', 'memory'): + record_to = tmp["record_to"] + if record_to not in ("ascii", "memory"): msg = f'Cannot combine data when recording to "{record_to}".' raise Exception(msg) - if record_to == 'memory': - event_keys = tmp['events'].keys() + if record_to == "memory": + event_keys = tmp["events"].keys() for key in event_keys: - tmp['events'][key] = [] + tmp["events"][key] = [] for device_dict in device_dicts: for key in event_keys: - tmp['events'][key].extend(device_dict['events'][key]) + tmp["events"][key].extend(device_dict["events"][key]) - if record_to == 'ascii': - tmp['filenames'] = [] + if record_to == "ascii": + tmp["filenames"] = [] for device_dict in device_dicts: - tmp['filenames'].extend(device_dict['filenames']) + tmp["filenames"].extend(device_dict["filenames"]) result.append(tmp) - if element_type == 'stimulator': + if element_type == "stimulator": result.append(device_dicts[0]) return result From 0642be20b1acccdeeaad0307159bb8afae461bb3 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Wed, 19 Jul 2023 11:33:13 +0200 Subject: [PATCH 121/168] Remove cors_origins() --- pynest/nest/server/hl_api_server.py | 1 - 1 file changed, 1 deletion(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 02cc81fb5f..ca4800520e 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -180,7 +180,6 @@ def _setup_auth(): @app.route("/", methods=["GET"]) -@cross_origin() def index(): return jsonify( { From 0a1d50449b138ec4f9828d6ccf0e6f69b6d833bb Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Wed, 19 Jul 2023 11:44:36 +0200 Subject: [PATCH 122/168] Update changes --- doc/htmldoc/whats_new/changes.rst | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/doc/htmldoc/whats_new/changes.rst b/doc/htmldoc/whats_new/changes.rst index f7593baf99..a90209d711 100644 --- a/doc/htmldoc/whats_new/changes.rst +++ b/doc/htmldoc/whats_new/changes.rst @@ -4,7 +4,8 @@ Changes in NEST Server * Improve the security in NEST Server. The user can modify the security options in environment variables: * Requests require Bearer tokens. By default, the authentication is on (``NEST_SERVER_DISABLE_AUTH=0``). - * The CORS origins are restricted. By default, the only allowed CORS origin is ``http://localhost`` (``NEST_SERVER_CORS_ORIGINS=localhost``). + * NEST Server takes also custom token (``NEST_SERVER_ACCESS_TOKEN='alongaccesstoken'``), otherwise it generates token. + * The CORS origins are restricted. By default, the only allowed CORS origin is ``http://localhost`` + (``NEST_SERVER_CORS_ORIGINS=http://localhost``). * Only API calls are enabled. By default, the exec call is disabled (``NEST_SERVER_ENABLE_EXEC_CALL=0``). - * The code execution is restricted. By default, the restriction is activated (``NEST_SERVER_DISABLE_RESTRICTION=0``). - * NEST Server takes also custom token (``NEST_SERVER_ACCESS_TOKEN='abcdefghijk'``) \ No newline at end of file + * The code execution is restricted. By default, the restriction is activated (``NEST_SERVER_DISABLE_RESTRICTION=0``). \ No newline at end of file From ede355f7fe265405243222563309076f49f65877 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Wed, 19 Jul 2023 11:50:52 +0200 Subject: [PATCH 123/168] Fix pylint --- pynest/nest/server/hl_api_server.py | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index ca4800520e..b9881a430b 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -168,10 +168,9 @@ def _setup_auth(): return ("Unauthorized", 403) # DON'T LINT! Intentional bare except clause! Even `KeyboardInterrupt` and # `SystemExit` exceptions should not bypass authentication! - except: # noqa + except Exception: # noqa return ("Unauthorized", 403) - print(80 * "*") _check_security() _setup_auth() @@ -550,7 +549,7 @@ def combine(call_name, response): log("combine()", f"ERROR: cannot combine response={response}") msg = "Cannot combine data because of unknown reason" - raise Exception(msg) + raise Exception(msg) # pylint: disable=W0719 def merge_dicts(response): @@ -579,7 +578,7 @@ def merge_dicts(response): if element_type not in ("neuron", "recorder", "stimulator"): msg = f'Cannot combine data of element with type "{element_type}".' - raise Exception(msg) + raise Exception(msg) # pylint: disable=W0719 if element_type == "neuron": tmp = list(filter(lambda status: status["local"], device_dicts)) @@ -596,7 +595,7 @@ def merge_dicts(response): record_to = tmp["record_to"] if record_to not in ("ascii", "memory"): msg = f'Cannot combine data when recording to "{record_to}".' - raise Exception(msg) + raise Exception(msg) # pylint: disable=W0719 if record_to == "memory": event_keys = tmp["events"].keys() From 795a5e661b47301fa379bebc31dd2b822f39cbc8 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Wed, 19 Jul 2023 11:51:20 +0200 Subject: [PATCH 124/168] Apply black --- pynest/nest/server/hl_api_server.py | 1 + 1 file changed, 1 insertion(+) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index b9881a430b..395c4c9878 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -171,6 +171,7 @@ def _setup_auth(): except Exception: # noqa return ("Unauthorized", 403) + print(80 * "*") _check_security() _setup_auth() From d8eefb5c6207cd2a93425323d79887a97516a50d Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Wed, 19 Jul 2023 11:54:15 +0200 Subject: [PATCH 125/168] try to fix black --- pynest/nest/server/hl_api_server.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 395c4c9878..e50a533a82 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -451,7 +451,7 @@ def nestify(call_name, args, kwargs): objectnames = ["nodes", "source", "target", "pre", "post"] paramKeys = list(inspect.signature(call).parameters.keys()) args = [nest.NodeCollection(arg) if paramKeys[idx] in objectnames else arg for (idx, arg) in enumerate(args)] - for (key, value) in kwargs.items(): + for key, value in kwargs.items(): if key in objectnames: kwargs[key] = nest.NodeCollection(value) From ec863dc0ba720dc47a7b0fb726e0ae9fec307a55 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Wed, 19 Jul 2023 11:57:11 +0200 Subject: [PATCH 126/168] Apply black --- pynest/nest/server/hl_api_server.py | 1 - 1 file changed, 1 deletion(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index e50a533a82..30135c3a33 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -570,7 +570,6 @@ def merge_dicts(response): result = [] for device_dicts in zip(*response): - # TODO: either stip fields like thread, vp, thread_local_id, # and local or make them lists that contain the values from # all dicts. From 58b8b5edaf2c5d912f21682369013b8cf794f255 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Wed, 13 Sep 2023 16:24:14 +0200 Subject: [PATCH 127/168] Fix import modules --- pynest/nest/server/hl_api_server.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 30135c3a33..5f46bad42e 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -59,7 +59,7 @@ def get_boolean_environ(env_key, default_value="false"): AUTH_DISABLED = get_boolean_environ("NEST_SERVER_DISABLE_AUTH") CORS_ORIGINS = os.environ.get("NEST_SERVER_CORS_ORIGINS", _default_origins).split(",") EXEC_CALL_ENABLED = get_boolean_environ("NEST_SERVER_ENABLE_EXEC_CALL") -MODULES = os.environ.get("NEST_SERVER_MODULES", "nest").split(",") +MODULES = os.environ.get("NEST_SERVER_MODULES", "import nest") RESTRICTION_DISABLED = get_boolean_environ("NEST_SERVER_DISABLE_RESTRICTION") EXCEPTION_ERROR_STATUS = 400 From feaefa3b7d17bd56efec5871e6dedb73a794ca82 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Wed, 13 Sep 2023 16:33:34 +0200 Subject: [PATCH 128/168] Move changes in v3.6 --- doc/htmldoc/whats_new/changes.rst | 11 ----------- doc/htmldoc/whats_new/v3.6/index.rst | 14 ++++++++++++++ 2 files changed, 14 insertions(+), 11 deletions(-) delete mode 100644 doc/htmldoc/whats_new/changes.rst diff --git a/doc/htmldoc/whats_new/changes.rst b/doc/htmldoc/whats_new/changes.rst deleted file mode 100644 index a90209d711..0000000000 --- a/doc/htmldoc/whats_new/changes.rst +++ /dev/null @@ -1,11 +0,0 @@ - -Changes in NEST Server -~~~~~~~~~~~~~~~~~~~~~~ - -* Improve the security in NEST Server. The user can modify the security options in environment variables: - * Requests require Bearer tokens. By default, the authentication is on (``NEST_SERVER_DISABLE_AUTH=0``). - * NEST Server takes also custom token (``NEST_SERVER_ACCESS_TOKEN='alongaccesstoken'``), otherwise it generates token. - * The CORS origins are restricted. By default, the only allowed CORS origin is ``http://localhost`` - (``NEST_SERVER_CORS_ORIGINS=http://localhost``). - * Only API calls are enabled. By default, the exec call is disabled (``NEST_SERVER_ENABLE_EXEC_CALL=0``). - * The code execution is restricted. By default, the restriction is activated (``NEST_SERVER_DISABLE_RESTRICTION=0``). \ No newline at end of file diff --git a/doc/htmldoc/whats_new/v3.6/index.rst b/doc/htmldoc/whats_new/v3.6/index.rst index 25ed2fe769..d5c58ada3b 100644 --- a/doc/htmldoc/whats_new/v3.6/index.rst +++ b/doc/htmldoc/whats_new/v3.6/index.rst @@ -38,3 +38,17 @@ the property `volume_transmitter` of the synapse's common properties: | ) | ) | | | | +--------------------------------------------------+--------------------------------------------------+ + + +Changes in NEST Server +~~~~~~~~~~~~~~~~~~~~~~ + +* Improve the security in NEST Server. The user can modify the security options in environment variables: + * Requests require Bearer tokens. By default, the authentication is on (``NEST_SERVER_DISABLE_AUTH=0``). + * NEST Server takes also custom token (``NEST_SERVER_ACCESS_TOKEN='alongaccesstoken'``), otherwise it generates token. + * The CORS origins are restricted. By default, the only allowed CORS origin is ``http://localhost`` + (``NEST_SERVER_CORS_ORIGINS=http://localhost``). + * Only API calls are enabled. By default, the exec call is disabled (``NEST_SERVER_ENABLE_EXEC_CALL=0``). + * The code execution is restricted. By default, the restriction is activated (``NEST_SERVER_DISABLE_RESTRICTION=0``). + * For security reasons the exec call in NEST Server accepts only modules from NEST_SERVER_MODULES. + As example: ``NEST_SERVER_MODULES='import nest; import numpy as np; from numpy import random'`` \ No newline at end of file From 99e0eba32c481162d224ff40de2cf045e9c4d0cc Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Thu, 14 Sep 2023 10:52:31 +0200 Subject: [PATCH 129/168] Rename Auth Bearer to NESTServerAuth --- pynest/nest/server/hl_api_server.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 5f46bad42e..70f2e86adf 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -104,7 +104,7 @@ def _check_security(): @app.before_request def _setup_auth(): """ - Authentication function that generates and validates the Authorization header with a + Authentication function that generates and validates the NESTServerAuth header with a bearer token. Cleans up references to itself and the running `app` from this module, as it may be @@ -145,7 +145,7 @@ def _setup_auth(): hasher.update(str(time.perf_counter()).encode("utf-8")) self._hash = hasher.hexdigest()[:48] if not AUTH_DISABLED: - print(f" Bearer token to NEST server: {self._hash}\n") + print(f" Access token to NEST server: {self._hash}\n") if request.method == "OPTIONS": return @@ -153,7 +153,7 @@ def _setup_auth(): # The first time we hit the line below is when below the function definition we # call `setup_auth` without any Flask request existing yet, so the function errors # and exits here after generating and storing the auth hash. - auth = request.headers.get("Authorization", None) + auth = request.headers.get("NESTServerAuth", None) # We continue here the next time this function is called, before the Flask app # handles the first request. At that point we also remove this module's reference # to the running app. @@ -162,9 +162,9 @@ def _setup_auth(): except KeyError: pass # Things get more straightforward here: Every time a request is handled, compare - # the Authorization header to the hash, with a constant-time algorithm to avoid + # the NESTServerAuth header to the hash, with a constant-time algorithm to avoid # timing attacks. - if not (AUTH_DISABLED or hmac.compare_digest(auth, f"Bearer {self._hash}")): + if not (AUTH_DISABLED or hmac.compare_digest(NESTServerAuth, self._hash)): return ("Unauthorized", 403) # DON'T LINT! Intentional bare except clause! Even `KeyboardInterrupt` and # `SystemExit` exceptions should not bypass authentication! From 86e7629fae9a8c633bd6f23dcc5cdce2911abf96 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Thu, 14 Sep 2023 10:59:03 +0200 Subject: [PATCH 130/168] Rename Auth Bearer to NESTServerAuth --- doc/htmldoc/whats_new/v3.6/index.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/htmldoc/whats_new/v3.6/index.rst b/doc/htmldoc/whats_new/v3.6/index.rst index d5c58ada3b..67bcbf8749 100644 --- a/doc/htmldoc/whats_new/v3.6/index.rst +++ b/doc/htmldoc/whats_new/v3.6/index.rst @@ -44,7 +44,7 @@ Changes in NEST Server ~~~~~~~~~~~~~~~~~~~~~~ * Improve the security in NEST Server. The user can modify the security options in environment variables: - * Requests require Bearer tokens. By default, the authentication is on (``NEST_SERVER_DISABLE_AUTH=0``). + * Requests require NESTServerAuth tokens. By default, the authentication is on (``NEST_SERVER_DISABLE_AUTH=0``). * NEST Server takes also custom token (``NEST_SERVER_ACCESS_TOKEN='alongaccesstoken'``), otherwise it generates token. * The CORS origins are restricted. By default, the only allowed CORS origin is ``http://localhost`` (``NEST_SERVER_CORS_ORIGINS=http://localhost``). From 803302eb3f5abbe4c07a74d1d1459c1b88cc6adb Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Thu, 14 Sep 2023 11:10:41 +0200 Subject: [PATCH 131/168] Run pre-commit --- bin/nest-server-mpi | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-) diff --git a/bin/nest-server-mpi b/bin/nest-server-mpi index 2eb46c406d..7c0a54ac32 100755 --- a/bin/nest-server-mpi +++ b/bin/nest-server-mpi @@ -16,7 +16,7 @@ Options: from docopt import docopt from mpi4py import MPI -if __name__ == '__main__': +if __name__ == "__main__": opt = docopt(__doc__) import time @@ -35,34 +35,33 @@ rank = comm.Get_rank() def log(call_name, msg): - msg = f'==> WORKER {rank}/{time.time():.7f} ({call_name}): {msg}' + msg = f"==> WORKER {rank}/{time.time():.7f} ({call_name}): {msg}" print(msg, flush=True) if rank == 0: print("==> Starting NEST Server Master on rank 0", flush=True) nest.server.set_mpi_comm(comm) - nest.server.run_mpi_app(host=opt.get('--host', HOST), port=opt.get('--port', PORT)) + nest.server.run_mpi_app(host=opt.get("--host", HOST), port=opt.get("--port", PORT)) else: print(f"==> Starting NEST Server Worker on rank {rank}", flush=True) nest.server.set_mpi_comm(comm) while True: - - log('spinwait', 'waiting for call bcast') + log("spinwait", "waiting for call bcast") call_name = comm.bcast(None, root=0) - log(call_name, 'received call bcast, waiting for data bcast') + log(call_name, "received call bcast, waiting for data bcast") data = comm.bcast(None, root=0) - log(call_name, f'received data bcast, data={data}') + log(call_name, f"received data bcast, data={data}") args, kwargs = data - if call_name == 'exec': + if call_name == "exec": response = nest.server.do_exec(args, kwargs) else: call, args, kwargs = nest.server.nestify(call_name, args, kwargs) - log(call_name, f'local call, args={args}, kwargs={kwargs}') + log(call_name, f"local call, args={args}, kwargs={kwargs}") # The following exception handler is useful if an error # occurs simulataneously on all processes. If only a @@ -74,5 +73,5 @@ else: except Exception: continue - log(call_name, f'sending reponse gather, data={response}') + log(call_name, f"sending reponse gather, data={response}") comm.gather(nest.serializable(response), root=0) From 558907b430d82c2ddef78ac2d4cdcf829033aaeb Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Thu, 14 Sep 2023 11:17:37 +0200 Subject: [PATCH 132/168] Fix error --- pynest/nest/server/hl_api_server.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 70f2e86adf..d3c2da1f1b 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -164,7 +164,7 @@ def _setup_auth(): # Things get more straightforward here: Every time a request is handled, compare # the NESTServerAuth header to the hash, with a constant-time algorithm to avoid # timing attacks. - if not (AUTH_DISABLED or hmac.compare_digest(NESTServerAuth, self._hash)): + if not (AUTH_DISABLED or hmac.compare_digest(auth, self._hash)): return ("Unauthorized", 403) # DON'T LINT! Intentional bare except clause! Even `KeyboardInterrupt` and # `SystemExit` exceptions should not bypass authentication! From 4b404c7714b2e6545b9c28ee1d68f144e0503201 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Thu, 14 Sep 2023 15:30:10 +0200 Subject: [PATCH 133/168] Better instruction for access token --- pynest/nest/server/hl_api_server.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index d3c2da1f1b..44119e165a 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -145,7 +145,8 @@ def _setup_auth(): hasher.update(str(time.perf_counter()).encode("utf-8")) self._hash = hasher.hexdigest()[:48] if not AUTH_DISABLED: - print(f" Access token to NEST server: {self._hash}\n") + print(f" Access token to NEST Server: {self._hash}") + print(" Add this to the headers: {'NESTServerAuth': ''}\n") if request.method == "OPTIONS": return From d8bc5fe8a02c8f60967fb81285c3fc926e738be2 Mon Sep 17 00:00:00 2001 From: Dennis Terhorst Date: Fri, 15 Sep 2023 10:00:03 +0200 Subject: [PATCH 134/168] Apply suggestions from code review Change description to be more explicit --- pynest/nest/server/hl_api_server.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 44119e165a..eb0a4818af 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -95,10 +95,13 @@ def _check_security(): msg.append("RESTRICTION: Code scripts will be executed without a restricted environment.") if len(msg) > 0: - print("WARNING: The security of your system can not be ensured!") + print( + "WARNING: You chose to disable important access restrictions!\n" + " This allows other computers to execute code on this machine as the current user!\n" + " Be sure you understand the implications of these settings and take" + " appropriate measures to protect your runtime environment!" + ) print("\n - ".join([" "] + msg) + "\n") - else: - print("INFO: The security of your system can be ensured!\n") @app.before_request From 357d2beced1e628316b739a3f04f9674cbef7fab Mon Sep 17 00:00:00 2001 From: Jessica Mitchell Date: Fri, 15 Sep 2023 10:58:55 +0200 Subject: [PATCH 135/168] move text to server guide --- doc/htmldoc/connect_nest/nest_server.rst | 19 +++++++++++++++++++ doc/htmldoc/whats_new/v3.6/index.rst | 15 ++++----------- 2 files changed, 23 insertions(+), 11 deletions(-) diff --git a/doc/htmldoc/connect_nest/nest_server.rst b/doc/htmldoc/connect_nest/nest_server.rst index 3657e6c16e..60e0e65dfe 100644 --- a/doc/htmldoc/connect_nest/nest_server.rst +++ b/doc/htmldoc/connect_nest/nest_server.rst @@ -91,6 +91,25 @@ As an alternative to a native installation, NEST Server is available from the NEST Docker image. Please check out the corresponding :ref:`installation instructions ` for more details. +.. _sec_server_vars: + +Set environment variables for security options +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +To use NEST Server, there are several environment variables users need to set in their environment. + +* Requests require NESTServerAuth tokens. By default, the authentication is on (``NEST_SERVER_DISABLE_AUTH=0``). +* NEST Server generates a token automatically, but it can also take custom tokens (``NEST_SERVER_ACCESS_TOKEN='alongaccesstoken'``). +* The `CORS `_ origins are restricted. By default, the only allowed CORS origin is ``http://localhost`` + (``NEST_SERVER_CORS_ORIGINS=http://localhost``). +* Only API calls are enabled. By default, the exec call is disabled (``NEST_SERVER_ENABLE_EXEC_CALL=0``). +* The code execution is restricted. By default, the restriction is activated (``NEST_SERVER_DISABLE_RESTRICTION=0``). +* For security reasons the exec call in NEST Server accepts only modules from NEST_SERVER_MODULES. + + For example: + + ``NEST_SERVER_MODULES='import nest; import numpy as np; from numpy import random'`` + Run NEST Server ~~~~~~~~~~~~~~~ diff --git a/doc/htmldoc/whats_new/v3.6/index.rst b/doc/htmldoc/whats_new/v3.6/index.rst index 67bcbf8749..9c8b51e1c8 100644 --- a/doc/htmldoc/whats_new/v3.6/index.rst +++ b/doc/htmldoc/whats_new/v3.6/index.rst @@ -41,14 +41,7 @@ the property `volume_transmitter` of the synapse's common properties: Changes in NEST Server -~~~~~~~~~~~~~~~~~~~~~~ - -* Improve the security in NEST Server. The user can modify the security options in environment variables: - * Requests require NESTServerAuth tokens. By default, the authentication is on (``NEST_SERVER_DISABLE_AUTH=0``). - * NEST Server takes also custom token (``NEST_SERVER_ACCESS_TOKEN='alongaccesstoken'``), otherwise it generates token. - * The CORS origins are restricted. By default, the only allowed CORS origin is ``http://localhost`` - (``NEST_SERVER_CORS_ORIGINS=http://localhost``). - * Only API calls are enabled. By default, the exec call is disabled (``NEST_SERVER_ENABLE_EXEC_CALL=0``). - * The code execution is restricted. By default, the restriction is activated (``NEST_SERVER_DISABLE_RESTRICTION=0``). - * For security reasons the exec call in NEST Server accepts only modules from NEST_SERVER_MODULES. - As example: ``NEST_SERVER_MODULES='import nest; import numpy as np; from numpy import random'`` \ No newline at end of file +---------------------- + +We improved the security in NEST Server. Now to use NEST Server, users can modify the security options in . +See :ref:`section on setting these varialbles ` in our NEST Server guide. From ec163262dab39fe85ac5b9e53fe381b375070d3e Mon Sep 17 00:00:00 2001 From: jessica-mitchell Date: Fri, 15 Sep 2023 12:04:49 +0200 Subject: [PATCH 136/168] Update doc/htmldoc/whats_new/v3.6/index.rst --- doc/htmldoc/whats_new/v3.6/index.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/htmldoc/whats_new/v3.6/index.rst b/doc/htmldoc/whats_new/v3.6/index.rst index 9c8b51e1c8..8bcdd470e5 100644 --- a/doc/htmldoc/whats_new/v3.6/index.rst +++ b/doc/htmldoc/whats_new/v3.6/index.rst @@ -43,5 +43,5 @@ the property `volume_transmitter` of the synapse's common properties: Changes in NEST Server ---------------------- -We improved the security in NEST Server. Now to use NEST Server, users can modify the security options in . +We improved the security in NEST Server. Now to use NEST Server, users can modify the security options. See :ref:`section on setting these varialbles ` in our NEST Server guide. From d5409ed53768f26dcf7bb7e75e2c0fe3ce6b8a48 Mon Sep 17 00:00:00 2001 From: Jessica Mitchell Date: Fri, 15 Sep 2023 13:30:15 +0200 Subject: [PATCH 137/168] add whats new 3.6 --- .../pynest_api/nest.NestModule.rst | 2 +- doc/htmldoc/whats_new/index.rst | 2 + doc/htmldoc/whats_new/v3.6/index.rst | 59 ++++++++++++++++++- 3 files changed, 59 insertions(+), 4 deletions(-) diff --git a/doc/htmldoc/ref_material/pynest_api/nest.NestModule.rst b/doc/htmldoc/ref_material/pynest_api/nest.NestModule.rst index d175f1235d..f780fc7d4b 100644 --- a/doc/htmldoc/ref_material/pynest_api/nest.NestModule.rst +++ b/doc/htmldoc/ref_material/pynest_api/nest.NestModule.rst @@ -1,4 +1,4 @@ -.. _sec:kernel_attributes: +.. _sec_kernel_attributes: Kernel attributes (nest.NestModule) =================================== diff --git a/doc/htmldoc/whats_new/index.rst b/doc/htmldoc/whats_new/index.rst index 3de538bdd2..22f3340960 100644 --- a/doc/htmldoc/whats_new/index.rst +++ b/doc/htmldoc/whats_new/index.rst @@ -8,6 +8,7 @@ versions of NEST. On the linked pages, you will find both information about new features, as well as quick guides on how to transition your simulation code to the new versions. +* :ref:`NEST 3.6 ` * :ref:`NEST 3.5 ` * :ref:`NEST 3.4 ` * :ref:`NEST 3.3 ` @@ -20,6 +21,7 @@ the new versions. :hidden: :glob: + v3.6/* v3.5/* v3.4/* v3.3/* diff --git a/doc/htmldoc/whats_new/v3.6/index.rst b/doc/htmldoc/whats_new/v3.6/index.rst index 25ed2fe769..8d23d95d08 100644 --- a/doc/htmldoc/whats_new/v3.6/index.rst +++ b/doc/htmldoc/whats_new/v3.6/index.rst @@ -11,9 +11,42 @@ your simulation scripts when you come from an older version of NEST. If you transition from an earlier version, please see our extensive :ref:`transition guide from NEST 2.x to 3.0 ` and the -:ref:`list of updates for previous releases in the 3.x series -`. +:ref:`list of updates for previous releases in the 3.x series `. +Astrocytes in NEST +------------------ + +Astrocytes, one of the main non-neuronal cell types in the brain, +interact with neurons through versatile cellular mechanisms and modulate neuronal +activity in a complex and not fully understood way. +We developed new NEST models to bring astrocytes and +neuron-astrocyte interactions to spiking neural networks in NEST. +Our new models support reproducible and collaborative large-scale modeling of +neuron-astrocyte circuits. + +See examples using astrocyte models: + +* :doc:`../../../auto_examples/astrocyte_single` +* :doc:`../../../auto_examples/astrocyte_tripartite` + +See model docs: + +* doc:`../../../models/index_astrocyte` + +New model: glif_psc_double_alpha +-------------------------------- + +This model is based on the ``glif_psc`` model, but +uses the sum of two alpha functions instead of a single +alpha function as the post synaptic current input. + +See example: + +* :doc:`../../../auto_examples/glif_psc_double_alpha_neuron` + +See model docs: + +* :doc:`../../../models/glif_psc_double_alpha` New way to set the volume transmitter on STDP dopamine synapse -------------------------------------------------------------- @@ -27,7 +60,7 @@ possible. Instead, the volume transmitter is now set by supplying a NodeCollecti the property `volume_transmitter` of the synapse's common properties: +--------------------------------------------------+--------------------------------------------------+ -| Up to NEST 3.5 | from NEST 3.6 on | +| Up to NEST 3.5 | from NEST 3.6 onward | +==================================================+==================================================+ | :: | :: | | | | @@ -38,3 +71,23 @@ the property `volume_transmitter` of the synapse's common properties: | ) | ) | | | | +--------------------------------------------------+--------------------------------------------------+ + + +Changes to kernel attributes +---------------------------- + +The following kernel attributes were removed: + +* ``sort_connections_by_source`` : Use ``use_compressed_spikes`` instead; it automatically activates connection sorting +* ``adaptive_spike_buffers`` — spike buffers are now always adaptive +* ``max_buffer_size_spike_data`` — there is no upper limit since all spikes need to be transmitted in one round + +New kernel attributes that control or report spike buffer resizing: + +* ``spike_buffer_grow_extra`` +* ``spike_buffer_shrink_limit`` +* ``spike_buffer_shrink_spare`` +* ``spike_buffer_resize_log`` + +For details, see our :ref:`docs on the new attributes `. + From 38f4176fbcd3769c860703c24ba8f84db722f5b9 Mon Sep 17 00:00:00 2001 From: Hans Ekkehard Plesser Date: Tue, 19 Sep 2023 00:18:30 +0200 Subject: [PATCH 138/168] Replace input() by show() at end for better run_examples compatibility --- pynest/examples/store_restore_network.py | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/pynest/examples/store_restore_network.py b/pynest/examples/store_restore_network.py index 1b6ddac39f..ffc944c763 100644 --- a/pynest/examples/store_restore_network.py +++ b/pynest/examples/store_restore_network.py @@ -304,8 +304,6 @@ def add_to_plot(self, net, n_max=100, t_min=0, t_max=1000, lbl=""): if __name__ == "__main__": - plt.ion() - T_sim = 1000 dplot = DemoPlot() @@ -370,6 +368,4 @@ def add_to_plot(self, net, n_max=100, t_min=0, t_max=1000, lbl=""): nest.Simulate(T_sim) dplot.add_to_plot(ein2, lbl="Reloaded simulation (different seed)") - dplot.fig.savefig("store_restore_network.png") - - input("Press ENTER to close figure!") + plt.show() From ff00aabdc4d9ceb5f121b737e6e27f1b5affe41e Mon Sep 17 00:00:00 2001 From: Hans Ekkehard Plesser Date: Tue, 19 Sep 2023 00:19:28 +0200 Subject: [PATCH 139/168] Slightly improved readme --- pynest/examples/pong/README.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pynest/examples/pong/README.rst b/pynest/examples/pong/README.rst index ddde75b354..cbe12a7380 100644 --- a/pynest/examples/pong/README.rst +++ b/pynest/examples/pong/README.rst @@ -5,7 +5,7 @@ the classic game of Pong. Requirements ------------ -- NEST 3.3 +- NEST 3.3 or later - NumPy - Matplotlib @@ -19,4 +19,4 @@ based on the ``stdp_dopamine_synapse`` and temporal difference learning is implemented, see ``networks.py`` for details. The learning progress and resulting game can be visualized with the -``generate_gif.py`` script. \ No newline at end of file +``generate_gif.py`` script. From e78e89b8cb0b7c6252ca9c92c3e4379d5cffc7a5 Mon Sep 17 00:00:00 2001 From: Hans Ekkehard Plesser Date: Tue, 19 Sep 2023 00:20:19 +0200 Subject: [PATCH 140/168] Fix parameter data type --- pynest/examples/evaluate_quantal_stp_synapse.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pynest/examples/evaluate_quantal_stp_synapse.py b/pynest/examples/evaluate_quantal_stp_synapse.py index d389bd5f04..5d377d62a0 100644 --- a/pynest/examples/evaluate_quantal_stp_synapse.py +++ b/pynest/examples/evaluate_quantal_stp_synapse.py @@ -84,7 +84,7 @@ # We define the number of trials as well as the number of release sites. -n_sites = 10.0 # number of synaptic release sites +n_sites = 10 # number of synaptic release sites n_trials = 500 # number of measurement trials # The pre-synaptic neuron is driven by an injected current for a part of each From 7f61375912a5025dffa45589d0b0612442db5d33 Mon Sep 17 00:00:00 2001 From: Hans Ekkehard Plesser Date: Tue, 19 Sep 2023 00:25:18 +0200 Subject: [PATCH 141/168] Set NEST_DATA_PATH correctly for examples and provide solution for running on macOS --- examples/run_examples.sh | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/examples/run_examples.sh b/examples/run_examples.sh index b00119d3b1..1b310ccff6 100755 --- a/examples/run_examples.sh +++ b/examples/run_examples.sh @@ -93,11 +93,13 @@ for i in $EXAMPLES; do echo " output_dir: '$output_dir'" >>"$metafile" echo " log: '$logfile'" >>"$metafile" - export NEST_DATA_PATH="" # $output_dir" + export NEST_DATA_PATH="$output_dir" touch .start_example sleep 1 set +e + # The following line will not work on macOS. There, `brew install gnu-time` and use the commented-out line below. /usr/bin/time -f "$time_format" --quiet sh -c "'$runner' '$example' >'$logfile' 2>&1" |& tee -a "$metafile" + # /usr/local/bin/gtime -f "$time_format" --quiet sh -c "'$runner' '$example' >'$logfile' 2>&1" | tee -a "$metafile" 2>&1 ret=$? set -e From fbc788a6a805c338f8e7fed13839ff5455da4d44 Mon Sep 17 00:00:00 2001 From: Hans Ekkehard Plesser Date: Tue, 19 Sep 2023 00:26:51 +0200 Subject: [PATCH 142/168] Ensure connection tables are correctly updated when synapses are deleted --- nestkernel/connection_manager.cpp | 4 ++ nestkernel/connector_base.h | 1 + nestkernel/simulation_manager.cpp | 70 ++++++++++++++++--------------- nestkernel/source_table.cpp | 21 ++++++---- 4 files changed, 53 insertions(+), 43 deletions(-) diff --git a/nestkernel/connection_manager.cpp b/nestkernel/connection_manager.cpp index c7771c8215..a0925ff3e9 100644 --- a/nestkernel/connection_manager.cpp +++ b/nestkernel/connection_manager.cpp @@ -1583,6 +1583,10 @@ nest::ConnectionManager::remove_disabled_connections( const size_t tid ) { continue; } + + // Source table and connectors are sorted synchronously. All invalid connections have + // been sorted to end of source_table_. We find them there, then remove corresponding + // elements from connectors. const size_t first_disabled_index = source_table_.remove_disabled_sources( tid, syn_id ); if ( first_disabled_index != invalid_index ) diff --git a/nestkernel/connector_base.h b/nestkernel/connector_base.h index ba9237bd10..addafb818e 100644 --- a/nestkernel/connector_base.h +++ b/nestkernel/connector_base.h @@ -392,6 +392,7 @@ class Connector : public ConnectorBase while ( true ) { + assert( lcid + lcid_offset < C_.size() ); ConnectionT& conn = C_[ lcid + lcid_offset ]; const bool is_disabled = conn.is_disabled(); const bool source_has_more_targets = conn.source_has_more_targets(); diff --git a/nestkernel/simulation_manager.cpp b/nestkernel/simulation_manager.cpp index daf71291c4..ae3ac6a689 100644 --- a/nestkernel/simulation_manager.cpp +++ b/nestkernel/simulation_manager.cpp @@ -811,40 +811,6 @@ nest::SimulationManager::update_() gettimeofday( &t_slice_begin_, nullptr ); } - if ( kernel().sp_manager.is_structural_plasticity_enabled() - and ( std::fmod( Time( Time::step( clock_.get_steps() + from_step_ ) ).get_ms(), - kernel().sp_manager.get_structural_plasticity_update_interval() ) - == 0 ) ) - { - for ( SparseNodeArray::const_iterator i = kernel().node_manager.get_local_nodes( tid ).begin(); - i != kernel().node_manager.get_local_nodes( tid ).end(); - ++i ) - { - Node* node = i->get_node(); - node->update_synaptic_elements( Time( Time::step( clock_.get_steps() + from_step_ ) ).get_ms() ); - } -#pragma omp barrier -#pragma omp single - { - kernel().sp_manager.update_structural_plasticity(); - } - // Remove 10% of the vacant elements - for ( SparseNodeArray::const_iterator i = kernel().node_manager.get_local_nodes( tid ).begin(); - i != kernel().node_manager.get_local_nodes( tid ).end(); - ++i ) - { - Node* node = i->get_node(); - node->decay_synaptic_elements_vacant(); - } - - // after structural plasticity has created and deleted - // connections, update the connection infrastructure; implies - // complete removal of presynaptic part and reconstruction - // from postsynaptic data - update_connection_infrastructure( tid ); - - } // of structural plasticity - // Do not deliver events at beginning of first slice, nothing can be there yet // and invalid markers have not been properly set in send buffers. if ( slice_ > 0 and from_step_ == 0 ) @@ -989,6 +955,42 @@ nest::SimulationManager::update_() } // of if(wfr_is_used) // end of preliminary update + if ( kernel().sp_manager.is_structural_plasticity_enabled() + and ( std::fmod( Time( Time::step( clock_.get_steps() + from_step_ ) ).get_ms(), + kernel().sp_manager.get_structural_plasticity_update_interval() ) + == 0 ) ) + { +#pragma omp barrier + for ( SparseNodeArray::const_iterator i = kernel().node_manager.get_local_nodes( tid ).begin(); + i != kernel().node_manager.get_local_nodes( tid ).end(); + ++i ) + { + Node* node = i->get_node(); + node->update_synaptic_elements( Time( Time::step( clock_.get_steps() + from_step_ ) ).get_ms() ); + } +#pragma omp barrier +#pragma omp single + { + kernel().sp_manager.update_structural_plasticity(); + } + // Remove 10% of the vacant elements + for ( SparseNodeArray::const_iterator i = kernel().node_manager.get_local_nodes( tid ).begin(); + i != kernel().node_manager.get_local_nodes( tid ).end(); + ++i ) + { + Node* node = i->get_node(); + node->decay_synaptic_elements_vacant(); + } + + // after structural plasticity has created and deleted + // connections, update the connection infrastructure; implies + // complete removal of presynaptic part and reconstruction + // from postsynaptic data + update_connection_infrastructure( tid ); + + } // of structural plasticity + + #ifdef TIMER_DETAILED #pragma omp barrier if ( tid == 0 ) diff --git a/nestkernel/source_table.cpp b/nestkernel/source_table.cpp index 6e8d903d2c..09c4195341 100644 --- a/nestkernel/source_table.cpp +++ b/nestkernel/source_table.cpp @@ -166,14 +166,14 @@ nest::SourceTable::remove_disabled_sources( const size_t tid, const synindex syn { if ( sources_[ tid ].size() <= syn_id ) { - return invalid_index; + return invalid_index; // no source table entry for this synapse model } BlockVector< Source >& mysources = sources_[ tid ][ syn_id ]; const size_t max_size = mysources.size(); if ( max_size == 0 ) { - return invalid_index; + return invalid_index; // no connections for this synapse model } // lcid needs to be signed, to allow lcid >= 0 check in while loop @@ -184,15 +184,14 @@ nest::SourceTable::remove_disabled_sources( const size_t tid, const synindex syn { --lcid; } - ++lcid; // lcid marks first disabled source, but the while loop only - // exits if lcid points at a not disabled element, hence we - // need to increase it by one again - mysources.erase( mysources.begin() + lcid, mysources.end() ); - if ( static_cast< size_t >( lcid ) == max_size ) + const size_t first_invalid_lcid = static_cast< size_t >( lcid + 1 ); // loop stopped on first valid entry or -1 + if ( first_invalid_lcid == max_size ) { - return invalid_index; + return invalid_index; // all lcids are valid, nothing to remove } - return static_cast< size_t >( lcid ); + + mysources.erase( mysources.begin() + first_invalid_lcid, mysources.end() ); + return first_invalid_lcid; } void @@ -458,6 +457,10 @@ nest::SourceTable::collect_compressible_sources( const size_t tid ) kernel().connection_manager.set_source_has_more_targets( tid, syn_id, lcid - 1, true ); ++lcid; } + // Mark last connection in sequence as not having successor. This is essential if connections are + // delete, e.g., by structural plasticity, because we do not globally reset the more_targets flag. + assert( lcid - 1 < syn_sources.size() ); + kernel().connection_manager.set_source_has_more_targets( tid, syn_id, lcid - 1, false ); } } } From dbcc1cd5d9b62cdb15175113b8308b57b90f8600 Mon Sep 17 00:00:00 2001 From: Hans Ekkehard Plesser Date: Tue, 19 Sep 2023 01:09:30 +0200 Subject: [PATCH 143/168] Add test to confirm that spike transmission works after disconnection --- ...est_spike_transmission_after_disconnect.py | 44 +++++++++++++++++++ 1 file changed, 44 insertions(+) create mode 100644 testsuite/pytests/test_spike_transmission_after_disconnect.py diff --git a/testsuite/pytests/test_spike_transmission_after_disconnect.py b/testsuite/pytests/test_spike_transmission_after_disconnect.py new file mode 100644 index 0000000000..5887a4bdd1 --- /dev/null +++ b/testsuite/pytests/test_spike_transmission_after_disconnect.py @@ -0,0 +1,44 @@ +# -*- coding: utf-8 -*- +# +# test_spike_transmission_after_disconnect.py +# +# This file is part of NEST. +# +# Copyright (C) 2004 The NEST Initiative +# +# NEST 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 2 of the License, or +# (at your option) any later version. +# +# NEST 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 NEST. If not, see . + +import nest + + +def test_spike_transmission_after_disconnect(): + """ + Confirm that spikes can be transmitted after connections have been removed. + """ + + n = nest.Create("parrot_neuron", 10) + nest.Connect(n, n) + + # Delete 1/3 of connections + c = nest.GetConnections() + c[::3].disconnect() + + # Add spike generator to drive + g = nest.Create("spike_generator", params={"spike_times": [1]}) + nest.Connect(g, n) + + # Simulate long enough for spikes to be delivered, but not too long + # since we otherwise will be buried by exponential growth in number + # of spikes. + nest.Simulate(3) From 10b09919c2c182dacaa78d82c0ca575cd13dae64 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Tue, 19 Sep 2023 11:13:57 +0200 Subject: [PATCH 144/168] Remove hmac --- pynest/nest/server/hl_api_server.py | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index eb0a4818af..31c612c6c5 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -96,11 +96,11 @@ def _check_security(): if len(msg) > 0: print( - "WARNING: You chose to disable important access restrictions!\n" - " This allows other computers to execute code on this machine as the current user!\n" - " Be sure you understand the implications of these settings and take" - " appropriate measures to protect your runtime environment!" - ) + "WARNING: You chose to disable important access restrictions!\n" + " This allows other computers to execute code on this machine as the current user!\n" + " Be sure you understand the implications of these settings and take" + " appropriate measures to protect your runtime environment!" + ) print("\n - ".join([" "] + msg) + "\n") @@ -120,7 +120,6 @@ def _setup_auth(): import gc # noqa import time # noqa import hashlib # noqa - import hmac # noqa # Find our reference to the current function in the garbage collector. frame = inspect.currentframe() @@ -168,7 +167,7 @@ def _setup_auth(): # Things get more straightforward here: Every time a request is handled, compare # the NESTServerAuth header to the hash, with a constant-time algorithm to avoid # timing attacks. - if not (AUTH_DISABLED or hmac.compare_digest(auth, self._hash)): + if not (AUTH_DISABLED or auth == self._hash): return ("Unauthorized", 403) # DON'T LINT! Intentional bare except clause! Even `KeyboardInterrupt` and # `SystemExit` exceptions should not bypass authentication! From a2de55640367042d3d30e0376bf72c2fec556998 Mon Sep 17 00:00:00 2001 From: Dennis Terhorst Date: Tue, 19 Sep 2023 16:41:57 +0200 Subject: [PATCH 145/168] Suggested from code review --- doc/htmldoc/whats_new/v3.6/index.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/htmldoc/whats_new/v3.6/index.rst b/doc/htmldoc/whats_new/v3.6/index.rst index 8d23d95d08..5af5f31cc1 100644 --- a/doc/htmldoc/whats_new/v3.6/index.rst +++ b/doc/htmldoc/whats_new/v3.6/index.rst @@ -20,7 +20,7 @@ Astrocytes, one of the main non-neuronal cell types in the brain, interact with neurons through versatile cellular mechanisms and modulate neuronal activity in a complex and not fully understood way. We developed new NEST models to bring astrocytes and -neuron-astrocyte interactions to spiking neural networks in NEST. +neuron-astrocyte interactions to spiking neural networks into NEST. Our new models support reproducible and collaborative large-scale modeling of neuron-astrocyte circuits. From d8724c915453c3db678f105e55905fc49f4fff90 Mon Sep 17 00:00:00 2001 From: Nicolai Haug Date: Tue, 19 Sep 2023 17:06:52 +0200 Subject: [PATCH 146/168] Run isort --- pynest/examples/astrocyte_single.py | 1 - pynest/examples/astrocyte_tripartite.py | 1 - pynest/examples/glif_psc_double_alpha_neuron.py | 4 ++-- testsuite/pytests/test_astrocyte.py | 4 ++-- testsuite/pytests/test_glif_psc_double_alpha.py | 1 + testsuite/pytests/test_sic_connection.py | 4 +--- 6 files changed, 6 insertions(+), 9 deletions(-) diff --git a/pynest/examples/astrocyte_single.py b/pynest/examples/astrocyte_single.py index a74eef36e6..2cc8de3d9d 100644 --- a/pynest/examples/astrocyte_single.py +++ b/pynest/examples/astrocyte_single.py @@ -60,7 +60,6 @@ # Import all necessary modules for simulation and plotting. import matplotlib.pyplot as plt - import nest ############################################################################### diff --git a/pynest/examples/astrocyte_tripartite.py b/pynest/examples/astrocyte_tripartite.py index a522b0d6a8..bbdb5cfe9c 100644 --- a/pynest/examples/astrocyte_tripartite.py +++ b/pynest/examples/astrocyte_tripartite.py @@ -73,7 +73,6 @@ # Import all necessary modules for simulation and plotting. import matplotlib.pyplot as plt - import nest ############################################################################### diff --git a/pynest/examples/glif_psc_double_alpha_neuron.py b/pynest/examples/glif_psc_double_alpha_neuron.py index 44787f01e2..8939dc6a8c 100644 --- a/pynest/examples/glif_psc_double_alpha_neuron.py +++ b/pynest/examples/glif_psc_double_alpha_neuron.py @@ -41,9 +41,9 @@ # First, we import all necessary modules to simulate, analyze and plot this # example. -import nest -import matplotlib.pyplot as plt import matplotlib.gridspec as gridspec +import matplotlib.pyplot as plt +import nest ############################################################################## # We initialize NEST and set the simulation resolution. diff --git a/testsuite/pytests/test_astrocyte.py b/testsuite/pytests/test_astrocyte.py index a2bd3c0c56..3b0cacc44b 100644 --- a/testsuite/pytests/test_astrocyte.py +++ b/testsuite/pytests/test_astrocyte.py @@ -33,10 +33,10 @@ """ import os -import numpy as np -import pytest import nest +import numpy as np +import pytest pytestmark = pytest.mark.skipif_missing_gsl path = os.path.abspath(os.path.dirname(__file__)) diff --git a/testsuite/pytests/test_glif_psc_double_alpha.py b/testsuite/pytests/test_glif_psc_double_alpha.py index 3f4253e8dc..326155d8ac 100644 --- a/testsuite/pytests/test_glif_psc_double_alpha.py +++ b/testsuite/pytests/test_glif_psc_double_alpha.py @@ -20,6 +20,7 @@ # along with NEST. If not, see . import unittest + import nest try: diff --git a/testsuite/pytests/test_sic_connection.py b/testsuite/pytests/test_sic_connection.py index 0d470d0e83..1e6d69b7dc 100644 --- a/testsuite/pytests/test_sic_connection.py +++ b/testsuite/pytests/test_sic_connection.py @@ -23,12 +23,10 @@ Test functionality of the SIC connection """ +import nest import numpy as np import pytest -import nest - - pytestmark = pytest.mark.skipif_missing_gsl From 5bf20c02dddaec9401908a0ea5c56e1204963085 Mon Sep 17 00:00:00 2001 From: Dennis Terhorst Date: Tue, 19 Sep 2023 17:23:44 +0200 Subject: [PATCH 147/168] run isort --- pynest/nest/server/hl_api_server.py | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 02653e140a..b20dab862a 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -22,24 +22,23 @@ import ast import importlib import inspect -import logging import io +import logging import os import sys import time import traceback from copy import deepcopy +import flask import nest import RestrictedPython -import flask from flask import Flask, jsonify, request -from flask_cors import CORS from flask.logging import default_handler +from flask_cors import CORS from werkzeug.exceptions import abort from werkzeug.wrappers import Response - # This ensures that the logging information shows up in the console running the server, # even when Flask's event loop is running. root = logging.getLogger() @@ -113,10 +112,10 @@ def _setup_auth(): try: # Import the modules inside of the auth function, so that if they fail the auth # returns a forbidden error. - import inspect # noqa import gc # noqa - import time # noqa import hashlib # noqa + import inspect # noqa + import time # noqa # Find our reference to the current function in the garbage collector. frame = inspect.currentframe() From 4d23b0dbc82da78f0737e3256ceec33349d082d2 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Wed, 20 Sep 2023 11:45:59 +0200 Subject: [PATCH 148/168] Apply suggestions from code review Co-authored-by: Jochen Martin Eppler --- pynest/nest/server/hl_api_server.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index b20dab862a..13ced00441 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -82,13 +82,13 @@ def _check_security(): msg = [] if AUTH_DISABLED: - msg.append("AUTH:\tThe authorization is disabled.") + msg.append("AUTH:\tThe authorization settings are disabled.") if "*" in CORS_ORIGINS: - msg.append("CORS:\tAllowed origins is not restricted.") + msg.append("CORS:\tThe allowed origins are not restricted.") if EXEC_CALL_ENABLED: - msg.append("EXEC CALL:\tAny code scripts can be executed!") + msg.append("EXEC CALL:\tThe exec route is enables and scripts can be executed.") if RESTRICTION_DISABLED: - msg.append("RESTRICTION: Code scripts will be executed without a restricted environment.") + msg.append("RESTRICTION: The execution of scripts is not protected by RestrictedPython.") if len(msg) > 0: print( From 429faafd478f0b4866d8cab542d413b8438e9c33 Mon Sep 17 00:00:00 2001 From: Dennis Terhorst Date: Wed, 20 Sep 2023 11:48:21 +0200 Subject: [PATCH 149/168] Update doc/htmldoc/connect_nest/nest_server.rst Co-authored-by: Jochen Martin Eppler --- doc/htmldoc/connect_nest/nest_server.rst | 23 +++++++++-------------- 1 file changed, 9 insertions(+), 14 deletions(-) diff --git a/doc/htmldoc/connect_nest/nest_server.rst b/doc/htmldoc/connect_nest/nest_server.rst index 60e0e65dfe..ac16599020 100644 --- a/doc/htmldoc/connect_nest/nest_server.rst +++ b/doc/htmldoc/connect_nest/nest_server.rst @@ -96,20 +96,15 @@ from the NEST Docker image. Please check out the corresponding Set environment variables for security options ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -To use NEST Server, there are several environment variables users need to set in their environment. - -* Requests require NESTServerAuth tokens. By default, the authentication is on (``NEST_SERVER_DISABLE_AUTH=0``). -* NEST Server generates a token automatically, but it can also take custom tokens (``NEST_SERVER_ACCESS_TOKEN='alongaccesstoken'``). -* The `CORS `_ origins are restricted. By default, the only allowed CORS origin is ``http://localhost`` - (``NEST_SERVER_CORS_ORIGINS=http://localhost``). -* Only API calls are enabled. By default, the exec call is disabled (``NEST_SERVER_ENABLE_EXEC_CALL=0``). -* The code execution is restricted. By default, the restriction is activated (``NEST_SERVER_DISABLE_RESTRICTION=0``). -* For security reasons the exec call in NEST Server accepts only modules from NEST_SERVER_MODULES. - - For example: - - ``NEST_SERVER_MODULES='import nest; import numpy as np; from numpy import random'`` - +NEST Server comes with a number of access restrictions that are meant to protect your +computer. After careful consideration, each of the restrictions can be disabled by setting +a corresponding environment variable. + +* ``NEST_SERVER_DISABLE_AUTH``: By default, the NEST Server requires a NESTServerAuth tokens. Setting this variable to ``0`` disables this restriction. A token is automatically created and printed to the console by NEST Server upon start-up. If needed, a custom token can be set using the environment variable ``NEST_SERVER_ACCESS_TOKEN`` +* ``NEST_SERVER_CORS_ORIGINS``: By default, the NEST Server only allows requests from localhost (see `CORS `_). Other hosts can be explicitly allowed by supplying them in the form `http://host_or_ip`` to this variable. +* ``NEST_SERVER_ENABLE_EXEC_CALL``: By default, NEST Server only allows calls to its PyNEST-like API. If the use-case requires the execution of scripts via the ``/exec`` route, this variable can be set to 0. PLEASE BE AWARE THAT THIS OPENS YOUR COMPUTER TO REMOTE CODE EXECUTION. +* ``NEST_SERVER_DISABLE_RESTRICTION``: By default, NEST Server runs all code passed to the ``/exec`` route through RestrictedPython to sanitize it. To disable this mechanism, this variable can be set to 0. For increased security, code passed in this way only allows explictly whitelisted modules to be imported. To import modules, the variable ``NEST_SERVER_MODULES`` can be set to a standard Python import line like this: + ``NEST_SERVER_MODULES='import nest; import scipy as sp; from numpy import random'`` Run NEST Server ~~~~~~~~~~~~~~~ From 28c0da899b5090edc1019c20705d68e70dcce0b9 Mon Sep 17 00:00:00 2001 From: Jochen Martin Eppler Date: Wed, 20 Sep 2023 11:52:56 +0200 Subject: [PATCH 150/168] Update doc/htmldoc/connect_nest/nest_server.rst Co-authored-by: Sebastian Spreizer --- doc/htmldoc/connect_nest/nest_server.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/htmldoc/connect_nest/nest_server.rst b/doc/htmldoc/connect_nest/nest_server.rst index ac16599020..9560525ef1 100644 --- a/doc/htmldoc/connect_nest/nest_server.rst +++ b/doc/htmldoc/connect_nest/nest_server.rst @@ -100,7 +100,7 @@ NEST Server comes with a number of access restrictions that are meant to protect computer. After careful consideration, each of the restrictions can be disabled by setting a corresponding environment variable. -* ``NEST_SERVER_DISABLE_AUTH``: By default, the NEST Server requires a NESTServerAuth tokens. Setting this variable to ``0`` disables this restriction. A token is automatically created and printed to the console by NEST Server upon start-up. If needed, a custom token can be set using the environment variable ``NEST_SERVER_ACCESS_TOKEN`` +* ``NEST_SERVER_DISABLE_AUTH``: By default, the NEST Server requires a NESTServerAuth tokens. Setting this variable to ``1`` disables this restriction. A token is automatically created and printed to the console by NEST Server upon start-up. If needed, a custom token can be set using the environment variable ``NEST_SERVER_ACCESS_TOKEN`` * ``NEST_SERVER_CORS_ORIGINS``: By default, the NEST Server only allows requests from localhost (see `CORS `_). Other hosts can be explicitly allowed by supplying them in the form `http://host_or_ip`` to this variable. * ``NEST_SERVER_ENABLE_EXEC_CALL``: By default, NEST Server only allows calls to its PyNEST-like API. If the use-case requires the execution of scripts via the ``/exec`` route, this variable can be set to 0. PLEASE BE AWARE THAT THIS OPENS YOUR COMPUTER TO REMOTE CODE EXECUTION. * ``NEST_SERVER_DISABLE_RESTRICTION``: By default, NEST Server runs all code passed to the ``/exec`` route through RestrictedPython to sanitize it. To disable this mechanism, this variable can be set to 0. For increased security, code passed in this way only allows explictly whitelisted modules to be imported. To import modules, the variable ``NEST_SERVER_MODULES`` can be set to a standard Python import line like this: From 9eab72f721281ce9b55ef5d4cf9da58d08e9c3b9 Mon Sep 17 00:00:00 2001 From: Jochen Martin Eppler Date: Wed, 20 Sep 2023 11:53:06 +0200 Subject: [PATCH 151/168] Update doc/htmldoc/connect_nest/nest_server.rst Co-authored-by: Sebastian Spreizer --- doc/htmldoc/connect_nest/nest_server.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/htmldoc/connect_nest/nest_server.rst b/doc/htmldoc/connect_nest/nest_server.rst index 9560525ef1..48e1c7f19d 100644 --- a/doc/htmldoc/connect_nest/nest_server.rst +++ b/doc/htmldoc/connect_nest/nest_server.rst @@ -102,7 +102,7 @@ a corresponding environment variable. * ``NEST_SERVER_DISABLE_AUTH``: By default, the NEST Server requires a NESTServerAuth tokens. Setting this variable to ``1`` disables this restriction. A token is automatically created and printed to the console by NEST Server upon start-up. If needed, a custom token can be set using the environment variable ``NEST_SERVER_ACCESS_TOKEN`` * ``NEST_SERVER_CORS_ORIGINS``: By default, the NEST Server only allows requests from localhost (see `CORS `_). Other hosts can be explicitly allowed by supplying them in the form `http://host_or_ip`` to this variable. -* ``NEST_SERVER_ENABLE_EXEC_CALL``: By default, NEST Server only allows calls to its PyNEST-like API. If the use-case requires the execution of scripts via the ``/exec`` route, this variable can be set to 0. PLEASE BE AWARE THAT THIS OPENS YOUR COMPUTER TO REMOTE CODE EXECUTION. +* ``NEST_SERVER_ENABLE_EXEC_CALL``: By default, NEST Server only allows calls to its PyNEST-like API. If the use-case requires the execution of scripts via the ``/exec`` route, this variable can be set to ``1``. PLEASE BE AWARE THAT THIS OPENS YOUR COMPUTER TO REMOTE CODE EXECUTION. * ``NEST_SERVER_DISABLE_RESTRICTION``: By default, NEST Server runs all code passed to the ``/exec`` route through RestrictedPython to sanitize it. To disable this mechanism, this variable can be set to 0. For increased security, code passed in this way only allows explictly whitelisted modules to be imported. To import modules, the variable ``NEST_SERVER_MODULES`` can be set to a standard Python import line like this: ``NEST_SERVER_MODULES='import nest; import scipy as sp; from numpy import random'`` Run NEST Server From c6a9329c4520bce20960e0a015c7aa25708bc04b Mon Sep 17 00:00:00 2001 From: Jochen Martin Eppler Date: Wed, 20 Sep 2023 11:53:17 +0200 Subject: [PATCH 152/168] Update doc/htmldoc/connect_nest/nest_server.rst Co-authored-by: Sebastian Spreizer --- doc/htmldoc/connect_nest/nest_server.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/htmldoc/connect_nest/nest_server.rst b/doc/htmldoc/connect_nest/nest_server.rst index 48e1c7f19d..c873d93fc6 100644 --- a/doc/htmldoc/connect_nest/nest_server.rst +++ b/doc/htmldoc/connect_nest/nest_server.rst @@ -103,7 +103,7 @@ a corresponding environment variable. * ``NEST_SERVER_DISABLE_AUTH``: By default, the NEST Server requires a NESTServerAuth tokens. Setting this variable to ``1`` disables this restriction. A token is automatically created and printed to the console by NEST Server upon start-up. If needed, a custom token can be set using the environment variable ``NEST_SERVER_ACCESS_TOKEN`` * ``NEST_SERVER_CORS_ORIGINS``: By default, the NEST Server only allows requests from localhost (see `CORS `_). Other hosts can be explicitly allowed by supplying them in the form `http://host_or_ip`` to this variable. * ``NEST_SERVER_ENABLE_EXEC_CALL``: By default, NEST Server only allows calls to its PyNEST-like API. If the use-case requires the execution of scripts via the ``/exec`` route, this variable can be set to ``1``. PLEASE BE AWARE THAT THIS OPENS YOUR COMPUTER TO REMOTE CODE EXECUTION. -* ``NEST_SERVER_DISABLE_RESTRICTION``: By default, NEST Server runs all code passed to the ``/exec`` route through RestrictedPython to sanitize it. To disable this mechanism, this variable can be set to 0. For increased security, code passed in this way only allows explictly whitelisted modules to be imported. To import modules, the variable ``NEST_SERVER_MODULES`` can be set to a standard Python import line like this: +* ``NEST_SERVER_DISABLE_RESTRICTION``: By default, NEST Server runs all code passed to the ``/exec`` route through RestrictedPython to sanitize it. To disable this mechanism, this variable can be set to ``1``. For increased security, code passed in this way only allows explictly whitelisted modules to be imported. To import modules, the variable ``NEST_SERVER_MODULES`` can be set to a standard Python import line like this: ``NEST_SERVER_MODULES='import nest; import scipy as sp; from numpy import random'`` Run NEST Server ~~~~~~~~~~~~~~~ From 2cbc29b1072b1e11294d4c2ce33b410fc1ed52d6 Mon Sep 17 00:00:00 2001 From: Hans Ekkehard Plesser Date: Wed, 20 Sep 2023 18:09:20 +0200 Subject: [PATCH 153/168] Minor fixes to some examples --- pynest/examples/brunel_alpha_evolution_strategies.py | 2 +- pynest/examples/pong/README.rst | 2 +- pynest/examples/pong/generate_gif.py | 3 ++- pynest/examples/sudoku/README.rst | 8 +++++++- pynest/examples/sudoku/plot_progress.py | 2 +- 5 files changed, 12 insertions(+), 5 deletions(-) diff --git a/pynest/examples/brunel_alpha_evolution_strategies.py b/pynest/examples/brunel_alpha_evolution_strategies.py index ab980f9007..268baee54a 100644 --- a/pynest/examples/brunel_alpha_evolution_strategies.py +++ b/pynest/examples/brunel_alpha_evolution_strategies.py @@ -390,7 +390,7 @@ def optimize( s = np.vstack([s, -s]) # evaluate fitness for every individual in population - fitness = np.fromiter((func(*zi) for zi in z), np.float) + fitness = np.fromiter((func(*zi) for zi in z), float) # print status if enabled if verbosity > 0: diff --git a/pynest/examples/pong/README.rst b/pynest/examples/pong/README.rst index cbe12a7380..2e8a4be063 100644 --- a/pynest/examples/pong/README.rst +++ b/pynest/examples/pong/README.rst @@ -12,7 +12,7 @@ Requirements Instructions ------------ To start training between two networks with R-STDP plasticity, run -the ``generate_gif.py`` script. By default, one of the networks will +the ``run_simulations.py`` script. By default, one of the networks will be stimulated with Gaussian white noise, showing that this is necessary for learning under this paradigm. In addition to R-STDP, a learning rule based on the ``stdp_dopamine_synapse`` and temporal difference learning diff --git a/pynest/examples/pong/generate_gif.py b/pynest/examples/pong/generate_gif.py index fb16f385a1..4bc8781179 100644 --- a/pynest/examples/pong/generate_gif.py +++ b/pynest/examples/pong/generate_gif.py @@ -138,6 +138,7 @@ def grayscale_to_heatmap(in_image, min_val, max_val, base_color): sys.exit(1) temp_dir = "temp" + if os.path.exists(temp_dir): print(f"Output folder <{temp_dir}> already exists, aborting!") sys.exit(1) @@ -271,7 +272,7 @@ def grayscale_to_heatmap(in_image, min_val, max_val, base_color): filenames = sorted(glob(os.path.join(temp_dir, "*.png"))) - with imageio.get_writer(out_file, mode="I", fps=6) as writer: + with imageio.get_writer(out_file, mode="I", duration=150) as writer: for filename in filenames: image = imageio.imread(filename) writer.append_data(image) diff --git a/pynest/examples/sudoku/README.rst b/pynest/examples/sudoku/README.rst index f197556f81..35e8d1c4ef 100644 --- a/pynest/examples/sudoku/README.rst +++ b/pynest/examples/sudoku/README.rst @@ -1,4 +1,10 @@ NEST Sudoku =========== -A PyNEST implementation of Sudoku as a constraint satisfaction problem +A PyNEST implementation of Sudoku as a constraint satisfaction +problem. + +You can run the solver using ``sudoku_solver.py``. It will display the +solution in the end. + +To visualize the solution process, you can afterwards run ``plot_progress.py``. diff --git a/pynest/examples/sudoku/plot_progress.py b/pynest/examples/sudoku/plot_progress.py index bbdfdbdce9..04b90fe47d 100644 --- a/pynest/examples/sudoku/plot_progress.py +++ b/pynest/examples/sudoku/plot_progress.py @@ -158,7 +158,7 @@ def get_progress(puzzle, solution): for filename in filenames: images.append(imageio.imread(filename)) -imageio.mimsave(out_file, images, fps=4) +imageio.mimsave(out_file, images, duration=250) print(f"gif created under: {out_file}") if not keep_temps: From 3ae321e64ccdbcf004dd29de076fa36a09c7117b Mon Sep 17 00:00:00 2001 From: Hans Ekkehard Plesser Date: Wed, 20 Sep 2023 18:10:50 +0200 Subject: [PATCH 154/168] Formatting in comment. --- pynest/examples/sudoku/README.rst | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/pynest/examples/sudoku/README.rst b/pynest/examples/sudoku/README.rst index 35e8d1c4ef..81f78058a0 100644 --- a/pynest/examples/sudoku/README.rst +++ b/pynest/examples/sudoku/README.rst @@ -1,8 +1,7 @@ NEST Sudoku =========== -A PyNEST implementation of Sudoku as a constraint satisfaction -problem. +A PyNEST implementation of Sudoku as a constraint satisfaction problem. You can run the solver using ``sudoku_solver.py``. It will display the solution in the end. From 5682b0b943b64a033d8d2817b2c58100090f14be Mon Sep 17 00:00:00 2001 From: Hans Ekkehard Plesser Date: Wed, 20 Sep 2023 18:14:09 +0200 Subject: [PATCH 155/168] Point out visualisation of Pong/Sudoku requires imagio. --- pynest/examples/pong/README.rst | 2 +- pynest/examples/sudoku/README.rst | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/pynest/examples/pong/README.rst b/pynest/examples/pong/README.rst index 2e8a4be063..7bc6c6d9a5 100644 --- a/pynest/examples/pong/README.rst +++ b/pynest/examples/pong/README.rst @@ -19,4 +19,4 @@ based on the ``stdp_dopamine_synapse`` and temporal difference learning is implemented, see ``networks.py`` for details. The learning progress and resulting game can be visualized with the -``generate_gif.py`` script. +``generate_gif.py`` script; this requires the ``imageio`` package. diff --git a/pynest/examples/sudoku/README.rst b/pynest/examples/sudoku/README.rst index 81f78058a0..ad0c9dc0aa 100644 --- a/pynest/examples/sudoku/README.rst +++ b/pynest/examples/sudoku/README.rst @@ -6,4 +6,5 @@ A PyNEST implementation of Sudoku as a constraint satisfaction problem. You can run the solver using ``sudoku_solver.py``. It will display the solution in the end. -To visualize the solution process, you can afterwards run ``plot_progress.py``. +To visualize the solution process, you can afterwards run ``plot_progress.py``; +this requires the ``imageio`` package. From 47be2ca982a7df1745d066ca32cf2a892f53cbd5 Mon Sep 17 00:00:00 2001 From: johannes gille Date: Fri, 22 Sep 2023 15:52:29 +0200 Subject: [PATCH 156/168] fix sudoku image generation --- pynest/examples/sudoku/plot_progress.py | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/pynest/examples/sudoku/plot_progress.py b/pynest/examples/sudoku/plot_progress.py index 827c2772fb..b7679cbfa8 100644 --- a/pynest/examples/sudoku/plot_progress.py +++ b/pynest/examples/sudoku/plot_progress.py @@ -49,7 +49,7 @@ def get_progress(puzzle, solution): - valid, boxes, rows, cols = helpers.validate_solution(puzzle, solution) + valid, boxes, rows, cols = helpers_sudoku.validate_solution(puzzle, solution) if valid: return 1.0 return (boxes.sum() + rows.sum() + cols.sum()) / 27 @@ -61,9 +61,6 @@ def get_progress(puzzle, solution): out_file = "sudoku.gif" # Name of the output GIF keep_temps = False # If True, temporary files will not be deleted -px = 1 / plt.rcParams['figure.dpi'] -plt.subplots(figsize=(600 * px, 400 * px)) - if os.path.exists(out_file): print(f"Target file ({out_file}) already exists! Aborting.") @@ -80,6 +77,7 @@ def get_progress(puzzle, solution): # store datapoints for multiple files in a single list lines = [] for file in in_files: + with open(file, "rb") as f: sim_data = pickle.load(f) @@ -97,6 +95,9 @@ def get_progress(puzzle, solution): solution_progress.append(get_progress(puzzle, solution_states[i])) for i in range(n_iterations): + px = 1 / plt.rcParams['figure.dpi'] + fig, ax = plt.subplots(figsize=(600 * px, 400 * px)) + ax.set_axis_off() current_state = solution_states[i] lines[-1][0] = x_data[:i + 1] @@ -124,10 +125,10 @@ def get_progress(puzzle, solution): ax = plt.subplot2grid((3, 3), (0, 1), rowspan=3, colspan=2) if i == 0: # repeat the (colorless) starting configuration several times - helpers.plot_field(sim_data['puzzle'], sim_data['puzzle'], ax, False) + helpers_sudoku.plot_field(puzzle, puzzle, ax, True) image_repeat = 8 else: - helpers.plot_field(puzzle, current_state, ax, True) + helpers_sudoku.plot_field(puzzle, current_state, ax, True) image_repeat = 1 if i == len(solution_states) - 1: @@ -139,6 +140,7 @@ def get_progress(puzzle, solution): for j in range(image_repeat): plt.savefig(os.path.join(temp_dir, f"{str(image_count).zfill(4)}.png")) image_count += 1 + plt.close() filenames = sorted(glob(os.path.join(temp_dir, "*.png"))) @@ -146,7 +148,7 @@ def get_progress(puzzle, solution): for filename in filenames: images.append(imageio.imread(filename)) -imageio.mimsave(out_file, images, fps=4) +imageio.mimsave(out_file, images, duration=250) print(f"gif created under: {out_file}") if not keep_temps: From 4daa16fa2792b153e4de18caf6e5cc506dafe9dd Mon Sep 17 00:00:00 2001 From: johannes gille Date: Fri, 22 Sep 2023 16:26:06 +0200 Subject: [PATCH 157/168] fix pong image generation --- pynest/examples/pong/generate_gif.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/pynest/examples/pong/generate_gif.py b/pynest/examples/pong/generate_gif.py index 0e2e5263b2..86918a84ae 100644 --- a/pynest/examples/pong/generate_gif.py +++ b/pynest/examples/pong/generate_gif.py @@ -40,9 +40,7 @@ import numpy as np from pong import GameOfPong as Pong -px = 1 / plt.rcParams["figure.dpi"] -plt.subplots(figsize=(400 * px, 300 * px)) -plt.rcParams.update({"font.size": 6}) + gridsize = (12, 16) # Shape of the grid used for positioning subplots @@ -182,6 +180,10 @@ def grayscale_to_heatmap(in_image, min_val, max_val, base_color): output_speed = DEFAULT_SPEED while i < n_iterations: + px = 1 / plt.rcParams["figure.dpi"] + fig, ax = plt.subplots(figsize=(400 * px, 300 * px)) + ax.set_axis_off() + plt.rcParams.update({"font.size": 6}) # Set up the grid containing all components of the output image title = plt.subplot2grid(gridsize, (0, 0), 1, 16) l_info = plt.subplot2grid(gridsize, (1, 0), 7, 2) @@ -266,6 +268,7 @@ def grayscale_to_heatmap(in_image, min_val, max_val, base_color): output_speed = DEFAULT_SPEED i += output_speed + plt.close() print("Image creation complete, collecting them into a GIF...") From 77c942f634044d3f3ec165b69926fa446f0e32d7 Mon Sep 17 00:00:00 2001 From: Hans Ekkehard Plesser Date: Fri, 22 Sep 2023 17:53:45 +0200 Subject: [PATCH 158/168] Fix formatting --- pynest/examples/pong/generate_gif.py | 1 - pynest/examples/sudoku/plot_progress.py | 9 ++++----- 2 files changed, 4 insertions(+), 6 deletions(-) diff --git a/pynest/examples/pong/generate_gif.py b/pynest/examples/pong/generate_gif.py index 86918a84ae..42e9c96c67 100644 --- a/pynest/examples/pong/generate_gif.py +++ b/pynest/examples/pong/generate_gif.py @@ -41,7 +41,6 @@ from pong import GameOfPong as Pong - gridsize = (12, 16) # Shape of the grid used for positioning subplots left_color = np.array((204, 0, 153)) # purple diff --git a/pynest/examples/sudoku/plot_progress.py b/pynest/examples/sudoku/plot_progress.py index 01ff3218a1..85c2c055d4 100644 --- a/pynest/examples/sudoku/plot_progress.py +++ b/pynest/examples/sudoku/plot_progress.py @@ -58,9 +58,9 @@ def get_progress(puzzle, solution): # Name of the .pkl files to read from. in_files = ["350Hz_puzzle_4.pkl"] -temp_dir = "tmp" # Name of directory for temporary files -out_file = "sudoku.gif" # Name of the output GIF -keep_temps = False # If True, temporary files will not be deleted +temp_dir = "tmp" # Name of directory for temporary files +out_file = "sudoku.gif" # Name of the output GIF +keep_temps = False # If True, temporary files will not be deleted if os.path.exists(out_file): @@ -78,7 +78,6 @@ def get_progress(puzzle, solution): # store datapoints for multiple files in a single list lines = [] for file in in_files: - with open(file, "rb") as f: sim_data = pickle.load(f) @@ -96,7 +95,7 @@ def get_progress(puzzle, solution): solution_progress.append(get_progress(puzzle, solution_states[i])) for i in range(n_iterations): - px = 1 / plt.rcParams['figure.dpi'] + px = 1 / plt.rcParams["figure.dpi"] fig, ax = plt.subplots(figsize=(600 * px, 400 * px)) ax.set_axis_off() current_state = solution_states[i] From 6273848c1b653a75390f76a33ec4c66e1c018733 Mon Sep 17 00:00:00 2001 From: Hans Ekkehard Plesser Date: Fri, 22 Sep 2023 18:01:32 +0200 Subject: [PATCH 159/168] Fix formatting --- pynest/examples/pong/generate_gif.py | 1 - 1 file changed, 1 deletion(-) diff --git a/pynest/examples/pong/generate_gif.py b/pynest/examples/pong/generate_gif.py index 42e9c96c67..890586849d 100644 --- a/pynest/examples/pong/generate_gif.py +++ b/pynest/examples/pong/generate_gif.py @@ -40,7 +40,6 @@ import numpy as np from pong import GameOfPong as Pong - gridsize = (12, 16) # Shape of the grid used for positioning subplots left_color = np.array((204, 0, 153)) # purple From 5a51eaf58933f8a079cee1ed3337ca8c2e105027 Mon Sep 17 00:00:00 2001 From: Jessica Mitchell Date: Mon, 25 Sep 2023 11:12:56 +0200 Subject: [PATCH 160/168] fix links --- doc/htmldoc/whats_new/v3.6/index.rst | 4 ++-- models/sic_connection.h | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/doc/htmldoc/whats_new/v3.6/index.rst b/doc/htmldoc/whats_new/v3.6/index.rst index 74c987609d..d95a8d9e8c 100644 --- a/doc/htmldoc/whats_new/v3.6/index.rst +++ b/doc/htmldoc/whats_new/v3.6/index.rst @@ -31,7 +31,7 @@ See examples using astrocyte models: See model docs: -* doc:`../../../models/index_astrocyte` +* :doc:`../../../models/index_astrocyte` New model: glif_psc_double_alpha -------------------------------- @@ -94,4 +94,4 @@ Changes in NEST Server ---------------------- We improved the security in NEST Server. Now to use NEST Server, users can modify the security options. -See :ref:`section on setting these varialbles ` in our NEST Server guide. \ No newline at end of file +See :ref:`section on setting these varialbles ` in our NEST Server guide. diff --git a/models/sic_connection.h b/models/sic_connection.h index 668b13b368..4a710ad633 100644 --- a/models/sic_connection.h +++ b/models/sic_connection.h @@ -43,7 +43,7 @@ induced by the astrocyte. The amplitude of the current is the product of the ast ``sic_connection``. The source node of a ``sic_connection`` must be an astrocyte emitting a slow inward current, and the target node must be -able to handle slow inward current input. Currently, :doc:`aeif_conda_alpha_astro` is the only neuron model that can +able to handle slow inward current input. Currently, :doc:`aeif_cond_alpha_astro` is the only neuron model that can receive ``sic_connection``. The connection may have a delay. Sends From 3bb24524ee15ea43b3e98c24cfbdbe7f20e116df Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Thu, 21 Sep 2023 14:22:57 +0200 Subject: [PATCH 161/168] Fix default origins for NEST Server --- pynest/nest/server/hl_api_server.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 13ced00441..20746ed5e6 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -50,7 +50,7 @@ def get_boolean_environ(env_key, default_value="false"): return env_value.lower() in ["yes", "true", "t", "1"] -_default_origins = "http://localhost" +_default_origins = "http://localhost:*" ACCESS_TOKEN = os.environ.get("NEST_SERVER_ACCESS_TOKEN", "") AUTH_DISABLED = get_boolean_environ("NEST_SERVER_DISABLE_AUTH") CORS_ORIGINS = os.environ.get("NEST_SERVER_CORS_ORIGINS", _default_origins).split(",") From 2eb9f8e4a78a0e98a6ed63f1c2fcdde7f88f79b4 Mon Sep 17 00:00:00 2001 From: Sebastian Spreizer Date: Mon, 25 Sep 2023 14:35:32 +0200 Subject: [PATCH 162/168] Fix typo --- pynest/nest/server/hl_api_server.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pynest/nest/server/hl_api_server.py b/pynest/nest/server/hl_api_server.py index 20746ed5e6..53362caf2f 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -86,7 +86,7 @@ def _check_security(): if "*" in CORS_ORIGINS: msg.append("CORS:\tThe allowed origins are not restricted.") if EXEC_CALL_ENABLED: - msg.append("EXEC CALL:\tThe exec route is enables and scripts can be executed.") + msg.append("EXEC CALL:\tThe exec route is enabled and scripts can be executed.") if RESTRICTION_DISABLED: msg.append("RESTRICTION: The execution of scripts is not protected by RestrictedPython.") From b88b099d71fe10c73d4443edd15bdbd93d2d77ae Mon Sep 17 00:00:00 2001 From: Dennis Terhorst Date: Thu, 28 Sep 2023 10:27:18 +0200 Subject: [PATCH 163/168] Update VERSION after 3.6 release --- VERSION | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/VERSION b/VERSION index 58e17a2cdf..7a5f20296a 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -3.5.0-post0.dev0 +3.6.0-post0.dev0 From 00b5025db7489e64143b22bc892720194808e1e5 Mon Sep 17 00:00:00 2001 From: Jessica Mitchell Date: Mon, 18 Sep 2023 11:18:24 +0200 Subject: [PATCH 164/168] make more extension like --- doc/htmldoc/_ext/extract_api_functions.py | 20 +++++++++++++++++--- doc/htmldoc/conf.py | 11 +---------- 2 files changed, 18 insertions(+), 13 deletions(-) diff --git a/doc/htmldoc/_ext/extract_api_functions.py b/doc/htmldoc/_ext/extract_api_functions.py index 2a39cb43cf..47e8e803b8 100644 --- a/doc/htmldoc/_ext/extract_api_functions.py +++ b/doc/htmldoc/_ext/extract_api_functions.py @@ -105,13 +105,27 @@ def process_directory(directory): return api_dict -def ExtractPyNESTAPIS(): +def get_pynest_list(app, env, docname): directory = "../../pynest/nest/" all_variables_dict = process_directory(directory) with open("api_function_list.json", "w") as outfile: json.dump(all_variables_dict, outfile, indent=4) + env.env_attribute.append(all_variables_dict) -if __name__ == "__main__": - ExtractPyNESTAPIS() + +def api_customizer(app, docname, source): + env = app.builder.env + if docname == "ref_material/pynest_api/index": + # list_apis = env.env_attribute + list_apis = json.load(open("api_function_list.json")) + html_context = {"api_dict": list_apis} + api_source = source[0] + rendered = app.builder.templates.render_string(api_source, html_context) + source[0] = rendered + + +def setup(app): + app.connect("env-before-read-docs", get_pynest_list) + app.connect("source-read", api_customizer) diff --git a/doc/htmldoc/conf.py b/doc/htmldoc/conf.py index 42096d1f56..5ea6cb4a51 100644 --- a/doc/htmldoc/conf.py +++ b/doc/htmldoc/conf.py @@ -57,6 +57,7 @@ "add_button_notebook", "IPython.sphinxext.ipython_console_highlighting", "nbsphinx", + "extract_api_functions", "sphinx_design", "HoverXTooltip", "VersionSyncRole", @@ -218,15 +219,6 @@ def get_pynest_list(app, env, docname): ExtractPyNESTAPIS() -def api_customizer(app, docname, source): - if docname == "ref_material/pynest_api/index": - list_apis = json.load(open("api_function_list.json")) - html_context = {"api_dict": list_apis} - api_source = source[0] - rendered = app.builder.templates.render_string(api_source, html_context) - source[0] = rendered - - def toc_customizer(app, docname, source): if docname == "models/models-toc": models_toc = json.load(open("models/toc-tree.json")) @@ -240,7 +232,6 @@ def setup(app): # for events see # https://www.sphinx-doc.org/en/master/extdev/appapi.html#sphinx-core-events app.connect("source-read", toc_customizer) - app.connect("source-read", api_customizer) app.add_css_file("css/custom.css") app.add_css_file("css/pygments.css") app.add_js_file("js/custom.js") From ee036761ba852cde34e5a40c3dbd0f2f43663b36 Mon Sep 17 00:00:00 2001 From: Jessica Mitchell Date: Fri, 29 Sep 2023 13:23:26 +0200 Subject: [PATCH 165/168] use env attribute --- doc/htmldoc/_ext/extract_api_functions.py | 21 +++++++++++++-------- 1 file changed, 13 insertions(+), 8 deletions(-) diff --git a/doc/htmldoc/_ext/extract_api_functions.py b/doc/htmldoc/_ext/extract_api_functions.py index 47e8e803b8..4c6a2a63a1 100644 --- a/doc/htmldoc/_ext/extract_api_functions.py +++ b/doc/htmldoc/_ext/extract_api_functions.py @@ -20,9 +20,10 @@ # along with NEST. If not, see . import ast import glob -import json import os import re +from sphinx.application import Sphinx + """ Generate a JSON dictionary that stores the module name as key and corresponding @@ -107,20 +108,18 @@ def process_directory(directory): def get_pynest_list(app, env, docname): directory = "../../pynest/nest/" - all_variables_dict = process_directory(directory) - with open("api_function_list.json", "w") as outfile: - json.dump(all_variables_dict, outfile, indent=4) + if not hasattr(env, "pynest_dict"): + env.pynest_dict = {} - env.env_attribute.append(all_variables_dict) + env.pynest_dict = process_directory(directory) def api_customizer(app, docname, source): env = app.builder.env if docname == "ref_material/pynest_api/index": - # list_apis = env.env_attribute - list_apis = json.load(open("api_function_list.json")) - html_context = {"api_dict": list_apis} + get_apis = env.pynest_dict + html_context = {"api_dict": get_apis} api_source = source[0] rendered = app.builder.templates.render_string(api_source, html_context) source[0] = rendered @@ -129,3 +128,9 @@ def api_customizer(app, docname, source): def setup(app): app.connect("env-before-read-docs", get_pynest_list) app.connect("source-read", api_customizer) + + return { + "version": "0.1", + "parallel_read_safe": True, + "parallel_write_safe": True, + } From b8d78b02c0fb2419cb077872f80427633bec81d2 Mon Sep 17 00:00:00 2001 From: Jessica Mitchell Date: Fri, 29 Sep 2023 13:35:59 +0200 Subject: [PATCH 166/168] remove conf.py call --- doc/htmldoc/conf.py | 6 ------ 1 file changed, 6 deletions(-) diff --git a/doc/htmldoc/conf.py b/doc/htmldoc/conf.py index 5ea6cb4a51..fbc0ba0b0a 100644 --- a/doc/htmldoc/conf.py +++ b/doc/htmldoc/conf.py @@ -32,7 +32,6 @@ extension_module_dir = os.path.abspath("./_ext") sys.path.append(extension_module_dir) -from extract_api_functions import ExtractPyNESTAPIS # noqa from extractor_userdocs import ExtractUserDocs, relative_glob # noqa repo_root_dir = os.path.abspath("../..") @@ -215,10 +214,6 @@ def config_inited_handler(app, config): ) -def get_pynest_list(app, env, docname): - ExtractPyNESTAPIS() - - def toc_customizer(app, docname, source): if docname == "models/models-toc": models_toc = json.load(open("models/toc-tree.json")) @@ -235,7 +230,6 @@ def setup(app): app.add_css_file("css/custom.css") app.add_css_file("css/pygments.css") app.add_js_file("js/custom.js") - app.connect("env-before-read-docs", get_pynest_list) app.connect("config-inited", config_inited_handler) From f0a967bf4de1a3a5acfb59ea0e8a070e9a1c0b25 Mon Sep 17 00:00:00 2001 From: Jessica Mitchell Date: Fri, 29 Sep 2023 13:45:38 +0200 Subject: [PATCH 167/168] isort --- doc/htmldoc/_ext/extract_api_functions.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/htmldoc/_ext/extract_api_functions.py b/doc/htmldoc/_ext/extract_api_functions.py index 4c6a2a63a1..09b0f2e36f 100644 --- a/doc/htmldoc/_ext/extract_api_functions.py +++ b/doc/htmldoc/_ext/extract_api_functions.py @@ -22,8 +22,8 @@ import glob import os import re -from sphinx.application import Sphinx +from sphinx.application import Sphinx """ Generate a JSON dictionary that stores the module name as key and corresponding From b287d56f6f499c0f0e9cf11b9aeaf5f329c3ada5 Mon Sep 17 00:00:00 2001 From: Hans Ekkehard Plesser Date: Sat, 7 Oct 2023 17:30:12 +0200 Subject: [PATCH 168/168] Properly suppress pylint complaints about unused plt in tests --- testsuite/pytests/test_stdp_pl_synapse_hom.py | 1 + testsuite/pytests/test_stdp_synapse.py | 1 + 2 files changed, 2 insertions(+) diff --git a/testsuite/pytests/test_stdp_pl_synapse_hom.py b/testsuite/pytests/test_stdp_pl_synapse_hom.py index a9dcb6507d..e334462b64 100644 --- a/testsuite/pytests/test_stdp_pl_synapse_hom.py +++ b/testsuite/pytests/test_stdp_pl_synapse_hom.py @@ -332,6 +332,7 @@ def plot_weight_evolution( fname_snip="", title_snip="", ): + # pylint: disable=E0601 fig, ax = plt.subplots(nrows=3) n_spikes = len(pre_spikes) diff --git a/testsuite/pytests/test_stdp_synapse.py b/testsuite/pytests/test_stdp_synapse.py index 22e64a8209..49307aa71d 100644 --- a/testsuite/pytests/test_stdp_synapse.py +++ b/testsuite/pytests/test_stdp_synapse.py @@ -366,6 +366,7 @@ def plot_weight_evolution( fname_snip="", title_snip="", ): + # pylint: disable=E0601 fig, ax = plt.subplots(nrows=3) n_spikes = len(pre_spikes)