diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 7dc973ba..7b2f9532 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -12,9 +12,9 @@ jobs: strategy: matrix: os: [ubuntu-latest] - python-version: ["3.8", "3.9", "3.10", "3.11"] + python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"] include: - - os: macos-latest + - os: macos-12 python-version: "3.10" steps: diff --git a/.install_neuron.sh b/.install_neuron.sh deleted file mode 100755 index c1756556..00000000 --- a/.install_neuron.sh +++ /dev/null @@ -1,37 +0,0 @@ -#!/bin/sh - -set -e - -SRC_DIR=$1 -INSTALL_DIR=$2 -PYTHON_BIN=$3 - -if [ ! -e ${INSTALL_DIR}/.install_finished ] -then - echo 'Neuron was not fully installed in previous build, installing ...' - mkdir -p ${SRC_DIR} - cd ${SRC_DIR} - echo "Downloading NEURON ..." - rm -rf nrn - git clone --depth 1 https://github.com/neuronsimulator/nrn.git >download.log 2>&1 - cd nrn - echo "Preparing NEURON ..." - ./build.sh >prepare.log 2>&1 - echo "Configuring NEURON ..." - PYTHON_BLD=${PYTHON_BIN} ./configure --prefix=${INSTALL_DIR} --without-x --with-nrnpython=${PYTHON_BIN} --disable-rx3d >configure.log 2>&1 - echo "Building NEURON ..." - make -j4 >make.log 2>&1 - echo "Installing NEURON ..." - make -j4 install >install.log 2>&1 - - export PATH="${INSTALL_DIR}/x86_64/bin":${PATH} - export PYTHONPATH="${INSTALL_DIR}/lib/python":${PYTHONPATH} - - echo "Testing NEURON import ...." - ${PYTHON_BIN} -c 'import neuron' >testimport.log 2>&1 - - touch -f ${INSTALL_DIR}/.install_finished - echo "NEURON successfully installed" -else - echo 'Neuron was successfully installed in previous build, not rebuilding' -fi diff --git a/.jenkins.sh b/.jenkins.sh deleted file mode 100755 index 3cb8c4b0..00000000 --- a/.jenkins.sh +++ /dev/null @@ -1,39 +0,0 @@ -#!/bin/bash - -set -e -set -x - -tox_args='--recreate -e py3-unit-functional-style' - -if [ "${os}" = "cscsviz" ] -then - . /opt/rh/python27/enable -elif [ "${os}" = "Ubuntu-18.04" ] -then - tox_args="${tox_args}" -fi - -which python -python --version - -cd $WORKSPACE - -######### -# Virtualenv -######### - -if [ ! -d "${WORKSPACE}/env" ]; then - virtualenv ${WORKSPACE}/env --no-site-packages -fi - -. ${WORKSPACE}/env/bin/activate -pip install pip --upgrade -pip install tox --upgrade - -##### -# Tests -##### - -cd ${WORKSPACE}/BluePyOpt - -tox ${tox_args} diff --git a/.readthedocs.yaml b/.readthedocs.yaml index 77ea544e..551d5134 100644 --- a/.readthedocs.yaml +++ b/.readthedocs.yaml @@ -14,3 +14,8 @@ python: - method: pip path: . - requirements: requirements_docs.txt + +build: + os: ubuntu-22.04 + tools: + python: "3.10" diff --git a/.zenodo.json b/.zenodo.json new file mode 100644 index 00000000..8768b81a --- /dev/null +++ b/.zenodo.json @@ -0,0 +1,48 @@ +{ + "title" : "BluePyOpt", + "license": "LGPL-3.0", + "upload_type": "software", + "description": "The Blue Brain Python Optimisation Library (BluePyOpt) is an extensible framework for data-driven model parameter optimisation that wraps and standardises several existing open-source tools. It simplifies the task of creating and sharing these optimisations, and the associated techniques and knowledge. This is achieved by abstracting the optimisation and evaluation tasks into various reusable and flexible discrete elements according to established best-practices. Further, BluePyOpt provides methods for setting up both small- and large-scale optimisations on a variety of platforms, ranging from laptops to Linux clusters and cloud-based compute infrastructures.", + "creators": [ + { + "affiliation": "Blue Brain Project, EPFL", + "name": "Van Geit, Werner", + "orcid": "0000-0002-2915-720X" + }, + { + "affiliation": "Blue Brain Project, EPFL", + "name": "Gevaert, Michael", + "orcid": "0000-0002-7547-3297" + }, + { + "affiliation": "Blue Brain Project, EPFL", + "name": "Damart, Tanguy", + "orcid": "0000-0003-2175-7304" + }, + { + "affiliation": "Blue Brain Project, EPFL", + "name": "Rössert, Christian", + "orcid": "0000-0002-4839-2424" + }, + { + "affiliation": "Blue Brain Project, EPFL", + "name": "Courcol, Jean-Denis", + "orcid": "0000-0002-9351-1461" + }, + { + "affiliation": "Blue Brain Project, EPFL", + "name": "Chindemi, Guiseppe", + "orcid": "0000-0001-6872-2366" + }, + { + "affiliation": "Blue Brain Project, EPFL", + "name": "Jaquier, Aurélien", + "orcid": "0000-0001-6202-6175" + }, + { + "affiliation": "Blue Brain Project, EPFL", + "name": "Muller, Eilif", + "orcid": "0000-0003-4309-8266" + } + ] +} diff --git a/README.rst b/README.rst index f4cb40a8..8c124b2f 100644 --- a/README.rst +++ b/README.rst @@ -3,59 +3,22 @@ BluePyOpt ========= -.. raw:: html - - - - - - - - - - - - - - - - - - - - - - - - - - -
Latest Release - - latest release - -
Documentation - - latest documentation - -
License - - license - -
Build Status - - Actions build status - -
Coverage - - coverage - -
Gitter - - -
++----------------+------------+ +| Latest Release | |pypi| | ++----------------+------------+ +| Documentation | |docs| | ++----------------+------------+ +| License | |license| | ++----------------+------------+ +| Build Status | |build| | ++----------------+------------+ +| Coverage | |coverage| | ++----------------+------------+ +| Gitter | |gitter| | ++----------------+------------+ +| Zenodo | |zenodo| | ++----------------+------------+ Introduction @@ -229,6 +192,33 @@ Copyright (c) 2016-2022 Blue Brain Project/EPFL The index.rst location is used for the docs README; index.rst also defined an end-marker, to skip content after the marker 'substitutions'. +.. |pypi| image:: https://img.shields.io/pypi/v/bluepyopt.svg + :target: https://pypi.org/project/bluepyopt/ + :alt: latest release + +.. |docs| image:: https://readthedocs.org/projects/bluepyopt/badge/?version=latest + :target: https://bluepyopt.readthedocs.io/ + :alt: latest documentation + +.. |license| image:: https://img.shields.io/pypi/l/bluepyopt.svg + :target: https://github.com/BlueBrain/bluepyopt/blob/master/LICENSE.txt + :alt: license + +.. |build| image:: https://github.com/BlueBrain/BluePyOpt/workflows/Build/badge.svg?branch=master + :target: https://github.com/BlueBrain/BluePyOpt/actions + :alt: actions build status + +.. |coverage| image:: https://codecov.io/github/BlueBrain/BluePyOpt/coverage.svg?branch=master + :target: https://codecov.io/gh/BlueBrain/bluepyopt + :alt: coverage + +.. |gitter| image:: https://badges.gitter.im/Join%20Chat.svg + :target: https://gitter.im/BlueBrain/blueptopt + :alt: Join the chat at https://gitter.im/BlueBrain/BluePyOpt + +.. |zenodo| image:: https://zenodo.org/badge/DOI/10.5281/zenodo.8135890.svg + :target: https://doi.org/10.5281/zenodo.8135890 + .. substitutions .. |banner| image:: docs/source/logo/BluePyOptBanner.png .. |landscape_example| image:: examples/simplecell/figures/landscape_example.png diff --git a/bluepyopt/deapext/tools/selIBEA.py b/bluepyopt/deapext/tools/selIBEA.py index 95c86fbc..84dda0ef 100644 --- a/bluepyopt/deapext/tools/selIBEA.py +++ b/bluepyopt/deapext/tools/selIBEA.py @@ -1,9 +1,5 @@ """IBEA selector""" -from __future__ import division - -from past.builtins import xrange # pylint: disable=W0622 - """ Copyright (c) 2016-2022, EPFL/Blue Brain Project @@ -77,7 +73,7 @@ def _calc_fitness_components(population, kappa): box_ranges[box_ranges == 0] = 1.0 components_matrix = numpy.zeros((pop_len, pop_len)) - for i in xrange(0, pop_len): + for i in range(0, pop_len): diff = population_matrix - population_matrix[i, :] components_matrix[i, :] = numpy.max( numpy.divide(diff, box_ranges), @@ -115,9 +111,9 @@ def _mating_selection(population, mu, tournament_n): """Returns the n_of_parents individuals with the best fitness""" parents = [] - for _ in xrange(mu): + for _ in range(mu): winner = _choice(population) - for _ in xrange(tournament_n - 1): + for _ in range(tournament_n - 1): individual = _choice(population) # Save winner is element with smallest fitness if individual.ibea_fitness < winner.ibea_fitness: diff --git a/bluepyopt/ephys/create_acc.py b/bluepyopt/ephys/create_acc.py index 4d176014..b0974d1e 100644 --- a/bluepyopt/ephys/create_acc.py +++ b/bluepyopt/ephys/create_acc.py @@ -1,4 +1,4 @@ -'''create JSON/ACC files for Arbor from a set of BluePyOpt.ephys parameters''' +"""create JSON/ACC files for Arbor from a set of BluePyOpt.ephys parameters""" # pylint: disable=R0914 @@ -14,14 +14,18 @@ from bluepyopt.ephys.acc import arbor from bluepyopt.ephys.morphologies import ArbFileMorphology -from bluepyopt.ephys.create_hoc import \ - Location, RangeExpr, PointExpr, \ - _get_template_params, format_float +from bluepyopt.ephys.create_hoc import ( + Location, + RangeExpr, + PointExpr, + _get_template_params, + format_float, +) logger = logging.getLogger(__name__) # Inhomogeneous expression for scaled parameter in Arbor -RangeIExpr = namedtuple('RangeIExpr', 'name, value, scale') +RangeIExpr = namedtuple("RangeIExpr", "name, value, scale") class ArbVar: @@ -39,25 +43,32 @@ def __init__(self, name, conv=None): self.conv = conv def __repr__(self): - return 'ArbVar(%s, %s)' % (self.name, self.conv) + return "ArbVar(%s, %s)" % (self.name, self.conv) class Nrn2ArbParamAdapter: """Converts a Neuron parameter to Arbor format (name and value)""" _mapping = dict( - v_init=ArbVar(name='membrane-potential'), - celsius=ArbVar(name='temperature-kelvin', - conv=lambda celsius: celsius + 273.15), - Ra=ArbVar(name='axial-resistivity'), - cm=ArbVar(name='membrane-capacitance', - conv=lambda cm: cm / 100.), # NEURON: uF/cm^2, Arbor: F/m^2 - **{species + loc[0]: - ArbVar(name='ion-%sternal-concentration \"%s\"' % (loc, species)) - for species in ['na', 'k', 'ca'] for loc in ['in', 'ex']}, - **{'e' + species: - ArbVar(name='ion-reversal-potential \"%s\"' % species) - for species in ['na', 'k', 'ca']} + v_init=ArbVar(name="membrane-potential"), + celsius=ArbVar( + name="temperature-kelvin", conv=lambda celsius: celsius + 273.15 + ), + Ra=ArbVar(name="axial-resistivity"), + cm=ArbVar( + name="membrane-capacitance", conv=lambda cm: cm / 100.0 + ), # NEURON: uF/cm^2, Arbor: F/m^2 + **{ + species + loc[0]: ArbVar( + name='ion-%sternal-concentration "%s"' % (loc, species) + ) + for species in ["na", "k", "ca"] + for loc in ["in", "ex"] + }, + **{ + "e" + species: ArbVar(name='ion-reversal-potential "%s"' % species) + for species in ["na", "k", "ca"] + }, ) @classmethod @@ -77,13 +88,19 @@ def _param_value(cls, param): param (): A Neuron parameter with a value in Neuron units """ - if param.name in cls._mapping and \ - cls._mapping[param.name].conv is not None: + if ( + param.name in cls._mapping + and cls._mapping[param.name].conv is not None + ): return format_float( - cls._mapping[param.name].conv(float(param.value))) + cls._mapping[param.name].conv(float(param.value)) + ) else: - return param.value if isinstance(param.value, str) else \ - format_float(param.value) + return ( + param.value + if isinstance(param.value, str) + else format_float(param.value) + ) @classmethod def _conv_param(cls, param, name): @@ -95,20 +112,26 @@ def _conv_param(cls, param, name): """ if isinstance(param, Location): - return Location(name=cls._param_name(name), - value=cls._param_value(param)) + return Location( + name=cls._param_name(name), value=cls._param_value(param) + ) elif isinstance(param, RangeExpr): - return RangeExpr(location=param.location, - name=cls._param_name(name), - value=cls._param_value(param), - value_scaler=param.value_scaler) + return RangeExpr( + location=param.location, + name=cls._param_name(name), + value=cls._param_value(param), + value_scaler=param.value_scaler, + ) elif isinstance(param, PointExpr): - return PointExpr(name=cls._param_name(name), - point_loc=param.point_loc, - value=cls._param_value(param)) + return PointExpr( + name=cls._param_name(name), + point_loc=param.point_loc, + value=cls._param_value(param), + ) else: raise CreateAccException( - 'Unsupported parameter expression type %s.' % type(param)) + "Unsupported parameter expression type %s." % type(param) + ) @classmethod def format(cls, param, mechs): @@ -123,12 +146,16 @@ def format(cls, param, mechs): parameter in Arbor format """ if not isinstance(param, PointExpr): - mech_matches = [i for i, mech in enumerate(mechs) - if param.name.endswith("_" + mech)] + mech_matches = [ + i + for i, mech in enumerate(mechs) + if param.name.endswith("_" + mech) + ] else: param_pprocesses = [loc.pprocess_mech for loc in param.point_loc] - mech_matches = [i for i, mech in enumerate(mechs) - if mech in param_pprocesses] + mech_matches = [ + i for i, mech in enumerate(mechs) if mech in param_pprocesses + ] if len(mech_matches) == 0: return None, cls._conv_param(param, name=param.name) @@ -136,15 +163,17 @@ def format(cls, param, mechs): elif len(mech_matches) == 1: mech = mechs[mech_matches[0]] if not isinstance(param, PointExpr): - name = param.name[:-(len(mech) + 1)] + name = param.name[: -(len(mech) + 1)] else: name = param.name return mech, cls._conv_param(param, name=name) else: - raise CreateAccException("Parameter name %s matches" % param.name + - " multiple mechanisms %s" % - [repr(mechs[i]) for i in mech_matches]) + raise CreateAccException( + "Parameter name %s matches" % param.name + + " multiple mechanisms %s" + % [repr(mechs[i]) for i in mech_matches] + ) class Nrn2ArbMechGrouper: @@ -159,14 +188,21 @@ def _is_global_property(loc, param): param (): A parameter in Arbor format (name and units) """ - return loc == ArbFileMorphology.region_labels['all'] and ( - param.name in ['membrane-potential', - 'temperature-kelvin', - 'axial-resistivity', - 'membrane-capacitance'] or - param.name.split(' ')[0] in ['ion-internal-concentration', - 'ion-external-concentration', - 'ion-reversal-potential']) + return loc == ArbFileMorphology.region_labels["all"] and ( + param.name + in [ + "membrane-potential", + "temperature-kelvin", + "axial-resistivity", + "membrane-capacitance", + ] + or param.name.split(" ")[0] + in [ + "ion-internal-concentration", + "ion-external-concentration", + "ion-reversal-potential", + ] + ) @classmethod def _separate_global_properties(cls, loc, mechs): @@ -187,7 +223,6 @@ def _separate_global_properties(cls, loc, mechs): global_properties = [] for mech, params in mechs.items(): - if mech is None: local_properties = [] for param in params: @@ -213,8 +248,9 @@ def _format_params_and_group_by_mech(params, channels): Mapping of Arbor mechanism name to list of parameters in Arbor format """ - mech_params = [Nrn2ArbParamAdapter.format( - param, channels) for param in params] + mech_params = [ + Nrn2ArbParamAdapter.format(param, channels) for param in params + ] mechs = {mech: [] for mech, _ in mech_params} for mech in channels: if mech not in mechs: @@ -236,9 +272,11 @@ def process_global(cls, params): (mechanism name is None for non-mechanism parameters). """ return cls._format_params_and_group_by_mech( - [Location(name=name, value=value) - for name, value in params.items()], - [] # no default mechanisms + [ + Location(name=name, value=value) + for name, value in params.items() + ], + [], # no default mechanisms ) @classmethod @@ -261,16 +299,19 @@ def process_local(cls, params, channels): global_properties = dict() for loc, loc_params in params: mechs = cls._format_params_and_group_by_mech( - loc_params, channels[loc]) + loc_params, channels[loc] + ) # move Arbor global properties to global_params mechs, global_props = cls._separate_global_properties(loc, mechs) if global_props.keys() != {None}: raise CreateAccException( - 'Support for Arbor default mechanisms not implemented.') + "Support for Arbor default mechanisms not implemented." + ) # iterate over global_props items if above exception triggers - global_properties[None] = \ + global_properties[None] = ( global_properties.get(None, []) + global_props[None] + ) local_mechs[loc] = mechs return local_mechs, global_properties @@ -289,8 +330,11 @@ def _arb_filter_point_proc_locs(pprocess_mechs): for mech, point_exprs in mechs.items(): result[loc][mech.name] = dict( mech=mech.suffix, - params=[Location(point_expr.name, point_expr.value) - for point_expr in point_exprs]) + params=[ + Location(point_expr.name, point_expr.value) + for point_expr in point_exprs + ], + ) return result @@ -300,18 +344,21 @@ def _arb_append_scaled_mechs(mechs, scaled_mechs): for mech, scaled_params in scaled_mechs.items(): if mech is None and len(scaled_params) > 0: raise CreateAccException( - 'Non-mechanism parameters cannot have inhomogeneous' - ' expressions in Arbor %s' % scaled_params) - mechs[mech] = mechs.get(mech, []) + \ - [RangeIExpr( + "Non-mechanism parameters cannot have inhomogeneous" + " expressions in Arbor %s" % scaled_params + ) + mechs[mech] = mechs.get(mech, []) + [ + RangeIExpr( name=p.name, value=p.value, - scale=p.value_scaler.acc_scale_iexpr(p.value)) - for p in scaled_params] + scale=p.value_scaler.acc_scale_iexpr(p.value), + ) + for p in scaled_params + ] # An mechanism's NMODL GLOBAL and RANGE variables in Arbor -MechMetaData = namedtuple('MechMetaData', 'globals, ranges') +MechMetaData = namedtuple("MechMetaData", "globals, ranges") class ArbNmodlMechFormatter: @@ -338,37 +385,42 @@ def _load_catalogue_meta(cat_dir): """ # used to generate arbor_mechanisms.json on NMODL from arbor/mechanisms - nmodl_pattern = '^\s*%s\s+((?:\w+\,\s*)*?\w+)\s*?$' # NOQA - suffix_pattern = nmodl_pattern % 'SUFFIX' - globals_pattern = nmodl_pattern % 'GLOBAL' - ranges_pattern = nmodl_pattern % 'RANGE' + nmodl_pattern = r"^\s*%s\s+((?:\w+\,\s*)*?\w+)\s*?$" # NOQA + suffix_pattern = nmodl_pattern % "SUFFIX" + globals_pattern = nmodl_pattern % "GLOBAL" + ranges_pattern = nmodl_pattern % "RANGE" def process_nmodl(nmodl_str): """Extract global and range params from Arbor-conforming NMODL""" try: - nrn = re.search(r'NEURON\s+{([^}]+)}', nmodl_str, - flags=re.MULTILINE).group(1) - suffix_ = re.search(suffix_pattern, nrn, - flags=re.MULTILINE) + nrn = re.search( + r"NEURON\s+{([^}]+)}", nmodl_str, flags=re.MULTILINE + ).group(1) + suffix_ = re.search(suffix_pattern, nrn, flags=re.MULTILINE) suffix_ = suffix_ if suffix_ is None else suffix_.group(1) - globals_ = re.search(globals_pattern, nrn, - flags=re.MULTILINE) - globals_ = globals_ if globals_ is None \ - else re.findall(r'\w+', globals_.group(1)) - ranges_ = re.search(ranges_pattern, nrn, - flags=re.MULTILINE) - ranges_ = ranges_ if ranges_ is None \ - else re.findall(r'\w+', ranges_.group(1)) + globals_ = re.search(globals_pattern, nrn, flags=re.MULTILINE) + globals_ = ( + globals_ + if globals_ is None + else re.findall(r"\w+", globals_.group(1)) + ) + ranges_ = re.search(ranges_pattern, nrn, flags=re.MULTILINE) + ranges_ = ( + ranges_ + if ranges_ is None + else re.findall(r"\w+", ranges_.group(1)) + ) except Exception as e: raise CreateAccException( - 'NMODL-inspection for %s failed.' % nmodl_file) from e + "NMODL-inspection for %s failed." % nmodl_file + ) from e # skipping suffix_ return MechMetaData(globals=globals_, ranges=ranges_) mechs = dict() cat_dir = pathlib.Path(cat_dir) - for nmodl_file in cat_dir.glob('*.mod'): + for nmodl_file in cat_dir.glob("*.mod"): with open(cat_dir.joinpath(nmodl_file)) as f: mechs[nmodl_file.stem] = process_nmodl(f.read()) @@ -393,18 +445,23 @@ def _load_mech_catalogue_meta(cls, ext_catalogues): if ext_catalogues is not None: for cat, cat_nmodl in ext_catalogues.items(): arb_cats[cat] = cls._load_catalogue_meta( - pathlib.Path(cat_nmodl).resolve()) + pathlib.Path(cat_nmodl).resolve() + ) - builtin_catalogues = pathlib.Path(__file__).parent.joinpath( - 'static/arbor_mechanisms.json').resolve() + builtin_catalogues = ( + pathlib.Path(__file__) + .parent.joinpath("static/arbor_mechanisms.json") + .resolve() + ) with open(builtin_catalogues) as f: builtin_arb_cats = json.load(f) - for cat in ['BBP', 'default', 'allen']: + for cat in ["BBP", "default", "allen"]: if cat not in arb_cats: arb_cats[cat] = { mech: MechMetaData(**meta) - for mech, meta in builtin_arb_cats[cat].items()} + for mech, meta in builtin_arb_cats[cat].items() + } return arb_cats @@ -415,7 +472,7 @@ def _mech_name(name): Args: name (): A Neuron mechanism name """ - if name in ['Exp2Syn', 'ExpSyn']: + if name in ["Exp2Syn", "ExpSyn"]: return name.lower() else: return name @@ -441,51 +498,64 @@ def _translate_mech(cls, mech_name, mech_params, arb_cats): for cat in arb_cats: # in order of precedence if arb_mech_name in arb_cats[cat]: arb_mech = arb_cats[cat][arb_mech_name] - mech_name = cat + '::' + arb_mech_name + mech_name = cat + "::" + arb_mech_name break if arb_mech is None: # not Arbor built-in mech, no qualifier added if mech_name is not None: logger.warn( - 'create_acc: Could not find Arbor mech for %s (%s).' - % (mech_name, mech_params)) + "create_acc: Could not find Arbor mech for %s (%s)." + % (mech_name, mech_params) + ) return (mech_name, mech_params) else: if arb_mech.globals is None: # only Arbor range params for param in mech_params: if param.name not in arb_mech.ranges: raise CreateAccException( - '%s not a GLOBAL or RANGE parameter of %s' % - (param.name, mech_name)) + "%s not a GLOBAL or RANGE parameter of %s" + % (param.name, mech_name) + ) return (mech_name, mech_params) else: for param in mech_params: - if param.name not in arb_mech.globals and \ - param.name not in arb_mech.ranges: + if ( + param.name not in arb_mech.globals + and param.name not in arb_mech.ranges + ): raise CreateAccException( - '%s not a GLOBAL or RANGE parameter of %s' % - (param.name, mech_name)) + "%s not a GLOBAL or RANGE parameter of %s" + % (param.name, mech_name) + ) mech_name_suffix = [] remaining_mech_params = [] for mech_param in mech_params: if mech_param.name in arb_mech.globals: - mech_name_suffix.append(mech_param.name + '=' + - mech_param.value) + mech_name_suffix.append( + mech_param.name + "=" + mech_param.value + ) if isinstance(mech_param, RangeIExpr): remaining_mech_params.append( - RangeIExpr(name=mech_param.name, - value=None, - scale=mech_param.scale)) + RangeIExpr( + name=mech_param.name, + value=None, + scale=mech_param.scale, + ) + ) else: remaining_mech_params.append(mech_param) if len(mech_name_suffix) > 0: - mech_name += '/' + ','.join(mech_name_suffix) + mech_name += "/" + ",".join(mech_name_suffix) return (mech_name, remaining_mech_params) def translate_density(self, mechs): """Translate all density mechanisms in a specific region""" - return dict([self._translate_mech(mech, params, self.cats) - for mech, params in mechs.items()]) + return dict( + [ + self._translate_mech(mech, params, self.cats) + for mech, params in mechs.items() + ] + ) def translate_points(self, mechs): """Translate all point mechanisms for a specific locset""" @@ -493,9 +563,9 @@ def translate_points(self, mechs): for synapse_name, mech_desc in mechs.items(): mech, params = self._translate_mech( - mech_desc['mech'], mech_desc['params'], self.cats) - result[synapse_name] = dict(mech=mech, - params=params) + mech_desc["mech"], mech_desc["params"], self.cats + ) + result[synapse_name] = dict(mech=mech, params=params) return result @@ -527,13 +597,16 @@ def _arb_populate_label_dict(local_mechs, local_scaled_mechs, pprocess_mechs): acc_labels = ChainMap(local_mechs, local_scaled_mechs, pprocess_mechs) for acc_label in acc_labels: - if acc_label.name in label_dict and \ - acc_label != label_dict[acc_label.name]: + if ( + acc_label.name in label_dict + and acc_label != label_dict[acc_label.name] + ): raise CreateAccException( - 'Label %s already exists in' % acc_label.name + - ' label_dict with different s-expression: ' - ' %s != %s.' % (label_dict[acc_label.name].loc, - acc_label.loc)) + "Label %s already exists in" + % acc_label.name + + " label_dict with different s-expression: " + " %s != %s." % (label_dict[acc_label.name].loc, acc_label.loc) + ) elif acc_label.name not in label_dict: label_dict[acc_label.name] = acc_label @@ -542,10 +615,11 @@ def _arb_populate_label_dict(local_mechs, local_scaled_mechs, pprocess_mechs): def _read_templates(template_dir, template_filename): """Expand Jinja2 template filepath with glob and - return dict of target filename -> parsed template""" + return dict of target filename -> parsed template""" if template_dir is None: - template_dir = \ - pathlib.Path(__file__).parent.joinpath('templates').resolve() + template_dir = ( + pathlib.Path(__file__).parent.joinpath("templates").resolve() + ) template_paths = pathlib.Path(template_dir).glob(template_filename) @@ -554,17 +628,18 @@ def _read_templates(template_dir, template_filename): with open(template_path) as template_file: template = template_file.read() name = template_path.name - if name.endswith('.jinja2'): + if name.endswith(".jinja2"): name = name[:-7] - if name.endswith('_template'): + if name.endswith("_template"): name = name[:-9] - if '_' in name: - name = '.'.join(name.rsplit('_', 1)) + if "_" in name: + name = ".".join(name.rsplit("_", 1)) templates[name] = jinja2.Template(template) if templates == {}: raise FileNotFoundError( - f'No templates found for JSON/ACC-export in {template_dir}') + f"No templates found for JSON/ACC-export in {template_dir}" + ) return templates @@ -574,20 +649,22 @@ def _arb_loc_desc(location, param_or_mech): return location.acc_label() -def create_acc(mechs, - parameters, - morphology=None, - morphology_dir=None, - ext_catalogues=None, - ignored_globals=(), - replace_axon=None, - create_mod_morph=False, - template_name='CCell', - template_filename='acc/*_template.jinja2', - disable_banner=None, - template_dir=None, - custom_jinja_params=None): - '''return a dict with strings containing the rendered JSON/ACC templates +def create_acc( + mechs, + parameters, + morphology=None, + morphology_dir=None, + ext_catalogues=None, + ignored_globals=(), + replace_axon=None, + create_mod_morph=False, + template_name="CCell", + template_filename="acc/*_template.jinja2", + disable_banner=None, + template_dir=None, + custom_jinja_params=None, +): + """return a dict with strings containing the rendered JSON/ACC templates Args: mechs (): All the mechs for the decor template @@ -604,39 +681,45 @@ def create_acc(mechs, template_dir (str): dir name of the jinja2 templates custom_jinja_params (dict): dict of additional jinja2 params in case of a custom template - ''' + """ if custom_jinja_params is None: custom_jinja_params = {} - if pathlib.Path(morphology).suffix.lower() not in ['.swc', '.asc']: - raise CreateAccException("Morphology file %s not supported in Arbor " - " (only supported types are .swc and .asc)." - % morphology) + if pathlib.Path(morphology).suffix.lower() not in [".swc", ".asc"]: + raise CreateAccException( + "Morphology file %s not supported in Arbor " + " (only supported types are .swc and .asc)." % morphology + ) if replace_axon is not None: - if not hasattr(arbor.segment_tree, 'tag_roots'): - raise NotImplementedError("Need a newer version of Arbor" - " for axon replacement.") - logger.debug("Obtain axon replacement by applying " - "ArbFileMorphology.replace_axon after loading " - "morphology in Arbor.") - replace_axon_path = \ - pathlib.Path(morphology).stem + '_axon_replacement.acc' + if not hasattr(arbor.segment_tree, "tag_roots"): + raise NotImplementedError( + "Need a newer version of Arbor" " for axon replacement." + ) + logger.debug( + "Obtain axon replacement by applying " + "ArbFileMorphology.replace_axon after loading " + "morphology in Arbor." + ) + replace_axon_path = ( + pathlib.Path(morphology).stem + "_axon_replacement.acc" + ) replace_axon_acc = io.StringIO() arbor.write_component(replace_axon, replace_axon_acc) replace_axon_acc.seek(0) if create_mod_morph: - modified_morphology_path = \ - pathlib.Path(morphology).stem + '_modified.acc' + modified_morphology_path = ( + pathlib.Path(morphology).stem + "_modified.acc" + ) modified_morpho = ArbFileMorphology.load( pathlib.Path(morphology_dir).joinpath(morphology), - replace_axon_acc) + replace_axon_acc, + ) replace_axon_acc.seek(0) modified_morphology_acc = io.StringIO() - arbor.write_component( - modified_morpho, modified_morphology_acc) + arbor.write_component(modified_morpho, modified_morphology_acc) modified_morphology_acc.seek(0) modified_morphology_acc = modified_morphology_acc.read() else: @@ -652,47 +735,49 @@ def create_acc(mechs, default_location_order = list(ArbFileMorphology.region_labels.values()) - template_params = _get_template_params(mechs, - parameters, - ignored_globals, - disable_banner, - default_location_order, - _arb_loc_desc) + template_params = _get_template_params( + mechs, + parameters, + ignored_globals, + disable_banner, + default_location_order, + _arb_loc_desc, + ) filenames = { - name: template_name + (name if name.startswith('.') else "_" + name) - for name in templates.keys()} + name: template_name + (name if name.startswith(".") else "_" + name) + for name in templates.keys() + } # postprocess template parameters for Arbor - channels = template_params['channels'] - point_channels = template_params['point_channels'] - banner = template_params['banner'] + channels = template_params["channels"] + point_channels = template_params["point_channels"] + banner = template_params["banner"] # global_mechs refer to default density mechs/params in Arbor # [mech -> param] (params under mech == None) - global_mechs = \ - Nrn2ArbMechGrouper.process_global( - template_params['global_params']) + global_mechs = Nrn2ArbMechGrouper.process_global( + template_params["global_params"] + ) # local_mechs refer to locally painted density mechs/params in Arbor # [label -> mech -> param.name/.value] (params under mech == None) - local_mechs, additional_global_mechs = \ - Nrn2ArbMechGrouper.process_local( - template_params['section_params'], channels) + local_mechs, additional_global_mechs = Nrn2ArbMechGrouper.process_local( + template_params["section_params"], channels + ) for mech, params in additional_global_mechs.items(): - global_mechs[mech] = \ - global_mechs.get(mech, []) + params + global_mechs[mech] = global_mechs.get(mech, []) + params # scaled_mechs refer to iexpr params of scaled density mechs in Arbor # [label -> mech -> param.location/.name/.value/.value_scaler] range_params = {loc: [] for loc in default_location_order} - for param in template_params['range_params']: + for param in template_params["range_params"]: range_params[param.location].append(param) range_params = list(range_params.items()) - local_scaled_mechs, global_scaled_mechs = \ - Nrn2ArbMechGrouper.process_local( - range_params, channels) + local_scaled_mechs, global_scaled_mechs = Nrn2ArbMechGrouper.process_local( + range_params, channels + ) # join each mech's constant params with inhomogeneous ones on mechanisms _arb_append_scaled_mechs(global_mechs, global_scaled_mechs) @@ -701,12 +786,13 @@ def create_acc(mechs, # pprocess_mechs refer to locally placed mechs/params in Arbor # [label -> mech -> param.name/.value] - pprocess_mechs, global_pprocess_mechs = \ - Nrn2ArbMechGrouper.process_local( - template_params['pprocess_params'], point_channels) + pprocess_mechs, global_pprocess_mechs = Nrn2ArbMechGrouper.process_local( + template_params["pprocess_params"], point_channels + ) if any(len(params) > 0 for params in global_pprocess_mechs.values()): - raise CreateAccException('Point process mechanisms cannot be' - ' placed globally in Arbor.') + raise CreateAccException( + "Point process mechanisms cannot be" " placed globally in Arbor." + ) # Evaluate synapse locations # (no new labels introduced, but locations explicitly defined) @@ -720,36 +806,43 @@ def create_acc(mechs, global_mechs = nmodl_formatter.translate_density(global_mechs) local_mechs = { loc: nmodl_formatter.translate_density(mechs) - for loc, mechs in local_mechs.items()} + for loc, mechs in local_mechs.items() + } pprocess_mechs = { loc: nmodl_formatter.translate_points(mechs) - for loc, mechs in pprocess_mechs.items()} + for loc, mechs in pprocess_mechs.items() + } # get iexpr parameters of scaled density mechs global_scaled_mechs = _arb_project_scaled_mechs(global_mechs) - local_scaled_mechs = {loc: _arb_project_scaled_mechs(mechs) - for loc, mechs in local_mechs.items()} + local_scaled_mechs = { + loc: _arb_project_scaled_mechs(mechs) + for loc, mechs in local_mechs.items() + } # populate label dict - label_dict = _arb_populate_label_dict(local_mechs, - local_scaled_mechs, - pprocess_mechs) - - ret = {filenames[name]: - template.render(template_name=template_name, - banner=banner, - morphology=morphology, - replace_axon=replace_axon_path, - modified_morphology=modified_morphology_path, - filenames=filenames, - label_dict=label_dict, - global_mechs=global_mechs, - global_scaled_mechs=global_scaled_mechs, - local_mechs=local_mechs, - local_scaled_mechs=local_scaled_mechs, - pprocess_mechs=pprocess_mechs, - **custom_jinja_params) - for name, template in templates.items()} + label_dict = _arb_populate_label_dict( + local_mechs, local_scaled_mechs, pprocess_mechs + ) + + ret = { + filenames[name]: template.render( + template_name=template_name, + banner=banner, + morphology=morphology, + replace_axon=replace_axon_path, + modified_morphology=modified_morphology_path, + filenames=filenames, + label_dict=label_dict, + global_mechs=global_mechs, + global_scaled_mechs=global_scaled_mechs, + local_mechs=local_mechs, + local_scaled_mechs=local_scaled_mechs, + pprocess_mechs=pprocess_mechs, + **custom_jinja_params, + ) + for name, template in templates.items() + } if replace_axon is not None: ret[replace_axon_path] = replace_axon_acc @@ -759,12 +852,16 @@ def create_acc(mechs, return ret -def write_acc(output_dir, cell, parameters, - template_filename='acc/*_template.jinja2', - ext_catalogues=None, - create_mod_morph=False, - sim=None): - '''Output mixed JSON/ACC format for Arbor cable cell to files +def write_acc( + output_dir, + cell, + parameters, + template_filename="acc/*_template.jinja2", + ext_catalogues=None, + create_mod_morph=False, + sim=None, +): + """Output mixed JSON/ACC format for Arbor cable cell to files Args: output_dir (str): Output directory. If not exists, will be created @@ -777,18 +874,24 @@ def write_acc(output_dir, cell, parameters, create_mod_morph (str): Output ACC with axon replacement sim (): Neuron simulator instance (only used used with axon replacement if morphology has not yet been instantiated) - ''' - output = cell.create_acc(parameters, template=template_filename, - ext_catalogues=ext_catalogues, - create_mod_morph=create_mod_morph, - sim=sim) - - cell_json = [comp_rendered - for comp, comp_rendered in output.items() - if pathlib.Path(comp).suffix == '.json'] + """ + output = cell.create_acc( + parameters, + template=template_filename, + ext_catalogues=ext_catalogues, + create_mod_morph=create_mod_morph, + sim=sim, + ) + + cell_json = [ + comp_rendered + for comp, comp_rendered in output.items() + if pathlib.Path(comp).suffix == ".json" + ] if len(cell_json) != 1: raise CreateAccException( - 'JSON file from create_acc is non-unique: %s' % cell_json) + "JSON file from create_acc is non-unique: %s" % cell_json + ) cell_json = json.loads(cell_json[0]) @@ -799,10 +902,10 @@ def write_acc(output_dir, cell, parameters, comp_filename = output_dir.joinpath(comp) if comp_filename.exists(): raise CreateAccException("%s already exists!" % comp_filename) - with open(output_dir.joinpath(comp), 'w') as f: + with open(output_dir.joinpath(comp), "w") as f: f.write(comp_rendered) - morpho_filename = output_dir.joinpath(cell_json['morphology']['original']) + morpho_filename = output_dir.joinpath(cell_json["morphology"]["original"]) if morpho_filename.exists(): raise CreateAccException("%s already exists!" % morpho_filename) shutil.copy2(cell.morphology.morphology_path, morpho_filename) @@ -810,12 +913,12 @@ def write_acc(output_dir, cell, parameters, # Read the mixed JSON/ACC-output, to be moved to Arbor in future release def read_acc(cell_json_filename): - '''Return constituents to build an Arbor cable cell from create_acc-export + """Return constituents to build an Arbor cable cell from create_acc-export Args: cell_json_filename (str): The path to the JSON file containing meta-information on morphology, label-dict and decor of exported cell - ''' + """ with open(cell_json_filename) as cell_json_file: cell_json = json.load(cell_json_file) @@ -823,22 +926,24 @@ def read_acc(cell_json_filename): cell_json_dir = pathlib.Path(cell_json_filename).parent morpho_filename = cell_json_dir.joinpath( - cell_json['morphology']['original']) - replace_axon = cell_json['morphology'].get('replace_axon', None) + cell_json["morphology"]["original"] + ) + replace_axon = cell_json["morphology"].get("replace_axon", None) if replace_axon is not None: replace_axon = cell_json_dir.joinpath(replace_axon) morpho = ArbFileMorphology.load(morpho_filename, replace_axon) decor = arbor.load_component( - cell_json_dir.joinpath(cell_json['decor'])).component + cell_json_dir.joinpath(cell_json["decor"]) + ).component labels = arbor.load_component( - cell_json_dir.joinpath(cell_json['label_dict'])).component + cell_json_dir.joinpath(cell_json["label_dict"]) + ).component return cell_json, morpho, decor, labels class CreateAccException(Exception): - """Exceptions generated by create_acc module""" def __init__(self, message): diff --git a/bluepyopt/ephys/create_hoc.py b/bluepyopt/ephys/create_hoc.py index a287571b..b1a340c1 100644 --- a/bluepyopt/ephys/create_hoc.py +++ b/bluepyopt/ephys/create_hoc.py @@ -105,8 +105,18 @@ def range_exprs_to_hoc(range_params): for param in range_params: value = param.value_scaler.inst_distribution value = re.sub(r'math\.', '', value) + value = re.sub(r'\&', '&&', value) value = re.sub('{distance}', FLOAT_FORMAT, value) value = re.sub('{value}', format_float(param.value), value) + if hasattr(param.value_scaler, "step_begin"): + value = re.sub( + '{step_begin}', + format_float(param.value_scaler.step_begin), + value + ) + value = re.sub( + '{step_end}', format_float(param.value_scaler.step_end), value + ) ret.append(Range(param.location, param.name, value)) return ret diff --git a/bluepyopt/ephys/efeatures.py b/bluepyopt/ephys/efeatures.py index ab8c4fe1..edfa56cf 100644 --- a/bluepyopt/ephys/efeatures.py +++ b/bluepyopt/ephys/efeatures.py @@ -429,6 +429,11 @@ def calculate_feature( peak_times = self._get_peak_times( responses, raise_warnings=raise_warnings ) + if peak_times is None: + if return_waveforms: + return None, None + else: + return None if len(peak_times) > 1 and self.skip_first_spike: peak_times = peak_times[1:] @@ -439,7 +444,10 @@ def calculate_feature( if responses[self.recording_names[""]] is not None: response = responses[self.recording_names[""]] else: - return None + if return_waveforms: + return None, None + else: + return None if np.std(np.diff(response["time"])) > 0.001 * np.mean( np.diff(response["time"]) diff --git a/bluepyopt/ephys/objectives.py b/bluepyopt/ephys/objectives.py index 7df442a5..e5b12848 100644 --- a/bluepyopt/ephys/objectives.py +++ b/bluepyopt/ephys/objectives.py @@ -87,7 +87,7 @@ def __str__(self): return '( %s )' % self.features[0] -class SingletonWeightObjective(EFeatureObjective): +class SingletonWeightObjective(SingletonObjective): """Single EPhys feature""" @@ -99,7 +99,7 @@ def __init__(self, name, feature, weight): weight (float): weight to scale to the efeature with """ - super(SingletonWeightObjective, self).__init__(name, [feature]) + super(SingletonWeightObjective, self).__init__(name, feature) self.weight = weight def calculate_score(self, responses): diff --git a/bluepyopt/ephys/parameterscalers/parameterscalers.py b/bluepyopt/ephys/parameterscalers/parameterscalers.py index 47f5189a..342cb61f 100644 --- a/bluepyopt/ephys/parameterscalers/parameterscalers.py +++ b/bluepyopt/ephys/parameterscalers/parameterscalers.py @@ -161,9 +161,8 @@ def inst_distribution(self): # Use this special formatting to bypass missing keys return string.Formatter().vformat(self.distribution, (), dist_dict) - def eval_dist(self, values, distance): - """Create the final dist string""" - + def scale_dict(self, values, distance): + """Create scale dictionary""" scale_dict = {} if isinstance(values, dict): for k, v in values.items(): @@ -172,6 +171,12 @@ def eval_dist(self, values, distance): scale_dict["value"] = format_float(values) scale_dict["distance"] = format_float(distance) + return scale_dict + + def eval_dist(self, values, distance): + """Create the final dist string""" + scale_dict = self.scale_dict(values, distance) + return self.inst_distribution.format(**scale_dict) def scale(self, values, segment, sim=None): @@ -261,3 +266,51 @@ def acc_scale_iexpr(self, value, constant_formatter=format_float): ArbFileMorphology.region_labels['somatic'].ref ) return generate_acc_scale_iexpr(iexpr, variables, constant_formatter) + + +class NrnSegmentSomaDistanceStepScaler(NrnSegmentSomaDistanceScaler, + ParameterScaler, DictMixin): + + """Scaler based on distance from soma with a step function""" + SERIALIZED_FIELDS = ('name', 'comment', 'distribution', ) + + def __init__( + self, + name=None, + distribution=None, + comment='', + dist_param_names=None, + soma_ref_location=0.5, + step_begin=None, + step_end=None): + """Constructor + Args: + name (str): name of this object + distribution (str): distribution of parameter dependent on distance + from soma. string can contain `distance` and/or `value` as + placeholders for the distance to the soma and parameter value + respectively. It can also contain step_begin and step_end. + dist_param_names (list): list of names of parameters that + parametrise the distribution. These names will become + attributes of this object. + The distribution string should contain these names, and they + will be replaced by values of the corresponding attributes + soma_ref_location (float): location along the soma used as origin + from which to compute the distances. Expressed as a fraction + (between 0.0 and 1.0). + step_begin (float): distance at which the step begins + step_end (float): distance at which the step ends + """ + + super(NrnSegmentSomaDistanceStepScaler, self).__init__( + name, distribution, comment, dist_param_names, + soma_ref_location=soma_ref_location) + self.step_begin = step_begin + self.step_end = step_end + + def scale_dict(self, values, distance): + scale_dict = super().scale_dict(values, distance) + scale_dict["step_begin"] = self.step_begin + scale_dict["step_end"] = self.step_end + + return scale_dict diff --git a/bluepyopt/ephys/serializer.py b/bluepyopt/ephys/serializer.py index 77b64e87..3265271b 100644 --- a/bluepyopt/ephys/serializer.py +++ b/bluepyopt/ephys/serializer.py @@ -1,8 +1,4 @@ '''Mixin class to make dictionaries''' -from __future__ import unicode_literals -from __future__ import print_function -from __future__ import division -from __future__ import absolute_import # Disabling lines below, generate error when loading ephys.examples # from future import standard_library diff --git a/bluepyopt/ephys/simulators.py b/bluepyopt/ephys/simulators.py index 71790bc8..de546633 100644 --- a/bluepyopt/ephys/simulators.py +++ b/bluepyopt/ephys/simulators.py @@ -2,26 +2,30 @@ # pylint: disable=W0511 -import os -import logging -import imp import ctypes +import importlib.util +import logging +import os +import pathlib import platform import warnings -import pathlib from bluepyopt.ephys.acc import arbor - logger = logging.getLogger(__name__) class NrnSimulator(object): - """Neuron simulator""" - def __init__(self, dt=None, cvode_active=True, cvode_minstep=None, - random123_globalindex=None, mechanisms_directory=None): + def __init__( + self, + dt=None, + cvode_active=True, + cvode_minstep=None, + random123_globalindex=None, + mechanisms_directory=None, + ): """Constructor Args: @@ -41,7 +45,7 @@ def __init__(self, dt=None, cvode_active=True, cvode_minstep=None, # hoc.so does not exist on NEURON Windows or MacOS # although \\hoc.pyd can work here, it gives an error for # nrn_nobanner_ line - self.disable_banner = platform.system() not in ['Windows', 'Darwin'] + self.disable_banner = platform.system() not in ["Windows", "Darwin"] self.banner_disabled = False self.mechanisms_directory = mechanisms_directory @@ -77,18 +81,21 @@ def cvode_minstep(self, value): def _nrn_disable_banner(): """Disable Neuron banner""" - nrnpy_path = os.path.join(imp.find_module('neuron')[1]) - import glob - hoc_so_list = \ - glob.glob(os.path.join(nrnpy_path, 'hoc*.so')) + nrnpy_path = pathlib.Path( + importlib.util.find_spec("neuron").origin + ).parent + + hoc_so_list = list(nrnpy_path.glob("hoc*.so")) if len(hoc_so_list) != 1: - warnings.warn('Unable to find Neuron hoc shared library in %s, ' - 'not disabling banner' % nrnpy_path) + warnings.warn( + "Unable to find Neuron hoc shared library in %s, " + "not disabling banner" % nrnpy_path + ) else: hoc_so = hoc_so_list[0] - nrndll = ctypes.cdll[hoc_so] - ctypes.c_int.in_dll(nrndll, 'nrn_nobanner_').value = 1 + nrndll = ctypes.cdll[str(hoc_so)] + ctypes.c_int.in_dll(nrndll, "nrn_nobanner_").value = 1 # pylint: disable=R0201 @property @@ -110,24 +117,26 @@ def neuron(self): def initialize(self): """Initialize simulator: Set Neuron variables""" - self.neuron.h.load_file('stdrun.hoc') + self.neuron.h.load_file("stdrun.hoc") self.neuron.h.dt = self.dt self.neuron.h.cvode_active(1 if self.cvode_active else 0) def run( - self, - tstop=None, - dt=None, - cvode_active=None, - random123_globalindex=None): + self, + tstop=None, + dt=None, + cvode_active=None, + random123_globalindex=None, + ): """Run protocol""" self.neuron.h.tstop = tstop if cvode_active and dt is not None: raise ValueError( - 'NrnSimulator: Impossible to combine the dt argument when ' - 'cvode_active is True in the NrnSimulator run method') + "NrnSimulator: Impossible to combine the dt argument when " + "cvode_active is True in the NrnSimulator run method" + ) if cvode_active is None: cvode_active = self.cvode_active @@ -135,11 +144,12 @@ def run( if not cvode_active and dt is None: # use dt of simulator if self.neuron.h.dt != self.dt: raise Exception( - 'NrnSimulator: Some process has changed the ' - 'time step dt of Neuron since the creation of this ' - 'NrnSimulator object. Not sure this is intended:\n' - 'current dt: %.6g\n' - 'init dt: %.6g' % (self.neuron.h.dt, self.dt)) + "NrnSimulator: Some process has changed the " + "time step dt of Neuron since the creation of this " + "NrnSimulator object. Not sure this is intended:\n" + "current dt: %.6g\n" + "init dt: %.6g" % (self.neuron.h.dt, self.dt) + ) dt = self.dt self.neuron.h.cvode_active(1 if cvode_active else 0) @@ -148,14 +158,13 @@ def run( self.cvode_minstep = self.cvode_minstep_value if cvode_active: - logger.debug('Running Neuron simulator %.6g ms, with cvode', tstop) + logger.debug("Running Neuron simulator %.6g ms, with cvode", tstop) else: self.neuron.h.dt = dt self.neuron.h.steps_per_ms = 1.0 / dt logger.debug( - 'Running Neuron simulator %.6g ms, with dt=%r', - tstop, - dt) + "Running Neuron simulator %.6g ms, with dt=%r", tstop, dt + ) if random123_globalindex is None: random123_globalindex = self.random123_globalindex @@ -167,16 +176,15 @@ def run( try: self.neuron.h.run() except Exception as e: - raise NrnSimulatorException('Neuron simulator error', e) + raise NrnSimulatorException("Neuron simulator error", e) if self.cvode_minstep_value is not None: self.cvode_minstep = save_minstep - logger.debug('Neuron simulation finished') + logger.debug("Neuron simulation finished") class NrnSimulatorException(Exception): - """All exception generated by Neuron simulator""" def __init__(self, message, original): @@ -187,11 +195,16 @@ def __init__(self, message, original): class LFPySimulator(NrnSimulator): - """LFPy simulator""" - def __init__(self, dt=None, cvode_active=True, cvode_minstep=None, - random123_globalindex=None, mechanisms_directory=None): + def __init__( + self, + dt=None, + cvode_active=True, + cvode_minstep=None, + random123_globalindex=None, + mechanisms_directory=None, + ): """Constructor Args: @@ -213,17 +226,18 @@ def __init__(self, dt=None, cvode_active=True, cvode_minstep=None, cvode_active=cvode_active, cvode_minstep=cvode_minstep, random123_globalindex=random123_globalindex, - mechanisms_directory=mechanisms_directory + mechanisms_directory=mechanisms_directory, ) def run( - self, - lfpy_cell, - lfpy_electrode, - tstop=None, - dt=None, - cvode_active=None, - random123_globalindex=None): + self, + lfpy_cell, + lfpy_electrode, + tstop=None, + dt=None, + cvode_active=None, + random123_globalindex=None, + ): """Run protocol""" _ = self.neuron @@ -235,8 +249,9 @@ def run( if cvode_active and dt is not None: raise ValueError( - 'NrnSimulator: Impossible to combine the dt argument when ' - 'cvode_active is True in the NrnSimulator run method') + "NrnSimulator: Impossible to combine the dt argument when " + "cvode_active is True in the NrnSimulator run method" + ) if cvode_active is None: cvode_active = self.cvode_active @@ -276,7 +291,6 @@ def run( class LFPySimulatorException(Exception): - """All exception generated by LFPy simulator""" def __init__(self, message, original): @@ -287,7 +301,6 @@ def __init__(self, message, original): class ArbSimulator(object): - """Arbor simulator""" def __init__(self, dt=None, ext_catalogues=None): @@ -303,14 +316,15 @@ def __init__(self, dt=None, ext_catalogues=None): self.ext_catalogues = ext_catalogues if ext_catalogues is not None: for cat, cat_path in ext_catalogues.items(): - cat_lib = '%s-catalogue.so' % cat + cat_lib = "%s-catalogue.so" % cat cat_path = pathlib.Path(cat_path).resolve() if not os.path.exists(cat_path / cat_lib): raise ArbSimulatorException( - 'Cannot find %s at %s - first build' % (cat_lib, - cat_path) + - ' mechanism catalogue with modcc:' + - ' arbor-build-catalogue %s %s' % (cat, cat_path)) + "Cannot find %s at %s - first build" + % (cat_lib, cat_path) + + " mechanism catalogue with modcc:" + + " arbor-build-catalogue %s %s" % (cat, cat_path) + ) # TODO: add parameters for discretization def initialize(self): @@ -318,9 +332,9 @@ def initialize(self): pass def instantiate(self, morph, decor, labels): - cable_cell = arbor.cable_cell(morphology=morph, - decor=decor, - labels=labels) + cable_cell = arbor.cable_cell( + morphology=morph, decor=decor, labels=labels + ) arb_cell_model = arbor.single_cell_model(cable_cell) @@ -330,35 +344,31 @@ def instantiate(self, morph, decor, labels): # User-supplied catalogues take precedence if self.ext_catalogues is not None: for cat, cat_path in self.ext_catalogues.items(): - cat_lib = '%s-catalogue.so' % cat + cat_lib = "%s-catalogue.so" % cat cat_path = pathlib.Path(cat_path).resolve() arb_cell_model.properties.catalogue.extend( - arbor.load_catalogue(cat_path / cat_lib), - cat + "::") + arbor.load_catalogue(cat_path / cat_lib), cat + "::" + ) # Built-in catalogues are always added (could be made optional) - if self.ext_catalogues is None or \ - 'default' not in self.ext_catalogues: + if self.ext_catalogues is None or "default" not in self.ext_catalogues: arb_cell_model.properties.catalogue.extend( - arbor.default_catalogue(), "default::") + arbor.default_catalogue(), "default::" + ) - if self.ext_catalogues is None or \ - 'BBP' not in self.ext_catalogues: + if self.ext_catalogues is None or "BBP" not in self.ext_catalogues: arb_cell_model.properties.catalogue.extend( - arbor.bbp_catalogue(), "BBP::") + arbor.bbp_catalogue(), "BBP::" + ) - if self.ext_catalogues is None or \ - 'allen' not in self.ext_catalogues: + if self.ext_catalogues is None or "allen" not in self.ext_catalogues: arb_cell_model.properties.catalogue.extend( - arbor.allen_catalogue(), "allen::") + arbor.allen_catalogue(), "allen::" + ) return arb_cell_model - def run(self, - arb_cell_model, - tstop=None, - dt=None): - + def run(self, arb_cell_model, tstop=None, dt=None): dt = dt if dt is not None else self.dt if dt is not None: @@ -368,7 +378,6 @@ def run(self, class ArbSimulatorException(Exception): - """All exception generated by Arbor simulator""" def __init__(self, message): diff --git a/bluepyopt/ephys/templates/cell_template.jinja2 b/bluepyopt/ephys/templates/cell_template.jinja2 index 33210a3c..65d9376b 100644 --- a/bluepyopt/ephys/templates/cell_template.jinja2 +++ b/bluepyopt/ephys/templates/cell_template.jinja2 @@ -42,6 +42,10 @@ begintemplate {{template_name}} public all, somatic, apical, axonal, basal, myelinated, APC objref all, somatic, apical, axonal, basal, myelinated, APC +obfunc getCell(){ + return this +} + proc init(/* args: morphology_dir, morphology_name */) { all = new SectionList() apical = new SectionList() @@ -120,7 +124,8 @@ proc distribute_distance(){local x localobj sl this.soma[0] distance(0, 0.5) sprint(distfunc, "%%s %s(%%f) = %s", mech, distfunc) forsec sl for(x, 0) { - sprint(stmp, distfunc, secname(), x, distance(x)) + // use distance(x) twice for the step distribution case, e.g. for calcium hotspot + sprint(stmp, distfunc, secname(), x, distance(x), distance(x)) execute(stmp) } } diff --git a/bluepyopt/ipyp/bpopt_tasksdb.py b/bluepyopt/ipyp/bpopt_tasksdb.py index edafd2d7..5709209c 100644 --- a/bluepyopt/ipyp/bpopt_tasksdb.py +++ b/bluepyopt/ipyp/bpopt_tasksdb.py @@ -1,7 +1,5 @@ """Get stats out of ipyparallel's tasks.db""" -from __future__ import print_function - """ Copyright (c) 2016-2020, EPFL/Blue Brain Project diff --git a/bluepyopt/tests/test_ephys/test_create_acc.py b/bluepyopt/tests/test_ephys/test_create_acc.py index 649b0af5..baae6def 100644 --- a/bluepyopt/tests/test_ephys/test_create_acc.py +++ b/bluepyopt/tests/test_ephys/test_create_acc.py @@ -2,46 +2,47 @@ # pylint: disable=W0212 +import json import os -import sys import pathlib import re -import json +import sys import tempfile -from bluepyopt.ephys.acc import arbor, ArbLabel -from bluepyopt.ephys.morphologies import ArbFileMorphology -from bluepyopt.ephys.parameterscalers import NrnSegmentSomaDistanceScaler - -from . import utils +import pytest from bluepyopt import ephys from bluepyopt.ephys import create_acc -from bluepyopt.ephys.create_acc import (Nrn2ArbParamAdapter, - Nrn2ArbMechGrouper, - ArbNmodlMechFormatter) +from bluepyopt.ephys.acc import ArbLabel, arbor +from bluepyopt.ephys.create_acc import ( + ArbNmodlMechFormatter, + Nrn2ArbMechGrouper, + Nrn2ArbParamAdapter, +) +from bluepyopt.ephys.morphologies import ArbFileMorphology +from bluepyopt.ephys.parameterscalers import NrnSegmentSomaDistanceScaler -import pytest +from . import utils DEFAULT_ARBOR_REGION_ORDER = [ - ('soma', 1), - ('axon', 2), - ('dend', 3), - ('apic', 4), - ('myelin', 5)] + ("soma", 1), + ("axon", 2), + ("dend", 3), + ("apic", 4), + ("myelin", 5), +] -testdata_dir = pathlib.Path(__file__).parent.joinpath( - 'testdata') +testdata_dir = pathlib.Path(__file__).parent.joinpath("testdata") @pytest.mark.unit def test_read_templates(): """Unit test for _read_templates function.""" - template_dir = testdata_dir / 'acc/templates' + template_dir = testdata_dir / "acc/templates" template_filename = "*_template.jinja2" templates = create_acc._read_templates(template_dir, template_filename) - assert templates.keys() == {'label_dict.acc', 'cell.json', 'decor.acc'} + assert templates.keys() == {"label_dict.acc", "cell.json", "decor.acc"} with pytest.raises(FileNotFoundError): create_acc._read_templates("DOES_NOT_EXIST", template_filename) @@ -52,13 +53,14 @@ def test_Nrn2ArbParamAdapter_param_name(): """Test Neuron to Arbor parameter mapping.""" # Identity mech_param_name = "gSKv3_1bar_SKv3_1" - assert Nrn2ArbParamAdapter._param_name(mech_param_name) \ - == mech_param_name + assert Nrn2ArbParamAdapter._param_name(mech_param_name) == mech_param_name # Non-trivial transformation global_property_name = "v_init" - assert Nrn2ArbParamAdapter._param_name(global_property_name) \ + assert ( + Nrn2ArbParamAdapter._param_name(global_property_name) == "membrane-potential" + ) @pytest.mark.unit @@ -75,7 +77,8 @@ def test_Nrn2ArbParamAdapter_param_value(): # Non-trivial name and value/units transformation global_property = create_acc.Location(name="celsius", value=34) assert Nrn2ArbParamAdapter._param_value(global_property) == ( - "307.14999999999998") + "307.14999999999998" + ) @pytest.mark.unit @@ -85,38 +88,39 @@ def test_Nrn2ArbParamAdapter_format(): mech_param = create_acc.Location(name="gSKv3_1bar_SKv3_1", value="1.025") mech = "SKv3_1" arb_mech_param = create_acc.Location(name="gSKv3_1bar", value="1.025") - assert ( - Nrn2ArbParamAdapter.format( - mech_param, mechs=[mech]) - == (mech, arb_mech_param) + assert Nrn2ArbParamAdapter.format(mech_param, mechs=[mech]) == ( + mech, + arb_mech_param, ) # Non-unique mapping to mechanisms with pytest.raises(create_acc.CreateAccException): - Nrn2ArbParamAdapter.format( - mech_param, mechs=["SKv3_1", "1"]) + Nrn2ArbParamAdapter.format(mech_param, mechs=["SKv3_1", "1"]) # Global property with non-trivial transformation global_property = create_acc.Location(name="celsius", value="0") mech = None arb_global_property = create_acc.Location( - name="temperature-kelvin", value="273.14999999999998") + name="temperature-kelvin", value="273.14999999999998" + ) # Non-trivial name and value/units transformation - assert Nrn2ArbParamAdapter.format(global_property, []) == \ - (mech, arb_global_property) + assert Nrn2ArbParamAdapter.format(global_property, []) == ( + mech, + arb_global_property, + ) # Inhomogeneuos mechanism parameter apical_region = ArbLabel("region", "apic", "(tag 4)") param_scaler = NrnSegmentSomaDistanceScaler( - name='soma-distance-scaler', - distribution='(-0.8696 + 2.087*math.exp(({distance})*0.0031))*{value}' + name="soma-distance-scaler", + distribution="(-0.8696 + 2.087*math.exp(({distance})*0.0031))*{value}", ) iexpr_param = create_acc.RangeExpr( location=apical_region, name="gkbar_hh", value="0.025", - value_scaler=param_scaler + value_scaler=param_scaler, ) mech = "hh" arb_iexpr_param = create_acc.RangeExpr( @@ -125,50 +129,56 @@ def test_Nrn2ArbParamAdapter_format(): value="0.025", value_scaler=param_scaler, ) - assert ( - Nrn2ArbParamAdapter.format( - iexpr_param, mechs=[mech]) - == (mech, arb_iexpr_param) + assert Nrn2ArbParamAdapter.format(iexpr_param, mechs=[mech]) == ( + mech, + arb_iexpr_param, ) # Point process mechanism parameter loc = ephys.locations.ArbLocsetLocation( - name='somacenter', - locset='(location 0 0.5)') + name="somacenter", locset="(location 0 0.5)" + ) mech = ephys.mechanisms.NrnMODPointProcessMechanism( - name='expsyn', - suffix='ExpSyn', - locations=[loc]) + name="expsyn", suffix="ExpSyn", locations=[loc] + ) mech_loc = ephys.locations.NrnPointProcessLocation( - 'expsyn_loc', - pprocess_mech=mech) + "expsyn_loc", pprocess_mech=mech + ) point_expr_param = create_acc.PointExpr( - name="tau", value="10", point_loc=[mech_loc]) + name="tau", value="10", point_loc=[mech_loc] + ) arb_point_expr_param = create_acc.PointExpr( - name="tau", value="10", point_loc=[mech_loc]) - assert ( - Nrn2ArbParamAdapter.format( - point_expr_param, mechs=[mech]) - == (mech, arb_point_expr_param) + name="tau", value="10", point_loc=[mech_loc] + ) + assert Nrn2ArbParamAdapter.format(point_expr_param, mechs=[mech]) == ( + mech, + arb_point_expr_param, ) @pytest.mark.unit def test_Nrn2ArbMechGrouper_format_params_and_group_by_mech(): """Test grouping of parameters by mechanism.""" - params = [create_acc.Location(name="gSKv3_1bar_SKv3_1", value="1.025"), - create_acc.Location(name="ena", value="-30")] + params = [ + create_acc.Location(name="gSKv3_1bar_SKv3_1", value="1.025"), + create_acc.Location(name="ena", value="-30"), + ] mechs = ["SKv3_1"] - local_mechs = Nrn2ArbMechGrouper.\ - _format_params_and_group_by_mech(params, mechs) - assert local_mechs == \ - {None: [create_acc.Location(name="ion-reversal-potential \"na\"", - value="-30")], - "SKv3_1": [create_acc.Location(name="gSKv3_1bar", value="1.025")]} + local_mechs = Nrn2ArbMechGrouper._format_params_and_group_by_mech( + params, mechs + ) + assert local_mechs == { + None: [ + create_acc.Location( + name='ion-reversal-potential "na"', value="-30" + ) + ], + "SKv3_1": [create_acc.Location(name="gSKv3_1bar", value="1.025")], + } @pytest.mark.unit @@ -177,10 +187,13 @@ def test_Nrn2ArbMechGrouper_process_global(): params = {"ki": 3, "v_init": -65} global_mechs = Nrn2ArbMechGrouper.process_global(params) assert global_mechs == { - None: [create_acc.Location(name="ion-internal-concentration \"k\"", - value="3"), - create_acc.Location(name="membrane-potential", - value="-65")]} + None: [ + create_acc.Location( + name='ion-internal-concentration "k"', value="3" + ), + create_acc.Location(name="membrane-potential", value="-65"), + ] + } @pytest.mark.unit @@ -188,22 +201,23 @@ def test_Nrn2ArbMechGrouper_is_global_property(): """Test adapting local parameters from Neuron to Arbor.""" all_regions = ArbLabel("region", "all_regions", "(all)") param = create_acc.Location(name="axial-resistivity", value="1") - assert Nrn2ArbMechGrouper._is_global_property( - all_regions, param) is True + assert Nrn2ArbMechGrouper._is_global_property(all_regions, param) is True soma_region = ArbLabel("region", "soma", "(tag 1)") - assert Nrn2ArbMechGrouper._is_global_property( - soma_region, param) is False + assert Nrn2ArbMechGrouper._is_global_property(soma_region, param) is False @pytest.mark.unit def test_separate_global_properties(): """Test separating global properties from label-specific mechs.""" all_regions = ArbLabel("region", "all_regions", "(all)") - mechs = {None: [create_acc.Location(name="axial-resistivity", value="1")], - "SKv3_1": [create_acc.Location(name="gSKv3_1bar", value="1.025")]} - local_mechs, global_properties = \ + mechs = { + None: [create_acc.Location(name="axial-resistivity", value="1")], + "SKv3_1": [create_acc.Location(name="gSKv3_1bar", value="1.025")], + } + local_mechs, global_properties = ( Nrn2ArbMechGrouper._separate_global_properties(all_regions, mechs) + ) assert local_mechs == {None: [], "SKv3_1": mechs["SKv3_1"]} assert global_properties == {None: mechs[None]} @@ -214,23 +228,28 @@ def test_Nrn2ArbMechGrouper_process_local(): all_regions = ArbLabel("region", "all_regions", "(all)") soma_region = ArbLabel("region", "soma", "(tag 1)") params = [ - (all_regions, - [create_acc.Location(name="cm", value="100")]), - (soma_region, - [create_acc.Location(name="v_init", value="-65"), - create_acc.Location(name="gSKv3_1bar_SKv3_1", value="1.025")]) + (all_regions, [create_acc.Location(name="cm", value="100")]), + ( + soma_region, + [ + create_acc.Location(name="v_init", value="-65"), + create_acc.Location(name="gSKv3_1bar_SKv3_1", value="1.025"), + ], + ), ] channels = {all_regions: [], soma_region: ["SKv3_1"]} - local_mechs, global_properties = \ - Nrn2ArbMechGrouper.process_local(params, channels) + local_mechs, global_properties = Nrn2ArbMechGrouper.process_local( + params, channels + ) assert local_mechs.keys() == {all_regions, soma_region} assert local_mechs[all_regions] == {None: []} assert local_mechs[soma_region] == { None: [create_acc.Location(name="membrane-potential", value="-65")], - "SKv3_1": [create_acc.Location(name="gSKv3_1bar", value="1.025")] + "SKv3_1": [create_acc.Location(name="gSKv3_1bar", value="1.025")], } assert global_properties == { - None: [create_acc.Location(name="membrane-capacitance", value="1")]} + None: [create_acc.Location(name="membrane-capacitance", value="1")] + } @pytest.mark.unit @@ -239,8 +258,8 @@ def test_ArbNmodlMechFormatter_load_mech_catalogue_meta(): nmodl_formatter = ArbNmodlMechFormatter(None) assert isinstance(nmodl_formatter.cats, dict) - assert nmodl_formatter.cats.keys() == {'BBP', 'default', 'allen'} - assert "Ca_HVA" in nmodl_formatter.cats['BBP'] + assert nmodl_formatter.cats.keys() == {"BBP", "default", "allen"} + assert "Ca_HVA" in nmodl_formatter.cats["BBP"] @pytest.mark.unit @@ -261,7 +280,7 @@ def test_ArbNmodlMechFormatter_translate_density(): value="0.029999999999999999", scale=( "(add (scalar -0.62109375) (mul (scalar 0.546875) " - "(log (add (mul (distance (region \"soma\"))" + '(log (add (mul (distance (region "soma"))' " (scalar 0.421875) ) (scalar 1.25) ) ) ) )" ), ), @@ -273,7 +292,7 @@ def test_ArbNmodlMechFormatter_translate_density(): value="0.029999999999999999", scale=( "(add (scalar -0.62109375) (mul (scalar 0.546875) " - "(log (add (mul (distance (region \"soma\"))" + '(log (add (mul (distance (region "soma"))' " (scalar 0.421875) ) (scalar 1.25) ) ) ) )" ), ), @@ -281,8 +300,7 @@ def test_ArbNmodlMechFormatter_translate_density(): } nmodl_formatter = ArbNmodlMechFormatter(None) translated_mechs = nmodl_formatter.translate_density(mechs) - assert translated_mechs.keys() == {"default::hh", - "default::pas/e=0.25"} + assert translated_mechs.keys() == {"default::hh", "default::pas/e=0.25"} assert translated_mechs["default::hh"] == mechs["hh"] assert translated_mechs["default::pas/e=0.25"] == mechs["pas"][1:] @@ -291,21 +309,21 @@ def test_ArbNmodlMechFormatter_translate_density(): def test_arb_populate_label_dict(): """Unit test for _populate_label_dict.""" local_mechs = {ArbLabel("region", "all", "(all)"): {}} - local_scaled_mechs = { - ArbLabel("region", "first_branch", "(branch 0)"): {}} + local_scaled_mechs = {ArbLabel("region", "first_branch", "(branch 0)"): {}} pprocess_mechs = {} - label_dict = create_acc._arb_populate_label_dict(local_mechs, - local_scaled_mechs, - pprocess_mechs) + label_dict = create_acc._arb_populate_label_dict( + local_mechs, local_scaled_mechs, pprocess_mechs + ) assert label_dict.keys() == {"all", "first_branch"} with pytest.raises(create_acc.CreateAccException): other_pprocess_mechs = { - ArbLabel("region", "first_branch", "(branch 1)"): {}} - create_acc._arb_populate_label_dict(local_mechs, - local_scaled_mechs, - other_pprocess_mechs) + ArbLabel("region", "first_branch", "(branch 1)"): {} + } + create_acc._arb_populate_label_dict( + local_mechs, local_scaled_mechs, other_pprocess_mechs + ) @pytest.mark.unit @@ -314,11 +332,16 @@ def test_create_acc(): mech = utils.make_mech() parameters = utils.make_parameters() - acc = create_acc.create_acc([mech, ], parameters, - morphology='CCell.swc', - template_name='CCell') + acc = create_acc.create_acc( + [ + mech, + ], + parameters, + morphology="CCell.swc", + template_name="CCell", + ) - ref_dir = testdata_dir / 'acc/CCell' + ref_dir = testdata_dir / "acc/CCell" cell_json = "CCell.json" decor_acc = "CCell_decor.acc" label_dict_acc = "CCell_label_dict.acc" @@ -326,22 +349,22 @@ def test_create_acc(): # Testing keys assert cell_json in acc cell_json_dict = json.loads(acc[cell_json]) - assert 'cell_model_name' in cell_json_dict - assert 'produced_by' in cell_json_dict - assert 'morphology' in cell_json_dict - assert 'label_dict' in cell_json_dict - assert 'decor' in cell_json_dict + assert "cell_model_name" in cell_json_dict + assert "produced_by" in cell_json_dict + assert "morphology" in cell_json_dict + assert "label_dict" in cell_json_dict + assert "decor" in cell_json_dict # Testing values with open(ref_dir / cell_json) as f: ref_cell_json = json.load(f) for k in ref_cell_json: - if k != 'produced_by': + if k != "produced_by": assert ref_cell_json[k] == cell_json_dict[k] # Testing building blocks assert decor_acc in acc - assert acc[decor_acc].startswith('(arbor-component') - assert '(decor' in acc[decor_acc] + assert acc[decor_acc].startswith("(arbor-component") + assert "(decor" in acc[decor_acc] # Testing values with open(ref_dir / decor_acc) as f: ref_decor = f.read() @@ -349,19 +372,20 @@ def test_create_acc(): # Testing building blocks assert label_dict_acc in acc - assert acc[label_dict_acc].startswith('(arbor-component') - assert '(label-dict' in acc[label_dict_acc] - matches = re.findall(r'\(region-def "(?P\w+)" \(tag (?P\d+)\)\)', - acc[label_dict_acc]) + assert acc[label_dict_acc].startswith("(arbor-component") + assert "(label-dict" in acc[label_dict_acc] + matches = re.findall( + r'\(region-def "(?P\w+)" \(tag (?P\d+)\)\)', + acc[label_dict_acc], + ) for pos, loc_tag in enumerate(DEFAULT_ARBOR_REGION_ORDER): assert matches[pos][0] == loc_tag[0] assert matches[pos][1] == str(loc_tag[1]) # Testing values - ref_labels = arbor.load_component( - ref_dir / label_dict_acc).component + ref_labels = arbor.load_component(ref_dir / label_dict_acc).component with tempfile.TemporaryDirectory() as test_dir: test_labels_filename = pathlib.Path(test_dir).joinpath(label_dict_acc) - with open(test_labels_filename, 'w') as f: + with open(test_labels_filename, "w") as f: f.write(acc[label_dict_acc]) test_labels = arbor.load_component(test_labels_filename).component assert dict(ref_labels.items()) == dict(test_labels.items()) @@ -375,41 +399,46 @@ def test_create_acc_filename(): custom_param_val = str(__file__) acc = create_acc.create_acc( - [mech, ], - parameters, morphology='CCell.asc', - template_name='CCell', - template_filename='acc/templates/*_template.jinja2', + [ + mech, + ], + parameters, + morphology="CCell.asc", + template_name="CCell", + template_filename="acc/templates/*_template.jinja2", template_dir=testdata_dir, - custom_jinja_params={ - 'custom_param': custom_param_val}) + custom_jinja_params={"custom_param": custom_param_val}, + ) cell_json = "CCell_cell.json" decor_acc = "CCell_decor.acc" label_dict_acc = "CCell_label_dict.acc" assert cell_json in acc cell_json_dict = json.loads(acc[cell_json]) - assert 'cell_model_name' in cell_json_dict - assert 'produced_by' in cell_json_dict - assert 'morphology' in cell_json_dict - assert 'label_dict' in cell_json_dict - assert 'decor' in cell_json_dict + assert "cell_model_name" in cell_json_dict + assert "produced_by" in cell_json_dict + assert "morphology" in cell_json_dict + assert "label_dict" in cell_json_dict + assert "decor" in cell_json_dict assert decor_acc in acc - assert acc[decor_acc].startswith('(arbor-component') - assert '(decor' in acc[decor_acc] + assert acc[decor_acc].startswith("(arbor-component") + assert "(decor" in acc[decor_acc] assert label_dict_acc in acc - assert acc[label_dict_acc].startswith('(arbor-component') - assert '(label-dict' in acc[label_dict_acc] - matches = re.findall(r'\(region-def "(?P\w+)" \(tag (?P\d+)\)\)', - acc[label_dict_acc]) + assert acc[label_dict_acc].startswith("(arbor-component") + assert "(label-dict" in acc[label_dict_acc] + matches = re.findall( + r'\(region-def "(?P\w+)" \(tag (?P\d+)\)\)', + acc[label_dict_acc], + ) for pos, loc_tag in enumerate(DEFAULT_ARBOR_REGION_ORDER): assert matches[pos][0] == loc_tag[0] assert matches[pos][1] == str(loc_tag[1]) assert '(meta-data (info "test-decor"))' in acc[decor_acc] assert '(meta-data (info "test-label-dict"))' in acc[label_dict_acc] - assert custom_param_val in cell_json_dict['produced_by'] + assert custom_param_val in cell_json_dict["produced_by"] @pytest.mark.unit @@ -426,60 +455,76 @@ def test_create_acc_replace_axon(): latest_seg, arbor.mpoint(prox_x, 0, 0, 0.5), arbor.mpoint(dist_x, 0, 0, 0.5), - ArbFileMorphology.tags['axon'] + ArbFileMorphology.tags["axon"], ) replace_axon = arbor.morphology(replace_axon_st) try: - acc = create_acc.create_acc([mech, ], parameters, - morphology_dir=testdata_dir, - morphology='simple.swc', - template_name='CCell', - replace_axon=replace_axon) + acc = create_acc.create_acc( + [ + mech, + ], + parameters, + morphology_dir=testdata_dir, + morphology="simple.swc", + template_name="CCell", + replace_axon=replace_axon, + ) except Exception as e: # fail with an older Arbor version assert isinstance(e, NotImplementedError) - assert len(e.args) == 1 and e.args[0] == \ - "Need a newer version of Arbor for axon replacement." + assert ( + len(e.args) == 1 + and e.args[0] + == "Need a newer version of Arbor for axon replacement." + ) return cell_json = "CCell.json" cell_json_dict = json.loads(acc[cell_json]) - assert 'replace_axon' in cell_json_dict['morphology'] + assert "replace_axon" in cell_json_dict["morphology"] - with open(testdata_dir / 'acc/CCell/simple_axon_replacement.acc') as f: + with open(testdata_dir / "acc/CCell/simple_axon_replacement.acc") as f: replace_axon_ref = f.read() - assert acc[cell_json_dict['morphology']['replace_axon']] == \ - replace_axon_ref + assert ( + acc[cell_json_dict["morphology"]["replace_axon"]] == replace_axon_ref + ) def make_cell(replace_axon): - morph_filename = testdata_dir / 'simple_ax2.swc' - morph = ephys.morphologies.NrnFileMorphology(morph_filename, - do_replace_axon=replace_axon) + morph_filename = testdata_dir / "simple_ax2.swc" + morph = ephys.morphologies.NrnFileMorphology( + morph_filename, do_replace_axon=replace_axon + ) somatic_loc = ephys.locations.NrnSeclistLocation( - 'somatic', seclist_name='somatic') - mechs = [ephys.mechanisms.NrnMODMechanism( - name='hh', suffix='hh', locations=[somatic_loc])] - gkbar_hh_scaler = '(-0.62109375 + 0.546875*math.log(' \ - '({distance})*0.421875 + 1.25))*{value}' + "somatic", seclist_name="somatic" + ) + mechs = [ + ephys.mechanisms.NrnMODMechanism( + name="hh", suffix="hh", locations=[somatic_loc] + ) + ] + gkbar_hh_scaler = ( + "(-0.62109375 + 0.546875*math.log(" + "({distance})*0.421875 + 1.25))*{value}" + ) params = [ ephys.parameters.NrnSectionParameter( - name='gnabar_hh', - param_name='gnabar_hh', - locations=[somatic_loc]), + name="gnabar_hh", param_name="gnabar_hh", locations=[somatic_loc] + ), ephys.parameters.NrnRangeParameter( - name='gkbar_hh', - param_name='gkbar_hh', + name="gkbar_hh", + param_name="gkbar_hh", value_scaler=ephys.parameterscalers.NrnSegmentSomaDistanceScaler( - distribution=gkbar_hh_scaler), - locations=[somatic_loc])] + distribution=gkbar_hh_scaler + ), + locations=[somatic_loc], + ), + ] return ephys.models.CellModel( - 'simple_ax2', - morph=morph, - mechs=mechs, - params=params) + "simple_ax2", morph=morph, mechs=mechs, params=params + ) def run_short_sim(cable_cell): @@ -487,9 +532,9 @@ def run_short_sim(cable_cell): arb_cell_model = arbor.single_cell_model(cable_cell) arb_cell_model.properties.catalogue = arbor.catalogue() arb_cell_model.properties.catalogue.extend( - arbor.default_catalogue(), "default::") - arb_cell_model.properties.catalogue.extend( - arbor.bbp_catalogue(), "BBP::") + arbor.default_catalogue(), "default::" + ) + arb_cell_model.properties.catalogue.extend(arbor.bbp_catalogue(), "BBP::") # Run a very short simulation to test mechanism instantiation arb_cell_model.run(tfinal=0.1) @@ -499,26 +544,29 @@ def run_short_sim(cable_cell): def test_cell_model_write_and_read_acc(): """ephys.create_acc: Test write_acc and read_acc w/o axon replacement""" cell = make_cell(replace_axon=False) - param_values = {'gnabar_hh': 0.1, - 'gkbar_hh': 0.03} + param_values = {"gnabar_hh": 0.1, "gkbar_hh": 0.03} with tempfile.TemporaryDirectory() as acc_dir: cell.write_acc(acc_dir, param_values) - cell_json, arb_morph, arb_decor, arb_labels = \ - create_acc.read_acc( - pathlib.Path(acc_dir).joinpath(cell.name + '.json')) - assert 'replace_axon' not in cell_json['morphology'] - - cable_cell = arbor.cable_cell(morphology=arb_morph, - decor=arb_decor, - labels=arb_labels) + cell_json, arb_morph, arb_decor, arb_labels = create_acc.read_acc( + pathlib.Path(acc_dir).joinpath(cell.name + ".json") + ) + assert "replace_axon" not in cell_json["morphology"] + + cable_cell = arbor.cable_cell( + morphology=arb_morph, decor=arb_decor, labels=arb_labels + ) assert isinstance(cable_cell, arbor.cable_cell) assert len(cable_cell.cables('"soma"')) == 1 assert len(cable_cell.cables('"axon"')) == 1 - assert len(arb_morph.branch_segments( - cable_cell.cables('"soma"')[0].branch)) == 5 - assert len(arb_morph.branch_segments( - cable_cell.cables('"axon"')[0].branch)) == 5 + assert ( + len(arb_morph.branch_segments(cable_cell.cables('"soma"')[0].branch)) + == 5 + ) + assert ( + len(arb_morph.branch_segments(cable_cell.cables('"axon"')[0].branch)) + == 5 + ) run_short_sim(cable_cell) @@ -527,40 +575,50 @@ def test_cell_model_write_and_read_acc(): def test_cell_model_write_and_read_acc_replace_axon(): """ephys.create_acc: Test write_acc and read_acc w/ axon replacement""" cell = make_cell(replace_axon=True) - param_values = {'gnabar_hh': 0.1, - 'gkbar_hh': 0.03} + param_values = {"gnabar_hh": 0.1, "gkbar_hh": 0.03} with tempfile.TemporaryDirectory() as acc_dir: try: nrn_sim = ephys.simulators.NrnSimulator() - cell.write_acc(acc_dir, param_values, - sim=nrn_sim) + cell.write_acc(acc_dir, param_values, sim=nrn_sim) except Exception as e: # fail with an older Arbor version assert isinstance(e, NotImplementedError) - assert len(e.args) == 1 and e.args[0] == \ - "Need a newer version of Arbor for axon replacement." + assert ( + len(e.args) == 1 + and e.args[0] + == "Need a newer version of Arbor for axon replacement." + ) return # Axon replacement implemented in installed Arbor version - cell_json, arb_morph, arb_decor, arb_labels = \ - create_acc.read_acc( - pathlib.Path(acc_dir).joinpath(cell.name + '.json')) - - assert 'replace_axon' in cell_json['morphology'] - cable_cell = arbor.cable_cell(morphology=arb_morph, - decor=arb_decor, - labels=arb_labels) + cell_json, arb_morph, arb_decor, arb_labels = create_acc.read_acc( + pathlib.Path(acc_dir).joinpath(cell.name + ".json") + ) + + assert "replace_axon" in cell_json["morphology"] + cable_cell = arbor.cable_cell( + morphology=arb_morph, decor=arb_decor, labels=arb_labels + ) assert isinstance(cable_cell, arbor.cable_cell) assert len(cable_cell.cables('"soma"')) == 1 assert len(cable_cell.cables('"axon"')) == 1 - assert len(arb_morph.branch_segments( - cable_cell.cables('"soma"')[0].branch)) == 6 - assert len(arb_morph.branch_segments( - cable_cell.cables('"axon"')[0].branch)) == 6 - assert cable_cell.cables('"soma"')[0].prox == 0. - assert abs(cable_cell.cables('"soma"')[0].dist - - cable_cell.cables('"axon"')[0].prox) < 1e-6 - assert cable_cell.cables('"axon"')[0].dist == 1. + assert ( + len(arb_morph.branch_segments(cable_cell.cables('"soma"')[0].branch)) + == 6 + ) + assert ( + len(arb_morph.branch_segments(cable_cell.cables('"axon"')[0].branch)) + == 6 + ) + assert cable_cell.cables('"soma"')[0].prox == 0.0 + assert ( + abs( + cable_cell.cables('"soma"')[0].dist + - cable_cell.cables('"axon"')[0].prox + ) + < 1e-6 + ) + assert cable_cell.cables('"axon"')[0].dist == 1.0 run_short_sim(cable_cell) @@ -569,37 +627,37 @@ def test_cell_model_write_and_read_acc_replace_axon(): def test_cell_model_create_acc_replace_axon_without_instantiate(): """ephys.create_acc: Test write_acc and read_acc w/ axon replacement""" cell = make_cell(replace_axon=True) - param_values = {'gnabar_hh': 0.1, - 'gkbar_hh': 0.03} - - with pytest.raises(ValueError, - match='Need an instance of NrnSimulator in sim' - ' to instantiate morphology in order to' - ' create JSON/ACC-description with' - ' axon replacement.'): + param_values = {"gnabar_hh": 0.1, "gkbar_hh": 0.03} + + with pytest.raises( + ValueError, + match="Need an instance of NrnSimulator in sim" + " to instantiate morphology in order to" + " create JSON/ACC-description with" + " axon replacement.", + ): cell.create_acc(param_values) def check_acc_dir(test_dir, ref_dir): - assert os.listdir(ref_dir) == os.listdir(test_dir) + assert sorted(os.listdir(ref_dir)) == sorted(os.listdir(test_dir)) - ref_dir_ver_suffix = '_py' + ''.join(sys.version.split('.')[:2]) + ref_dir_ver_suffix = "_py" + "".join(sys.version.split(".")[:2]) ref_dir_ver = ref_dir.parent / (ref_dir.name + ref_dir_ver_suffix) for file in os.listdir(ref_dir): - if (ref_dir_ver / file).exists(): ref_dir_file = ref_dir_ver else: ref_dir_file = ref_dir - if file.endswith('.json'): + if file.endswith(".json"): with open(os.path.join(test_dir, file)) as f: cell_json_dict = json.load(f) with open(ref_dir_file / file) as f: ref_cell_json = json.load(f) for k in ref_cell_json: - if k != 'produced_by': + if k != "produced_by": assert ref_cell_json[k] == cell_json_dict[k] else: with open(os.path.join(test_dir, file)) as f: @@ -611,17 +669,21 @@ def check_acc_dir(test_dir, ref_dir): @pytest.mark.unit def test_write_acc_simple(): - SIMPLECELL_PATH = str((pathlib.Path(__file__).parent / - '../../../examples/simplecell').resolve()) + SIMPLECELL_PATH = str( + ( + pathlib.Path(__file__).parent / "../../../examples/simplecell" + ).resolve() + ) sys.path.insert(0, SIMPLECELL_PATH) - ref_dir = (testdata_dir / 'acc/simplecell').resolve() + ref_dir = (testdata_dir / "acc/simplecell").resolve() old_cwd = os.getcwd() try: os.chdir(SIMPLECELL_PATH) import simplecell_model + param_values = { - 'gnabar_hh': 0.10299326453483033, - 'gkbar_hh': 0.027124836082684685 + "gnabar_hh": 0.10299326453483033, + "gkbar_hh": 0.027124836082684685, } cell = simplecell_model.create(do_replace_axon=True) @@ -629,16 +691,20 @@ def test_write_acc_simple(): cell.instantiate_morphology_3d(nrn_sim) with tempfile.TemporaryDirectory() as test_dir: - cell.write_acc(test_dir, - param_values, - # ext_catalogues=ext_catalogues, - create_mod_morph=True) + cell.write_acc( + test_dir, + param_values, + # ext_catalogues=ext_catalogues, + create_mod_morph=True, + ) check_acc_dir(test_dir, ref_dir) - except Exception as e: # fail with an older Arbor version - assert isinstance(e, NotImplementedError) - assert len(e.args) == 1 and e.args[0] == \ - "Need a newer version of Arbor for axon replacement." + except NotImplementedError as e: # fail with an older Arbor version + assert ( + len(e.args) == 1 + and e.args[0] + == "Need a newer version of Arbor for axon replacement." + ) finally: cell.destroy(nrn_sim) os.chdir(old_cwd) @@ -647,34 +713,36 @@ def test_write_acc_simple(): @pytest.mark.unit def test_write_acc_l5pc(): - L5PC_PATH = str((pathlib.Path(__file__).parent / - '../../../examples/l5pc').resolve()) + L5PC_PATH = str( + (pathlib.Path(__file__).parent / "../../../examples/l5pc").resolve() + ) sys.path.insert(0, L5PC_PATH) - ref_dir = (testdata_dir / 'acc/l5pc').resolve() + ref_dir = (testdata_dir / "acc/l5pc").resolve() old_cwd = os.getcwd() try: import l5pc_model + param_values = { - 'gNaTs2_tbar_NaTs2_t.apical': 0.026145, - 'gSKv3_1bar_SKv3_1.apical': 0.004226, - 'gImbar_Im.apical': 0.000143, - 'gNaTa_tbar_NaTa_t.axonal': 3.137968, - 'gK_Tstbar_K_Tst.axonal': 0.089259, - 'gamma_CaDynamics_E2.axonal': 0.002910, - 'gNap_Et2bar_Nap_Et2.axonal': 0.006827, - 'gSK_E2bar_SK_E2.axonal': 0.007104, - 'gCa_HVAbar_Ca_HVA.axonal': 0.000990, - 'gK_Pstbar_K_Pst.axonal': 0.973538, - 'gSKv3_1bar_SKv3_1.axonal': 1.021945, - 'decay_CaDynamics_E2.axonal': 287.198731, - 'gCa_LVAstbar_Ca_LVAst.axonal': 0.008752, - 'gamma_CaDynamics_E2.somatic': 0.000609, - 'gSKv3_1bar_SKv3_1.somatic': 0.303472, - 'gSK_E2bar_SK_E2.somatic': 0.008407, - 'gCa_HVAbar_Ca_HVA.somatic': 0.000994, - 'gNaTs2_tbar_NaTs2_t.somatic': 0.983955, - 'decay_CaDynamics_E2.somatic': 210.485284, - 'gCa_LVAstbar_Ca_LVAst.somatic': 0.000333, + "gNaTs2_tbar_NaTs2_t.apical": 0.026145, + "gSKv3_1bar_SKv3_1.apical": 0.004226, + "gImbar_Im.apical": 0.000143, + "gNaTa_tbar_NaTa_t.axonal": 3.137968, + "gK_Tstbar_K_Tst.axonal": 0.089259, + "gamma_CaDynamics_E2.axonal": 0.002910, + "gNap_Et2bar_Nap_Et2.axonal": 0.006827, + "gSK_E2bar_SK_E2.axonal": 0.007104, + "gCa_HVAbar_Ca_HVA.axonal": 0.000990, + "gK_Pstbar_K_Pst.axonal": 0.973538, + "gSKv3_1bar_SKv3_1.axonal": 1.021945, + "decay_CaDynamics_E2.axonal": 287.198731, + "gCa_LVAstbar_Ca_LVAst.axonal": 0.008752, + "gamma_CaDynamics_E2.somatic": 0.000609, + "gSKv3_1bar_SKv3_1.somatic": 0.303472, + "gSK_E2bar_SK_E2.somatic": 0.008407, + "gCa_HVAbar_Ca_HVA.somatic": 0.000994, + "gNaTs2_tbar_NaTs2_t.somatic": 0.983955, + "decay_CaDynamics_E2.somatic": 210.485284, + "gCa_LVAstbar_Ca_LVAst.somatic": 0.000333, } cell = l5pc_model.create(do_replace_axon=True) @@ -682,16 +750,21 @@ def test_write_acc_l5pc(): cell.instantiate_morphology_3d(nrn_sim) with tempfile.TemporaryDirectory() as test_dir: - cell.write_acc(test_dir, - param_values, - # ext_catalogues=ext_catalogues, - create_mod_morph=True) + cell.write_acc( + test_dir, + param_values, + # ext_catalogues=ext_catalogues, + create_mod_morph=True, + ) check_acc_dir(test_dir, ref_dir) except Exception as e: # fail with an older Arbor version assert isinstance(e, NotImplementedError) - assert len(e.args) == 1 and e.args[0] == \ - "Need a newer version of Arbor for axon replacement." + assert ( + len(e.args) == 1 + and e.args[0] + == "Need a newer version of Arbor for axon replacement." + ) finally: cell.destroy(nrn_sim) os.chdir(old_cwd) @@ -700,22 +773,26 @@ def test_write_acc_l5pc(): @pytest.mark.unit def test_write_acc_expsyn(): - EXPSYN_PATH = str((pathlib.Path(__file__).parent / - '../../../examples/expsyn').resolve()) + EXPSYN_PATH = str( + (pathlib.Path(__file__).parent / "../../../examples/expsyn").resolve() + ) sys.path.insert(0, EXPSYN_PATH) - ref_dir = (testdata_dir / 'acc/expsyn').resolve() + ref_dir = (testdata_dir / "acc/expsyn").resolve() old_cwd = os.getcwd() try: import expsyn - param_values = {'expsyn_tau': 10.0} - cell = expsyn.create_model(sim='arb', do_replace_axon=False) + param_values = {"expsyn_tau": 10.0} + + cell = expsyn.create_model(sim="arb", do_replace_axon=False) with tempfile.TemporaryDirectory() as test_dir: - cell.write_acc(test_dir, - param_values, - # ext_catalogues=ext_catalogues, - create_mod_morph=True) + cell.write_acc( + test_dir, + param_values, + # ext_catalogues=ext_catalogues, + create_mod_morph=True, + ) check_acc_dir(test_dir, ref_dir) finally: diff --git a/bluepyopt/tests/test_ephys/test_create_hoc.py b/bluepyopt/tests/test_ephys/test_create_hoc.py index 4666d4e3..19153a52 100644 --- a/bluepyopt/tests/test_ephys/test_create_hoc.py +++ b/bluepyopt/tests/test_ephys/test_create_hoc.py @@ -5,7 +5,9 @@ import os from bluepyopt.ephys.acc import ArbLabel +from bluepyopt.ephys.locations import NrnSomaDistanceCompLocation from bluepyopt.ephys.parameterscalers import NrnSegmentSomaDistanceScaler +from bluepyopt.ephys.parameterscalers import NrnSegmentSomaDistanceStepScaler from . import utils from bluepyopt.ephys import create_acc, create_hoc @@ -151,3 +153,33 @@ def test_range_exprs_to_hoc(): assert hoc[0].param_name == 'gkbar_hh' val_gt = '(-0.8696 + 2.087*exp((%.17g)*0.0031))*0.025000000000000001' assert hoc[0].value == val_gt + + +@pytest.mark.unit +def test_range_exprs_to_hoc_step_scaler(): + """ephys.create_hoc: Test range_exprs_to_hoc with step scaler""" + # apical_region = ArbLabel("region", "apic", "(tag 4)") + apical_location = NrnSomaDistanceCompLocation( + name='apic100', + soma_distance=100, + seclist_name='apical', + ) + param_scaler = NrnSegmentSomaDistanceStepScaler( + name='soma-distance-step-scaler', + distribution='{value} * (0.1 + 0.9 * int(' + '({distance} > {step_begin}) & (' + '{distance} < {step_end})))', + step_begin=300, + step_end=500) + + range_expr = create_hoc.RangeExpr( + location=apical_location, + name="gCa_LVAstbar_Ca_LVAst", + value=1, + value_scaler=param_scaler + ) + + hoc = create_hoc.range_exprs_to_hoc([range_expr]) + assert hoc[0].param_name == 'gCa_LVAstbar_Ca_LVAst' + val_gt = '1 * (0.1 + 0.9 * int((%.17g > 300) && (%.17g < 500)))' + assert hoc[0].value == val_gt diff --git a/bluepyopt/tests/test_ephys/test_locations.py b/bluepyopt/tests/test_ephys/test_locations.py index 28868742..cef6c78b 100644 --- a/bluepyopt/tests/test_ephys/test_locations.py +++ b/bluepyopt/tests/test_ephys/test_locations.py @@ -21,8 +21,8 @@ # pylint:disable=W0612, W0201 import json -import numpy as np +import numpy as np import pytest from bluepyopt import ephys @@ -33,27 +33,24 @@ def test_location_init(): """ephys.locations: test if Location works""" - loc = ephys.locations.Location('test') + loc = ephys.locations.Location("test") assert isinstance(loc, ephys.locations.Location) - assert loc.name == 'test' + assert loc.name == "test" @pytest.mark.unit class TestNrnSectionCompLocation(object): - """Test class for NrnSectionCompLocation""" - def setup(self): + def setup_method(self): """Setup""" self.loc = ephys.locations.NrnSectionCompLocation( - name='test', - sec_name='soma[0]', - comp_x=0.5) + name="test", sec_name="soma[0]", comp_x=0.5 + ) self.loc_dend = ephys.locations.NrnSectionCompLocation( - name='test', - sec_name='dend[1]', - comp_x=0.5) - assert self.loc.name == 'test' + name="test", sec_name="dend[1]", comp_x=0.5 + ) + assert self.loc.name == "test" self.sim = ephys.simulators.NrnSimulator() def test_instantiate(self): @@ -61,13 +58,14 @@ def test_instantiate(self): # Create a little test class with a soma and two dendritic sections class Cell(object): - """Cell class""" + pass + cell = Cell() soma = self.sim.neuron.h.Section() - dend1 = self.sim.neuron.h.Section(name='dend1') - dend2 = self.sim.neuron.h.Section(name='dend2') + dend1 = self.sim.neuron.h.Section(name="dend1") + dend2 = self.sim.neuron.h.Section(name="dend2") cell.soma = [soma] cell.dend = [dend1, dend2] @@ -81,22 +79,17 @@ class Cell(object): @pytest.mark.unit class TestNrnSeclistCompLocation(object): - """Test class for NrnSectionCompLocation""" - def setup(self): + def setup_method(self): """Setup""" self.loc = ephys.locations.NrnSeclistCompLocation( - name='test', - seclist_name='somatic', - sec_index=0, - comp_x=0.5) + name="test", seclist_name="somatic", sec_index=0, comp_x=0.5 + ) self.loc_dend = ephys.locations.NrnSeclistCompLocation( - name='test', - seclist_name='basal', - sec_index=1, - comp_x=0.5) - assert self.loc.name == 'test' + name="test", seclist_name="basal", sec_index=1, comp_x=0.5 + ) + assert self.loc.name == "test" self.sim = ephys.simulators.NrnSimulator() def test_instantiate(self): @@ -105,12 +98,13 @@ def test_instantiate(self): # Create a little test class with a soma and two dendritic sections class Cell(object): """Cell class""" + pass cell = Cell() soma = self.sim.neuron.h.Section() - dend1 = self.sim.neuron.h.Section(name='dend1') - dend2 = self.sim.neuron.h.Section(name='dend2') + dend1 = self.sim.neuron.h.Section(name="dend1") + dend2 = self.sim.neuron.h.Section(name="dend2") cell.somatic = self.sim.neuron.h.SectionList() cell.somatic.append(soma) @@ -130,20 +124,17 @@ class Cell(object): @pytest.mark.unit class TestNrnSeclistSecLocation(object): - """Test class for NrnSeclistSecLocation""" - def setup(self): + def setup_method(self): """Setup""" self.loc = ephys.locations.NrnSeclistSecLocation( - name='test', - seclist_name='somatic', - sec_index=0) + name="test", seclist_name="somatic", sec_index=0 + ) self.loc_dend = ephys.locations.NrnSeclistSecLocation( - name='test', - seclist_name='basal', - sec_index=1) - assert self.loc.name == 'test' + name="test", seclist_name="basal", sec_index=1 + ) + assert self.loc.name == "test" self.sim = ephys.simulators.NrnSimulator() def test_instantiate(self): @@ -152,12 +143,13 @@ def test_instantiate(self): # Create a little test class with a soma and two dendritic sections class Cell(object): """Cell class""" + pass cell = Cell() soma = self.sim.neuron.h.Section() - dend1 = self.sim.neuron.h.Section(name='dend1') - dend2 = self.sim.neuron.h.Section(name='dend2') + dend1 = self.sim.neuron.h.Section(name="dend1") + dend2 = self.sim.neuron.h.Section(name="dend2") cell.somatic = self.sim.neuron.h.SectionList() cell.somatic.append(soma) @@ -174,16 +166,14 @@ class Cell(object): @pytest.mark.unit class TestNrnSomaDistanceCompLocation(object): - """Test class for NrnSomaDistanceCompLocation""" - def setup(self): + def setup_method(self): """Setup""" self.loc = ephys.locations.NrnSomaDistanceCompLocation( - 'test', - 125, - 'testdend') - assert self.loc.name == 'test' + "test", 125, "testdend" + ) + assert self.loc.name == "test" self.sim = ephys.simulators.NrnSimulator() def test_instantiate(self): @@ -191,23 +181,26 @@ def test_instantiate(self): # Create a little test class with a soma and two dendritic sections class Cell(object): - """Cell class""" + pass + cell = Cell() soma = self.sim.neuron.h.Section() cell.soma = [soma] cell.testdend = self.sim.neuron.h.SectionList() - dend1 = self.sim.neuron.h.Section(name='dend1') - dend2 = self.sim.neuron.h.Section(name='dend2') + dend1 = self.sim.neuron.h.Section(name="dend1") + dend2 = self.sim.neuron.h.Section(name="dend2") cell.testdend.append(sec=dend1) cell.testdend.append(sec=dend2) - pytest.raises(ephys.locations.EPhysLocInstantiateException, - self.loc.instantiate, - sim=self.sim, - icell=cell) + pytest.raises( + ephys.locations.EPhysLocInstantiateException, + self.loc.instantiate, + sim=self.sim, + icell=cell, + ) dend1.connect(soma(0.5), 0.0) dend2.connect(dend1(1.0), 0.0) @@ -218,22 +211,17 @@ class Cell(object): @pytest.mark.unit class TestNrnSecSomaDistanceCompLocation(object): - """Test class for NrnSecSomaDistanceCompLocation""" - def setup(self): + def setup_method(self): """Setup""" self.loc = ephys.locations.NrnSecSomaDistanceCompLocation( - 'test', - 125, - 1, - 'testdend') + "test", 125, 1, "testdend" + ) self.loc_other = ephys.locations.NrnSecSomaDistanceCompLocation( - 'test', - 250, - 4, - 'testdend') - assert self.loc.name == 'test' + "test", 250, 4, "testdend" + ) + assert self.loc.name == "test" self.sim = ephys.simulators.NrnSimulator() def test_instantiate(self): @@ -241,18 +229,19 @@ def test_instantiate(self): # Create a little test class with a soma and two dendritic sections class Cell(object): - """Cell class""" + pass + cell = Cell() soma = self.sim.neuron.h.Section(name="soma[0]") cell.soma = [soma] cell.testdend = self.sim.neuron.h.SectionList() - dend1 = self.sim.neuron.h.Section(name='dend[0]') - dend2 = self.sim.neuron.h.Section(name='dend[1]') - dend3 = self.sim.neuron.h.Section(name='dend[2]') - dend4 = self.sim.neuron.h.Section(name='dend[3]') - dend5 = self.sim.neuron.h.Section(name='dend[4]') + dend1 = self.sim.neuron.h.Section(name="dend[0]") + dend2 = self.sim.neuron.h.Section(name="dend[1]") + dend3 = self.sim.neuron.h.Section(name="dend[2]") + dend4 = self.sim.neuron.h.Section(name="dend[3]") + dend5 = self.sim.neuron.h.Section(name="dend[4]") cell.testdend.append(sec=dend1) cell.testdend.append(sec=dend2) @@ -274,21 +263,18 @@ class Cell(object): @pytest.mark.unit class TestNrnTrunkSomaDistanceCompLocation(object): - """Test class for NrnTrunkSomaDistanceCompLocation""" - def setup(self): + def setup_method(self): """Setup""" self.loc = ephys.locations.NrnTrunkSomaDistanceCompLocation( - 'test', - soma_distance=150, - seclist_name='testdend') + "test", soma_distance=150, seclist_name="testdend" + ) self.loc_other = ephys.locations.NrnTrunkSomaDistanceCompLocation( - 'test', - soma_distance=350, - seclist_name='testdend') + "test", soma_distance=350, seclist_name="testdend" + ) - assert self.loc.name == 'test' + assert self.loc.name == "test" self.sim = ephys.simulators.NrnSimulator() def test_instantiate(self): @@ -296,18 +282,19 @@ def test_instantiate(self): # Create a little test class with a soma and two dendritic sections class Cell(object): - """Cell class""" + pass + cell = Cell() soma = self.sim.neuron.h.Section(name="soma[0]") cell.soma = [soma] cell.testdend = self.sim.neuron.h.SectionList() - dend1 = self.sim.neuron.h.Section(name='dend[0]') - dend2 = self.sim.neuron.h.Section(name='dend[1]') - dend3 = self.sim.neuron.h.Section(name='dend[2]') - dend4 = self.sim.neuron.h.Section(name='dend[3]') - dend5 = self.sim.neuron.h.Section(name='dend[4]') + dend1 = self.sim.neuron.h.Section(name="dend[0]") + dend2 = self.sim.neuron.h.Section(name="dend[1]") + dend3 = self.sim.neuron.h.Section(name="dend[2]") + dend4 = self.sim.neuron.h.Section(name="dend[3]") + dend5 = self.sim.neuron.h.Section(name="dend[4]") cell.testdend.append(sec=dend1) cell.testdend.append(sec=dend2) @@ -348,18 +335,22 @@ def test_serialize(): NrnSeclistCompLocation, NrnSeclistLocation, NrnSeclistSecLocation, - NrnSomaDistanceCompLocation) + NrnSomaDistanceCompLocation, + ) - seclist_name, sec_index, comp_x, soma_distance = 'somatic', 0, 0.5, 800 + seclist_name, sec_index, comp_x, soma_distance = "somatic", 0, 0.5, 800 locations = ( - NrnSeclistCompLocation('NrnSeclistCompLocation', - seclist_name, sec_index, comp_x), - NrnSeclistLocation( - 'NrnSeclistLocation', seclist_name), + NrnSeclistCompLocation( + "NrnSeclistCompLocation", seclist_name, sec_index, comp_x + ), + NrnSeclistLocation("NrnSeclistLocation", seclist_name), NrnSeclistSecLocation( - 'NrnSeclistSecLocation', seclist_name, sec_index), + "NrnSeclistSecLocation", seclist_name, sec_index + ), NrnSomaDistanceCompLocation( - 'NrnSomaDistanceCompLocation', soma_distance, seclist_name),) + "NrnSomaDistanceCompLocation", soma_distance, seclist_name + ), + ) for loc in locations: serialized = loc.to_dict() diff --git a/bluepyopt/tests/test_ephys/test_parameterscalers.py b/bluepyopt/tests/test_ephys/test_parameterscalers.py index 7d0380e9..846bf023 100644 --- a/bluepyopt/tests/test_ephys/test_parameterscalers.py +++ b/bluepyopt/tests/test_ephys/test_parameterscalers.py @@ -51,6 +51,22 @@ def test_NrnSegmentSectionDistanceScaler_eval_dist_with_dict(): == '0.5 + (1 - (abs(10 - 8) / 4)) * 1') +@pytest.mark.unit +def test_NrnSegmentSomaDistanceStepScaler_eval_dist_with_dict(): + """ephys.parameterscalers: eval_dist of NrnSegmentSomaDistanceStepScaler""" + + dist = '{value} * (0.1 + 0.9 * int(' \ + '({distance} > {step_begin}) & ({distance} < {step_end})))' + + scaler = ephys.parameterscalers.NrnSegmentSomaDistanceStepScaler( + distribution=dist, step_begin=300, step_end=500) + + _values = {'value': 1} + + assert (scaler.eval_dist(values=_values, distance=10) + == '1 * (0.1 + 0.9 * int((10 > 300) & (10 < 500)))') + + @pytest.mark.unit def test_serialize(): """ephys.parameterscalers: test serialization""" diff --git a/bluepyopt/tests/test_ephys/test_simulators.py b/bluepyopt/tests/test_ephys/test_simulators.py index f35fd006..4e4203f5 100644 --- a/bluepyopt/tests/test_ephys/test_simulators.py +++ b/bluepyopt/tests/test_ephys/test_simulators.py @@ -22,13 +22,12 @@ # pylint:disable=W0612 import os +import pathlib import types - -import pytest -import numpy - from unittest import mock + import numpy +import pytest import bluepyopt.ephys as ephys import bluepyopt.ephys.examples as examples @@ -46,7 +45,7 @@ def test_nrnsimulator_init(): def test_nrnsimulator_init_windows(): """ephys.simulators: test if NrnSimulator constructor works on Windows""" - with mock.patch('platform.system', mock.MagicMock(return_value="Windows")): + with mock.patch("platform.system", mock.MagicMock(return_value="Windows")): neuron_sim = ephys.simulators.NrnSimulator() assert isinstance(neuron_sim, ephys.simulators.NrnSimulator) assert not neuron_sim.disable_banner @@ -69,9 +68,9 @@ def test_nrnsimulator_cvode_minstep(): # Check default minstep before and after run neuron_sim = ephys.simulators.NrnSimulator(cvode_minstep=0.01) - assert neuron_sim.cvode.minstep() == 0. + assert neuron_sim.cvode.minstep() == 0.0 neuron_sim.run(tstop=10) - assert neuron_sim.cvode.minstep() == 0. + assert neuron_sim.cvode.minstep() == 0.0 # Check with that minstep is set back to the original value after run neuron_sim = ephys.simulators.NrnSimulator(cvode_minstep=0.0) @@ -82,20 +81,26 @@ def test_nrnsimulator_cvode_minstep(): # Check that the minstep is effective cvode_minstep = 0.012 - params = {'gnabar_hh': 0.10299326453483033, - 'gkbar_hh': 0.027124836082684685} + params = { + "gnabar_hh": 0.10299326453483033, + "gkbar_hh": 0.027124836082684685, + } simplecell = examples.simplecell.SimpleCell() evaluator = simplecell.cell_evaluator evaluator.cell_model.unfreeze(params.keys()) evaluator.sim = ephys.simulators.NrnSimulator(cvode_minstep=cvode_minstep) responses = evaluator.run_protocols( - protocols=evaluator.fitness_protocols.values(), - param_values=params) + protocols=evaluator.fitness_protocols.values(), param_values=params + ) ton = list(evaluator.fitness_protocols.values())[0].stimuli[0].step_delay - toff = ton + list(evaluator.fitness_protocols.values())[0].stimuli[ - 0].step_duration - t_series = numpy.array(responses['Step1.soma.v']['time']) - t_series = t_series[((ton + 1.) < t_series) & (t_series < (toff - 1.))] + toff = ( + ton + + list(evaluator.fitness_protocols.values())[0] + .stimuli[0] + .step_duration + ) + t_series = numpy.array(responses["Step1.soma.v"]["time"]) + t_series = t_series[((ton + 1.0) < t_series) & (t_series < (toff - 1.0))] min_dt = numpy.min(numpy.ediff1d(t_series)) assert (min_dt >= cvode_minstep) == 1 evaluator.cell_model.freeze(params) @@ -105,6 +110,7 @@ def test_nrnsimulator_cvode_minstep(): def test_neuron_import(): """ephys.simulators: test if bluepyopt.neuron import was successful""" from bluepyopt import ephys # NOQA + neuron_sim = ephys.simulators.NrnSimulator() assert isinstance(neuron_sim.neuron, types.ModuleType) @@ -114,6 +120,7 @@ def test_nrnsim_run_dt_exception(): """ephys.simulators: test if run return exception when dt was changed""" from bluepyopt import ephys # NOQA + neuron_sim = ephys.simulators.NrnSimulator() neuron_sim.neuron.h.dt = 1.0 pytest.raises(Exception, neuron_sim.run, 10, cvode_active=False) @@ -124,18 +131,20 @@ def test_nrnsim_run_cvodeactive_dt_exception(): """ephys.simulators: test if run return exception cvode and dt both used""" from bluepyopt import ephys # NOQA + neuron_sim = ephys.simulators.NrnSimulator() neuron_sim.neuron.h.dt = 1.0 pytest.raises(ValueError, neuron_sim.run, 10, dt=0.1, cvode_active=True) @pytest.mark.unit -@mock.patch('glob.glob') +@mock.patch.object(pathlib.Path, "glob") def test_disable_banner_exception(mock_glob): """ephys.simulators: test if disable_banner raises exception""" mock_glob.return_value = [] import warnings + with warnings.catch_warnings(record=True) as warnings_record: ephys.simulators.NrnSimulator._nrn_disable_banner() assert len(warnings_record) == 1 @@ -154,7 +163,7 @@ def test_lfpysimulator_init(): def test_lfpyimulator_init_windows(): """ephys.simulators: test if LFPySimulator constructor works on Windows""" - with mock.patch('platform.system', mock.MagicMock(return_value="Windows")): + with mock.patch("platform.system", mock.MagicMock(return_value="Windows")): empty_cell = ephys.models.LFPyCellModel(name="empty_cell") neuron_sim = ephys.simulators.LFPySimulator() assert isinstance(neuron_sim, ephys.simulators.LFPySimulator) @@ -171,6 +180,7 @@ def test_lfpyimulator_init_windows(): def test__lfpysimulator_neuron_import(): """ephys.simulators: test neuron import from LFPySimulator""" from bluepyopt import ephys # NOQA + empty_cell = ephys.models.LFPyCellModel(name="empty_cell") neuron_sim = ephys.simulators.LFPySimulator() assert isinstance(neuron_sim.neuron, types.ModuleType) @@ -181,10 +191,11 @@ def test_lfpysim_run_cvodeactive_dt_exception(): """ephys.simulators: test if LFPySimulator run returns exception""" from bluepyopt import ephys # NOQA + TESTDATA_DIR = os.path.join( - os.path.dirname(os.path.abspath(__file__)), 'testdata' + os.path.dirname(os.path.abspath(__file__)), "testdata" ) - simple_morphology_path = os.path.join(TESTDATA_DIR, 'simple.swc') + simple_morphology_path = os.path.join(TESTDATA_DIR, "simple.swc") test_morph = ephys.morphologies.NrnFileMorphology(simple_morphology_path) lfpy_cell = ephys.models.LFPyCellModel( @@ -196,9 +207,9 @@ def test_lfpysim_run_cvodeactive_dt_exception(): with pytest.raises( ValueError, match=( - 'NrnSimulator: ' - 'Impossible to combine the dt argument when ' - 'cvode_active is True in the NrnSimulator run method' + "NrnSimulator: " + "Impossible to combine the dt argument when " + "cvode_active is True in the NrnSimulator run method" ), ): neuron_sim.run( @@ -206,19 +217,20 @@ def test_lfpysim_run_cvodeactive_dt_exception(): dt=0.1, cvode_active=True, lfpy_cell=lfpy_cell.lfpy_cell, - lfpy_electrode=lfpy_cell.lfpy_electrode + lfpy_electrode=lfpy_cell.lfpy_electrode, ) lfpy_cell.destroy(sim=neuron_sim) @pytest.mark.unit -@mock.patch('glob.glob') +@mock.patch.object(pathlib.Path, "glob") def test_lfpysimulator_disable_banner_exception(mock_glob): """ephys.simulators: test LFPySimulator disable_banner raises exception""" mock_glob.return_value = [] import warnings + with warnings.catch_warnings(record=True) as warnings_record: ephys.simulators.LFPySimulator._nrn_disable_banner() assert len(warnings_record) == 1 diff --git a/bluepyopt/tests/test_l5pc.py b/bluepyopt/tests/test_l5pc.py index b6e3fc8a..ddc76883 100644 --- a/bluepyopt/tests/test_l5pc.py +++ b/bluepyopt/tests/test_l5pc.py @@ -3,8 +3,11 @@ import json import os import sys - from contextlib import contextmanager + +import bluepyopt +from bluepyopt import ephys + if sys.version_info[0] < 3: from StringIO import StringIO else: @@ -13,45 +16,43 @@ import pytest -L5PC_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), - '../../examples/l5pc')) +L5PC_PATH = os.path.abspath( + os.path.join(os.path.dirname(__file__), "../../examples/l5pc") +) SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) sys.path.insert(0, L5PC_PATH) -import bluepyopt -from bluepyopt import ephys neuron_sim = ephys.simulators.NrnSimulator() neuron_sim.neuron.h.nrn_load_dll( - os.path.join( - L5PC_PATH, - 'x86_64/.libs/libnrnmech.so')) + os.path.join(L5PC_PATH, "x86_64/.libs/libnrnmech.so") +) # Parameters in release circuit model release_parameters = { - 'gNaTs2_tbar_NaTs2_t.apical': 0.026145, - 'gSKv3_1bar_SKv3_1.apical': 0.004226, - 'gImbar_Im.apical': 0.000143, - 'gNaTa_tbar_NaTa_t.axonal': 3.137968, - 'gK_Tstbar_K_Tst.axonal': 0.089259, - 'gamma_CaDynamics_E2.axonal': 0.002910, - 'gNap_Et2bar_Nap_Et2.axonal': 0.006827, - 'gSK_E2bar_SK_E2.axonal': 0.007104, - 'gCa_HVAbar_Ca_HVA.axonal': 0.000990, - 'gK_Pstbar_K_Pst.axonal': 0.973538, - 'gSKv3_1bar_SKv3_1.axonal': 1.021945, - 'decay_CaDynamics_E2.axonal': 287.198731, - 'gCa_LVAstbar_Ca_LVAst.axonal': 0.008752, - 'gamma_CaDynamics_E2.somatic': 0.000609, - 'gSKv3_1bar_SKv3_1.somatic': 0.303472, - 'gSK_E2bar_SK_E2.somatic': 0.008407, - 'gCa_HVAbar_Ca_HVA.somatic': 0.000994, - 'gNaTs2_tbar_NaTs2_t.somatic': 0.983955, - 'decay_CaDynamics_E2.somatic': 210.485284, - 'gCa_LVAstbar_Ca_LVAst.somatic': 0.000333 + "gNaTs2_tbar_NaTs2_t.apical": 0.026145, + "gSKv3_1bar_SKv3_1.apical": 0.004226, + "gImbar_Im.apical": 0.000143, + "gNaTa_tbar_NaTa_t.axonal": 3.137968, + "gK_Tstbar_K_Tst.axonal": 0.089259, + "gamma_CaDynamics_E2.axonal": 0.002910, + "gNap_Et2bar_Nap_Et2.axonal": 0.006827, + "gSK_E2bar_SK_E2.axonal": 0.007104, + "gCa_HVAbar_Ca_HVA.axonal": 0.000990, + "gK_Pstbar_K_Pst.axonal": 0.973538, + "gSKv3_1bar_SKv3_1.axonal": 1.021945, + "decay_CaDynamics_E2.axonal": 287.198731, + "gCa_LVAstbar_Ca_LVAst.axonal": 0.008752, + "gamma_CaDynamics_E2.somatic": 0.000609, + "gSKv3_1bar_SKv3_1.somatic": 0.303472, + "gSK_E2bar_SK_E2.somatic": 0.008407, + "gCa_HVAbar_Ca_HVA.somatic": 0.000994, + "gNaTs2_tbar_NaTs2_t.somatic": 0.983955, + "decay_CaDynamics_E2.somatic": 210.485284, + "gCa_LVAstbar_Ca_LVAst.somatic": 0.000333, } @@ -65,8 +66,8 @@ def load_from_json(filename): def dump_to_json(content, filename): """Dump structure to json""" - with open(filename, 'w') as json_file: - return json.dump(content, json_file, indent=4, separators=(',', ': ')) + with open(filename, "w") as json_file: + return json.dump(content, json_file, indent=4, separators=(",", ": ")) def test_import(): @@ -78,17 +79,16 @@ def test_import(): class TestL5PCModel(object): - """Test L5PC model""" - def setup(self): + def setup_method(self): """Set up class""" sys.path.insert(0, L5PC_PATH) import l5pc_model # NOQA + self.l5pc_cell = l5pc_model.create() - assert isinstance(self.l5pc_cell, - bluepyopt.ephys.models.CellModel) + assert isinstance(self.l5pc_cell, bluepyopt.ephys.models.CellModel) self.nrn = ephys.simulators.NrnSimulator() def test_instantiate(self): @@ -96,42 +96,45 @@ def test_instantiate(self): self.l5pc_cell.freeze(release_parameters) self.l5pc_cell.instantiate(sim=self.nrn) - def teardown(self): + def teardown_method(self): """Teardown""" self.l5pc_cell.destroy(sim=self.nrn) class TestL5PCEvaluator(object): - """Test L5PC evaluator""" - def setup(self): + def setup_method(self): """Set up class""" import l5pc_evaluator # NOQA self.l5pc_evaluator = l5pc_evaluator.create() - assert isinstance(self.l5pc_evaluator, - bluepyopt.ephys.evaluators.CellEvaluator) + assert isinstance( + self.l5pc_evaluator, bluepyopt.ephys.evaluators.CellEvaluator + ) @pytest.mark.slow def test_eval(self): """L5PC: test evaluation of l5pc evaluator""" result = self.l5pc_evaluator.evaluate_with_dicts( - param_dict=release_parameters) + param_dict=release_parameters + ) expected_results = load_from_json( - os.path.join(SCRIPT_DIR, 'expected_results.json')) + os.path.join(SCRIPT_DIR, "expected_results.json") + ) # Use two lines below to update expected result # expected_results['TestL5PCEvaluator.test_eval'] = result # dump_to_json(expected_results, 'expected_results.json') - assert set(result.keys( - )) == set(expected_results['TestL5PCEvaluator.test_eval'].keys()) + assert set(result.keys()) == set( + expected_results["TestL5PCEvaluator.test_eval"].keys() + ) - def teardown(self): + def teardown_method(self): """Teardown""" pass @@ -152,7 +155,8 @@ def stdout_redirector(stream): def test_exec(): """L5PC Notebook: test execution""" import numpy - numpy.seterr(all='raise') + + numpy.seterr(all="raise") old_cwd = os.getcwd() output = StringIO() try: @@ -162,14 +166,14 @@ def test_exec(): # Probably because multiprocessing doesn't work correctly during # import if sys.version_info[0] < 3: - execfile('L5PC.py') # NOQA + execfile("L5PC.py") # NOQA else: - with open('L5PC.py') as l5pc_file: - exec(compile(l5pc_file.read(), 'L5PC.py', 'exec')) # NOQA + with open("L5PC.py") as l5pc_file: + exec(compile(l5pc_file.read(), "L5PC.py", "exec")) # NOQA stdout = output.getvalue() # first and last values of optimal individual - assert '0.001017834439738432' in stdout - assert '202.18814057682334' in stdout + assert "0.001017834439738432" in stdout + assert "202.18814057682334" in stdout assert "'gamma_CaDynamics_E2.somatic': 0.03229357096515606" in stdout finally: os.chdir(old_cwd) @@ -180,7 +184,8 @@ def test_exec(): def test_l5pc_validate_neuron_arbor(): """L5PC Neuron/Arbor validation Notebook: test execution""" import numpy - numpy.seterr(all='raise') + + numpy.seterr(all="raise") old_cwd = os.getcwd() output = StringIO() try: @@ -190,19 +195,28 @@ def test_l5pc_validate_neuron_arbor(): # Probably because multiprocessing doesn't work correctly during # import if sys.version_info[0] < 3: - execfile('l5pc_validate_neuron_arbor_somatic.py') # NOQA + execfile("l5pc_validate_neuron_arbor_somatic.py") # NOQA else: - with open('l5pc_validate_neuron_arbor_somatic.py') \ - as l5pc_file: + with open( + "l5pc_validate_neuron_arbor_somatic.py" + ) as l5pc_file: l5pc_globals = {} - exec(compile(l5pc_file.read(), - 'l5pc_validate_neuron_arbor_somatic.py', - 'exec'), l5pc_globals, l5pc_globals) # NOQA + exec( + compile( + l5pc_file.read(), + "l5pc_validate_neuron_arbor_somatic.py", + "exec", + ), + l5pc_globals, + l5pc_globals, + ) # NOQA stdout = output.getvalue() # mean relative L1-deviation between Arbor and Neuron below tolerance - assert 'Default dt ({:,.3g}): test_l5pc OK!'.format(0.025) + \ - ' The mean relative Arbor-Neuron L1-deviation and error' \ + assert ( + "Default dt ({:,.3g}): test_l5pc OK!".format(0.025) + + " The mean relative Arbor-Neuron L1-deviation and error" in stdout + ) finally: os.chdir(old_cwd) output.close() diff --git a/bluepyopt/tests/test_lfpy.py b/bluepyopt/tests/test_lfpy.py index c141e7f6..746b4bb3 100644 --- a/bluepyopt/tests/test_lfpy.py +++ b/bluepyopt/tests/test_lfpy.py @@ -2,13 +2,11 @@ import os import sys + import pytest L5PC_LFPY_PATH = os.path.abspath( - os.path.join( - os.path.dirname(__file__), - '../../examples/l5pc_lfpy' - ) + os.path.join(os.path.dirname(__file__), "../../examples/l5pc_lfpy") ) SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) @@ -30,10 +28,10 @@ def test_lfpy_evaluator(): responses = evaluator.run_protocols( protocols=evaluator.fitness_protocols.values(), - param_values=release_params + param_values=release_params, ) values = evaluator.fitness_calculator.calculate_values(responses) assert len(values) == 21 - assert abs(values['Step1.soma.AP_height'] - 27.85963902931001) < 1e-5 - assert len(responses['Step1.MEA.v']["voltage"]) == 40 + assert abs(values["Step1.soma.AP_height"] - 27.85963902931001) < 1e-5 + assert len(responses["Step1.MEA.v"]["voltage"]) == 40 diff --git a/bluepyopt/tests/test_simplecell.py b/bluepyopt/tests/test_simplecell.py index 93a6c564..394a9fbc 100644 --- a/bluepyopt/tests/test_simplecell.py +++ b/bluepyopt/tests/test_simplecell.py @@ -1,40 +1,38 @@ """Simple cell example test class""" -import sys import os +import sys -SIMPLECELL_PATH = os.path.abspath(os.path.join( - os.path.dirname(__file__), - '../../examples/simplecell')) +SIMPLECELL_PATH = os.path.abspath( + os.path.join(os.path.dirname(__file__), "../../examples/simplecell") +) # sys.path.insert(0, SIMPLECELL_PATH) class TestSimpleCellClass(object): - """Simple cell example test class for NEURON""" - def setup(self): + def setup_method(self): """Setup""" self.old_cwd = os.getcwd() self.old_stdout = sys.stdout os.chdir(SIMPLECELL_PATH) - sys.stdout = open(os.devnull, 'w') + sys.stdout = open(os.devnull, "w") - @staticmethod - def test_exec(): + def test_exec(self): """Simplecell NEURON: test execution""" # When using import instead of execfile this doesn't work # Probably because multiprocessing doesn't work correctly during # import if sys.version_info[0] < 3: - execfile('simplecell.py') # NOQA + execfile("simplecell.py") # NOQA else: - with open('simplecell.py') as sc_file: - exec(compile(sc_file.read(), 'simplecell.py', 'exec')) # NOQA + with open("simplecell.py") as sc_file: + exec(compile(sc_file.read(), "simplecell.py", "exec")) # NOQA - def teardown(self): + def teardown_method(self): """Tear down""" sys.stdout = self.old_stdout @@ -42,31 +40,28 @@ def teardown(self): class TestSimpleCellArborClass(object): - """Simple cell example test class for Arbor""" - def setup(self): + def setup_method(self): """Setup""" self.old_cwd = os.getcwd() self.old_stdout = sys.stdout os.chdir(SIMPLECELL_PATH) - sys.stdout = open(os.devnull, 'w') + sys.stdout = open(os.devnull, "w") - @staticmethod - def test_exec(): + def test_exec(self): """Simplecell Arbor: test execution""" # When using import instead of execfile this doesn't work # Probably because multiprocessing doesn't work correctly during # import if sys.version_info[0] < 3: - execfile('simplecell_arbor.py') # NOQA + execfile("simplecell_arbor.py") # NOQA else: - with open('simplecell_arbor.py') as sc_file: - exec(compile(sc_file.read(), - 'simplecell_arbor.py', 'exec')) # NOQA + with open("simplecell_arbor.py") as sc_file: + exec(compile(sc_file.read(), "simplecell_arbor.py", "exec")) # NOQA - def teardown(self): + def teardown_method(self): """Tear down""" sys.stdout = self.old_stdout diff --git a/examples/graupnerbrunelstdp/run_fit.py b/examples/graupnerbrunelstdp/run_fit.py index 2b1ae136..a677fa82 100644 --- a/examples/graupnerbrunelstdp/run_fit.py +++ b/examples/graupnerbrunelstdp/run_fit.py @@ -2,8 +2,6 @@ # pylint: disable=R0914 -from __future__ import print_function - import pickle import bluepyopt as bpop import matplotlib.pyplot as plt diff --git a/examples/l5pc/L5PC.ipynb b/examples/l5pc/L5PC.ipynb index 2a1b2d3b..9997e9ca 100644 --- a/examples/l5pc/L5PC.ipynb +++ b/examples/l5pc/L5PC.ipynb @@ -1,6 +1,7 @@ { "cells": [ { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -8,6 +9,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -31,6 +33,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -67,8 +70,6 @@ "%load_ext autoreload\n", "%autoreload\n", "\n", - "from __future__ import print_function\n", - "\n", "!nrnivmodl mechanisms\n", "import bluepyopt as bpopt\n", "import bluepyopt.ephys as ephys\n", @@ -81,6 +82,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -102,6 +104,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -109,6 +112,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -116,6 +120,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -158,758 +163,7 @@ }, { "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "window.mpl = {};\n", - "\n", - "mpl.get_websocket_type = function() {\n", - " if (typeof(WebSocket) !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof(MozWebSocket) !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert('Your browser does not have WebSocket support.' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.');\n", - " };\n", - "}\n", - "\n", - "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = (this.ws.binaryType != undefined);\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById(\"mpl-warnings\");\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent = (\n", - " \"This browser does not support binary websocket messages. \" +\n", - " \"Performance may be slow.\");\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = $('
');\n", - " this._root_extra_style(this.root)\n", - " this.root.attr('style', 'display: inline-block');\n", - "\n", - " $(parent_element).append(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", - " fig.send_message(\"send_image_mode\", {});\n", - " fig.send_message(\"refresh\", {});\n", - " }\n", - "\n", - " this.imageObj.onload = function() {\n", - " if (fig.image_mode == 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function() {\n", - " this.ws.close();\n", - " }\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "}\n", - "\n", - "mpl.figure.prototype._init_header = function() {\n", - " var titlebar = $(\n", - " '
');\n", - " var titletext = $(\n", - " '
');\n", - " titlebar.append(titletext)\n", - " this.root.append(titlebar);\n", - " this.header = titletext[0];\n", - "}\n", - "\n", - "\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "mpl.figure.prototype._init_canvas = function() {\n", - " var fig = this;\n", - "\n", - " var canvas_div = $('
');\n", - "\n", - " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", - "\n", - " function canvas_keyboard_event(event) {\n", - " return fig.key_event(event, event['data']);\n", - " }\n", - "\n", - " canvas_div.keydown('key_press', canvas_keyboard_event);\n", - " canvas_div.keyup('key_release', canvas_keyboard_event);\n", - " this.canvas_div = canvas_div\n", - " this._canvas_extra_style(canvas_div)\n", - " this.root.append(canvas_div);\n", - "\n", - " var canvas = $('');\n", - " canvas.addClass('mpl-canvas');\n", - " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", - "\n", - " this.canvas = canvas[0];\n", - " this.context = canvas[0].getContext(\"2d\");\n", - "\n", - " var rubberband = $('');\n", - " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", - "\n", - " var pass_mouse_events = true;\n", - "\n", - " canvas_div.resizable({\n", - " start: function(event, ui) {\n", - " pass_mouse_events = false;\n", - " },\n", - " resize: function(event, ui) {\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " stop: function(event, ui) {\n", - " pass_mouse_events = true;\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " });\n", - "\n", - " function mouse_event_fn(event) {\n", - " if (pass_mouse_events)\n", - " return fig.mouse_event(event, event['data']);\n", - " }\n", - "\n", - " rubberband.mousedown('button_press', mouse_event_fn);\n", - " rubberband.mouseup('button_release', mouse_event_fn);\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband.mousemove('motion_notify', mouse_event_fn);\n", - "\n", - " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", - " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", - "\n", - " canvas_div.on(\"wheel\", function (event) {\n", - " event = event.originalEvent;\n", - " event['data'] = 'scroll'\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " mouse_event_fn(event);\n", - " });\n", - "\n", - " canvas_div.append(canvas);\n", - " canvas_div.append(rubberband);\n", - "\n", - " this.rubberband = rubberband;\n", - " this.rubberband_canvas = rubberband[0];\n", - " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", - " this.rubberband_context.strokeStyle = \"#000000\";\n", - "\n", - " this._resize_canvas = function(width, height) {\n", - " // Keep the size of the canvas, canvas container, and rubber band\n", - " // canvas in synch.\n", - " canvas_div.css('width', width)\n", - " canvas_div.css('height', height)\n", - "\n", - " canvas.attr('width', width);\n", - " canvas.attr('height', height);\n", - "\n", - " rubberband.attr('width', width);\n", - " rubberband.attr('height', height);\n", - " }\n", - "\n", - " // Set the figure to an initial 600x600px, this will subsequently be updated\n", - " // upon first draw.\n", - " this._resize_canvas(600, 600);\n", - "\n", - " // Disable right mouse context menu.\n", - " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", - " return false;\n", - " });\n", - "\n", - " function set_focus () {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "}\n", - "\n", - "mpl.figure.prototype._init_toolbar = function() {\n", - " var fig = this;\n", - "\n", - " var nav_element = $('
')\n", - " nav_element.attr('style', 'width: 100%');\n", - " this.root.append(nav_element);\n", - "\n", - " // Define a callback function for later on.\n", - " function toolbar_event(event) {\n", - " return fig.toolbar_button_onclick(event['data']);\n", - " }\n", - " function toolbar_mouse_event(event) {\n", - " return fig.toolbar_button_onmouseover(event['data']);\n", - " }\n", - "\n", - " for(var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " // put a spacer in here.\n", - " continue;\n", - " }\n", - " var button = $('');\n button.click(method_name, toolbar_event);\n button.mouseover(tooltip, toolbar_mouse_event);\n nav_element.append(button);\n }\n\n // Add the status bar.\n var status_bar = $('');\n nav_element.append(status_bar);\n this.message = status_bar[0];\n\n // Add the close button to the window.\n var buttongrp = $('
');\n var button = $('');\n button.click(function (evt) { fig.handle_close(fig, {}); } );\n button.mouseover('Stop Interaction', toolbar_mouse_event);\n buttongrp.append(button);\n var titlebar = this.root.find($('.ui-dialog-titlebar'));\n titlebar.prepend(buttongrp);\n}\n\nmpl.figure.prototype._root_extra_style = function(el){\n var fig = this\n el.on(\"remove\", function(){\n\tfig.close_ws(fig, {});\n });\n}\n\nmpl.figure.prototype._canvas_extra_style = function(el){\n // this is important to make the div 'focusable\n el.attr('tabindex', 0)\n // reach out to IPython and tell the keyboard manager to turn it's self\n // off when our div gets focus\n\n // location in version 3\n if (IPython.notebook.keyboard_manager) {\n IPython.notebook.keyboard_manager.register_events(el);\n }\n else {\n // location in version 2\n IPython.keyboard_manager.register_events(el);\n }\n\n}\n\nmpl.figure.prototype._key_event_extra = function(event, name) {\n var manager = IPython.notebook.keyboard_manager;\n if (!manager)\n manager = IPython.keyboard_manager;\n\n // Check for shift+enter\n if (event.shiftKey && event.which == 13) {\n this.canvas_div.blur();\n // select the cell after this one\n var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n IPython.notebook.select(index + 1);\n }\n}\n\nmpl.figure.prototype.handle_save = function(fig, msg) {\n fig.ondownload(fig, null);\n}\n\n\nmpl.find_output_cell = function(html_output) {\n // Return the cell and output element which can be found *uniquely* in the notebook.\n // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n // IPython event is triggered only after the cells have been serialised, which for\n // our purposes (turning an active figure into a static one), is too late.\n var cells = IPython.notebook.get_cells();\n var ncells = cells.length;\n for (var i=0; i= 3 moved mimebundle to data attribute of output\n data = data.data;\n }\n if (data['text/html'] == html_output) {\n return [cell, data, j];\n }\n }\n }\n }\n}\n\n// Register the function which deals with the matplotlib target/channel.\n// The kernel may be null if the page has been refreshed.\nif (IPython.notebook.kernel != null) {\n IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n}\n", "text/plain": [ "" ] @@ -963,6 +217,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -990,6 +245,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -997,6 +253,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -1025,6 +282,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -1089,6 +347,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -1096,6 +355,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -1103,6 +363,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -1152,6 +413,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -1159,6 +421,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -1250,6 +513,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -1269,6 +533,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -1276,6 +541,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -1303,6 +569,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -1359,6 +626,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -1366,6 +634,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -1482,6 +751,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": { "collapsed": true @@ -1491,6 +761,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -1509,6 +780,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -1516,6 +788,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -1539,6 +812,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -1578,6 +852,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -1596,6 +871,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -1611,758 +887,7 @@ "outputs": [ { "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "window.mpl = {};\n", - "\n", - "mpl.get_websocket_type = function() {\n", - " if (typeof(WebSocket) !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof(MozWebSocket) !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert('Your browser does not have WebSocket support.' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.');\n", - " };\n", - "}\n", - "\n", - "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = (this.ws.binaryType != undefined);\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById(\"mpl-warnings\");\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent = (\n", - " \"This browser does not support binary websocket messages. \" +\n", - " \"Performance may be slow.\");\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = $('
');\n", - " this._root_extra_style(this.root)\n", - " this.root.attr('style', 'display: inline-block');\n", - "\n", - " $(parent_element).append(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", - " fig.send_message(\"send_image_mode\", {});\n", - " fig.send_message(\"refresh\", {});\n", - " }\n", - "\n", - " this.imageObj.onload = function() {\n", - " if (fig.image_mode == 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function() {\n", - " this.ws.close();\n", - " }\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "}\n", - "\n", - "mpl.figure.prototype._init_header = function() {\n", - " var titlebar = $(\n", - " '
');\n", - " var titletext = $(\n", - " '
');\n", - " titlebar.append(titletext)\n", - " this.root.append(titlebar);\n", - " this.header = titletext[0];\n", - "}\n", - "\n", - "\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "mpl.figure.prototype._init_canvas = function() {\n", - " var fig = this;\n", - "\n", - " var canvas_div = $('
');\n", - "\n", - " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", - "\n", - " function canvas_keyboard_event(event) {\n", - " return fig.key_event(event, event['data']);\n", - " }\n", - "\n", - " canvas_div.keydown('key_press', canvas_keyboard_event);\n", - " canvas_div.keyup('key_release', canvas_keyboard_event);\n", - " this.canvas_div = canvas_div\n", - " this._canvas_extra_style(canvas_div)\n", - " this.root.append(canvas_div);\n", - "\n", - " var canvas = $('');\n", - " canvas.addClass('mpl-canvas');\n", - " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", - "\n", - " this.canvas = canvas[0];\n", - " this.context = canvas[0].getContext(\"2d\");\n", - "\n", - " var rubberband = $('');\n", - " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", - "\n", - " var pass_mouse_events = true;\n", - "\n", - " canvas_div.resizable({\n", - " start: function(event, ui) {\n", - " pass_mouse_events = false;\n", - " },\n", - " resize: function(event, ui) {\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " stop: function(event, ui) {\n", - " pass_mouse_events = true;\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " });\n", - "\n", - " function mouse_event_fn(event) {\n", - " if (pass_mouse_events)\n", - " return fig.mouse_event(event, event['data']);\n", - " }\n", - "\n", - " rubberband.mousedown('button_press', mouse_event_fn);\n", - " rubberband.mouseup('button_release', mouse_event_fn);\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband.mousemove('motion_notify', mouse_event_fn);\n", - "\n", - " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", - " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", - "\n", - " canvas_div.on(\"wheel\", function (event) {\n", - " event = event.originalEvent;\n", - " event['data'] = 'scroll'\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " mouse_event_fn(event);\n", - " });\n", - "\n", - " canvas_div.append(canvas);\n", - " canvas_div.append(rubberband);\n", - "\n", - " this.rubberband = rubberband;\n", - " this.rubberband_canvas = rubberband[0];\n", - " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", - " this.rubberband_context.strokeStyle = \"#000000\";\n", - "\n", - " this._resize_canvas = function(width, height) {\n", - " // Keep the size of the canvas, canvas container, and rubber band\n", - " // canvas in synch.\n", - " canvas_div.css('width', width)\n", - " canvas_div.css('height', height)\n", - "\n", - " canvas.attr('width', width);\n", - " canvas.attr('height', height);\n", - "\n", - " rubberband.attr('width', width);\n", - " rubberband.attr('height', height);\n", - " }\n", - "\n", - " // Set the figure to an initial 600x600px, this will subsequently be updated\n", - " // upon first draw.\n", - " this._resize_canvas(600, 600);\n", - "\n", - " // Disable right mouse context menu.\n", - " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", - " return false;\n", - " });\n", - "\n", - " function set_focus () {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "}\n", - "\n", - "mpl.figure.prototype._init_toolbar = function() {\n", - " var fig = this;\n", - "\n", - " var nav_element = $('
')\n", - " nav_element.attr('style', 'width: 100%');\n", - " this.root.append(nav_element);\n", - "\n", - " // Define a callback function for later on.\n", - " function toolbar_event(event) {\n", - " return fig.toolbar_button_onclick(event['data']);\n", - " }\n", - " function toolbar_mouse_event(event) {\n", - " return fig.toolbar_button_onmouseover(event['data']);\n", - " }\n", - "\n", - " for(var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " // put a spacer in here.\n", - " continue;\n", - " }\n", - " var button = $('');\n button.click(method_name, toolbar_event);\n button.mouseover(tooltip, toolbar_mouse_event);\n nav_element.append(button);\n }\n\n // Add the status bar.\n var status_bar = $('');\n nav_element.append(status_bar);\n this.message = status_bar[0];\n\n // Add the close button to the window.\n var buttongrp = $('
');\n var button = $('');\n button.click(function (evt) { fig.handle_close(fig, {}); } );\n button.mouseover('Stop Interaction', toolbar_mouse_event);\n buttongrp.append(button);\n var titlebar = this.root.find($('.ui-dialog-titlebar'));\n titlebar.prepend(buttongrp);\n}\n\nmpl.figure.prototype._root_extra_style = function(el){\n var fig = this\n el.on(\"remove\", function(){\n\tfig.close_ws(fig, {});\n });\n}\n\nmpl.figure.prototype._canvas_extra_style = function(el){\n // this is important to make the div 'focusable\n el.attr('tabindex', 0)\n // reach out to IPython and tell the keyboard manager to turn it's self\n // off when our div gets focus\n\n // location in version 3\n if (IPython.notebook.keyboard_manager) {\n IPython.notebook.keyboard_manager.register_events(el);\n }\n else {\n // location in version 2\n IPython.keyboard_manager.register_events(el);\n }\n\n}\n\nmpl.figure.prototype._key_event_extra = function(event, name) {\n var manager = IPython.notebook.keyboard_manager;\n if (!manager)\n manager = IPython.keyboard_manager;\n\n // Check for shift+enter\n if (event.shiftKey && event.which == 13) {\n this.canvas_div.blur();\n // select the cell after this one\n var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n IPython.notebook.select(index + 1);\n }\n}\n\nmpl.figure.prototype.handle_save = function(fig, msg) {\n fig.ondownload(fig, null);\n}\n\n\nmpl.find_output_cell = function(html_output) {\n // Return the cell and output element which can be found *uniquely* in the notebook.\n // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n // IPython event is triggered only after the cells have been serialised, which for\n // our purposes (turning an active figure into a static one), is too late.\n var cells = IPython.notebook.get_cells();\n var ncells = cells.length;\n for (var i=0; i= 3 moved mimebundle to data attribute of output\n data = data.data;\n }\n if (data['text/html'] == html_output) {\n return [cell, data, j];\n }\n }\n }\n }\n}\n\n// Register the function which deals with the matplotlib target/channel.\n// The kernel may be null if the page has been refreshed.\nif (IPython.notebook.kernel != null) {\n IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n}\n", "text/plain": [ "" ] @@ -2419,6 +944,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -2444,6 +970,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -2470,6 +997,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -2518,6 +1046,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -2536,6 +1065,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -2553,758 +1083,7 @@ "outputs": [ { "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "window.mpl = {};\n", - "\n", - "mpl.get_websocket_type = function() {\n", - " if (typeof(WebSocket) !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof(MozWebSocket) !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert('Your browser does not have WebSocket support.' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.');\n", - " };\n", - "}\n", - "\n", - "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = (this.ws.binaryType != undefined);\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById(\"mpl-warnings\");\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent = (\n", - " \"This browser does not support binary websocket messages. \" +\n", - " \"Performance may be slow.\");\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = $('
');\n", - " this._root_extra_style(this.root)\n", - " this.root.attr('style', 'display: inline-block');\n", - "\n", - " $(parent_element).append(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", - " fig.send_message(\"send_image_mode\", {});\n", - " fig.send_message(\"refresh\", {});\n", - " }\n", - "\n", - " this.imageObj.onload = function() {\n", - " if (fig.image_mode == 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function() {\n", - " this.ws.close();\n", - " }\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "}\n", - "\n", - "mpl.figure.prototype._init_header = function() {\n", - " var titlebar = $(\n", - " '
');\n", - " var titletext = $(\n", - " '
');\n", - " titlebar.append(titletext)\n", - " this.root.append(titlebar);\n", - " this.header = titletext[0];\n", - "}\n", - "\n", - "\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "mpl.figure.prototype._init_canvas = function() {\n", - " var fig = this;\n", - "\n", - " var canvas_div = $('
');\n", - "\n", - " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", - "\n", - " function canvas_keyboard_event(event) {\n", - " return fig.key_event(event, event['data']);\n", - " }\n", - "\n", - " canvas_div.keydown('key_press', canvas_keyboard_event);\n", - " canvas_div.keyup('key_release', canvas_keyboard_event);\n", - " this.canvas_div = canvas_div\n", - " this._canvas_extra_style(canvas_div)\n", - " this.root.append(canvas_div);\n", - "\n", - " var canvas = $('');\n", - " canvas.addClass('mpl-canvas');\n", - " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", - "\n", - " this.canvas = canvas[0];\n", - " this.context = canvas[0].getContext(\"2d\");\n", - "\n", - " var rubberband = $('');\n", - " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", - "\n", - " var pass_mouse_events = true;\n", - "\n", - " canvas_div.resizable({\n", - " start: function(event, ui) {\n", - " pass_mouse_events = false;\n", - " },\n", - " resize: function(event, ui) {\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " stop: function(event, ui) {\n", - " pass_mouse_events = true;\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " });\n", - "\n", - " function mouse_event_fn(event) {\n", - " if (pass_mouse_events)\n", - " return fig.mouse_event(event, event['data']);\n", - " }\n", - "\n", - " rubberband.mousedown('button_press', mouse_event_fn);\n", - " rubberband.mouseup('button_release', mouse_event_fn);\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband.mousemove('motion_notify', mouse_event_fn);\n", - "\n", - " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", - " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", - "\n", - " canvas_div.on(\"wheel\", function (event) {\n", - " event = event.originalEvent;\n", - " event['data'] = 'scroll'\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " mouse_event_fn(event);\n", - " });\n", - "\n", - " canvas_div.append(canvas);\n", - " canvas_div.append(rubberband);\n", - "\n", - " this.rubberband = rubberband;\n", - " this.rubberband_canvas = rubberband[0];\n", - " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", - " this.rubberband_context.strokeStyle = \"#000000\";\n", - "\n", - " this._resize_canvas = function(width, height) {\n", - " // Keep the size of the canvas, canvas container, and rubber band\n", - " // canvas in synch.\n", - " canvas_div.css('width', width)\n", - " canvas_div.css('height', height)\n", - "\n", - " canvas.attr('width', width);\n", - " canvas.attr('height', height);\n", - "\n", - " rubberband.attr('width', width);\n", - " rubberband.attr('height', height);\n", - " }\n", - "\n", - " // Set the figure to an initial 600x600px, this will subsequently be updated\n", - " // upon first draw.\n", - " this._resize_canvas(600, 600);\n", - "\n", - " // Disable right mouse context menu.\n", - " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", - " return false;\n", - " });\n", - "\n", - " function set_focus () {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "}\n", - "\n", - "mpl.figure.prototype._init_toolbar = function() {\n", - " var fig = this;\n", - "\n", - " var nav_element = $('
')\n", - " nav_element.attr('style', 'width: 100%');\n", - " this.root.append(nav_element);\n", - "\n", - " // Define a callback function for later on.\n", - " function toolbar_event(event) {\n", - " return fig.toolbar_button_onclick(event['data']);\n", - " }\n", - " function toolbar_mouse_event(event) {\n", - " return fig.toolbar_button_onmouseover(event['data']);\n", - " }\n", - "\n", - " for(var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " // put a spacer in here.\n", - " continue;\n", - " }\n", - " var button = $('');\n button.click(method_name, toolbar_event);\n button.mouseover(tooltip, toolbar_mouse_event);\n nav_element.append(button);\n }\n\n // Add the status bar.\n var status_bar = $('');\n nav_element.append(status_bar);\n this.message = status_bar[0];\n\n // Add the close button to the window.\n var buttongrp = $('
');\n var button = $('');\n button.click(function (evt) { fig.handle_close(fig, {}); } );\n button.mouseover('Stop Interaction', toolbar_mouse_event);\n buttongrp.append(button);\n var titlebar = this.root.find($('.ui-dialog-titlebar'));\n titlebar.prepend(buttongrp);\n}\n\nmpl.figure.prototype._root_extra_style = function(el){\n var fig = this\n el.on(\"remove\", function(){\n\tfig.close_ws(fig, {});\n });\n}\n\nmpl.figure.prototype._canvas_extra_style = function(el){\n // this is important to make the div 'focusable\n el.attr('tabindex', 0)\n // reach out to IPython and tell the keyboard manager to turn it's self\n // off when our div gets focus\n\n // location in version 3\n if (IPython.notebook.keyboard_manager) {\n IPython.notebook.keyboard_manager.register_events(el);\n }\n else {\n // location in version 2\n IPython.keyboard_manager.register_events(el);\n }\n\n}\n\nmpl.figure.prototype._key_event_extra = function(event, name) {\n var manager = IPython.notebook.keyboard_manager;\n if (!manager)\n manager = IPython.keyboard_manager;\n\n // Check for shift+enter\n if (event.shiftKey && event.which == 13) {\n this.canvas_div.blur();\n // select the cell after this one\n var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n IPython.notebook.select(index + 1);\n }\n}\n\nmpl.figure.prototype.handle_save = function(fig, msg) {\n fig.ondownload(fig, null);\n}\n\n\nmpl.find_output_cell = function(html_output) {\n // Return the cell and output element which can be found *uniquely* in the notebook.\n // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n // IPython event is triggered only after the cells have been serialised, which for\n // our purposes (turning an active figure into a static one), is too late.\n var cells = IPython.notebook.get_cells();\n var ncells = cells.length;\n for (var i=0; i= 3 moved mimebundle to data attribute of output\n data = data.data;\n }\n if (data['text/html'] == html_output) {\n return [cell, data, j];\n }\n }\n }\n }\n}\n\n// Register the function which deals with the matplotlib target/channel.\n// The kernel may be null if the page has been refreshed.\nif (IPython.notebook.kernel != null) {\n IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n}\n", "text/plain": [ "" ] diff --git a/examples/l5pc/L5PC_arbor.ipynb b/examples/l5pc/L5PC_arbor.ipynb index f736a8e1..0f977c9a 100644 --- a/examples/l5pc/L5PC_arbor.ipynb +++ b/examples/l5pc/L5PC_arbor.ipynb @@ -1,6 +1,7 @@ { "cells": [ { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -8,6 +9,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -31,6 +33,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -143,8 +146,6 @@ "%load_ext autoreload\n", "%autoreload\n", "\n", - "from __future__ import print_function\n", - "\n", "!nrnivmodl mechanisms\n", "import bluepyopt as bpopt\n", "import bluepyopt.ephys as ephys\n", @@ -157,6 +158,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -176,6 +178,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -183,6 +186,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -190,6 +194,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -249,7 +254,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -267,6 +272,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -297,6 +303,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -304,6 +311,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -335,6 +343,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -402,6 +411,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -409,6 +419,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -416,6 +427,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -468,6 +480,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -475,6 +488,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -577,6 +591,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -594,6 +609,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -601,6 +617,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -631,6 +648,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -690,6 +708,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -697,6 +716,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -819,6 +839,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -826,6 +847,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -847,6 +869,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -854,6 +877,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -880,6 +904,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -917,6 +942,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -938,6 +964,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -956,7 +983,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -978,6 +1005,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -1006,6 +1034,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -1035,6 +1064,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -1086,6 +1116,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -1107,6 +1138,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -1127,7 +1159,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] diff --git a/examples/l5pc/convert_params.py b/examples/l5pc/convert_params.py index c90f881d..ddab01fa 100644 --- a/examples/l5pc/convert_params.py +++ b/examples/l5pc/convert_params.py @@ -1,7 +1,5 @@ """Convert params.json and fixed_params.json to parameters.json format""" -from __future__ import print_function - import json diff --git a/examples/l5pc_lfpy/generate_extra_features.py b/examples/l5pc_lfpy/generate_extra_features.py index 98b8ce23..1679eda6 100644 --- a/examples/l5pc_lfpy/generate_extra_features.py +++ b/examples/l5pc_lfpy/generate_extra_features.py @@ -71,7 +71,7 @@ def default(self, obj): ): return int(obj) elif isinstance( - obj, (numpy.float_, numpy.float16, numpy.float32, numpy.float64) + obj, (numpy.float16, numpy.float32, numpy.float64) ): return float(obj) elif isinstance(obj, numpy.ndarray): diff --git a/examples/stochkv/stochkv3cell.hoc b/examples/stochkv/stochkv3cell.hoc index b019b4a8..b19bf683 100644 --- a/examples/stochkv/stochkv3cell.hoc +++ b/examples/stochkv/stochkv3cell.hoc @@ -27,6 +27,10 @@ begintemplate stochkv3_cell public all, somatic, apical, axonal, basal, myelinated, APC objref all, somatic, apical, axonal, basal, myelinated, APC +obfunc getCell(){ + return this +} + proc init(/* args: morphology_dir, morphology_name */) { all = new SectionList() apical = new SectionList() @@ -98,7 +102,8 @@ proc distribute_distance(){local x localobj sl this.soma[0] distance(0, 0.5) sprint(distfunc, "%%s %s(%%f) = %s", mech, distfunc) forsec sl for(x, 0) { - sprint(stmp, distfunc, secname(), x, distance(x)) + // use distance(x) twice for the step distribution case, e.g. for calcium hotspot + sprint(stmp, distfunc, secname(), x, distance(x), distance(x)) execute(stmp) } } diff --git a/examples/stochkv/stochkv3cell_det.hoc b/examples/stochkv/stochkv3cell_det.hoc index 54b14b08..4ece5e02 100644 --- a/examples/stochkv/stochkv3cell_det.hoc +++ b/examples/stochkv/stochkv3cell_det.hoc @@ -27,6 +27,10 @@ begintemplate stochkv3_cell public all, somatic, apical, axonal, basal, myelinated, APC objref all, somatic, apical, axonal, basal, myelinated, APC +obfunc getCell(){ + return this +} + proc init(/* args: morphology_dir, morphology_name */) { all = new SectionList() apical = new SectionList() @@ -98,7 +102,8 @@ proc distribute_distance(){local x localobj sl this.soma[0] distance(0, 0.5) sprint(distfunc, "%%s %s(%%f) = %s", mech, distfunc) forsec sl for(x, 0) { - sprint(stmp, distfunc, secname(), x, distance(x)) + // use distance(x) twice for the step distribution case, e.g. for calcium hotspot + sprint(stmp, distfunc, secname(), x, distance(x), distance(x)) execute(stmp) } } diff --git a/examples/stochkv/stochkvcell.hoc b/examples/stochkv/stochkvcell.hoc index f3296d15..fcdc4ea3 100644 --- a/examples/stochkv/stochkvcell.hoc +++ b/examples/stochkv/stochkvcell.hoc @@ -27,6 +27,10 @@ begintemplate stochkv_cell public all, somatic, apical, axonal, basal, myelinated, APC objref all, somatic, apical, axonal, basal, myelinated, APC +obfunc getCell(){ + return this +} + proc init(/* args: morphology_dir, morphology_name */) { all = new SectionList() apical = new SectionList() @@ -98,7 +102,8 @@ proc distribute_distance(){local x localobj sl this.soma[0] distance(0, 0.5) sprint(distfunc, "%%s %s(%%f) = %s", mech, distfunc) forsec sl for(x, 0) { - sprint(stmp, distfunc, secname(), x, distance(x)) + // use distance(x) twice for the step distribution case, e.g. for calcium hotspot + sprint(stmp, distfunc, secname(), x, distance(x), distance(x)) execute(stmp) } } diff --git a/examples/stochkv/stochkvcell_det.hoc b/examples/stochkv/stochkvcell_det.hoc index 63244811..7a926b5c 100644 --- a/examples/stochkv/stochkvcell_det.hoc +++ b/examples/stochkv/stochkvcell_det.hoc @@ -27,6 +27,10 @@ begintemplate stochkv_cell public all, somatic, apical, axonal, basal, myelinated, APC objref all, somatic, apical, axonal, basal, myelinated, APC +obfunc getCell(){ + return this +} + proc init(/* args: morphology_dir, morphology_name */) { all = new SectionList() apical = new SectionList() @@ -98,7 +102,8 @@ proc distribute_distance(){local x localobj sl this.soma[0] distance(0, 0.5) sprint(distfunc, "%%s %s(%%f) = %s", mech, distfunc) forsec sl for(x, 0) { - sprint(stmp, distfunc, secname(), x, distance(x)) + // use distance(x) twice for the step distribution case, e.g. for calcium hotspot + sprint(stmp, distfunc, secname(), x, distance(x), distance(x)) execute(stmp) } } diff --git a/setup.py b/setup.py index d6bc5ada..f62638c4 100644 --- a/setup.py +++ b/setup.py @@ -52,8 +52,8 @@ 'ipyparallel', 'pickleshare>=0.7.3', 'Jinja2>=2.8', - 'future', - 'Pebble>=4.3.10', + 'Pebble>=4.6.0', + 'NEURON>=7.8', ], extras_require={ 'all': EXTRA_SCOOP + EXTRA_NEUROML + EXTRA_LFP + EXTRA_ARBOR, diff --git a/versioneer.py b/versioneer.py index f11c1fee..3dd263e9 100644 --- a/versioneer.py +++ b/versioneer.py @@ -1,4 +1,3 @@ - # Version: 0.18 """The Versioneer - like a rocketeer, but for versions. @@ -277,6 +276,7 @@ """ from __future__ import print_function + try: import configparser except ImportError: @@ -308,11 +308,13 @@ def get_root(): setup_py = os.path.join(root, "setup.py") versioneer_py = os.path.join(root, "versioneer.py") if not (os.path.exists(setup_py) or os.path.exists(versioneer_py)): - err = ("Versioneer was unable to run the project root directory. " - "Versioneer requires setup.py to be executed from " - "its immediate directory (like 'python setup.py COMMAND'), " - "or in a way that lets it use sys.argv[0] to find the root " - "(like 'python path/to/setup.py COMMAND').") + err = ( + "Versioneer was unable to run the project root directory. " + "Versioneer requires setup.py to be executed from " + "its immediate directory (like 'python setup.py COMMAND'), " + "or in a way that lets it use sys.argv[0] to find the root " + "(like 'python path/to/setup.py COMMAND')." + ) raise VersioneerBadRootError(err) try: # Certain runtime workflows (setup.py install/develop in a setuptools @@ -325,8 +327,10 @@ def get_root(): me_dir = os.path.normcase(os.path.splitext(me)[0]) vsr_dir = os.path.normcase(os.path.splitext(versioneer_py)[0]) if me_dir != vsr_dir: - print("Warning: build in %s is using versioneer.py from %s" - % (os.path.dirname(me), versioneer_py)) + print( + "Warning: build in %s is using versioneer.py from %s" + % (os.path.dirname(me), versioneer_py) + ) except NameError: pass return root @@ -339,15 +343,16 @@ def get_config_from_root(root): # configparser.NoOptionError (if it lacks "VCS="). See the docstring at # the top of versioneer.py for instructions on writing your setup.cfg . setup_cfg = os.path.join(root, "setup.cfg") - parser = configparser.SafeConfigParser() + parser = configparser.ConfigParser() with open(setup_cfg, "r") as f: - parser.readfp(f) + parser.read_file(f) VCS = parser.get("versioneer", "VCS") # mandatory def get(parser, name): if parser.has_option("versioneer", name): return parser.get("versioneer", name) return None + cfg = VersioneerConfig() cfg.VCS = VCS cfg.style = get(parser, "style") or "" @@ -372,17 +377,20 @@ class NotThisMethod(Exception): def register_vcs_handler(vcs, method): # decorator """Decorator to mark a method as the handler for a particular VCS.""" + def decorate(f): """Store f in HANDLERS[vcs][method].""" if vcs not in HANDLERS: HANDLERS[vcs] = {} HANDLERS[vcs][method] = f return f + return decorate -def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, - env=None): +def run_command( + commands, args, cwd=None, verbose=False, hide_stderr=False, env=None +): """Call the given command(s).""" assert isinstance(commands, list) p = None @@ -390,10 +398,13 @@ def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, try: dispcmd = str([c] + args) # remember shell=False, so use git.cmd on windows, not just git - p = subprocess.Popen([c] + args, cwd=cwd, env=env, - stdout=subprocess.PIPE, - stderr=(subprocess.PIPE if hide_stderr - else None)) + p = subprocess.Popen( + [c] + args, + cwd=cwd, + env=env, + stdout=subprocess.PIPE, + stderr=(subprocess.PIPE if hide_stderr else None), + ) break except EnvironmentError: e = sys.exc_info()[1] @@ -418,7 +429,7 @@ def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, return stdout, p.returncode -LONG_VERSION_PY['git'] = ''' +LONG_VERSION_PY["git"] = ''' # This file helps to compute a version number in source trees obtained from # git-archive tarball (such as those provided by githubs download-from-tag # feature). Distribution tarballs (built by setup.py sdist) and build @@ -1011,7 +1022,7 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose): # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of # just "foo-1.0". If we see a "tag: " prefix, prefer those. TAG = "tag: " - tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)]) + tags = set([r[len(TAG) :] for r in refs if r.startswith(TAG)]) if not tags: # Either we're using git < 1.8.3, or there really are no tags. We use # a heuristic: assume all version tags have a digit. The old git %d @@ -1020,7 +1031,7 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose): # between branches and tags. By ignoring refnames without digits, we # filter out many common branch names like "release" and # "stabilization", as well as "HEAD" and "master". - tags = set([r for r in refs if re.search(r'\d', r)]) + tags = set([r for r in refs if re.search(r"\d", r)]) if verbose: print("discarding '%s', no digits" % ",".join(refs - tags)) if verbose: @@ -1028,19 +1039,26 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose): for ref in sorted(tags): # sorting will prefer e.g. "2.0" over "2.0rc1" if ref.startswith(tag_prefix): - r = ref[len(tag_prefix):] + r = ref[len(tag_prefix) :] if verbose: print("picking %s" % r) - return {"version": r, - "full-revisionid": keywords["full"].strip(), - "dirty": False, "error": None, - "date": date} + return { + "version": r, + "full-revisionid": keywords["full"].strip(), + "dirty": False, + "error": None, + "date": date, + } # no suitable tags, so version is "0+unknown", but full hex is still there if verbose: print("no suitable tags, using unknown + full revision id") - return {"version": "0+unknown", - "full-revisionid": keywords["full"].strip(), - "dirty": False, "error": "no suitable tags", "date": None} + return { + "version": "0+unknown", + "full-revisionid": keywords["full"].strip(), + "dirty": False, + "error": "no suitable tags", + "date": None, + } @register_vcs_handler("git", "pieces_from_vcs") @@ -1055,8 +1073,9 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): if sys.platform == "win32": GITS = ["git.cmd", "git.exe"] - out, rc = run_command(GITS, ["rev-parse", "--git-dir"], cwd=root, - hide_stderr=True) + out, rc = run_command( + GITS, ["rev-parse", "--git-dir"], cwd=root, hide_stderr=True + ) if rc != 0: if verbose: print("Directory %s not under git control" % root) @@ -1064,10 +1083,19 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty] # if there isn't one, this yields HEX[-dirty] (no NUM) - describe_out, rc = run_command(GITS, ["describe", "--tags", "--dirty", - "--always", "--long", - "--match", "%s*" % tag_prefix], - cwd=root) + describe_out, rc = run_command( + GITS, + [ + "describe", + "--tags", + "--dirty", + "--always", + "--long", + "--match", + "%s*" % tag_prefix, + ], + cwd=root, + ) # --long was added in git-1.5.5 if describe_out is None: raise NotThisMethod("'git describe' failed") @@ -1090,17 +1118,18 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): dirty = git_describe.endswith("-dirty") pieces["dirty"] = dirty if dirty: - git_describe = git_describe[:git_describe.rindex("-dirty")] + git_describe = git_describe[: git_describe.rindex("-dirty")] # now we have TAG-NUM-gHEX or HEX if "-" in git_describe: # TAG-NUM-gHEX - mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe) + mo = re.search(r"^(.+)-(\d+)-g([0-9a-f]+)$", git_describe) if not mo: # unparseable. Maybe git-describe is misbehaving? - pieces["error"] = ("unable to parse git-describe output: '%s'" - % describe_out) + pieces["error"] = ( + "unable to parse git-describe output: '%s'" % describe_out + ) return pieces # tag @@ -1109,10 +1138,12 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): if verbose: fmt = "tag '%s' doesn't start with prefix '%s'" print(fmt % (full_tag, tag_prefix)) - pieces["error"] = ("tag '%s' doesn't start with prefix '%s'" - % (full_tag, tag_prefix)) + pieces["error"] = "tag '%s' doesn't start with prefix '%s'" % ( + full_tag, + tag_prefix, + ) return pieces - pieces["closest-tag"] = full_tag[len(tag_prefix):] + pieces["closest-tag"] = full_tag[len(tag_prefix) :] # distance: number of commits since tag pieces["distance"] = int(mo.group(2)) @@ -1123,13 +1154,15 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): else: # HEX: no tags pieces["closest-tag"] = None - count_out, rc = run_command(GITS, ["rev-list", "HEAD", "--count"], - cwd=root) + count_out, rc = run_command( + GITS, ["rev-list", "HEAD", "--count"], cwd=root + ) pieces["distance"] = int(count_out) # total number of commits # commit date: see ISO-8601 comment in git_versions_from_keywords() - date = run_command(GITS, ["show", "-s", "--format=%ci", "HEAD"], - cwd=root)[0].strip() + date = run_command(GITS, ["show", "-s", "--format=%ci", "HEAD"], cwd=root)[ + 0 + ].strip() pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1) return pieces @@ -1185,16 +1218,22 @@ def versions_from_parentdir(parentdir_prefix, root, verbose): for i in range(3): dirname = os.path.basename(root) if dirname.startswith(parentdir_prefix): - return {"version": dirname[len(parentdir_prefix):], - "full-revisionid": None, - "dirty": False, "error": None, "date": None} + return { + "version": dirname[len(parentdir_prefix) :], + "full-revisionid": None, + "dirty": False, + "error": None, + "date": None, + } else: rootdirs.append(root) root = os.path.dirname(root) # up a level if verbose: - print("Tried directories %s but none started with prefix %s" % - (str(rootdirs), parentdir_prefix)) + print( + "Tried directories %s but none started with prefix %s" + % (str(rootdirs), parentdir_prefix) + ) raise NotThisMethod("rootdir doesn't start with parentdir_prefix") @@ -1223,11 +1262,17 @@ def versions_from_file(filename): contents = f.read() except EnvironmentError: raise NotThisMethod("unable to read _version.py") - mo = re.search(r"version_json = '''\n(.*)''' # END VERSION_JSON", - contents, re.M | re.S) + mo = re.search( + r"version_json = '''\n(.*)''' # END VERSION_JSON", + contents, + re.M | re.S, + ) if not mo: - mo = re.search(r"version_json = '''\r\n(.*)''' # END VERSION_JSON", - contents, re.M | re.S) + mo = re.search( + r"version_json = '''\r\n(.*)''' # END VERSION_JSON", + contents, + re.M | re.S, + ) if not mo: raise NotThisMethod("no version_json in _version.py") return json.loads(mo.group(1)) @@ -1236,8 +1281,9 @@ def versions_from_file(filename): def write_to_version_file(filename, versions): """Write the given version number to the given _version.py file.""" os.unlink(filename) - contents = json.dumps(versions, sort_keys=True, - indent=1, separators=(",", ": ")) + contents = json.dumps( + versions, sort_keys=True, indent=1, separators=(",", ": ") + ) with open(filename, "w") as f: f.write(SHORT_VERSION_PY % contents) @@ -1269,8 +1315,7 @@ def render_pep440(pieces): rendered += ".dirty" else: # exception #1 - rendered = "0+untagged.%d.g%s" % (pieces["distance"], - pieces["short"]) + rendered = "0+untagged.%d.g%s" % (pieces["distance"], pieces["short"]) if pieces["dirty"]: rendered += ".dirty" return rendered @@ -1291,6 +1336,7 @@ def render_pep440_pre(pieces): rendered = "0.post.dev%d" % pieces["distance"] return rendered + def render_pep440_minor(pieces): # TAG[.DISTANCE] . No -dirty @@ -1307,7 +1353,6 @@ def render_pep440_minor(pieces): return rendered - def render_pep440_post(pieces): """TAG[.postDISTANCE[.dev0]+gHEX] . @@ -1400,11 +1445,13 @@ def render_git_describe_long(pieces): def render(pieces, style): """Render the given version pieces into the requested style.""" if pieces["error"]: - return {"version": "unknown", - "full-revisionid": pieces.get("long"), - "dirty": None, - "error": pieces["error"], - "date": None} + return { + "version": "unknown", + "full-revisionid": pieces.get("long"), + "dirty": None, + "error": pieces["error"], + "date": None, + } if not style or style == "default": style = "pep440" # the default @@ -1426,9 +1473,13 @@ def render(pieces, style): else: raise ValueError("unknown style '%s'" % style) - return {"version": rendered, "full-revisionid": pieces["long"], - "dirty": pieces["dirty"], "error": None, - "date": pieces.get("date")} + return { + "version": rendered, + "full-revisionid": pieces["long"], + "dirty": pieces["dirty"], + "error": None, + "date": pieces.get("date"), + } class VersioneerBadRootError(Exception): @@ -1451,8 +1502,9 @@ def get_versions(verbose=False): handlers = HANDLERS.get(cfg.VCS) assert handlers, "unrecognized VCS '%s'" % cfg.VCS verbose = verbose or cfg.verbose - assert cfg.versionfile_source is not None, \ - "please set versioneer.versionfile_source" + assert ( + cfg.versionfile_source is not None + ), "please set versioneer.versionfile_source" assert cfg.tag_prefix is not None, "please set versioneer.tag_prefix" versionfile_abs = os.path.join(root, cfg.versionfile_source) @@ -1506,9 +1558,13 @@ def get_versions(verbose=False): if verbose: print("unable to compute version") - return {"version": "0+unknown", "full-revisionid": None, - "dirty": None, "error": "unable to compute version", - "date": None} + return { + "version": "0+unknown", + "full-revisionid": None, + "dirty": None, + "error": "unable to compute version", + "date": None, + } def get_version(): @@ -1557,6 +1613,7 @@ def run(self): print(" date: %s" % vers.get("date")) if vers["error"]: print(" error: %s" % vers["error"]) + cmds["version"] = cmd_version # we override "build_py" in both distutils and setuptools @@ -1589,10 +1646,12 @@ def run(self): # now locate _version.py in the new build/ directory and replace # it with an updated value if cfg.versionfile_build: - target_versionfile = os.path.join(self.build_lib, - cfg.versionfile_build) + target_versionfile = os.path.join( + self.build_lib, cfg.versionfile_build + ) print("UPDATING %s" % target_versionfile) write_to_version_file(target_versionfile, versions) + cmds["build_py"] = cmd_build_py if "cx_Freeze" in sys.modules: # cx_freeze enabled? @@ -1617,17 +1676,21 @@ def run(self): os.unlink(target_versionfile) with open(cfg.versionfile_source, "w") as f: LONG = LONG_VERSION_PY[cfg.VCS] - f.write(LONG % - {"DOLLAR": "$", - "STYLE": cfg.style, - "TAG_PREFIX": cfg.tag_prefix, - "PARENTDIR_PREFIX": cfg.parentdir_prefix, - "VERSIONFILE_SOURCE": cfg.versionfile_source, - }) + f.write( + LONG + % { + "DOLLAR": "$", + "STYLE": cfg.style, + "TAG_PREFIX": cfg.tag_prefix, + "PARENTDIR_PREFIX": cfg.parentdir_prefix, + "VERSIONFILE_SOURCE": cfg.versionfile_source, + } + ) + cmds["build_exe"] = cmd_build_exe del cmds["build_py"] - if 'py2exe' in sys.modules: # py2exe enabled? + if "py2exe" in sys.modules: # py2exe enabled? try: from py2exe.distutils_buildexe import py2exe as _py2exe # py3 except ImportError: @@ -1646,13 +1709,17 @@ def run(self): os.unlink(target_versionfile) with open(cfg.versionfile_source, "w") as f: LONG = LONG_VERSION_PY[cfg.VCS] - f.write(LONG % - {"DOLLAR": "$", - "STYLE": cfg.style, - "TAG_PREFIX": cfg.tag_prefix, - "PARENTDIR_PREFIX": cfg.parentdir_prefix, - "VERSIONFILE_SOURCE": cfg.versionfile_source, - }) + f.write( + LONG + % { + "DOLLAR": "$", + "STYLE": cfg.style, + "TAG_PREFIX": cfg.tag_prefix, + "PARENTDIR_PREFIX": cfg.parentdir_prefix, + "VERSIONFILE_SOURCE": cfg.versionfile_source, + } + ) + cmds["py2exe"] = cmd_py2exe # we override different "sdist" commands for both environments @@ -1679,8 +1746,10 @@ def make_release_tree(self, base_dir, files): # updated value target_versionfile = os.path.join(base_dir, cfg.versionfile_source) print("UPDATING %s" % target_versionfile) - write_to_version_file(target_versionfile, - self._versioneer_generated_versions) + write_to_version_file( + target_versionfile, self._versioneer_generated_versions + ) + cmds["sdist"] = cmd_sdist return cmds @@ -1735,11 +1804,15 @@ def do_setup(): root = get_root() try: cfg = get_config_from_root(root) - except (EnvironmentError, configparser.NoSectionError, - configparser.NoOptionError) as e: + except ( + EnvironmentError, + configparser.NoSectionError, + configparser.NoOptionError, + ) as e: if isinstance(e, (EnvironmentError, configparser.NoSectionError)): - print("Adding sample versioneer config to setup.cfg", - file=sys.stderr) + print( + "Adding sample versioneer config to setup.cfg", file=sys.stderr + ) with open(os.path.join(root, "setup.cfg"), "a") as f: f.write(SAMPLE_CONFIG) print(CONFIG_ERROR, file=sys.stderr) @@ -1748,15 +1821,18 @@ def do_setup(): print(" creating %s" % cfg.versionfile_source) with open(cfg.versionfile_source, "w") as f: LONG = LONG_VERSION_PY[cfg.VCS] - f.write(LONG % {"DOLLAR": "$", - "STYLE": cfg.style, - "TAG_PREFIX": cfg.tag_prefix, - "PARENTDIR_PREFIX": cfg.parentdir_prefix, - "VERSIONFILE_SOURCE": cfg.versionfile_source, - }) - - ipy = os.path.join(os.path.dirname(cfg.versionfile_source), - "__init__.py") + f.write( + LONG + % { + "DOLLAR": "$", + "STYLE": cfg.style, + "TAG_PREFIX": cfg.tag_prefix, + "PARENTDIR_PREFIX": cfg.parentdir_prefix, + "VERSIONFILE_SOURCE": cfg.versionfile_source, + } + ) + + ipy = os.path.join(os.path.dirname(cfg.versionfile_source), "__init__.py") if os.path.exists(ipy): try: with open(ipy, "r") as f: @@ -1798,8 +1874,10 @@ def do_setup(): else: print(" 'versioneer.py' already in MANIFEST.in") if cfg.versionfile_source not in simple_includes: - print(" appending versionfile_source ('%s') to MANIFEST.in" % - cfg.versionfile_source) + print( + " appending versionfile_source ('%s') to MANIFEST.in" + % cfg.versionfile_source + ) with open(manifest_in, "a") as f: f.write("include %s\n" % cfg.versionfile_source) else: