Hello community,
here is the log from the commit of package python-jupyter_nbval for
openSUSE:Factory checked in at 2018-08-03 12:39:39
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/python-jupyter_nbval (Old)
and /work/SRC/openSUSE:Factory/.python-jupyter_nbval.new (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-jupyter_nbval"
Fri Aug 3 12:39:39 2018 rev:2 rq:627149 version:0.9.1
Changes:
--------
---
/work/SRC/openSUSE:Factory/python-jupyter_nbval/python-jupyter_nbval.changes
2018-06-15 14:37:02.836594999 +0200
+++
/work/SRC/openSUSE:Factory/.python-jupyter_nbval.new/python-jupyter_nbval.changes
2018-08-03 12:39:43.915786418 +0200
@@ -1,0 +2,13 @@
+Thu Aug 2 17:25:44 UTC 2018 - [email protected]
+
+- Update to 0.9.1
+ * Only pass absolute config path if config file exists
+ * Ignore .pytest_cache
+ * Mark cells in generated notebook as run
+ * Rerun sample notebook
+ * Pass coverage config file by absolute path
+ * Respect the --color=no option
+ * Ensure test works on python 2
+ * Optionally mark run cells with exc. count in tests
+
+-------------------------------------------------------------------
Old:
----
nbval-0.9.0.tar.gz
New:
----
nbval-0.9.1.tar.gz
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ python-jupyter_nbval.spec ++++++
--- /var/tmp/diff_new_pack.K8gAPn/_old 2018-08-03 12:39:44.431787187 +0200
+++ /var/tmp/diff_new_pack.K8gAPn/_new 2018-08-03 12:39:44.431787187 +0200
@@ -18,7 +18,7 @@
%{?!python_module:%define python_module() python-%{**} python3-%{**}}
Name: python-jupyter_nbval
-Version: 0.9.0
+Version: 0.9.1
Release: 0
Summary: A pytest plugin to validate Jupyter notebooks
License: BSD-3-Clause
@@ -79,9 +79,11 @@
sed -i 's/\r$//' README.md
%build
+export LANG=en_US.UTF-8
%python_build
%install
+export LANG=en_US.UTF-8
%python_install
%python_expand %fdupes %{buildroot}%{$python_sitelib}
++++++ nbval-0.9.0.tar.gz -> nbval-0.9.1.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/nbval-0.9.0/PKG-INFO new/nbval-0.9.1/PKG-INFO
--- old/nbval-0.9.0/PKG-INFO 2018-01-16 11:33:41.000000000 +0100
+++ new/nbval-0.9.1/PKG-INFO 2018-06-04 17:11:00.000000000 +0200
@@ -1,13 +1,160 @@
Metadata-Version: 1.1
Name: nbval
-Version: 0.9.0
+Version: 0.9.1
Summary: A py.test plugin to validate Jupyter notebooks
Home-page: https://github.com/computationalmodelling/nbval
Author: Laslett, Cortes, Fauske, Kluyver, Pepper, Fangohr
Author-email: UNKNOWN
License: UNKNOWN
-Description-Content-Type: UNKNOWN
-Description: UNKNOWN
+Description-Content-Type: text/markdown
+Description: # Py.test plugin for validating Jupyter notebooks
+
+ [](https://travis-ci.org/computationalmodelling/nbval)
+ [](https://pypi.python.org/pypi/nbval)
+ [](https://nbval.readthedocs.io/)
+
+ The plugin adds functionality to py.test to recognise and collect
Jupyter
+ notebooks. The intended purpose of the tests is to determine whether
execution
+ of the stored inputs match the stored outputs of the `.ipynb` file.
Whilst also
+ ensuring that the notebooks are running without errors.
+
+ The tests were designed to ensure that Jupyter notebooks (especially
those for
+ reference and documentation), are executing consistently.
+
+ Each cell is taken as a test, a cell that doesn't reproduce the
expected
+ output will fail.
+
+ See
[`docs/source/index.ipynb`](http://nbviewer.jupyter.org/github/computationalmodelling/nbval/blob/master/docs/source/index.ipynb)
for the full documentation.
+
+ ## Installation
+ Available on PyPi:
+
+ pip install nbval
+
+ or install the latest version from cloning the repository and running:
+
+ pip install .
+
+ from the main directory. To uninstall:
+
+ pip uninstall nbval
+
+
+ ## How it works
+ The extension looks through every cell that contains code in an
IPython notebook
+ and then the `py.test` system compares the outputs stored in the
notebook
+ with the outputs of the cells when they are executed. Thus, the
notebook itself is
+ used as a testing function.
+ The output lines when executing the notebook can be sanitized passing
an
+ extra option and file, when calling the `py.test` command. This file
+ is a usual configuration file for the `ConfigParser` library.
+
+ Regarding the execution, roughly, the script initiates an
+ IPython Kernel with a `shell` and
+ an `iopub` sockets. The `shell` is needed to execute the cells in
+ the notebook (it sends requests to the Kernel) and the `iopub` provides
+ an interface to get the messages from the outputs. The contents
+ of the messages obtained from the Kernel are organised in dictionaries
+ with different information, such as time stamps of executions,
+ cell data types, cell types, the status of the Kernel, username, etc.
+
+ In general, the functionality of the IPython notebook system is
+ quite complex, but a detailed explanation of the messages
+ and how the system works, can be found here
+
+ http://ipython.org/ipython-doc/stable/development/messaging.html
+
+ ## Execution
+ To execute this plugin, you need to execute `py.test` with the `nbval`
flag
+ to differentiate the testing from the usual python files:
+
+ py.test --nbval
+
+ You can also specify `--nbval-lax`, which runs notebooks and checks for
+ errors, but only compares the outputs of cells with a
`#NBVAL_CHECK_OUTPUT`
+ marker comment.
+
+ py.test --nbval-lax
+
+ The commands above will execute all the `.ipynb` files in the current
folder.
+ Alternatively, you can execute a specific notebook:
+
+ py.test --nbval my_notebook.ipynb
+
+ If the output lines are going to be sanitized, an extra flag,
`--sanitize-with`
+ together with the path to a confguration file with regex expressions,
must be passed,
+ i.e.
+
+ py.test --nbval my_notebook.ipynb --sanitize-with
path/to/my_sanitize_file
+
+ where `my_sanitize_file` has the following structure.
+
+ ```
+ [Section1]
+ regex: [a-z]*
+ replace: abcd
+
+ regex: [1-9]*
+ replace: 0000
+
+ [Section2]
+ regex: foo
+ replace: bar
+ ```
+
+ The `regex` option contains the expression that is going to be matched
in the outputs, and
+ `replace` is the string that will replace the `regex` match.
Currently, the section
+ names do not have any meaning or influence in the testing system, it
will take
+ all the sections and replace the corresponding options.
+
+
+ ### Coverage
+
+ To use notebooks to generate coverage for imported code, use the
pytest-cov plugin.
+ nbval should automatically detect the relevant options and configure
itself with it.
+
+
+ ### Parallel execution
+
+ nbval is compatible with the pytest-xdist plugin for parallel running
of tests. It does
+ however require the use of the `--dist loadscope` flag to ensure that
all cells of one
+ notebook are run on the same kernel.
+
+
+ ## Help
+ The `py.test` system help can be obtained with `py.test -h`, which will
+ show all the flags that can be passed to the command, such as the
+ verbose `-v` option. The IPython notebook plugin can be found under the
+ `general` section.
+
+
+ ## Acknowledgements
+ This plugin was inspired by Andrea Zonca's py.test plugin for
collecting unit
+ tests in the IPython notebooks (https://github.com/zonca/pytest-ipynb).
+
+ The original prototype was based on the template in
+ https://gist.github.com/timo/2621679 and the code of a testing system
+ for notebooks https://gist.github.com/minrk/2620735 which we
+ integrated and mixed with the `py.test` system.
+
+ We acknowledge financial support from
+
+ - OpenDreamKit Horizon 2020 European Research Infrastructures project
(#676541), http://opendreamkit.org
+
+ - EPSRC’s Centre for Doctoral Training in Next Generation
+ Computational Modelling, http://ngcm.soton.ac.uk (#EP/L015382/1) and
+ EPSRC’s Doctoral Training Centre in Complex System Simulation
+ ((EP/G03690X/1),
+
+ - The Gordon and Betty Moore Foundation through Grant GBMF #4856,by the
+ Alfred P. Sloan Foundation and by the Helmsley Trust.
+
+
+ ## Authors
+
+ 2014 - 2017 David Cortes-Ortuno, Oliver Laslett, T. Kluyver, Vidar
+ Fauske, Maximilian Albert, MinRK, Ondrej Hovorka, Hans Fangohr
+
Platform: UNKNOWN
Classifier: Framework :: IPython
Classifier: Framework :: Pytest
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/nbval-0.9.0/README.md new/nbval-0.9.1/README.md
--- old/nbval-0.9.0/README.md 2018-01-15 14:53:53.000000000 +0100
+++ new/nbval-0.9.1/README.md 2018-06-04 17:10:28.000000000 +0200
@@ -2,6 +2,7 @@
[](https://travis-ci.org/computationalmodelling/nbval)
[](https://pypi.python.org/pypi/nbval)
+[](https://nbval.readthedocs.io/)
The plugin adds functionality to py.test to recognise and collect Jupyter
notebooks. The intended purpose of the tests is to determine whether execution
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/nbval-0.9.0/docs/environment.yml
new/nbval-0.9.1/docs/environment.yml
--- old/nbval-0.9.0/docs/environment.yml 1970-01-01 01:00:00.000000000
+0100
+++ new/nbval-0.9.1/docs/environment.yml 2018-06-04 17:10:28.000000000
+0200
@@ -0,0 +1,9 @@
+name: nbval_docs
+channels:
+ - conda-forge
+dependencies:
+- python=3.5
+- numpy
+- matplotlib
+- sphinx
+- nbsphinx>=0.3.1
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/nbval-0.9.0/docs/source/conf.py
new/nbval-0.9.1/docs/source/conf.py
--- old/nbval-0.9.0/docs/source/conf.py 2018-01-15 14:51:26.000000000 +0100
+++ new/nbval-0.9.1/docs/source/conf.py 2018-06-04 17:10:28.000000000 +0200
@@ -21,17 +21,6 @@
# import sys
# sys.path.insert(0, os.path.abspath('.'))
-# Check if docs are being built by ReadTheDocs
-# If so, generate a config.rst file and populate it with documentation about
-# configuration options
-
-if os.environ.get('READTHEDOCS', ''):
-
- # Readthedocs doesn't run our Makefile, so we do this to force it to
generate
- # the config docs.
- with open('../autogen_config.py') as f:
- exec(compile(f.read(), '../autogen_config.py', 'exec'), {})
-
# -- General configuration ------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/nbval-0.9.0/nbval/_version.py
new/nbval-0.9.1/nbval/_version.py
--- old/nbval-0.9.0/nbval/_version.py 2018-01-16 11:19:29.000000000 +0100
+++ new/nbval-0.9.1/nbval/_version.py 2018-06-04 17:10:28.000000000 +0200
@@ -1,2 +1,2 @@
-version_info = (0, 9, 0)
+version_info = (0, 9, 1)
__version__ = '.'.join(map(str, version_info[:3])) + ''.join(version_info[3:])
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/nbval-0.9.0/nbval/cover.py
new/nbval-0.9.1/nbval/cover.py
--- old/nbval-0.9.0/nbval/cover.py 2018-01-15 13:12:36.000000000 +0100
+++ new/nbval-0.9.1/nbval/cover.py 2018-06-04 17:10:28.000000000 +0200
@@ -51,6 +51,8 @@
# Get options from pytest-cov's command line arguments:
source = config.option.cov_source
config_file = config.option.cov_config
+ if isinstance(config_file, str) and os.path.isfile(config_file):
+ config_file = os.path.abspath(config_file)
# Copy the suffix of plugin if available
suffix = _make_suffix(cov)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/nbval-0.9.0/nbval/plugin.py
new/nbval-0.9.1/nbval/plugin.py
--- old/nbval-0.9.0/nbval/plugin.py 2018-01-16 11:19:41.000000000 +0100
+++ new/nbval-0.9.1/nbval/plugin.py 2018-06-04 17:10:28.000000000 +0200
@@ -42,6 +42,15 @@
FAIL = '\033[91m'
ENDC = '\033[0m'
+class nocolors:
+ HEADER = ''
+ OKBLUE = ''
+ OKGREEN = ''
+ WARNING = ''
+ FAIL = ''
+ ENDC = ''
+
+
class NbCellError(Exception):
""" custom exception for error reporting. """
@@ -319,6 +328,8 @@
self.options = options
self.config = parent.parent.config
self.output_timeout = 5
+ # Disable colors if we have been explicitly asked to
+ self.colors = bcolors if self.config.option.color != 'no' else nocolors
# _pytest.skipping assumes all pytest.Item have this attribute:
self.obj = Dummy()
@@ -329,12 +340,13 @@
def repr_failure(self, excinfo):
""" called when self.runtest() raises an exception. """
exc = excinfo.value
+ cc = self.colors
if isinstance(exc, NbCellError):
msg_items = [
- bcolors.FAIL + "Notebook cell execution failed" + bcolors.ENDC]
+ cc.FAIL + "Notebook cell execution failed" + cc.ENDC]
formatstring = (
- bcolors.OKBLUE + "Cell %d: %s\n\n" +
- "Input:\n" + bcolors.ENDC + "%s\n")
+ cc.OKBLUE + "Cell %d: %s\n\n" +
+ "Input:\n" + cc.ENDC + "%s\n")
msg_items.append(formatstring % (
exc.cell_num,
str(exc),
@@ -342,7 +354,7 @@
))
if exc.inner_traceback:
msg_items.append((
- bcolors.OKBLUE + "Traceback:" + bcolors.ENDC + "\n%s\n") %
+ cc.OKBLUE + "Traceback:" + cc.ENDC + "\n%s\n") %
exc.inner_traceback)
return "\n".join(msg_items)
else:
@@ -359,6 +371,9 @@
test = transform_streams_for_comparison(test)
ref = transform_streams_for_comparison(ref)
+ # Color codes to use for reporting
+ cc = self.colors
+
# We reformat outputs into a dictionaries where
# key:
# - all keys on output except 'data' and those in skip_compare
@@ -409,18 +424,18 @@
if ref_keys - test_keys:
self.comparison_traceback.append(
- bcolors.FAIL
+ cc.FAIL
+ "Missing output fields from running code: %s"
% (ref_keys - test_keys)
- + bcolors.ENDC
+ + cc.ENDC
)
return False
elif test_keys - ref_keys:
self.comparison_traceback.append(
- bcolors.FAIL
+ cc.FAIL
+ "Unexpected output fields from running code: %s"
% (test_keys - ref_keys)
- + bcolors.ENDC
+ + cc.ENDC
)
return False
@@ -435,24 +450,24 @@
if len(test_values) != len(ref_values):
# The number of outputs for a specific MIME type differs
self.comparison_traceback.append(
- bcolors.OKBLUE
+ cc.OKBLUE
+ 'dissimilar number of outputs for key "%s"' % key
- + bcolors.FAIL
+ + cc.FAIL
+ "<<<<<<<<<<<< Reference outputs from ipynb file:"
- + bcolors.ENDC
+ + cc.ENDC
)
for val in ref_values:
self.comparison_traceback.append(_trim_base64(val))
self.comparison_traceback.append(
- bcolors.FAIL
+ cc.FAIL
+ '============ disagrees with newly computed (test)
output:'
- + bcolors.ENDC)
+ + cc.ENDC)
for val in test_values:
self.comparison_traceback.append(_trim_base64(val))
self.comparison_traceback.append(
- bcolors.FAIL
+ cc.FAIL
+ '>>>>>>>>>>>>'
- + bcolors.ENDC)
+ + cc.ENDC)
return False
for ref_out, test_out in zip(ref_values, test_values):
@@ -469,10 +484,12 @@
if isinstance(right, six.string_types):
right = _trim_base64(right)
+ cc = self.colors
+
self.comparison_traceback.append(
- bcolors.OKBLUE
+ cc.OKBLUE
+ " mismatch '%s'" % key
- + bcolors.FAIL)
+ + cc.FAIL)
# Use comparison repr from pytest:
hook_result = self.ihook.pytest_assertrepr_compare(
@@ -487,17 +504,17 @@
# Fallback repr:
self.comparison_traceback.append(
" <<<<<<<<<<<< Reference output from ipynb file:"
- + bcolors.ENDC)
+ + cc.ENDC)
self.comparison_traceback.append(_indent(left))
self.comparison_traceback.append(
- bcolors.FAIL
+ cc.FAIL
+ ' ============ disagrees with newly computed (test) output:'
- + bcolors.ENDC)
+ + cc.ENDC)
self.comparison_traceback.append(_indent(right))
self.comparison_traceback.append(
- bcolors.FAIL
+ cc.FAIL
+ ' >>>>>>>>>>>>')
- self.comparison_traceback.append(bcolors.ENDC)
+ self.comparison_traceback.append(cc.ENDC)
""" *****************************************************
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/nbval-0.9.0/nbval.egg-info/PKG-INFO
new/nbval-0.9.1/nbval.egg-info/PKG-INFO
--- old/nbval-0.9.0/nbval.egg-info/PKG-INFO 2018-01-16 11:33:41.000000000
+0100
+++ new/nbval-0.9.1/nbval.egg-info/PKG-INFO 2018-06-04 17:10:59.000000000
+0200
@@ -1,13 +1,160 @@
Metadata-Version: 1.1
Name: nbval
-Version: 0.9.0
+Version: 0.9.1
Summary: A py.test plugin to validate Jupyter notebooks
Home-page: https://github.com/computationalmodelling/nbval
Author: Laslett, Cortes, Fauske, Kluyver, Pepper, Fangohr
Author-email: UNKNOWN
License: UNKNOWN
-Description-Content-Type: UNKNOWN
-Description: UNKNOWN
+Description-Content-Type: text/markdown
+Description: # Py.test plugin for validating Jupyter notebooks
+
+ [](https://travis-ci.org/computationalmodelling/nbval)
+ [](https://pypi.python.org/pypi/nbval)
+ [](https://nbval.readthedocs.io/)
+
+ The plugin adds functionality to py.test to recognise and collect
Jupyter
+ notebooks. The intended purpose of the tests is to determine whether
execution
+ of the stored inputs match the stored outputs of the `.ipynb` file.
Whilst also
+ ensuring that the notebooks are running without errors.
+
+ The tests were designed to ensure that Jupyter notebooks (especially
those for
+ reference and documentation), are executing consistently.
+
+ Each cell is taken as a test, a cell that doesn't reproduce the
expected
+ output will fail.
+
+ See
[`docs/source/index.ipynb`](http://nbviewer.jupyter.org/github/computationalmodelling/nbval/blob/master/docs/source/index.ipynb)
for the full documentation.
+
+ ## Installation
+ Available on PyPi:
+
+ pip install nbval
+
+ or install the latest version from cloning the repository and running:
+
+ pip install .
+
+ from the main directory. To uninstall:
+
+ pip uninstall nbval
+
+
+ ## How it works
+ The extension looks through every cell that contains code in an
IPython notebook
+ and then the `py.test` system compares the outputs stored in the
notebook
+ with the outputs of the cells when they are executed. Thus, the
notebook itself is
+ used as a testing function.
+ The output lines when executing the notebook can be sanitized passing
an
+ extra option and file, when calling the `py.test` command. This file
+ is a usual configuration file for the `ConfigParser` library.
+
+ Regarding the execution, roughly, the script initiates an
+ IPython Kernel with a `shell` and
+ an `iopub` sockets. The `shell` is needed to execute the cells in
+ the notebook (it sends requests to the Kernel) and the `iopub` provides
+ an interface to get the messages from the outputs. The contents
+ of the messages obtained from the Kernel are organised in dictionaries
+ with different information, such as time stamps of executions,
+ cell data types, cell types, the status of the Kernel, username, etc.
+
+ In general, the functionality of the IPython notebook system is
+ quite complex, but a detailed explanation of the messages
+ and how the system works, can be found here
+
+ http://ipython.org/ipython-doc/stable/development/messaging.html
+
+ ## Execution
+ To execute this plugin, you need to execute `py.test` with the `nbval`
flag
+ to differentiate the testing from the usual python files:
+
+ py.test --nbval
+
+ You can also specify `--nbval-lax`, which runs notebooks and checks for
+ errors, but only compares the outputs of cells with a
`#NBVAL_CHECK_OUTPUT`
+ marker comment.
+
+ py.test --nbval-lax
+
+ The commands above will execute all the `.ipynb` files in the current
folder.
+ Alternatively, you can execute a specific notebook:
+
+ py.test --nbval my_notebook.ipynb
+
+ If the output lines are going to be sanitized, an extra flag,
`--sanitize-with`
+ together with the path to a confguration file with regex expressions,
must be passed,
+ i.e.
+
+ py.test --nbval my_notebook.ipynb --sanitize-with
path/to/my_sanitize_file
+
+ where `my_sanitize_file` has the following structure.
+
+ ```
+ [Section1]
+ regex: [a-z]*
+ replace: abcd
+
+ regex: [1-9]*
+ replace: 0000
+
+ [Section2]
+ regex: foo
+ replace: bar
+ ```
+
+ The `regex` option contains the expression that is going to be matched
in the outputs, and
+ `replace` is the string that will replace the `regex` match.
Currently, the section
+ names do not have any meaning or influence in the testing system, it
will take
+ all the sections and replace the corresponding options.
+
+
+ ### Coverage
+
+ To use notebooks to generate coverage for imported code, use the
pytest-cov plugin.
+ nbval should automatically detect the relevant options and configure
itself with it.
+
+
+ ### Parallel execution
+
+ nbval is compatible with the pytest-xdist plugin for parallel running
of tests. It does
+ however require the use of the `--dist loadscope` flag to ensure that
all cells of one
+ notebook are run on the same kernel.
+
+
+ ## Help
+ The `py.test` system help can be obtained with `py.test -h`, which will
+ show all the flags that can be passed to the command, such as the
+ verbose `-v` option. The IPython notebook plugin can be found under the
+ `general` section.
+
+
+ ## Acknowledgements
+ This plugin was inspired by Andrea Zonca's py.test plugin for
collecting unit
+ tests in the IPython notebooks (https://github.com/zonca/pytest-ipynb).
+
+ The original prototype was based on the template in
+ https://gist.github.com/timo/2621679 and the code of a testing system
+ for notebooks https://gist.github.com/minrk/2620735 which we
+ integrated and mixed with the `py.test` system.
+
+ We acknowledge financial support from
+
+ - OpenDreamKit Horizon 2020 European Research Infrastructures project
(#676541), http://opendreamkit.org
+
+ - EPSRC’s Centre for Doctoral Training in Next Generation
+ Computational Modelling, http://ngcm.soton.ac.uk (#EP/L015382/1) and
+ EPSRC’s Doctoral Training Centre in Complex System Simulation
+ ((EP/G03690X/1),
+
+ - The Gordon and Betty Moore Foundation through Grant GBMF #4856,by the
+ Alfred P. Sloan Foundation and by the Helmsley Trust.
+
+
+ ## Authors
+
+ 2014 - 2017 David Cortes-Ortuno, Oliver Laslett, T. Kluyver, Vidar
+ Fauske, Maximilian Albert, MinRK, Ondrej Hovorka, Hans Fangohr
+
Platform: UNKNOWN
Classifier: Framework :: IPython
Classifier: Framework :: Pytest
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/nbval-0.9.0/nbval.egg-info/SOURCES.txt
new/nbval-0.9.1/nbval.egg-info/SOURCES.txt
--- old/nbval-0.9.0/nbval.egg-info/SOURCES.txt 2018-01-16 11:33:41.000000000
+0100
+++ new/nbval-0.9.1/nbval.egg-info/SOURCES.txt 2018-06-04 17:10:59.000000000
+0200
@@ -4,6 +4,7 @@
setup.cfg
setup.py
docs/Makefile
+docs/environment.yml
docs/make.bat
docs/source/conf.py
docs/source/doc_sanitize
@@ -29,10 +30,12 @@
tests/test_coalesce.ipynb
tests/test_collect.py
tests/test_coverage.py
+tests/test_ignore.py
tests/test_plugin.py
tests/test_timeouts.py
tests/test_unit_tests_in_notebooks.py
tests/utils.py
+tests/.ipynb_checkpoints/sample_notebook-checkpoint.ipynb
tests/ipynb-test-samples/test-exceptions-fail-storedmismatch.ipynb
tests/ipynb-test-samples/test-latex-fail-randomoutput.ipynb
tests/ipynb-test-samples/test-latex-pass-correctouput.ipynb
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/nbval-0.9.0/setup.py new/nbval-0.9.1/setup.py
--- old/nbval-0.9.0/setup.py 2018-01-16 11:19:41.000000000 +0100
+++ new/nbval-0.9.1/setup.py 2018-06-04 17:10:28.000000000 +0200
@@ -2,11 +2,16 @@
from nbval._version import __version__
+with open('README.md') as f:
+ readme = f.read()
+
setup(
name="nbval",
version=__version__,
author="Laslett, Cortes, Fauske, Kluyver, Pepper, Fangohr",
description='A py.test plugin to validate Jupyter notebooks',
+ long_description=readme,
+ long_description_content_type="text/markdown",
packages = ['nbval'],
url='https://github.com/computationalmodelling/nbval',
# the following makes a plugin available to pytest
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/nbval-0.9.0/tests/.ipynb_checkpoints/sample_notebook-checkpoint.ipynb
new/nbval-0.9.1/tests/.ipynb_checkpoints/sample_notebook-checkpoint.ipynb
--- old/nbval-0.9.0/tests/.ipynb_checkpoints/sample_notebook-checkpoint.ipynb
1970-01-01 01:00:00.000000000 +0100
+++ new/nbval-0.9.1/tests/.ipynb_checkpoints/sample_notebook-checkpoint.ipynb
2015-11-30 16:46:56.000000000 +0100
@@ -0,0 +1,172 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Sample notebook"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "This is a sample notebook which can be used to test the `py.test --ipynb`
plugin."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "%matplotlib inline\n",
+ "import matplotlib.pyplot as plt"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Hello world\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"Hello world\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "from datetime import datetime"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "datetime.datetime(2015, 4, 8, 14, 17, 21, 527210)"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# PYTEST_VALIDATE_IGNORE_OUTPUT\n",
+ "datetime.now()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Last executed: 2015-04-08, 14:30:02'"
+ ]
+ },
+ "execution_count": 31,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "#datetime.today().strftime(\"%a %y %b %Y, %H:%M:%S\")\n",
+ "datetime.today().strftime(\"Last executed: %Y-%m-%d, %H:%M:%S\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "<matplotlib.legend.Legend at 0xb9480ac>"
+ ]
+ },
+ "execution_count": 26,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png":
"iVBORw0KGgoAAAANSUhEUgAAAYgAAAEZCAYAAACNebLAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
+ "text/plain": [
+ "<matplotlib.figure.Figure at 0xb76c54c>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plt.plot([1, 2, 3, 4, 5], [1, 3, 2, 2.5, 1.5], 'o-', label='graph')\n",
+ "plt.xlabel('x')\n",
+ "plt.ylabel('y')\n",
+ "plt.title('Simple plot')\n",
+ "plt.legend(loc='best')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.4.3"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/nbval-0.9.0/tests/sample_notebook.ipynb
new/nbval-0.9.1/tests/sample_notebook.ipynb
--- old/nbval-0.9.0/tests/sample_notebook.ipynb 2017-02-10 15:26:52.000000000
+0100
+++ new/nbval-0.9.1/tests/sample_notebook.ipynb 2018-06-04 17:10:28.000000000
+0200
@@ -33,10 +33,8 @@
},
{
"cell_type": "code",
- "execution_count": 5,
- "metadata": {
- "collapsed": true
- },
+ "execution_count": 2,
+ "metadata": {},
"outputs": [],
"source": [
"from datetime import datetime"
@@ -53,16 +51,16 @@
},
{
"cell_type": "code",
- "execution_count": 6,
+ "execution_count": 3,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
- "datetime.datetime(2015, 4, 8, 14, 17, 21, 527210)"
+ "datetime.datetime(2018, 6, 1, 12, 33, 8, 310117)"
]
},
- "execution_count": 6,
+ "execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
@@ -80,7 +78,7 @@
{
"data": {
"text/plain": [
- "datetime.datetime(2017, 1, 3, 16, 6, 20, 529355)"
+ "datetime.datetime(2018, 6, 1, 12, 33, 9, 629357)"
]
},
"execution_count": 4,
@@ -105,7 +103,7 @@
{
"data": {
"text/plain": [
- "datetime.datetime(2017, 1, 3, 16, 6, 20, 543350)"
+ "datetime.datetime(2018, 6, 1, 12, 33, 11, 435879)"
]
},
"execution_count": 5,
@@ -120,7 +118,7 @@
},
{
"cell_type": "code",
- "execution_count": 5,
+ "execution_count": 6,
"metadata": {
"tags": [
"nbval-check-output"
@@ -130,10 +128,10 @@
{
"data": {
"text/plain": [
- "datetime.datetime(2017, 1, 3, 16, 6, 20, 543350)"
+ "datetime.datetime(2018, 6, 1, 12, 33, 12, 13278)"
]
},
- "execution_count": 5,
+ "execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
@@ -147,7 +145,7 @@
},
{
"cell_type": "code",
- "execution_count": 6,
+ "execution_count": 7,
"metadata": {
"tags": [
"nbval-ignore-output"
@@ -171,7 +169,7 @@
},
{
"cell_type": "code",
- "execution_count": 6,
+ "execution_count": 8,
"metadata": {
"tags": [
"nbval-check-output"
@@ -193,16 +191,16 @@
},
{
"cell_type": "code",
- "execution_count": 31,
+ "execution_count": 9,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
- "'Last executed: 2015-04-08, 14:30:02'"
+ "'Last executed: 2018-06-01, 12:33:15'"
]
},
- "execution_count": 31,
+ "execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
@@ -214,7 +212,7 @@
},
{
"cell_type": "code",
- "execution_count": 1,
+ "execution_count": 10,
"metadata": {
"scrolled": true
},
@@ -222,18 +220,18 @@
{
"data": {
"text/plain": [
- "<matplotlib.legend.Legend at 0x7fb310790150>"
+ "<matplotlib.legend.Legend at 0x7fae26a349b0>"
]
},
- "execution_count": 1,
+ "execution_count": 10,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
- "image/png":
"iVBORw0KGgoAAAANSUhEUgAAAYUAAAEZCAYAAAB4hzlwAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAH/NJREFUeJzt3XuU1PWZ5/H3wx3FqCwuIDS66Uk2yxmNmAQRI5SeI6C4\nXsboRBfBuBkNKniOMxMdLhGCnD3GiWvAM7NuNIZoNkrUiZfWkWhs8DKiIuINiRKNIsgYQUYu3YHm\n2T+quqwuqrt/VV2/+l3q8zqnj9VV3/r1w+/Y/dTzfer5lbk7IiIiAL2iDkBEROJDSUFERPKUFERE\nJE9JQURE8pQUREQkT0lBRETylBQklczsf5jZ4yEd++dmtiiE415iZk9X+7gi5VBSkMQys2+a2XNm\n9qmZfWJmz5jZ1wHc/ZfuPjmkH+25r8iYWbOZ/c8oY5B06hN1ACKVMLMvAI8AlwPLgf7AyUBrrUKo\n0c/pjKZOJRSqFCSpvgy4u9/rWS3u/lt3fw0O3Ioxs/1mNtPM3jaz/zCzH5pZo5n9W67SuMfM+ubW\nZsxsk5n9g5l9bGbvmtlFnQViZmea2Stmtt3MnjWzY7pYu9/MZpnZxtyxf2RmJROMmY03sxdz8b1g\nZifm7l9MNgHeamafmdmSis6gSAlKCpJUG4C23P7+FDM7PMBzJgFjgHHAtcBPgQuBUcAxudvthgL/\nCTgSmAH8XzP7UvEBzWwMcAfwN8Bg4DbgITPr10Uc5wBfA44HzgYuLXHcwUATcEvuuDcDTWZ2uLvP\nBZ4GrnT3Q9x9doB/u0ggSgqSSO7+GfBNstsoPwX+3cweNLP/3MXTfuTuO939TeA14DF3f8/d/wN4\njGzCKDTf3fe6+yqyf6D/ujCE3H8vA25z9xdzFcsvyG5hjesijhvd/VN3/4DsH/0LS6yZCmzI9Ub2\nu/s9wFvAWQVrot7CkhRSUpDEcve33P077t4A/CXZV/W3dPGUrQW39xR93wIMKvh+u7vvKfj+j8Dw\nEsc8Cvjb3NbRdjPbDozsZG27Dwpuv5+Lu9iRuccK/bForfoKUnVKCpIK7r4BWEY2OVR0iKLvDzez\ngwq+PwrYXOJ57wOL3f3wgq9B7n5vFz9rVNHtD0us+TD3MwsdVbBWCUFCoaQgiWRm/9XMrjGzEbnv\nG8huw/xbOYfp5Ha7hWbW18xOJrud8+uCte3rfwp8z8zGWtbBZjbVzAaVOF67vzOzw3IxzwZKJZDH\ngC+b2YVm1sfM/hr4Ctl3XEG2ymkM9K8UKYOSgiTVZ8AJwGoz20k2GbwK/G3u8eJZglKvrIsfL/z+\nI2A72ergLuByd/998Vp3X0O2yXwrsA14G5jeTewPAmuAtWT/yN9R4rifAGfm/j1/Av4OONPdt+XW\n/gT4lpltM7OutsxEymJhfciOmQ0AVpJ9/3g/4EF3/4cS65YApwO7gUvcfW0oAYkEZGYZ4K5cr6La\nx94P/IW7/6HaxxaphtCG19y9xcxOcffdZtYHeMbMvunuz7SvMbMzyP6CfMnMTgD+ma7ftSEiIiEK\ndfvI3XfnbvYDepMtrwudRbY5iLuvBg4zs6FhxiQSUFiNXDWIJdZCTQpm1svMXiHbFHsq9/7wQiPo\n+Pa8TWTfzicSGXdvdvdR3a+s6Ni9tXUkcRZ2pbDf3Y8j+4d+Qm6vtljxuz70SkpEJCI1uSCeu+8w\nsybg60BzwUMfAoXNvJGUeM+2mSlRiIhUwN3LmnwPrVIwsyFmdlju9kDgNLJvwSv0ELm375nZOOBT\nd99KCe4e+6/rr78+8hhKfU2aNJfP3+14ff725MnzIo8taedScSrOJMVZiTC3j4YDv8v1FFYDD7v7\nk2Z2uZldDuDujwJ/MLN3yF5I7IoQ46lbs2dPYuTIuR3u69VrDqeeelpEEYlIXIX5ltTXyF4Fsvj+\n24q+vyqsGCRr6tQJHHssDBgwn717n+YrX5nPuHFTuPXWCVx6KQwZEnWEIhIX+pCdKspkMlGHUFJL\nC6xePYGXX57AH/7QnI9zzx6YMQMefhh6xWy2Pa7nspjirC7FGb3QJpqrycw8CXHG1a9/DbfdBk88\n0fH+vXshk4Gzz4bvfz+S0EQkRGaGl9loVqVQB37+c7jkkgPv79sX7rkHvvENOOmk7JdI1Dr5IDrp\nRrVeOKtSSLktW2D0aNi0CQ4+uPSapiaYORNefln9BYle7tVt1GEkSmfnrJJKIWY7yVJtd98N553X\neUIAmDoVLrww21/Yv792sYlI/CgppJh751tHxW64AT79FP7xH8OOSkTiTD2FFHvpJWhtDdYrUH9B\nRECVQqq1VwlB+3YNDXDHHdmtpD/9KczIRKQr7733Hr169WJ/BPu5Sgop1dIC994L07v7DLAi6i+I\n1DclhZR6+GE47jgYVcEFoNVfkDhqalrF5MnzyGQWMHnyPJqaVkVyjCD27dsXynFrIuoLNgW8qJNL\nec44w/2uuyp//vvvuw8d6v7MM9WLSSSIUr/vjzyy0hsb53j27RPZr8bGOf7IIysDH7cax1izZo0f\nd9xxfsghh/j555/vF1xwgc+bN8+feuopHzFihN94440+bNgwnz59um/fvt2nTp3qRxxxhB9++OF+\n5pln+qZNm/LHmjhxol933XU+duxY/8IXvuBnn322b9u2zd3d3333XTczX7ZsmY8aNcqHDBniixcv\nLuucFdxf3t/bcp8QxZeSQnk2b3Y/7DD3nTt7dpxHHnFvaHD/+OPqxCUSRKnf90mT5nb4Y97+NXny\nvMDH7ekxWltbfdSoUb5kyRLft2+fP/DAA96vXz+fP3++Nzc3e58+ffy6667zP//5z75nzx7/5JNP\n/IEHHvA9e/b4Z5995ueff76fc845+eNNnDjRR4wY4W+88Ybv2rXLzzvvPJ82bZq7f54ULrvsMm9p\nafF169Z5//79ff369YHPWcH9Zf291fZRCgWZTQhC/QWJi9bW0m+UfPzx3pgR6GvFitLHaGnpHSiG\n559/nra2NmbNmkXv3r0599xzGTt2bP7xXr16sXDhQvr27cuAAQMYPHgw5557LgMGDGDQoEHMmTOH\nlStX5tebGdOnT2f06NEcdNBBLFq0iOXLl7e/EAbg+uuvp3///hx77LF89atfZd26dYFi7QklhZQp\nZzYhCPUXJA769y+9Rz95cluJ1/6lvyZNKn2MAQPaAsWwefNmRowY0eG+hoaG/B/xI444gn79+uUf\n2717N5dffjlHH300hx56KBMnTmTHjh0d/ug3NHz+GWOjRo1i7969/KngrX/Dhg3L3z7ooIPYtWtX\noFh7QkkhZcqZTQiifX7h5pvh2Werc0yRcs2ePYnGxo6fCdLYOIdZs4J/JkhPjzF8+HA+/LDjB0O+\n//77+Ws1FV+z6cc//jG///3veeGFF9ixYwcrV64s3BLPP7/wdt++fRkS8bVmNLyWMuXOJgRROL+g\n6yNJFKZOnQDA0qXzaWnpzYABbcyaNSV/fy2OMX78eHr37s2tt97K9773PZqamnjxxRc59dRTO/yh\nb7dz504GDhzIoYceyrZt21i4cGGHx92du+++m+nTp3PUUUfxgx/8gPPPP7/LCwKW+jnVpgvipUhL\nC4wcmf3DXclbUbtz7bXw+uvx/PwFSY84XxBvzZo1fPe73+Wdd97h9NNPp62tjTFjxnDyySdz8cUX\nd3jlv2XLFi666CJeeuklRowYwTXXXMPMmTPZu3cvvXr14pRTTuHEE0/kySef5K233iKTyXDnnXcy\nePBg3nvvPRobG/NrAU455RQuvvhiLr300gPiquYF8ZQUUqSzz02oFn3+gtRCnJNCsRNOOIErrriC\nGTNmlP3crv7Il0tXSZWSqtlgLkX9Bal3q1at4qOPPmLfvn0sW7aM119/nSlTplR8vDgmP/UUUmLL\nFnjuOVi+PNyfo/6C1LMNGzZwwQUXsGvXLhobG7nvvvsYOnRoxceL4wcKafsoJW66CTZsgNtvr83P\nU39BwpKk7aO40PaRdFDt2YQgNL8gkk7aPkqBas8mBKHPXxBJJ1UKKRDGbEIQ+vwFkfRRTyHhwp5N\nCEL9BammODZfk0A9BQF69rkJ1aL+glRTuVf11FfHS2f0lHoKCVfrBnMp6i+IpIe2jxJsyxYYPRo2\nber5ZbKroakJZs7U/IJIXGj7qM5U63MTqkWfvyCSfEoKCRXFbEIQ6i+IJJt6CgkVxWxCEOoviCSb\nKoWEimo2IQjNL4gklxrNCRSH2YQgNL8gEi01mutEHGYTglB/QSR51FNIoDg2mEtRf0EkebR9lDBx\nm00IQvMLItHQ9lEdiNtsQhCaXxBJDiWFBInrbEIQ6i+IJIN6CgkS19mEINRfEEkGVQoJEufZhCA0\nvyASf2o0J0RSZhOC0PyCSG2o0ZxiSZlNCEL9BZH4Uk8hIZLaYC5F/QWR+NL2UQIkcTYhCM0viIRL\n20cplcTZhCA0vyASP0oKMZfk2YQg1F8QiRf1FGIuybMJQai/IBIvoVUKZtZgZk+Z2Rtm9rqZzS6x\nJmNmO8xsbe5rXljxJFXSZxOC0PyCSHyE1mg2s2HAMHd/xcwGAWuAc9x9fcGaDHCNu5/VzbHqstGc\nptmEIDS/UL+amlaxZMkKWlv70L//PmbPnsTUqROiDivxKmk0h7Z95O4fAR/lbu80s/XAkcD6oqUp\nfg3cM2maTQjihhsgk8n2F77//aijkVppalrF1Vc/zsaNi/P3bdw4F0CJIQI1eT1mZkcDY4DVRQ85\nMN7M1pnZo2Y2uhbxJEWaG8yltPcXbr4Znn026mikVpYsWdEhIQBs3LiYpUt/G1FE9S30RnNu6+g+\n4Gp331n08MtAg7vvNrPTgd8AXy51nAULFuRvZzIZMplMKPHGxZYt8NxzsHx51JHUVmF/QfML9aG1\ntfSfoZaW3jWOJPmam5tpbm7u0TFCHV4zs77AI8Bj7n5LgPXvAl9z921F99ddT+Gmm2DDBrj99qgj\niYb6C/Xh44/hmGPmsXXrDQc8NnnyfP71XxdFEFV6xGp4zcwMuAN4s7OEYGZDc+sws7Fkk9S2Umvr\nSdpnE4LQ/EL63X8/HHssjB8/iS9+cW6Hx446ag6zZp0WUWT1Lczto5OAacCrZrY2d98cYBSAu98G\nfAuYaWb7gN3At0OMJzHSPpsQhOYX0uvjj+Gqq2DdOnjgATjxxAk0NcHSpfNpaenNhx+20b//FCZP\nVpM5Crr2UQxdeSUMHw7zNLWh6yOlzP33ZxPCtGnwwx/CwIEHrmlrgylTYNw4WKTdox6pZPtISSFm\n6m02IQj1F5KvsDq480448cSu12/dCscfn107aVJtYkyjWPUUpDL1NpsQhPoLydbeOxg1Ctau7T4h\nAAwdmr0Q5IwZsHlz+DHK51QpxEz7lUOnTYs6knj54INsf+H++9VfSIpyq4NSFi2CJ5+EJ56APrpS\nW9lUKSRc+2zCuedGHUn86PpIyVJJdVDKnDnZNx0sXFjd+KRzqhRipN5nE4JQfyHeqlEdFFN/oXKq\nFBJMswnBqL8QX9WqDoqpv1BbqhRi4sUXs1sjb7+d7stkV4P6C/ESRnVQivoL5VOlkGD18LkJ1aL+\nQnyEVR2Uov5CbahSiAHNJlRG/YXo1Ko6KKb+QnlUKSSUZhMqo/5CNGpZHRRTfyF8qhRiQLMJlVN/\noXaiqg5KUX8hGFUKCaTZhJ5Rf6E2oqwOSlF/ITyqFCKm2YTqUH8hHHGqDoqpv9A9VQoJo9mE6lF/\nofriVh0UU38hHKoUIqTZhOpSf6E64lwdlKL+QudUKSSMZhOqS/2Fnot7dVCK+gvVpUohIppNCI/6\nC+VLWnVQTP2F0lQpJIhmE8Kj/kJ5klgdFFN/oXpUKUREswnhUn+he0mvDkpRf6EjVQoJodmE8Km/\n0LU0VAelqL/Qc6oUIqDZhNpRf6GjNFYHxdRf+JwqhQTQbEJtqb/wubRWB8XUX+gZVQo1ptmE2qv3\n/kI9VAelqL+gSiERNJtQe/XcX6iX6qAU9Rcqo0qhhjSbEK166i/Ua3VQrN77C6oUYk6zCdGql/5C\nPVcHxdRfKJ8qhRrSbEL00txfUHXQuXrtL6hSiDHNJsRDWvsLqg66pv5CcKoUakSzCfGSlv6CqoPg\n6rG/oEohpjSbED9p6C+oOiiP+gvBqFKoAc0mxFNS+wuqDnqmnvoLqhRiSrMJ8ZTE/oKqg55Tf6Fr\nqhRCptmE+EtCf0HVQXXVS39BlUIMaTYh/uLeX1B1UH3qL3ROlULINJuQDHHsL6g6CF/a+wuqFGJG\nswnJEbf+gqqD2lB/4UCqFEKk2YTkibq/oOqg9tLcX1ClECOaTUimKPsLqg6iof5CR6oUQqLZhOSq\ndX9B1UE8pLG/oEohRjSbkFy17C+oOogP9ReyVCmEQLMJ6RBmf0HVQTylrb+gSiEmNJuQDmH1F1Qd\nxJf6C6oUQqHZhPSoZn9B1UFypKW/oEohBjSbkC7V6i+oOkiWeu4vqFKoMs0mpFOl/QVVB8mVhv6C\nKoWIaTYhvSrpL6g6SLZ67S+oUqgizSakW9D+gqqDdElyfyFWlYKZNZjZU2b2hpm9bmazO1m3xMze\nNrN1ZjYmrHhqQbMJ6Rakv6DqIH3qrb8QWqVgZsOAYe7+ipkNAtYA57j7+oI1ZwBXufsZZnYC8BN3\nH1fiWLGvFDSbUD+uvRZ+97tVDB68gtbWPvTvv48ZMybx4IMTVB2kVFL7C5VUCt0WQ7lX+He5+/Zy\nDuzuHwEf5W7vNLP1wJHA+oJlZwHLcmtWm9lhZjbU3beW87PiQLMJ9WP8+FX85CeP09q6OH/fk0/O\n5ayzYO3aCQwcGGFwEor2/sJFF8GaNXDkkVFHFJ4g20dDgRfNbLmZTTErf3PEzI4GxgCrix4aAXxQ\n8P0mYGS5x48DNZjrxz/904oOCQGgrW0xu3f/VgkhxU45Ba64IpsY9u2LOprwdFspuPtcM5sPTAIu\nAW41s+XAHe6+sbvn57aO7gOudvedpZYU/8hSx1mwYEH+diaTIZPJdPeja6Z9NmH58qgjkVpobS39\na9PS0rvGkUitzZkDq1Zl+wuLFkUdzYGam5tpbm7u0TEC9dLdfb+ZfQRsBdqAw4H7zOwJd//7zp5n\nZn2B+4G73f03JZZ8CDQUfD8yd98BCpNC3Nx9N5x3Hhx8cNSRSC3071/6ZeKAAW01jkRqrXfv7O/7\n8cfDySfHr79Q/IJ5YQXd8W63j8zsajNbA/wIeBb4S3efCXwN+KsunmfAHcCb7n5LJ8seAqbn1o8D\nPk1aP0GzCfVn9uxJNDbO7XBfY+McZs06LaKIpJbSPr8QpFIYDPyVu/+x8M5c9fDfu3jeScA04FUz\nW5u7bw4wKvf829z9UTM7w8zeAXYB3yn7XxCxl16C1tb4fK6vhG/q1AkALF06n5aW3gwY0MasWVPy\n90v6FfYXkji/0BUNr/XQlVfC8OEwb17UkYhILbW1wZQpMG5cPPsLUNlbUpUUekCzCSL1Le7zC7Ga\naK4Hmk0QqW9p7C8oKfSAGswikrb5BW0fVWjLFhg9GjZt0ltRRepdXPsL2j6qIc0miEi79vmFn/0M\nVqyIOpqeUVKogGYTRKRYWvoLSgoV0GyCiJSShv6CkkIF9LkJItKZpH/+ghrNZdJsgoh0Jy7zC2o0\n14BmE0SkO0nuLygplEkNZhEJIqn9BW0flUGzCSJSjqjnF7R9FDLNJohIOZI4v6CkEJBmE0SkEknr\nLygpBKTZBBGpVJL6C0oKAWk2QUR6IinzC2o0B6DZBBGphlrPL6jRHBLNJohINSShv6CkEIAazCJS\nLXHvL2j7qBuaTRCRaqvV/IK2j0Kg2QQRqbY4zy8oKXRBswkiEpa49heUFLqg2QQRCVMc+wtKCl3Q\nbIKIhC1u8wtqNHdCswkiUithzS+o0VxFmk0QkVqJU39BSaETajCLSC3Fpb+g7aMSNJsgIlGo9vyC\nto+qRLMJIhKFOMwvKCkU0WyCiEQp6v6CkkIRzSaISNSi7C8oKRTRbIKIxEFU8wtqNBfQbIKIxElP\n5xfUaO4hzSaISJxE0V9QUiigBrOIxE2t+wvaPsrRbIKIxFWl8wvaPuoBzSaISFzVcn5BSQHNJohI\n/NWqv6CkgGYTRCQZatFfUFJAswkikhxhzy/UfaNZswkikjRB5xfUaK6AZhNEJGnC7C/UfVJQg1lE\nkiis/kJdbx9pNkFEkqy7+QVtH5VJswkikmRhzC/UbVLQbIKIpEG1+wt1mxQ0myAiaVHN/kKoScHM\nfmZmW83stU4ez5jZDjNbm/uaF2Y8hTSbICJpUq35hT7VCadTdwJLgV90sWalu58VchwdtLTAvfdm\nZxNERNKgvb9w/PHQr98qnnmmsiZDqJWCuz8NbO9mWc1fq2s2QUTSaOhQuOqqVSxc+DgrVtxQ0TGi\n7ik4MN7M1pnZo2Y2uhY/VA1mEUmr5uYVtLUtrvj5YW8fdedloMHdd5vZ6cBvgC+XWrhgwYL87Uwm\nQyaTqegHbtkCzz0Hy5dX9HQRkdhqbm5mw4ZngAUVHyP04TUzOxp42N2PCbD2XeBr7r6t6P6qDa/d\ndBNs2AC3316Vw4mIxMrkyfMKto4SNrxmZkPNsu//MbOxZJPUtm6eVjHNJohI2s2ePYnGxrkVPz/U\n7SMz+xUwERhiZh8A1wN9Adz9NuBbwEwz2wfsBr4dZjyaTRCRtJs6dQIAS5fO5/HHy39+XV376Mor\nYfhwmFezaQgRkehUcu2jukkK+twEEak3uiBeFzSbICLSvbpJCmowi4h0ry62j/S5CSJSj7R91Al9\nboKISDCpTwqaTRARCS71SUGzCSIiwaU+KehzE0REgkt1o1mzCSJSz9RoLqLZBBGR8qQ6KajBLCJS\nntRuH2k2QUTqnbaPCmg2QUSkfKlMCppNEBGpTCqTgmYTREQqk8qkoNkEEZHKpK7RrNkEEZEsNZrR\nbIKISE+kLimowSwiUrlUbR9pNkFE5HN1v32k2QQRkZ5JTVLQbIKISM+lJiloNkFEpOdSkxQ0myAi\n0nOpaDRrNkFE5EB122jWbIKISHWkIimowSwiUh2J3z7SbIKISGl1uX2k2QQRkepJdFLQbIKISHUl\nOiloNkFEpLoSnRQ0myAiUl2JbTRrNkFEpGt11WjWbIKISPUlNimowSwiUn2J3D7SbIKISPfqZvtI\nswkiIuFIXFLQbIKISHgSlxQ0myAiEp7EJQXNJoiIhCdRjWbNJoiIBJf6RrNmE0REwpWopKAGs4hI\nuBKzfbR5s2s2QUSkDKnePtJsgohI+BKTFLR1JCISvlCTgpn9zMy2mtlrXaxZYmZvm9k6MxvT2TrN\nJoiIhC/sSuFOYEpnD5rZGcBfuPuXgMuAf+5sbRJmE5qbm6MOoVtJiBEUZ7UpzupKSpyVCDUpuPvT\nwPYulpwFLMutXQ0cZmZDSy1csWIeTU2rqh9kFSXhf5QkxAiKs9oUZ3UlJc5K9In4548APij4fhMw\nEthavPDpp29g8+a5AEydOqEmwYmI1Js4NJqLN4U6fY/sxo2LWbr0tyGHIyJSv0KfUzCzo4GH3f2Y\nEo/9H6DZ3e/Jff8WMNHdtxati/8whYhIDJU7pxD19tFDwFXAPWY2Dvi0OCFA+f8oERGpTKhJwcx+\nBUwEhpjZB8D1QF8Ad7/N3R81szPM7B1gF/CdMOMREZGuJeIyFyIiUhtxaDQD1R10C1N3cZpZxsx2\nmNna3Ne8CGJsMLOnzOwNM3vdzGZ3si7S8xkkzpiczwFmttrMXjGzN83sf3WyLurz2W2ccTifuTh6\n537+w508Hvnvei6OTuOM0bl8z8xezcXwQidrgp9Pd4/FF3AyMAZ4rZPHzwAezd0+AXg+pnFmgIci\nPpfDgONytwcBG4D/FrfzGTDOyM9nLo6Dcv/tAzwPfDNu5zNgnHE5n9cAvywVS1zOZYA443Iu3wUG\nd/F4WeczNpWCV3HQLUwB4oQD32ZbU+7+kbu/kru9E1gPHFm0LPLzGTBOiPh8Arj77tzNfkBvYFvR\nksjPZ+5ndxcnRHw+zWwk2T9Ut3cSSyzOZYA46eL+WusqjrLOZ2ySQgCdDbrFjQPjc2Xao2Y2Ospg\ncm8JHgOsLnooVuezizhjcT7NrJeZvUJ2sPIpd3+zaEkszmeAOONwPv838PfA/k4ej8W5pPs443Au\n2+N4wsxeMrO/KfF4WeczSUkByhh0i9DLQIO7fxVYCvwmqkDMbBBwH3B17pX4AUuKvo/kfHYTZyzO\np7vvd/fjyP4yTTCzTIllkZ/PAHFGej7N7Ezg3919LV2/uo30XAaMMxb/bwInufsY4HTgSjM7ucSa\nwOczSUnhQ6Ch4PuRuftixd0/ay/h3f0xoK+ZDa51HGbWF7gfuNvdS/3PGovz2V2ccTmfBfHsAJqA\nrxc9FIvz2a6zOGNwPscDZ5nZu8CvgFPN7BdFa+JwLruNMwbnsj2OLbn/fgz8CzC2aElZ5zNJSeEh\nYDpAV4NuUTOzoWbZ67ma2Viyb/stta8bZgwG3AG86e63dLIs8vMZJM6YnM8hZnZY7vZA4DRgbdGy\nOJzPbuOM+ny6+xx3b3D3/wJ8G/idu08vWhb5uQwSZ9TnMvdzDzKzQ3K3DwYmAcXvjCzrfEY90Zxn\nCRl06y5O4FvATDPbB+wm+z9UrZ0ETANeNbP2PwpzgFHtccbkfHYbJ/E4n8OBZWbWi+wLqbvc/Ukz\nu7w9zpicz27jJB7ns5ADxPBcFjsgTuJxLocC/5LLTX2AX7r7ip6cTw2viYhIXpK2j0REJGRKCiIi\nkqekICIieUoKIiKSp6QgIiJ5SgoiIpKnpCAiInlKCiIikqekIFImM/tG7sqY/c3sYMt+QFCkV8MV\nqRZNNItUwMwWAQOAgcAH7n5jxCGJVIWSgkgFcld3fQnYA5zo+kWSlND2kUhlhgAHk/0Y0YERxyJS\nNaoURCpgZg8B/w/4IjDc3WdFHJJIVcTm0tkiSWFm04FWd78nd5nq58ws4+7NEYcm0mOqFEREJE89\nBRERyVNSEBGRPCUFERHJU1IQEZE8JQUREclTUhARkTwlBRERyVNSEBGRvP8Ppe3kWKiNlv0AAAAA\nSUVORK5CYII=\n",
+ "image/png":
"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\n",
"text/plain": [
- "<matplotlib.figure.Figure at 0x7fb33d56dfd0>"
+ "<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {},
@@ -313,21 +311,21 @@
"metadata": {
"celltoolbar": "Tags",
"kernelspec": {
- "display_name": "Python 2",
+ "display_name": "Python 3",
"language": "python",
- "name": "python2"
+ "name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
- "version": 2
+ "version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
- "pygments_lexer": "ipython2",
- "version": "2.7.6"
+ "pygments_lexer": "ipython3",
+ "version": "3.5.2"
}
},
"nbformat": 4,
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/nbval-0.9.0/tests/test_coverage.py
new/nbval-0.9.1/tests/test_coverage.py
--- old/nbval-0.9.0/tests/test_coverage.py 2017-04-05 16:38:49.000000000
+0200
+++ new/nbval-0.9.1/tests/test_coverage.py 2018-06-04 17:10:28.000000000
+0200
@@ -37,13 +37,13 @@
"lib.myprod(1, 3)",
"lib.myprod(2.5, 2.5)",
"lib.myprod(2, 'cat')"
- ])
+ ], mark_run=True)
add_expected_plaintext_outputs(nb, [
None, "3", "6.25", "'catcat'"
])
# Write notebook to test dir
nbformat.write(nb, os.path.join(
- str(testdir.tmpdir), 'test_timeouts.ipynb'))
+ str(testdir.tmpdir), 'test_coverage.ipynb'))
# Run tests
result = testdir.runpytest_inprocess('--nbval', '--current-env', '--cov',
'.')
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/nbval-0.9.0/tests/test_ignore.py
new/nbval-0.9.1/tests/test_ignore.py
--- old/nbval-0.9.0/tests/test_ignore.py 1970-01-01 01:00:00.000000000
+0100
+++ new/nbval-0.9.1/tests/test_ignore.py 2018-06-04 17:10:28.000000000
+0200
@@ -0,0 +1,57 @@
+
+import os
+import re
+
+import nbformat
+from utils import build_nb
+
+pytest_plugins = "pytester"
+
+
+_ignore_stderr_code = """
+def pytest_collectstart(collector):
+ if collector.fspath and collector.fspath.ext == '.ipynb':
+ collector.skip_compare += ('stderr',)
+"""
+
+
+def test_conf_ignore_stderr(testdir):
+
+ # Setup test config
+ testdir.makeconftest(_ignore_stderr_code)
+
+ # Setup notebook with stream outputs
+ nb = build_nb([
+ "import sys",
+ "sys.stdout.write('test\\n')",
+ "sys.stderr.write('error output\\n')",
+ "sys.stdout.write('test\\n')\nsys.stderr.write('error output\\n')",
+ ], mark_run=True)
+ nb.cells[1].outputs.append(nbformat.v4.new_output(
+ 'stream',
+ text=u'test\n',
+ ))
+ nb.cells[2].outputs.append(nbformat.v4.new_output(
+ 'stream',
+ name='stderr',
+ text=u'different error output',
+ ))
+ nb.cells[3].outputs.append(nbformat.v4.new_output(
+ 'stream',
+ text=u'test\n',
+ ))
+ nb.cells[3].outputs.append(nbformat.v4.new_output(
+ 'stream',
+ name='stderr',
+ text=u'different error output',
+ ))
+
+ # Write notebook to test dir
+ nbformat.write(nb, os.path.join(
+ str(testdir.tmpdir), 'test_ignore.ipynb'))
+
+ # Run tests
+ result = testdir.runpytest_subprocess('--nbval', '--current-env', '.')
+
+ # Check tests went off as they should:
+ assert result.ret == 0
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/nbval-0.9.0/tests/utils.py
new/nbval-0.9.1/tests/utils.py
--- old/nbval-0.9.0/tests/utils.py 2017-04-05 16:38:49.000000000 +0200
+++ new/nbval-0.9.1/tests/utils.py 2018-06-04 17:10:28.000000000 +0200
@@ -2,12 +2,17 @@
import nbformat
-def build_nb(sources):
+def build_nb(sources, mark_run=False):
"""Builds a notebook of only code cells, from a list of sources
"""
nb = nbformat.v4.new_notebook()
+ execution_count = 1
for src in sources:
- nb.cells.append(nbformat.v4.new_code_cell(src))
+ cell = nbformat.v4.new_code_cell(src)
+ if mark_run:
+ cell.execution_count = execution_count
+ execution_count += 1
+ nb.cells.append(cell)
return nb
