diff --git a/.github/workflows/nestbuildmatrix.yml b/.github/workflows/nestbuildmatrix.yml index d6d9362185..56a79017a2 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 --thirdparty="nest" --check-only --diff 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" diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 8b6555b246..dccd50487f 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", "--thirdparty", "nest", "--diff"] - repo: https://github.com/psf/black - rev: 23.3.0 + rev: 23.7.0 hooks: - id: black language_version: python3 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 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 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/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} 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/add_button_notebook.py b/doc/htmldoc/_ext/add_button_notebook.py index 5813723532..7375f0a2db 100644 --- a/doc/htmldoc/_ext/add_button_notebook.py +++ b/doc/htmldoc/_ext/add_button_notebook.py @@ -22,9 +22,10 @@ import glob import os import sys -from sphinx.application import Sphinx from pathlib import Path +from sphinx.application import Sphinx + def add_button_to_examples(app, env, docnames): """Find all examples and include a link to launch notebook. diff --git a/doc/htmldoc/_ext/extract_api_functions.py b/doc/htmldoc/_ext/extract_api_functions.py index 04bd8f2e60..09b0f2e36f 100644 --- a/doc/htmldoc/_ext/extract_api_functions.py +++ b/doc/htmldoc/_ext/extract_api_functions.py @@ -18,12 +18,12 @@ # # You should have received a copy of the GNU General Public License # along with NEST. If not, see . -import os import ast -import json -import re import glob +import os +import re +from sphinx.application import Sphinx """ Generate a JSON dictionary that stores the module name as key and corresponding @@ -106,13 +106,31 @@ 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) + if not hasattr(env, "pynest_dict"): + env.pynest_dict = {} + + env.pynest_dict = process_directory(directory) + + +def api_customizer(app, docname, source): + env = app.builder.env + if docname == "ref_material/pynest_api/index": + 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 + +def setup(app): + app.connect("env-before-read-docs", get_pynest_list) + app.connect("source-read", api_customizer) -if __name__ == "__main__": - ExtractPyNESTAPIS() + return { + "version": "0.1", + "parallel_read_safe": True, + "parallel_write_safe": True, + } diff --git a/doc/htmldoc/_ext/extractor_userdocs.py b/doc/htmldoc/_ext/extractor_userdocs.py index 39146b1059..160982a645 100644 --- a/doc/htmldoc/_ext/extractor_userdocs.py +++ b/doc/htmldoc/_ext/extractor_userdocs.py @@ -19,18 +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(__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/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 e40a60b8d7..fbc0ba0b0a 100644 --- a/doc/htmldoc/conf.py +++ b/doc/htmldoc/conf.py @@ -20,22 +20,19 @@ # 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") sys.path.append(extension_module_dir) from extractor_userdocs import ExtractUserDocs, relative_glob # noqa -from extract_api_functions import ExtractPyNESTAPIS # noqa repo_root_dir = os.path.abspath("../..") pynest_dir = os.path.join(repo_root_dir, "pynest") @@ -59,6 +56,7 @@ "add_button_notebook", "IPython.sphinxext.ipython_console_highlighting", "nbsphinx", + "extract_api_functions", "sphinx_design", "HoverXTooltip", "VersionSyncRole", @@ -216,19 +214,6 @@ def config_inited_handler(app, config): ) -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")) @@ -242,11 +227,9 @@ 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") - app.connect("env-before-read-docs", get_pynest_list) app.connect("config-inited", config_inited_handler) diff --git a/doc/htmldoc/connect_nest/nest_server.rst b/doc/htmldoc/connect_nest/nest_server.rst index 3657e6c16e..c873d93fc6 100644 --- a/doc/htmldoc/connect_nest/nest_server.rst +++ b/doc/htmldoc/connect_nest/nest_server.rst @@ -91,6 +91,20 @@ 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 +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +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 ``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 ``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 ~~~~~~~~~~~~~~~ diff --git a/doc/htmldoc/developer_space/guidelines/coding_guidelines_check.rst b/doc/htmldoc/developer_space/guidelines/coding_guidelines_check.rst index 4871185c56..963b5f5811 100644 --- a/doc/htmldoc/developer_space/guidelines/coding_guidelines_check.rst +++ b/doc/htmldoc/developer_space/guidelines/coding_guidelines_check.rst @@ -1,81 +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 +~~~~~~~~~~ +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. -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. +To set up the Git hook scripts specified in ``.pre-commit-config.yaml``, run -From the source directory call: +.. code-block:: bash -.. code:: + pre-commit install - ./build_support/format_all_c_c++_files.sh [start folder, defaults to '$PWD'] +.. note:: -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. + 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. -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. +Black +~~~~~ +We enforce `PEP8 `_ formatting of Python code by using the uncompromising +`Black `_ formatter. -In addition, we let `cppcheck `_ statically analyse -the committed files and check for severe errors. We require cppcheck version -1.69 or later. +``Black`` is run automatically with ``pre-commit``. -.. code:: sh +Run ``Black`` manually with + +.. code-block:: bash + + 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 diff --git a/doc/htmldoc/model_details/aeif_models_implementation.ipynb b/doc/htmldoc/model_details/aeif_models_implementation.ipynb index 00d25e4e1d..38f1bce242 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" + "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." ] }, { @@ -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/doc/htmldoc/networks/scripts/connections.py b/doc/htmldoc/networks/scripts/connections.py index b420a30cb1..ae96d82c27 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/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..d95a8d9e8c 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 into 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,27 @@ 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 `. + +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. 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/environment.yml b/environment.yml index 7ac6b3e6cd..f7849be8e8 100644 --- a/environment.yml +++ b/environment.yml @@ -74,7 +74,6 @@ dependencies: # Building NEST documentation - PyYAML>=4.2b1 - - assimulo - breathe - csvkit - docutils 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/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 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 diff --git a/nestkernel/connection_manager.cpp b/nestkernel/connection_manager.cpp index cdc4fcf9cf..037d8d3de4 100644 --- a/nestkernel/connection_manager.cpp +++ b/nestkernel/connection_manager.cpp @@ -1509,6 +1509,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 ); } } } diff --git a/pynest/examples/BrodyHopfield.py b/pynest/examples/BrodyHopfield.py index db32eda88d..5d73e22eca 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 0605eb3626..05c3a49f10 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 bdca06511e..7f09f47c21 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 fb48e236d6..297129282f 100644 --- a/pynest/examples/aeif_cond_beta_multisynapse.py +++ b/pynest/examples/aeif_cond_beta_multisynapse.py @@ -26,9 +26,8 @@ """ import matplotlib.pyplot as plt -import numpy as np - import nest +import numpy as np 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/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/balancedneuron.py b/pynest/examples/balancedneuron.py index 4a9da52fbd..88940791c9 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 23ff335f89..9bb172c51c 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 3861a21c83..3d4d995f8a 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 a6f8d3a14f..e89f2a4391 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 @@ -387,7 +387,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/brunel_alpha_nest.py b/pynest/examples/brunel_alpha_nest.py index 0cd92cff5e..b80365cb0b 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 da8055bbae..6b22f8377c 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 29290a92db..386a5ab602 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 fb829bb4da..935aa1490b 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 19c48ff541..fdd352bd26 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/evaluate_quantal_stp_synapse.py b/pynest/examples/evaluate_quantal_stp_synapse.py index 583a1f0f1b..de4b3708dc 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``, @@ -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 diff --git a/pynest/examples/evaluate_tsodyks2_synapse.py b/pynest/examples/evaluate_tsodyks2_synapse.py index 3d9cef483f..9134e04ab2 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 fa81b4821b..8fb2e60f87 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 6c02bb24db..b241c6b25d 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 6b49d21a1a..dab1f6905f 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 4aacc0561a..2585b12563 100644 --- a/pynest/examples/gif_pop_psc_exp.py +++ b/pynest/examples/gif_pop_psc_exp.py @@ -44,12 +44,12 @@ """ +############################################################################### +# Import necessary modules. -# Loading the necessary modules: -import numpy as np import matplotlib.pyplot as plt import nest - +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 d6b1ce233c..c90ca1ef82 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 5a84ff491f..ea827fab55 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_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/pynest/examples/glif_psc_neuron.py b/pynest/examples/glif_psc_neuron.py index 56e6150134..854441929b 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 5318d40ed9..c545c698ea 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 3c8d34beb6..b4cc11b5be 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 7987c230fe..37dec5a941 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 8ada93ac53..324979c0cd 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 cb720ec530..e3c843334f 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 af6cf12bba..21388f5ee9 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 f0210a223a..879368e5ea 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 d48cce35dc..19410f45c3 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 6fd9f697d7..93407f5e5d 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 5fdc372f4c..9ca53e9ca3 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/README.rst b/pynest/examples/pong/README.rst index ddde75b354..7bc6c6d9a5 100644 --- a/pynest/examples/pong/README.rst +++ b/pynest/examples/pong/README.rst @@ -5,18 +5,18 @@ the classic game of Pong. Requirements ------------ -- NEST 3.3 +- NEST 3.3 or later - NumPy - Matplotlib 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 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; this requires the ``imageio`` package. diff --git a/pynest/examples/pong/generate_gif.py b/pynest/examples/pong/generate_gif.py index fb16f385a1..890586849d 100644 --- a/pynest/examples/pong/generate_gif.py +++ b/pynest/examples/pong/generate_gif.py @@ -28,23 +28,18 @@ :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"] -plt.subplots(figsize=(400 * px, 300 * px)) -plt.rcParams.update({"font.size": 6}) - gridsize = (12, 16) # Shape of the grid used for positioning subplots left_color = np.array((204, 0, 153)) # purple @@ -138,6 +133,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) @@ -182,6 +178,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,12 +266,13 @@ 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...") 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/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 09cd6ed2d7..875ce630f0 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 6c03b36e74..942fb71f1f 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 f9791192ea..15df8d6880 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 347e9b98d5..22a6b3aaa8 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 627e34f09d..5bfb208d37 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 1f12d6ca12..a018966c88 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 8e08c299e0..faff67f1b6 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 132b40db0a..e4b331b14b 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 e23c4daed4..96a163b891 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 ac6b2905f7..7ee26a8d40 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 e3c5b41691..6fa643cd50 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 86af4c0a8c..d5ccb594b4 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 3e5827f419..aaf1557a10 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 ffde77b030..b3f7bda217 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 6dd59ce9d5..9a6f06742e 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 b363194754..4f454e4cbe 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 26649ef66c..6e2ddd4cf5 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 88c2eca754..fe752f32db 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 e97f242d8d..3bba3e2111 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 4116579496..33aef6b139 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 2d0ac03938..aec62cecae 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 @@ -300,8 +302,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() @@ -366,6 +366,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() diff --git a/pynest/examples/structural_plasticity.py b/pynest/examples/structural_plasticity.py index 8320ed4829..d6480a7fdc 100644 --- a/pynest/examples/structural_plasticity.py +++ b/pynest/examples/structural_plasticity.py @@ -48,11 +48,11 @@ #################################################################################### # First, we 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/README.rst b/pynest/examples/sudoku/README.rst index f197556f81..ad0c9dc0aa 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``; +this requires the ``imageio`` package. 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..85c2c055d4 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): @@ -61,9 +62,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.") @@ -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] @@ -136,7 +137,7 @@ 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_sudoku.plot_field(sim_data["puzzle"], sim_data["puzzle"], ax, False) + helpers_sudoku.plot_field(puzzle, puzzle, ax, False) image_repeat = 8 else: helpers_sudoku.plot_field(puzzle, current_state, ax, True) @@ -151,6 +152,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"))) @@ -158,7 +160,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: 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 23d70df987..3fb5c76d43 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 5975646f9d..abf9f0e780 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 1bd71d9a1c..49bcf61cb3 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 22cddd3888..837fbfde69 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 931739761f..85d46180be 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 ce542228d2..5bc03947da 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 8b27f0e820..908f94e37b 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 9b79823f6a..e32467e290 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,12 +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 synapsemodels # 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 82c884094c..d191e7cbd5 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 25f4cfd61a..6a10636dc8 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_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 a226c0d945..daab4cbf9d 100644 --- a/pynest/nest/lib/hl_api_models.py +++ b/pynest/nest/lib/hl_api_models.py @@ -25,11 +25,16 @@ import numpy -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_helper import ( + deprecated, + is_iterable, + is_literal, + model_deprecation_warning, +) +from .hl_api_simulation import GetKernelStatus from .hl_api_types import to_json +from ..ll_api import check_stack, spp, sps, sr from ..synapsemodels.hl_api_synapsemodels import _copy_synapse_class -from .hl_api_simulation import GetKernelStatus __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 9fba479858..54ed584611 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/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 d167ef4d91..53362caf2f 100644 --- a/pynest/nest/server/hl_api_server.py +++ b/pynest/nest/server/hl_api_server.py @@ -23,34 +23,42 @@ import importlib import inspect import io +import logging +import os import sys +import time +import traceback +from copy import deepcopy -from flask import Flask, request, jsonify -from flask_cors import CORS, cross_origin - +import flask +import nest +import RestrictedPython +from flask import Flask, jsonify, request +from flask.logging import default_handler +from flask_cors import CORS from werkzeug.exceptions import abort from werkzeug.wrappers import Response -import nest +# 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 RestrictedPython -import time - -import traceback -from copy import deepcopy +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"] -import os -MODULES = os.environ.get("NEST_SERVER_MODULES", "nest").split(",") -RESTRICTION_OFF = bool(os.environ.get("NEST_SERVER_RESTRICTION_OFF", 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") +MODULES = os.environ.get("NEST_SERVER_MODULES", "import nest") +RESTRICTION_DISABLED = get_boolean_environ("NEST_SERVER_DISABLE_RESTRICTION") EXCEPTION_ERROR_STATUS = 400 -if RESTRICTION_OFF: - msg = "NEST Server runs without a RestrictedPython trusted environment." - print(f"***\n*** WARNING: {msg}\n***") - - __all__ = [ "app", "do_exec", @@ -60,11 +68,116 @@ ] app = Flask(__name__) -CORS(app) +# 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 +def _check_security(): + """ + Checks the security level of the NEST Server instance. + """ + + msg = [] + if AUTH_DISABLED: + msg.append("AUTH:\tThe authorization settings are disabled.") + 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 enabled and scripts can be executed.") + if RESTRICTION_DISABLED: + msg.append("RESTRICTION: The execution of scripts is not protected by RestrictedPython.") + + 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!" + ) + print("\n - ".join([" "] + msg) + "\n") + + +@app.before_request +def _setup_auth(): + """ + 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 + 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 gc # noqa + import hashlib # noqa + import inspect # noqa + import time # 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"): + 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" Access token to NEST Server: {self._hash}") + print(" Add this to the headers: {'NESTServerAuth': ''}\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. + 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. + try: + del globals()["app"] + except KeyError: + pass + # 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 auth == self._hash): + return ("Unauthorized", 403) + # DON'T LINT! Intentional bare except clause! Even `KeyboardInterrupt` and + # `SystemExit` exceptions should not bypass authentication! + except Exception: # noqa + return ("Unauthorized", 403) + + +print(80 * "*") +_check_security() +_setup_auth() +del _setup_auth +print(80 * "*") + + @app.route("/", methods=["GET"]) def index(): return jsonify( @@ -82,7 +195,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()) @@ -110,7 +223,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): @@ -165,13 +278,18 @@ def do_call(call_name, args=[], kwargs={}): @app.route("/exec", methods=["GET", "POST"]) -@cross_origin() def route_exec(): """Route to execute script in Python.""" - args, kwargs = get_arguments(request) - response = do_call("exec", args, kwargs) - return jsonify(response) + if EXEC_CALL_ENABLED: + args, kwargs = get_arguments(request) + response = do_call("exec", args, kwargs) + return jsonify(response) + else: + flask.abort( + 403, + "The route `/exec` has been disabled. Please contact the server administrator.", + ) # -------------------------- @@ -184,14 +302,12 @@ def route_exec(): @app.route("/api", methods=["GET"]) -@cross_origin() def route_api(): """Route to list call functions in NEST.""" return jsonify(nest_calls) @app.route("/api/", methods=["GET", "POST"]) -@cross_origin() def route_api_call(call): """Route to call function in NEST.""" print(f"\n{'='*40}\n", flush=True) @@ -287,7 +403,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 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 05ffbca6fa..9f7cc6f130 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -7,5 +7,9 @@ markers = [ "simulation: the simulation class to use. Always pass a 2nd dummy argument" ] +[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 a00e4cd7ba..dabee55088 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 61c4e1bca0..c8757d8086 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_connect/test_getconnections_multiple_syn_models.py b/testsuite/pytests/sli2py_connect/test_getconnections_multiple_syn_models.py index c15cbfca01..038dcedfcd 100644 --- a/testsuite/pytests/sli2py_connect/test_getconnections_multiple_syn_models.py +++ b/testsuite/pytests/sli2py_connect/test_getconnections_multiple_syn_models.py @@ -27,12 +27,11 @@ and some also have both. """ +import nest import numpy.testing as nptest import pandas as pd import pytest -import nest - def build_net(num_threads=1): """ 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 d81873da36..ee60d9a650 100644 --- a/testsuite/pytests/sli2py_neurons/test_add_freeze_thaw.py +++ b/testsuite/pytests/sli2py_neurons/test_add_freeze_thaw.py @@ -23,11 +23,10 @@ Test that per-thread nodes vectors are updated. """ +import nest import numpy as np import pytest -import nest - @pytest.mark.skipif_missing_threads def test_add_freeze_thaw(): 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_multisynapse_models.py b/testsuite/pytests/sli2py_neurons/test_multisynapse_models.py index 1a9bacb15a..c8f8406eea 100644 --- a/testsuite/pytests/sli2py_neurons/test_multisynapse_models.py +++ b/testsuite/pytests/sli2py_neurons/test_multisynapse_models.py @@ -23,9 +23,8 @@ Test properties of multisynapse models. """ -import pytest - import nest +import pytest @pytest.fixture(autouse=True) diff --git a/testsuite/pytests/sli2py_neurons/test_neurons_handle_multiplicity.py b/testsuite/pytests/sli2py_neurons/test_neurons_handle_multiplicity.py index 6bd94960de..b76e844853 100644 --- a/testsuite/pytests/sli2py_neurons/test_neurons_handle_multiplicity.py +++ b/testsuite/pytests/sli2py_neurons/test_neurons_handle_multiplicity.py @@ -26,12 +26,11 @@ the spikes have arrived must be identical in both cases. """ +import nest import numpy as np import numpy.testing as nptest import pytest -import nest - # The following models will not be tested: 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_multiple_random_source_stepping.py b/testsuite/pytests/sli2py_other/test_multiple_random_source_stepping.py index 56dea8c501..f13fa9eb47 100644 --- a/testsuite/pytests/sli2py_other/test_multiple_random_source_stepping.py +++ b/testsuite/pytests/sli2py_other/test_multiple_random_source_stepping.py @@ -33,9 +33,8 @@ only. """ -import numpy.testing as nptest - import nest +import numpy.testing as nptest def run_sim(interval, steppings): 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_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 188f28157f..5929630174 100644 --- a/testsuite/pytests/sli2py_recording/test_multimeter_stepping.py +++ b/testsuite/pytests/sli2py_recording/test_multimeter_stepping.py @@ -23,13 +23,11 @@ Test multimeter recording in stepwise simulation. """ +import nest import pandas as pd import pandas.testing as pdtest import pytest -import nest - -# The following models will not be tested: skip_models = [ "erfc_neuron", # binary neuron "ginzburg_neuron", # binary neuron diff --git a/testsuite/pytests/sli2py_regressions/test_issue_105.py b/testsuite/pytests/sli2py_regressions/test_issue_105.py index 2c6aa62f15..bde128b276 100644 --- a/testsuite/pytests/sli2py_regressions/test_issue_105.py +++ b/testsuite/pytests/sli2py_regressions/test_issue_105.py @@ -23,9 +23,8 @@ Regression test for Issue #105 (GitHub). """ -import pytest - import nest +import pytest @pytest.fixture(autouse=True) diff --git a/testsuite/pytests/sli2py_regressions/test_issue_1140.py b/testsuite/pytests/sli2py_regressions/test_issue_1140.py index 809b818b82..e7aa9722fa 100644 --- a/testsuite/pytests/sli2py_regressions/test_issue_1140.py +++ b/testsuite/pytests/sli2py_regressions/test_issue_1140.py @@ -26,11 +26,10 @@ arrays for `rate_times` and `rate_values`. """ +import nest import numpy.testing as nptest import pytest -import nest - @pytest.fixture(autouse=True) def reset(): 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_1640.py b/testsuite/pytests/sli2py_regressions/test_issue_1640.py index 486c746329..cd3ee64814 100644 --- a/testsuite/pytests/sli2py_regressions/test_issue_1640.py +++ b/testsuite/pytests/sli2py_regressions/test_issue_1640.py @@ -23,11 +23,10 @@ Regression test for Issue #1640 (GitHub). """ +import nest import numpy as np import pytest -import nest - @pytest.mark.skipif_missing_threads @pytest.mark.parametrize("num_threads", [2, 3, 4]) diff --git a/testsuite/pytests/sli2py_regressions/test_issue_2282.py b/testsuite/pytests/sli2py_regressions/test_issue_2282.py index ce03fa9c2d..9a951b1277 100644 --- a/testsuite/pytests/sli2py_regressions/test_issue_2282.py +++ b/testsuite/pytests/sli2py_regressions/test_issue_2282.py @@ -26,11 +26,10 @@ `noise_generator` if NEST runs with multiple threads. """ +import nest import numpy as np import pytest -import nest - pytestmark = pytest.mark.skipif_missing_threads diff --git a/testsuite/pytests/sli2py_regressions/test_issue_2629.py b/testsuite/pytests/sli2py_regressions/test_issue_2629.py index 270c6b66be..dfc14e6b2d 100644 --- a/testsuite/pytests/sli2py_regressions/test_issue_2629.py +++ b/testsuite/pytests/sli2py_regressions/test_issue_2629.py @@ -39,9 +39,8 @@ is possible to pass a ``pathlib.Path`` object as filename. """ -import pytest - import nest +import pytest @pytest.fixture(scope="module") 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/sli2py_regressions/test_issue_264.py b/testsuite/pytests/sli2py_regressions/test_issue_264.py index d4a6a4da90..8fec1a7e6a 100644 --- a/testsuite/pytests/sli2py_regressions/test_issue_264.py +++ b/testsuite/pytests/sli2py_regressions/test_issue_264.py @@ -30,9 +30,8 @@ handles the unusual case where NEST is compiled with a different value. """ -import pytest - import nest +import pytest @pytest.fixture(autouse=True) 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/test_issue_521.py b/testsuite/pytests/sli2py_regressions/test_issue_521.py index 36ab733a26..0da8cf98cc 100644 --- a/testsuite/pytests/sli2py_regressions/test_issue_521.py +++ b/testsuite/pytests/sli2py_regressions/test_issue_521.py @@ -23,9 +23,8 @@ Regression test for Issue #521 (GitHub). """ -import pytest - import nest +import pytest @pytest.mark.skipif_missing_threads diff --git a/testsuite/pytests/sli2py_regressions/test_issue_77.py b/testsuite/pytests/sli2py_regressions/test_issue_77.py index 86264a74b0..69baa9aad3 100644 --- a/testsuite/pytests/sli2py_regressions/test_issue_77.py +++ b/testsuite/pytests/sli2py_regressions/test_issue_77.py @@ -23,9 +23,8 @@ Regression test for Issue #77 (GitHub). """ -import pytest - import nest +import pytest # The following models will not be tested: skip_models = [ 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) diff --git a/testsuite/pytests/sli2py_regressions/test_ticket_754.py b/testsuite/pytests/sli2py_regressions/test_ticket_754.py index f92a1fb0a8..6c33c3a3a3 100644 --- a/testsuite/pytests/sli2py_regressions/test_ticket_754.py +++ b/testsuite/pytests/sli2py_regressions/test_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_aeif_lsodar.py b/testsuite/pytests/test_aeif_lsodar.py index 4027211ba9..7c22de6882 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_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_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 b4425d64b7..34a2217ff2 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 6dbc7e5628..96809e2f91 100644 --- a/testsuite/pytests/test_compartmental_model.py +++ b/testsuite/pytests/test_compartmental_model.py @@ -25,10 +25,10 @@ import nest import unittest + import numpy as np import nest.lib.hl_api_projections as hl_api_projections - SP = {"C_m": 1.00, "g_C": 0.00, "g_L": 0.100, "e_L": -70.0} DP = [ {"C_m": 0.10, "g_C": 0.10, "g_L": 0.010, "e_L": -70.0}, diff --git a/testsuite/pytests/test_connect_all_to_all.py b/testsuite/pytests/test_connect_all_to_all.py index 0a35b3c8e3..39a2018469 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 ff1421a8ab..60e2ce5532 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 91f4b4d6a2..bc7bb4bbd4 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 a80db17f3c..df96c6da0c 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 3cf6602f90..d54ee533f4 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 e98fd707e4..55bb0e21c6 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 33e7145d14..ade5d11cf0 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 a3cd31b846..14af71c1c8 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_node_collection.py b/testsuite/pytests/test_connect_node_collection.py index da323fef9c..94808aa1a8 100644 --- a/testsuite/pytests/test_connect_node_collection.py +++ b/testsuite/pytests/test_connect_node_collection.py @@ -23,9 +23,8 @@ Test basic connection with ``NodeCollection``. """ -import pytest - import nest +import pytest @pytest.fixture(autouse=True) diff --git a/testsuite/pytests/test_connect_one_to_one.py b/testsuite/pytests/test_connect_one_to_one.py index d10be21602..3abb616710 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 3a404e1029..c9e2935aa5 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 7aeaa39985..d5c9299f5e 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_current_recording_generators.py b/testsuite/pytests/test_current_recording_generators.py index 94a0397e41..c0667631c5 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 19137c5bd5..31d7849a55 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 f50601fca0..66935a734a 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 dff9ed431c..562c94dc1b 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_connections.py b/testsuite/pytests/test_get_connections.py index 0e9c35641b..f08d1d40f5 100644 --- a/testsuite/pytests/test_get_connections.py +++ b/testsuite/pytests/test_get_connections.py @@ -27,12 +27,11 @@ elsewhere. """ +import nest import pandas as pd import pandas.testing as pdtest import pytest -import nest - @pytest.fixture(autouse=True) def reset(): diff --git a/testsuite/pytests/test_getconnections.py b/testsuite/pytests/test_getconnections.py index 0f005c727f..7d264f0a7e 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 6c570cbc0f..48fac5c15e 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 d6758de3dc..cad59b6a8f 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_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_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_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 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 861b78be8b..3b7f62b1cb 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 ebe1929d70..55c43f2501 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 c61efd58e5..1767a78596 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 5308084937..9cbcacece2 100644 --- a/testsuite/pytests/test_multimeter.py +++ b/testsuite/pytests/test_multimeter.py @@ -19,11 +19,10 @@ # 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 -import nest - # Obtain all models with non-empty recordables list all_models_with_rec = [model for model in nest.node_models if nest.GetDefaults(model).get("recordables")] diff --git a/testsuite/pytests/test_multiple_synapses.py b/testsuite/pytests/test_multiple_synapses.py index 7cdeaf7d29..39c637ff10 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 8e09138662..7894d411e5 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_node_collection_indexing_slicing.py b/testsuite/pytests/test_node_collection_indexing_slicing.py index 03479bf2f2..734e600f5d 100644 --- a/testsuite/pytests/test_node_collection_indexing_slicing.py +++ b/testsuite/pytests/test_node_collection_indexing_slicing.py @@ -24,11 +24,10 @@ """ +import nest import numpy as np import pytest -import nest - @pytest.fixture(autouse=True) def reset(): diff --git a/testsuite/pytests/test_node_collection_operations.py b/testsuite/pytests/test_node_collection_operations.py index d8269c13e0..d8764fe10f 100644 --- a/testsuite/pytests/test_node_collection_operations.py +++ b/testsuite/pytests/test_node_collection_operations.py @@ -23,11 +23,10 @@ Test basic operations with ``NodeCollection``. """ +import nest import numpy as np import pytest -import nest - @pytest.fixture(autouse=True) def reset(): diff --git a/testsuite/pytests/test_node_collection_to_from_object.py b/testsuite/pytests/test_node_collection_to_from_object.py index 354b72bf7c..2c1d9eece3 100644 --- a/testsuite/pytests/test_node_collection_to_from_object.py +++ b/testsuite/pytests/test_node_collection_to_from_object.py @@ -24,12 +24,11 @@ """ +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/test_onetooneconnect.py b/testsuite/pytests/test_onetooneconnect.py index 2da61d6757..a99a446f12 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 d9294d2bac..5844d98981 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 008a9c93e7..b558d5934e 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 8ed90694df..3074c65856 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 042121febc..30bc7b1da9 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 da9728020b..e769deaafa 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 a6cb65e52e..e2f95394cb 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 d72874b61b..6f7c84c9eb 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 f4a0f4b074..555270bee2 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 bab41ed557..0273103143 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 2ded2a7d6a..cbf34f51a0 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 498204e019..1cfb9ff597 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 4f7179e130..12d40b4f9f 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 2e86d56807..9b4f17290c 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 6f230165ac..be4abd7ea1 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 71e45359ce..c7acfe8a4d 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 f9ff90c275..bf8282a145 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 4b85e5e9e7..d76df81cdd 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 8ec3d801c1..6e84c41f0d 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_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 diff --git a/testsuite/pytests/test_siegert_neuron.py b/testsuite/pytests/test_siegert_neuron.py index f3628197b0..2adc24a6d9 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 4298e1fa3c..caee8d22c4 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 5657abd590..4819d2d228 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 c505444caf..733c6db31f 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 ce12177c07..c8d1991504 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_autapses_multapses.py b/testsuite/pytests/test_sp/test_sp_autapses_multapses.py index d7ea4185f5..1d181fffc0 100644 --- a/testsuite/pytests/test_sp/test_sp_autapses_multapses.py +++ b/testsuite/pytests/test_sp/test_sp_autapses_multapses.py @@ -19,11 +19,11 @@ # You should have received a copy of the GNU General Public License # along with NEST. If not, see . -import nest import unittest - from pprint import pprint +import nest + class TestStructuralPlasticityAutapses(unittest.TestCase): def test_autapses(self): diff --git a/testsuite/pytests/test_sp/test_sp_manager.py b/testsuite/pytests/test_sp/test_sp_manager.py index 1069640526..8d2b9c8e4e 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 869597180a..94c5d995fc 100644 --- a/testsuite/pytests/test_spatial/test_SynapseCollection_distance.py +++ b/testsuite/pytests/test_spatial/test_SynapseCollection_distance.py @@ -25,11 +25,10 @@ import math +import nest import numpy as np import pytest -import nest - @pytest.fixture(autouse=True) def _reset_kernel(): diff --git a/testsuite/pytests/test_spatial/test_basics.py b/testsuite/pytests/test_spatial/test_basics.py index 29f67179f0..c5ff42995b 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 28195b3a53..9ef1273526 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 111d68d725..85c43c79d0 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 f3627407ec..6c1c872624 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_distance.py b/testsuite/pytests/test_spatial/test_distance.py index 628496c59a..10024b891a 100644 --- a/testsuite/pytests/test_spatial/test_distance.py +++ b/testsuite/pytests/test_spatial/test_distance.py @@ -25,9 +25,8 @@ from math import sqrt -import pytest - import nest +import pytest @pytest.fixture(autouse=True) diff --git a/testsuite/pytests/test_spatial/test_dumping.py b/testsuite/pytests/test_spatial/test_dumping.py index 3002d8164e..44e2f7c0ac 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_parameter_apply.py b/testsuite/pytests/test_spatial/test_parameter_apply.py index 897c683155..d10c0b2dbf 100644 --- a/testsuite/pytests/test_spatial/test_parameter_apply.py +++ b/testsuite/pytests/test_spatial/test_parameter_apply.py @@ -23,11 +23,10 @@ Test ``Parameter`` ``apply`` method for spatial ``NodeCollection``. """ +import nest import numpy as np import pytest -import nest - @pytest.fixture(autouse=True) def reset(): diff --git a/testsuite/pytests/test_spatial/test_plotting.py b/testsuite/pytests/test_spatial/test_plotting.py index afbbec729d..a97fe14330 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 60db2a5178..ca43ec6d91 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 f96937a570..e95e443fbe 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_spatial/test_weight_delay.py b/testsuite/pytests/test_spatial/test_weight_delay.py index 70922da4db..3cd0a76180 100644 --- a/testsuite/pytests/test_spatial/test_weight_delay.py +++ b/testsuite/pytests/test_spatial/test_weight_delay.py @@ -29,11 +29,10 @@ weights are 1.0, 0.98, 0.96, 0.94, 0.92, 0.90, 0.88, 0.86, 0.84, 0.82. """ +import nest import numpy as np import pytest -import nest - def build_network(layer_type): """Build spatial network with specified layer type.""" 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_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 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) diff --git a/testsuite/pytests/test_split_simulation.py b/testsuite/pytests/test_split_simulation.py index 4e267578de..e2c592ee72 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 aa136217b4..ca4916b4b4 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 2a2402fa59..a4378b7819 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_pl_synapse_hom.py b/testsuite/pytests/test_stdp_pl_synapse_hom.py index b551056216..e334462b64 100644 --- a/testsuite/pytests/test_stdp_pl_synapse_hom.py +++ b/testsuite/pytests/test_stdp_pl_synapse_hom.py @@ -19,10 +19,11 @@ # You should have received a copy of the GNU General Public License # along with NEST. If not, see . -import nest -import pytest from math import exp + +import nest import numpy as np +import pytest DEBUG_PLOTS = False @@ -331,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 6b9906bbd5..edb063b4f5 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 import pytest @@ -364,6 +365,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_triplet_synapse.py b/testsuite/pytests/test_stdp_triplet_synapse.py index 489cc5cd5b..933742ba7c 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 1e728cee87..70776893c7 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 e5ac765b38..b4cb349504 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 d5d6a5529a..0900567cb7 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 03484cf6b3..45d794593a 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 8407743bc6..30e1981caf 100644 --- a/testsuite/pytests/test_urbanczik_synapse.py +++ b/testsuite/pytests/test_urbanczik_synapse.py @@ -25,9 +25,8 @@ import unittest -import numpy as np - import nest +import numpy as np HAVE_GSL = nest.ll_api.sli_func("statusdict/have_gsl ::") diff --git a/testsuite/pytests/test_visualization.py b/testsuite/pytests/test_visualization.py index eccbe67dc2..ee410ba20f 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 09e41eaddf..ad83bd5900 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 c814ad24eb..774d835106 100644 --- a/testsuite/pytests/test_weight_recorder.py +++ b/testsuite/pytests/test_weight_recorder.py @@ -25,9 +25,8 @@ import unittest -import numpy as np - import nest +import numpy as np HAVE_GSL = nest.ll_api.sli_func("statusdict/have_gsl ::") HAVE_OPENMP = nest.ll_api.sli_func("is_threaded") diff --git a/testsuite/pytests/test_weights_as_lists.py b/testsuite/pytests/test_weights_as_lists.py index f78b1b33d6..b76665f739 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"