scipy-doctest 1.7.1__tar.gz → 2.0.0__tar.gz

{scipy_doctest-1.7.1 → scipy_doctest-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scipy_doctest
-Version: 1.7.1
+Version: 2.0.0
 Summary: Configurable, whitespace-insensitive, floating-point-aware doctest helpers.
 Maintainer-email: SciPy developers <scipy-dev@python.org>
 Requires-Python: >=3.8
@@ -17,7 +17,7 @@ Requires-Dist: furo==2024.8.6 ; extra == "doc"
 Requires-Dist: myst-parser==4.0.0 ; extra == "doc"
 Requires-Dist: sphinx==8.1.3 ; extra == "doc"
 Requires-Dist: sphinx-copybutton==0.5.2 ; extra == "doc"
-Requires-Dist: scipy <= 1.14.1 ; extra == "test"
+Requires-Dist: scipy ; extra == "test"
 Requires-Dist: matplotlib ; extra == "test"
 Project-URL: Home, https://github.com/scipy/scipy_doctest
 Provides-Extra: doc
@@ -176,6 +176,21 @@ $ pytest --pyargs <your-package> --doctest-modules --doctest-collect=api
 See [More fine-grained control](#more-fine-grained-control) section
 for details on how to customize the behavior.
 
+**NOTE** In versions 1.x, `pytest --doctest-modules` was only collecting doctests, and
+skipped 'regular' unit tests. This differed from the vanilla `pytest` behavior, which
+collects both doctests and unit tests.
+
+The behavior was changed in version 2.0: from `scipy-doctest==2.0` the default is
+changed to align with the vanilla `pytest`.
+
+To retain the previous behavior and skip 'regular' unit tests, use the
+`--doctest-only-doctests` CLI option:
+
+```
+$ pytest --doctest-modules --doctest-only-doctests=true
+```
+
+
 ### Basic usage
 
 The use of `pytest` is optional, and you can use the `doctest` layer API.
@@ -316,18 +331,18 @@ NumPy wraps `scipy-doctest` with the `spin` command
 $ spin check-docs
 ```
 
-SciPy wraps `scipy-doctest` with custom `dev.py` commands:
+In SciPy, the name of the `spin` command is `smoke-docs`::
 
 ```
-$ python dev.py smoke-docs    # check docstrings
-$ python dev.py smoke-tutorials   # ReST user guide tutorials
+$ spin smoke-docs    # check docstrings
+$ spin smoke-tutorials   # ReST user guide tutorials
 ```
 
 ## Rough edges and sharp bits
 
 Here is a (non-exhaustive) list of possible gotchas:
 
-- _In-place development builds_.
+#### _In-place development builds_.
 
 Some tools (looking at you `meson-python`) simulate in-place builds with a
 `build-install` directory. If this directory is located under the project root,
@@ -351,10 +366,10 @@ If push really comes to shove, you may try using the magic env variable:
 however the need usually indicates an issue with the package itself.
 (see [gh-107](https://github.com/scipy/scipy_doctest/pull/107) for an example).
 
-- _Optional dependencies are not that optional_
+#### _Optional dependencies are not that optional_
 
 If your package contains optional dependencies, doctests do not know about them
-being optional. So you either guard the imports in doctests (yikes!), or
+being optional. So you either guard the imports in doctests themselves (yikes!), or
 the collections fails if dependencies are not available.
 
 The solution is to explicitly `--ignore` the paths to modules with optionals.
@@ -370,7 +385,7 @@ Note that installed packages are no different:
 $ pytest --pyargs scipy --doctest-modules --ignore=/path/to/installed/scipy/_lib
 ```
 
-- _Doctest collection strategies_
+#### _Doctest collection strategies_
 
 The default collection strategy follows `doctest` module and `pytest`. This leads
 to duplicates if your package has the split between public and \_private modules,
@@ -380,19 +395,19 @@ objects will be collected.
 
 The decision on what is public is as follows: an object is public iff
 
-- it is included into the `__all__` list of a public module;
-- the name of the object does not have a leading underscore;
-- the name of the module from which the object is collected does not have
+  - it is included into the `__all__` list of a public module;
+  - the name of the object does not have a leading underscore;
+  - the name of the module from which the object is collected does not have
   a leading underscore.
 
 Consider an example: `scipy.linalg.det` is defined in `scipy/linalg/_basic.py`,
 so it is collected twice, from `_basic.py` and from `__init__.py`. The rule above
 leads to
 
-- `scipy.linalg._basic.det`, collected from `scipy/linalg/_basic.py`, is private.
-- `scipy.linalg.det`, collected from `scipy/linalg/__init__.py`, is public.
+  - `scipy.linalg._basic.det`, collected from `scipy/linalg/_basic.py`, is private.
+  - `scipy.linalg.det`, collected from `scipy/linalg/__init__.py`, is public.
 
-- _`pytest`'s assertion rewriting_
+#### _`pytest`'s assertion rewriting_
 
 In some rare cases you may need to either explicitly register the `scipy_doctest`
 package with the `pytest` assertion rewriting machinery, or ask it to avoid rewriting
@@ -404,6 +419,21 @@ In general, rewriting assertions is not very useful for doctests, as the
 output on error is fixed by the doctest machinery anyway. Therefore, we believe
 adding `--assert=plain` is reasonable.
 
+#### _Mixing strings and numbers_
+
+Generally, we aim to handle mixtures of strings and numeric data. Deeply nested data
+structures, however, may cause the checker to fall back to the vanilla `doctest` literal
+checking. For instance, `["value", 1/3]` will use the floating-point aware checker, and
+so will `{"value": 1/3, "other value": 2/3}` or `[(1, 2), (3, 4)]`; Meanwhile, nested
+dictionaries, `{"a": dict(value=1/3)}`, or lists of tuples with mixed entries,
+`[("a", 1/3), ("b", 2/3)]`, will currently fall back to vanilla `doctest` literal
+comparisons.
+
+We stress that no matter how tricky or deeply nested the output is, the worst case
+scenario is that the floating-point aware checker is not used. If you have a case where
+`doctest` works correctly and `scipy_doctest` does not, please report it as a bug.
+
+
 ## Prior art and related work
 
 - `pytest` provides some limited floating-point aware `NumericLiteralChecker`.
@@ -411,24 +441,30 @@ adding `--assert=plain` is reasonable.
 - `pytest-doctestplus` plugin from the `AstroPy` project has similar goals.
   The package is well established and widely used. From a user perspective, main
   differences are: (i) `pytest-doctestplus` is more sensitive to formatting,
-  including whitespace---thus if numpy tweaks its output formatting, doctests
-  may start failing; (ii) there is still a need for `# doctest: +FLOAT_CMP`
+  including whitespace; (ii) there is still a need for `# doctest: +FLOAT_CMP`
   directives.
 
-  This project takes a different approach: in addition to plugging into `pytest`,
-  we closely follow the `doctest` API and implementation, which are naturally
-  way more stable then `pytest`.
+  This project takes a slightly different approach: we strive to make numeric comparisons
+  whitespace insensitive and automatic, without a need for explicit markup.  For rare cases
+  which require additional configuration, we either keep it in the tool (thus out of
+  reader-visible docstrings), or provide human-readable markers (hence `# may vary`
+  not `# doctest +SKIP`).
+  Furthermore, in addition to plugging into `pytest`, we provide an API layer which closely
+  follows the `doctest` API. Essentially all aspects of doctesting are user-configurable.
+
+- `xdoctest` package relies on a deeper rewrite of the standard-library `doctest`
+  functionality, and uses an AST-based analysis to parse code examples out of docstrings.
 
 - `NumPy` and `SciPy` were using modified doctesting in their `refguide-check` utilities.
-  These utilities are tightly coupled to their libraries, and have been reported
+  These utilities were tightly coupled to their libraries, and have been reported
   to be not easy to reason about, work with, and extend to other projects.
 
-  This project is mainly the core functionality of the modified
-  `refguide-check` doctesting, extracted to a separate package.
-  We believe having it separate simplifies both addressing the needs of these
-  two packages, and potential adoption by other projects.
+  This project is mainly the core functionality of the modified `refguide-check` doctesting,
+  extracted to a separate package. We believe having it separate simplifies both
+  addressing the needs of these two packages, and adoption by other projects.
+
 
-### Bug reports, feature requests and contributions
+## Bug reports, feature requests and contributions
 
 This package is work in progress. Contributions are most welcome!
 Please don't hesitate to open an issue in the tracker or send a pull request.

{scipy_doctest-1.7.1 → scipy_doctest-2.0.0}/README.md

@@ -151,6 +151,21 @@ $ pytest --pyargs <your-package> --doctest-modules --doctest-collect=api
 See [More fine-grained control](#more-fine-grained-control) section
 for details on how to customize the behavior.
 
+**NOTE** In versions 1.x, `pytest --doctest-modules` was only collecting doctests, and
+skipped 'regular' unit tests. This differed from the vanilla `pytest` behavior, which
+collects both doctests and unit tests.
+
+The behavior was changed in version 2.0: from `scipy-doctest==2.0` the default is
+changed to align with the vanilla `pytest`.
+
+To retain the previous behavior and skip 'regular' unit tests, use the
+`--doctest-only-doctests` CLI option:
+
+```
+$ pytest --doctest-modules --doctest-only-doctests=true
+```
+
+
 ### Basic usage
 
 The use of `pytest` is optional, and you can use the `doctest` layer API.
@@ -291,18 +306,18 @@ NumPy wraps `scipy-doctest` with the `spin` command
 $ spin check-docs
 ```
 
-SciPy wraps `scipy-doctest` with custom `dev.py` commands:
+In SciPy, the name of the `spin` command is `smoke-docs`::
 
 ```
-$ python dev.py smoke-docs    # check docstrings
-$ python dev.py smoke-tutorials   # ReST user guide tutorials
+$ spin smoke-docs    # check docstrings
+$ spin smoke-tutorials   # ReST user guide tutorials
 ```
 
 ## Rough edges and sharp bits
 
 Here is a (non-exhaustive) list of possible gotchas:
 
-- _In-place development builds_.
+#### _In-place development builds_.
 
 Some tools (looking at you `meson-python`) simulate in-place builds with a
 `build-install` directory. If this directory is located under the project root,
@@ -326,10 +341,10 @@ If push really comes to shove, you may try using the magic env variable:
 however the need usually indicates an issue with the package itself.
 (see [gh-107](https://github.com/scipy/scipy_doctest/pull/107) for an example).
 
-- _Optional dependencies are not that optional_
+#### _Optional dependencies are not that optional_
 
 If your package contains optional dependencies, doctests do not know about them
-being optional. So you either guard the imports in doctests (yikes!), or
+being optional. So you either guard the imports in doctests themselves (yikes!), or
 the collections fails if dependencies are not available.
 
 The solution is to explicitly `--ignore` the paths to modules with optionals.
@@ -345,7 +360,7 @@ Note that installed packages are no different:
 $ pytest --pyargs scipy --doctest-modules --ignore=/path/to/installed/scipy/_lib
 ```
 
-- _Doctest collection strategies_
+#### _Doctest collection strategies_
 
 The default collection strategy follows `doctest` module and `pytest`. This leads
 to duplicates if your package has the split between public and \_private modules,
@@ -355,19 +370,19 @@ objects will be collected.
 
 The decision on what is public is as follows: an object is public iff
 
-- it is included into the `__all__` list of a public module;
-- the name of the object does not have a leading underscore;
-- the name of the module from which the object is collected does not have
+  - it is included into the `__all__` list of a public module;
+  - the name of the object does not have a leading underscore;
+  - the name of the module from which the object is collected does not have
   a leading underscore.
 
 Consider an example: `scipy.linalg.det` is defined in `scipy/linalg/_basic.py`,
 so it is collected twice, from `_basic.py` and from `__init__.py`. The rule above
 leads to
 
-- `scipy.linalg._basic.det`, collected from `scipy/linalg/_basic.py`, is private.
-- `scipy.linalg.det`, collected from `scipy/linalg/__init__.py`, is public.
+  - `scipy.linalg._basic.det`, collected from `scipy/linalg/_basic.py`, is private.
+  - `scipy.linalg.det`, collected from `scipy/linalg/__init__.py`, is public.
 
-- _`pytest`'s assertion rewriting_
+#### _`pytest`'s assertion rewriting_
 
 In some rare cases you may need to either explicitly register the `scipy_doctest`
 package with the `pytest` assertion rewriting machinery, or ask it to avoid rewriting
@@ -379,6 +394,21 @@ In general, rewriting assertions is not very useful for doctests, as the
 output on error is fixed by the doctest machinery anyway. Therefore, we believe
 adding `--assert=plain` is reasonable.
 
+#### _Mixing strings and numbers_
+
+Generally, we aim to handle mixtures of strings and numeric data. Deeply nested data
+structures, however, may cause the checker to fall back to the vanilla `doctest` literal
+checking. For instance, `["value", 1/3]` will use the floating-point aware checker, and
+so will `{"value": 1/3, "other value": 2/3}` or `[(1, 2), (3, 4)]`; Meanwhile, nested
+dictionaries, `{"a": dict(value=1/3)}`, or lists of tuples with mixed entries,
+`[("a", 1/3), ("b", 2/3)]`, will currently fall back to vanilla `doctest` literal
+comparisons.
+
+We stress that no matter how tricky or deeply nested the output is, the worst case
+scenario is that the floating-point aware checker is not used. If you have a case where
+`doctest` works correctly and `scipy_doctest` does not, please report it as a bug.
+
+
 ## Prior art and related work
 
 - `pytest` provides some limited floating-point aware `NumericLiteralChecker`.
@@ -386,24 +416,30 @@ adding `--assert=plain` is reasonable.
 - `pytest-doctestplus` plugin from the `AstroPy` project has similar goals.
   The package is well established and widely used. From a user perspective, main
   differences are: (i) `pytest-doctestplus` is more sensitive to formatting,
-  including whitespace---thus if numpy tweaks its output formatting, doctests
-  may start failing; (ii) there is still a need for `# doctest: +FLOAT_CMP`
+  including whitespace; (ii) there is still a need for `# doctest: +FLOAT_CMP`
   directives.
 
-  This project takes a different approach: in addition to plugging into `pytest`,
-  we closely follow the `doctest` API and implementation, which are naturally
-  way more stable then `pytest`.
+  This project takes a slightly different approach: we strive to make numeric comparisons
+  whitespace insensitive and automatic, without a need for explicit markup.  For rare cases
+  which require additional configuration, we either keep it in the tool (thus out of
+  reader-visible docstrings), or provide human-readable markers (hence `# may vary`
+  not `# doctest +SKIP`).
+  Furthermore, in addition to plugging into `pytest`, we provide an API layer which closely
+  follows the `doctest` API. Essentially all aspects of doctesting are user-configurable.
+
+- `xdoctest` package relies on a deeper rewrite of the standard-library `doctest`
+  functionality, and uses an AST-based analysis to parse code examples out of docstrings.
 
 - `NumPy` and `SciPy` were using modified doctesting in their `refguide-check` utilities.
-  These utilities are tightly coupled to their libraries, and have been reported
+  These utilities were tightly coupled to their libraries, and have been reported
   to be not easy to reason about, work with, and extend to other projects.
 
-  This project is mainly the core functionality of the modified
-  `refguide-check` doctesting, extracted to a separate package.
-  We believe having it separate simplifies both addressing the needs of these
-  two packages, and potential adoption by other projects.
+  This project is mainly the core functionality of the modified `refguide-check` doctesting,
+  extracted to a separate package. We believe having it separate simplifies both
+  addressing the needs of these two packages, and adoption by other projects.
+
 
-### Bug reports, feature requests and contributions
+## Bug reports, feature requests and contributions
 
 This package is work in progress. Contributions are most welcome!
 Please don't hesitate to open an issue in the tracker or send a pull request.

{scipy_doctest-1.7.1 → scipy_doctest-2.0.0}/pyproject.toml

@@ -25,7 +25,7 @@ dependencies  = [
 
 [project.optional-dependencies]
 test = [
-    "scipy <= 1.14.1",   # black-list 1.5.1 ?
+    "scipy",
     "matplotlib"
 ]
 doc = [

{scipy_doctest-1.7.1 → scipy_doctest-2.0.0}/scipy_doctest/__init__.py

@@ -3,7 +3,7 @@ Configurable, whitespace-insensitive, floating-point-aware doctest helpers.
 """
 
 
-__version__ = "1.7.1"
+__version__ = "2.0.0"
 
 try:
     # register internal modules with pytest; obscure errors galore otherwise

{scipy_doctest-1.7.1 → scipy_doctest-2.0.0}/scipy_doctest/impl.py

@@ -2,6 +2,7 @@ import re
 import warnings
 import inspect
 import doctest
+import operator
 from doctest import NORMALIZE_WHITESPACE, ELLIPSIS, IGNORE_EXCEPTION_DETAIL
 from itertools import zip_longest
 from sys import version_info
@@ -78,7 +79,7 @@ class DTConfig:
         Default is False.
     pytest_extra_ignore : list
         A list of names/modules to ignore when run under pytest plugin. This is
-        equivalent to using `--ignore=...` cmdline switch.
+        equivalent to using ``--ignore=...`` cmdline switch.
     pytest_extra_skip : dict
         Names/modules to skip when run under pytest plugin. This is
         equivalent to decorating the doctest with `@pytest.mark.skip` or adding
@@ -91,6 +92,12 @@ class DTConfig:
         adding `# may vary` to the outputs of all examples.
         Each key is a doctest name to skip, and the corresponding value is
         a string. If not empty, the string value is used as the skip reason.
+    pytest_extra_requires : dict
+        Paths or functions to conditionally ignore unless requirements are met.
+        The format is ``{path/or/glob/pattern: requirement(s), full.func.name: requirement(s)}``,
+        where the values are PEP 508 dependency specifiers. If a requirement is not met,
+        the behavior is equivalent to using the ``--ignore=...`` command line switch for
+        paths, and to using a `pytest_extra_skip` for function names.
     CheckerKlass : object, optional
         The class for the Checker object. Must mimic the ``DTChecker`` API:
         subclass the `doctest.OutputChecker` and make the constructor signature
@@ -124,6 +131,7 @@ class DTConfig:
                           pytest_extra_ignore=None,
                           pytest_extra_skip=None,
                           pytest_extra_xfail=None,
+                          pytest_extra_requires=None,
     ):
         ### DTChecker configuration ###
         self.CheckerKlass = CheckerKlass or DTChecker
@@ -216,6 +224,7 @@ class DTConfig:
         self.pytest_extra_ignore = pytest_extra_ignore or []
         self.pytest_extra_skip = pytest_extra_skip or {}
         self.pytest_extra_xfail = pytest_extra_xfail or {}
+        self.pytest_extra_requires = pytest_extra_requires or {}
 
 
 def try_convert_namedtuple(got):
@@ -413,6 +422,22 @@ class DTChecker(doctest.OutputChecker):
         if is_list_or_tuple and type(a_want) is not type(a_got):
             return False
 
+        # dicts and other mappings need special treatment
+        want_is_dict = hasattr(a_want, 'items')
+        got_is_dict = hasattr(a_got, 'items')
+        if operator.xor(want_is_dict, got_is_dict):
+            # either both are dicts or both are not
+            return False
+
+        if want_is_dict:
+            # split each dict into a pair of lists of keys and values, and retry
+            want_keys, want_values = f"{list(a_want.keys())}", f"{list(a_want.values())}"
+            got_keys, got_values = f"{list(a_got.keys())}", f"{list(a_got.values())}"
+
+            keys_match = self.check_output(want_keys, got_keys, optionflags)
+            values_match = self.check_output(want_values, got_values, optionflags)
+            return keys_match and values_match
+
         # ... and defer to numpy
         strict = self.config.strict_check
         try:

{scipy_doctest-1.7.1 → scipy_doctest-2.0.0}/scipy_doctest/plugin.py

@@ -13,7 +13,7 @@ from _pytest.pathlib import import_path
 
 from .impl import DTParser, DebugDTRunner
 from .conftest import dt_config
-from .util import np_errstate, matplotlib_make_nongui, temp_cwd
+from .util import np_errstate, matplotlib_make_nongui, temp_cwd, is_req_satisfied
 from .frontend import find_doctests
 
 
@@ -29,6 +29,28 @@ def pytest_addoption(parser):
         dest="collection_strategy"
     )
 
+    # We cannot add `--doctest-only` option because of
+    # https://github.com/pytest-dev/pytest/discussions/13435
+    #
+    # Therefore, we add a new option, --doctest-only-doctests,
+    # which was `true` by default in versions 1.x.
+    #
+    # In v2.0, the default is `false`, so that
+    #
+    # $ pytest --doctest-modules
+    #
+    # runs both doctests and unit tests, and the way to use the previous behavior
+    # (only run doctests, skip unit tests) is
+    #
+    # $ pytest --doctest-modules --doctest-only-doctests=true
+    #
+    group.addoption("--doctest-only-doctests",
+        action="store",
+        default="false",
+        help="Whether to only collect doctests, or also collect unit tests, too.",
+        choices=("true", "false"),
+        dest="doctest_only_doctests"
+    )
 
 def pytest_configure(config):
     """
@@ -49,15 +71,27 @@ def pytest_ignore_collect(collection_path, config):
     This function is used to exclude the 'tests' directory and test modules when
     the `--doctest-modules` option is used.
     """
-    if config.getoption("--doctest-modules"):
+    # XXX: From v2.0, --doctest-modules means "run both doctests and unit tests",
+    # (consistent with vanilla pytest), and the way to retain the 1.x behavior
+    # is to add --doctest-only-doctests=true to the CLI command
+    if (
+        config.getoption("--doctest-modules") and
+        config.getoption("--doctest-only-doctests") == 'true'
+    ):
         path_str = str(collection_path)
         if "tests" in path_str or "test_" in path_str:
             return True
 
+    fnmatch_ex = _pytest.pathlib.fnmatch_ex
+
     for entry in config.dt_config.pytest_extra_ignore:
-        if entry in str(collection_path):
+        if fnmatch_ex(entry, collection_path):
             return True
 
+    for entry, reqs in config.dt_config.pytest_extra_requires.items():
+        if fnmatch_ex(entry, collection_path):
+            return not is_req_satisfied(reqs)
+
 
 def is_private(item):
     """Decide if an DocTestItem `item` is private.
@@ -82,21 +116,26 @@ def _maybe_add_markers(item, config):
     dt_config = config.dt_config
 
     extra_skip = dt_config.pytest_extra_skip
-    skip_it = item.name in extra_skip
-    if skip_it:
+    if skip_it := item.name in extra_skip:
         reason = extra_skip[item.name] or ''
         item.add_marker(
             pytest.mark.skip(reason=reason)
         )
 
     extra_xfail = dt_config.pytest_extra_xfail
-    fail_it = item.name in extra_xfail
-    if fail_it:
+    if fail_it := item.name in extra_xfail:
         reason = extra_xfail[item.name] or ''
         item.add_marker(
             pytest.mark.xfail(reason=reason)
         )
 
+    extra_requires = dt_config.pytest_extra_requires
+    if req_str := extra_requires.get(item.name, None):
+        if not is_req_satisfied(req_str):
+            item.add_marker(
+                pytest.mark.skip(reason=f"requires {req_str}")
+            )
+
 
 def pytest_collection_modifyitems(config, items):
     """

scipy_doctest-2.0.0/scipy_doctest/tests/failure_cases.py

@@ -0,0 +1,118 @@
+__all__ = ['func9', 'func10', 'iterable_length_1', 'iterable_length_2',
+           'tuple_and_list_1', 'tuple_and_list_2']
+
+
+def func9():
+    """
+    Wrong output.
+    >>> import numpy as np
+    >>> np.array([1, 2, 3])
+    array([2, 3, 4])
+    """
+
+
+def func10():
+    """
+    NameError
+    >>> import numpy as np
+    >>> np.arraY([1, 2, 3])
+    """
+
+
+def iterable_length_1():
+    """
+    >>> [1, 2, 3]
+    [1, 2, 3, 4]
+    """
+
+
+def iterable_length_2():
+    """
+    >>> [1, 2, 3]
+    [1, 2]
+    """
+
+
+def tuple_and_list_1():
+    """
+    >>> [0, 1, 2]
+    (0, 1, 2)
+    """
+
+
+def tuple_and_list_2():
+    """
+    >>> (0, 1, 2)
+    [0, 1, 2]
+    """
+
+
+def dtype_mismatch():
+    """
+    >>> import numpy as np
+    >>> 3.0
+    3
+    """
+
+
+def dict_not_dict():
+    """
+    >>> dict(a=1, b=2)
+    ['a', 'b']
+    """
+
+def dict_not_dict_2():
+    """
+    >>> [('a', 1), ('b', 2)]
+    {'a': 1, 'b': 2}
+    """
+
+
+def dict_wrong_keys():
+    """
+    >>> dict(a=1, b=2)
+    {'c': 1, 'd': 2}
+    """
+
+
+def dict_wrong_values():
+    """
+    >>> dict(a=1, b=2)
+    {'a': -1, 'b': -2}
+    """
+
+
+def dict_wrong_values_np():
+    """
+    >>> import numpy as np
+    >>> dict(a=1, b=np.arange(3)/3)
+    {'a': 1, 'b': array([0, 0.335, 0.69])}
+    """
+
+
+def dict_nested_wrong_values_np():
+    """
+    >>> import numpy as np
+    >>> dict(a=1, b=dict(blurb=np.arange(3)/3))
+    {'a': 1, 'b': {'blurb': array([0, 0.335, 0.69])}}
+    """
+
+
+# This is an XFAIL
+# Currently, checking nested dicts falls back to vanilla doctest
+# When this is fixed, move this case to module_cases.py
+def dict_nested_needs_numeric_comparison():
+    """
+    >>> import numpy as np
+    >>> dict(a=1, b=dict(blurb=np.arange(3)/3))
+    {'a': 1, 'b': {'blurb': array([0, 0.333, 0.667])}}
+    """
+
+
+# This is an XFAIL
+# Nested sequences which contain strings fall back to vanilla doctest
+def list_of_tuples():
+    """
+    >>> [('a', 1/3), ('b', 2/3)]
+    [('a', 0.333), ('b', 0.667)]
+    """

{scipy_doctest-1.7.1 → scipy_doctest-2.0.0}/scipy_doctest/tests/module_cases.py

@@ -1,8 +1,5 @@
-__all__ = [
-    'func', 'func2', 'func3', 'func4', 'func5', 'func6', 'func8',
-    'func7', 'manip_printoptions', 'array_abbreviation'
-]
-
+""" A collection of test cases.
+"""
 
 def func():
     """
@@ -242,3 +239,38 @@ def array_and_list_2():
     >>> [1, 2, 3]
     array([1, 2, 3])
     """
+
+
+def two_dicts():
+    """
+    >>> import numpy as np
+    >>> dict(a=0, b=1)
+    {'a': 0, 'b': 1}
+    >>> {'a': 1/3, 'b': 2/3}
+    {'a': 0.333, 'b': 0.667}
+    >>> {'a': 0., 'b': np.arange(3) / 3 }
+    {'a': 0.0, 'b': array([0, 0.333, 0.667])}
+    """
+
+def nested_dicts():
+    # Note that we need to give all digits: checking nested dictionaries
+    # currently fall back to vanilla doctest.
+    # cf failure_cases.py::dict_nested_needs_numeric_comparison
+    """
+    >>> import numpy as np
+    >>> {'a': 1.0, 'b': dict(blurb=np.arange(3)/3)}
+    {'a': 1.0, 'b': {'blurb': array([0, 0.33333333, 0.66666667])}}
+    """
+
+
+def list_of_tuples_numeric():
+    # cf failure_cases.py::list_of_tuples --- string entries preclude numeric comparisons
+    """
+    >>> [(1, 1/3), (2, 2/3)]
+    [(1, 0.333), (2, 0.667)]
+    """
+
+
+# This is used by test_testmod.py::test_public_object_discovery
+# While in test we only need __all__ to be not empty, let's make it correct, too.
+__all__ = [x for x in vars().keys() if not x.startswith("_")]

{scipy_doctest-1.7.1 → scipy_doctest-2.0.0}/scipy_doctest/tests/test_testmod.py

@@ -15,6 +15,7 @@ import pytest
 
 try:
     import scipy    # noqa
+    from scipy import stats   # https://github.com/scipy/scipy_doctest/issues/184
     HAVE_SCIPY = True
 except Exception:
     HAVE_SCIPY = False
@@ -117,6 +118,29 @@ def test_tuple_and_list():
     assert res.failed == 2
 
 
+def test_list_of_tuples():
+    config = DTConfig()
+    res, _ = _testmod(failure_cases,
+                      strategy=[failure_cases.list_of_tuples],
+                      config=config)
+    assert res.failed == 1
+
+
+def test_dict():
+    config = DTConfig()
+    res, _ = _testmod(failure_cases,
+                      strategy=[failure_cases.dict_not_dict,
+                                failure_cases.dict_not_dict_2,
+                                failure_cases.dict_wrong_keys,
+                                failure_cases.dict_wrong_values,
+                                failure_cases.dict_wrong_values_np,
+                                failure_cases.dict_nested_wrong_values_np,
+                                failure_cases.dict_nested_needs_numeric_comparison,
+                      ],
+                      config=config)
+    assert res.failed == 7
+
+
 @pytest.mark.parametrize('strict, num_fails', [(True, 1), (False, 0)])
 class TestStrictDType:
     def test_np_fix(self, strict, num_fails):

{scipy_doctest-1.7.1 → scipy_doctest-2.0.0}/scipy_doctest/util.py

@@ -10,6 +10,10 @@ import tempfile
 import inspect
 from contextlib import contextmanager
 
+from typing import Sequence
+
+from importlib.metadata import version as get_version, PackageNotFoundError
+from packaging.requirements import Requirement
 
 @contextmanager
 def matplotlib_make_nongui():
@@ -255,6 +259,20 @@ def get_public_objects(module, skiplist=None):
     return (items, names), failures
 
 
+def is_req_satisfied(req_strs: str | Sequence[str]) -> bool:
+    """ Check if all PEP 508-compliant requirement(s) are satisfied or not.
+    """
+    req_strs = [req_strs] if isinstance(req_strs, str) else req_strs
+    reqs = [Requirement(req_str) for req_str in req_strs]
+    if any(req.marker is not None for req in reqs):
+        msg = r"Markers not supported in `pytest_extra_requires`"
+        raise NotImplementedError(msg)
+    try:
+        return all(get_version(req.name) in req.specifier for req in reqs)
+    except PackageNotFoundError:
+        return False
+
+
 # XXX: not used ATM
 modules = []
 def generate_log(module, test):

scipy_doctest-1.7.1/scipy_doctest/tests/failure_cases.py

@@ -1,55 +0,0 @@
-__all__ = ['func9', 'func10', 'iterable_length_1', 'iterable_length_2',
-           'tuple_and_list_1', 'tuple_and_list_2']
-
-
-def func9():
-    """
-    Wrong output.
-    >>> import numpy as np
-    >>> np.array([1, 2, 3])
-    array([2, 3, 4])
-    """
-
-
-def func10():
-    """
-    NameError
-    >>> import numpy as np
-    >>> np.arraY([1, 2, 3])
-    """
-
-
-def iterable_length_1():
-    """
-    >>> [1, 2, 3]
-    [1, 2, 3, 4]
-    """
-
-
-def iterable_length_2():
-    """
-    >>> [1, 2, 3]
-    [1, 2]
-    """
-
-
-def tuple_and_list_1():
-    """
-    >>> [0, 1, 2]
-    (0, 1, 2)
-    """
-
-
-def tuple_and_list_2():
-    """
-    >>> (0, 1, 2)
-    [0, 1, 2]
-    """
-
-
-def dtype_mismatch():
-    """
-    >>> import numpy as np
-    >>> 3.0
-    3
-    """