Merge pull request #100 from Cadair/cleanup_upgrade

Remove support for mpl 1.5 and python<3.6

Author: astrofrog

pytest_mpl/classic.mplstyle

@@ -28,31 +28,21 @@
 #
 #   https://github.com/astrofrog/wcsaxes
 
-from functools import wraps
-
-import contextlib
 import io
 import os
-import sys
 import json
 import shutil
+import hashlib
 import inspect
 import tempfile
 import warnings
-import hashlib
-from distutils.version import LooseVersion
+import contextlib
 from pathlib import Path
+from functools import wraps
+from urllib.request import urlopen
 
 import pytest
 
-if sys.version_info[0] == 2:
-    from urllib import urlopen
-    string_types = basestring  # noqa
-else:
-    from urllib.request import urlopen
-    string_types = str
-
-
 SHAPE_MISMATCH_ERROR = """Error: Image dimensions did not match.
   Expected shape: {expected_shape}
     {expected_path}
@@ -74,11 +64,11 @@ def _download_file(baseline, filename):
     else:
         raise Exception("Could not download baseline image from any of the "
                         "available URLs")
-    result_dir = tempfile.mkdtemp()
-    filename = os.path.join(result_dir, 'downloaded')
-    with open(filename, 'wb') as tmpfile:
+    result_dir = Path(tempfile.mkdtemp())
+    filename = result_dir / 'downloaded'
+    with open(str(filename), 'wb') as tmpfile:
         tmpfile.write(content)
-    return filename
+    return Path(filename)
 
 
 def _hash_file(in_stream):
@@ -212,6 +202,10 @@ def get_marker(item, marker_name):
         return item.keywords.get(marker_name)
 
 
+def path_is_not_none(apath):
+    return Path(apath) if apath is not None else apath
+
+
 class ImageComparison(object):
 
     def __init__(self,
@@ -225,13 +219,13 @@ def __init__(self,
                  ):
         self.config = config
         self.baseline_dir = baseline_dir
-        self.baseline_relative_dir = baseline_relative_dir
-        self.generate_dir = generate_dir
-        self.results_dir = results_dir
-        self.hash_library = hash_library
-        self.generate_hash_library = generate_hash_library
-        if self.results_dir and not os.path.exists(self.results_dir):
-            os.mkdir(self.results_dir)
+        self.baseline_relative_dir = path_is_not_none(baseline_relative_dir)
+        self.generate_dir = path_is_not_none(generate_dir)
+        self.results_dir = path_is_not_none(results_dir)
+        self.hash_library = path_is_not_none(hash_library)
+        self.generate_hash_library = path_is_not_none(generate_hash_library)
+        if self.results_dir and not self.results_dir.exists():
+            self.results_dir.mkdir()
 
         # We need global state to store all the hashes generated over the run
         self._generated_hash_library = {}
@@ -261,7 +255,7 @@ def make_results_dir(self, item):
         """
         Generate the directory to put the results in.
         """
-        return tempfile.mkdtemp(dir=self.results_dir)
+        return Path(tempfile.mkdtemp(dir=self.results_dir))
 
     def get_baseline_directory(self, item):
         """
@@ -274,21 +268,19 @@ def get_baseline_directory(self, item):
         baseline_dir = compare.kwargs.get('baseline_dir', None)
         if baseline_dir is None:
             if self.baseline_dir is None:
-                baseline_dir = os.path.join(os.path.dirname(item.fspath.strpath), 'baseline')
+                baseline_dir = Path(item.fspath).parent / 'baseline'
             else:
                 if self.baseline_relative_dir:
                     # baseline dir is relative to the current test
-                    baseline_dir = os.path.join(
-                        os.path.dirname(item.fspath.strpath),
-                        self.baseline_relative_dir
-                    )
+                    baseline_dir = Path(item.fspath).parent / self.baseline_relative_dir
                 else:
                     # baseline dir is relative to where pytest was run
                     baseline_dir = self.baseline_dir
 
-        baseline_remote = baseline_dir.startswith(('http://', 'https://'))
+        baseline_remote = (isinstance(baseline_dir, str) and  # noqa
+                           baseline_dir.startswith(('http://', 'https://')))
         if not baseline_remote:
-            return os.path.join(os.path.dirname(item.fspath.strpath), baseline_dir)
+            return Path(item.fspath).parent / baseline_dir
 
         return baseline_dir
 
@@ -301,13 +293,14 @@ def obtain_baseline_image(self, item, target_dir):
         """
         filename = self.generate_filename(item)
         baseline_dir = self.get_baseline_directory(item)
-        baseline_remote = baseline_dir.startswith(('http://', 'https://'))
+        baseline_remote = (isinstance(baseline_dir, str) and  # noqa
+                           baseline_dir.startswith(('http://', 'https://')))
         if baseline_remote:
             # baseline_dir can be a list of URLs when remote, so we have to
             # pass base and filename to download
             baseline_image = _download_file(baseline_dir, filename)
         else:
-            baseline_image = os.path.abspath(os.path.join(baseline_dir, filename))
+            baseline_image = (baseline_dir / filename).absolute()
 
         return baseline_image
 
@@ -321,10 +314,11 @@ def generate_baseline_image(self, item, fig):
         if not os.path.exists(self.generate_dir):
             os.makedirs(self.generate_dir)
 
-        fig.savefig(os.path.abspath(os.path.join(self.generate_dir, self.generate_filename(item))),
+        fig.savefig(str((self.generate_dir / self.generate_filename(item)).absolute()),
                     **savefig_kwargs)
+
         close_mpl_figure(fig)
-        pytest.skip("Skipping test, since generating data")
+        pytest.skip("Skipping test, since generating image")
 
     def generate_hash_name(self, item):
         """
@@ -363,8 +357,8 @@ def compare_image_to_baseline(self, item, fig, result_dir):
 
         baseline_image_ref = self.obtain_baseline_image(item, result_dir)
 
-        test_image = os.path.abspath(os.path.join(result_dir, self.generate_filename(item)))
-        fig.savefig(test_image, **savefig_kwargs)
+        test_image = (result_dir / self.generate_filename(item)).absolute()
+        fig.savefig(str(test_image), **savefig_kwargs)
 
         if not os.path.exists(baseline_image_ref):
             pytest.fail("Image file not found for comparison test in: "
@@ -376,38 +370,32 @@ def compare_image_to_baseline(self, item, fig, result_dir):
 
         # distutils may put the baseline images in non-accessible places,
         # copy to our tmpdir to be sure to keep them in case of failure
-        baseline_image = os.path.abspath(
-            os.path.join(result_dir,
-                         'baseline-' + self.generate_filename(item))
-        )
+        baseline_image = (result_dir / f"baseline-{self.generate_filename(item)}").absolute()
         shutil.copyfile(baseline_image_ref, baseline_image)
 
         # Compare image size ourselves since the Matplotlib
         # exception is a bit cryptic in this case and doesn't show
         # the filenames
-        expected_shape = imread(baseline_image).shape[:2]
-        actual_shape = imread(test_image).shape[:2]
+        expected_shape = imread(str(baseline_image)).shape[:2]
+        actual_shape = imread(str(test_image)).shape[:2]
         if expected_shape != actual_shape:
             error = SHAPE_MISMATCH_ERROR.format(expected_path=baseline_image,
                                                 expected_shape=expected_shape,
                                                 actual_path=test_image,
                                                 actual_shape=actual_shape)
             pytest.fail(error, pytrace=False)
 
-        return compare_images(baseline_image, test_image, tol=tolerance)
+        return compare_images(str(baseline_image), str(test_image), tol=tolerance)
 
     def load_hash_library(self, library_path):
-        with open(library_path) as fp:
+        with open(str(library_path)) as fp:
             return json.load(fp)
 
     def compare_image_to_hash_library(self, item, fig, result_dir):
         compare = self.get_compare(item)
 
         hash_library_filename = self.hash_library or compare.kwargs.get('hash_library', None)
-        hash_library_filename = os.path.abspath(
-            os.path.join(os.path.dirname(item.fspath.strpath),
-                         hash_library_filename)
-        )
+        hash_library_filename = (Path(item.fspath).parent / hash_library_filename).absolute()
 
         if not Path(hash_library_filename).exists():
             pytest.fail(f"Can't find hash library at path {hash_library_filename}")
@@ -432,23 +420,17 @@ def pytest_runtest_setup(self, item):  # noqa
         if compare is None:
             return
 
-        import matplotlib
         import matplotlib.pyplot as plt
         try:
             from matplotlib.testing.decorators import remove_ticks_and_titles
         except ImportError:
             from matplotlib.testing.decorators import ImageComparisonTest as MplImageComparisonTest
             remove_ticks_and_titles = MplImageComparisonTest.remove_text
 
-        MPL_LT_15 = LooseVersion(matplotlib.__version__) < LooseVersion('1.5')
-
         style = compare.kwargs.get('style', 'classic')
         remove_text = compare.kwargs.get('remove_text', False)
         backend = compare.kwargs.get('backend', 'agg')
 
-        if MPL_LT_15 and style == 'classic':
-            style = os.path.join(os.path.dirname(__file__), 'classic.mplstyle')
-
         original = item.function
 
         @wraps(item.function)

pytest_mpl/plugin.py

@@ -42,4 +42,10 @@ testpaths = "tests"
 max-line-length = 100
 
 [pycodestyle]
-max_line_length = 100
+max_line_length = 100
+
+[isort]
+balanced_wrapping = True
+length_sort = False
+length_sort_sections = stdlib
+line_length = 100